RIOT — DEV BLOG

Development log · City-building, tile by tile

16 entries published · Newest first
Latest — November 21, 2026

Arrested, Not Killed

Yesterday RIOT learned how a fight ends — both ways.

Combat has had an entrance since RIOT-106 dissolved the exploration chain on contact, turns since RIOT-107, and a real enemy since RIOT-108. What it never had was an exit. RIOT-109 was the ticket that closed the loop, and the interesting work turned out to be deciding what defeat means before writing any of it.

The first candidate was the familiar one: permadeath, the fallen hero as martyr. I passed on it, and the reason is roster arithmetic. Permadeath works when a game can generate a deep bench of replacements. RIOT’s roster is hand-built — every character is authored, painted, and measured through the pipeline — so there is no bench to draw from, and burning authored characters would punish the player for the game’s own scope. The direction I locked instead leans into the fiction: the party does not die. The party gets arrested.

That produced a lethality law that now governs the whole game. The party can kill. Party members are never killed — they are arrested. Death flows one way, outward from the party, and even on the enemy side the fiction splits by class: a disabled machine is just disabled, while human authority can actually die. Defeat, then, is a custody event. Your gear is confiscated — taken, not deleted — your companions are gone, and you wake up alone as your chosen main character. Heat rises. The full jailbreak, recovering the confiscated gear and escaping, is its own ticket now, RIOT-112, parked behind the demo road where it belongs.

The plan-before-code gate earned its keep again. Victory proved feasible on the existing follow motor: legality-checked, step-capped movement, a converge phase, then the original chain order restored — no new locomotion system needed. Defeat was the opposite. Verifying the gaps against the codebase showed custody retention already worked, but there was no campaign phase service, no scrap transaction service, no authored tenement wake point, and no heat increment path. Four missing systems is not a detail to improvise inside an exit ticket, so I split the scope: RIOT-109 lands victory plus the defeat event — the fade, the arrest, custody, the party lost — and the wake itself integrates later as RIOT-113, dependent on RIOT-11’s day cycle and RIOT-17’s base. Minimum stand-ins were explicitly rejected. A fake wake point would just be a debt with a costume on.

The Gate A receipt came back clean. Victory passed with a live audit of 842 movement writes and zero teleport-class writes — the party walked to the leader legally, every step — with the original four-member order restored and follow resumed. The arrest passed too: full fade, three original item instances retained in custody, three companions lost, the Organizer solo, and twelve of twelve authored root-motion steps matching the animation driver, with three frame-cap warnings on the post-arrest walk noted for the record. EditMode held at 103 of 103, including blocked convergence, wall routing, leadership transfer, and rally. I passed it, and PR #39 merged into dev at fcda8a4, on top of the 82ded07 tip the morning’s gap audit had verified unchanged.

One exception surfaced during that proof and it was worth chasing the same night. The legacy RIOT-91/92 follow runner stalled — the Officer walking into the Organizer’s occupied cell — identically on dev and on the feature branch, which made it pre-existing rather than a regression, and it became RIOT-114. The diagnosis was satisfying: the harness was the bug. LOCK A correctly refused the occupied cell, exactly as designed, and then MoveLeaderToward hung with no timeout at step 10. A harness-only fix unstuck it, and the runner then completed at 49 pass and 8 fail — those eight are not new breakage, they are checkpoints the stall had been hiding, now reachable and named for the first time. They are filed as RIOT-115 for triage, and EditMode stayed at 103 of 103 throughout.

The evening also re-locked who the enemy even is. A world law landed: enemies are authority, or robots controlled by authority — never neighborhood people. That retired the Thug identity for enemy one on the spot, and RIOT-110 re-locked around it as the Patroller: an authority machine walking a beat, melee, AdjacentSingle. The design carries the roster’s geometry discipline — human height in the 42 to 46 band, soles on row 80, difference carried in width and mass rather than height — with legs moving in the roster’s stride grammar. The read is almost-android: a smooth shell, a black visor faceplate instead of a painted face, a quicksilver finish worn by the sector, one mismatched replacement panel, and red eyes as the only saturated color anywhere on it. A threat signal you can read at sprite scale.

Production proved something in parallel. The two-Dotty lane test — one lane generating while the other paints — overlapped for real: the Organizer Downed family’s first GIMP stroke landed while a render was still running on the other lane, and later that night a three-seat overlap was measured at 121 milliseconds of simultaneous strokes across two machines during another render, no collision. The Downed delivery itself passed Gate A with flags: 248,168 bytes, hash exact, all 25 internal checksums verified, and the paint pixel-exact against the approved silhouettes — zero alpha differences across all eight facings, one connected component per facing, heads attached, ground bottoms running +6 to +13 past row 80 exactly as the approved prone masks dictate, and maximum saturation outside the drape at 0.2806 in every facing, so the saturated red lives only on the flag where the palette law allows it. The one honest gap is runtime placement, which the delivery itself flags as unknown until Unity seating closes it.

The seat model changed to match the evidence. Codex is out as a generation and art seat — its generations arrive as files in a chat, which makes me the transport layer, and that is exactly the job the factory exists to eliminate. Dotty is the artist again, generation and paint both, and a ratified tool-governance rule now travels with every dispatch she gets: authored versus generated decides the tool, precision pencil-class work is the finish standard at native sprite scale, hand mode is the standard for painterly large canvas, and every delivery’s work log names the hand that did the work.

The morning, for the record, was quiet — the gap audit found both dev tips unchanged and no RIOT movement before the evening session. Some days the factory idles. Yesterday it idled, then shipped an ending, a law, an enemy, and a second pair of hands.

■ End of Entry 16 Next: RIOT-110 — the Patroller — and RIOT-113, the wake

Proof, Not Promises

Yesterday started with an argument in my own records, and I am glad it did, because resolving it is most of what the day was actually about.

The night before, the enemy work had stopped at a preflight gate. The report was clear: the turn engine only knew how to recognize one hard-coded hostile, the director owned exactly one pending intent and ended the enemy phase after that single hostile acted, a pure advance incorrectly published an attack intent, and a script-level search across all six bound animation sets found no Thug set at all. Three decisions came back on that report. The engine generalization was authorized inside the ticket, but only as three named changes — real enemy registration so any registered combatant can trigger the combat hinge, per-hostile pending intents with ordered activations across all hostiles, and a pure advance publishing no intent — with anything beyond those three changes being a stop-and-report condition. The missing Thug art was authorized as an honestly labeled placeholder rather than a blocker. And the first-advance question got a deterministic answer: head for the member whose attacking cell has the lowest path cost, ties broken by lowest current HP and then declaration order, with the heading re-evaluated at each declaration and creating no selection lock by itself.

By morning, a second record claimed the work had already merged. Both records could not be the whole story, so yesterday morning was spent doing the only thing that settles that kind of disagreement: going to the repository, which is the home source for code state, and reading the receipts end to end.

The receipts held. The dev tip sits at 82ded07, the merge of the enemy-combatant work, with the combat-hinge merge and the combat-turns merge in its lineage in order. The deletion scan across all three merges came back at zero deletions total and zero deleted Assets — the guard that exists because a bad commit once taught this project, expensively, that a merge is not finished until you have proven nothing vanished inside it. The test ladder recorded in the session log on dev climbs cleanly with each step of the arc: 72 of 72 after the hinge, 84 of 84 after the turn engine, and 100 of 100 with zero skips after the enemy work, with the fixture census summing to exactly 100.

Then the proofs themselves. The enemy proof fields two Thugs through the same code path, differentiated by data alone: the base Thug at 20 HP, 6 damage, and 5 move, and a proof variant at 24 HP, 8 damage, and 3 move. That second definition matters more than it looks. The twelve-field configuration shape — identity, health, movement, fixed damage, attack pattern, range band, targeting profile, and the rest — is the template the next three enemy types will be built from, and a template is only proven when a second instance runs through it without new code. In the proof, the second enemy advanced in round one and published no intent, exactly as the ruling required. It selected the wounded Butcher through the second rung of the targeting ladder — the largest fraction of current HP lost — with the target at 14 HP out of three candidates. Later, one of its declared attacks was forfeited when the target moved out of reach, and it did not retarget: a declared attack that cannot land is spent, not redirected, because a forecast the player cannot trust is worse than no forecast at all. The base Thug was cancelled by a Flinch and then downed, the selection lock held across rounds, and the integrity counters stayed at zero across 2,486 occupancy samples — no teleports, no unattributed moves, no shared cells, no claim faults.

Just as important, the older proof was re-run against the generalized director rather than assumed compatible with it. The combat-turns proof passed again in full: seven rounds, four forecasts matching exactly under determinism, zero faults across 1,440 samples. Generalizing an engine is where regressions like to hide, so the regression gate was written into the authorization itself — the old behavior had to survive the new architecture, demonstrated, before the new work counted.

The placeholder discipline held everywhere, too. Every record names the stand-in art for what it is — a placeholder animation set borrowed from the Butcher, with the grip flagged as pending real art — and carries explicit art-debt lines. Debt that is written down is a plan; debt that is not is a surprise. So the morning’s gap audit converted the debt into tickets: a reduced animation set for the Thug, covering move, attack, hit, flinch, and downed, to be produced and seated in place of the placeholder, and the Garbage Lady’s missing combat families — attack, hit, flinch, downed, and rally — which the turn-engine proof had recorded as gaps back when her set was still only neutrals and a stride.

What remains is the exit. The combat arc now has an entrance, a turn structure, and enemies; the last unlanded piece is leaving combat cleanly and handing the party back to exploration, and it is unblocked and startable. One smaller question surfaced alongside it and is still open: the Officer has no dedicated grab state in the animation state set, so a decision is owed on whether grabbing gets its own state or rides an existing one. The board, for the record, now stands at 111 RIOT tickets with 72 open — the three merged pieces still show as open there, because board state follows verification, and verification finished yesterday. The code, the proofs, and the receipts are the part that is actually true.

■ End of Entry 15 Next: RIOT-109 — the exit, where the chain reforms — and the Officer’s grab state

The Chain Holds, Then Breaks on Purpose

Yesterday started where the night before had left off: two defects standing between me and a party-follow system I could call done. The door reform was still teleporting followers — the last snap in the system — and the unstick routine that was supposed to rescue hung-up followers had never actually worked. Detection fired, and then nothing happened.

The door fix was a ruling before it was code: no snapping, anywhere. A follower who crosses a door now walks out from the door cell to its slot, the same way it walks everywhere else. The leader crosses under ordinary free movement, player-controlled the whole way; the door system does bookkeeping and nothing more. Gate run 8 proved it in the evidence dump — across 4,096 movement receipts the only writers left were SlotPathStep, FreeMove, and SeparationStep. DoorReform and DoorLeader wrote zero times. Every member’s largest single step was 0.011, and there was not one over-budget write in the run.

Unstick turned out to be a different kind of bug. In the previous run it had triggered three times and failed three times, each failure landing about four milliseconds after its trigger — an instant rejection, not a failed walk. Once the actuation was fixed properly, the same run shape gave three triggers, three completions, zero failures, with real walk durations of 0.87, 0.65, and 0.24 seconds. Followers step apart to a statically walkable, unclaimed cell at least two cells away in Chebyshev distance, and only then repath, in chain order.

That left facings, which sounds cosmetic and is not — a follower sliding north while drawn facing south reads as broken even when the math is right. The diagnosis was structural: facing had been set in exactly two scattered places, each covering one movement sub-path, and nowhere else. The fix removed both sites and centralized facing at the write choke point. After any step write, a chained follower faces its actual achieved travel direction, quantized through the same facing function the leader uses — no second facing system — with a zero-length guard so a blocked step never turns anyone. Gate run 9 closed the list: facing agreed with the eight-way direction of the step that produced it on every single receipt, for all four members — the butcher 1010 of 1010, the officer 937 of 937, garbage lady 1175 of 1175, the organizer 974 of 974. Commit-blocked events were down to four. Nine gate runs, and the whole stack — transit, write authorization, repath stagger, slot uniqueness, door identity and approach, separation, unstick, chain recalibration, walk-out, facings — verified end to end.

