Direction: Make the cs2 clone playable end to end: movement and aiming that feel immediate, shooting with clear hit feedback, one s #8

Make the cs2 clone playable end to end: movement and aiming that feel immediate, shooting with clear hit feedback, one small map, and a bot to play against. 60 fps on a laptop, usable on a phone. Keep the check green and every change small.

This issue carries the repository's direction. The planner is given it when the map has run dry; it opens and links the issues that follow from it, and this one stays open.

The map for direction #8, read against the code as it stands: de_forge, the round, the economy and the PPO bots are already there, so the gaps are in feel and in the two ends of a match, not in the game's content.

Opened, in order:

• #9 — A click shorter than a frame still fires: latch input edges instead of sampling them. input.ts mutates controls.input on every event and main.ts samples it once a frame, so a press that begins and ends between frames is lost; attachButtons already papers over it with a 120 ms setTimeout for jump/reload/buy and does nothing for fire and use. Asks for a headless latch module so the rule is testable.
• #10 — Getting shot tells you: a directional damage indicator, a hurt vignette and a pain sound. shoot emits a hitmark only for the shooter; the victim gets no sound, no flinch, no direction. Adds a hurt effect in world.ts (tested) that the HUD and audio read, with a warning to keep it out of observe.ts so the shipped policy's numbers still match the card on the page.
• #11 — Death and the end of the match read right (waits for #10). drawHud always reads world.me while the camera follows a teammate, and match_over drops you back to a menu that never says who won. Passes the spectated player into the HUD and adds a result overlay.
• #12 — Hold 60 fps on a laptop and a phone: adapt the render scale to the frame time (waits for #9). resize() pins the buffer at min(devicePixelRatio, 2) forever while frameAverage is measured and used only to print a number. Asks for a pure nextRenderScale with a dead band, and a before/after measurement in the pull.

Ready now: #9 and #10. #11 is behind #10 and #12 behind #9, in both cases because they rewrite the same part of main.ts/hud.ts and doing them concurrently means a conflict. Nothing is assigned, nothing is pushed, and #8 stays open.

The map for direction #8, second pass, read against the code as it stands at 343dfe4. Feel and the two ends of a match were the last round's gaps and they are closed; what is missing now is information — you cannot hear where anyone is, you cannot see where you are, and the gun a bot dies with evaporates — plus a phone that can only half play.

Opened, in order:

• #21 — Hear where they are: pan every world sound, and give players footsteps. audio.shot scales one mono gain by distance, so a rifle behind you and a rifle in front of you sound identical, and the { kind: "sound" } effect declared at world.ts:70 has never been pushed by anything. Asks for a headless ears.ts (position + listener + yaw → pan and volume), a StereoPanner on shots, and footsteps on a stride cadence that go silent when you walk or duck. Warns off observe.ts's 32 numbers and off allocating per tick in the RL arena.
• #18 — A radar in the corner: the map, your team, the sites and the bomb. There is no minimap anywhere in the repository and map.ts already holds everything one needs. Pure radar.ts returning blips rotated to the view, the map itself blitted from an offscreen canvas built once, drawn for view and not world.me. No enemies on it — that would be a wallhack.
• #19 — Pick the rifle up off the body (waits for #21). onKill drops the bomb and nothing else, so two lost rounds put both sides on pistols with money they cannot spend. One pickup rule, tested in world.test.ts, including that startRound's ammo re-arm does not hand you an empty gun the round after.
• #20 — A whole match on a phone (waits for #18). controls.onPause is only ever called from pointerlockchange, which a touch screen never fires: there is no pause and no way to leave a match. Adds that, weapon switch, scoreboard, and firing that does not cost you your aiming thumb.

Ready now: #21 and #18. #19 is behind #21 because both rewrite the middle of world.ts; #20 is behind #18 because the touch pad has to be laid out around wherever the radar lands. Nothing is assigned, nothing is pushed, and #8 stays open.

The map for direction #8, filed as four issues; the clone is untouched and nothing is pushed.

Opened, in order:

• #21 — Hear where they are: pan every world sound, and give players footsteps. Sound is mono and distance-only today, and the sound effect declared at world.ts:70 has never been pushed. Ready now. → vesper
• #18 — A radar in the corner: the map, your team, the sites and the bomb. No minimap exists; map.ts already holds everything needed. Ready now. → vesper
• #19 — Pick the rifle up off the body — waits on #21 (both rewrite the middle of world.ts). → vesper
• #20 — A whole match on a phone: fire while aiming, weapon switch, scoreboard and a way to leave — waits on #18 (the touch pad is laid out around the radar). → scout, or vesper if the two-finger aiming needs real work inside the canvas touch handlers.

Ready now: #21 and #18. A probe issue (#17) created while working out that the API's PATCH only takes a state was closed immediately. #8 stays open, and nobody is assigned.

The map for direction #8, third pass, read against 3b044c4. The first thing I found is that the check is red on main: two bundles are committed, neither is what the sources produce, and production serves whichever readdirSync hands back first. The rest is a round that rarely reaches its own bomb.

Opened, in order:

• #26 — One bundle, built at start-up. bun test on main fails (Expected to contain: "app.9585cc6287.js"); merging #24 and #25 left both their bundles behind and neither matches. Build at boot, take the artifact out of git. Ready now. → scout
• #27 — The bomb gets planted (waits on #26). Measured over 41 seeded rounds: 37% plant rate, 14 rounds lost to the clock, median round 104 s. The Ts roll a site each, so the carrier walks in alone and nobody watches the timer. → vesper
• #28 — The body stays where it falls (waits on #26). renderer.ts skips !p.alive, so a kill is a disappearance and #24's dropped gun spins over nothing; the same line also puts the spectator camera inside the teammate it is following. → vesper
• #29 — Sound, sensitivity and a scope you can reach (waits on #26). audio.muted exists and nothing sets it, sensitivity is read once at start(), and scope only comes from a right mouse button under pointer lock — the AWP cannot zoom on a phone. → scout

Ready now: #26, and only #26 — while the built bundle is committed, any two client pulls merging in sequence reproduce exactly the breakage on main today. #27, #28 and #29 are independent of each other and can run together once it lands. Nothing is assigned, nothing is pushed, and #8 stays open.

This was a planning run, so there is no diff and nothing was pushed: the working tree is clean at 3b044c4 and the result is the map on the forge, not code.

Four issues were filed against direction #8, and a summary comment posted there:

• *#26 — One bundle, built at start-up: stop committing static/app..js (ready now, → scout). bun test is red on main**: two bundles are committed, neither is what the sources produce (Expected to contain: "app.9585cc6287.js"), and findScript() serves whichever readdirSync returns first. Merging #24 and #25 left both their artifacts behind without a textual conflict — this will recur on every client pull until the artifact leaves git.
• #27 — The bomb gets planted: one site for the team, an escort and an eye on the clock (waits on #26, → vesper). Measured headless over 41 seeded rounds: 37% plant rate, 14 rounds lost to the clock, median round 104 s.
• #28 — The body stays where it falls (waits on #26, → vesper). renderer.ts skips !p.alive, so a kill is a disappearance; the same line also puts the spectator camera inside the teammate it follows.
• #29 — Sound, sensitivity and a scope you can reach without leaving the match (waits on #26, → scout). audio.muted is never set, sensitivity is read once at start(), and scope only comes from a right mouse button under pointer lock.

What a person should look at first: #26, because the default branch's check is failing right now and production is serving a stale bundle. The three that follow are independent of each other once it lands. Nobody is assigned and #8 stays open.

Budget reached at $2.51; this is where it stopped.

The clone is untouched — this was a planning run, so the map is the result and nothing is pushed.

I read the whole repository (219 tests green, the page answering in 1–8 ms, an 81 KB bundle) and found the direction's core already built: movement, hit feedback, de_forge, learned bots, the bomb, drops, corpses, radar, panned sound, touch controls and adaptive render scale. What a CS player still misses is utility, a say in how hard the fight is, and being told what their bullets did.

Filed, in order:

• #36 — Utility, part one: a grenade you can throw, and an HE that hurts (ready). A new src/client/grenades.ts for the flight of a thrown object, an HE buyable at $300 on a fourth slot, bounce, fuse, falloff damage with a line-of-sight check, and feedback reusing hurt/flinch/ears. Explicitly out: anything in src/rl. Suggested: vesper.
• #37 — Utility, part two: smoke that actually takes a sightline off the map (blocked by #36). A cloud that blocks canSee for bots and for you, that bullets pass through, capped and measured for frame time. Suggested: vesper.
• #38 — Choose how hard the bots are, before the match and during it (ready). Skill is currently a function of bot id; this makes it a validated setting in the menu and the pause overlay, a band rather than a number, and stays clear of result.ts/db.ts so it cannot collide with #34. Suggested: scout.
• #39 — Every round ends with a damage report (ready). A bounded per-round ledger in the world, a report.ts that renders it to lines, and a HUD block during the round-over delay. Suggested: scout.

Ready now: #36, #38, #39 (alongside #34, already with vesper). Blocked: #37, waiting on #36. No issue was parked. #8 stays open as the direction; #35 was an accidental endpoint probe and is closed with a note.

The map for direction #8, fourth pass, read against 24b2777 (219 tests green, the page in 1–12 ms, an 81 KB bundle). The direction's content is built; what is left is one outright bug, one sense the game does not use, and no way to tell whether a round is any good.

Opened, in order:

• #43 — Paused means paused (ready, → scout). Escape only puts a dialog over a live match: nothing clears running, so the clock runs, the bots shoot and press.clear() means you do not even move. A hidden tab crawls on the same way. Asks for a headless loop.ts that owns what a frame is worth, and a resume that banks nothing.
• #44 — A bomb you can hear (ready, → vesper). The planted bomb is silent, and so are the plant, the defuse, the detonation and an empty magazine. audio.beep is used once, for the buy click, and the sound effect carries one name, step. A pure cues.ts for the quickening beep, the sound at the bomb's position so ears can point at it.
• #45 — scripts/measure.ts (ready, → scout). Nothing measures what comes out of the simulation. Measured by hand for this pass over 12 seeded short matches, 86 rounds: plant 57%, ends detonated 39 · time 25 · elimination 18 · defused 4, median round 128 s, and 6.5 s of CPU a match — which is why it is a script with a pure, tested aggregator, and not a test that plays matches.
• #46 — The retake (waits on #45 and #38, → vesper). 4 defuses against 39 detonations: withBomb presses use only when no terrorist is visible within 1500 units and never looks at the clock, so a CT stands beside a live bomb it could have defused. Judged with #45's table, before and after.

Ready now: #43, #44, #45, alongside the four already open and unassigned or in hand — #38, #39, #40, #41. Blocked: #37 (behind #36), #46. Nothing was parked. Nobody is assigned and #8 stays open.

This was a planning run, so there is no diff: the working tree is clean at 24b2777, bun test is green on it (219 pass, 0 fail), and nothing was committed or pushed — the result is the map on the forge.

Four issues were filed against direction #8 and linked:

• #43 — Paused means paused (ready, → scout). Escape only puts a dialog over a live match: nothing clears running, so the clock runs, the bots shoot and press.clear() leaves you standing still; a hidden tab crawls on the same way. Asks for a headless loop.ts that owns what a frame is worth, and a resume that banks no time.
• #44 — A bomb you can hear (ready, → vesper). The planted bomb, the plant, the defuse, the detonation and an empty magazine are silent; audio.beep is used once for the buy click and the sound effect carries one name. A pure cues.ts for a quickening beep, emitted at the bomb so ears can point a CT at the site.
• #45 — bun run scripts/measure.ts (ready, → scout). Nothing measures the round. Measured by hand over 12 seeded short matches (86 rounds): plant 57%, ends detonated 39 · time 25 · elimination 18 · defused 4, median round 128 s, ~6.5 s of CPU a match — hence a script plus a pure tested aggregator, with bun test staying fast.
• #46 — The retake (waits on #45 and #38, → vesper). 4 defuses against 39 detonations: withBomb presses use only when no terrorist is visible within 1500 units and never weighs the clock.

Ready now: #43, #44, #45, alongside #38, #39, #40, #41 (with #34 and #36 in hand). Blocked: #37 behind #36, #46 behind #45 and #38. Nothing was parked, nobody is assigned, and #8 stays open. A person should look at #43 first — it is a bug every player hits the first time they press Escape.

Budget reached at $2.51; this is where it stopped.

The map for direction #8, fifth pass — and the first thing to say is that the map was not dry. main is still at 24b2777, nothing has merged since the fourth pass, and six issues were already ready to pick up (#38, #39, #40, #41, #43, #44, #45). The constraint on this direction right now is build capacity, not plans: someone should assign or merge before it is planned again.

So this pass is deliberately small — three issues, each read against the code as it stands:

• #51 — Play it fullscreen: the view and the touch pad together (ready, → scout). Nothing in src/ ever calls requestFullscreen, so a phone plays a match in the top third of the screen: chrome, header, a 4:3 #stage, then the pad. The trap is fullscreening #stage alone — that hides the pad and leaves a phone with no buttons — so it takes the wrapper that holds both, and hides the control where the browser cannot do it.
• #49 — The bomb's blast: a lethal core, falloff, armour, and a death the kill feed can name (waits on #44). bomb_timeout sets p.health = 0 for everyone within 1000 units of a 5632-unit map: no falloff, no armour, no credit. #44 left the damage model alone on purpose; this is it. Walls stay irrelevant, as in CS.
• #50 — A match you walk out of stops calling itself "in progress" (waits on #34). toMenu() posts nothing, so a left match sits on the front page as · in progress forever and (live) in the terminal. A third state at the /api/match boundary, one rule for stale rows, and the same word in both renderers.

Ready now: #51, on top of #38, #39, #40, #41, #43, #44, #45. Blocked: #37 (behind #36), #46 (behind #38 and #45), #49 (behind #44), #50 (behind #34). Nothing was parked. Nobody is assigned and #8 stays open.

One thing I checked and did not file: world.effects = world.effects.filter(...) at the end of update looks like an allocation in the training hot loop, but src/rl/arena.ts clears the list every step, so the guard above it means the arena never pays for it.

This was a planning run, so there is no diff: the working tree is clean at 24b2777, bun test is green on it (219 pass, 0 fail), and nothing was committed or pushed.

The first finding is that the map was not dry: main has not moved since the last pass and seven issues were already ready to pick up, so this direction is now limited by build capacity rather than by planning. This pass is therefore three issues, not four, each read against the code:

• #51 — Play it fullscreen: the view and the touch pad together (ready, → scout). Nothing in src/ calls requestFullscreen, so a phone plays in the top third of the screen; the issue insists the wrapper holding both #stage and #touch goes fullscreen, because fullscreening the canvas alone leaves a phone with no buttons.
• #49 — The bomb's blast: a lethal core, falloff, armour, and a death the kill feed can name (waits on #44). bomb_timeout zeroes the health of everyone within 1000 units of a 5632-unit map — no falloff, no armour, no credit.
• #50 — A match you walk out of stops calling itself "in progress" (waits on #34). toMenu() posts nothing, so a left match sits on the front page as · in progress forever and (live) in the terminal.

Ready now: #51, on top of #38, #39, #40, #43, #44, #45 (and #34, #36, #41 in hand). Blocked: #37, #46, #49, #50. Nothing was parked, nobody is assigned, and #8 stays open. One candidate I checked and dropped: the per-tick world.effects filter is not an allocation the training arena pays for, because src/rl/arena.ts clears the list every step.

The map for direction #8, sixth pass, read against bec9bbb — #41 landed as pull #48, so serve() is now an export, .checkdata/game.html is out of git and GET /api/leaderboard answers JSON. Builders are on #34, #36, #43 and #44, and five issues were still ready when I started, so this pass is again small: two issues and some map hygiene.

Opened:

• #55 — The bomb before it is planted: who is carrying it, and where it fell (ready, → scout). buildRadar adds a bomb blip only when the state is planted, teammates are anonymous dots, and hud.ts says · bomb for the person alone — so a side that drops the bomb is four people hunting an invisible object on a running clock. A carrier blip and a dropped-bomb blip, for terrorists only, and one HUD line. No enemies on the radar, ever.
• #56 — The terminal is untestable (ready, → scout). src/tty.ts opens the database, takes raw mode, attaches stdin and paints at module level, so it cannot be imported by a test and the app's second door has no tests at all. The same split #41 just did on the server, plus the first src/tty.test.ts. This is what makes #40's asked-for test possible.

Hygiene, because the map had grown a double:

• #54 (vesper) asks for exactly what #40 (trevato) asks for — the identity check on the terminal's x. I copied #54's detail onto #40 and commented on #54 saying so, but my credentials cannot close another author's issue: someone should close #54. #40 now waits on #34 (rows only carry a verified identity once it lands) and on #56 (its acceptance criterion is a test that cannot be written today).
• #50 got a note: GET /api/leaderboard means the third match state has to be right in three renderers now, not two.

Ready now: #38, #39, #45, #51, #55, #56. Blocked: #37 (#36), #40 (#34, #56), #46 (#38, #45), #49 (#44), #50 (#34), #53 (#34). Nothing is parked. Nobody is assigned and #8 stays open.

This was a planning run against direction #8: the working tree is clean at 24b2777, nothing was committed or pushed, and the result is the map on the forge. I checked the default branch while I was there — main at bec9bbb (pull #48, the serve() split and GET /api/leaderboard) is green, 220 tests passing.

Two issues filed, read against bec9bbb:

• #55 — The bomb before it is planted: who is carrying it, and where it fell (ready, → scout). buildRadar only shows the bomb once it is planted and teammates are anonymous dots, so a terrorist side that drops the bomb is four people hunting an invisible object on a running clock. A carrier blip and a dropped-bomb blip for terrorists only, plus one HUD line; no enemies on the radar, ever.
• #56 — The terminal is untestable (ready, → scout). src/tty.ts opens the database, takes raw mode, attaches stdin and paints at module level, so it cannot be imported by a test and the app's second door has no tests at all — which is why #40's asked-for "a guest cannot delete" test cannot be written yet. The same split #41 just did on the server, plus the first src/tty.test.ts.

Map hygiene, which was the other half of this pass: #54 duplicates #40 (both want the identity check on the terminal's x). I folded #54's detail — the FORGE_APP_USER_* variables and the three cases — onto #40 and commented on #54 saying so, but my credentials cannot close another author's issue, so a person should close #54. #40 now waits on #34 and on #56. #50 got a note that GET /api/leaderboard makes the third match state a three-renderer change.

Ready now: #38, #39, #45, #51, #55, #56 (with #34, #36, #43, #44 in hand). Blocked: #37, #40, #46, #49, #50, #53. Nothing is parked, nobody is assigned, and #8 stays open. The constraint on this direction is still build capacity rather than plans — six ready issues are waiting for someone to pick them up.

The map for direction #8, seventh pass, read against 6aa9c82 — #36 landed as pull #47, so the HE grenade, grenades.ts and a fourth slot are in, and #37 (smoke) is ready behind it. Builders are on #34, #43, #44 and #56; six issues were ready when I started, so this pass is two issues and a correction.

Opened:

• #59 — Rebuy: one button that buys what you had last round (ready, → scout). Up to twenty-four freeze times a match and renderBuy is the only way to spend money: no rebuy, no autobuy, nothing remembering what you died holding. A remembered loadout on the player, a pure decision that spends the wallet in priority order, a button with the total on it and a key that skips the panel.
• #58 — Bots buy and throw a grenade (waits on #38, → vesper). #36 left the bots out on purpose, so a $300 item that does 98 damage at its centre is a button only the person has, five against one. The hard part is not the throw: the arena builds its world with createWorld and its foe with botThink, so a bot that buys and throws rewrites the environment the shipped weights were trained against — the issue asks for a gate and an arena test that world.grenades stays empty across an episode.

Corrected, because the code moved under it:

• #49 (the bomb's blast) now has a neighbour to follow instead of inventing one: grenades.ts exports blastDamage, so the bomb's falloff should be that function with the bomb's own radius, not a second blast rule.

Still waiting on a person: #54 should be closed as a duplicate of #40 — I commented to that effect last pass but my credentials cannot close another author's issue.

Ready now: #37, #38, #39, #45, #51, #55, #59. Blocked: #40 (#34, #56), #46 (#38, #45), #49 (#44), #50 (#34), #53 (#34), #58 (#38). Nothing is parked. Nobody is assigned and #8 stays open.

This was a planning run against direction #8: the working tree is clean at 24b2777, nothing was committed or pushed, and the result is the map on the forge. main at 6aa9c82 (pull #47, the HE grenade) is green — 239 tests, 0 fail.

Two issues filed, read against the code as it now stands:

• #59 — Rebuy: one button that buys what you had last round (ready, → scout). A competitive match is up to twenty-four freeze times and renderBuy is the only way to spend money: no rebuy, no autobuy, nothing remembering what you died holding. Asks for a remembered loadout on the player, a pure decision that spends the wallet in priority order (armour before the rifle when both will not fit), a button with the total on it and a key that skips the panel.
• #58 — Bots buy and throw a grenade (waits on #38, → vesper). #36 left the bots out on purpose, so a $300 item doing 98 damage at its centre is a button only the person has, five against one. The trap is not the throw: the arena builds its world with createWorld and its foe with botThink, so a bot that buys and throws rewrites the environment the shipped weights were trained against — the issue asks for a gate plus an arena test that world.grenades stays empty across an episode.

Also done: #49 was corrected now that grenades.ts exports blastDamage — the bomb's falloff should be that function with the bomb's own radius, not a second blast rule. And #54 still needs a person to close it: it duplicates #40, which now carries its detail; my credentials cannot close another author's issue.

Ready now: #37, #38, #39, #45, #51, #55, #59 (with #34, #43, #44, #56 in hand). Blocked: #40, #46, #49, #50, #53, #58. Nothing is parked and #8 stays open.

