Transformation Priority Premise TDD

Alterability. Item: Change Case 1: sow seeds anti-clockwise. Score /5: 5.

Reason: Sowing direction is handled only by mirroring the board in BoardView.lines, which is one if/else. Board and the game loop do not depend on direction at all.

Alterability. Item: Change Case 2: 7 houses with 5 seeds. Score /5: 3.

Reason: The house and seed counts go into the Board constructor in one place, and Board and cells scale with them. border and divider hardcode literal strings for 6 and 7 houses, so any other size would need new literals.

Code quality principles. Item: 1. Clear Presentation. Score /5: 4.

Reason: Formatting is tidy and the files are short and well ordered. The long BoardView.lines call in printBoard and the index arithmetic in sow are a little dense to read.

Code quality principles. Item: 2. Explanatory Language. Score /5: 4.

Reason: Doc comments explain intent, for example the mover's-lap pit indexing. Names like n, last and pit, and literals such as 2*n+1 and the 0/1 player ids, are only partly explained.

Code quality principles. Item: 3. Consistent Code. Score /5: 4.

Reason: Players are 0 and 1 throughout, and the static view helpers follow one style. Houses are numbered from 1 in the API but from 0 inside it, and some helpers are package-private for tests while their siblings are private.

Code quality principles. Item: 4. Used Content. Score /5: 5.

Reason: Every element is used. The starter placeholder was removed and nothing is dead.

Code quality principles. Item: 5. Simple Constructs. Score /5: 4.

Reason: The control flow is simple and the nesting is shallow. sow packs sowing, capture and the extra-move check into one method that uses modular arithmetic.

Code quality principles. Item: 6. Minimal Duplication. Score /5: 3.

Reason: border and divider each repeat near-identical literal strings for 6 and 7 houses where a loop could build them. play also repeats the Game over plus printBoard sequence on both exit paths.

Code quality principles. Item: 7. Modular Structure. Score /5: 5.

Reason: Board holds the rules, BoardView handles rendering and Kalah handles I/O and turns. Their dependencies are minimal and clean.

Code quality principles. Item: 8. Problem Alignment. Score /5: 4.

Reason: Board, sow, store, score and hasMoves match the domain language. Modelling direction as a pure rendering mirror is apt, but the code never states that this is why it works.

Test quality. Item: Test quality. Score /5: 4.

Reason: Many small, clearly named unit tests pin sowing, wrapping, skipping the opponent's store, captures, scoring and rendering, and spec tests cover each scenario end to end. The spec scenarios exercise only two of the four variants, anticlockwise 6-4 and clockwise 7-5.

2026-10-15T23:53:23Z. Step: s1. Unit: TPP ranked list. Tests added: 0. Cycles: 0. Sha: d5642a9. Agent: tpp:s1. Tokens: 118327. Seconds: 16.195.

Actions: Wrote Martin's 12 transformations with one-line definitions to TPP.md and committed it. No code or tests touched so no checks run.

2026-10-15T23:58:32Z. Step: L2-7 iter 1. Unit: Board rendering for all four variants. Tests added: 15. Cycles: 15. Sha: 8f21b36. Agent: tpp:L2-7#1. Tokens: 3250312. Seconds: 310.637.

Actions: Wrote UNITS.md with 8 units. Built BoardView (house, pad, border, divider, row, lines) and wired play() to print the starting board, one TPP transformation per commit. Lower-ranked moves accepted with no simpler test: if->while for row joining, if->while for building board cells and expression->function plus loop in play(). Border and divider stay as 6/7 if-branches because a loop would change behaviour for other sizes. No impasse. Hit the 15-cycle limit exactly. Full ./run.sh test: BoardViewTest 13 and KalahBoardTest 2 pass. The 6 example tests still error as expected until later units land.

2026-10-16T00:00:21Z. Step: L2-7 iter 2. Unit: Prompt and quit with the Game over board. Tests added: 2. Cycles: 1. Sha: e85537d. Agent: tpp:L2-7#2. Tokens: 1040657. Seconds: 107.514.