Then came the commit, which stopped on its own scope gate, correctly. The working tree held 752 distinct paths: 29 tracked modifications and 723 untracked files, with only 21 matching the narrow allowlist the commit prompt carried — and, the number that mattered most, zero deleted Assets files. Reconciling the pile showed it was not scope creep; it was the whole coherent program — the coordinator stack, the spatial navigation service, the proof tooling, the evidence record, plus staging provenance from an earlier art swap-in. I made the call to merge all of it rather than leave 723 files floating uncommitted, which is the genuinely dangerous state. The merge landed as PR #34, roughly 80,000 lines, the bulk of it the evidence record rather than game code, and the dev tip moved to 55ba4a5. An architecture documentation pass followed on its own branch and merged as PR #35, rewriting the architecture and stub inventory documents against the code as it now exists on dev — code wins any disagreement with the older documents.

With exploration movement finally trustworthy, the day turned to the thing it exists for: combat. I filed the whole arc in dependency order — RIOT-106, the hinge where contact dissolves the chain into combat; RIOT-107, the turn engine; RIOT-108, the first enemy as a real combat actor; and RIOT-109, the exit where the party converges and the chain reforms.

RIOT-106 was mostly wiring — the state already carried a dissolve call that nothing in gameplay invoked — plus a stand-down audit and a proof. Mid-dig, the seat stopped on a real conflict: party solidity was enforced only after the fact, by the coordinator cleaning up writes that should never have happened. I approved enforcing solidity at the writers themselves, for party members only, through the existing occupancy map: claim the cell before writing, in exploration and while dissolved alike. The proof run dissolved at frame 4903, the hostile at (18, 3, 0) against the butcher at (17, 4, 0). After the dissolve, the tagged member stayed drivable with 93 writes and every follower wrote zero times across 614 receipts, with the history never wrapping. The hard test was a thirteen-frame drive straight into an occupied cell: zero writes, positions identical at the end. Teleports, over-cap writes, unattributed writes, faults — all zero. It merged as PR #36 with 72 EditMode tests passing and a clean deletion scan, dev tip 2f98234.

RIOT-107 got its research pass before its dig, the way the hard systems here now do. The engine follows the Into the Breach and Fire Emblem skeleton: side turns, one move and one action per member, free activation order inside the player phase. At contact, the enemy declares its intent — target and destination — and the player phase runs first; a flinch before the enemy phase cancels the declared attack, which is how this game gets reaction drama without a reaction system. One deliberate import from XCOM: the action can be spent as a dash, a second move, because these maps are street-scale rather than arena-scale. No randomness anywhere; the forecast the engine exposes before you commit an attack is exact, not a probability. The live proof passed seven completed rounds — declared intents executed six times, one cancelled by a flinch in round two, the butcher downed by an executed intent in round five, rallied back for six hit points with eligibility returning the following round, and the hostile downed in round eight with its pending intent cancelled. Four forecasts matched exactly, and across 1,422 occupancy samples every integrity counter stayed at zero. It merged late last night, dev tip fb5db1b.

RIOT-108 closed the day the same way, research first. The first enemy is the Thug, melee, and its brain is the Fire Emblem ladder: prefer a target the attack would down, then the target losing the largest fraction of its current health, then the nearest by path distance — and once it picks, the selection locks while that target stands. Its definition is twelve data fields — health, move allowance, fixed damage, attack pattern, range band, targeting profile, and the rest — so enemies two through four become configuration instead of code. The proof tuning is placeholder data, on the record as placeholder: 20 health, 6 damage, 5 movement. The dig then stopped before branching, honestly, on three findings: the new engine was still shaped around a single proof hostile, no Thug animation set is actually bound anywhere in the repo, and the ladder had no rule for a first advance when nobody is attackable yet. I authorized the engine generalization inside the ticket, a clearly labeled placeholder visual with the real Thug set recorded as art debt, and an advance rule — head for the member whose nearest attacking cell costs the least path, re-evaluated at each declaration, locking nothing. That is where yesterday ended: exploration proven, the hinge and the turn engine on dev, and the first real enemy cleared to be built.

■ End of Entry 14 Next: RIOT-108 — the Thug as a real combat actor — then RIOT-109, where the chain reforms

The Harness Was the Bug

Yesterday was one long dig on RIOT-91/92, the party-follow system, and it started with an instrument finally working. The evidence-capture tool built for this dig needed two fixes before it would compile and stay editor-only — a missing using directive and placement under an Editor folder — and once those landed, I ran the road test and dumped the diagnostics. The dump was 762 lines and about 282 KB, at simulation time 166.0, with the chain running organizer, butcher, officer, garbage lady. It also taught me the instrument's limit on the first read: the histories are capped buffers, 480 movement receipts and 240 follow events, so by dump time they only covered roughly the last eleven seconds. The window I most wanted, around the 50-second mark where an earlier build had shown a jump, had already rolled off. That defect stays unattributed, and I would rather leave it unattributed than invent an explanation for it.

What the retained tail did show was clean on one axis and loud on another. There were zero broken-integrity receipts, the largest single step was 0.125 — inside the normal cap — and the writers broke down as SlotPathStep 364, RootFrame 89, and SeparationStep 27. But 217 of the 240 follow events were one follower retrying an unreachable repath at roughly 15-millisecond intervals, ending in a PathBlocked hold. His totals for the run were 1,287 repicks and 1,826 repaths, against 271 and 464 for the officer. A storm like that is never a tuning problem; something structural was letting the retry escape its own cooldown.

The attribution work split into three findings. First, the blocked path was not a transit problem. The officer's own resting position — reserved and live cells at (6,3,0), with a diagonal-squeeze effect on the corner at the same cell — was being treated as a reason another follower could not pass through at all. Resting rules were governing transit. Second, the repath storm had an exact mechanism: the path-ensuring code only honored its next-repath time when a cached path existed, and an unreachable result clears the path, so the next frame repathed immediately. The locked staggered retry of 0.25 seconds simply did not apply on the empty-path branch. Third, and most uncomfortable, some position writes were validating after they wrote. The visual driver's root-frame path changed the transform position and only then checked whether the binding root matched, and the leader controller had the same shape on its free-move and flinch paths. Write-then-validate is exactly the shape that lets a follower get moved by the wrong authority, so the fix direction was pre-write authorization against the bound member, everywhere.

The ruling that came out of that is simple to state: planning ignores live cells and reservations, a commit still refuses an occupied live cell, and the two-cell separation rule binds where a member may come to rest — slot selection and goal selection — not whether another member may walk past. Transit is allowed to pass at ring one beside a resting member. That sounds like a relaxation, but it is really a classification fix. A resting rule doing a transit rule's job was manufacturing unreachable paths out of ordinary formation geometry.

Then the dig spent five rounds fighting its own harness, and this is the part I want on the record because it cost the most time and taught the most. The API-driven agent I use for these digs runs through Aider, and the session kept refusing to edit, insisting it had no edit tools and demanding complete file listings before it would touch anything. It looked like defiance. It was not. Aider has no edit tools in the first place — it applies changes by parsing search-and-replace blocks out of the model's reply. For a model identifier Aider does not recognize, its edit format defaults to none, which falls back to whole-file behavior, whose instructions demand complete-file reproduction. The model was obeying its harness configuration, not arguing with me. My own settings dump proved the session had launched with no edit format set at all. One more trap on the way out: in this Aider version, the chat-mode flag is an alias of the edit-format flag, and code is not a valid value for it. The corrected launch line sets the edit format to diff explicitly, and the standing rule now is to check the settings output and confirm the format reads diff before pasting any work. Relaunched that way, the three fixes applied on the first try.

From there the evening became a sequence of editor gate runs, each one killing the defect in front of it and exposing the one behind it. The first gate, at simulation time 53.3, showed the storm dead: unreachable repaths went from 217 to zero, and the butcher's totals fell to 117 repaths and 32 repicks. In their place, all three followers converged on the same slot cell, (19,7,0), with two of them looping on an illegal goal. A first attempt at a uniqueness guard in slot selection never even engaged in the next gate — the slots in that scenario were being assigned through the door-approach path, which bypassed the guarded code entirely. That second gate, at simulation time 88.9, also finally attributed the teleport I had been chasing: the door transit writer snapped the leader to the door entry anchor at (9.0, 6.5) five times, with deltas of 3.428, 2.605, 2.550, 2.625, and 2.625. The crossing never became consumed because the blocked followers never completed it, so every time the leader walked back to the threshold, the transit fired again.

Fixing that properly meant giving doors an identity. The transit call carried no door or crossing identifier at all, and the crossing record only minted its ID after acceptance, so it could never deduplicate itself. The volume that triggers a crossing now carries its own serialized door identifier, with a deterministic hierarchy-path fallback, the one-shot key is that identifier plus entry facing, and the key is released only when no chained member still holds that crossing unconsumed. The third gate showed zero leader snaps and zero illegal-goal loops — and 240 door-approach rejections on a single cell, (19,7,0), because the officer had crossed first and come to rest at (20,8,0), one Chebyshev step away, so resting separation rejected the approach cell for everyone behind him, permanently. The approach cell is a transit and queue point, not a resting slot, and it got its own predicate: sector-legal, statically walkable, and not claimed by another follower, with separation explicitly not governing it. The rejection event also learned to fire only when a hold begins or its reason changes, instead of every tick. Gate four: rejections fell from 240 to 3, with exactly one leader door write and one reform write, both the mechanism working as designed.

The remaining work that night was separation behaving badly in transit. The fix gave the chain a priority order — a member ahead never yields to one behind — made separation a steering influence while a follower is in transit and a hard legality only at rest, and stopped a claimed door approach from freezing the follower queued behind it. Gate five, at simulation time 117.1, was the best state the system has reached: the party ended in a clean ring-two rest formation at (10,9), (12,7), and (14,7), no holds, no pileups weaving through crowds, and a maximum follower step of 0.017. I also enlarged the evidence buffers — receipts from 480 to 4,096 and follow events from 240 to 2,048, with every dump header now required to state its own coverage — because a buffer that silently rolls is an instrument that lies by omission. Gate six immediately justified that: teleports did not reproduce, but a commit-blocked condition froze the butcher for fourteen seconds on a door-area slot while the leader walked roughly nineteen tiles away. A lock must never mean stay, so the next steer added hangup detection — three consecutive blocked commits force the pair to walk apart before any repath — and chain recalibration, where free followers behind a stuck member re-link around it once the leader is twelve cells past, a named configuration value rather than a magic number.

Gate seven caught the last teleport class in the act: a door-reform write moved the butcher 2.024 units in one step, from (5.07, 5.97) to (7.00, 6.50), straight into his formation spot. That is why the jumps always looked like one character hopping into a good position — the reform anchor is the formation spot. My ruling was that there will be no snapping at all; it reads as unnatural no matter how short it is. Followers will walk out of a door to their slots on ordinary capped steps, the same as every other movement in the game. The same gate showed the new unstick detection triggering three times and completing zero, each failure landing within about four milliseconds — detection working, actuation a no-op — so the finishing fix pairs the walk-out with a real multi-tick step-apart attempt that reports its failure reason. That fix is handed off with the full verified stack beneath it: transit, write authorization, stagger, slot uniqueness, door identity and approach, separation priority, and the enlarged evidence buffers, all proven in sequence across seven gate runs in one night. Nothing from the dig is committed yet. It stays uncommitted until the finishing fix passes its gate and I say so — the letter of the process holds even at the end of a long night, especially then.

■ End of Entry 13 Next: the finishing fix — door walk-out on capped steps with a real step-apart attempt — and its gate

The Trail Was the Problem

Yesterday was one long argument with a single system: party follow. It started before sunrise and ended with the design thrown out and rebuilt on a different principle — and the rebuilt version is the first one that has ever formed up correctly on a straight road.

The day opened with a smoke test of the proximity re-slot build. EditMode said 50/50. My hands said otherwise. Once all three followers got within two tiles of each other, they all stopped and stayed stopped — I walked twelve tiles away and one of them was still just standing there. Teleporting persisted. And I verified twice that walking far enough away after a lock forced a full line reset that snapped the character I was controlling to one side of the re-formed line. That produced the ruling the rest of the day obeyed: a lock exists only to prevent collision. It must never mean lock-and-stay. If members lock, they step apart automatically, the trail recalibrates, and following resumes in proximity order.