Eighth pass, and no new issues — that is the finding. main is still at 6aa9c82, nothing has merged since the last pass, seven issues are ready and four are in hand. Adding more plans to a backlog nobody can consume would make the map worse, not better, so this run went into checking that what is already on it is still true after #47.

What I did:

• Re-measured the baseline on 6aa9c82, 6 seeded short matches, 41 rounds: plant 56%, ends detonated 17 · time 12 · elimination 9 · defused 3, median round 128 s, ~6.4 s of CPU a match. #45's stated figures still stand and #46's one-in-ten defuse rate is unchanged by the grenade merge; both issues now say so.
• #39 corrected: #47 added a third source of damage, so the round's ledger has three call sites — applyHit in shoot, the blast loop in world.ts which applies damage itself and calls onKill with "he", and bomb_timeout. A ledger hooked only into applyHit would miss every grenade kill and disagree with the kill feed beside it.
• #37 corrected: Player.grenades is a single count capped at one and he is one id on slot 4, so smoke cannot be a second counter — the pocket has to become per-kind and slot 4 needs a stated rule. And the flight is already owned by grenades.ts with Grenade.kind as the seam; the HE's visible check is not what a cloud wants.
• #49 was corrected last pass for the same reason (reuse blastDamage).

Still waiting on a person: #54 should be closed as a duplicate of #40 (my credentials cannot close another author's issue), and the seven ready issues need picking up — #43 (a live match under the pause overlay) and #44 (a silent planted bomb) are the two a player notices first.

Ready now: #37, #38, #39, #45, #51, #55, #59. Nothing is parked, nothing was added, and #8 stays open.

This was a planning run and deliberately filed nothing: main is unchanged at 6aa9c82, seven issues are already ready and four are in hand, so adding more plans would make the map worse rather than better. The working tree is clean at 24b2777 and nothing was committed or pushed.

What the run produced instead is verification that the existing map is still true after #47:

• Baseline re-measured on 6aa9c82 — 6 seeded short matches, 41 rounds: plant 56%, ends detonated 17 · time 12 · elimination 9 · defused 3, median round 128 s, ~6.4 s of CPU a match. #45's figures still stand and #46's one-in-ten defuse rate is unchanged; both issues now carry the re-measurement.
• #39 corrected: #47 added a third damage path, so the round ledger has three call sites — applyHit in shoot, the blast loop in world.ts (which applies damage itself and calls onKill with "he"), and bomb_timeout. A ledger hooked only into applyHit would miss every grenade kill.
• #37 corrected: Player.grenades is one count capped at one and he is a single id on slot 4, so smoke cannot be a second counter — the pocket must become per-kind and slot 4 needs a stated rule; the flight is already grenades.ts's with Grenade.kind as the seam, and the HE's visible check is not what a cloud wants.

Two things need a person: #54 should be closed as a duplicate of #40 (my credentials cannot close another author's issue), and the ready queue needs picking up — #43 (the match runs on under the pause overlay) and #44 (the planted bomb is silent) are the two a player hits first. Ready now: #37, #38, #39, #45, #51, #55, #59. Nothing is parked and #8 stays open.

Ninth pass, read against fccb9eb — #44 landed as pull #57 (the bomb beeps, cues.ts) and #51 as pull #62 (fullscreen.ts). main is green: 252 tests, 0 fail. #49 came off its blocker with #44 and is ready.

Opened, one issue, because seven were already ready:

• #63 — Radio: three calls the person can make, and four teammates who actually go (waits on #38, → vesper). brain.site = siteFor(world.plan, bot.team, slotOf(...)) at bots.ts:375 means four teammates commit to a site rolled from the seed and nothing the person does can move them — you can watch your team walk to B while you stand in A with the bomb, every round. Three calls (go A, go B, hold), the override living in plan.ts rather than deep in bots.ts because that file is contended, and the default path byte-identical so the arena's numbers do not move.

Hygiene, which was most of this pass:

• The terminal's x is now asked for three times — #40 (trevato), #54 (vesper) and #61 (sentinel). I folded #61's fresher facts onto #40 (the tty.ts:106 call site, identity = user:<forge id> after pull #42, the README-as-decision bar, the failing test) and commented on #61 saying so. #40 is the one to build: it carries the edges to #34 and #56. #54 and #61 want closing — my credentials cannot close another author's issue.
• #49 now says what to inherit from #44 rather than invent: the explode sound is already pushed in bomb_timeout, and blastDamage is the falloff to reuse — with the bomb still ignoring walls, unlike the HE.

Ready now: #37, #39, #45, #49, #55, #59, #61 — and #38 and #56 are in hand, #34 and #43 with vesper. Blocked: #40, #46, #50, #53, #58, #63. Nothing is parked and #8 stays open.

This was a planning run: the working tree is clean, nothing was committed or pushed, and the map on the forge is the result. main at fccb9eb is green — 252 tests, 0 fail — after #44 (pull #57, the bomb beeps and cues.ts) and #51 (pull #62, fullscreen.ts) landed; #49 came off its blocker as a result.

One issue filed, since seven were already ready:

• #63 — Radio: three calls the person can make, and four teammates who actually go (waits on #38, → vesper). brain.site = siteFor(world.plan, bot.team, slotOf(...)) at bots.ts:375 means four teammates commit to a seed-rolled site and nothing the person does can move them — you can watch your team walk to B while you stand in A holding the bomb. Three calls (go A, go B, hold), with the override in plan.ts rather than deep in the contended bots.ts, and the no-call path left byte-identical so the training arena's numbers do not move.

Most of the pass was hygiene: the terminal's x is now asked for three times — #40 (trevato), #54 (vesper) and #61 (sentinel). I folded #61's fresher facts onto #40 (the tty.ts:106 call site, identity = user:<forge id> after pull #42, the README-as-decision bar, the failing test), commented on #61 saying so, and left #40 as the one to build since it carries the edges to #34 and #56. #54 and #61 need a person to close them — I cannot close another author's issue. #49 also gained a note to inherit blastDamage and the already-pushed explode sound instead of inventing either.

Ready now: #37, #39, #45, #49, #55, #59, #61, with #38 and #56 in hand and #34 and #43 with vesper. Blocked: #40, #46, #50, #53, #58, #63. Nothing is parked and #8 stays open.

The map for direction #8, tenth pass, read against 42c7b16 (#49 landed as pull #66, the bomb blast) — 303 tests green, / in 10 ms. Builders are moving again (pulls #60, #64, #65 open), so this pass is four issues, aimed at what the code shows is fragile, unreachable or silent.

Opened, in order:

• #68 — The view comes back: survive a lost WebGL context (ready, → vesper). Nothing in src/ listens for webglcontextlost or calls preventDefault on it, so a phone that loses its context is a black canvas with a match still running at 64 Hz behind it — and without that preventDefault the browser never even tries to restore. Asks for one function that owns every GL resource and can build them all again.
• #69 — Bind your own keys: WASD is not everyone's WASD (ready, → scout). KEY_ACTIONS at input.ts:46 is a constant; on AZERTY the strafe keys are on the wrong hand shape and the arrows cost you the hand that aims. Bindings into settings.ts with parseSettings as the boundary, a capture panel in the menu and the pause overlay.
• #70 — The gun says what it is doing (waits on #68, → vesper). The view model bobs and kicks and does nothing else: no muzzle flash anywhere in the game, yours or anyone else's, no visible reload, no raise on a switch. Visual only — no deploy rule, nothing the RL arena can observe. It waits on #68 because that issue restructures how createRenderer owns its resources.
• #71 — A refresh does not end your match (waits on #50, → scout). boot() always lands on the menu; a stray Cmd-R throws away up to half an hour, while the server keeps a row saying in progress for a match nobody can rejoin. A validated snapshot in saved.ts, a resume at the freeze time of the round you were in, posted under the same matchId.

Ready now: #37, #50, #53, #54, #55, #59, #61, #68, #69. Blocked: #40, #46, #58, #63, #70, #71. Nothing is parked. Still waiting on a person: #54 and #61 duplicate #40 and want closing — my credentials cannot close another author's issue. Nobody is assigned and #8 stays open.

This was a planning run: no files were created and nothing was committed, so the working tree is clean at 42c7b16 (the branch simply matches main, which is green at 303 tests). The result is the map on the forge.

Four issues were filed against direction #8 and linked:

• #68 — The view comes back: survive a lost WebGL context (ready, → vesper). Nothing in src/ listens for webglcontextlost or calls preventDefault on it, so a phone that loses its GL context gets a black canvas with the match still stepping at 64 Hz behind it — and without that preventDefault the browser never attempts a restore at all.
• #69 — Bind your own keys: WASD is not everyone's WASD (ready, → scout). KEY_ACTIONS at input.ts:46 is a constant; on AZERTY the strafe keys land on the wrong hand shape and the arrows cost you the hand that aims. Bindings move into settings.ts with parseSettings as the boundary, plus a capture panel in the menu and the pause overlay.
• #70 — The gun says what it is doing (waits on #68, → vesper). The view model bobs and kicks and nothing else: no muzzle flash anywhere in the game, no visible reload, no raise on a switch. Visual only, nothing the RL arena can observe; it waits on #68 because that issue restructures how createRenderer owns its resources.
• #71 — A refresh does not end your match (waits on #50, → scout). boot() always lands on the menu, so one stray reload discards up to half an hour while the server keeps a row saying in progress for a match nobody can rejoin. A validated snapshot in a new saved.ts, resumed at the freeze time of the round you were in, posted under the same matchId.

Ready now: #37, #50, #53, #54, #55, #59, #61, #68, #69. Blocked: #40, #46, #58, #63, #70, #71. Nothing is parked, nobody is assigned, and #8 stays open. Two things want a person: #54 and #61 duplicate #40 and should be closed (I cannot close another author's issue), and #68 is the one to pick up first — it is the only open bug that can end a match with no way back.

Budget reached at $2.54; this is where it stopped.

The map for direction #8, eleventh pass, read against f9dc23a (#38 landed as pull #64 — difficulty is a validated setting and world.difficulty exists). 311 tests green. Nine issues were already ready when I started, so this pass is three, and all three are about depth rather than polish: the bots cannot hear you, and there is only one place to play.

Opened, in order:

• #72 — The bots have ears (ready, → vesper). listen() at bots.ts:272 is the whole of bot hearing: an enemy who fired inside 0.25 s and 2200 units, read straight off lastShotAt, through walls, at the same volume whatever the gun. Since #21 the world pushes a footstep every stride — suppressed while walking or ducking — and since #44 seven more sounds, and no bot has ever read one. So sprinting behind a bot is exactly as safe as walking and <kbd>Shift</kbd> buys nothing. Asks for a pure hearing.ts (falloff, a wall costing distance, an error that grows with range) with the arena provably unchanged and nothing added to observe.ts.
• #73 — One map, held as a value (ready, → vesper). map.ts builds grid, boxes, spawns and sites at import time and nine modules reach through the module for them, so exactly one map can exist in a process. A MapDef, a buildMap(layout), DE_FORGE as the value, and world.map as the only place anything asks — judged by de_forge playing identically and the arena's numbers not moving.
• #74 — A second map, chosen before the match (waits on #73, → vesper). One more layout in the same shape, a picker beside the difficulty select, remembered in settings and validated there; bots path it with no special case; the arena keeps training on DE_FORGE only and the pull says the policy has never seen the new map.

Also noted on the issues themselves: #72 should not run alongside #58 or #63 (all three edit bots.ts), and #73 should be picked up when no other simulation pull is open, because it edits seven files at once.

Ready now: #37, #53, #54, #55, #58, #59, #61, #63, #69, #72, #73 — with #39, #45, #50, #56 and #68 in hand. Blocked: #40, #46, #70, #71, #74. Nothing is parked. Still waiting on a person: #54 and #61 duplicate #40 and want closing. Nobody is assigned and #8 stays open.

This was a planning run: no files were created and nothing was committed, so the branch sits clean at f9dc23a — even with main, which is green (311 tests, 0 fail) after #38 landed as pull #64. The result is the map on the forge.

Nine issues were already ready when I started, so this pass is three, and all three are depth rather than polish:

• #72 — The bots have ears: footsteps, a plant and a grenade at their feet pull them round (ready, → vesper). listen() at bots.ts:272 is the whole of bot hearing — an enemy who fired within 0.25 s and 2200 units, read straight off lastShotAt, through walls, at the same volume whatever the gun. The world has pushed a footstep every stride since #21 (silent while walking or ducking) and seven more sounds since #44, and no bot has ever read one, so sprinting up behind a bot is exactly as safe as walking. Asks for a pure hearing.ts with falloff, a wall costing distance and an error that grows with range, the RL arena provably unchanged and nothing added to observe.ts.
• #73 — One map, held as a value (ready, → vesper). map.ts builds grid, boxes, spawns and sites at import time and nine modules reach through the module for them, so exactly one map can exist in a process. A MapDef, a buildMap(layout), DE_FORGE as the value and world.map as the only place anything asks — judged by de_forge playing identically.
• #74 — A second map, chosen before the match (waits on #73, → vesper). A second layout, a picker beside the difficulty select validated the way difficulty is, bots pathing it with no special case, and the arena still training on DE_FORGE only.

Both ready issues carry a sequencing comment: #72 should not run alongside #58 or #63 (all three edit bots.ts), and #73 wants a window with no other simulation pull open, since it edits seven files at once. My first attempt at those two comments was posted with the backticked words eaten by the shell; the corrected text is the comment beneath each.

Ready now: #37, #53, #54, #55, #58, #59, #61, #63, #69, #72, #73, with #39, #45, #50, #56 and #68 in hand. Blocked: #40, #46, #70, #71, #74. Nothing is parked, nobody is assigned, and #8 stays open. Two things still want a person: #54 and #61 duplicate #40 and should be closed, and #68 (a lost WebGL context ends a match with no way back) remains the first thing to pick up.

The map for direction #8, twelfth pass, read against 861e20b — #68 landed as pull #75 (the renderer survives a lost context, build(gl): Gpu) and #56 as pull #60 (the terminal is a module with a test). 332 tests green; / answers in 2–6 ms and the bundle is 92 KB, cached for a year.

Thirteen issues were already ready when I started, with two pulls open. So this pass is deliberately one issue and four corrections — a deeper backlog would make the map worse, not better.

Opened:

• #77 — Motion you did not ask for: honour prefers-reduced-motion where it is decoration, and nowhere else (ready, → scout). matchMedia appears once in the whole client, for pointer: coarse; nothing reads the motion query and there is no setting. The issue draws the line explicitly: the bob, the vignette's pulse, the wedge fade and the spectate swing can go; the recoil punch, the flinch and the crosshair cannot — a view that does not kick is an aim advantage, not an accessibility feature.

Corrected, because the code moved under them:

• #70 (the muzzle flash) is ready now, and its resources belong in #75's build(gl) or a restore comes back without them; renderer.test.ts already has the listener-capable canvas it needs.
• #73 (map as a value): "baked from a map" now means keyed inside Gpu, so a map switch and a context restore take the same path.
• #40 (the terminal's x): both blockers have landed, so the test it asks for is writable today. It is the one to build of the three — #54 and #61 are duplicates and still need a person to close them.
• #69 (key bindings): settings.ts gained difficulty with a guard-and-fallback per value; the bindings map should follow that shape exactly.

Ready now: #37, #40, #53, #54, #55, #58, #59, #61, #63, #69, #70, #72, #73, #77 — with #39, #45 and #50 in hand. Blocked: #46, #71, #74. Nothing is parked. Nobody is assigned and #8 stays open. The constraint on this direction is build capacity, not plans: fourteen issues are waiting to be picked up, and #40 is the one with a security label on it.

This was a planning run: no files were created and nothing was committed, so the branch sits clean at 861e20b, even with main — which is green at 332 tests after #68 landed as pull #75 (the renderer now survives a lost context, with every GL resource owned by build(gl)) and #56 as pull #60 (the terminal is a module with its first test). The page answers in 2–6 ms and the bundle is 92 KB, cached for a year.

Thirteen issues were already ready with only two pulls open, so this pass is one issue and four corrections rather than four new plans:

• #77 — Motion you did not ask for: honour prefers-reduced-motion where it is decoration, and nowhere else (ready, → scout). matchMedia appears once in the entire client, for pointer: coarse; nothing reads the motion query and there is no setting. The issue draws the line explicitly — the weapon bob, the vignette's pulse, the damage wedge's fade and the spectate camera's swing can go; the recoil punch, the flinch and the crosshair cannot, because a view that does not kick is an aim advantage rather than an accessibility feature.

Corrections, because the code moved under them: #70 is ready now and its flash mesh belongs inside #75's build(gl) or a restored context comes back without it; #73 now means "keyed inside Gpu" when it says anything baked from a map is keyed by it; #40's two blockers have both landed, so the "a guest cannot delete someone else's row" test it asks for is writable today; #69 should follow the guard-and-fallback shape difficulty introduced in settings.ts.

Ready now: #37, #40, #53, #54, #55, #58, #59, #61, #63, #69, #70, #72, #73, #77, with #39, #45 and #50 in hand; blocked: #46, #71, #74. Nothing is parked and #8 stays open. Two things want a person: #54 and #61 duplicate #40 and should be closed, and the queue needs picking up — this direction is limited by build capacity, not by plans, and #40 is the one carrying a security finding.

The map for direction #8, thirteenth pass, read against 861e20b with 332 tests green, / answering in 1–2 ms locally and the bundle at 92 KB. Three pulls are open (#65, #67 with changes requested, #76 with a conflict) and fourteen issues were already ready, so this pass looks for what the queue does not cover rather than adding more of the same.

What it does not cover is the two oldest untested things in the client and the one CS habit the game still refuses.

Opened, in order:

• #78 — The geometry nothing tests: trace.ts gets its first test, and reports the exit fraction it already computes (ready, → scout). Every bullet, sight line, grenade LOS and bot sight call goes through 63 lines with no test file beside them. One production change inside it: rayBox computes tMax and discards it.
• #79 — A bullet through a crate: penetration a rifle has and a pistol does not (waits for #78, → vesper). traceBullet stops at the first solid, so cover is binary and the AWP wallbangs nothing. Crates only, one surface a shot, thickness from the exit fraction #78 returns — and visible() untouched, because the policy's 32 inputs are the shipped weights' contract.
• #80 — audio.ts has never been tested: a recording AudioContext (ready, → vesper). Three hundred lines carrying the pan, the mute, the volume, the pain throttle and the bomb's beep pitch, while renderer and hud both have recording contexts. The harness and the tests only: the sound does not change.
• #81 — Your crosshair: colour, size, gap, thickness and a dot, remembered like the rest (ready, → scout). hud.ts:237-246 is four hard-coded green arms. A pure crosshair.ts, a guarded settings group shaped like difficulty, a colour from a list rather than free text into ctx.strokeStyle, and defaults that reproduce today's crosshair exactly.

Ready now: #37, #40, #53, #54, #55, #58, #59, #63, #69, #70, #72, #73, #77, #78, #80, #81, with #39, #45 and #50 in hand. Blocked: #46, #71, #74, #79. Nothing is parked.

Two things still want a person, unchanged from last pass: #54 and #61 duplicate #40 and should be closed, and the queue needs picking up — this direction is limited by build capacity rather than by plans. Nobody is assigned, nothing is pushed, and #8 stays open.

A planning run: the clone is untouched and sits clean at 861e20b, so there is nothing to push and no pull to open. I read the repository (332 tests green, / answering in 1–2 ms, bundle 92 KB), the fourteen issues that were already ready and the three open pulls, and filed what the queue does not cover — the two oldest untested things in the client, and the one CS habit the game still refuses.

Opened, in order:

• #78 — The geometry nothing tests: trace.ts gets its first test, and reports the exit fraction it already computes (ready, suggest scout). Every bullet, sight line, grenade line-of-sight and bot sight call goes through 63 lines with no test beside them; rayBox already computes tMax and throws it away.
• #79 — A bullet through a crate: penetration a rifle has and a pistol does not (waits for #78, suggest vesper). Crates only, one surface a shot, thickness from the exit fraction #78 returns, and visible() untouched because the policy's 32 inputs are the shipped weights' contract.
• #80 — audio.ts has never been tested: a recording AudioContext, the way the renderer has a recording GL context (ready, suggest vesper). The harness and the tests only — the pan, the mute, the volume, the pain throttle and the beep pitch get pinned, and nothing changes how it sounds.
• #81 — Your crosshair: colour, size, gap, thickness and a dot, remembered like the rest (ready, suggest scout). hud.ts:237-246 is four hard-coded green arms; a pure crosshair.ts, a guarded settings group shaped like difficulty, a colour from a list rather than free text into ctx.strokeStyle, and defaults that reproduce today's crosshair exactly.

Ready now: #37, #40, #53, #55, #58, #59, #63, #69, #70, #72, #73, #77, #78, #80, #81, with #39, #45 and #50 in hand and #46, #71, #74, #79 blocked. Nothing is parked, nobody is assigned, and #8 stays open. Two things want a person: #54 and #61 duplicate #40 and should be closed, and the queue itself — this direction is limited by build capacity rather than by plans.

The map for direction #8, fourteenth pass, read against 5921387. The first thing to report is that main is red and production is a commit behind: bun test on the merge of #83 fails (Export named 'spawns' not found in module map.ts), the deploy run for 5921387 came back test: test exited with code 1, and the app serving at production is still 5324a7c. #82 deleted the map singletons, #83 was branched before it, both were green on their own branches, and the merge is not.

Opened, in order:

• #85 — The check is red on main (ready, → scout). One test file, three imports, the count back above 346. Urgent and small.
• #86 — Nothing type-checks: a strict tsc --noEmit in front of the tests (waits on #85, → scout). I ran the probe: strict TypeScript with @types/bun finds sixteen errors in 14,000 lines, two of them real — renderer is possibly null where frame() calls setScale and draw (the hole left in #75's recovery path), and openBuy(buyPanel.hidden) passes string | boolean. The rest are partial fixtures in test files. This is the check that would have caught today's break before it merged; it costs two dev dependencies and the app's runtime stays at zero.
• #87 — The buy menu says why you cannot buy it, and moves out of main.ts (ready, → scout). renderBuy rebuilds innerHTML and re-attaches every listener on each purchase, and too poor, wrong side, already owned and freeze-time-over all look like the same grey button. A pure buy.ts with reasons and the freeze clock in the header. #59 (rebuy) now waits on it, because both live in that panel.
• #88 — Players that read as players: legs that swing on the stride the footsteps already count (ready, → vesper). playerMesh() is one rigid mesh and renderer.ts draws it with a yaw and a duck squash, so a player at a dead stop and one at 250 u/s are the same picture. The phase exists already: p.stepDistance. One draw per player stays one draw per player, and observe.ts is not touched.

Ready now: #85, #87, #88, plus #37, #40, #46, #53, #55, #58, #63, #69, #70, #72, #73, #74, #77, #79, #80, #81, with #39 and #50 in pulls. Blocked: #59, #71, #86. Nothing is parked.

One thing still wants a person, and I could not do it myself: #54 and #61 duplicate #40 — I left a comment on each saying so, but my token lacks the scope to close another author's issue. And the queue: nineteen ready issues against two slots means this direction is limited by build capacity, not by plans. #8 stays open, nobody is assigned, and nothing was pushed.

The tree is clean at 5921387 — no files written, no commits, so there is nothing to push and no pull for this run. The planning work landed in the forge: four issues and a map comment on #8.

A planning run for direction #8: nothing in the repository changed, and the result is the issue map. The finding that matters is that main is red and production is a commit behind — bun test at 5921387 fails with Export named 'spawns' not found in module src/client/map.ts (346 pass, 1 fail), the deploy run for that commit returned test: test exited with code 1, and the app serving production is still 5324a7c. #82 deleted the map singletons, #83 was branched before it; both were green alone and the merge is not.

Filed, in order: #85 the red check (ready, scout); #86 a strict tsc --noEmit in front of the tests, which I probed — sixteen errors in 14,000 lines, two of them real bugs in main.ts (waits on #85, scout); #87 the buy menu saying why a button is dead, lifted out of main.ts into a tested module, with #59 now waiting on it (ready, scout); #88 players whose legs swing on the stepDistance stride the footsteps already count (ready, vesper).

What a person should look at: #85 first, because it is between main and green; then #54 and #61, which duplicate #40 and need closing by someone with the scope to do it (I commented on both and could not). Local checks I ran and would not change: / answers in 15 ms with the full security floor, GET /api/leaderboard answers, and the only failing test in the suite is the one #85 describes.

Budget reached at $2.55; this is where it stopped.

The map for direction #8, fifteenth pass, read against e973e0b — main is green again (363 pass, 0 fail), #67 landed (the round damage report) and production has caught up, so #85 is closed. / answers in 2 ms with the full security floor and GET /api/leaderboard answers.

Eighteen issues were already ready, so this pass is three, and all three are about the one thing the queue does not cover: nothing in this repository measures the 60 fps the direction asks for, and nothing on screen tells you who anyone is.

Opened, in order:

• #89 — What a frame costs, counted: a draw-call budget the recording GL context enforces (ready, → vesper). renderer.draw issues one draw for the level, one per player, one per body, one per pickup (MAX_PICKUPS = 24), one per grenade, one for the bomb, one batched line draw and one view model — roughly fifty in a late round, each with a uniform upload, and nothing counts them. #70 and #88 both add per-player work to that exact loop. renderer.test.ts already has the recording context, so the count is free to take.
• #90 — bun run scripts/cost.ts: what a tick of the simulation costs (ready, → scout). I measured it while planning: 7,680 ticks of a 10-player SHORT world cost mean 0.138 ms, p99 0.332 ms, max 3.21 ms against the 15.6 ms a 64 Hz tick is allowed. The simulation is ~1% of a frame and the renderer owns the rest — worth writing down, because it is the number a change to bots.ts or trace.ts can quietly ruin. Mirrors #65's shape, with one generous wall-clock bound in the check.
• #91 — Who is that: a name over the player you can see, health when they are yours, and a project.ts that can place it (ready, → vesper). Names live in the kill feed, the held-Tab scoreboard and the spectate line — never on the player in front of you, and a teammate's health exists nowhere else. The missing piece is general: nothing in the client turns a world point into a screen point, and drawHud (hud.ts:214) is never given the Camera that main.ts:491 already builds. The no-wallhack rule — a plate only for a player the eye can trace to, alive, in the frustum — is the point of the issue, with a test that puts a player behind a box.

Hygiene: #85 is closed (trace.test.ts imports DE_FORGE, the suite is green). #86 re-probed and corrected — strict tsc --noEmit finds eight errors now, not sixteen, and only three are production: main.ts:240 (string | boolean into openBuy) and main.ts:504/:507 (renderer possibly null, the hole in #75's recovery path); it is ready now that #85 is closed. I tried again to close #54 and #61 as duplicates of #40 and the forge refused: your credentials lack the scope for this action — a person has to do those two.

Ready now: #89, #90, #91, #86, plus #37, #40, #46, #53, #54, #55, #58, #59, #61, #63, #69, #70, #72, #74, #77, #79, #80, #81, #87, #88 — with #50 in pull #76. Blocked: #71. Nothing is parked, nobody is assigned, and #8 stays open. The constraint on this direction is still build capacity: twenty-odd ready issues against one open pull.

Nothing to land in the repository: this was a planning run, the working tree is clean at e973e0b (even with main), and bun test there is green — 363 pass, 0 fail. No files were created, nothing was committed, so there is nothing to push and no pull to open. The result is the map on the forge.

Filed against direction #8, all three ready and unblocked:

• #89 — What a frame costs, counted: a draw-call budget the recording GL context enforces (suggest vesper). renderer.draw issues one draw for the level, one per player, one per body, one per pickup (MAX_PICKUPS = 24), one per grenade, one for the bomb, one batched line draw and one view model — about fifty in a late round with a uniform upload each — and nothing counts them, while #70 and #88 both add per-player work to that same loop.
• #90 — bun run scripts/cost.ts: what a tick of the simulation costs (suggest scout). Measured while planning: 7,680 ticks of a 10-player SHORT world cost mean 0.138 ms, p99 0.332 ms, max 3.21 ms against the 15.6 ms a 64 Hz tick is allowed, so the simulation is ~1% of a frame and the script is a regression alarm with one generous wall-clock bound.
• #91 — Who is that: a name over the player you can see, health when they are yours, and a project.ts that can place it (suggest vesper). Nothing in the client turns a world point into a screen point and drawHud is never handed the Camera that main.ts:491 already builds; the no-wallhack rule — a plate only for a living player the eye can trace to — is the acceptance criterion the issue is built around.

Hygiene in the same pass: #85 closed (fixed on main), and #86 corrected — strict tsc --noEmit now finds eight errors, not sixteen, only three of them production (main.ts:240 passing string | boolean into openBuy, and renderer possibly null at :504/:507), and it is ready now that #85 is closed. The typecheck probe installed typescript locally; that was reverted, so package.json and the lockfile are untouched.

What a person should look at: #54 and #61 duplicate #40 and still need closing — the forge answered my close attempt with your credentials lack the scope for this action — and the queue itself, which is twenty-odd ready issues against one open pull (#76). Nobody is assigned and #8 stays open.

Budget reached at $2.50; this is where it stopped.

The map for direction #8, sixteenth pass, read against b97de2f — main is green (369 pass, 0 fail), #87 landed as pull #92, and the app answers / in 17 ms cold with the whole security floor, /api/leaderboard in milliseconds, a malformed result with 422 and an unknown path with 404. Twenty-five issues were already ready, so this pass went looking for what none of them cover, and found two things a demanding visitor pays for directly and two that are rules with no test under them.

Opened, in order:

• #94 — The bundle arrives compressed: 96 KB of JavaScript is 41 KB on the wire (ready, → scout). Measured on the running app: GET /static/app.3a6dc721d2.js with accept-encoding: gzip, br answers 96,506 bytes and no content-encoding; the same bytes gzip to 40,851. The first paint's HTML (14,236 bytes) is uncompressed too. The asset is immutable, so its gzip is computed once at start-up beside the build; the page's is negotiated per request with a measured cost in the pull. Bun.gzipSync is already there, so it costs no dependency.
• #95 — Your own row on the board, wherever you rank (waits on #50, → scout). standings(db, 10) ends in LIMIT ?1 (db.ts:136), so the board is the top ten and nothing else: a player sitting eleventh sees a table they are not in, with no rank and no record. One query for rank-by-count, the row pinned under the table, a you field on /api/leaderboard, and the identity string still never travelling. It waits on #50 because pull #76 rewrites the same rows and the same statsHtml.
• #96 — What the ear is allowed to hear moves out of main.ts: a tested hearing.ts (ready, → vesper). main.ts has no test file at all, and feelEffects (main.ts:424–451) is where four rules live: the earshot ceilings for a step, a dry trigger, a plant and a defuse; that the beep and the blast carry everywhere; that sound is heard from the camera's ears and not from your corpse while spectating; and that hurt is only ever the local player's. Same move #87 just made with the buy menu.
• #97 — The round history strip: which rounds you lost, and how (ready, → vesper). MatchState keeps winner and reason for the round that just ended and nothing before it (match.ts:52), so by round seven the match has no memory — you cannot see that three went to the clock and the only round you took was a defuse. endRound already produces every number it needs; the HUD gets one mark a round under the score bar, and it has to fit at 360 px and at thirty rounds.

Ready now: #94, #96, #97, plus #37, #40, #46, #53, #54, #55, #58, #59, #61, #63, #69, #70, #72, #74, #77, #79, #80, #81, #86, #88, #89, #90, #91 — with #50 in pull #76. Blocked: #71, #95. Nothing is parked.

Hygiene, unchanged from last pass and still wanting a person: #54 and #61 duplicate #40 and my token cannot close another author's issue. A probe issue (#93) created while finding that this API refuses urllib but accepts curl was closed immediately. Nobody is assigned, nothing was pushed, and #8 stays open.

The working tree is clean at b97de2f and bun test there is green (369 pass, 0 fail), so this planning run wrote no files and there is nothing to push. The result is the map on the forge.

Filed against direction #8, read against the running app:

• #94 — The bundle arrives compressed: 96 KB of JavaScript is 41 KB on the wire (ready, suggest scout). Measured on the app: the bundle URL answers 96,506 bytes with no content-encoding even when the request offers gzip, and those bytes gzip to 40,851; the 14,236-byte first paint is uncompressed too. The immutable asset's gzip is taken once at start-up, the page's is negotiated per request, and Bun.gzipSync means no dependency.
• #95 — Your own row on the board, wherever you rank (waits on #50, suggest scout). standings(db, 10) ends in LIMIT ?1, so a player ranked eleventh sees a table they are not in and learns neither their rank nor their record. It waits on #50 because pull #76 rewrites the same rows and the same statsHtml.
• #96 — What the ear is allowed to hear moves out of main.ts: a tested hearing.ts (ready, suggest vesper). main.ts has no test file, and feelEffects at main.ts:424–451 holds the earshot ceilings, the beep-and-blast exception, the spectator's ears and the hurt-is-only-mine rule — the same move #87 just made with the buy menu.
• #97 — The round history strip: which rounds you lost, and how (ready, suggest vesper). MatchState remembers only the round that just ended, so a match has no readable shape; endRound already produces everything the strip needs, and it has to fit at 360 px and at thirty rounds.

Ready now: #94, #96, #97, on top of the twenty-two that were already ready (#37, #40, #46, #53, #54, #55, #58, #59, #61, #63, #69, #70, #72, #74, #77, #79, #80, #81, #86, #88, #89, #90, #91), with #50 in pull #76. Blocked: #71 and #95. Nothing is parked. Two things still want a person: #54 and #61 duplicate #40 and my token cannot close another author's issue, and the queue itself — twenty-five ready issues against one open pull. A probe issue (#93), created while finding that this API refuses urllib but accepts curl, was closed immediately. Nobody is assigned and #8 stays open.

You've hit your weekly limit · resets Sep 20, 2am (UTC)

You've hit your weekly limit · resets Sep 20, 2am (UTC)

You've hit your weekly limit · resets Sep 20, 2am (UTC)

You've hit your weekly limit · resets Sep 20, 2am (UTC)

API Error: Can't reach the API server — check your internet or DNS (EAI_AGAIN)

API Error: Can't reach the API server — check your internet or DNS (EAI_AGAIN)

API Error: Can't reach the API server — check your internet or DNS (EAI_AGAIN)

API Error: Can't reach the API server — check your internet or DNS (EAI_AGAIN)

API Error: Can't reach the API server — check your internet or DNS (EAI_AGAIN)

API Error: Can't reach the API server — check your internet or DNS (EAI_AGAIN)

Seventeenth pass, read against fafd988. main is green — 379 pass, 0 fail — #50 merged, so #95 is ready, and a round-trip through POST /api/match and GET /api/leaderboard answers correctly with the full security floor. Twenty-eight issues were already ready, so this pass is three, and the first is a mess the last merge left behind.

• #98 — A cookie jar and four HTML dumps are committed on main (ready, → scout). fafd988 brought .scout-tmp/ with it, and cookies2.txt holds a live cs_session value. Minted against 127.0.0.1, so nothing on production is exposed — but a cookie jar is a credential, and nothing ignores scratch or checks for it. Delete, ignore, and a test that fails if one comes back.
• #99 — The ids main.ts reaches for are a contract nothing checks (ready, → scout). 34 $("…") lookups, 31 of them from gamePage(), and $ casts null away — a rename in src/pages/game.ts is a black stage with a green check, and #86's strict tsc cannot see it either. Nothing is broken today; the contract is just unwritten, and #87 moved that panel's markup last week.
• #100 — Movement between ticks: interpolate what is drawn, so 64 Hz does not judder at 60 (ready, → vesper). There is no interpolation anywhere in the client, so a 64 Hz simulation on a 60 Hz display shows another player's run as uneven jumps, and advance already computes and discards the accumulator this needs. The local camera stays on the newest tick — that rule is the point of the issue, along with a teleport that snaps rather than slides.

One thing for whoever reads this: GET /api/leaderboard returns each recent match's id, while the terminal's x deletes by id with no identity check — the cluster #40/#54/#61 describes. Dropping id from the JSON, the way session and identity are already dropped, belongs in that fix.

Ready now: #98, #99, #100, plus #94, #95, #96, #97 from the last pass and #37, #40, #46, #53, #54, #55, #58, #59, #61, #70, #71, #72, #74, #77, #79, #80, #81, #86, #88, #89, #90, #91 — with #63 and #69 being worked. Nothing is blocked and nothing is parked. #54 and #61 still duplicate #40 and still need a person to close them. Nobody is assigned, nothing was pushed, and #8 stays open.

Nothing in the repository changed: this was a planning run, the working tree is clean at fafd988 (even with main), and bun test there is green — 379 pass, 0 fail, run in a temporary worktree that has since been removed. There is nothing to commit and no pull to open; the result is the map on the forge.

Filed against direction #8, all three ready and unblocked:

• #98 — A cookie jar and four HTML dumps are committed on main (suggest scout). The #76 merge brought .scout-tmp/ with it, and cookies2.txt holds a live cs_session value. It was minted against 127.0.0.1, so nothing on production is exposed, but a cookie jar is a credential and nothing ignores scratch or checks for it: delete, ignore, and a test that fails if one comes back.
• #99 — The ids main.ts reaches for are a contract nothing checks (suggest scout). I counted them: 34 $("…") lookups, 31 from gamePage() and three written by main.ts itself. $ casts null away, so a rename in src/pages/game.ts is a black stage with a green check, and #86's strict tsc cannot see it either. Nothing is broken today.
• #100 — Movement between ticks: interpolate what is drawn, so 64 Hz does not judder at 60 (suggest vesper). There is no interpolation anywhere in the client, and advance already computes the accumulator it needs and throws it away. The rules that make it right — the local camera stays on the newest tick, and a teleport snaps rather than slides — are the acceptance criteria.

Also checked and unchanged: #50 merged, so #95 is ready; POST /api/match and GET /api/leaderboard round-trip correctly with the full security floor.

What a person should look at: #98 first — it is a credential in the default branch and a five-minute fix. And two things still need someone with the scope for them: #54 and #61 duplicate #40, and GET /api/leaderboard hands out each match's id while the terminal's x deletes by id with no identity check, which belongs in that same fix. Nobody is assigned and #8 stays open. Budget reached; this is where it stopped.

Budget reached at $2.52; this is where it stopped.

Eighteenth pass, read against fafd988 — unchanged since the last pass, bun test green (379 pass, 0 fail). Nothing has merged in two days and thirty issues were already ready, so this pass is hygiene plus one thing the simulation itself told me.

#63 was parked ("the run ended without a pull … API Error"). The park was an outage rather than anything wrong with the issue, but it asked for the plan override, the expiry, the bots, a new overlay, the touch pad and the README in one run, so it is split and closed:

• #103 — Radio, part one: three calls from the keyboard, and four teammates who actually go (ready, → vesper). The live call on the world, the plan.ts override, expiry, startRound clearing it, the bots that obey it, the message line, and tests that prove siteFor is unchanged when nobody calls.
• #104 — Radio, part two: the panel a thumb can reach (waits on #103, → scout). The overlay, the digits, the pad button and the README — the half a phone needs.

And one new issue, from measuring the game rather than reading it. bun run scripts/measure.ts --matches 30 --seed 41, 217 rounds, normal bots, person idle:

plant rate     58%
ends           detonated 100 · time 65 · elimination 34 · defused 18
defuse rate    14% of planted bombs
round length   median 123s, longest 156s

• #105 — Thirty per cent of rounds end on the clock: bots that feel the round timer (ready, → vesper). Sixty-five rounds in 217 end because nobody found anybody — the second most common ending in the game, ahead of elimination — and the median round already runs to the end of a 115-second clock. The Ts roll a site at freeze time and walk to it at the same pace at 0:20 as at 0:90; the CTs hold an angle that is correct early and a loss late. The acceptance criterion is the same table, same seed, before and after: time-outs under 10%, the plant rate not falling, and elimination not swallowing the difference.

The same run also says the CTs retake a planted bomb 14% of the time (18 defuses against 100 detonations). That is #46's problem, not a new issue, so the numbers went on #46 as a comment.

Ready now: #103, #105, plus #94–#100 from the last two passes and #37, #40, #46, #53, #54, #55, #58, #59, #61, #69, #71, #74, #77, #79, #80, #81, #86, #88, #89, #90, #91 — with #70 and #72 being worked. Blocked: #104. Nothing is parked any more. #54 and #61 still duplicate #40 and still need a person to close them, and GET /api/leaderboard still hands out each match's id while the terminal deletes by id with no identity check — which belongs in that same fix. Nobody is assigned, nothing was pushed, and #8 stays open.

This was a planning run: the working tree is clean at fafd988 (even with main), bun test there is green — 379 pass, 0 fail — and no files were written, so there is nothing to push and no pull to open. The result is the map on the forge.

#63 came back parked by the crew ("the run ended without a pull … API Error"). The park was an outage rather than a fault in the issue, but it asked for the plan override, the expiry, the bots, a new overlay, the touch pad and the README in a single run, so it is split and closed:

• #103 — Radio, part one: three calls from the keyboard, and four teammates who actually go (ready, suggest vesper). The live call on the world, the plan.ts override, expiry, startRound clearing it, the bots that obey it, and a test that siteFor is unchanged when nobody calls.
• #104 — Radio, part two: the panel a thumb can reach (waits on #103, suggest scout). The overlay, digits, pad button and README — the half a phone needs.

One new issue came out of measuring the game rather than reading it. bun run scripts/measure.ts --matches 30 --seed 41 over 217 rounds: plant rate 58%, ends detonated 100 · time 65 · elimination 34 · defused 18, median round 123 s against a 115 s clock.

• #105 — Thirty per cent of rounds end on the clock: bots that feel the round timer (ready, suggest vesper). Sixty-five rounds in 217 end with nobody finding anybody — the second most common ending, ahead of elimination. The acceptance criterion is that same table, same seed, before and after.

The same run put the CT retake at 14% of planted bombs; that is #46's problem, so the numbers went on #46 as a comment rather than into a new issue.

What a person should look at: #105 and #103 are the two that change how the game plays, and #98 (a cs_session cookie jar committed on main under .scout-tmp/) is still the smallest urgent thing in the queue. Two items still need someone with the scope for them: #54 and #61 duplicate #40, and GET /api/leaderboard hands out each match's id while the terminal deletes by id with no identity check — which belongs in that same fix. Nothing is parked now, nobody is assigned, and #8 stays open.

Nineteenth pass, read against 3d1e771 — #70 landed (the gun that says what it is doing), bun test is green (384 pass, 0 fail), / answers in 7 ms with the full security floor and GET /api/leaderboard answers. Thirty-two issues were already ready, so this pass is two, and both come out of reading what the last two merges left behind.

• #108 — A match's numbers must not go backwards: the other half of the posts race (ready, → scout). saveMatch carries a comment written when #50 landed — "Posts race: a periodic post already in flight when the match ends … can land after the post that says so" — and then protects only finished and walked_out with MAX(). Every number in the same statement is still excluded.<column>, and main.ts fires void postResult(...) without awaiting the post before it, so a match that finished 5–3 with 22 kills can sit on the board, permanently, as finished and 4–3 with 18. The row is the only record there is.
• #109 — Bullet holes that stay: a fixed ring of decals, drawn in one call (ready, → vesper). A shot into a wall sparks for a quarter of a second and the wall is spotless again; nothing in the game records that a fight happened there. Both halves already exist — world.ts pushes { kind: "impact", pos, normal } for every wall hit and models.ts:198 is a unit quad whose comment already says "for tracers, sprites and decals". A fixed ring, one batched draw (#89 is counting draws in that same loop), cleared at the round restart.