Actions: Replaced KalahBoardTest with KalahQuitTest since play() now prompts and the board-only specs no longer describe its behaviour. One red-green cycle on the anticlockwise 6-4 quit spec, passed with statement->statements (prompt read, Game over, board again). The clockwise 7-5 quit spec was then updated to the new behaviour. Refactored on green by extracting printBoard. No lower-ranked move and no impasse. Conflict logged: the Write and Edit tools strip the prompt's trailing space, so the 6-4 spec was copied from the identical examples quit.txt and the 7-5 spec was assembled with head and cat from the example's first six lines plus a scratch tail. Full ./run.sh test: BoardViewTest 13, KalahQuitTest 2 and ExampleAnticlockwiseTest.testQuit pass. The other 5 example tests still error as expected.

2026-10-16T00:11:44Z. Step: L2-7 iter 3. Unit: Sowing a move within the player's own houses in either direction. Tests added: 7. Cycles: 7. Sha: 5b10280. Agent: tpp:L2-7#3. Tokens: 1321298. Seconds: 680.431.

Actions: Added a Board model (houses per player, sow) and wired play() to alternate moves, one TPP transformation per commit. Lower-ranked moves accepted with no simpler test: expression->function for the house fill, scalar->array with variable->assignment to empty the chosen house, if->while to spread several seeds, and if->while with variable->assignment and an extracted prompt function to give P2 a move. Sowing runs toward higher house numbers in both directions so direction only affects BoardView. No refactor needed on green and no impasse. Conflict logged: the two new specs were written with printf in Bash because the Write tool strips the prompt's trailing space. Full ./run.sh test: BoardTest 5, KalahSowTest 2, BoardViewTest 13, KalahQuitTest 2 and ExampleAnticlockwiseTest.testQuit pass. The other 5 example tests still fail as expected until the store, wrap, capture and game end units land.

2026-10-16T00:14:30Z. Step: L2-7 iter 4. Unit: Last seed in own store gives another move. Tests added: 6. Cycles: 5. Sha: 0ef6b38. Agent: tpp:L2-7#4. Tokens: 1268106. Seconds: 169.752.

Actions: Added stores to Board and made sow report another move, then wired play() to show stores and keep the mover, one TPP transformation per commit: {}->nil for an empty store, unconditional->if with scalar->array to sow into the store, nil->constant then constant->scalar for the another-move result. Lower-ranked move accepted with no simpler test: unconditional->if with constant->scalar in play(), since a store seed cannot show without another move until wrapping lands. A clockwise 7-5 spec for P2's another move passed on arrival and was kept as a guard with no cycle counted. No refactor needed on green and no impasse. Conflict logged: the two new specs were written with printf in Bash because the Write tool strips the prompt's trailing space. Full ./run.sh test: BoardTest 9, KalahStoreTest 2, KalahSowTest 2, BoardViewTest 13, KalahQuitTest 2, ExampleAnticlockwiseTest.testQuit and one ExampleClockwiseTest pass. The other 4 example tests still fail as expected until the wrap, capture and game end units land.

2026-10-16T00:17:47Z. Step: L2-7 iter 5. Unit: Sowing wraps onto opponent houses and skips the opponent store. Tests added: 6. Cycles: 4. Sha: aa6582a. Agent: tpp:L2-7#5. Tokens: 1596744. Seconds: 193.322.

Actions: Extended Board.sow past the mover's store, one TPP transformation per commit: unconditional->if to wrap onto opponent houses and unconditional->if to skip the opponent store back onto own houses. Lower-ranked moves accepted with no simpler test: variable->assignment with expression->function for a modulo lap position so sowing can lap the board more than once, and expression->function reusing that position so a lap ending in the store gives another move. Refactored on green by extracting pit(). Two play() wrap specs for anticlockwise 6-4 and clockwise 7-5 passed on arrival once a store-placement error in the hand-written clockwise spec was corrected, and were kept as guards with no cycle counted. No impasse. Conflict logged: the two new specs were written by a printf script in .scratch because the Write tool strips the prompt's trailing space. Full ./run.sh test: BoardTest 13, BoardViewTest 13, KalahQuitTest 2, KalahSowTest 2, KalahStoreTest 2 and KalahWrapTest 2 pass. ExampleAnticlockwiseTest and ExampleClockwiseTest each still have 2 errors as expected until the capture, empty house and game end units land.