The morning also cleaned the board up. A gap audit verified more than twenty ticket closures against the repository, confirmed the Organizer redo swap-in had landed through PR #32, and verified the real slash-arc replacement was in dev. The board and the repo agree again, which matters more than it sounds — twice last week I was briefed from a board that was behind the code.

The separation plan came back clean and I approved it with one amendment. Its diagnosis was that the freeze is a single defect, not two: a refused follow step leaves the follower’s arc distance sitting on an unmoved body, the remaining distance grows as the leader walks, the arrival clear never fires, and nothing at any distance releases it. The fix design moves every locked follower on the same tick — a joint assignment over each body’s current cell plus its eight neighbors, destinations walked to at party speed, which bounds a 2×2 clump’s escape at about 1.067 seconds. Recalibration fires once when an episode ends, writes no transforms, and explicitly refuses the synthetic backfill line — a straight line laid opposite the facing, which is plausibly the line geometry I kept seeing in the resets. My amendment made one check mandatory instead of conditional: separation eligibility was gated on arc debt — a remainder over 0.25 — rather than on the spatial pack itself, so a body flinched into a packed position with a satisfied arc could be held forever. If that state is reachable in production, the fix belongs in the motor, not the test harness.

Then the video work started paying for itself. A 28.8-second party-walk clip, re-analyzed at full frame rate after a sparse pass missed everything, confirmed three defects: a spring-back at about 15.5 seconds where a parked character shifted a third of a cell and flipped facing in a single frame — roughly ten times the largest legal motor step; a follower jittering through facings for 1.4 seconds with zero net travel; and stride animation cycling on a body that never moved. The stationary-write dig named the writer from the latch log instead of guessing: the follow path was capping its step at party speed times delta-time rather than advance speed times delta-time, so on a hitch frame of 0.333 seconds one capped step came out to about 0.31 world units — the pop in the video, to the decimal. The fix is one line of principle: when advance speed is effectively zero, the follow path writes nothing. Re-verification passed across the board — zero stationary writes in the settle scenario, the freeze case moving 0.266 against a 0.02 gate, the cluster episode clearing in 0.300 seconds against the 1.167-second bound. That thread, open since morning, closed.

Underneath all of it sat a quieter root cause. The leader’s recorded speed flickers to zero on frames where no new breadcrumb is appended — crumbs land about one frame in seven at a 0.1 spacing — so followers spent their lives inside arrival easing, settling about 0.35 units behind their slots and staying permanently eligible for separation locks. Fixing the signal at the source, with elapsed-time accumulation in the trail, killed the inch-stop behavior the audits kept circling.

I also shipped the instrument the problem had been missing: a crumb debug view that colors the trail by chain band, marks each follower’s target, and draws the line from body to target. Its first job was witnessing — it caught the proximity re-slot firing live in ordinary play, labels swapping as I looped back past my own trail. Its second job was indictment. A fresh-seat audit against the two published follow patterns — position-history replay, and Reynolds steering with arrival and separation — returned the verdict that the build was neither: a speed-capped chase toward a delayed sample, integrating its own arc, so any debt from a lock or a discarded step could only be repaid when the leader fully stopped. The proof was in its own numbers, a remaining distance of 13.01 left sitting after a sharp turn. The audit’s prescription, bind the follower to the sample, was built and passed 53 of 53 — and I rejected it on sight anyway, from the debug footage. At one point the Garbage Lady’s body stood about two tiles from me while her sample sat some fifteen arc-units away at the bottom of a loop I had walked. Binding her to that sample would march her down and back to a point the party had already left. Arc distance had divorced from spatial distance, and no amount of tuning repairs a divorce.

So the contract changed. Followers no longer replay my route. Each follower’s slot is defined spatially — a legal cell on the two-tile Chebyshev ring around the body ahead — and travel to it is by the shortest legal path on the sector grid. The plan that came back centers on one shared weighted A* service, eight-neighbor travel with corner-squeeze forbidden, slot cells reserved per member, exactly two modes — slot follow and separation — typed door edges inside the path instead of a separate reform writer, and the single overwritten writer latch replaced by an append-only write ledger, so an unattributed write becomes a named fault instead of a shrug. It also caught a free bug: downed-member leadership was restarting at index zero instead of passing to the next in chain. I locked the two open questions myself — eight-neighbor Chebyshev travel, and event-based slot re-picking with a staggered 0.25-second blocked retry, so turning in place can never orbit the chain.

The spatial build is the best formation yet on straight runs. It is not done. A playtest caught a discontinuous write of about two tiles at roughly 51 seconds, landing where the front follower’s slot marker sat, and the second and third followers reporting path-blocked on an open road — the suspicion is the one-tile transit ring being rejected by the two-tile resting rule. The dig is briefed, spacing stays at two tiles while it runs, and a one-tile trial comes afterward as a config-only experiment to price, not a decision smuggled in. The front is pinned exactly there, with an editor evidence-capture tool gated and ready, because the writer ledger lives only in memory and yesterday’s receipts no longer exist.

Two process rules came out of the wreckage and are now standing law. Any system in a known-hard class gets a research pass against the published patterns before its first dig, and any defect family that survives two patches stops for research and a fresh-seat audit before a third. And the debug visualization ships with the first implementation of a behavioral system, not after the defect rounds — the crumb view caught in one clip what weeks of logs had not. The trail was the problem. The map is the answer, and tomorrow the dig names the writer.

■ End of Entry 12 Next: the dig names the writer behind the two-tile write, then the one-tile spacing trial

Five Bodies, One Chain

Yesterday completed three characters, seated all five bodies in the game, and then immediately found out that having five characters is not the same problem as moving five characters. The morning started with bookkeeping that mattered: the daily gap audit filed RIOT-88, the banking and swap-in ticket for the Organizer redo, so the families finishing that day had somewhere verified to land. By mid-afternoon the board stood at 96 tickets, and the character queue was the deepest it has ever been.

The Officer finished first. His Throw family is a person-throw, not an object throw — the release out of a grab — so the full eight-facing set had to land exactly on the contacts the South/North proof had locked the day before: South hold at left (44, 63) and right (20, 63), North at left (20, 45) and right (44, 45). The delivery was 24 sprites, and verification was strict about it: the six proof masks byte-identical to the approved proof, all eight recovery frames pixel-identical to the banked neutrals, 24 of 24 alphas matching their masks, all 32 hand contacts sitting on occupied boundary pixels, and a 15-color palette with 11 colors shared with his Hit set. Approved. Grab, his last family, was built to close the circuit Throw opened, and it did so literally: in the full Grab set the settle masks and painted frames are byte-identical to the Throw holds in all eight facings, the recoveries are byte-identical too, all 48 contact guides sit on boundary hand pixels, and the palette is exactly Throw’s 15 colors with zero new ones. Grab chains into Throw with no seam because, at the pixel level, they are the same hold. With neutrals, stride, club, Hit, Downed, Throw, and Grab closed, the Officer is a complete character.

The Organizer redo closed three more families the same day. Carry paint version 2 was approved after version 1 taught a precise lesson: its alphas were byte-identical to the approved masks, so the bleed I could see was inside the arm shapes — the masks themselves were jagged, and faithful paint had faithfully copied them. Version 2 repaired the masks first, then repainted, and passed. Hit paint passed with its lower rows exactly matching the neutrals, soles on row 80 with nothing below, and peak saturation at 0.292 against the 0.35 cap. His Downed silhouettes were approved and their paint released. The redo now stands with neutrals, stride, blade attack, crouch, carry, and hit complete.

Then the roster grew. Two new playable starters — the Garbage Lady and the Construction Worker — went from first silhouette to complete starter set in one day. Her silhouettes measured slim against the medium envelope, widths 7 to 15 pixels under and total mass at 51 to 67 percent, but crowns and heights matched exactly and every sole sat on row 80, so the build was approved as delivered and the read was left to paint: red ponytail carried as a color mass in every facing, freckles, a detailed painted south face as the master, and the hi-vis vest blocked in with green accents and a small recycle mark on the back. Paint and stride both passed — stride uppers pixel-identical to the approved paint through row 72, phases timed at 140 milliseconds — and her starter set closed. His silhouettes came in heavier than hers everywhere but still under the muscular brief, at 76 to 90 percent of the Organizer’s mass with shoulders 2 to 5 pixels narrower; that build was also approved as delivered. His paint held a 36-color palette with no additions in stride, suspender columns at x28 and x36, the belt band across rows 64 to 68, and stride frames pixel-identical through row 72 in all 16 frames with one foot planted on row 80 in every frame. Second starter set closed.

Seating turned finished art into playable bodies. The Drive manifest carried 17 approved families; 15 were seated directly from verified packages and the Officer’s neutrals and stride came from their banked in-repo bytes with cross-verification. The order ran Officer, Garbage Lady, Construction Worker, then the Organizer swap-in. The Garbage Lady’s seating proof is representative: 24 sprites seated, compile clean, EditMode 22 of 22, byte evidence 24 of 24, and a clean deletion scan. By evening all five bodies — Organizer, Butcher, Officer, Garbage Lady, Construction Worker — were wired and walkable in game, and the Organizer redo swap had merged as PR #32 with dev at 5618db3.

With five bodies live, the party system stopped being a design conversation. Ten locks settled it: a party cap of four; joining needs both story availability and the player chaining the character; a downed leader passes leadership down the chain and a downed follower is re-linked past until rallied; the chain is exploration-only and dissolves into free XCOM-style combat on contact, then the party converges on the leader before chaining resumes; chained members go through doors with the leader while unchained members stay separate; switching control is the tag; a stuck follower may cut a corner but never teleports; and members are solid bodies, never ghosts. The first build recorded the leader’s path as breadcrumbs sampled every 0.2 units, with follower slots at 0.8, 1.6, and 2.4 units behind the tip and a 1.75-times catch-up speed — and its scripted proof passed everything. My hands-on test failed it anyway. Followers slid instead of walking, because the coordinator forced Idle on non-move frames and every state change restarted the walk clip at frame zero, so the stride never cycled. Follow targets sat far enough back that followers started late, the corner-cut escape fired during ordinary following and popped people forward into bunches, and the leader kept springing back toward the group on a straight walk. A fix round passed 42 of 42 checks and fixed the continuity, but traded the lag for tailgating at roughly 0.2-unit gaps and a sharp-turn pile-up that never recovered. Two harder locks came out of that: members never share a cell, and system-driven movement keeps members at least two cells apart. The follow architecture is being redesigned as path replay rather than slot-chasing, which is the honest fix — the diagnosis says the geometry of the first approach was the problem, not its tuning.

The evening closed with measurement catching what my eyes had only suspected in scene. I ratified a Character Scale and Proportion Standard built only from the two reads I trust, the Organizer and the Butcher: soles exactly on row 80, figure height 42 to 46 with standard builds targeting 42, head-width to figure-height between 0.27 and 0.34, and head-width to shoulder-width between 0.36 and 0.55. Against that band the Officer’s head measured 0.543 — about 60 percent over — and his same-day face fix brought the south master from a 25-pixel head to 15, ratios 0.326 and 0.484, inside the band, with no pixels changed outside the head and neck. The Garbage Lady is 16 pixels wide at 42 tall, a narrowness problem rather than a height one, and she now carries a named exception at a 10-to-11-pixel head instead of a widened body; her fix passed verification with eye spacing tightened from 5 pixels to 3. The Construction Worker sits borderline at 0.262, his defect inside the face rather than in the outline. I also recorded the process failure plainly: the two starter sets skipped the generated-silhouette stage across all eight facings, and the face defects are what that shortcut costs. Their bodies stand; the fixes are facial reconstruction and a finish pass, swapped in under identical file names so the wired game never breaks. A board sweep the same evening closed 23 tickets whose work had already landed, and the new architecture documentation seat delivered its first survey of the game as it actually exists, stubs inventoried. Five bodies, one chain, and a ruler the next defect has to argue with — that was yesterday.

■ End of Entry 11 Next: the party follow redesign verdict, Gate B on the three face fixes, and the Organizer’s remaining redo families

Four Families in a Day