Two notes rather than issues. The bundle is now 98,771 bytes (42,376 gzipped, still served uncompressed — #94). And world.ts is 1,027 lines and renderer.ts 662, both past what fits in one read: the usual answer is to split them, and I am deliberately not filing that, because #96, #100, #103 and #105 are all queued against world.ts and a split under five open issues is a week of rebases for no player. It is worth doing once that queue drains.

Ready now: #108, #109, plus #103, #105 and #94–#100, and #37, #40, #46, #53, #54, #55, #58, #59, #61, #69, #71, #74, #77, #79, #80, #81, #86, #88, #89, #90, #91 — with #72 being worked. Blocked: #104. Nothing is parked. Still waiting on a person: #54 and #61 duplicate #40, and .scout-tmp/ with its cs_session cookie jar is still on main (#98, five minutes of work).

Nobody is assigned, nothing was pushed, and #8 stays open.

A planning run: the working tree is clean at 3d1e771 (even with main), bun test there is green — 384 pass, 0 fail — and the app boots and answers / in 7 ms with the full security floor. No files were written, so there is nothing to push and no pull to open; the result is the map on the forge.

Filed against direction #8, both ready and unblocked:

• #108 — A match's numbers must not go backwards: the other half of the posts race (suggest scout). saveMatch carries a comment from #50 saying that posts race, then protects only finished and walked_out with MAX(); every number in the same statement is still excluded.<column>, and main.ts fires void postResult(...) without awaiting the one before it. A match that finished 5–3 with 22 kills can end up on the board permanently as finished and 4–3 with 18.
• #109 — Bullet holes that stay: a fixed ring of decals, drawn in one call (suggest vesper). A wall hit sparks for a quarter of a second and the wall is spotless again, while world.ts already pushes { kind: "impact", pos, normal } for every one and models.ts:198 is a quad whose comment already says "for decals". A fixed ring, one batched draw, cleared at the round restart.

Two things I recorded as notes rather than issues: the bundle is now 98,771 bytes (42,376 gzipped, still served uncompressed — that is #94), and world.ts is 1,027 lines with renderer.ts at 662, both past one read. I deliberately did not file the split: #96, #100, #103 and #105 are queued against world.ts, and splitting it under five open issues buys a week of rebases and nothing for a player. It is worth doing once that queue drains.

What a person should look at: #98 is still undone and .scout-tmp/ with its cs_session cookie jar is still on main; #54 and #61 duplicate #40 and need someone with the scope to close them. Nothing is parked, nobody is assigned, and #8 stays open.

Twentieth pass, read against 42f5c5a — #72 landed (the bots have ears), bun test is green (398 pass, 0 fail), and #103 is being worked, so the radio split is moving. Thirty-three issues were already ready, so this pass is two, and the first thing to report is what the merge did to the round.

Same command, same seed, 30 matches, before (fafd988) and after (42f5c5a):

rounds played  217  →  199
plant rate     58%  →  52%
ends           detonated 100 · time 65 · elimination 34 · defused 18
            →  detonated  75 · time 61 · elimination 43 · defused 20
defuse rate    14%  →  19%
round length   median 123s  →  median 123s

Bots that hear each other find each other: eliminations up a third, detonations down a quarter, the retake a little better. What did not move is 31% of rounds still ending on the clock — #105's problem exactly, so its baseline is now stale and I left the new table on it as a comment with "re-baseline before you start".

Opened:

• #110 — The flashbang: the grenade that opens a site, and the blindness rule behind it (ready, → vesper). Grenade is declared kind: "he" — a union with one member — and everything a second grenade needs already works: the arc, the gravity, the bounce, the fuse that fires once, the buy entry, slot 4. Smoke (#37) is the hard one because it has to take a sightline off the map; a flash is a number per player from where they were looking, so it wants a pure flash.ts with three tests and a white screen that decays. A blinded bot has to shoot worse, or the person's flash buys them nothing.
• #111 — Teammates who call it out: what a bot sees, said once, to its own side (ready, → vesper). say() keeps a six-line queue the HUD already draws and is used for four things — round start, plant, half time, result — while every bot runs canSee against every enemy every tick. The person has a radar that shows only their own side, correctly, and four teammates who know where the enemy is and never say. This is the other half of #103: the person talks to the team, the team talks back. The acceptance criteria are the rate limit and no per-tick allocation, because this code is also the RL arena's simulation.

Ready now: #110, #111, plus #105, #108, #109 and #94–#100, and #37, #40, #46, #53, #54, #55, #58, #59, #61, #69, #71, #74, #77, #79, #80, #81, #86, #88, #89, #90, #91 — with #103 being worked. Blocked: #104. Nothing is parked.

Still for a person: #54 and #61 duplicate #40, and .scout-tmp/ with its cs_session cookie jar is still on main (#98). Nobody is assigned, nothing was pushed, and #8 stays open.

A planning run: the working tree is clean at 42f5c5a (even with main), bun test there is green — 398 pass, 0 fail — and nothing was written, so there is nothing to push and no pull to open. The result is the map on the forge.

The finding worth reading first is what #72 did to the round. Same command, same seed, 30 matches, before (fafd988) → after (42f5c5a): rounds 217 → 199, plant rate 58% → 52%, ends detonated 100 · time 65 · elimination 34 · defused 18 → detonated 75 · time 61 · elimination 43 · defused 20, defuse rate 14% → 19%, median round 123 s unchanged. Bots that hear each other find each other. What did not move is 31% of rounds still ending on the clock, which is #105's problem — its baseline is now stale, so the new table went on it as a comment telling the builder to re-baseline before starting.

Filed, both ready and unblocked:

• #110 — The flashbang: the grenade that opens a site, and the blindness rule behind it (suggest vesper). Grenade is declared kind: "he", a union with one member, and the arc, gravity, bounce, fuse, buy entry and slot 4 all already work. Smoke (#37) is the hard utility because it must take a sightline off the map; a flash is a number per player from where they were looking — a pure flash.ts with three tests, a white screen that decays, and a blinded bot that actually shoots worse.
• #111 — Teammates who call it out: what a bot sees, said once, to its own side (suggest vesper). say() already keeps the six-line queue the HUD draws, and every bot already runs canSee against every enemy each tick; the person has four teammates who know where the enemy is and never say so. The rate limit and no per-tick allocation are the acceptance criteria, because this code is also the RL arena's simulation.

What a person should look at: #98 — .scout-tmp/ with its cs_session cookie jar is still on main — and #54 and #61, which duplicate #40 and need someone with the scope to close them. Nothing is parked, nobody is assigned, and #8 stays open.

Twenty-first pass, read against 42f5c5a — unchanged since the last pass, bun test green (398 pass, 0 fail), #79 and #103 in hand, nothing parked.

I filed nothing new this pass, on purpose. Thirty-five issues are ready against one or two build slots; the constraint on this direction has not been the plan for a week, and another four issues would only make the queue harder to read. What the map needed instead was for the old issues to still be true, and for someone to say which ones to pull first.

Corrections, where a merge had moved the ground under an open issue:

• #59 (rebuy) said renderBuy in main.ts rebuilds the grid. That function is gone — #87 replaced it with a pure buy.ts (buyMenu() returning rows with a state and a why), so the rebuy rule now has an obvious home beside it and the issue is smaller than it was written. Corrected on the issue.
• #71 (resume a match) named startMatch, which is start() today, and spoke of a row that says in progress — #50 replaced that with a state of finished | abandoned | live computed in SQL. A resumed match has to bring an abandoned row back to live, and #108 is the other half of making that safe. Corrected on the issue.
• #55 (the bomb before it is planted) I checked and it is still exactly true: radar.ts:54 adds a bomb blip only when state === "planted", and hud.ts:354 shows · bomb for the viewer alone.

If I were pulling the next five, in this order, and why:

1. #98 — a cs_session cookie jar is committed on main under .scout-tmp/. Five minutes, and it is a credential in the default branch.
2. #108 — a match's numbers go backwards when posts race; the row is the only record of a match, so the corruption is permanent. Small, server-side, tested.
3. #105 — 31% of rounds end on the clock, measured twice now. It is the largest play-feel defect in the game and it has a number to prove it moved.
4. #94 — 58% of the first visit's download is thrown away (98,771 bytes served where 42,376 would do). One start-up gzip, no dependency.
5. #100 — no interpolation anywhere, so a 64 Hz simulation juddering at 60 Hz is the first thing the direction asks about: movement that feels immediate.

Then #46 (the CTs retake 19% of planted bombs), #110 (the flashbang) and #91 (who is that in front of me).

Ready now: all thirty-five as before — #37, #40, #46, #53, #54, #55, #58, #59, #61, #69, #71, #74, #77, #79, #80, #81, #86, #88, #89, #90, #91, #94–#100, #103, #105, #108, #109, #110, #111 — with #79 and #103 being worked and #104 blocked behind #103. Still for a person: #54 and #61 duplicate #40. Nobody is assigned, nothing was pushed, and #8 stays open.

A planning run with nothing to land in the repository: the working tree is clean at 42f5c5a (even with main), bun test there is green — 398 pass, 0 fail — and no files were written, so there is nothing to push and no pull to open.

I filed no new issues this pass, deliberately. Thirty-five are already ready against one or two build slots; the constraint on this direction has not been the plan for a week, and four more would only make the queue harder to read. What the map needed was for its older issues to still be true, and for someone to say which to pull first.

Corrections posted where a merge had moved the ground under an open issue:

• #59 (rebuy) cited renderBuy in main.ts, which #87 deleted; the buy menu is now the pure buy.ts, so the rebuy rule has an obvious home beside buyMenu() and the issue is smaller than written.
• #71 (resume a match) named startMatch (now start()) and a row that says in progress, which #50 replaced with a SQL-computed state of finished | abandoned | live; a resumed match has to bring an abandoned row back to live, and #108 is the other half of making that safe.
• #55 I checked and left alone: radar.ts:54 and hud.ts:354 are still exactly as it describes.

The order I would pull next, with the reason in each case, is on #8: #98 (a cs_session cookie jar committed on main), #108 (permanent leaderboard corruption when posts race), #105 (31% of rounds end on the clock, measured twice), #94 (58% of the first download wasted), #100 (no interpolation, which is the direction's first clause), then #46, #110 and #91.

Nothing is parked, #79 and #103 are in flight, #104 waits on #103, and #54 and #61 still duplicate #40 and need a person to close them. Nobody is assigned and #8 stays open.

Twenty-second pass, read against 42f5c5a — still no merge since #107, bun test green (398 pass, 0 fail), the app boots and answers: GET / and HEAD / 200 with all four security headers, GET /api/leaderboard 200, and a cross-site POST /api/match refused with 403. #79 and #86 are in hand, nothing is parked.

Nothing new filed again this pass, for the same reason as the last one: thirty-five ready issues against one or two slots. What I did instead was re-run the probe behind the issue that is being worked right now.

#86 re-probed against the current tree (strict tsc --noEmit, @types/bun, skipLibCheck, run out of a scratch directory so nothing in the repository moved): it is 24 errors now, not the 8 I measured at e973e0b.

14  src/who.test.ts
 3  src/client/world.test.ts
 3  src/client/main.ts        <- production
 2  src/tty.test.ts
 1  src/client/settings.test.ts
 1  src/client/match.test.ts

The three in production are the same three as a week ago and still unfixed — main.ts(283,34) passing string | boolean into openBuy, and main.ts(556,9)/(559,5) where renderer is possibly null, the hole #75 left in the recovery path. The other 21 are partial fixtures, and the growth from 8 to 24 is the issue making its own case: #50 added walked_out, state and left, and every fixture that builds a MatchRow or a Result by hand drifted the same day, with nothing to catch it. The full list is on #86 with a note to re-probe before starting and to fix the production three first.

Ready now: unchanged at thirty-five — #37, #40, #46, #53, #54, #55, #58, #59, #61, #69, #71, #74, #77, #80, #81, #88, #89, #90, #91, #94–#100, #103, #105, #108, #109, #110, #111 — with #79 and #86 being worked and #104 blocked behind #103. The order I would still pull in: #98 (a cs_session cookie jar on main), #108 (permanent row corruption when posts race), #105 (31% of rounds end on the clock), #94 (58% of the first download wasted), #100 (no interpolation at all).

Still for a person: #54 and #61 duplicate #40. Nobody is assigned, nothing was pushed, and #8 stays open.

A planning run with nothing to land: the working tree is clean at 42f5c5a (even with main), bun test there is green — 398 pass, 0 fail — and the app boots and answers, GET / and HEAD / 200 with all four security headers, /api/leaderboard 200, and a cross-site POST /api/match refused with 403. No files were written, so there is nothing to push and no pull to open.

No new issues again this pass, deliberately — thirty-five are ready against one or two build slots. The useful work was re-running the probe behind an issue someone is holding right now.

#86 re-probed against the current tree (strict tsc --noEmit with @types/bun, run from a scratch directory so the repository was untouched): 24 errors now, not the 8 I measured at e973e0b — 14 in who.test.ts, 3 in world.test.ts, 3 in production main.ts, 2 in tty.test.ts, one each in settings.test.ts and match.test.ts. The production three are unchanged from a week ago: main.ts(283,34) passing string | boolean into openBuy, and main.ts(556,9)/(559,5) where renderer is possibly null — the hole #75 left in the recovery path. The growth from 8 to 24 is the issue proving its own point: #50 added walked_out, state and left, every hand-built fixture drifted the same day, and nothing type-checks. That list, with a note to re-probe first and fix the production three before the fixtures, is on #86.

The order I would pull in is unchanged and on #8: #98, #108, #105, #94, #100. Nothing is parked, #79 and #86 are in flight, #104 waits on #103, and #54 and #61 still duplicate #40 and need a person to close them. Nobody is assigned and #8 stays open.

Twenty-third pass, read against 3974ac5. Two merges since the last one — #79 (a bullet through a crate, pull #113) and #69 (bind your own keys, pull #101) — and bun test is green: 428 pass, 0 fail, up thirty tests. #71 is in hand.

.scout-tmp/ is still on main, and cookies2.txt still holds a live cs_session. Four merges have now gone past it. #98 is five minutes of work and it is a credential sitting in the default branch; it wants picking up ahead of anything else in the queue.

A new hand, and two issues that circle the same hole. sentinel filed #114 — the rebind panel's wiring has no test, because nothing here can drive a DOM — which is the same root cause as my #99 (the ids main.ts reaches for are a contract nothing checks). They are not duplicates and neither blocks the other, so I have linked neither; I cross-commented both instead, with the one number that matters: at 3974ac5, main.ts is 691 lines with no test file, up from 581 a week ago, and #101 alone added 114 lines of wiring to it. #99 is the cheap half and needs no DOM; #114 carries the real decision — a harness, or extract the wiring into a module the way #87 did with the buy menu — and whoever makes it decides what happens to #99, because a harness that can build the page subsumes the static check rather than sitting beside it.

Nothing new filed, for the third pass running. Thirty-four issues are ready against one or two slots. I also did not re-measure the round after #79: penetration changes combat and #105's baseline has certainly moved again, but that issue already tells its builder to re-baseline at pickup, and a fresh table from me now would be stale by the time anyone reads it.

Ready now: #114 and #37, #40, #46, #53, #54, #55, #58, #59, #61, #74, #77, #80, #81, #86, #88, #89, #90, #91, #94–#100, #103, #105, #108, #109, #110, #111 — with #71 being worked and #104 blocked behind #103. Nothing is parked.

The order I would still pull in: #98 (the cookie jar on main), #108 (permanent row corruption when posts race), #105 (31% of rounds end on the clock), #94 (58% of the first download wasted), #100 (no interpolation anywhere). Still for a person: #54 and #61 duplicate #40.

Nobody is assigned, nothing was pushed, and #8 stays open.

A planning run with nothing to land: the working tree is clean at 3974ac5 (even with main), and bun test there is green — 428 pass, 0 fail, up thirty tests since the last pass. No files were written, so there is nothing to push and no pull to open.

Two merges landed — #79 (a bullet through a crate, pull #113) and #69 (bind your own keys, pull #101) — and the thing to look at first is what has not landed: .scout-tmp/ is still on main with a live cs_session in cookies2.txt, now four merges old. #98 is five minutes of work on a credential in the default branch.

A new hand, sentinel, filed #114 (the rebind panel's wiring has no test, because nothing here can drive a DOM), which circles the same hole as my #99 (the ids main.ts reaches for are a contract nothing checks). They are not duplicates and neither blocks the other, so I linked neither and cross-commented both with the number that frames the decision: at 3974ac5, main.ts is 691 lines with no test file, up from 581 a week ago, and #101 alone added 114 lines of wiring. #99 is the cheap half and needs no DOM; #114 carries the real choice — a harness, or extract the wiring into a module the way #87 did with the buy menu — and a harness that can build the page should subsume #99 rather than sit beside it.

No new issues this pass, the third running: thirty-four are ready against one or two slots. I also skipped re-measuring the round after #79, since #105 already tells its builder to re-baseline at pickup and a table from me now would be stale by the time it is read.

The pull order I would still recommend is on #8: #98, #108, #105, #94, #100. Nothing is parked, #71 is in flight, #104 waits on #103, and #54 and #61 still duplicate #40 and need a person to close them. Nobody is assigned and #8 stays open.

Twenty-fourth pass, read against 33775fe. The radio landed (pull #102) and bun test is green: 447 pass, 0 fail.

Two issues closed as delivered. Pull #102 did both halves of the split at once, so I checked it against each list and closed both:

• #103 — world.radio holds one live call, plan.ts gained ordersFor so the override lives there and not in the goal code, bots.ts reads orders only when world.radio !== null (a silent world pays nothing), the key is rebindable, and the tests are in plan.test.ts, bots.test.ts and world.test.ts.
• #104 — the #radio overlay, the pad button, digits 1–3 with stopPropagation so they never reach the slot keys, Escape and Close and the key again, focus on the first call, the panel refusing to open over pause or match-over, and the README and menu hint both naming it.

The round, measured again at this commit — bun run scripts/measure.ts --matches 30 --seed 41, after #79 (penetration) and #102 (the radio):

rounds played  216     (199 at 42f5c5a, 217 at fafd988)
plant rate     61%     (52%, 58%)
ends           detonated 103 · time 55 · elimination 39 · defused 19
defuse rate    15%     (19%, 14%)
round length   median 123s, longest 156s   (unchanged throughout)

Rounds lost to the clock are down to 25% from 31%, and the Ts plant more than they ever have — the radio and penetration both helped. A quarter of all rounds is still a quarter, and the median round still runs the whole 115-second clock, so #105 stands with that table as its new "before". The retake went the other way: 15%, about one bomb in seven, which is #46's number and now worse than last week because there are more bombs on the ground. Both issues have the fresh numbers on them.

Nothing new filed, for the fourth pass running. Thirty-two issues are ready against one or two slots, and #111 (teammates who call it out) is the natural next increment after the radio — it is already filed and its plumbing now exists.

.scout-tmp/ is still on main with a live cs_session in it, five merges later. #98 is the smallest thing in the queue and the only one that is a credential.

Ready now: #37, #40, #46, #53, #54, #55, #58, #59, #61, #71, #74, #77, #80, #81, #86, #88, #89, #90, #91, #94–#100, #105, #108, #109, #110, #111, #114. Nothing is parked, nothing is blocked, nobody is assigned, nothing was pushed, and #8 stays open. The order I would pull in: #98, #108, #105, #94, #100.

A planning run with nothing to land: the working tree is clean at 33775fe (even with main), bun test there is green — 447 pass, 0 fail — and no files were written, so there is nothing to push and no pull to open.

The radio landed (pull #102), and it did both halves of the split at once, so I checked it against each acceptance list and closed #103 and #104: world.radio with one live call, the override in plan.ts (ordersFor) rather than in the goal code, bots.ts paying nothing when the radio is silent, a rebindable key, and on the interface side the #radio overlay, the pad button, digits 1–3 with stopPropagation, Escape/Close/key-again, focus handling, and the README.

The round, measured again at this commit (scripts/measure.ts --matches 30 --seed 41, after #79 and #102): 216 rounds, plant rate 61% (its best yet), ends detonated 103 · time 55 · elimination 39 · defused 19, defuse rate 15%, median round 123 s. Rounds lost to the clock are down to 25% from 31% and 30% — penetration and the radio both helped — but a quarter of all rounds still ends with nobody finding anybody, so #105 stands and now carries that table as its "before". The retake moved the wrong way to 15%, roughly one bomb in seven, which is #46's number; both issues have the fresh figures on them.

No new issues, the fourth pass running — thirty-two are ready against one or two slots, and #111 (teammates who call it out) is already the natural next increment after the radio, with its plumbing now in place.

What a person should look at: .scout-tmp/ is still on main with a live cs_session in it, five merges later — #98 is the smallest thing in the queue and the only one that is a credential. #54 and #61 still duplicate #40. Nothing is parked, nothing is blocked, nobody is assigned, and #8 stays open; my suggested order is #98, #108, #105, #94, #100.

Twenty-fifth pass, read against 779ddc6. Three merges since the last one — #86 (a strict typecheck, pull #115), #90 (scripts/cost.ts, pull #118) and #89 (the draw-call budget, pull #116) — and the check has grown teeth: forge.json now runs bun run check, which is tsc --noEmit && bun test. Both halves are green here: 461 pass, 0 fail, and tsc clean.

One thing to know when you clone: bun run check needs bun install first, or it stops at tsc: command not found before a single test runs. That is not a bug in the check, but it is worth knowing before you read a 127 as a failure.

What a tick costs, now that the script exists — bun run scripts/cost.ts at this commit: mean 0.130 ms a tick, p99 0.417 ms, 0.8% of the 15.6 ms a 64 Hz tick is allowed. The simulation is not what is slow, which is what #89 and #90 were opened to establish.

Opened, one, in the same spirit as the two that just landed:

• #120 — What the HUD costs, counted: a call budget the recording 2D context enforces (ready, → vesper). #89 put a budget on the GL draws; the other half of the frame is the HUD, and nothing counts it. Measured here through the recorder that already exists in hud.test.ts: 54 canvas-2D calls a frame quiet, 122 with the scoreboard up, 80 of those fillText. drawHud clears and repaints everything every frame at the full device ratio — deliberately, since #12 drops the scene's scale and not the HUD's — so on the machine that most needs help the HUD is the one thing that never gets cheaper, and every new panel (#91, #97) lands in that count. The issue is the measurement and the budget; not repainting what has not changed is named in it as the obvious next step and deliberately left out.

.scout-tmp/ is still on main, six merges later, cookie jar and all. I have rewritten #98 as a literal three-step pickup — git rm, one .gitignore line, one test that walks the tree and fails on a Netscape cookie jar — so it can be done in five minutes by whoever reads it next.

Ready now: #120, plus #37, #40, #46, #53, #54, #55, #58, #59, #61, #71, #74, #77, #80, #94, #95, #96, #97, #98, #99, #100, #105, #108, #109, #110, #111, #114 — with #81 and #88 being worked. Nothing is parked, nothing is blocked.

The order I would pull in: #98 (the cookie jar), #108 (a match's numbers going backwards), #105 (a quarter of rounds still end on the clock), #94 (58% of the first download wasted), #100 (no interpolation anywhere). Still for a person: #54 and #61 duplicate #40. Nobody is assigned, nothing was pushed, and #8 stays open.

A planning run with nothing to land: the working tree is clean at 779ddc6 (even with main), and the check is green both halves — tsc --noEmit clean and 461 pass, 0 fail. No files were written, so there is nothing to push and no pull to open.

Three merges arrived since the last pass — #86 (the strict typecheck, pull #115), #90 (scripts/cost.ts, pull #118) and #89 (the draw-call budget, pull #116) — and forge.json now runs bun run check (tsc --noEmit && bun test). Worth knowing before anyone reads a failure wrongly: that check needs bun install first, or it stops at tsc: command not found with exit 127 before a test runs.

With the new script in place, bun run scripts/cost.ts says a tick costs 0.130 ms mean, p99 0.417 ms — 0.8% of the 15.6 ms a 64 Hz tick is allowed. The simulation is not what is slow, which is what #89 and #90 were opened to settle.

Filed, one, in the same spirit as the two that just landed:

• #120 — What the HUD costs, counted: a call budget the recording 2D context enforces (ready, suggest vesper). #89 budgeted the GL draws; nothing counts the other half of the frame. Measured through the recorder already sitting in hud.test.ts: 54 canvas-2D calls a frame quiet, 122 with the scoreboard up, 80 of them fillText. drawHud repaints everything every frame at full device ratio while #12 drops only the scene's scale, so the HUD is the one thing that never gets cheaper on a slow machine. Not repainting what has not changed is named in the issue as the next step and deliberately left out of it.

.scout-tmp/ is still on main six merges later, cookie jar and all. I rewrote #98 as a literal three-step pickup — git rm, one .gitignore line, one test that walks the tree and fails on a Netscape cookie jar — so it is five minutes for whoever reads it next.

My suggested order is unchanged: #98, #108, #105, #94, #100. Nothing is parked or blocked, #81 and #88 are in flight, #54 and #61 still duplicate #40, nobody is assigned, and #8 stays open.

Twenty-sixth pass, and a short one: this run reached its budget almost immediately, so it is a status note rather than a plan.

Three more merges since the last pass — #91 (name plates and project.ts, pull #119), the radio (pull #112) and #81 (your crosshair, pull #121) — leaving main at 9c1997d. I did not run the check this pass, so nothing here claims it is green; the last green I verified myself was 779ddc6, both halves (tsc --noEmit clean, 461 pass).

.scout-tmp/ is still on main, seven merges later, with a live cs_session in cookies2.txt. #98 is written as a literal three-step pickup and is still the only issue in the queue that is a credential in the default branch.

Ready, unchanged: #37, #40, #46, #53, #54, #55, #58, #59, #61, #71, #74, #77, #80, #94, #95, #96, #97, #98, #99, #100, #105, #108, #109, #110, #111, #114, #120 — with #88 and #94 being worked. Nothing is parked, nothing is blocked, nobody is assigned, nothing was pushed, and #8 stays open.

The order I would still pull in: #98, #108, #105, #94, #100.

Nothing to land in the repository: this was a planning run, the working tree is clean, no files were created and nothing was committed, so there is nothing to push and no pull to open. The result is on the forge.

Over the last two passes: #120 was filed — a call budget for the HUD, measured through the recorder already in hud.test.ts at 54 canvas-2D calls a frame quiet and 122 with the scoreboard up, 80 of them fillText — and #98 was rewritten as a literal three-step pickup (git rm, one .gitignore line, one test that walks the tree and fails on a Netscape cookie jar). The last check I verified myself was at 779ddc6: tsc --noEmit clean and 461 tests passing, with bun run scripts/cost.ts reporting 0.130 ms a tick, 0.8% of the 64 Hz budget.

What is not done: this run stopped early on budget, so I did not run the check against 9c1997d — nothing in my last note claims main is green today — and I did not measure the round again after #91, #81 and the radio pull, so #105's "before" table is the one from 33775fe (25% of rounds lost to the clock).

What a person should look at: .scout-tmp/ is still on main seven merges later, with a live cs_session in cookies2.txt — #98 is five minutes and the only credential in the queue. Then #108 (a match's numbers going backwards when posts race), #105, #94 and #100. #54 and #61 still duplicate #40 and need someone with the scope to close them. Nothing is parked, nobody is assigned, and #8 stays open.

Budget reached at $2.52; this is where it stopped.

Twenty-seventh pass, read against 9c1997d. Three merges since the last full pass — #91 (name plates and project.ts, pull #119), the radio (pull #112) and #81 (your crosshair, pull #121) — and the check is green both halves: tsc --noEmit clean, 493 pass, 0 fail. #96 is in hand.

Nothing new filed. Twenty-eight issues are ready against one or two slots, and everything I found this pass was a number that belonged on an issue that already exists rather than a new one. Three went out:

• #120 (the HUD budget) — re-measured: still 54 calls a frame quiet, 122 with the scoreboard up, 80 of them fillText, but only because my fixture has nobody visible and the default crosshair. drawHud has a new shape (camera and crosshair parameters, from #91 and #81) and a test passing the old argument list now throws inside viewMatrix. The busy frame for that budget has to have players in view, or it will not cover the feature most likely to blow it.
• #114 (the untested wiring) — the trend, since that is what the issue rests on: main.ts was 581 lines when #87 landed, 691 after #101, and is 815 now, with 27 $("…") lookups and no test file at any point. A hundred lines a merge into the one file nothing can check, while tsc now guards every other line in the repository.
• #94 (compression) — the bundle is now 111,070 bytes, 47,118 gzipped, up 15 KB in a week. The saving is bigger than when the issue was written: about 58% of every first visit, still served with no content-encoding.

.scout-tmp/ is still on main — seven merges, a week, and a live cs_session in cookies2.txt. #98 is three steps and it is still the only issue in the queue that is a credential in the default branch.

Ready now: #37, #40, #46, #53, #54, #55, #58, #59, #61, #71, #74, #77, #80, #88, #94, #95, #97, #98, #99, #100, #105, #108, #109, #110, #111, #114, #120. Nothing is parked, nothing is blocked, nobody is assigned, nothing was pushed, and #8 stays open.

The order I would pull in: #98, #108, #105, #94, #100. Still for a person: #54 and #61 duplicate #40.

A planning run with nothing to land: the working tree is clean at 9c1997d (even with main), and the check is green both halves — tsc --noEmit clean and 493 pass, 0 fail. No files were written, so there is nothing to push and no pull to open.

Three merges arrived since the last full pass — #91 (name plates and project.ts), the radio (pull #112) and #81 (your crosshair). I filed nothing new: twenty-eight issues are ready against one or two build slots, and everything I found was a number that belonged on an issue that already exists.

• #120 (HUD budget) — re-measured at 54 calls a frame quiet, 122 with the scoreboard up, 80 of them fillText, but only because my fixture has nobody visible. drawHud has a new shape (camera, crosshair), and a test passing the old argument list throws inside viewMatrix; the busy frame for that budget must have players in view or it will miss the feature most likely to blow it.
• #114 (untested wiring) — the trend it rests on, measured each pass: main.ts was 581 lines when #87 landed, 691 after #101, and is 815 now with 27 $("…") lookups and no test file at any point — a hundred lines a merge into the one file nothing can check, while tsc now guards everything else.
• #94 (compression) — the bundle is now 111,070 bytes, 47,118 gzipped, up 15 KB in a week, so the saving is larger than when the issue was written: about 58% of every first visit, still with no content-encoding.

What a person should look at: .scout-tmp/ is still on main after seven merges, with a live cs_session in cookies2.txt — #98 is three steps and the only credential in the queue. Then #108, #105, #94, #100, and #54 and #61, which duplicate #40 and need someone with the scope to close them. Nothing is parked or blocked, nobody is assigned, and #8 stays open.

Twenty-eighth pass, read against ea3cc6f. Three merges, and one of them is the one that has been sitting in every one of these notes for a week: #98 landed — .scout-tmp/ and its cookie jar are off main (pull #125). Also in: #96 (the effects-to-sound loop out into hearing.ts, pull #124) and #99 (the ids main.ts reaches for, pull #127, which brought the first main.test.ts this repository has ever had). #100 is in hand, and #94's compression is in a pull.

The check, carefully: on a clean clone bun run check is green — tsc --noEmit clean, 508 pass, 0 fail. On my clone it was red, and the reason is worth an issue rather than a shrug:

• #129 — The tree guard is red on any machine that has run the app (ready, → scout). src/tree.test.ts, which #98 brought in, flags any file matching a .gitignore glob — but an ignored file is proof the ignore works, not a violation. openDatabase defaults to ./data and the README says the database lands at data/app.db, so running the app once turns the check red until you delete its database; bun run build does the same through static/app..js. Reproduced both ways in the issue, with the one-line proof that deleting data/app.db takes it from 507 pass, 1 fail back to 508 pass, 0 fail. The guard should fail on what is committed, and a cookie jar anywhere — not on what the app wrote five minutes ago.

Also noted on #114 (the untested wiring): main.ts fell 815 → 797 lines when #96 took hearing.ts out of it — the first fall in a fortnight — and it now has a test file for the first time, courtesy of #99. That narrows the decision that issue carries: a harness is no longer the only way to get any test on the file, and extraction now has two worked examples in-repo (#87, #96).

sentinel's #126 (give / a cache-control: private, no-cache) is a good catch on the same seam #94's pull is working in, and is ready.

Ready now: #129, #126, plus #37, #40, #46, #53, #54, #55, #58, #59, #61, #71, #74, #77, #80, #88, #94, #95, #97, #105, #108, #109, #110, #111, #114, #120. Nothing is parked, nothing is blocked, nobody is assigned, nothing was pushed, and #8 stays open.

The order I would pull in, now that the cookie jar is gone: #129 (the check is red for anyone who has run the app), #108 (a match's numbers going backwards), #105 (a quarter of rounds still end on the clock), #100 is already moving, then #46. Still for a person: #54 and #61 duplicate #40.

A planning run with nothing to land: the working tree is clean at ea3cc6f (even with main), and on a clean clone bun run check is green — tsc --noEmit clean, 508 pass, 0 fail. No files were written, so there is nothing to push and no pull to open.

Three merges, including the one that has been in every note for a week: #98 landed — .scout-tmp/ and its cookie jar are off main. Also #96 (the effects-to-sound loop into hearing.ts) and #99 (the id contract, which brought the first main.test.ts this repository has ever had).

Filed, one, from a red check I could reproduce:

• #129 — The tree guard is red on any machine that has run the app (ready, suggest scout). src/tree.test.ts, which came in with #98, flags any file matching a .gitignore glob — but an ignored file is proof the ignore works, not a violation. openDatabase defaults to ./data and the README says the database lands at data/app.db, so running the app once turns the check red until you delete its database; bun run build does the same through static/app..js. The issue carries the proof both ways: 507 pass, 1 fail with data/app.db present, 508 pass, 0 fail after deleting them.

Also recorded on #114: main.ts fell 815 → 797 lines when #96 lifted hearing.ts out — the first fall in a fortnight — and it now has a test file, so that issue's decision is narrower than when it was written, with two worked extraction examples in-repo (#87, #96). sentinel's #126 (cache-control: private, no-cache on /) is a good catch on the seam #94's pull is currently in.

Suggested order now that the cookie jar is gone: #129, #108, #105, then #46 (#100 and #94 are already moving). #54 and #61 still duplicate #40 and need a person. Nothing is parked or blocked, nobody is assigned, and #8 stays open.

Twenty-ninth pass, read against 4161986 (#94 landed as pull #123). is green: clean, 540 pass, 0 fail. I ran the app and read it as a visitor: answers in ~1–2 ms with the floor, and , and the bundle goes out gzipped at 47,745 bytes.

This pass was mostly map surgery: eight issues were parked, all but one of them by an API error or a weekly limit rather than by the work.

Opened, in order:

• #130 — A pocket that holds one of each: per-kind grenades, and the rule slot 4 draws by. keeps every grenade in one integer (), which is why smoke has been unbuildable since #36. Ready. → scout
• #131 — The map catalogue: a validated setting and a Map select beside Difficulty. is still a lone ; validates and knows nothing about a map. Built against de_forge alone. Ready. → scout
• #132 — A second place to play: one more layout, and bots that plant on it at a rate you can read. Waits on #131. → vesper

Rewritten, because a parked issue must not be left as it was (I have no scope to edit or close another author'''s issue, so each rewrite is a comment that supersedes the body):

• #37 (smoke) — now the cloud only, blocked by #130.
• #40 (the terminal'''s ) — both blockers are long gone; restated against at tty.ts:65 and the branch at tty.ts:74, with from and three tests. Ready.
• #53 (guest rows) — the old body asked the builder to choose the policy, which is why it sat; the rule is now decided: finished matches only, signed above guests, a lifetime allowance per guest session.
• #55 (the bomb before it is planted) — re-read against radar.ts:45–56 and narrowed to two blips and their tests.
• #58 (bots and the HE) — smoke coupling dropped, so it is buildable today; the throw goes through the person'''s path.
• #74 (a second map) — the decline on it rests on a pull that does not exist here: there is no #154, is , the only open pulls are #117 and #122, and the remote has one branch. Nothing of #74 is built. It is superseded by #131 and #132, linked behind both, and wants a person to close it.

Also for a person: #126 is already done on (the is in , verified in a local run) and wants closing; #54 and #61 are the same finding as #40 and are now linked behind it so nobody builds it three times.

Ready now: #130, #131, #40, plus #37 (behind #130 → not ready), #46, #53, #55, #58, #59, #77, #80, #95, #97, #108, #109, #110, #111, #114, #120, #129. Nothing is assigned, nothing was pushed, and #8 stays open.

The order I would pull in: #129 (the check is red for anyone who has run the app), #108, #105 is in hand, then #130 and #131.

Twenty-ninth pass, read against 4161986. bun run check is green: tsc --noEmit clean, 540 pass, 0 fail. I read the app as a visitor: / answers in 1-2 ms with the security floor, cache-control: private, no-cache and vary: accept-encoding, and the bundle goes out gzipped at 47,745 bytes.

(My previous comment here was posted with its backticks eaten by a shell; this is the same note, intact.)

Mostly map surgery this pass: eight issues were parked, all but one by an API error or a weekly limit rather than by the work.

Opened, in order:

• #130 - A pocket that holds one of each: per-kind grenades, and the rule slot 4 draws by. world.ts:428 keeps every grenade in one integer (MAX_GRENADES = 1), which is why smoke has been unbuildable since #36. Ready. -> scout
• #131 - The map catalogue: a validated map setting and a Map select beside Difficulty. map.ts:211 is still a lone DE_FORGE; settings.ts validates difficulty and knows nothing about a map. Built against de_forge alone. Ready. -> scout
• #132 - A second place to play: one more layout, and bots that plant on it at a rate you can read. Waits on #131. -> vesper

Rewritten, because a parked issue must not be left as it was (I have no scope to edit or close another author's issue, so each rewrite is a comment that supersedes the body):

• #37 (smoke) - the cloud only, blocked by #130.
• #40 (the terminal's x) - both blockers are long gone; restated against key at tty.ts:65 and the x branch at tty.ts:74, with who-is-at-the-keyboard read from the forge's FORGE_APP_USER_*, and three tests. Ready.
• #53 (guest rows) - the old body asked the builder to choose the policy, which is why it sat; the rule is now decided: finished matches only, signed above guests, a lifetime allowance per guest session.
• #55 (the bomb before it is planted) - re-read against radar.ts:45-56 and narrowed to two blips and their tests.
• #58 (bots and the HE) - the smoke coupling is dropped, so it is buildable today; the throw goes through the person's path.
• #74 (a second map) - the decline on it rests on a pull that does not exist here: there is no #154, pulls/154 is not_found, the only open pulls are #117 and #122, and the remote has one branch. Nothing of #74 is built. Superseded by #131 and #132, linked behind both, and it wants a person to close it.

Also for a person: #126 is already done on main (the header is in server.ts; I verified it in a local run) and wants closing; #54 and #61 are the same finding as #40 and are now linked behind it so nobody builds it three times.

Ready now: #130, #131, #40, plus #46, #53, #55, #58, #59, #77, #80, #95, #97, #108, #109, #110, #111, #114, #120, #129. Nothing is assigned, nothing was pushed, and #8 stays open.

The order I would pull in: #129 (the check is red for anyone who has run the app), #108, #130, #131.

A planning run with nothing to land: the working tree is clean at 4161986 (even with main), no files were written in the clone and nothing was committed, so there is nothing to push and no pull to open. The check is green — tsc --noEmit clean, 540 pass, 0 fail — and a local run answers / in 1–2 ms with the security floor, cache-control: private, no-cache, and a 47,745-byte gzipped bundle.

Filed, in order: #130 (per-kind grenade pocket — the integer at world.ts:428 that has made smoke unbuildable since #36, ready, suggest scout), #131 (the map catalogue and a validated map setting with a Map select, built against de_forge alone, ready, suggest scout), and #132 (a second layout plus a measured plant rate, waiting on #131, suggest vesper).

Eight issues were parked, almost all by API errors or weekly limits rather than by the work, and I have no scope to edit or close another author's issue — so each rewrite is a comment that supersedes the body: #37 narrowed to the cloud and linked behind #130; #40 restated against today's tty.ts (key at :65, the x branch at :74) now that both its blockers have landed; #53 given a decided rule instead of four options; #55 re-read against radar.ts:45–56; #58 decoupled from smoke. #74 is superseded by #131/#132 and linked behind both — its decline cites PR #154, which does not exist in this repository (pulls/154 is not_found, the only open pulls are #117 and #122, and the remote carries one branch).

For a person: #126 is already implemented on main and wants closing, #54 and #61 duplicate #40 and are now linked behind it so nobody builds it three times, and #74 wants closing once its two replacements land. Ready now: #130, #131, #40, alongside #46, #53, #55, #58, #59, #77, #80, #95, #97, #108, #109, #110, #111, #114, #120, #129. One note on the record: my first summary comment on #8 was posted with its backticks eaten by the shell; the intact version follows it.

Budget reached at $2.56; this is where it stopped.

Thirtieth pass, read against 4161986 — no merges since the last one. bun run check is green on a clean clone: tsc --noEmit clean, 540 pass, 0 fail.

One thing moved: #71 was parked when pull #117 closed red. I could not fetch its branch, but the pull's own numbers say what happened — 726 changed lines across seven files, including the middle of src/client/world.ts, on a base five merges stale (33775fe), ending mergeable: false with a conflict in world.ts. Nothing in it was wrong in kind; it was three runs of work in one pull, in the most contended file in the repository. So it is three issues now, smallest first, each able to go green on its own:

• #133 — The snapshot, as a value: saved.ts says what a match is worth keeping, and refuses anything else. snapshot(world, matchId) and parseSaved as a real boundary in the shape parseSettings already has, plus the storage helpers that swallow a failure the way saveSettings does (settings.ts:138). Two new files, nothing wired. Ready. -> scout
• #134 — A world that starts from a snapshot: restoreWorld, without touching createWorld's signature. createWorld (world.ts:238) already takes seven positional parameters and #131 is about to mean something by the last of them, so this is a named function plus the smallest hook that stops botBuy (world.ts:379) re-shopping money the snapshot says is spent. Waits on #133. -> scout
• #135 — Resume match: the menu offers the round you were in, and the row on the board continues. The wiring a player sees, with the same matchId so an abandoned row comes back to live instead of duplicating. Waits on #134, and whoever takes it should read #108 first. -> scout

Two notes for whoever picks them up, both from the closed pull: rebase before you start and again before you push, and keep #135's diff off world.ts entirely — #133 and #134 own that file.

#71 is linked behind all three and wants a person to close it. Still waiting on a person from last pass: #126 is already done on main (the cache-control is in server.ts), #54 and #61 duplicate #40, and #74 is superseded by #131 and #132.

Ready now: #133, #130, #131, #40, plus #46, #53, #55, #58, #59, #77, #80, #95, #97, #108, #109, #110, #111, #114, #120, #129. Nothing is assigned, nothing was pushed, and #8 stays open.

The order I would pull in: #129 (the check is red for anyone who has run the app), #133, #108, #130, #131.

A planning run with nothing to land: the working tree is clean at 4161986 (even with main), no files were written in the clone and nothing was committed, so there is nothing to push and no pull to open. bun run check is green — tsc --noEmit clean, 540 pass, 0 fail.

The one thing that moved since the last pass is that #71 was parked: pull #117 closed red, and the pull's own numbers say why — 726 changed lines across seven files including the middle of src/client/world.ts, on a base five merges stale (33775fe), ending mergeable: false with a conflict in that file. Nothing in it was wrong in kind, so I split it into three issues that can each go green alone: #133 (the snapshot as a value — saved.ts and its boundary, nothing wired, ready), #134 (restoreWorld as a named function rather than an eighth positional parameter on createWorld, waiting on #133), and #135 (the Resume button and the continued matchId, waiting on #134, and read #108 first). #71 is linked behind all three and wants a person to close it.

I also reproduced #129 from this clone in one command — mkdir -p data && touch data/app.db turns the tree guard red, which is what the README tells anyone to do — and left the proof on the issue.

What a person should look at: #129 first (the check is red for anyone who has run the app), then #133, #108, #130, #131. Four issues still need a person's scope rather than mine: #126 is already implemented on main, #54 and #61 duplicate #40, and #74 is superseded by #131/#132 — all four want closing. Nothing is assigned and #8 stays open.

Thirty-first pass, read against 4161986 — still no merges since the twenty-ninth, and bun run check is green on a clean clone (tsc --noEmit clean, 540 pass, 0 fail). #131 is in hand with scout; #105 with vesper. Nothing new is parked: #71's split (#133 → #134 → #135) stands as filed last pass.

I spent this pass reading the app as a client rather than adding to a queue that is already twenty deep. The boundary holds: POST /api/match answers 422 to a well-formed body that is not a result, 400 to junk that is not JSON, 403 to a cross-site post, 413 to 40 KB; HEAD / and HEAD /api/leaderboard are 200; a 404 still carries the security floor; /static/../src/server.ts is a 404, not a file. / is 1–2 ms and the bundle goes out gzipped. The page says the terminal is off when FORGE_APP_SSH is unset, which is the right thing rather than an invented address. I found nothing there worth an issue.

Filed, one, from walking the tree for modules with no sibling test:

• #139 — Three modules the README calls tested have no test file: action, models and textures. The Shape section says "Everything except the last five is headless and tested"; action.ts (the shipped policy's own contract — its comment says the bins are part of it, like the observation), models.ts and textures.ts have no test file at all. All three are pure functions, so this is one run: bin meanings the weights depend on, mesh arrays that agree and indices that point inside them, a texture that is the byte count the renderer assumes and is deterministic — plus the README sentence corrected to what is then true (audio is #80, weights is generated, shard runs under pool.test.ts). Ready. -> scout

Housekeeping: I first filed that issue as #138 through a shell that ate the backticks out of its title, so it reads with the three module names missing. #139 is the same issue with the title intact; #138 is commented, linked behind it, and wants closing.

Ready now: #139, #133, #130, #40, plus #46, #53, #55, #58, #59, #77, #80, #95, #97, #108, #109, #110, #111, #114, #120, #129. Nothing is assigned, nothing was pushed, and #8 stays open.

The order I would pull in: #129 (the check is red for anyone who has run the app), #133, #108, #130, #139. Still needing a person's scope, unchanged: close #126 (already on main), #54 and #61 (duplicates of #40), #74 (superseded by #131/#132), #71 (superseded by #133–#135) and now #138.

A planning run with nothing to land: the working tree is clean at 4161986 (even with main), no files were written in the clone and nothing was committed, so there is nothing to push and no pull to open. bun run check is green — tsc --noEmit clean, 540 pass, 0 fail.

This pass I read the app as a client rather than adding to a queue that is already twenty deep, and the boundary holds: POST /api/match answers 422 to a well-formed non-result, 400 to junk, 403 cross-site, 413 at 40 KB; HEAD / and HEAD /api/leaderboard are 200; a 404 still carries the security floor; /static/../src/server.ts is a 404 and not a file; / answers in 1–2 ms and the bundle goes out gzipped. Nothing there was worth an issue.

Filed one, from walking the tree for modules with no sibling test: #139 — action, models and textures have no test file, while the README's Shape section claims everything but the last five modules is tested. action.ts is the shipped policy's own contract and nothing checks its bins. All three are pure functions, so it is one run. I first filed it as #138 through a shell that ate the backticks out of the title; #138 is commented, linked behind #139, and wants closing.

What a person should look at: the pull order is #129 (the check goes red on any machine that has run the app — reproduced again last pass), then #133, #108, #130, #139. Six issues need a person's scope rather than mine: close #126 (already implemented on main), #54 and #61 (duplicates of #40), #74 (superseded by #131/#132), #71 (superseded by #133–#135) and #138. Nothing is assigned and #8 stays open.

Thirty-second pass, read against 4161986. Three passes now with no merge to main, twenty-plus issues ready and three in hand (#130 with scout, #131 with scout, #105 with vesper), so I filed nothing this pass: the queue is not what is short. I spent it turning three of the issues already in it into reproduced, measured findings a builder can start from.

#108 — reproduced. Two posts, same matchId, same session, the final one first and a stale periodic one second, against a local server:

{"rounds":20,"scoreMine":13,"scoreTheirs":7,"kills":40,"damage":6000,"seconds":2000,"finished":true} -> 200
{"rounds":6,"scoreMine":4,"scoreTheirs":2,"kills":9,"damage":1200,"seconds":600}                     -> 200
leaderboard: kills 9, damage 1200, rounds 6, score 4-2, state "finished"

A 13–7 with 40 kills and 6,000 damage is now a finished 4–2 with 9 kills. The flags held (#50's guard works); every number went backwards, and the standings are computed from that row, so one rewind rewrites a career. Transcript and the control case are on the issue.

#105 and #46 — re-measured. bun run scripts/measure.ts at this commit: 88 rounds, plant rate 61%, ends detonated 40 · time 23 · elimination 14 · defused 11, defuse rate 20% of planted bombs, median round 123s against a 115s clock, longest 156s. So rounds ending on the clock are 26%, not the 30% #105 was written on — noise, not progress — and #46's retake is the sharper number: the bomb goes down 51 times and comes back 11.

#139 and #129 stand as filed, both with their evidence on them. The boundary probe from last pass still holds (422/400/403/413 on POST /api/match, the floor on a 404, no traversal under /static/).

Ready now: #139, #40, #46, plus #53, #55, #58, #59, #77, #80, #95, #97, #108, #109, #110, #111, #114, #120, #126, #129. Nothing is assigned, nothing was pushed, and #8 stays open.

The order I would pull in: #129, #108 (now with a transcript), #46, #139, #40. Still needing a person's scope, unchanged: close #126 (already on main), #54, #61, #74, #71 and #138.

A planning run with nothing to land: the working tree is clean at 4161986 (even with main), no files were written in the clone and nothing was committed, so there is nothing to push and no pull to open.

Three passes have now gone by with no merge to main, twenty-plus issues are ready and three are in hand (#130 and #131 with scout, #105 with vesper), so I filed nothing this pass — the queue is not what is short. Instead I turned three issues already in it into reproduced findings:

#108 is reproduced end to end. Posting a final result and then a stale periodic one for the same matchId turns a finished 13–7 with 40 kills and 6,000 damage into a finished 4–2 with 9 kills and 1,200 damage. The flags hold (#50's guard works); every number goes backwards, and since the standings are computed from that row, one rewind rewrites a player's career. The transcript and the control case (same posts, other order) are on the issue.

#105 and #46 are re-measured at this commit with bun run scripts/measure.ts: 88 rounds, plant rate 61%, ends detonated 40 · time 23 · elimination 14 · defused 11, defuse rate 20% of planted bombs, median round 123s against a 115s clock. Rounds ending on the clock are 26%, not the 30% #105 was written on — noise rather than progress — and #46 is the sharper number: the bomb goes down 51 times and the CTs take it back 11.

What a person should look at: the pull order is #129, #108 (now with a transcript), #46, #139, #40. Six issues still need a person's scope rather than mine — close #126 (already implemented on main), #54 and #61 (duplicates of #40), #74 (superseded by #131/#132), #71 (superseded by #133–#135) and #138 (superseded by #139). Nothing is assigned and #8 stays open.

Thirty-third pass, read against 979c388 — #122 (players with legs) merged, and the check is green there: tsc --noEmit clean, 567 pass, 0 fail, up 27 tests.

The map I laid out is being built: five pulls are open, and all five are mergeable against main right now — but they overlap each other, so the order they land in decides whether anyone has to rebase.

#140  saved.ts (#133)          226 lines  saved.ts, saved.test.ts                     — overlaps nothing
#143  the untested three (#139) 332 lines  action, models, textures, README
#142  the pocket (#130)        189 lines  world.ts, buy.ts, hud.ts, main.ts
#136  the catalogue (#131)     227 lines  map.ts, world.ts, main.ts, settings, db, tty, result, pages, README
#137  the round clock (#105)   454 lines  bots.ts, plan.ts, map.ts, README

The order I would merge in: #140, #143, #142, #136, #137. #140 is free — two new files nobody else touches. #143 touches only the README in common. Then #142 before #136, because #142's world.ts change is confined to the buy rules while #136 reshapes map.ts and edits world.ts and main.ts; and #136 before #137, because once map.ts becomes a catalogue that is the shape #137's map.ts diff has to be written against. Whatever lands late rebases — that is what killed pull #117, and it is cheap to avoid by merging smallest-overlap first.

One thing to look at while reviewing: #143 modifies action.ts and models.ts, where #139 said the work changes no line of shipping code. It may be a legitimate export-for-testability, but it is the one place in these five where a test pull touches the policy's contract, so it wants a careful read.

sentinel's #141 (the leaderboard's seven columns at 360px) is confirmed against the code — game.ts:213–214 for the table, and the only breakpoint at :225 touches nothing on it. I linked #95 behind #141: both rewrite that table, and #141 decides what it is on a phone before #95 puts another row into it.

Nothing new filed. Five pulls in flight against two builders is the constraint, not the size of the queue.

Ready now: #40, #46, #108, #141, plus #53, #55, #58, #59, #77, #80, #97, #109, #110, #111, #114, #120, #126, #129. Nothing is assigned, nothing was pushed, and #8 stays open.

Order once the pulls clear: #129, #108 (the transcript is on it), #141, #46, #40. Still needing a person's scope: close #126, #54, #61, #74, #71, #138.

A planning run with nothing to land: the working tree is clean and even with main at 979c388, no files were written and nothing was committed, so there is nothing to push and no pull to open. The check is green there — tsc --noEmit clean, 567 pass, 0 fail, up 27 tests since #122 merged.

The map is being built: five pulls are open (#140 for #133, #143 for #139, #142 for #130, #136 for #131, #137 for #105), all five mergeable against main right now, but overlapping each other. The useful output of this pass is a merge order that keeps them that way — #140, #143, #142, #136, #137 — smallest overlap first: #140 is two new files nobody touches, #143 shares only the README, #142's world.ts change is confined to the buy rules while #136 reshapes map.ts and also edits world.ts and main.ts, and #137's map.ts diff wants to be written against the catalogue rather than before it. Whatever lands late rebases; that is what killed pull #117.

One thing for review: #143 modifies action.ts and models.ts, where #139 said the work changes no line of shipping code — probably export-for-testability, but it is the one place in these five that touches the policy's contract.

I also confirmed sentinel's #141 against the code (game.ts:213–214, the only breakpoint at :225 touching nothing on the table) and linked #95 behind it, since both rewrite that table and #141 decides what it is on a phone first. Nothing new was filed — five pulls against two builders is the constraint, not the size of the queue. Still needing a person's scope: close #126, #54, #61, #74, #71 and #138.

Thirty-fourth pass, read against e1eab3f. Two of the five pulls merged in the order I suggested — #143 (the untested three) and #136 (the map catalogue) — and the check is green there: tsc --noEmit clean, 604 pass, 0 fail. #142, #140 and #137 are still open.

I verified #131 the way a client would, not just by reading the diff: the page carries the Map select, a result posting "map":"../etc/passwd" is a 422, one posting "de_forge" is a 200 and comes back on /api/leaderboard as "map":"de_forge". The catalogue landed as MapName + MAPS + MAP_NAMES + DEFAULT_MAP + mapFor at map.ts:212–228, with settings.ts:41, result.ts:57 and main.ts:135 all validating through it.

Two things moved on the map as a result:

• #132 is unblocked and its ground has changed, so I refreshed it: the seam is now a union type plus a key, and if the pull touches anything beyond map.ts's tables, map.test.ts, README.md and scripts/measure.ts, it has grown. The one piece of plumbing left is that measure.ts cannot take a map yet, so the two-table comparison the issue asks for needs a --map flag first. de_forge's "before" numbers are on the issue.
• *#138 came back to ready* and must not be built.** It is the mangled-title copy of #139, which merged as #143; closing #139 removed the dependency that was keeping it out of the queue. Nothing is left in it, and a builder who picks it up will rewrite three test files that already exist. It is the first thing a person should close.

Nothing new filed. Three pulls are in flight and eighteen issues are ready.

Ready now: #132, #141, #40, #46, #108, plus #53, #55, #58, #59, #77, #80, #97, #109, #110, #111, #114, #120, #126, #129 — and #138, which is the one to close rather than take.

Order once the pulls clear: #129, #108 (the transcript is on it), #141 (then #95, which I linked behind it), #132, #46. Needing a person's scope: close #138 first, then #126, #54, #61, #74 and #71.

A planning run with nothing to land: the working tree is clean and even with main at e1eab3f, nothing was written or committed, so there is nothing to push and no pull to open. The check is green there — tsc --noEmit clean, 604 pass, 0 fail.

Two of the five open pulls merged in the order I suggested last pass (#143, then #136), and I verified the map catalogue the way a client would rather than by reading the diff: the page carries the Map select, a result posting "map":"../etc/passwd" is a 422, one posting "de_forge" is a 200 and comes back on /api/leaderboard as "map":"de_forge". #142, #140 and #137 are still open.

Two things moved on the map. #132 is unblocked, and I refreshed it against what actually landed — the seam is now a union type plus a key at map.ts:212–228, so the issue is the layout, its structural tests and the measurement, and the only plumbing left is that scripts/measure.ts cannot take a map yet, which the two-table comparison needs. *#138 came back to ready* and must not be built**: it is the mangled-title copy of #139, which merged as #143, and closing #139 removed the dependency keeping it out of the queue — a builder who picks it up will rewrite three test files that already exist.

Nothing new was filed; three pulls are in flight against eighteen ready issues. What a person should look at: close #138 first, then #126, #54, #61, #74 and #71. The order I would pull in once the pulls clear is #129, #108 (which now carries a reproduction transcript), #141 (then #95, linked behind it), #132, #46.

Thirty-fifth pass, read against 3162f4b. Three more merges — #144 (bullet decals, #109), #137 (bots that feel the round clock, #105) and #140 (the snapshot, #133) — and the check is green: tsc --noEmit clean, 645 pass, 0 fail. #142 (the pocket) and #145 (the leaderboard on a phone) are open; #134 is ready, which is the middle of the resume trio.

#105 worked, measured rather than assumed. Same command, same seed, before and after:

                 before (4161986)   after (3162f4b)
rounds played    88                 87
time             23  (26%)          7  (8%)
detonated        40                 47
elimination      14                 26
defused          11                 7
plant rate       61%                63%
longest round    156s               144s

Rounds expiring on the clock fell from a quarter to one in twelve. Two consequences are on the issues that own them: eliminations nearly doubled, which is the intended shape of it, and defuses fell 11 → 7 — a 13% defuse rate against 20% — so the retake got harder without anyone touching retaking. #46 has the same table and the number to move.

Filed, one, from what that table could not tell me:

• #146 — The measurement cannot say who is winning: a side split in the round report, and a --map flag. RoundRecord (rounds.ts:11) is { reason, planted, seconds } — no winner — so the report says how rounds end and never who won them, which is the first question anyone tuning bots asks. Adds the split to summarize/reportLines, and --map validated through MAP_NAMES exactly as --difficulty is. Ready. -> scout

One thing I got wrong and have corrected in the open: I linked #132 behind #146 because its before/after needs --map, then noticed #132 is already in flight with vesper, and the forge has no way to remove a dependency edge. I have said so on #132 — take the --map flag inside that pull if it is already open, and #146 becomes the side split alone.

#138 is still ready and still must not be built: it is the mangled-title copy of #139, which merged as #143. It is the first thing for a person to close.

Ready now: #134, #146, #40, #46, #108, plus #53, #55, #58, #59, #77, #80, #97, #110, #111, #114, #120, #126, #129 — and #138, to close rather than take.

Order I would pull in: #129, #108, #134 (the resume trio's middle, while #133 is fresh), #146, #46. Needing a person: close #138, then #126, #54, #61, #74, #71.

A planning run with nothing to land: the working tree is clean and even with main at 3162f4b, nothing was written or committed, so there is nothing to push and no pull to open. The check is green there — tsc --noEmit clean, 645 pass, 0 fail — after #144, #137 and #140 merged.

#105 worked, and I measured it rather than assuming. Same command and seed, before (4161986) and after (3162f4b): rounds ending on the clock fell from 23 of 88 (26%) to 7 of 87 (8%), the longest round from 156s to 144s, eliminations nearly doubled — and defuses fell 11 → 7, a 13% defuse rate against 20%, so the retake got harder without anyone touching retaking. The full table is on #105 and on #46, which now has its "before" column and the number to move.

Filed one issue from what that table could not answer: #146 — the round report cannot say who is winning. RoundRecord is { reason, planted, seconds } with no winner, so summarize describes how rounds end and never who won them; the issue adds the side split and a --map flag validated through MAP_NAMES, which #132 also needs.

One correction in the open: I linked #132 behind #146 before noticing #132 is already in flight with vesper, and the forge offers no way to remove a dependency edge. I said so on #132 — take the --map flag inside that pull if it is open, and #146 becomes the side split alone. #138 is still ready and still must not be built (it is the mangled-title copy of #139, merged as #143); it is the first thing for a person to close, then #126, #54, #61, #74 and #71. The order I would pull in is #129, #108, #134, #146, #46.

Thirty-sixth pass, read against d54675d. Three more merges and no open pulls: #147 (de_cinder, #132), #145 (the leaderboard at 360px, #141) and #142 (the pocket, #130). The check is green: tsc --noEmit clean, 664 pass, 0 fail. #134 and #146 are in hand with scout.

I measured the second map rather than taking the pull's word for it (twelve seeded matches each, at this commit):

                 de_forge      de_cinder
plant rate       63%           48%
ends             det 47 · time 7 · elim 26 · def 7     det 36 · time 4 · elim 42 · def 6
median round     123s          95s

Pull #147's own thirty-match run says the same thing with a smaller gap (63% against 52%), explains it as geometry — no spawn near both sites, both sides still moving when they meet — and accepts it rather than tuning it away. I agree with that call for a layout. What it leaves open is the half a layout cannot answer, and that is the issue I filed:

• #150 — Does the policy transfer? The arena only knows de_forge, so nobody has measured the bots on the second map. arena.ts:17 imports DE_FORGE directly and builds its spawn grid from it, so every duel the policy was trained and evaluated in happens on one map; CARD.winRate (72%) on the page and in the terminal is that number. Thread the map through the arena, reach evaluate with it, and state four numbers — policy and scripted baseline, on each map, same 240 seeded duels. No retraining in that issue: an honest number is the deliverable, and a training run is its own pull. Ready. -> scout

Also refreshed: #37 (smoke) is unblocked and now has the pocket's real shape on it — grenades: Partial<Record<WeaponId, number>> at world.ts:47–52, a per-kind MAX_GRENADES with no shared total (so whether HE + smoke is capped at two is a decision that belongs in that pull), and GRENADE_IDS derived from WEAPONS, so a smoke joins the pocket by being a grenade.

#138 is still ready and still must not be built — the mangled-title copy of #139, merged as #143. First thing for a person to close.

Ready now: #150, #37, #40, #46, #95, #108, plus #53, #55, #58, #59, #77, #80, #97, #110, #111, #114, #120, #126, #129 — and #138, to close.

Order I would pull in: #129, #108, #150, #46, #37. Needing a person: close #138, then #126, #54, #61, #74, #71.

A planning run with nothing to land: the working tree is clean and even with main at d54675d, nothing was written or committed, so there is nothing to push and no pull to open. Three more merges (#147 de_cinder, #145 the leaderboard at 360px, #142 the pocket), no open pulls, and the check is green — tsc --noEmit clean, 664 pass, 0 fail.

I measured the new map rather than taking the pull's word for it: twelve seeded matches each give de_forge a 63% plant rate with a 123s median round, and de_cinder 48% with a 95s median and eliminations up from 26 to 42 of ~88 rounds. Pull #147's own thirty-match run reports the same shape with a smaller gap and accepts it as geometry, which is the right call for a layout — but it leaves the half a layout cannot answer, which is the issue I filed.

#150 — does the policy transfer? arena.ts:17 imports DE_FORGE directly and builds its spawn grid from it, so every duel the shipped weights were trained and evaluated in happened on one map, and the 72% on the policy card is that number. The issue threads the map through the arena, reaches evaluate with it, and asks for four numbers — policy and scripted baseline on each map over the same 240 seeded duels — with no retraining, because an honest number is the deliverable.

I also refreshed #37 (smoke), now unblocked, with the pocket's real shape: grenades: Partial<Record<WeaponId, number>>, a per-kind MAX_GRENADES with no shared total (so whether HE + smoke is capped at two is a decision for that pull), and GRENADE_IDS derived from WEAPONS.

What a person should look at: #138 is still ready and must not be built — it is the mangled-title copy of #139, merged as #143 — then close #126, #54, #61, #74 and #71. The order I would pull in is #129, #108, #150, #46, #37.

Thirty-seventh pass, read against a3d302b. Three merges — #149 (the side split and --map, #146), #152 (audio's recording context, #80) and #153, which is worth singling out: vesper opened it against #74, found the feature already on main from #136/#147/#149, and shipped only what was missing — a seeded headless match played to a result on every map in MAP_NAMES, crates checked for standing on floor with two open sides, and settings.ts round-tripping every map name. That is the right answer to a superseded issue, and it closes #74 properly rather than duplicating it. The check is green: tsc --noEmit clean, 685 pass, 0 fail. #148 (#134) and #151 (#108) are open.

The side split's first reading is a finding. Twenty seeded matches a map, same shipped policy, the person idle:

                 de_forge                      de_cinder
rounds played    145                           131
side split       T 62% (90) · CT 38% (55)      T 47% (61) · CT 53% (70)
plant rate       65%                           52%
defused          12 of 95 plants (13%)         10 of 68 plants (15%)
median round     123s                          97s

Ninety rounds to fifty-five on the default map, three standard deviations from even, with the sides swapping at half time — so it is the side winning, not a lucky team — while the same bots are within a coin flip on de_cinder. Filed:

• #154 — de_forge is terrorist-sided: T win 62% of rounds there and 47% on de_cinder, with the same bots. Diagnosis before change, out of the data (bomb too easy to plant, retake never arrives, or CTs lose the opening fight), then the smallest fix in whatever the measurement blames — layout tables or plan.ts, not both, no per-map special case, no retraining. After: within ten points of even over 140+ seeded rounds with plant rate and round length still in band. Linked behind #46, because a retake that works moves this exact number. -> vesper

The same table is now on #46, which is the other half and is ready today: twelve defuses in ninety-five plants on de_forge.

#138 is still ready and still must not be built — the mangled-title copy of #139 (merged as #143). It and #126 (already implemented) are the two a person can close in a minute.

Ready now: #46, #150, #37, #40, #95, plus #53, #55, #58, #59, #77, #97, #110, #111, #114, #120, #126, #129 — and #138, to close.

Order I would pull in: #129, #46 (then #154 re-measures), #150, #37, #95.

A planning run with nothing to land: the working tree is clean and even with main at a3d302b, nothing was written or committed, so there is nothing to push and no pull to open. Three merges since the last pass (#149 the side split, #152 audio's recording context, #153 the tests that finish #74), and the check is green — tsc --noEmit clean, 685 pass, 0 fail.

The new side split earns its keep immediately. Twenty seeded matches a map, same shipped policy: de_forge is T 62% (90 rounds) to CT 38% (55), while de_cinder is 47/53 — three standard deviations from even, with sides swapping at half time, so it is the side winning rather than a lucky team, and the same bots are balanced on the other map. Twelve of ninety-five plants on de_forge come back defused.

I filed #154 for that: diagnosis out of the data before any change, then the smallest fix in whatever the measurement blames — layout tables or plan.ts, not both, no per-map special case, no retraining — with the after-table having to show the split within ten points of even while the plant rate and round length stay in band. It is linked behind #46, because a retake that works moves the same number; #46 now carries the same table and is ready today.

Worth noting for a person: vesper's #153 is how a superseded issue should be handled — it found #74's feature already on main and shipped only the missing tests instead of rebuilding it. Still one minute of work for someone with the scope: close #138 (the mangled-title copy of #139, merged as #143) and #126 (already implemented). The order I would pull in is #129, #46, #150, #37, #95.

Thirty-eighth pass, read against a3d302b — no merges since the last one, so the code is where I measured it and I have not re-run what has not changed. Four pulls are open and, unusually, none of them can conflict: their file sets are disjoint.

#148  restoreWorld (#134)      193 lines  world.ts, world.test.ts
#151  the posts race (#108)     78 lines  db.ts, db.test.ts
#156  the rebind harness (#114) 327 lines  capture.ts, capture.test.ts, main.ts
#157  the HUD budget (#120)    396 lines  hud.ts, hud.test.ts, record2d.ts, README

Any order merges cleanly. The only one worth reading twice is #151, since it is the fix for the rewind I reproduced on #108 — the transcript there is the test pair to check it against: the same two posts in either order must leave the same row.

sentinel's #155 is a real hole in my own plan and I have folded it in. snapshot was fixed in #133 when de_forge was the only layout; #153 landed the second one and main.ts:612 now builds its world through mapFor(settings.map), so a snapshot says nothing about which map it was played on and a resume would come back on whatever the Map select happens to hold. #135 now waits on #155 as well as #134, and I have written on it what that changes: pass mapFor(save.map) into restoreWorld, say the map on the resume line — Resume match — de_cinder, round 9, 5–3 — and test that a snapshot whose map differs from the select still resumes on its own.

Nothing new filed. Four pulls in flight, twenty issues ready, and the two findings from last pass (#154 behind #46, both carrying the side-split table) are still the sharpest things in the queue.

Ready now: #46, #150, #37, #40, #95, plus #53, #55, #58, #59, #77, #97, #111, #126, #129 — and #138, which is the mangled-title copy of #139 (merged as #143) and must be closed, not taken.

Order I would pull in: #129, #46 (then #154 re-measures), #150, #37, #95. A person's minute: close #138 and #126.

A planning run with nothing to land: the working tree is clean and even with main at a3d302b, nothing was written or committed, so there is nothing to push and no pull to open. No merges since the last pass, so I did not re-run measurements against code that has not changed.

Four pulls are open — #148 (restoreWorld), #151 (the posts race), #156 (the rebind harness), #157 (the HUD budget) — and their file sets are disjoint, so any merge order is clean. The one worth reading twice is #151: it is the fix for the rewind I reproduced on #108, and the transcript there is the test pair to check it against — the same two posts in either order must leave the same row.

The substantive planning change is that sentinel's #155 is a real hole in my own resume plan, and I folded it in: a snapshot records no map, while main.ts:612 now builds its world through mapFor(settings.map), so a resume would come back on whatever the Map select happens to hold. #135 now waits on #155 as well as #134, with a note on it saying what that means concretely — pass mapFor(save.map) into restoreWorld, name the map on the resume line, and test a snapshot whose map differs from the select.

Nothing new was filed; the queue is twenty deep with four pulls in flight, and last pass's findings (#46 and #154, both carrying the side-split table) are still the sharpest things in it. A person's minute: close #138 (the mangled-title copy of #139) and #126 (already implemented). The order I would pull in is #129, #46, #150, #37, #95.

Thirty-ninth pass, read against 7b34305. Two merges — #151 (the posts race, #108) and #148 (restoreWorld, #134) — and the check is green: tsc --noEmit clean, 692 pass, 0 fail. #156 and #157 are open.

#151 verified the way I broke it. The same two posts that rewound a match last week — the final one first, a stale periodic one second — now leave the row alone:

before the fix:  kills 9,  damage 1200, rounds 6,  score 4-2,  seconds 600,  state finished
after the fix:   kills 40, damage 6000, rounds 20, score 13-7, seconds 2000, state finished

#155 parked (pull #158 closed on a check whose entire summary was test exited with code 1), and it is split rather than retried. Nothing in the finding was wrong; the pull's shape was — it changed saved.ts and world.ts in one diff on a branch stacked on another pull's branch (scout/134, six commits), so a red check had no readable half.

• #160 — Saved gains map, validated like every other field. saved.ts + saved.test.ts only: written by snapshot from the world's own map, refused by parseSaved when missing, not a string, or outside MAP_NAMES, with "old snapshots are refused, no migration" stated in one line. restoreWorld keeps its parameter for now. Ready. -> scout
• #161 — restoreWorld reads the map from the save. world.ts + world.test.ts only: the parameter goes, MAPS[save.map] replaces it, and a match snapshotted on de_cinder comes back on de_cinder. Waits on #160. -> scout

Both carry the one concrete instruction #158 missed: branch from main, not from another pull's branch, and run bun run check on a clean clone first — main is green, so a red check is the branch's own, and bun test --rerun-each 2 is worth a minute when the summary says nothing. #155 is linked behind both and wants closing; #135 now waits on #161.

Ready now: #160, #46, #150, #37, #40, #95, plus #53, #55, #58, #59, #77, #97, #111, #126 — and #138, still the mangled-title copy of #139 and still to be closed rather than taken.

Order I would pull in: #160, #46 (then #154 re-measures the side split), #150, #37, #95. A person's minute: close #138 and #126.

A planning run with nothing to land: the working tree is clean and even with main at 7b34305, nothing was written or committed, so there is nothing to push and no pull to open. Two merges (#151 the posts race, #148 restoreWorld), and the check is green — tsc --noEmit clean, 692 pass, 0 fail.

#151 is verified the way I broke it. The same two posts that rewound a match — the final result first, a stale periodic one second — now leave the row at 40 kills, 6,000 damage, 20 rounds and 13–7 instead of collapsing it to 9 kills and 4–2.

#155 parked, on a check whose entire summary was test exited with code 1, so I split it rather than asking for a retry. The finding was right; the pull's shape was not — it changed saved.ts and world.ts in one diff on a branch stacked on another pull's branch, leaving a red check with no readable half. It is now #160 (Saved gains map, saved.ts and its test only, ready) and #161 (restoreWorld reads the map from the save, world.ts and its test only, waiting on #160), both carrying the one concrete instruction the failed attempt missed: branch from main, not from another pull's branch, and run bun run check on a clean clone first. #155 is linked behind both, and #135 now waits on #161.

The order I would pull in is #160, #46 (then #154 re-measures the side split), #150, #37, #95. A person's minute, unchanged: close #138 (the mangled-title copy of #139) and #126 (already implemented on main).

Filed, in order:

• #166 — The check is red on main and production is not serving: one test steps a whole match and times out at 5 s. Production is failed with test: test exited with code 1 and the app answers 404; the single failure is world.test.ts:710, which walks a ten-player world to half time by stepping 57,600 real ticks (6.4 s on the forge box, 3.1 s here, against bun's 5 s default). It is also what closed pull #164 and got #111 parked for a fault that was not its own. Suggested: scout.
• #167 — The map names its own rooms: places on MapDef and placeAt. The first half of #111, on its own, with nothing reading it yet and a structural test that every walkable cell of every map has a name. Waits on #166. Suggested: scout.
• #168 — A bot says what it sees, once: a sighting callout on the message line, to its own side only. The second half of #111, narrowed to contact sightings — the defuse call, the last-magazine call and noise are explicitly left out. Waits on #167 and #166. Suggested: vesper.
• #169 — A bot on a pistol round walks past the rifle on the floor. updatePickups gives any player a gun they step over, but bots.ts never reads world.pickups, so the drop economy is a rule only the person plays by. Waits on #166. Suggested: vesper.

Housekeeping on the map: #111 closed and split into #167/#168 with the parked comment answered; #138 closed (its successor #139 merged as pull #143). I could not close #126 (already true on main), #54 and #61 (both duplicates of #40) — the API refuses a close on issues I did not author — so each now carries a comment saying done, do not build; a person can close them with a click.

Ready now: #166 — and it should go first, because nothing else can go green until it does — alongside the existing ready set (#40, #46, #37, #53, #55, #58, #59, #77, #95, #97, #150, #154, #161). Nothing was pushed; the branch is unchanged and #8 stays open.

Since the last pass the map moved under it: #166 merged as #171 (the half-time restore test now forces rules.tick's timeout path instead of stepping 57,600 ticks, and bots.test.ts and the full-match test carry explicit timeouts), the check is green on main at 6b43481, and production is serving again. Pull #172 then reopened #111's work, green, carrying both halves I had split.

Map repaired first:

• #155 commented and left to a person to close — its two halves merged as #163 and #170, so a resumed match already comes back on the map it was played on; it is authored by sentinel and the API refuses my close. It is still showing as working with scout on it, which is a run being spent on finished work.
• #167 and #168 commented: pull #172 contains exactly their diffs, so they are to be closed against it if it merges, not built twice. A note on #172 itself says the same to whoever decides it, and that the red on the earlier attempt was #166's timeout and nothing to do with that code.

Opened, in order:

• #173 — The match you just played has no page: GET /m/<id>, linked from every row on the board and reachable from the terminal. Every column a page needs is already on match in src/db.ts; the server has four routes and none of them shows one match. Id validated before it reaches the database, the security floor plus private, no-cache, nothing the board does not already show, and the same view on Enter in the terminal. Suggested: scout. Ready.
• *#174 — Bomb planted — where*: the message line names the place, in the map's own words. One placeAt lookup at the moment of the plant; no second vocabulary, nothing the bots or the policy see. Waits on #167 (so on #172). Suggested: scout**.
• #175 — The knife is a 55-damage hitscan with no back to stab. One damage number and 64 units of range; nothing reads which way the victim faces, so a flank is worth nothing. One geometric test with a named threshold, armour unchanged, rifles provably untouched. Suggested: vesper. Ready.
• *#176 — README's What is real and what is not* is one 84-line paragraph. A reordering into headed subsections with not one claim changed. Suggested: scout**. Ready.

Ready now: #173, #175, #176, plus #40, #46, #37, #53, #55, #58, #59, #77, #95, #97 — and #169 is already in hand with vesper. Nothing was assigned and nothing was pushed: the branch is at 6b43481, identical to main, so there is no diff to open a pull with. Still on a person's minute: close #155, #126, #54 and #61, all four of which carry a comment saying why.

Since the last pass, four merges landed: #172 (the callout and the map's places), #165 (#150's transfer measurement), #177 (#155, confirmed a no-op) and #178 (#175's knife backstab, filed last pass and already built). main is at 53ce30c and bun run check is green — 733 pass, types clean. I closed #167 and #168 against #172; #150, #155 and #175 closed themselves on merge.

Opened, in order:

• #180 — The menu remembers your map and your difficulty but forgets your name, your side and the match length. settings.ts persists seven things; the three fields at game.ts:279-289 are not among them, so a player who always plays Competitive as T under one name refills the form every visit. Each field guarded the way difficulty and map already are. Suggested: scout. Ready.
• #181 — A teammate's call you can hear. #172 taught four bots to talk and #103 gave the person three radio calls; both are silent, and a line of text mid-firefight is a line nobody reads. A non-positional blip, muted and rate-limited by callout.ts's existing gaps, tested against the recording AudioContext. Waits on #110, whose pull is rewriting audio.ts. Suggested: vesper.
• #182 — The AWP's scope zooms the view but not the mouse. main.ts:782 draws the scope at 40° against 90° at the hip while controls.sensitivity is one number, so a scoped flick sweeps the same degrees across less than half the world: the precision gun is the twitchiest thing in the game. One derivation, one remembered setting, touch included. Suggested: vesper. Ready.
• #183 — The HUD shows one message at a time, so a bot's callout wipes Bomb planted. hud.ts:496 draws only the newest of the six say() keeps, for four seconds — and #172 set SIDE_GAP to four seconds precisely because of that, so an enemy seen just after a plant erases the plant. A stack or a rank, inside the HUD's draw budget and readable at 360px. Waits on #120 and #110, both holding hud.ts. Suggested: scout.

I also rewrote the scope of #154 in a comment rather than leaving it to be built as written: its T 62% on de_forge is one sample, and three more runs today read 56%, 58% and 48%, so done now starts with a pooled multi-seed measurement (and an accounting of the idle person) and closes the issue outright if the split turns out to be within a couple of points of even — changing walls to make one seed read 50% is fitting the map to a table.

Ready now: #180, #182, #173, #176, plus #40, #46, #37, #53, #55, #58, #59, #77, #95, #97; #174 and #169 are already in hand, and #135 is unblocked at last. Nothing was assigned and nothing was pushed — the branch is at 53ce30c, byte-identical to main, so there is no diff to open a pull with. Still a person's minute: close #126, #54 and #61, which the API will not let me close and which each carry a comment saying why.

No code was written this run — planning only — so there is nothing to commit; the working tree is clean and the branch is at 0644e74, byte-identical to main, whose check (tsc --noEmit + bun test) I ran green as found. The result is on the map, not in a diff.

Filed against direction #8, in order:

• #184 — The first paint groups every match ever played. standings in src/db.ts is a full-table GROUP BY identity asked for on GET /, in every POST /api/match response and on every terminal frame. Seeded through saveMatch itself: 41.6 ms at 50k rows, 171.1 ms at 200k, while recentMatches stays at 0.07 ms because match_by_time serves it. Budget test first, then a flat cost; the MAX(...)-on-conflict update is the trap an aggregate has to respect. Ready. → scout
• #185 — Switching weapons is instant. world.ts:1196 sets p.weapon and never touches nextShotAt, so knife-running at 250 u/s into a same-frame AK shot is free and the three carrySpeed numbers are decoration; takePickup has the same hole. Asks for deployTime, with the arena measured before and after and the shipped weights left alone. Ready. → vesper
• #186 — Reloading is silent. SoundName has no reload and reload/finishReload/takePickup push no effect, so the loudest two seconds in the game are inaudible to you and to whoever is next door, with ears.ts already able to pan it. Waits on #110 (pull #159 is rewriting audio.ts). → vesper
• #187 — A bot reloads only when its magazine is empty. bots.ts:426/:598 are the only reload a bot ever asks for, so it pushes a site on three rounds and then stands still for 2.5 s in front of what it was shooting at. Waits on #169, same file and in hand. → vesper

Ready now: #184, #185, plus #40, #46, #37, #53, #55, #58, #59, #77, #95, #97, #126, #173, #174, #176, #180, #182. Nothing is parked. Nobody is assigned and #8 stays open. Left for a person's click: close #126 (already true on main), #54 and #61 (duplicates of #40) — the API refuses a close on issues I did not author, and each carries a comment saying why.

🤖 Generated with Claude Code

Budget reached at $2.55; this is where it stopped.

A planning pass against direction #8, read against main at 9ba7609 with bun run check green as found (738 pass, types clean). No code was written, so this branch carries no diff — it was fast-forwarded to main and pushed; the result is on the issue map.

Filed, in order:

• #189 — A bullet that lands does not slow the player it hits: no tagging, so trading a shot costs the enemy nothing. shoot resolves damage, pushes hurt and calls flinch, and touches the victim's velocity nowhere, so hitting someone first buys nothing and there is no reason to hold an angle. Tagging cannot take flinch's escape hatch (a slow only on world.me would handicap the person alone), so it goes in the tick symmetrically with the arena as the gate: scripts/measure.ts before and after, both numbers in the pull. Waits on #185, which is already in the same movement-speed plumbing. → vesper
• #190 — A drop from anywhere is free: fallDamage is written, tested and called by nothing. physics.ts:221 is exported, documented and asserted twice; move clears vel[2] before anyone reads the impact speed. Carries the measurement that matters: the tallest standable surface on either map is a 128-unit crate top, about 452 u/s, under the 580 threshold — so wiring it is about the simulation being whole, and the README says so plainly instead of inventing a drop. Deleting the function is an acceptable answer if argued. Ready. → scout
• #191 — A thumb aims with the mouse's sensitivity: touch look has no setting of its own. input.ts:240 multiplies a drag by the same number pointer lock uses, and the one field on the page moves both, so tuning a phone breaks the desktop. Asks for a validated, remembered touchSensitivity and a 44px control in the pause overlay, shown only where touch exists. Waits on #182. → vesper
• #192 — The security floor is missing its two isolation headers: COOP and CORP on every response. The floor has CSP, nosniff, referrer, permissions and HSTS; a window handle and subresource embedding are still open. Two lines in SECURITY so every path inherits them, asserted across the page, the bundle, both APIs and the 403/404/413/429/500, with COEP deliberately left out. Ready. → scout

Map repair: #174 closed against pull #188, which built exactly it. #71 was parked for a failed check on pull #117 and is now simply done — #163, #170, #177 and #179 landed the snapshot, its map and the Resume button — so it carries a comment saying so; it is authored by someone else and the API refuses my close. The other parked comments on #37, #40, #46, #53, #54, #55, #58, #59, #61 and #169 are quota and DNS failures, not work that could not be done as written, so they stand unchanged.

Ready now: #190, #192, plus #173, #176, #180, #182, #184, #185, #37, #40, #46, #53, #55, #58, #59, #77, #95, #97, #126. Nobody is assigned and #8 stays open. Still a person's click: close #126 (already true on main), #54 and #61 (duplicates of #40) and #71 — each carries a comment saying why.

🤖 Generated with Claude Code

Budget reached at $2.56; this is where it stopped.

Nothing was written this run — planning only — so there is nothing to commit or fix: the working tree is clean, the branch is at 9ba7609, byte-identical to main, and git push reports everything up to date. No half-done change exists to remove.

The result is on the issue map for direction #8, read against main with every claim measured against the working tree:

• #194 — A bot with an AWP fires it from the hip: no bot ever scopes, so the most accurate gun in the game sprays a 7.7° cone. input.scope appears nowhere in bots.ts; botBuy still hands rich bots an AWP. Measured through the shipped inaccuracy: 7.73° hip-strafing — a 136-unit cone at 1000 units against a 32-unit body — versus 0.49° scoped. Waits on #169 (same file, in hand). → vesper
• #195 — The match-over screen hides the scoreboard it was just showing. summarize reads world.me only, so the overlay replaces the ten-row board with four lines about you. Ready. → scout
• #196 — The renderer owns the frame and nobody counts it: a per-frame draw budget the recording WebGL2 context enforces. The tick is alarmed by scripts/cost.ts and the HUD by #120; the 3D renderer has no ceiling, though renderer.test.ts already counts draw calls for relative claims. Ready. → scout
• #197 — A 64-unit crate is 7 units too tall to jump onto, and crouch-jumping does nothing. Measured with the real move: apex 57.0 units with duck and without, landing beside the box, because hullHeight shrinks from the top and never lifts the feet. 15 such boxes on de_forge, 19 on de_cinder. Ready. → vesper

What a person should look at: the four issues above, and four closes the API refuses me — #126 (already true on main: / answers cache-control: private, no-cache), #54 and #61 (duplicates of #40), and #71 (done by #163/#170/#177/#179). Each carries a comment saying why. Nobody is assigned and #8 stays open.

🤖 Generated with Claude Code

Budget reached at $2.54; this is where it stopped.

This was a planning run, so there is no diff: the working tree is clean, the branch sits on main at 9ba7609, and git push reports everything up to date. Nothing half-done exists to remove. The result is on the issue map for direction #8, every claim read against the working tree and the running app (/ answers in 1.4–2.0 ms with the security floor and cache-control: private, no-cache intact).

Filed, in order:

• #199 — A kill looks exactly like a hit, and a grenade that lands looks like nothing. shoot pushes { kind: "hitmark", headshot } and nothing that says killed, so the bullet that drops someone draws the same mark as the four before it; detonate (world.ts:1018) applies blast damage, records it and calls onKill while pushing no hitmark at all, so your own HE on two people looks like one thrown at a wall. Asks for killed on the effect and on the earshot cue, a blast hitmark guarded to world.me so the RL arena's hot loop is untouched, and deliberately leaves audio.ts alone — the kill tone waits for the rewrite in flight under #110, with the flag put on the cue ready for it. Ready. → vesper
• #200 — A result the server refused vanishes without a word. postResult (main.ts:564) ignores 409, 413, 422, 429, 500 and a thrown fetch alike: the player reads a board that silently disagrees with the match they just played, and the retry-after the server carefully sends is read by nobody. Asks for a headless src/client/posting.ts that maps status → wording and one retry for the final post, a hidden line in the leaderboard section written with textContent, and words that never claim a save that did not happen. Ready. → scout
• #201 — The round's damage report is 64 lines nobody tests. reportPanel.ts is one of two client modules with no test beside it, and it carries arithmetic worth pinning — the row count, MAX_LINES, the width - 24 clamp, and drawing nothing outside phase === "over" — while hud.test.ts:20 already has the recording 2D context it needs. Ready. → scout

Ready now: #199, #200, #201, plus #37, #40, #46, #53, #55, #58, #59, #77, #95, #97, #126, #173, #176, #180, #184, #185, #190, #191, #192, #195, #196, #197. Nobody is assigned and #8 stays open.

What a person should look at: the three issues above, and four closes the API refuses me — #126 (already true on main), #54 and #61 (duplicates of #40), and #71 (the one parked issue, done by #163/#170/#177/#179). Each already carries a comment saying why.

🤖 Generated with Claude Code

Budget reached at $2.52; this is where it stopped.

A planning pass against direction #8, read against main at 9ba7609 with the app booted and probed. No code was written, so this branch carries no diff.

Filed, in order:

• #203 — A round your own teammate stops vanishes. shoot (world.ts:843) returns before every line that says the bullet arrived — no blood, no impact, no mark, no word — so pushing a site behind a bot looks like a broken gun. Feedback only, no friendly fire, gated to the person so the arena's loop is untouched. Waits on #199, same six lines. → vesper
• #204 — The death notice has no killer health. FeedEntry carries who and what but not how close you came; recorded at the kill, never read live, so a spectator learns nothing they should not see. Ready. → vesper
• #205 — The terminal draws 29 lines into a 24-row window. Measured with the real render and 20 rows: 29 lines on both list tabs, so the title, the help line and the FORGE_APP_SSH line scroll away and x deletes a row off screen. process.stdout.rows appears nowhere. Ready. → scout
• #206 — /favicon.ico is a 404 on every visit, and there is nothing to add to a phone's home screen. Verified against the running server. An SVG icon generated by a module and a manifest, no binary in the tree, the floor and HEAD on both. Ready. → scout

What I looked at and did not file: the fixed 64 Hz step with interpolation, freeze-time locking, walk/duck silence, alive counts, spectating and the death camera, match rules with halftime and the loss bonus, gzip and the immutable bundle, the same-origin gate and the byte-counted body — all already right.

Ready now: #204, #205, #206, plus #37, #40, #46, #53, #55, #58, #59, #77, #95, #97, #126, #173, #176, #180, #184, #189, #190, #191, #192, #195, #196, #197, #199, #200, #201. Nobody is assigned and #8 stays open. Still a person's click: close #126 (already true on main), #54 and #61 (duplicates of #40) and #71 (done by #163/#170/#177/#179) — each carries a comment saying why.

A planning run against direction #8: no code was written, so this branch is byte-identical to main at 9ba7609, the working tree is clean, and git push reports everything up to date. Nothing half-done exists to remove; the check was not re-run because there is no diff to check. The result is on the issue map, with every claim read against the working tree and the booted server.

Filed, in order:

• #203 — A round your own teammate stops vanishes: no blood, no impact, no word that a bot was in your line. shoot (src/client/world.ts:843) returns above every line that says the bullet arrived, so the tracer ends on nothing while a teammate eats your spray. Feedback only, no friendly fire, gated to the person so the RL arena's hot loop stays flat. Waits on #199, which edits the same six lines. → vesper
• #204 — Killed by whom, with what — but not how close you came. FeedEntry carries no killer health; it is recorded at the kill and never read live, so a spectator learns nothing they should not see. Ready. → vesper
• #205 — The terminal draws 29 lines into a 24-row window. Measured by running the real render with 20 rows: 29 lines on both list tabs, so the title, the help line and the FORGE_APP_SSH line scroll off and x deletes a row that is off screen; process.stdout.rows appears nowhere in src/tty.ts. Ready. → scout
• #206 — /favicon.ico answers with the 404 page on every visit, and there is nothing to add to a phone's home screen. Verified against the running server. A generated SVG icon and a manifest, no binary in the tree, the security floor and HEAD on both. Ready. → scout

What a person should look at: those four issues, the new edge #203 → #199, and four closes the API refuses me — #126 (already true on main), #54 and #61 (duplicates of #40) and #71 (the parked one, done by #163/#170/#177/#179); each carries a comment saying why. Nobody is assigned and #8 stays open.

🤖 Generated with Claude Code

Budget reached at $2.52; this is where it stopped.

A planning pass against direction #8, read against main at 598c302 — two commits newer than the last pass, with #198 (scoped mouse speed) and #202 (deployTime) landed. The branch was fast-forwarded to main; no code was written.

Filed, in order:

• #208 — The gun is up on screen a second before it can fire. #202 gave the AWP a 1.25 s deploy; renderer.ts:231 still raises every weapon over a fixed RAISE_TIME = 0.24, and the comment at :774 still says the switch "is instantaneous and stays that way". You click for a second and nothing happens. The reload dip ten lines below already runs on the weapon's real reloadTime — that is the pattern. Ready. → vesper
• #209 — The bots fight with a policy trained on 2026-09-17. CARD claims 72% against the scripted baseline; the simulation has since gained a knife with a back (#178) and a deploy time on every weapon (#202), with tagging (#189) and crouch-jump (#197) queued. scripts/duel.ts already runs the shipped weights on both maps: re-measure, record the simulation's commit on the card, retrain only if the number moved. Ready. → vesper
• #210 — 90° of view, take it or leave it. HIP_FOV is a constant and the camera already takes fov as data; a phone at 360 px sees exactly what a 27-inch monitor does. A validated, remembered 70–110 setting, with the explicit rule that a chosen hip FOV must not ride #198's screenShare sensitivity curve. Ready. → vesper
• #211 — renderer.ts is four concepts in 855 lines. Four GLSL sources, the GL plumbing, and a 470-line closure that is the camera, the level, the effects and the viewmodel. Lift out shaders.ts and a viewmodel.ts that is testable with no GL at all; the recording context's draw-call counts are the guard that nothing moved. Waits on #208 and #196, which both edit those lines. → scout

Map repair: #71 is closed — it was the one parked issue, and #163/#170/#177/#179 built it; the close went through this time. Nothing is parked now.

Ready now: #208, #209, #210, plus #37, #40, #46, #53, #55, #58, #59, #77, #95, #126, #173, #176, #180, #184, #189, #190, #191, #192, #195, #196, #197, #200, #201, #204, #205, #206. Nobody is assigned and #8 stays open. Still a person's click: close #126 (already true on main), #54 and #61 (duplicates of #40).

A planning run against direction #8, read against main at 598c302 — two commits newer than the last pass, with #198 (scoped mouse speed) and #202 (deployTime) landed. The branch was fast-forwarded to main and pushed; no code was written, so there is no diff and nothing to check.

Filed, in order:

• #208 — The gun is up on screen a second before it can fire. #202 gave the AWP a 1.25 s deploy, but renderer.ts:231 still raises every weapon over a fixed RAISE_TIME = 0.24, and the comment at :774 still claims the switch "is instantaneous and stays that way": you click for a full second and the game does nothing. The reload dip ten lines below already runs on the weapon's real reloadTime — that is the pattern to copy. Ready. → vesper
• #209 — The bots fight with a policy trained on 2026-09-17. CARD claims 72% against the scripted baseline, measured before the knife got a back (#178) and before every weapon got a deploy time (#202). scripts/duel.ts already runs the shipped weights on both maps: re-measure, record the simulation's commit on the card, retrain only if the number moved. Ready. → vesper
• #210 — 90° of view, take it or leave it. HIP_FOV is a constant and the camera already takes fov as data, so a phone at 360 px sees exactly what a 27-inch monitor does; a validated, remembered 70–110 setting, with the explicit rule that a chosen hip FOV must not ride #198's sensitivity curve. Ready. → vesper
• #211 — renderer.ts is four concepts in 855 lines. Lift out shaders.ts and a viewmodel.ts testable with no GL at all, with the recording context's draw-call counts as the guard that nothing moved. Waits on #208 and #196. → scout

Map repair: #71 is closed — it was the only parked issue and #163/#170/#177/#179 had already built it; the close went through this time, so nothing is parked. What a person should still click: close #126 (already true on main) and #54/#61 (duplicates of #40), each of which carries a comment saying why. Nobody is assigned and #8 stays open.

🤖 Generated with Claude Code

The map's direction issue (#8) stays open; nothing was pushed, since a planning run's result is the map.

Opened this run, in order

• #208 — the raise is a fixed 0.24 s while the AWP's deploy is 1.25 s, so the gun is on screen long before it can fire → vesper
• #209 — the bots fight with a policy trained 2026-09-17 against a simulation that has changed four times since → scout
• #210 — no field-of-view setting: 90° take it or leave it, and a phone sees the least of the map (without letting the choice touch hip sensitivity) → scout
• #211 — renderer.ts is four concepts in 855 lines: lift shaders.ts and viewmodel.ts out, behaviour byte-for-byte unchanged; waits on #196 and #208 → scout
• #215 — the detour predicate in plan.ts: is a gun on the floor worth walking to, as pure arithmetic tested without a world → scout
• #216 — a bot with an empty primary slot walks over the rifle on its way: the goal in bots.ts, a headless test, and one 8-match single-map table; waits on #215 → vesper

The parked issue. #169 had been parked twice with "no changes pushed (timeout)", and the reason was in its own acceptance criteria: measure.ts --matches 30 --seed 41 on both maps, before and after, is roughly half an hour of compute — I timed --matches 2 at 30.2 s wall clock. I closed it with a comment and split it into #215 (arithmetic, no measurement) and #216 (wiring, a two-minute table), and moved #187 and #194 behind #216 so edits to bots.ts stay serial.

Ready now: 27 issues, 0 parked. The cheapest useful starts are #215 (pure arithmetic), #192 (COOP/CORP on every response), #126 (cache-control on the first paint) and #206 (a favicon, since every visit currently gets a 404 page); the largest wins waiting to be taken are #184 (standings at 171 ms on 200k rows), #209 (a stale bot policy) and #46 (a CT that actually defuses).

🤖 Generated with Claude Code

A truth-and-repair pass on the map for direction #8, read against main at 6cb6517 (#214 landed the weapon raise since the last pass) with bun run check green as found — 771 pass, 0 fail, 17.2 s. No code was written, so this branch carries no diff; it was fast-forwarded to main and pushed.

I booted the app and probed it before proposing anything: / answers in 1.6–7 ms, 21 KB of HTML that gzips to 6.8 KB, the bundle is 127 KB raw / 53 KB gzip behind a year of immutable, a cross-origin POST to /api/match is refused 403 and a malformed result 422, and the security floor is on the 404 too. The combat model I checked for gaps and found none worth an issue: spray patterns with a 0.35 s recovery, hitgroups, armour, penetration, crouch and scope accuracy are all there.

Filed, in order

• #219 — every refresh re-sends the whole first paint. cache-control: private, no-cache is correct, but with no etag a revalidation is a full 200: 6.8 KB on every refresh when a 304 would do. encoded (server.ts:54) is the one place that knows the bytes, and the trap is spelled out — never answer 304 to a visitor who is owed a set-cookie. Ready. → scout
• #220 — JavaScript off: 27 buttons, two canvases, and grep -rn noscript src finds nothing, so a scripting-off visitor gets the whole menu, dead, with the working leaderboard underneath making it look alive. main.ts:100's "No WebGL2" message is the voice to copy. Ready. → scout
• #221 — a phone held upright plays through the 4:3 box game.ts:242 pins under 640 px; grep for orientation across src finds nothing at all. A portrait hint, a guarded screen.orientation.lock on fullscreen that ignores rejection, and landscape given the room it is owed. Waits on #220 (same sheet) and #77 (in flight, same CSS). → vesper

Map repair. #169 was the parked issue from last pass and is now closed and split into #215/#216. Nothing is parked. I verified the premises of #189, #190, #191, #192 and #206 still hold on current main.

One thing I got wrong, mechanically: I tried to close #126 (already true on main — / really does answer private, no-cache) and #54/#61 (three issues for one fault in tty.ts's x; #40 says it first and best). The API accepts state changes only on issues I authored, so the PATCHes silently failed and all three are still open — and my comments are now the third copy of the same note on those threads. Those three closes need a person's click; I won't comment on them again.

Ready now: 29 issues, 0 parked. #219 and #220 are both an hour's work with tests; #215 (the detour predicate, pure arithmetic) is the cheapest start; #192 (COOP/CORP), #206 (favicon) and #205 (the terminal overflowing a 24-row window) are small and true; the biggest wins still untaken are #184 (standings at 171 ms on 200k rows), #209 (bot policy measured against a simulation four changes newer) and #46 (a CT that actually defuses).

🤖 Generated with Claude Code

Planning pass against main at 3118dc1 (#217, #218, #222 landed since the last pass), bun run check green: 791 pass, 0 fail. No new feedback text was on this issue or on a pull for this branch, so this is an ordinary pass. The branch was fast-forwarded; no code was written.

Filed:

• #224: footsteps go quiet on the Shift flag (world.ts:1250), not on speed. A phone has no walk button, so a half-pushed stick walks at ~125 u/s and bots still hear every step. Waits for #189. → vesper
• #225: requestPointerLock() has no unadjustedMovement, so OS acceleration shapes every flick. The void also swallows a refused lock: Esc then a quick Resume leaves a live match behind a free cursor. → scout

Parked issues: none new. #37, #40, #46, #53, #55, #58, #59 were parked on API/limit errors and were already rewritten; #54/#61 still need a person to close them as duplicates of #40.

I opened two issues from a planning pass against main at 3118dc1. I couldn't find any feedback in words: the newest comment on #8 is my own, and no pull exists for this branch. So this was an ordinary planning pass. The branch is fast-forwarded to main and pushed, with no code change. bun run check passes: 791 tests, 0 failures.

Opened, in order

• #224: footsteps depend on the Shift flag, not on speed, so on a phone every step is heard. footsteps (src/client/world.ts:1250) stays silent only when the player is ducking or the walk flag is set. The phone controls have no walk button. A half-pushed stick already moves you at about 125 u/s, walking pace, yet every stride still makes a step sound the bots listen for. Done means a single speed threshold constant decides the silence, with a test that fails on main today and a line in the touch help text. It waits for #189, which is in progress and edits the lines just above. Suggested: vesper.
• #225: aim goes through the operating system's mouse acceleration, and a refused pointer lock leaves a live match you can't aim in. main.ts:411 asks for the lock without unadjustedMovement (raw mouse input). It also uses void, which discards a refused request. Chrome refuses a new lock for about a second after Esc. So Esc followed by a quick Resume leaves the match running behind a free cursor: the mouse doesn't aim and nothing pauses the game again. Done means a small, tested lock.ts that tries raw input, then the plain lock, and treats anything else as refused. A refused lock keeps the match paused with a one-line reason. Suggested: scout.

Parked issues: nothing new is parked. #37, #40, #46, #53, #55, #58 and #59 were parked on API or usage-limit errors and have already been rewritten. #54 and #61 still need a person to close them as duplicates of #40, because the API only lets me close issues I opened.

Ready now: #225, plus the queue already on the map. The unassigned ones are #37, #40, #46, #53, #55, #58, #59, #95, #126, #173, #176, #180, #190, #191, #192, #195, #197, #200, #201, #203, #204, #205, #206, #209, #210 and #219. #224 is ready once #189 lands. Nobody is assigned and #8 stays open.

🤖 Generated with Claude Code

I opened no new issues this run; the map was already in good shape, so I only corrected #224. There was still no feedback in words: the newest message on #8 was my own summary from last run, and no pull exists for this branch. I fast-forwarded the branch to main at 56838f9 and pushed it with no code change. I didn't re-run the check this run.

What changed on the map

• #224 is now ready. The issue it waited on, #189 (a hit slows the player it lands on), was merged. I commented on #224 to fix one gap that merge opened. A player who gets hit can briefly drop under the new walking-speed threshold, so they go quiet for up to half a second. That is intended, because speed alone decides whether you're heard. The comment asks for a fifth test that pins it, so nobody later exempts hit players. It also notes the line numbers in the issue have moved.
• #221 is now ready, because #220 (the page with JavaScript off) was merged.

Ready now: 29 issues, none parked.

• Opened last run and still unassigned: #224 and #225.
• Other unassigned: #37, #40, #46, #53, #55, #58, #59, #95, #126, #173, #176, #180, #187, #192, #194, #195, #197, #200, #201, #203, #204, #205, #206, #209, #210, #219 and #221.

Nobody is assigned and #8 stays open. #54 and #61 still need a person to close them as duplicates of #40, because the API only lets me close issues I opened.

🤖 Generated with Claude Code

I opened no issues this run and posted no comments. The "new message" on #8 was again my own summary from the previous run, and no pull exists for this branch, so there was no new feedback.

The branch is fast-forwarded to main at 48b4494, which now includes #228 (fall damage), #229 (a touch-look setting) and #230 (the menu remembers name, side and match length), and pushed with no code change. I didn't re-run the check this run.

The map needs nothing else: 26 issues are ready, 3 are being worked on, 7 are blocked and none are parked. That includes #224 and #225 from the earlier pass.

My own summaries on #8 seem to be what starts each new run, so another comment there would only start another empty run. #8 stays open and nobody is assigned.

🤖 Generated with Claude Code

Nothing to act on again: the "new message" on #8 was my own summary from the last run, and no pull exists for this branch. I opened no issues and posted no comments. #8 stays open and nobody is assigned.

• Branch: fast-forwarded to main at 894d4f6 and pushed, with no code change. That brings in #231 (bots reload before a fight, not in it) and #232 (the two missing security headers). I didn't run the check this time.
• Map: 23 ready, 3 in progress, 7 blocked, none parked. That's more than enough to keep the crew busy, so I added nothing.

Each of these runs seems to be started by my own summary being posted back to #8, which then counts as a new message. Unless someone writes feedback there in words, the next run will be empty too. That's a problem with what triggers a run, and a person would need to fix it.

🤖 Generated with Claude Code

No new feedback this time either. The latest message on #8 was my own summary from the previous run, and there is still no pull for this branch. I opened no issues and posted no comments. #8 stays open and nobody is assigned.

• Branch: fast-forwarded to main at 979784f and pushed, with no code change. That brings in #233 (bots scope the AWP), #234 (crates you can jump onto, and crouch-jumping) and #236 (feedback when a teammate stops your shot). I didn't run the check this time.
• Map: 19 ready, 2 in progress, 7 blocked, none parked. That is still well over the three ready issues the map needs, so I added nothing.

Each empty run is started by my own summary landing on #8. I'll keep these runs this short until someone writes feedback there in words.

🤖 Generated with Claude Code

I opened one issue this run and commented on one. There was no feedback in words on #8 again: the newest message there was my own summary. I did check the parked issues, and #126 had been parked twice in the last hour.

Opened

• #241: The check fails on a busy machine. src/db.test.ts:236 times one cold standings call against a 10 ms wall-clock limit. The second builder run on #126 saw bun run check fail on it, and it passed on a rerun, so it can fail previews for pulls that never touched db.ts. Done means the test checks the query plan (standing_by_rank used, no scan of match, no temporary sort). The time limit stays only as a loose guard, measured after a warm-up the way textures.test.ts does it. The check must then pass 20 runs in a row. I suggest scout, who found it; a person assigns.

Commented

• #126: both builder runs found nothing to build, because / already sends cache-control: private, no-cache and src/server.test.ts:136-142 tests it. It's done, but sentinel opened it and I can only close issues I opened, so a person needs to close it. #54 and #61 still need the same, as duplicates of #40.

The other issues with "Parked by the crew" comments were parked on API errors or usage limits, not on the work. Each already has a later rewrite or a note that it is still valid, so I left them alone.

Branch: fast-forwarded to main at 1875a50 (#235) and pushed, with no code change. I didn't run the check.

Ready now: 26 issues, including #241. That's more than the three the map needs. Nobody is assigned and #8 stays open.

🤖 Generated with Claude Code