2026-10-16T00:20:21Z. Step: L2-7 iter 6. Unit: Capture when the last seed lands in an empty own house. Tests added: 7. Cycles: 3. Sha: 1c1eec4. Agent: tpp:L2-7#6. Tokens: 940241. Seconds: 149.972.

Actions: Added capture to Board.sow, one TPP transformation per commit: unconditional->if to add the landing seed and the opposite house to the store, then unconditional->if narrowing the condition so an empty opposite house gives no capture. The first test was split before going green so the store gain came alone and needed no assignment. Lower-ranked move accepted with no simpler test: statement->statements with variable->assignment to empty the landing and opposite houses. Refactored on green by extracting the opposite house index. Guards that passed on arrival with no cycle counted: no capture in an empty opponent house, a capture into the chosen house after a full lap, and two play() capture specs for anticlockwise 6-4 and clockwise 7-5. No impasse. Conflict logged: the two new specs were written by a printf script in .scratch because the Write tool strips the prompt's trailing space, and the UNITS.md tick used sed in place of Edit. Full ./run.sh test: BoardTest 18, BoardViewTest 13, KalahCaptureTest 2, KalahQuitTest 2, KalahSowTest 2, KalahStoreTest 2 and KalahWrapTest 2 pass. ExampleAnticlockwiseTest still has 1 error and ExampleClockwiseTest 2 errors as expected until the empty house and game end units land.

2026-10-16T00:21:39Z. Step: L2-7 iter 7. Unit: Choosing an empty house asks for another move. Tests added: 2. Cycles: 1. Sha: 62dd06d. Agent: tpp:L2-7#7. Tokens: 509320. Seconds: 71.18.

Actions: Added two play() specs for anticlockwise 6-4 and clockwise 7-5 where P1 picks its emptied house 1, seen red on line 22. One red-green cycle passed with unconditional->if in play() that prints House is empty. Move again. and the board, then prompts the same player. Refactored on green by printing the board once after either branch. No lower-ranked move and no impasse. Conflict logged: the two new specs were written by a printf script in .scratch because the Write tool strips the prompt's trailing space. Full ./run.sh test: BoardTest 18, BoardViewTest 13, KalahCaptureTest 2, KalahEmptyHouseTest 2, KalahQuitTest 2, KalahSowTest 2, KalahStoreTest 2 and KalahWrapTest 2 pass. ExampleClockwiseTest.testUseEmpty now passes. ExampleAnticlockwiseTest and ExampleClockwiseTest each still have 1 full game error as expected until the game end unit lands.

2026-10-16T00:24:44Z. Step: L2-7 iter 8. Unit: Game end with final scores and a winner or a tie. Tests added: 10. Cycles: 10. Sha: 245e63c. Agent: tpp:L2-7#8. Tokens: 1781453. Seconds: 187.804.

Actions: Added Board.score and Board.hasMoves and ended play() with Game over, the board, both scores and a result line when the player to move has no seeds, one TPP transformation per commit: {}->nil for a zero score, constant->scalar for the store and then a single house, nil->constant then constant->scalar for hasMoves, unconditional->if in play() driven red by ExampleAnticlockwiseTest.testFullGame2 with a constant Player 2 wins!, unconditional->if for A tie! driven red by ExampleClockwiseTest.testFullGameTie, and unconditional->if for Player 1 wins! in KalahResultTest. Lower-ranked moves accepted with no simpler test: expression->function summing every house for score and expression->function matching any seeded house for hasMoves. Refactored on green by extracting Kalah.result. Two KalahResultTest guards for the tie and the P2 win passed on arrival with no cycle counted. Quitting still prints no scores, as the quit examples show. No impasse. Full ./run.sh test: 11 classes pass with 0 failures, including all six example tests.