Yesterday was a throughput day, and it started before I was awake. Overnight, the merge wave that had been stacking up on branches finally landed in dev in one train: the RIOT-76 merge-up came in as PR #29, carrying the leave-hand seam commit with it, the Butcher’s ten-family wiring merged, and the RIOT-66 vegetation and ground banks, the RIOT-58 ground work, the officer’s club bank, and the RIOT-81 ambulance bank all came in behind it. Dev settled at 1671c47. That is the good version of a merge train — everything verified on its branch first, then landed in sequence — and it exposed an embarrassment in the other direction: the board had recorded zero Done transitions in 48 hours against all of that landed work. The repo was telling the truth and the board was behind it. The morning gap audit wrote that down plainly, closed the obvious paperwork gaps, and filed RIOT-87 so the Organizer redo, which had been running on momentum and thread posts since the day before, finally has a ticket of record with its family order and identity locks written on it. RIOT-83 got narrowed to its M1 repairs at the same time, since its M2 half had already been retired and merged, and the officer’s ticket now carries the note that he inherits the Flinch state at his hit turn, the same as everyone else on the roster.

Then the character work started, and it did not really stop. The morning opened by clearing the visual verdict lane completely: the Organizer’s blade-attack paint was approved, his crouch silhouettes were approved, and the officer’s Hit paint was approved. Three families closed or released in a few minutes, which is what the lane is supposed to look like when the prep work is done properly — my job in that moment is a verdict, not a work session.

Crouch was the first full cycle of the day. The treatment had been settled the night before: the banked lowered still is the fixed crouched upper across every facing, the stride lives entirely in the legs underneath it, and one planted foot stays on row 80 in every frame, because the moment the contact row drifts the whole crouch reads as floating. The paint delivery was 24 PNGs with 24 two-layer paint files and eight animation timelines, and it passed verification clean — crowns exactly three rows below the neutral crowns on every facing, the upper body byte-identical from rows 0 through 74 across the still and both walk variants, soles on row 80 and nothing below it. Approved. That made four completed families in the redo: neutrals, stride, blade attack, crouch.

The officer’s Downed family produced the day’s only real blocker, and it was a good one. There was no officer-specific prone envelope to build from. The Butcher’s downed work sits on the husky envelope and the Organizer’s sits on the medium envelope, and neither is automatically the officer’s — except the officer is the medium archetype, same as the Organizer. So the ruling was narrow: the banked medium envelope is released as the structural reference, binding the prone orientation, the extent, and the centroid-pivot method, while the officer’s own mass, shoulders, and cap still come from his banked neutrals. The husky envelope stays excluded. With that settled, the family moved fast: eight binary 64×128 silhouette masks passed verification, were approved, and the paint — eight sprites with their eight paint files — passed and was approved the same day. Hit in the morning, Downed by midday. Throw is next for him, then Grab, and Grab deliberately goes last.

Carry ran in parallel on the Organizer side. The walk treatment mirrors crouch: the upper body, the grips, and the crate stay fixed, the stride is built in the legs, and the only things moving above the crown are the arms and hands holding the load — which is correct, because a carried crate does not bounce independently of the person carrying it. The silhouette package was 24 still and walk masks plus eight crate sheets, verified and approved, and the paint followed with 24 sprites, crates kept byte-identical on their own separate layer, never baked into the character. That set passed its verification and sits at my verdict gate now; it is the one family from yesterday I still owe a decision on.

The officer’s Throw work closed the day with the strangest and, I think, most interesting construction problem of the set. His throw is not throwing an object. It is the release from a grab — throwing a person. That means the proof cannot be a normal eight-facing family yet, because the thing being thrown does not exist as art. So the proof is South and North only, six masks running hold to release to an exact recovery back on the neutral, with the victim’s contact points labeled instead of drawn: South contacts at left (44, 63) and right (20, 63), North at left (20, 45) and right (44, 45), with the release direction marked. No victim art, no baked travel. Those labeled contacts are now the spec the Grab family gets built to match when its turn comes, which is exactly why Grab goes last — it has to close a circuit that Throw opened. The proof passed verification and is queued for verdict behind the Carry paint.

By the end of the day the redo stood at four families complete with a fifth painted and waiting, and the officer stood at stride, club, Hit, and Downed complete with his Throw proof waiting. Two characters advancing in parallel on the same pipeline, with one blocker all day and that blocker turning into a reusable ruling about archetype envelopes. That is the system working the way it was designed to work.

■ End of Entry 10 Next: my verdict on the Carry paint and the officer’s Throw proof, then Grab — built to close the circuit Throw opened

The Day the Pipeline Proved Itself

Yesterday started at midnight with a test I expected to be a curiosity and ended with a complete playable character. The test was simple: could a character be authored from written locks alone, with no geometry sheet underneath it? The south-facing Butcher came back in about two and a half minutes — 64 by 128 canvas, 39 texels wide by 46 tall, feet planted on row 80 in two clusters, a single connected figure, max saturation 0.3214 against the 0.35 cap. Broader and heavier than the officer at the same 46-texel height, exactly as specced. Then I looked at it properly and saw the miss: it was a frontal portrait, not an overhead sprite. My spec had never stated the camera. The roster lives under an overhead view — tops of hats, shoulders seen from above — and I had assumed that knowledge instead of writing it down. That is now a standing rule: every spec carries the world's constants, camera included, every time.

The revision fixed the angle the right way. The toque was redrawn as a low cap with its top plane visible, the head seated lower into the shoulders, opaque mass rising from 1,270 to 1,364 texels with the feet unchanged. Approved in scene, at native scale next to roster characters — that superimpose is the real proof now, not an isolated sheet. The seven remaining neutral facings followed in 4 minutes 17 seconds: height exactly 46 and soles on row 80 on every facing, widths stepping correctly around the turn, the blood stain living only on the front three facings, the apron strap cross and waist tie on the backs, the knife roll tracking the same hip anatomically.

And then the set still was not right, which is where the day actually got interesting. I had a husky geometry lock built to the numbers — Gate A clean, 139 of 139 hashes matching, soles and clusters exact — and it read as a bell slab. It sat on every measurement and was not a husky man. Numbers alone get gap-filled into a generic form. The fix became the pipeline, ratified that night: skeleton, then silhouette, then paint. The skeleton locks stance, proportions, ground line and camera, and nothing more. A generated silhouette fills it in rather than adhering to it — arms separating, gut rounding past the slab edge — gated as pure black shapes, because if the black shape is not the man, nothing downstream is worth spending. Dotty paints over the approved silhouette, and only then is exact adherence correct. The silhouette test proved it: normalized fronts at 36 wide, diagonals 31 to 32, profiles 24, profile leg gaps preserved as two distinct boot clusters, and my own mask comparison agreeing at 0.979 IoU on fronts and profiles. The verdict on the painted result was the best we have produced by a wide margin.

The Butcher's south facing at each stage of the three-stage pipeline: the flat block-geometry skeleton, the solid black silhouette, and the finished hand-painted sprite in white cap and bloodied apron
Fig. 01One facing, three stages. Left: the skeleton — rough geometry only: height, width, ground line, camera — the lock that read as a bell slab when it was treated as the finished shape. Middle: the generated silhouette, a black shape that fills the skeleton in and authors the real human read. Right: the hand-painted finish over the approved silhouette.
The Butcher's Stage 1 skeleton sheet: block-geometry figures in all eight facings, two rows of four — broad torso blocks, heads seated on top, feet in two clusters
Fig. 02 — Stage 1 · SkeletonThe skeleton in all eight facings. It binds anchor, footprint, proportions, and the eight facings agreeing as one figure — 46 texels tall, soles on row 80 — and nothing more. Detail at this stage is advisory; the shape gets authored in the next one.
The Butcher's Stage 2 silhouette sheet: the same eight facings as solid black shapes — arms separated from the torso, the gut rounding the profile facings, two distinct boot clusters at the profiles
Fig. 03 — Stage 2 · SilhouetteThe same eight facings as pure black shapes, gated before any paint is spent: fronts 36 texels wide, diagonals 31–32, profiles 24, profile leg gaps preserved as two distinct boot clusters — and my mask comparison against the skeleton agreeing at 0.979 IoU on fronts and profiles.
The Butcher finished: hand-painted sprites in all eight facings — white cap, green-grey clothes, bloodied apron on the front facings, apron strap cross and waist tie on the backs, knife roll at the same hip
Fig. 04 — Stage 3 · PaintThe finished neutral set, painted over the approved silhouettes. Height exactly 46 and soles on row 80 on every facing; the blood stain lives only on the front three facings, the apron strap cross and waist tie sit on the backs, and the knife roll tracks the same hip around the turn.
Mermaid source for this chart
flowchart TD
    A["Step 0 — Spec<br/>written locks: overhead camera, 64×128 canvas,<br/>46-texel height, soles row 80, socket map;<br/>every state states its read in words"] --> B["Stage 1 — Skeleton (Codex)<br/>stance, proportions, ground line, camera;<br/>light envelope skeleton for crouch / downed / carry"]
    B --> C["Gate A — measure<br/>soles, boot clusters, hashes (139/139)"]
    C --> D["Stage 2 — Silhouette (generated)<br/>black shape fills the skeleton in;<br/>fronts 36, diagonals 31–32, profiles 24"]
    D --> E{"Gate A — does the black shape<br/>read as the man? (IoU 0.979)"}
    E -- "fail: regenerate the silhouette" --> D
    E -- pass --> F["Stage 3 — Paint (Dotty)<br/>hand-paint over the approved silhouette;<br/>faces painted, south face is the master"]
    F --> G["Gate B — owner verdict, taste only"]
    G --> H["State families<br/>movement, hit + flinch, downed, attack per grip class,<br/>crouch, carry, throw, rally — over the approved neutral"]
    H --> I["Layers + sockets<br/>items as separate 8-facing sheets, never baked in;<br/>engine owns swoosh, glint, knockback"]
    I --> J["Wiring — Gate A pass<br/>per-facing socket data applied; in game"]

With the process locked, the rest of yesterday was throughput. A face pass touched only rows 42 to 49, 35 to 57 pixels per facing, backs byte-identical, because paint prompts now carry real facial detail and linger on the face. Then family after family ran the same chain. Stride caught a west-facing leg pinch — 1 to 2 pixels against a 6-pixel floor — and was rebuilt in rows 69 to 76 only. Blade attack held the 46-pixel band by moving the northeast grip one row, from (46,34) to (46,35), in this character's socket map alone. Crouch dropped the crown to row 38 for a 43-pixel figure across 24 frames. Carry cleaned 70 isolated tip pixels down to 8 and 13 single-pixel holes down to zero, grips at rows 28 to 31, the 28 by 20 crate always a separate layer. Downed abandoned the standing anchor entirely for a per-facing centre-of-mass pivot, documented to six decimal places, cardinals exact, diagonals using their measured centroid. Throw ran 240, 90, 100, 300 milliseconds across its beats with frame one exactly the carry and frame four exactly the neutral. Rally stayed north-only, twelve beats, the steel stowed before the knife appears, the glint flagged at beat eight for the engine and never baked into a pixel.

The Butcher face pass: before and after close-ups of the south face — brows, eyes, and moustache sharpened by the pass — beside the full figure at game scale
Fig. 05The face pass. Rows 42–49 only, 35–57 pixels changed per facing, backs byte-identical. Paint prompts now carry real facial information and linger on the face — at this scale, the face is the character.

Reviewing the hit set taught the last lesson. Its raised guard arm reads as delivering a blow, not receiving one — the second time that read has slipped past on a character. So the roster gained a standard: Hit stays as delivered, and a separate Flinch state, forearm guarding, body recoiling, is now owed by every character, with knockback handled programmatically in the engine alongside it. Every state spec now states its read in words, receiving versus delivering, and Gate A checks that read, not just the measurements.

By early evening the Butcher was complete — ten families, neutrals through rally, plus knife and steel item sheets, all approved, built in one day on the new pipeline. He was not alone. The tile lanes passed concrete proofing with 18 of 18 brick hashes verified and zero overlap across 24 records, and roofing with zero changed protected pixels out of 473,268 and seam contrast improved from 1.22 to 0.75. Twelve gutter accent overlays were retired and merged, the ambulance joined the cruiser as the second approved vehicle of seventeen, the officer's club family closed, and the Organizer — built by the old technique — was ordered redone through the three-stage pipeline, his new neutrals and stride already approved by nightfall. The Butcher's wiring passed Gate A on its branch as well, with one honest finding: a cleaver rendering at local origin instead of the hand, fixed by applying the per-facing socket data the driver already owned. One character in a day is a good headline. A process that makes the next one routine is the actual result.

The RIOT-81 ambulance in its two facings: a white boxy ambulance with green cross and stripe, hand-painted finish over the redone geometry
Fig. 06The ambulance — the second vehicle approved of the seventeen in the fleet redo, after the cruiser. Same doctrine as the characters: geometry first, hand-painted finish over it, both gates before it counts.
■ End of Entry 09 Next: the Organizer redo through the three-stage pipeline, and the fleet redo continues

Character One, Complete

Yesterday started by correcting my own queue. The overnight landing train had already finished work I still had listed as pending: the corrected south crouch and the complete crouch family were in dev, and the RIOT-67 cleanup had landed with the deletion of the old PIL experiment sprites. That mattered because crouch was the last movement family standing between me and a clean run at the remaining state families. The queue I trusted at midnight was stale by morning, and the fix was simple and humbling: check dev first, then talk about what is next.

The hit family went first, and it went fast because the construction rules were already locked. The proof was south and north only. The torso recoils two texels away from the facing — never toward the blow, which would read as leaning into it — the head ducks one texel toward the chest with the neck still connected and the painted south face surviving the duck, the near arm comes up in guard, and the drape hem swings one texel along the facing. The legs do not move at all: rows 71 through 127 were byte-identical to the neutral in both facings. The strike-flash loop ran at 120 and 70 milliseconds. That proof passed both gates, the remaining six facings followed as a production set, and on the diagonals the only differences from the guide landmarks were exactly five pixels per facing, each one traceable to a clarification I had put on the ticket myself. Hit was done by early afternoon.

Downed was the family I expected to fight me, because a body on the ground does not use the standing anchor. This family anchors on the figure's center of mass, stated in the delivery note, and the cardinals are not redrawn at all — they are lossless 90-degree rotations of the approved south master. I re-rotated the master myself and reproduced the east, west, and north body and cloth layers byte-for-byte, with zero cardinal cleanup. The diagonals take a 45-degree nearest rotation plus hand cleanup bounded to silhouette edges only, and the ledger held exactly: three isolated boot-edge texels removed per diagonal facing, nothing added, nothing recolored, nothing inside the figure touched. The emblem is never rotated with the body. It is re-composited in pooled-cloth space, flag pooled on the ground where it fell, and it measured pixel-identical to the locked master at 117 texels on every facing. That is the whole method working as designed: rotate what rotation can prove, repaint only what it cannot, and account for every texel that changes.

Throw closed the set, and it changed the spec in the process. The first frame of the proof is byte-identical to the shipped carry composite and the last frame is byte-identical to the banked neutral, so the family starts and ends on ground I already trust. Between those frames the crate lives on its own layer, exactly as the held-item architecture requires: zero crate texels in either character sprite, 556 texels preserved in the south crate raster and 560 in the north, lifted in a pure translation with an airborne step of exactly eight texels. What I had written in the state-poses spec was a one-arm throw on neutral legs. What actually read correctly was a two-hand release — both arms coming down off the overhead carry together — on split-lunge legs repainted natively, with release grips that are separate from the carry grips: a drop of 30 texels from carry in the south facing, 14 in the north. I approved the proof and marked both supersessions in the spec in place, because a spec that disagrees with the approved art is just a future argument. The full set followed the same chain on all six remaining facings, crate texels preserved between 473 and 550 per facing, release grips reproduced arithmetically from the socket map and the approved delta formula. Timings of 240, 90, 100, and 300 milliseconds are in the animation as proposals only. The feel lock belongs to the engine, not the sprite sheet.

With throw approved, the Organizer was complete: stride, flag raise, carry, blade attack, crouch, hit, downed, and throw — all eight families through both gates, one character fully produced on Pipeline v2. He took long enough that finishing him felt less like a milestone and more like a proof that the factory can finish anything it starts.

The afternoon proved the second half of that sentence. The police officer, my transferability test, was supposed to run through the same compositor on configuration alone — new palette, new signature layers, no pipeline changes. Instead the composition seat stopped at the hard fence, correctly, because the signature compositor turned out to hard-code the Organizer's emblem hash, his layer set, and his output identity. There was no configuration path for a cap, a badge, and a duty belt. That is a real defect and exactly the kind the test existed to catch: the design said configuration, the code said one man. I filed the generalization as its own ticket, RIOT-78, with a strict regression bar — the Organizer re-run from his profile must come out byte-identical to the banked approvals, eight of eight hashes, or the tool is wrong. It did. The officer's first south master then failed my taste gate for honest reasons: the face needed to be stronger, the cap needed to read unmistakably as a policeman's peaked cap at game scale, and the outfit did not read as police. Revision two fixed all three, composited through the unchanged generalized executable with the signature layers removable byte-exactly, and the eight-facing set passed both gates that evening. Neutrals banked. Transferability is no longer a claim in a document. It is a second character standing in the repo. His owed families are a reduced enemy set — stride, club attack, hit, downed, throw as the release of a grab, and the grab itself last, because it is the one family with no Organizer precedent — with crouch, carry, rally, and the raise event cut.

Two smaller engine pieces landed alongside. The slash arc is now a runtime effect, never baked into a sprite: one shared swoosh swept by transform and fade from the hand-grip socket, which meant teaching the socket importer to carry the attack angle and blade length it had been discarding. The committed wiring runs at a 165-millisecond default lifetime inside a 210-millisecond ceiling. It also merged with the temporary swoosh still in the tree and the real sprite not yet landed, which I caught on a tree check after the merge — the ticket stays open, the fix is a forward repair, and a temporary asset never counts for a feel verdict. And the proof-graduation work settled its biggest open question: when the Organizer starts carrying a crate with the machete already equipped, the machete drops to the world as a world item, same frame the carry engages, to be picked up again after the throw or set-down. No stow state invented, carry never refused. That keeps the inventory gate honest — items are world objects first, and the state model, not the sprite, owns where they are.

I closed the day by opening the tile lane in its own worktree, because tiles were gated on the Organizer finishing and he had. The curb audit came back clean and specific: 104 files reviewed, 68 valid, 36 misfits in two classes — 24 driveway cuts still carrying the bright curb lip the grammar forbids at cuts, and 12 gutter rows carrying an accent the grammar forbids there — zero duplicates, and five missing roles ranked by how many real layouts demand them. Production built only the missing five, as 15 new members at 64 by 48 with centered pivots, moving the census from 950 tiles, 904 sprites, and 26 exceptions to 965, 919, and 26, with 1,212 incumbent files untouched and cut faces measuring at a maximum of 118 against 162 to 208 on the raised runs. In parallel the first world-finish family, brick commercial, passed its offline checks — 939 of 939 valid tile rows with decoded alpha unchanged, 12,223 color-only changes, maximum delta 7 against a cap of 8 — and then I sent it back anyway, because at game zoom it was too restrained to read. A stronger second pass is running inside the same cap. The cap does not move to make a finish louder.

One character complete, a second character proven possible on the same machinery, and a street that is starting to get its edges back. That was yesterday.

■ End of Entry 08 Next: the officer's reduced enemy set, and the stronger second pass on the brick commercial finish

One Man, Eight Directions

Yesterday started with rooms and ended with a person who can walk and carry a crate, and the distance between those two facts is the whole story.

The interiors closed first. The police station interior merged overnight, and the hospital followed it through both stages in one run. The hospital is two separate plans that share one building core: an emergency room built as an open treatment floor, bays around a central nurses station with an ambulance door flowing straight into treatment, and a ward built as a corridor spine, patient rooms off both sides, six doors, no exterior door at all. Each plan is 17 by 23, 391 cells. The emergency room partitions to 305 floor and 86 wall cells, the ward to 223 floor and 168 wall cells, with zero overlap. My verifier ran clean on both records, 176 faces in the emergency room and 256 in the ward, zero conflicts, and exactly one core in each plan at the identical anchor. The art stage added only eight new members, elevator and stair portals plus green protection rails, and the census moved from 942 tiles and 896 sprites to 950 and 904, exceptions still pinned at 26. With that, the translator gained its missing half. The relationship checks now prove what the cutaway checks could not: the bank vault door sits on its partition, the three station cell doors front the barred run, the hospital core connects to circulation in both plans and occupies the same shaft position across them, and the ward correctly has no outside door. Five deliberate mutations all flag. The ambulance for the emergency apron is done as well. Bank, station, and hospital are finished inside and out.

Then I stopped building places and started on the person who has to move through them. The rule I set was one character, proven completely, before any roster exists. Character one is the party leader, an organizer the party forms around. The proportion call is true overhead: head, shoulders, and torso from above dominate, legs short beneath, a compact figure of about 44 pixels against the 64-pixel story height. Eight facings, not four. That choice doubles every future animation frame, and I took it anyway because turning has to feel smooth. Identity comes from a flag worn on the body, draped over the shoulders and back. The figure itself stays in greys and browns, deliberately nobody. The flag carries all the color, and its emblem is the movement own symbol, the Blinded Eye, bone white on deep signal red. The production method is hybrid: a generator builds the base from one measurement set on the shared 64 by 128 canvas, anchor at 32, 80, legs band 10 pixels, torso band 18, shoulder span 30 front and back and 20 at the sides, head an 18 by 14 ellipse leaning 2 pixels into the facing. Every facing is a projection of those numbers, never a separate drawing. The palette law is mechanical: no non-flag pixel above 0.35 saturation.

The geometry nearly failed on the flag alone. The first handoff was deterministic, 16 of 16 byte-identical across reruns, with head centres within 0.8 pixels, but the draped flag was 24 pixels facing north and 241 facing south, exactly backwards from a flag that must dominate from behind. The raised cloth clipped off the top of the canvas, and at east and west it collapsed to a one-pixel line because the polygons were built on screen axes instead of along the facing vector. The fix rebuilt the cloth in its local frame with view-dependent draw order. On re-audit the back facings carried 475 to 480 flag pixels against 241 at the front, east and west held 217 draped and 361 raised, and nothing touched the top two rows. That set passed.

Painting the finish took three methods to learn what does not work. A programmatic finish flattened the rich texture I wanted and drew the wrong mark. A paint-and-conform route held its numbers, alpha difference zero, emblem exact at 117 texels, ten colours, maximum non-flag saturation 0.241, and still failed my eye at one sprite. The full sheet then passed every measurement I had, bounds identical, necks connected 16 of 16, and failed in motion: the figures did not read as one man turning. The cause was in the scaling stage, which stretched the whole painted foreground, flag and pole included, to the base rectangle, so matching outer bounds hid different heads, shoulders, and legs inside. A salvage test proved the repair direction, cutting cross-state body differences from 334, 284, and 375 texels to 54, 44, and 55, about an 85 percent reduction, by painting one body per facing and compositing the flag as a layer. Out of those failures came the laws I should have written first. The base geometry is an underdrawing, not a silhouette law: it binds anchor, footprint, proportions, and the eight facings agreeing as one figure, and a finish that closes the floating head and open neck notch in the draft is fidelity, not drift. Faces are painted, never composited, mirrored, or sheared, with the south face approved first as the master. And a part a pose moves is repainted in its new position and removed from its old one, reused byte-identical only when the pose does not move it.

Under those rules the fresh pass held. The eight draped sprites came back pixel-identical to the approved face work, necks connected eight of eight, landmark deviations inside 8 percent with the worst at 7.64 percent on the west torso, translations at or under 2.10 texels, and the raise became what it should always have been: a single north-facing event, 970 milliseconds across eight frames, not a second persistent set. I passed the turntable as cohesive, banked the geometry frozen as the human medium archetype, and ratified Pipeline v2 into the contract. Movement followed immediately. Stride poses step along the facing axis on a 140-millisecond cycle, neutral to step to neutral to step, with the emblem recomposited per frame in cloth space. The south and north proof passed, the other six facings reproduced it, and the family closed at 8 neutrals plus 16 stride poses. Carry proved the layer architecture under load: a 28 by 20 crate as its own sprite sheet, never baked into the character, hands at recorded grip sockets, legs reused and torso repainted natively under the new reuse law. The machete attack proved the blade grip class the same way, poses with empty hands and the weapon as a separate overlay, swipe marks left to the engine where they belong. By the end of the day the organizer could stand, turn, walk, raise his flag, carry, and swing, and every one of those verbs runs on rules the second character will inherit instead of reinvent.

■ End of Entry 07 Next: the remaining state families, hit, downed, crouch, and throw, then wiring the finished sets into the game and testing whether a second character, an enemy officer on the same archetype, can be built from configuration alone

Three Landmarks in a Day, Then the First Room

Yesterday was the day Batch 2 stopped being a queue and became a skyline. By the end of it, all three bespoke landmark exteriors — bank, police station, and hospital — had been produced, measured, approved, and merged to dev in sequence, and the project had already turned indoors and painted its first real interior. The census tells the shape of the day in one line: 804 tiles and 758 sprites at the start, 822 and 776 after the bank, 854 and 808 after the station, 908 and 862 after the hospital, and 932 and 886 after the bank interior art landed that evening. The orphan exception count never moved from 26, and at every step every incumbent row stayed identical. Nothing was touched that was not supposed to be touched.

The bank went first, and it almost did not go at all. Before any art existed, I closed its last four open decisions one at a time: the second-story limestone facade band is produced in the same session, so the bank ships complete at one and two stories; the lobby and vault interiors split off as a follow-on job; the signage band stays blank, a carved limestone panel with no lettering, because lettering turns to mush at this tile scale and a baked-in name would repeat on every bank the stamp ever paints; and the entrance steps are a one-cell stoop, with the monumentality carried by the chamfer, the pilasters, and the band instead. Production then stopped correctly at its first gate. The checkout the seat was working from carried an older naming constitution without the November amendments, and rather than guess at names it confirmed the fresh census, produced nothing, and escalated. The governing texts were supplied as reference only, the checkout file left untouched, and work resumed under the ratified rules. One more clarification mattered more than it looked: the entrance is a single assembly centered in the south chamfer itself, derived from the marker in front of the near vertex — not a second door centered on the long front. The deeper derivation rule governs, and the build conforms to it. The delivered set is 18 members. Its second-story family is exactly the proven pattern — wall bands on the southwest and southeast faces plus one corner band at the southern junction, near faces only, 64-pixel seating, with shared-pixel measurements of 192 on the southwest repeat and 128 on the southeast and zero color mismatches on either. The rear-face waiver holds, the parapet and cornice set is complete, and the proofs cover both heights at all four vertices. It passed technical review, passed my visual review, and merged. The first landmark was live.

The station repeated the pattern with its own opinions. I locked its centered civic front — canopy, blank name band, and flagpole composed as one entrance assembly over the public door, ribbon runs unbroken on either side — and then made the same three calls in the same spirit: interiors as a follow-on, the name band blank to match the bank, and one deliberate overrule. The yard gate does not sit centered on the rear street face. It is a two-tile vehicle gate offset into a side fence run, which is where a working yard actually wants its gate. The delivery was 32 members, 29 for the station itself and 3 shared civic pieces including the flagpole and both gate facings. The band family held a third time — 16 near-face cells, 64-pixel seating, zero gaps and zero mismatches — and the roof discipline is the anti-bank on purpose: a 4-pixel coping profile and no cornice at all. The yard was checked as playable space, not decoration, with 70 walkable cells connected and the gate, footprint, and cruiser cells correctly blocked. It passed technical review and waited for my verdict while the hospital was already moving.

The hospital is two buildings pretending to be one, and I locked it as a bookend: the three-story precast tower abuts one end of the two-story brick base, the main entrance stays centered on the base frontage, and the emergency entrance sits at the far end away from the tower, so the front elevation reads old wing, then new tower, in a single glance. The remaining locks followed the established pattern — interiors as a follow-on, the green accent spandrel confined to the tower's lower band at the base roofline so both eras share one identity line, and the emergency sign as a cross emblem, a symbol rather than lettering, so the blank-band rule survives intact. The ambulance the apron needs does not exist in the library, so it was assigned separately and correctly left out of this delivery; the marker waits on the apron for it. The build itself is the most partitioned work the factory has done: a 7-by-11 base and a 7-by-7 tower, audited at exactly two base doors and zero tower doors, band families correct on both materials at every level, and the seam between the eras proven with 64 matched opaque samples per level along the shared axis and no uncovered sample. The helipad derivation was validated with negative checks — it appears for the hospital tower part and rejects where it should. Fifty-four members, every import passing, and a generator rerun that reproduces every image byte-identically. It passed technical review, and that evening I approved both the station and the hospital together. All three landmarks merged in order, dev advancing through each verified census in turn. Batch 2's exteriors were done.

Then the project went indoors, and immediately found a real bug worth finding. The bank interior was designed in three questions: the vault at the back, so the round vault door centered on the far wall is the visual terminus from the entrance; a full teller counter run across the middle with a single gated gap, serving as both divider and cover line; and a dressed vault, with a safe-deposit wall and a center table. Two prop roles the design needed — counter and table — had no ratified host in the naming rules, so they were ratified properly and a new constitution revision was written before production cleared. The semantic map came back clean: an 11-by-17 plan, 128 floor cells and 59 wall cells accounting for all 187 cells, with entry, gate, and vault door aligned on a single axis. Its translator record, though, carried a defect the audit caught cold: of 120 wall faces, 33 were marked cut away that the interior rule requires full. Every conflict was the same cardinal direction. In the admitted projection that direction is a far, northwest-facing surface, and far faces stay full — only the presented southwest and southeast faces drop to stubs. The fix was one boolean in the translator, flipping that direction from presented to full, with the presented set becoming exactly south and east. It was verified the slow way: the verifier flagged all 33 conflicts against the old record and passed the regenerated record at 120 faces and zero conflicts, exactly 33 values changed and every other value identical, with 18 tests green including a new cardinal regression. Only then did the art proceed — 24 new members founding the plaster interior family, cutaway consumed per face rather than per cell at 60 full and 60 low faces, the vault surround standing at its own 66-pixel height and never cutting away, and exactly one vault door seated in the scene. It passed technical review that evening. The station interior followed the same discipline on paper and in plan: cells along the back wall behind a barred run, the armory beside them so the rear is one secure zone, an open bullpen in the middle, and a booking counter run with one gated gap at the front — and its semantic map, 15 by 19 with all 285 cells partitioned, passed its stage review late that night.

What remains is honest about its boundaries. Relationship verification for the interiors is still pending — existence and counts are proven, geometry between features is the follow-on's job, and no delivery claimed otherwise. The curb and street-edge audit is the last exterior item in the batch, and the hospital interior design has not yet run. The direction beyond the interiors is also set: character models come next, built overhead from a fresh design, and the earlier experimental character work will not be carried forward. Yesterday the factory proved it could finish a landmark. Then it proved it could finish three, walk inside the first one, catch its own tool lying about a wall, and fix the tool before painting another one. That second part is the system I actually care about.

■ End of Entry 06 Next: the interiors continue, then character models

Stacking Complete

The residential bands close the stacking set — and the bank stops being a proposal and becomes a composition.

Yesterday finished a job that had been running in serial for three days, and then immediately started the harder one. The morning’s work was the brick residential wall bands: the third and last application of the stacking system to a base kit. By early afternoon the family was reviewed, approved, committed, and merged, and the census had moved exactly three tiles. Then the project turned from kits to landmarks, and the bank — the first bespoke building in the line — got its composition locked.

The band system itself was not the experiment anymore. It was proven on the commercial kit and corrected on the warehouse kit, and the rule set is small enough to state in one breath: per added story, exactly three members — a wall band for the southwest face, a wall band for the southeast face, and one corner band at the near, southern junction. Band height is held at 64 pixels, so a two-story building is the base plus one band and a three-story building is the base plus two. The far side gets nothing. Hidden north bands are waived under the rear-face rule; on the far side only the roof corner rises, and that rise belongs to the roof geometry, not to the band family. The residential job was therefore not invention. It was measurement: whether a system tuned on two other kits could be seated honestly on a third kit with its own geometry, without borrowing numbers that do not belong to it.

The residential kit has opinions. Its base walls sit on a 64×120 canvas with a pivot at (32, 40), and its rear profile runs to a measured line that stays at ground level — a quirk the commercial and warehouse kits do not share. The bands were built to respect that instead of flattening it: each band is drawn on a 64×128 canvas with a pivot of (0.5, 0.375), preserving the kit’s top-relative anchor, the base kit itself was left byte-untouched, and no commercial or warehouse measurement was substituted anywhere. The band surface is the base wall’s own clean upper field, repeated — the new story reads as the same building continued, not as a different building stacked on top. Openings stayed disciplined for the same reason: only the residential kit’s already-admitted window pair appears, in aligned rows at the ground bays, with a single ground door and no doors or openings invented for the upper stories or the rear. A stacked house that sprouts a second front door halfway up is not a taller house. It is a drawing error with good posture.

Proof followed the pattern the project has settled on, and then went one step past the minimum. Both a two-story and a three-story stack were assembled and rendered, with close-ups at all four vertices on each stack — the far vertices matter precisely because they prove the waiver reads correctly, that the missing bands look intentional rather than forgotten. The audit of the saved scenes confirmed the placement arithmetic directly: 64-pixel band seating, thirteen front band cells per story, exactly one southern junction per band, windows aligned, the door at ground level only, and no rear bands anywhere. Both proof scenes survived a save-and-reload identity check, scene validation reported zero issues, and the family render at game zoom held together — the cleaner band read is what makes a three-story brick house look built rather than extruded.

The census is the receipt, and it is boring in exactly the way I want receipts to be. Before: 801 tiles, 755 sprite GUIDs, 26 orphan exceptions. After: 804 tiles, 758 sprites, 26 exceptions. Three in, three in, none orphaned, the exception set identical, and every one of the 801 baseline rows unchanged — the delivery added a family and touched nothing else. The landing was verified the same way the last two were: the delivery commit sits in the dev lineage, the merge commit is the dev tip on read-back, no verification commit was needed because the regenerated manifests came back unchanged, and the scratch files from the proof block were restored byte-identical. With that, stacking is complete for all three kits — commercial, warehouse, and now residential — each of them able to stand at one, two, or three stories under one band system with one height increment. A whole axis of the city just stopped being a per-building negotiation.

The afternoon belonged to the bank. Landmarks are not kits, and the bank’s design phase is deliberately split: proposal first, owner lock, production only after. Yesterday’s proposal was built entirely on the previous day’s locks — classical, pale limestone, flat roof, an identity stamp in the painting language, a lobby and a round-door vault as the only interior program, the second story as facade only — and it put three compositions inside those locks. The first paired a chamfered southern vertex, carrying a pilaster pair, with the main entrance assembly centered on the longer front: steps, double door, and a signage band, with pilaster overlays marking the bays and plain limestone runs doing the quiet work everywhere else. The second doubled the chamfer symmetrically at both front corners — more formal, more bespoke pieces, and a far chamfer that is half rear-facing and reads weakly for the extra cost. The third dropped the corner geometry and let the entrance assembly carry the whole signature, which is cheapest and risks reading as a limestone commercial block rather than a landmark.

I locked the first. One chamfer at the near vertex is the smallest honest signature that still announces the building at game zoom, and the centered entrance keeps the composition legible from the angles the camera actually uses. The signature set that goes to production is seven exterior members: the bank’s own limestone wall runs with their own block coursing — not a recolor of the commercial walls — the chamfer corner piece, the entrance assembly, the blank signage band, the entrance steps, the pilaster overlay pair, and a flat roof whose limestone parapet reuses proven roof assembly geometry in the new material. Four decisions deliberately remain open, asked one at a time in the project’s usual order: whether the two-story facade band is produced in the same session or banks ship one story tall until a level asks for more, whether the lobby and vault interiors become a follow-on ticket, whether the signage band stays blank or takes lettering, and whether the entrance steps are a single-cell stoop or a two-cell run. Production does not start until those close. That restraint is the system working as designed: the kits taught the factory how to repeat itself, and the landmarks are where it learns when not to.

■ End of Entry 05 Next: the bank’s remaining locks, then Phase 2 production

Three Landmarks, One Partition

Yesterday was a design day that turned into a shipping day. I started it with three buildings that did not exist except as ticket titles — a bank, a police station, and a hospital — and ended it with all three structurally locked, a new version of the visual-plan key set built and merged to dev, and one more tile family admitted to the library. The through-line was a rule I keep relearning on this project: decide things one at a time, in order, and write each decision down before the next one depends on it.

The landmarks came first, and they were deliberately not a kit. Each building got its own era. The bank is classical: a two-story corner building in pale limestone, its entrance cut into a chamfered near corner, pilasters carrying the faces instead of a full portico, and a flat roof where a heavy cornice and parapet do the classical work. The police station is mid-century civic modernism: a two-story precinct box in dark charcoal brick, ribbon windows, a flat roof, and an entrance assembly — canopy, flagpole, and name band composed as one piece — as its hero. The hospital is two buildings pretending to be one: an older two-story red-brick base wing joined directly to a newer three-story white tower, green accents as its identifying trim, an emergency entrance on the old wing, and a helipad on the tower roof. The seam where the two hospital eras meet is not a defect to hide. It is the building's story, and the painting is supposed to draw it.

All three are playable, not just facades. That decision forced the interior question early: every landmark kit is designed interior-capable, with finished interior wall faces and enough vocabulary variety that a larger structure does not read sterile. The programs are deliberately unequal. The bank gets two set-piece rooms, a public lobby and a vault, with a single round vault door as the interior's hero piece and its second story as facade only. The station gets a full ground floor — lobby, booking, holding cells, offices, armory — plus a rear secure yard, fenced, with a two-tile vehicle gate and cruisers parked inside it as playable tactical space. The hospital splits its program: the emergency room in the old base, one playable ward floor up in the tower, connected by an elevator and stair core piece. Entering any of them loads a separate interior scene, and interiors stay isometric with cutaway near walls — far walls at full height, near walls dropped to low stubs — so the grid, facing, and line of sight never rotate between outside and inside, and one art pipeline serves both.

Three bespoke buildings broke the key set, which is the part I am proudest of yesterday. The painting language I use to lay out sectors had exactly one landmark footprint symbol, which meant a bank, a station, and a hospital were indistinguishable on the page. Rather than mint three new footprint symbols, I kept the generic landmark fill and added identity stamps on the same mechanism that already handles story height: one stamp anywhere on a footprint sets the whole building's identity, and conflicting stamps get flagged instead of guessed at. The codes are BK for the bank, PD for the station — the obvious two letters were already taken by the player spawn — and HSP for the hospital.

The hospital then exposed the real algorithm problem. It paints as two adjoining landmark masses, a two-story part and a three-story part, but under the old translator rules two touching masses are one connected cluster, and two different story stamps on one cluster is exactly the conflict case the tool was built to flag. The fix is a flood-fill partition: each identity stamp claims cells by fewest steps, each part takes its own story stamp, equidistant contested cells are flagged rather than assigned, and parts sharing an identity group back into a single building record with two parts. Two principles fell out of the rest of the queue and are now general law. Derive what is fixed: the helipad exists because a hospital tower exists, and the bank's chamfer exists because a door marker sits in front of a near corner — neither gets its own stamp. Paint what varies: cruiser and ambulance markers are explicit symbols, because vehicle count and placement are level design, not entity constants. The key set grew from 26 symbols to 33 — three identity stamps, the two vehicle markers, and two interior keys for floor and wall — and interiors got a real painting flow of their own: a separate map per interior, a reuse-first vocabulary where a door means the same thing indoors as out, cutaway derived per wall face from camera orientation rather than painted, and interior records nested under their building's record in the output spec.

None of that shipped on trust. Acceptance for Key Set v2 required a landmark test painting exercising all three buildings through the translator, plus deliberate-error cases proving the flags actually fire: a contested partition cell, a bank stamped at the wrong height, and a bank with no door at its near corner, which is a mis-paint because the chamfer is mandatory. The old proof painting still translates identically — 576 cells, 119 buildings, 13 flags, no new flags — and the previous key set versions stayed byte-untouched, verified by hash. The one real trap in the build was the partition collapsing two same-identity regions into one part; keeping stamped regions as separate parts under one building record fixed it. The work merged the same night, and the follow-up it honestly owes — geometric checks on interior feature placement, like a vault door actually sitting between lobby and vault — is filed as its own ticket, triggered by the first real interior paintings rather than built speculatively now.

The day closed with production, and with a correction I want on the record. The warehouse wall bands applied the stacking system proven the day before to the concrete block and corrugated steel kit: exactly three members per level, the two near wall bands and the near corner band, band height held at 64 pixels. My first brief for it overgeneralized the vertex rule and demanded a far corner band that does not exist in this system — the earlier ticket lock, which waives hidden far band members, governed, the brief was corrected, and the delivery followed the lock. That ordering matters: a specific locked decision beats a general rule when the two appear to conflict. The family passed review with stacked two- and three-story proofs and close-ups at all four vertices, and the census moved exactly as predicted, from 798 tiles, 752 sprites, and 26 orphan exceptions to 801, 755, and 26 — three in, nothing orphaned, nothing else touched.

Batch 2 is now underway in serial order, with the residential wall bands next. The landmarks wait as locked proposals until their production turns come, but they no longer wait as questions — and on this project, converting questions into locked, testable decisions is most of the work.

■ End of Entry 04 Next: batch 2 continues — residential wall bands

The Last Car

Last night this log went out with one job unfinished. The merge train that carried the tile factory’s first batch — six families, merged one at a time, in dependency order, with the asset census regenerated and matched exact after every stop — had one car left in the yard: RIOT-52, the stackable wall bands. The family was admitted, the merge was authorized, and the train does not move on a handshake. It moves on a number.

The closing check was written into the merge authorization itself: after the merge, the census had to regenerate to exactly 798 tiles, 752 sprite GUIDs, and 26 orphan exceptions. Anything else stops the push and gets reported. No rounding, no “close enough,” no quiet adjustment to make the arithmetic pretty — and the merge report states the other half of that rule out loud: the exception set came through unchanged, and no assets were adjusted to force the counts. That clause matters more than the numbers do. A census you are allowed to nudge is a census that tells you nothing. These counts are evidence because they were free to fail.

The merge landed as feae89f, the final car of the 47–52 train. Post-merge census: exactly 798 tiles, 752 sprites, 26 orphan exceptions — the predicted stop, hit to the tile. Verification is recorded in commit 8499268. The merge was made locally and the push deliberately deferred — it was the last merge of a long night, and pushing tired is how repositories get hurt — then pushed with the night’s second landing, below. Dev now stands verified at cd713ed, matching origin.

So batch 1 is closed, end to end. The train started the evening at 697 tiles with the scratch test pieces set aside, and stopped at 706, 714, 722, 733, 795, and finally 798 — warehouse walls, warehouse openings, commercial openings, the residential completion, ground transitions, and the stacking bands — with the orphan count pinned at exactly 26 at every single stop. Six families that did not exist as a coherent kit a day earlier are now the standing construction set, each one admitted the same way: deterministic production, a Gate A proof, my verdict, a merge, and a census that landed exact.

Then the night had a second landing, quieter than the train and just as structural. RIOT-59 merged at cd713ed: Key Set v1 and the translator fold-in. The key set is the symbol vocabulary I design with in Tiled — the ink shapes that mean warehouse, road, fence, parked truck, spawn point — and v1 grows it to 26 symbols, adding the S2 and S3 story keys, the markers that carry narrative beats in a sketch rather than just geometry. The translator is the compiler that reads a sketch cell by cell and turns it into the formal spec the builders work from, flags instead of guesses wherever the sketch is silent. Until last night that compiler lived alongside the project. Now it is folded into dev, versioned with everything else, with all five of its tests passing and the working tree’s unrelated files untouched. My design surface and the machine that reads it now ship together, which means a change to the vocabulary and a change to the compiler can be reviewed as one act — because in practice they always were one.

That is what a finished batch actually buys. Batch 2 is already filed, and it is a different kind of work than batch 1: RIOT-53 and RIOT-54 take the stacking bands proven on brick commercial and apply them to the warehouse and residential kits; RIOT-55, RIOT-56, and RIOT-57 are the bespoke landmarks — the bank, the police station, and the hospital — each design-proposal-first, no production until the design is locked; RIOT-58 audits the curb and street-edge set before anyone touches it. Batch 1 was about proving the line could build families and land them exact. Batch 2 is where the line starts building a city worth naming.

Yesterday was a long shift at the factory, and it ended the way the system is designed to end: not with a feeling that the work looked right, but with a number that had to be exact — and was.

■ End of Entry 03 Next: batch 2 — warehouse and residential stacking, and the first landmark designs

The Merge Train

Six families, one track, and a census that has to land exact at every stop.

Entry 1 was the factory. This entry is what came off the line after it — the rest of the day went to verification tails, acceptance gates, and the first two cars of a six-family merge train. Every family in the batch was generated in its own worktree; every family had to pass the same two gates before it could merge: my visual verdict on its proof images, and an independent Gate A pass on its measurements.

The ladder

The train merges in dependency order — 47, 48, 49, 50, 51, 52 — one at a time, as merge commits, never fast-forwards. After each merge the asset census is regenerated inside the editor and has to match the predicted count exactly. With the scratch test tiles set aside, dev started the train at 697 tiles and 26 ruled orphan exceptions. The expected stops: 706, 714, 722, 733, and 795 tiles (sprite GUIDs 660, 668, 676, 687, 749), with orphans at exactly 26 at every single stop. Any other number stops the push.

Two standing conflict rules keep merges mechanical: generated manifests are never hand-merged — take either side and regenerate — and the session log resolves by union.

One correction mattered before the train moved. The original walkthrough had family 47 at +8, for a first stop of 705. The delivered warehouse-wall family actually has nine members — the ninth is a south outer corner that the vertex rule requires and the brick kit never had — so the correct first stop is 706. Running on the stale 705 would have made a good merge read as contaminated and tripped the stop rule on a real, admitted tile.

Why the line is deterministic

There are two ways to get a tile out of a machine. One is to ask a generator for a picture and accept whatever comes back; run it again and something slightly different arrives, and nobody can say which difference was intended. The other is to write code that draws. This factory runs on the second. Generated images do real work here, but it is teaching work: they build the reference textbook — the vocabulary of decay, brick, rust, and wear — and that vocabulary gets translated into briefs and specs. No generated picture ever ships as a tile.

The production renderer is Python and PIL, written against a contract with one hard rule: a fixed seed per generator, and a double render must come back byte-identical. The generator scripts ship with the tiles, so any family on the shelf can be rebuilt exactly by anyone, at any time. If the output changes, it changes because the script or the spec changed — an intentional diff I can read — never because the machine felt different that morning.

The spec side is locked the same way. A family’s palette is a whitelist: a surface is its base tile, and variants are seasoning placed sparsely. Which variant lands on a given cell is chosen by a hash of its (x, y) coordinates, and a spacing pass then demotes any variant that shares an edge with another variant, scanning in a fixed order. Same spec, same code, same coordinates: the same sector, every run. No stripes, no checkerboards, no reroll.

That is not tidiness for its own sake. Determinism is what turns my gates into evidence. The census tool re-runs byte-identical, so when it reports a count, that count is a fact, not a sample. Hash verification can prove a negative — the original PNGs stayed untouched through a whole day of tails, and when the RIOT-49 session died mid-tail, the continuation verified all eight draft PNGs by SHA-256 and did not regenerate a single one. The census is a standing gate, not a report: the healthy state is a fixed, known orphan set — 26 ruled exceptions on this train — and any new orphan stops the session. And Gate A’s close-ups judge an artifact that is standing still; a verdict on a render that cannot be reproduced would be a verdict on nothing.

When a gate does flag something, the correction goes upstream — back to the spec or back to the renderer, never a hand-patch on the tile itself. Tonight’s example is small and perfect: Gate A’s seating close-ups on RIOT-49 exposed daylight between the stoop and the door threshold. Only the SW and SE stoops were regenerated — deeper tread, raised riser, threshold contact closing the gap — and the counts did not move: 714 tiles, 668 sprites, 26 orphans. Fix the code, re-run the line, land on the same numbers. That is the whole method in one repair.

Flowchart of the deterministic rendering line: brief and sector spec feed a reference textbook, then the deterministic Python and PIL renderer, tiles out, import validity checks, census and hash verification, and the Gate A visual proof; a pass-fail gate loops back to the renderer for corrections, then owner verdict and merge to dev
DiagramThe deterministic line, end to end. The only loop in the system is the correction loop — and it runs back to the code, never to a hand-patched tile.
Mermaid source for this chart
flowchart TD
    A["Brief + sector spec r6<br/>palette lock: whitelist + coverage rules"] --> B["Reference textbook<br/>generated images teach vocabulary only"]
    B --> C["Deterministic renderer<br/>Python / PIL, fixed seed<br/>variants by hash of (x, y) + spacing pass"]
    C --> D["Tiles + Tile assets<br/>generator scripts ship with the tiles"]
    D --> E["Import validity checks<br/>sprite-valid, canvas, PPU, pivot"]
    E --> F["Census + hash verification<br/>counts land exact, orphans pinned,<br/>original PNG hashes unchanged"]
    F --> G["Gate A visual proof<br/>contact sheet + close-ups at tile scale"]
    G --> H{"Gate A pass?"}
    H -- "flag: fix the spec or the renderer,<br/>never patch the tile<br/>(RIOT-49: stoop-to-threshold gap)" --> C
    H -- pass --> I["Owner verdict<br/>my eyes are the acceptance gate"]
    I --> J["Merge to dev<br/>merge commit, census re-run at the stop"]

47 and 48 — the warehouse, merged

47 is the warehouse walls: nine members, with the base-proportion question settled by side-by-side close-ups before it merged — the 24-pixel-base set is what landed. It merged first and closed at a dev census of 706 tiles.

48 is the warehouse openings that seat into those walls: eight members — a rollup door, a personnel door, a six-pane industrial window, and a louver vent, each in both facings. Its verification tail reported 8 of 8 imports valid and a branch census of 714 tiles / 668 sprite GUIDs / 26 orphans, exactly +8/+8/+0. The palette was not guessed: steel colors were sampled per facing from the admitted wall art itself (SW base (60, 63, 62), SE base (68, 71, 70)), and the glass color (27, 31, 37) carried over from the brick kit. Seating geometry came down to baselines — opening art bottoms at local y94 against the wall baseline y99 — handled as one shared −5px layer offset for the whole family instead of per-door adjustments. The seating proof painted the rollup and personnel doors into real wall runs in both facings:

RIOT-48 seating proof, southwest facing: a personnel door and a rollup door seated into a corrugated steel warehouse wall run above a brick base course
Fig. 01RIOT-48 seating proof, first facing (SW): the personnel door and rollup door seated into an admitted warehouse wall run, sharing one −5px layer offset against the wall baseline.
RIOT-48 seating proof, southeast facing: the rollup door and personnel door seated into the opposite warehouse wall run, following the wall plane and baseline
Fig. 02The opposite facing (SE). Both doors follow the wall plane and the baseline; the palette was sampled from the admitted 24px wall art, not the superseded draft palette.

Gate A passed, I approved the close-ups, and 48 merged: merge commit 8c23d15, new dev tip 3a21f37, post-merge census exactly 714 / 668 / 26, both scenes loading clean with zero console errors, and all 35 scratch files restored byte-identical with their hashes verified.

49 — commercial openings, and the stoop

49 was never fired in the original parallel launch. It started late, in a fresh worktree, and still finished its tail the same day. Two early stops turned out to be rulings rather than defects: the 26 orphans are ruled exceptions and do not block production, and the foundation names the family needed were already in the naming constitution, ratified through another family.

Mid-tail, the session’s chat locked up — its model picker reported the model unavailable. The eight draft PNGs were already on disk, so a fresh continuation chat in the same worktree verified all eight intact by SHA-256 and ran the tail without regenerating anything: 8 of 8 imports valid, census 714 / 668 / 26 against the refreshed baseline, Gate A pass.

Then the seating close-ups earned their keep. They exposed a visible gap between the stoops and the door threshold above them. The fix was scoped to the two stoop pieces only — deeper tread, raised riser, real threshold contact — regenerated as an amended commit (ecdf5b5) with every count unchanged. The seating relationship itself is now locked: an opening overlays its own wall’s cell with the wall underneath, the stoop sits on the approach cell, and the foundation band stays in the wall stack. I approved the family after the fix. It sits at merge position 3, expected to bring dev to 722 tiles. Its seating close-ups live in the worktree on my machine and are not reproduced here; the stoop gap they caught is the kind of defect the proof exists to find.

50 and 51 — gated and waiting

50 completes the brick residential kit. Its tail census read 717 tiles / 671 sprites / 26 orphans on its branch — exactly +11/+11/+0 over the 706 baseline — with 11 of 11 imports valid and the orphan set identical. The repair inside this family: the front walls were clipping their own footing. The walls were recut at 64×120 with the pivot moved to (0.5, 1/3), which preserves the y80 anchor measured from the top and puts the extra 8 pixels entirely into the previously clipped footing; before-and-after vertex captures show the footing running continuous along the same ground plane into the neighbouring kit pieces. Gate A passed, I approved it, and it waits at merge position 4 (733 expected).

51 is the ground transitions, 62 new pieces, and it produced the day’s cleanest diagnosis. Its strip proof failed the save-and-reload check — and the family was innocent. All 48 transition placements and every grid fact round-tripped exactly; the mismatch was tint and flag overrides the proof helper had painted onto 12 base-concrete cells, which the save format does not persist, so reloaded cells reverted to the source tile’s authored color. The proof was rebuilt using the existing dark concrete tile instead of per-cell overrides, and the round-trip then passed on all 144 cells, tail census 759 / 713 / 26 (+62 exactly). The standing rule that came out of it: authoring writes tile identities and data facts only; tone comes from tile choice, never per-cell overrides. I approved its contact sheet tonight. Merge position 5 (795 expected).

52 — the stack, delivered

The stacking bands are the two-phase family: design first, production second. I locked Option B — 64 pixels per added story, brick commercial first, upper window rows aligned with the ground floor, a dedicated corner band per level, exterior-only cutaways, and a waiver for the rear-face band members no viewer can ever see. Two new roles, wall_band and corner_band, were ratified into the naming constitution to make the family describable at all.

Tonight produced the first full stacked building standing in the district:

RIOT-52 Option B render: a three-story brick commercial building with window rows aligned on both faces, standing in the district among streets, parked trucks, and neighbouring brick buildings
Fig. 03RIOT-52, Option B in the district: a brick commercial stack at 64px per added story — window rows aligned on both faces, ground floor keeping its own openings, one roof, plinth at the base.

RIOT-52 has since delivered its tail. The stacking bands landed on codex/riot-52-stackable-wall-bands (commit 8a39d27), built on the merged train at dev 9704fbd: three members — bldg_wall_band_brick_commercial_sw, bldg_wall_band_brick_commercial_se, and bldg_corner_band_brick_commercial_s — with 3/3 imports valid at 64x128, PPU 64. Two proof scenes, a 2-story and a 3-story, were built as clones that modify only B1’s visible assembly; the original scene stayed byte-identical, both proofs are save==reload verified, and Unity validation reported zero issues. The census moved by exactly the predicted arithmetic: 795 to 798 tiles, 752 sprite GUIDs, the 26 orphan exceptions unchanged, all 795 previous rows identical, and exactly three new rows, all VALID. Eight vertex close-ups and a game-zoom family sheet came with the delivery, and Gate A passed it on the technical evidence.

Admission followed the same evening. I approved the visual verdict — including the upper corner trim differing from the old ground corner, and the upper brick running calmer than the old base — and confirmed the completeness waiver for the three-member scope: what the lock never spelled out, the A/B and edge/transition matrix, is waived for this family as delivered. Gate A PASS and the owner verdict are both recorded on the ticket (comment 11239), and the merge is authorized as the final car of the 47–52 train. The merge itself is the last step, and it carries its own closing check: the post-merge census has to regenerate to exactly 798 tiles, 752 sprite GUIDs, and 26 orphan exceptions. Anything else stops it.

Where it stands tonight

On dev: RIOT-47 through RIOT-51, merged in order — dev stands at 795 tiles. RIOT-52 has delivered its tail (commit 8a39d27): Gate A PASS, admitted on my visual verdict and the confirmed completeness waiver, and its merge is authorized as the final car of the 47–52 train. The merge itself is still pending; its closing check is the post-merge census regenerating to exactly 798 tiles / 752 sprite GUIDs / 26 orphan exceptions. The bespoke builds Entry 1 pointed at — the bank, the police station, and the hospital — assemble from these proven kits once the train is in.

■ End of Entry 02 Next: the RIOT-52 merge — the final car

The Factory

What We Actually Built Today

The pipeline, in six moves
01SketchPaint a block in Tiled
02Spec864 cells, compiled
03Code drawsPython renders the tiles
04LayersData owns the truth
05InspectionCensus, proofs, counts
06CrewSix sessions, one queue

I’m building a city for a video game, and today we built the system that builds the city. Here’s the real pipeline, because it’s more interesting than the simple version:

  1. I design with a map editor, not code. I sketch a city block from overhead in a program called Tiled, painting with a symbol key I designed myself — this color means a warehouse, this one a road, this one a fence, a parked truck, a spawn point. It’s fast, visual design work: minutes, not hours.

  2. An AI agent compiles my sketch into an engineering spec. A second program reads the map file cell by cell — all 864 cells of a block — and translates the sketch into a formal spec sheet: exact coordinates, what each surface is, what it costs a character to move across it, what blocks sight lines. It works under strict rules: it is not allowed to guess. Anything my sketch doesn’t define gets flagged as a gap, never quietly invented. It even caught things in my own drawings I hadn’t noticed.

  3. The building AI doesn’t draw pictures. It writes code that draws. This is the part people get wrong about AI art. The agent that produces the actual game tiles uses no image generation at all. It writes Python scripts, and the scripts render the tiles pixel by pixel — brick walls, corrugated steel, roofs, doors — the way a plotter draws, not the way a painter paints. Because it’s code, it’s deterministic: run it twice, get the identical tile. Every dimension, angle, and anchor point is a number that can be measured and verified, not a vibe.

  4. The world assembles in data layers, and the data is the truth. The map isn’t just a picture. Underneath the visuals is a data grid that owns the facts of the world — what’s walkable, what blocks movement, what blocks sight. The picture tiles only render what the data says. That separation is what makes the game logic trustworthy.

  5. We built the quality system around all of it. A naming constitution so every one of the ~800 tiles has an exact, meaningful name. An automated census that counts and validates every asset. A rule that a saved map must reload byte-for-byte identical or the build is rejected. Test-builds (“proofs”) where new piece sets get assembled into a real building and inspected before they’re allowed in. Every merge into the game has to hit an exact predicted asset count — off by one, the push stops.

  6. The agents run like a crew, not a chatbot. Today six AI sessions worked in parallel, each in its own copy of the project, each on its own assignment. They share one testing machine — the game editor — so they line up and take it in turns, and they wait on each other’s finished work the way trades wait on each other on a job site. My role is producer: I write the assignments, set the standards, review the measurements, and give the final yes or no. One of the sessions even got replaced mid-day when it froze, and the work didn’t lose a step — because the work lives in the files and the rulebooks, not in any one conversation.

864
Cells compiled
per city block
~800
Tiles in the tracked,
validated kit
158
Broken or orphaned
pieces cleared out
6
AI sessions working
in parallel today

Where it stands tonight

Where it stands tonight: the tile library went from a messy box of about 680 pieces — 158 of them broken or orphaned — to a tracked, validated construction kit pushing 800 pieces, with complete sets for warehouses, brick storefronts, apartment buildings, roofs, and street surfaces. Tomorrow: the bank, the police station, and the hospital.

The short version

The short version: I sketch a neighborhood. Software I direct turns the sketch into an engineering spec, writes code that manufactures the parts, assembles the world in layers, and inspects its own work against numbers I set. That’s not “AI made my game.” That’s a factory, and I’m running it.

■ End of Entry 01 Next up — the bank, the police station, and the hospital