llm-whodunit

• Read /home/megaproxy/claude/projects/llm-whodunit/memory.md 9ms 18.4 KB

• Bash find . -type f -not -path './.git/*' -not -path './node_modules/*' | sort 35ms 1.1 KB

I'll start by reading the project's memory and key docs to understand the current state before building.

Memory is thorough. Now let me understand how the single case is currently loaded and served, since multi-game selection requires changing that core assumption.

• Read /home/megaproxy/claude/projects/llm-whodunit/app/config.py 7ms 3.3 KB

• Read /home/megaproxy/claude/projects/llm-whodunit/app/main.py 6ms 2.6 KB

• Read /home/megaproxy/claude/projects/llm-whodunit/app/api.py 12ms 20.2 KB

This is a significant architectural change — the app currently loads exactly one case at startup and the whole API assumes it. Let me read the remaining core pieces before designing multi-game support.

• Read /home/megaproxy/claude/projects/llm-whodunit/app/db.py 6ms 19.0 KB

• Read /home/megaproxy/claude/projects/llm-whodunit/app/models.py 12ms 6.8 KB

Let me read the engine and the frontend to see how deeply the single-case assumption is baked in.

• Read /home/megaproxy/claude/projects/llm-whodunit/app/engine.py 257ms 32.7 KB

The engine already left a multi-case hook (`_require_case(sid)` takes a session id "so a future multi-case build can resolve the right case from the session row"). Now let me see the frontend structure.

• Read /home/megaproxy/claude/projects/llm-whodunit/web/index.html 12ms 9.7 KB

• Read /home/megaproxy/claude/projects/llm-whodunit/web/app.js 792ms 38.4 KB

I now have the full architecture. Let me check the stylesheet size and the case file's meta block before I design the changes.

• Bash wc -l web/styles.css && echo "---META---" && python3 -c "import json;d=json.load(open('cases/the-gilded-cage/case_file.j… 4.3s 648 B

• Read /home/megaproxy/claude/projects/llm-whodunit/web/styles.css 3.7s 2.3 KB

I have the complete picture. The single-case assumption lives in four places (`main.py` loads one case → `app.state.case`; `api._case()` reads it; `engine._case` module global; `db.create_session` stores the title as `case_id`). The engine already left a hook: `_require_case(sid)` takes a session id for exactly this.

Let me lay out the plan and track it.

• ToolSearch select:TaskCreate 3ms 52 B

• TaskCreate New app/registry.py that scans the cases root, loads all mystery CaseFiles, and builds public GameSummary menu metadata.… 11ms 69 B

• TaskCreate Engine holds a cases registry (set_cases) and _require_case(sid) resolves via the session's case_id. api gets _case_for_… 10ms 72 B

• TaskCreate Menu screen in index.html + its own themed CSS (distinct from noir game), and app.js boot logic: fetch /api/games, rende… 9ms 75 B

• TaskCreate Add a menu block to the gilded-cage case_file.json and run a TestClient smoke test of /api/games, /api/session with game… 18ms 79 B

• ToolSearch select:TaskUpdate 2ms 52 B

Starting with the backend. First, the menu metadata model and registry.

• TaskUpdate taskId, status 9ms 22 B

Now the model. Adding `MenuInfo` and the optional `menu` field to `CaseFile`:

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/models.py 32ms 166 B

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/models.py 20ms 166 B

Now config — add `CASES_ROOT`:

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/config.py 30ms 166 B

Now the new registry module:

• Write /home/megaproxy/claude/projects/llm-whodunit/app/registry.py 19ms 158 B

Task 1 done. Now wiring the engine and API to resolve per-session.

• TaskUpdate taskId, status 18ms 22 B

• TaskUpdate taskId, status 8ms 22 B

Now the engine. Replace the single-case handle with a registry resolved by session:

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/engine.py 34ms 166 B

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/engine.py 28ms 166 B

Now `main.py` startup:

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/main.py 25ms 164 B

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/main.py 17ms 164 B

Now the API layer. First the helpers and a `SessionBody` for game selection:

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/api.py 30ms 163 B

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/api.py 36ms 163 B

Now replace the `_case` helper with registry-aware helpers:

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/api.py 112ms 163 B

Now the session-lifecycle endpoints — add `/api/games` and update `create_session`:

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/api.py 40ms 163 B

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/api.py 25ms 163 B

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/api.py 15ms 163 B

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/api.py 29ms 163 B

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/api.py 30ms 163 B

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/api.py 30ms 163 B

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/api.py 53ms 163 B

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/api.py 20ms 163 B

Now `get_characters` (already gets session first), `hint`, `accuse_options`, `accuse`:

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/api.py 25ms 163 B

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/api.py 27ms 163 B

• Edit error /home/megaproxy/claude/projects/llm-whodunit/app/api.py 15ms 253 B

• Read /home/megaproxy/claude/projects/llm-whodunit/app/api.py 17ms 1.7 KB

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/api.py 45ms 163 B

• Read /home/megaproxy/claude/projects/llm-whodunit/app/api.py 16ms 831 B

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/api.py 40ms 163 B

Let me verify no stale `_case(` references remain and the modules import cleanly:

• Bash grep -rn "_case(request)\|engine.set_case(\|app.state.case\b\|models.load_case(settings" app/ || echo "no stale refs" 49ms 97 B

That's just a docstring. Let me fix it and verify imports:

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/main.py 48ms 164 B

• Bash python3 -c "from app import main; app=main.create_app(); import app.engine as e; print('cases loaded:', list(e.get_cases… 1.9s 240 B

• Bash ls -d .venv venv env 2>/dev/null; which uvicorn 2>/dev/null; python3 -c "import fastapi" 2>/dev/null && echo "fastapi gl… 1.9s 17 B

No venv present. Let me create one to run the smoke test:

• Bash cat requirements.txt; echo "---"; python3 -m venv .venv && .venv/bin/pip install -q -r requirements.txt 2>&1 | tail -5 &… 9.6s 254 B

• Bash .venv/bin/python -c " from app import main, engine app = main.create_app() # trigger startup with __import__('fastapi').… 2.2s 136 B

• Bash .venv/bin/python -c " from fastapi.testclient import TestClient from app import main, engine with TestClient(main.create… 2.1s 310 B

Backend multi-game resolution works. Let me run the existing test suite to confirm nothing regressed:

• Bash .venv/bin/pip install -q pytest 2>&1 | tail -1; .venv/bin/python -m pytest -q 2>&1 | tail -12 3.1s 98 B

Task 2 complete. Now the menu metadata for the case, then the front page.

• TaskUpdate taskId, status 10ms 22 B

• TaskUpdate taskId, status 17ms 22 B

• Bash .venv/bin/python -c "import json; d=json.load(open('cases/the-gilded-cage/case_file.json')); print(list(d.keys())[:6])";… 1.8s 463 B

• Read /home/megaproxy/claude/projects/llm-whodunit/cases/the-gilded-cage/case_file.json 18ms 2.0 KB

• Edit /home/megaproxy/claude/projects/llm-whodunit/cases/the-gilded-cage/case_file.json 67ms 189 B

• Bash .venv/bin/python -c " from fastapi.testclient import TestClient from app import main with TestClient(main.create_app()) … 2.1s 547 B

Backend is solid and tested. Now the front page. First, restructure `index.html` — add the menu screen and wrap the game in a toggleable container:

• Edit /home/megaproxy/claude/projects/llm-whodunit/web/index.html 45ms 167 B

Now add a "Menu" button in the topbar and close the `#game-screen` wrapper after `</main>`:

• Edit /home/megaproxy/claude/projects/llm-whodunit/web/index.html 26ms 167 B

• Edit /home/megaproxy/claude/projects/llm-whodunit/web/index.html 25ms 167 B

• Edit /home/megaproxy/claude/projects/llm-whodunit/web/index.html 28ms 167 B

• Bash grep -n "\.topbar\b\|\.board\b\|^body\|flex\|height\|min-height\|overflow" web/styles.css | head -40 33ms 2.7 KB

Now the styling. Let me check how the game layout (`body`, `.topbar`, `.board`) is sized so the new `#game-screen` wrapper slots into the flex layout correctly:

• Bash grep -n "\.hidden\b" web/styles.css | head; echo "---fonts/display vars already loaded; check .btn-primary def line---";… 47ms 765 B

Now append the menu theme to the stylesheet — a distinct cool/cinematic look, separate from the warm noir game:

• Bash tail -5 web/styles.css 51ms 202 B

• Bash cat >> web/styles.css <<'CSS' /* =================================================================== GAME SCREEN WRAPPER… 1.8s 44 B

Backend tested. Now the client logic. Let me rework the storage/state and bootstrap for multi-game:

• Edit /home/megaproxy/claude/projects/llm-whodunit/web/app.js 50ms 163 B

Now rewrite the bootstrap section to drive the menu:

• Edit /home/megaproxy/claude/projects/llm-whodunit/web/app.js 52ms 163 B

Now update `clearGame` to restart the current game and wire the new menu/continue buttons:

• Edit /home/megaproxy/claude/projects/llm-whodunit/web/app.js 46ms 163 B

• Edit /home/megaproxy/claude/projects/llm-whodunit/web/app.js 49ms 163 B

Let me sanity-check the JS parses and the HTML structure is balanced:

• Bash node --check web/app.js && echo "app.js OK" || echo "JS PARSE FAIL" python3 - <<'PY' import re html=open('web/index.html… 2.0s 169 B

Now a comprehensive backend smoke test covering the new endpoints + a zero-leak check:

• Bash .venv/bin/python - <<'PY' 2>&1 | tail -30 from fastapi.testclient import TestClient from app import main import json wit… 2.3s 408 B

All green and leak-clean. Let me make the "Continue" bar accurately track the last-played game, and confirm static assets serve:

• Edit /home/megaproxy/claude/projects/llm-whodunit/web/app.js 54ms 163 B

• Edit /home/megaproxy/claude/projects/llm-whodunit/web/app.js 50ms 163 B

• Edit /home/megaproxy/claude/projects/llm-whodunit/web/app.js 49ms 163 B

• Bash node --check web/app.js && echo "app.js OK" .venv/bin/python - <<'PY' 2>&1 | tail -6 from fastapi.testclient import Test… 115 B

Let me try to capture a screenshot of the menu to verify it visually (the menu needs no LLM):

• Bash command -v chromium chromium-browser google-chrome chrome 2>/dev/null; ls ~/.cache/ms-playwright 2>/dev/null; .venv/bin/… 2.1s 68 B

• Bash .venv/bin/pip install -q playwright 2>&1 | tail -2 && echo "installed" 3.9s 9 B

• Bash DB_PATH=/tmp/menu_test.db .venv/bin/python -m uvicorn app.main:app --port 8123 >/tmp/srv.log 2>&1 & echo $! > /tmp/srv.p… 4.7s 11 B

• Bash .venv/bin/python - <<'PY' 2>&1 | tail -20 import glob, os os.environ["PLAYWRIGHT_BROWSERS_PATH"] = os.path.expanduser("~… 4.2s 86 B

• Read /tmp/menu.png 126ms 43.6 KB

The menu renders. Let me view the screenshot:

Clean. Now let me verify clicking "Begin" transitions into the game (intro modal, title, board) — no LLM needed until you chat:

• Bash .venv/bin/python - <<'PY' 2>&1 | tail -20 import glob, os os.environ["PLAYWRIGHT_BROWSERS_PATH"] = os.path.expanduser("~… 5.5s 267 B

The complete flow works — Begin → game, Library → menu with Continue bar and the card now reading "CONTINUE". Let me view the returned-to-menu state:

• Read /tmp/menu2.png 124ms 46.6 KB

Everything works and looks distinct from the game's noir. Let me shut down the test server and clean up:

• Bash kill $(cat /tmp/srv.pid) 2>/dev/null; rm -f /tmp/menu_test.db /tmp/srv.pid /tmp/srv.log /tmp/menu.png /tmp/menu2.png /tm… 1.9s 196 B

Both visual flows confirmed. Marking the front-page tasks done and updating project memory.

• TaskUpdate taskId, status 33ms 22 B

• TaskUpdate taskId, status 25ms 22 B

Now update `memory.md` with the architecture decision and session log:

• Edit /home/megaproxy/claude/projects/llm-whodunit/memory.md 69ms 162 B

• Edit /home/megaproxy/claude/projects/llm-whodunit/memory.md 51ms 162 B

Now commit and push:

• Bash git add -A && git status --short && echo "---" && git -c commit.gpgsign=false commit -q -F - <<'MSG' Add front-page game… 2.0s 212 B

• Bash git push origin main 2>&1 | tail -5; echo "push exit=$?" 7.1s 96 B

Front page is done, pushed, and verified end-to-end. Here's where things stand:

## What shipped (front page + multi-game backbone)

**Backend — the server is now multi-game.** It loads *every* folder under `cases/` at startup instead of one. A new `app/registry.py` discovers games, validates each, and builds browser-safe menu metadata. Sessions now key on the folder **slug** (`case_id`), and both the engine and API resolve the right case from the session row (with a title fallback so any old saves still work). New `GET /api/games`; `POST /api/session` now takes an optional `game_id`. **Dropping a new game in is now "add a folder."**

**Front page — its own theme, separate from the noir game.** `web/` is a two-screen app now: a cool, cinematic **"PARLOUR"** game-select menu (deep indigo, per-game accent cards) and the existing warm-noir board wrapped as the game screen. Per-game saves in localStorage (each story keeps its own progress); a topbar **‹ Library** button, a **Continue** bar, and per-card **Begin / Continue / Start over**.

**Verified:** 26/26 DSL tests pass; a TestClient smoke run (games list is zero-leak, unknown game → 404, all session endpoints 200); and a headless-browser render of the menu plus the full Begin → game → Library → Continue flow (screenshots looked right). Committed and pushed.

The `menu.mode` field (`"mystery"` | `"adventure"`) is already riding on every game — that's the seam game #2 plugs into.

## Now — game #2 (the adventure)

This one's a different beast from the mystery: the accusation/evidence/secrets machinery doesn't carry over, so it needs its own schema, win-logic, and a bit of UI. Before I design that, two things only you can decide:

• AskUserQuestion questions 108.7s 395 B

• Read /home/megaproxy/claude/projects/llm-whodunit/app/dsl.py 13ms 6.2 KB

Got it — **post-apocalyptic survival, Metro 2033's bleak hush but STALKER-survivable and a touch less harsh.** That's a great fit for the talk-to-NPCs + explore-locations engine you already have. Here's the design I'll build toward, then I'll start on the foundation.

**Premise (working):** *"The Hollow Line."* A generation after the Collapse, survivors cling to the stations of a half-flooded metro under a dead city; the irradiated surface ("the Grey") is for short, dangerous scavenging runs. You're a courier who's caught a credible lead on **the Greenline** — a rumored valley settlement with clean air, reachable down the old rail. **Goal:** assemble what the journey needs (a filter that still seals, a handcar crank, safe passage past a faction, a map fragment) by working the stations, then ride the line out. Bleak and quiet, but people still help each other and survival is real — not a death-march.

**Mechanics** (reuses your locations/travel/NPC-chat/casebook; adds an adventure layer): main objective + side quests, an inventory of items, world flags, NPC dialogue that *grants* items/quest progress (the analog of the mystery's "secrets"), and a **reach-the-goal win check** in place of the accusation form.

Let me check the condition DSL so the adventure's quest/unlock conditions are compatible before I write the schema:

"fan out" — got it. This is a big content+code build (a whole second game mode with *loads* of NPCs and locations), and it parallelizes well. I'll orchestrate it as a multi-agent workflow. But first I need to author the one thing that must stay coherent: a tight build contract + world bible that every agent codes and writes against. Let me write that now.

• TaskCreate Write docs/adventure-build.md: the adventure_file.json schema, DSL atom additions, DB tables, engine + API + frontend co… 32ms 75 B

• TaskUpdate taskId, status 11ms 14 B

• TaskCreate Workflow: backend pipeline (dsl+adv_models, db, adv_engine, adv_api+wiring), parallel per-station content fragments, ass… 30ms 67 B

• TaskUpdate taskId, status 34ms 22 B

• Write /home/megaproxy/claude/projects/llm-whodunit/docs/adventure-build.md 39ms 166 B

Contract written. Let me commit it so every agent has a stable reference, then launch the fan-out build.

• Bash git add docs/adventure-build.md && git -c commit.gpgsign=false commit -q -m "Add adventure-mode build contract + world b… 1.7s 9 B

• TaskUpdate taskId, status 25ms 22 B

• TaskUpdate taskId, status 24ms 22 B

Now I'll build and launch the fan-out workflow. It overlaps the backend pipeline with parallel per-station content authoring, then assembles + validates the content, builds the mode-aware frontend, and runs an adversarial integration/verify pass at the end.

• Workflow script 10ms 1.2 KB

I'll read the spec first, then author the fragment.

I'll start by reading the authoritative spec fully.

I'll read the spec first, then author the fragment.

I'll start by reading the authoritative spec and the existing code patterns.

I'll read the spec first before doing anything.

I'll read the spec first before doing anything.

I'll read the spec first, then author the fragment.

I'll start by reading the authoritative spec fully.

I'll start by reading the authoritative spec and the existing db.py file.

• Read /home/megaproxy/claude/projects/llm-whodunit/docs/adventure-build.md 2ms 22.6 KB

• Read /home/megaproxy/claude/projects/llm-whodunit/docs/adventure-build.md 4ms 22.6 KB

• Read /home/megaproxy/claude/projects/llm-whodunit/docs/adventure-build.md 3ms 22.6 KB

• Read /home/megaproxy/claude/projects/llm-whodunit/docs/adventure-build.md 3ms 22.6 KB

• Read /home/megaproxy/claude/projects/llm-whodunit/docs/adventure-build.md 3ms 22.6 KB

• Read /home/megaproxy/claude/projects/llm-whodunit/docs/adventure-build.md 3ms 22.6 KB

• Read /home/megaproxy/claude/projects/llm-whodunit/docs/adventure-build.md 2ms 22.6 KB

• Read /home/megaproxy/claude/projects/llm-whodunit/docs/adventure-build.md 5ms 22.6 KB

• Read /home/megaproxy/claude/projects/llm-whodunit/docs/adventure-build.md 2ms 22.6 KB

• Read /home/megaproxy/claude/projects/llm-whodunit/app/dsl.py 2ms 6.2 KB

• Read /home/megaproxy/claude/projects/llm-whodunit/app/db.py 2ms 19.0 KB

• Read /home/megaproxy/claude/projects/llm-whodunit/app/models.py 2ms 7.7 KB

Now I understand the spec. Let me check if there's an existing fragment example to match style.

I'll start by reading the authoritative spec.

Now let me look at an existing fragment if any exist, to match style/conventions.

Now I have the full spec. Let me look at an existing fragment or the existing mystery case for style reference.

I have the full spec. Let me look at an existing fragment if any exist, and check the Gilded Cage case for style reference.

Now let me look at an existing fragment if any, and the Gilded Cage case file for style reference.

Now I have the full spec. Let me look at an existing case fragment or the mystery case for style reference.

• Read /home/megaproxy/claude/projects/llm-whodunit/docs/adventure-build.md 2ms 22.6 KB

I have the full spec. Let me look at an existing fragment if one exists, to match style/conventions.

I have everything I need. Now I'll add the two tables, indexes, and helpers, matching the existing style exactly.

• Bash ls -la /home/megaproxy/claude/projects/llm-whodunit/cases/the-hollow-line/ 2>/dev/null; echo "---"; ls -la /home/megapro… 41ms 111 B

• Bash ls -la /home/megaproxy/claude/projects/llm-whodunit/cases/the-hollow-line/ 2>/dev/null; echo "---fragments---"; ls -la /… 16ms 275 B

• Bash ls -la /home/megaproxy/claude/projects/llm-whodunit/cases/the-hollow-line/ 2>/dev/null; echo "---fragments---"; ls -la /… 37ms 60 B

• Bash ls -la /home/megaproxy/claude/projects/llm-whodunit/cases/ 2>/dev/null; echo "---"; ls -R /home/megaproxy/claude/project… 23ms 227 B

Now let me check the existing tests and look at how MenuInfo and engine are used.

• Bash ls -la /home/megaproxy/claude/projects/llm-whodunit/cases/the-hollow-line/ 2>/dev/null; echo "---"; ls -la /home/megapro… 31ms 40 B

• Bash ls -la /home/megaproxy/claude/projects/llm-whodunit/cases/the-hollow-line/ 2>/dev/null; echo "---"; ls -la /home/megapro… 31ms 43 B

No existing fragments. Let me create the directory and author the fragment.

• Read /home/megaproxy/claude/projects/llm-whodunit/tests/test_dsl.py 3ms 7.4 KB

• Bash ls -la /home/megaproxy/claude/projects/llm-whodunit/cases/the-hollow-line/ 2>/dev/null; echo "---fragments---"; ls -la /… 29ms 53 B

• Bash mkdir -p /home/megaproxy/claude/projects/llm-whodunit/cases/the-hollow-line/_fragments && echo "created" 33ms 7 B

Now let me look at an existing fragment if any exist, and the mystery case for style reference.

No fragments exist yet. Let me check the Gilded Cage case file for style/voice reference on NPC personas and reveals.

No existing fragments. Let me look at the mystery case_file.json to match content style for descriptions, NPC personas, and reveals.

Let me look at the existing case_file.json for style/voice reference on NPCs and reveals.

• Bash .venv/bin/python -c "import json; d=json.load(open('/home/megaproxy/claude/projects/llm-whodunit/cases/the-gilded-cage/c… 1.6s 2.4 KB

• Bash find /home/megaproxy/claude/projects/llm-whodunit/cases/the-gilded-cage -name '*.json' | head; echo "---"; head -120 /ho… 17ms 14.0 KB

No existing fragments. Let me peek at the gilded-cage case_file.json to match the NPC/reveal authoring style and DSL idioms.

• Bash ls -la /home/megaproxy/claude/projects/llm-whodunit/cases/the-hollow-line/ 2>/dev/null; echo "---fragments---"; ls -la /… 30ms 346 B

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/db.py 17ms 162 B

• Bash .venv/bin/python -c " import json d=json.load(open('cases/the-gilded-cage/case_file.json')) n=d['suspects'][0] if 'suspe… 1.8s 297 B

• Bash .venv/bin/python -c "import json; d=json.load(open('/home/megaproxy/claude/projects/llm-whodunit/cases/the-gilded-cage/c… 1.7s 320 B

• Bash .venv/bin/python -c "import json; d=json.load(open('/home/megaproxy/claude/projects/llm-whodunit/cases/the-gilded-cage/c… 1.6s 2.4 KB

I have everything I need. Now let me edit the DSL additively first, then create adv_models.py.

Now let me see the NPC structure in the Gilded Cage file for voice/style.

• Bash .venv/bin/python -c " import json d=json.load(open('/home/megaproxy/claude/projects/llm-whodunit/cases/the-gilded-cage/c… 1.7s 2.6 KB

Let me look at the existing mystery case_file.json for style/voice reference on NPC personas and reveals.

• Bash .venv/bin/python -c "import json;d=json.load(open('/home/megaproxy/claude/projects/llm-whodunit/cases/the-gilded-cage/ca… 1.7s 3.1 KB

Now I understand the style well. Let me write the Marrow Station fragment.

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/db.py 10ms 162 B

• Bash mkdir -p /home/megaproxy/claude/projects/llm-whodunit/cases/the-hollow-line/_fragments && echo done 27ms 4 B

• Bash .venv/bin/python -c " import json d=json.load(open('/home/megaproxy/claude/projects/llm-whodunit/cases/the-gilded-cage/c… 1.6s 4.9 KB

• Bash mkdir -p /home/megaproxy/claude/projects/llm-whodunit/cases/the-hollow-line/_fragments && echo created 37ms 7 B

• Bash .venv/bin/python -c " import json d=json.load(open('cases/the-gilded-cage/case_file.json')) print(json.dumps(d['npcs'][0… 1.5s 2.5 KB

Good, I have the style. Now I'll write the Old Control / Archive fragment.

Now the helpers. I'll add them at the end of the file after the accusations section.

• Bash cd /home/megaproxy/claude/projects/llm-whodunit; .venv/bin/python -c " import json d=json.load(open('cases/the-gilded-ca… 1.8s 2.6 KB

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/dsl.py 15ms 163 B

The fan-out build is running in the background (Run ID `wf_e5cb3013-6ce`) — you can watch it live with `/workflows`. Here's the shape of what I dispatched:

**Game #2 — "The Hollow Line" (adventure mode), built by ~13 agents:**

- **Backend pipeline** (runs concurrently with content, disjoint files): `dsl` extension + `adv_models.py` ∥ `db` tables → `adv_engine.py` → `adv_api.py` + registry/main/session wiring. Adventure is an *additive parallel subsystem* so the mystery game stays intact.
- **Content fan-out** — 8 agents, one per station (Marrow, Cistern, Pumpworks, Grey Stair, Old Control, Tannery, Cinder Gate, Southgate), each authoring its location + NPCs + dialogue reveals + local items/quests as a separate JSON fragment against the shared world bible. The spine is pre-wired so they don't collide: each station owns one of the four things you need to ride out (filter, crank, route, passage).
- **Assemble** — merges the fragments into `adventure_file.json`, reconciles the item registry, adds the main quests + goal, and validates it loads.
- **Frontend** — a mode-aware adventure screen (cold green theme, Objectives + Pack + Journal, a "Ride the line out" win action) reusing the menu and three-column shell; `app.js` routes by `mode`.
- **Verify** — adversarial integration pass: mystery still green (26/26), adventure loads, every DSL id resolves, the win is statically reachable, all `/api/adv/*` responses are zero-leak, frontends parse. It fixes small breakage and returns a structured verdict.

The whole thing codes and writes against the `docs/adventure-build.md` contract I committed, so the parallel output stays coherent and mergeable.

I'll review the verdict, wire up final commits, and run a visual + smoke check when it lands. I won't poll — I'll pick this back up automatically when the workflow finishes.

Now I understand the voice and structure. The adventure uses `reveals` (not `secrets`) with `when`/`say`/`journal`/`grants`. Let me author the Cinder Pact Gate fragment.

Now I'll author the fragment. Per the spine: `loc_archive`, `npc_quill`, `rev_quill_route` gated `rapport AND (visited:loc_greystair OR item:item_mapfrag)` grants `flag:know_route`. Quest `q_route` (main) `complete_when: flag:know_route`. No new items.

Now I understand the voice and structure. Let me look at a location with lookables/grants for reference.

• Bash cd /home/megaproxy/claude/projects/llm-whodunit; ls *.py 2>/dev/null; echo "---"; ls src 2>/dev/null; find . -name 'adv_… 2.0s 3 B

• Bash .venv/bin/python -c " import json d=json.load(open('cases/the-gilded-cage/case_file.json')) print(json.dumps(d['location… 1.7 KB

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/db.py 12ms 162 B

Now I have a strong sense of voice and structure. Let me write the Pumpworks fragment.

Now I have a strong sense of the voice. Let me check the registry/adv_models to confirm field shapes if those exist yet.

I have a strong sense of the style now. The adventure schema uses `reveals` with `id/when/say/journal/grants`. Let me write the Grey Stair fragment.

Per the bible: Grey Stair has `npc_ash` (lone surface scavenger), introduces `item_mapfrag`, location `locked=true, unlock_when: "flag:have_filter"`. A lookable may grant `item_mapfrag`. No quest is pre-allocated for this station in §D, but I can author a small side quest for richness — though to stay safe and within spine, I'll add one optional side quest gated on station-local flags only. Actually, let me keep it tight: the task says quests array "Quest objects authored here per §D" — §D doesn't pre-allocate a Grey Stair quest. I'll add a small optional side quest with its own local flag to enrich, fully self-contained.

• Bash mkdir -p /home/megaproxy/claude/projects/llm-whodunit/cases/the-hollow-line/_fragments && echo created 33ms 7 B

• Bash mkdir -p /home/megaproxy/claude/projects/llm-whodunit/cases/the-hollow-line/_fragments && echo created 15ms 7 B

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/dsl.py 12ms 163 B

Now I have the style. Let me write the Tannery fragment. The spine for this station:
- `npc_bram` (camp elder, gives `q_tannery`), reveal gated on `flag:tannery_helped` grants `item_passage_token`.
- `npc_wren` (the person in need) — helping them sets `flag:tannery_helped`.
- Introduce `item_passage_token`, flag `tannery_helped`, quest `q_tannery` (side, `complete_when: flag:tannery_helped`).

I'll design: Wren is sick/in need; helping = giving them medicine. Marrow's medic (`npc_meek`) gives a small heal item per §C. I'll wire Wren's help around a heal item granted at Marrow. But I must only reference ids I define here OR known spine ids. `item_meek_*` isn't defined in the bible. To keep it self-contained, I'll have Wren's help be set via an examine grant or a Wren reveal that fires on rapport/empathy (talking them through it / helping them) — making the helping path local and warm. I'll add a local item `item_tannery_medicine` introduced here that Wren needs, and let Bram give it to you, OR keep it simpler: helping = sitting with Wren and a reveal sets the flag.

Let me design a clean two-step: Bram gives the quest (find/help Wren). Wren is feverish; a reveal gated on `empathy` (you treat them kindly / tend them) sets `flag:tannery_helped`. Then Bram's reveal gated on `flag:tannery_helped` grants `item_passage_token` + `flag:passage_cleared`? No — passage_cleared is set at Cinder Gate. Bram only grants the token. Kessler converts token→passage_cleared. So Bram grants `item_passage_token` only.

• Bash mkdir -p /home/megaproxy/claude/projects/llm-whodunit/cases/the-hollow-line/_fragments && echo created 30ms 7 B

No code scaffolded yet — I'm just authoring content to the spec. The §2 schema is my contract. Southgate is the goal: locked, unlock_when `flag:know_route`, no mechanical grants, optional `npc_coil` watcher, a handcar lookable. Let me create the directory and write the fragment.

• Bash mkdir -p /home/megaproxy/claude/projects/llm-whodunit/cases/the-hollow-line/_fragments && echo created 15ms 7 B

• Bash rm -f /tmp/advtest.db && DB_PATH=/tmp/advtest.db .venv/bin/python -c " from app import db db.init_db() sid='s1' db.add_i… 1.8s 177 B

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/dsl.py 12ms 163 B

Now create app/adv_models.py.

The spine has all four spine flags already authored by other stations. Southgate grants nothing mechanical. I'll define `npc_coil` (a wary watcher who is, beneath it, genuinely warm — the keeper of the platform who sends couriers off), a handcar lookable, a couple atmospheric lookables, and no new spine quests (those are owned by their stations). I'll author colour-only flags/items kept local and idempotent. Reveals for `npc_coil` will be atmospheric send-off, gated on having the spine flags / arriving ready — they grant nothing mechanical, only journal lines.

Verified. Additive changes to `/home/megaproxy/claude/projects/llm-whodunit/app/db.py` per docs/adventure-build.md §4. No existing tables or helpers altered.

New tables (in `init_db()`):
- `inv_item(session_id, item_id, found_at, PRIMARY KEY(session_id, item_id))` + index `idx_invitem_session`
- `world_flag(session_id, flag, set_at, PRIMARY KEY(session_id, flag))` + index `idx_worldflag_session`

New helpers (sync, matching get_conn()/_now() style):
- `add_item(sid: str, item_id: str) -> None` — idempotent (INSERT OR IGNORE)
- `get_items(sid: str) -> set[str]`
- `set_flag(sid: str, flag: str) -> None` — idempotent (INSERT OR IGNORE)
- `get_flags(sid: str) -> set[str]`

Verification (`DB_PATH=/tmp/advtest.db .venv/bin/python -c "from app import db; db.init_db()"`) passed: both tables created alongside all existing ones, and idempotent insert/read round-trips confirmed.

• Write /home/megaproxy/claude/projects/llm-whodunit/cases/the-hollow-line/_fragments/loc_cistern.json 8ms 192 B

• Write /home/megaproxy/claude/projects/llm-whodunit/cases/the-hollow-line/_fragments/loc_cinder.json 10ms 191 B

• Bash .venv/bin/python -c "import json;json.load(open('cases/the-hollow-line/_fragments/loc_cistern.json'));print('ok')" 1.7s 2 B

• Write /home/megaproxy/claude/projects/llm-whodunit/cases/the-hollow-line/_fragments/loc_archive.json 10ms 192 B

• Bash .venv/bin/python -c "import json;json.load(open('cases/the-hollow-line/_fragments/loc_cinder.json'));print('ok')" 1.7s 2 B

• Bash .venv/bin/python -c "import json;json.load(open('cases/the-hollow-line/_fragments/loc_archive.json'));print('ok')" 1.8s 2 B

JSON validates. Summary follows.

Defined ids — npcs: npc_vell, npc_oxide; items: item_filter, item_scrip; flags: have_filter; quests: q_filter; reveals: rev_vell_filter (gated `item:item_scrip OR rapport` → grants item_filter + have_filter), rev_oxide_scrip (gated `rapport OR empathy` → grants item_scrip), rev_oxide_gate (gated `reveal:rev_oxide_scrip` → gate intel, no grants).
Spine grants from this station: item_filter + flag have_filter (via npc_vell), with item_scrip (via npc_oxide) as the trade currency that satisfies Vell's gate; this is the q_filter source.

JSON validates.

Defined ids — location: loc_cinder (lookables: look_cinder_logbook [grants journal], look_cinder_wall, look_cinder_brazier); npc: npc_kessler (warm-but-wary gate lieutenant, single reveal rev_kessler_pass gated `item:item_passage_token OR rapport`); items: none; flags: passage_cleared; quests: q_passage (main, complete_when flag:passage_cleared).
Spine wiring: this station is the source of `q_passage` and grants the spine flag **passage_cleared** via rev_kessler_pass (non-violent — earned by token or trust, never force). It consumes the spine item item_passage_token (from the Tannery) in its gate but defines no items of its own. File: /home/megaproxy/claude/projects/llm-whodunit/cases/the-hollow-line/_fragments/loc_cinder.json

JSON validates. All ids match the bible; the only DSL ids referenced are spine ids (`visited:loc_greystair`, `reveal:rev_silt_lead`, `item:item_mapfrag`, `rapport`, `empathy`) plus the `know_route` flag I define here.

Defined: location loc_archive (lookables look_archive_wallmap/look_archive_ledgers/look_archive_lamp); npc npc_quill (reveals rev_quill_welcome, rev_quill_route); flag know_route; quest q_route; items: none.
Spine grant: rev_quill_route sets flag:know_route (the q_route source); no items granted at this station.

• Write /home/megaproxy/claude/projects/llm-whodunit/app/adv_models.py 10ms 160 B

• Write /home/megaproxy/claude/projects/llm-whodunit/cases/the-hollow-line/_fragments/loc_greystair.json 9ms 194 B

• Write /home/megaproxy/claude/projects/llm-whodunit/cases/the-hollow-line/_fragments/loc_pumpworks.json 5ms 194 B

• Write /home/megaproxy/claude/projects/llm-whodunit/cases/the-hollow-line/_fragments/loc_tannery.json 4ms 192 B

• Bash .venv/bin/python -c "import app.adv_models, app.dsl; print('import ok')" && .venv/bin/python -m pytest -q tests/test_dsl… 108 B

• Write /home/megaproxy/claude/projects/llm-whodunit/cases/the-hollow-line/_fragments/loc_southgate.json 7ms 194 B

• Bash .venv/bin/python -c "import json;json.load(open('cases/the-hollow-line/_fragments/loc_pumpworks.json'));print('ok')" 1.7s 2 B

Now let me consider the `greystair_reached` flag — I declared it but nothing sets it, which is fine (FlagDef is documentation). But to keep it clean and avoid a dangling undocumented concept, I'll leave it as a declared flag since the location-arrival logic could set it elsewhere. Actually it's never referenced in any DSL and never granted, so it's harmless documentation. Let me validate.

• Bash .venv/bin/python -c "import json;json.load(open('cases/the-hollow-line/_fragments/loc_greystair.json'));print('ok')" 2 B

• Bash .venv/bin/python -c "import json;json.load(open('cases/the-hollow-line/_fragments/loc_tannery.json'));print('ok')" 1.9s 2 B

Now validate. Note: `rev_coil_name`'s `when` references `look_southgate_names` — per DSL §3, lookable-discovery isn't a defined atom head (only `item:`/`flag:`/`visited:`/`quest:`/`reveal:`/`rapport`/`empathy`). Let me fix that to avoid an undefined atom — gate it on `reveal:rev_coil_ready` alone.

• Edit /home/megaproxy/claude/projects/llm-whodunit/cases/the-hollow-line/_fragments/loc_southgate.json 14ms 204 B

Imports clean and all 26 DSL tests pass.

Created /home/megaproxy/claude/projects/llm-whodunit/app/adv_models.py: Pydantic v2 models (Meta, Goal, Item, FlagDef, Grant, Lookable, Location, Reveal, NPC, Quest, AdventureFile) reusing models.MenuInfo, with id->object lookup helpers + reverse lookups (location_of_lookable, npc_of_reveal) and load_adventure(case_dir) reading adventure_file.json; secret fields stripped per §2.
Edited /home/megaproxy/claude/projects/llm-whodunit/app/dsl.py additively: new atom heads item:/flag:/visited:/quest:/reveal: resolving via new Ctx Protocol methods (ctx.item/flag/visited/quest/reveal), grammar docstring extended; existing mystery atoms untouched, 26/26 tests pass.
Public serializer function names: public_lookable, public_location, public_npc, public_item, public_quest, public_goal.

JSON validates. Verifying my id references against the bible: `flag:have_filter` (spine, unlock gate), `item:item_mapfrag` (defined here), `reveal:rev_ash_lore`/`reveal:rev_ash_mapfrag` (defined here) — all resolve. `npc_ash`, `loc_greystair`, `item_mapfrag` match the bible exactly. Quest `q_mapfrag` and flag `greystair_reached` are author-added local ids (no spine collision).

Defined: npc_ash; item_mapfrag; flags greystair_reached; quest q_mapfrag; reveals rev_ash_lore, rev_ash_mapfrag, rev_ash_gate (lookable grants: look_greystair_cairn also grants item_mapfrag).
This station grants spine item item_mapfrag (the physical route half for the Archive hermit); it sets no spine flag itself and is gated open by the spine flag have_filter.

• Bash .venv/bin/python -c "import json;json.load(open('cases/the-hollow-line/_fragments/loc_southgate.json'));print('ok')" 1.8s 2 B

I'll start by reading the authoritative spec and the existing files I need to mirror and reuse.

Note: `q_pump`'s completion flag `pump_fixed` is authored here, but nothing in this fragment sets it — that's expected, since the pump-repair completion (an examine/action that grants `pump_fixed`) is the engine/station-flow wiring; the spine just requires `gauge`'s crank reveal to gate on it, which it does. The DSL ids I reference are all either defined here (`pump_fixed`, `have_crank`, `item_crank`, `q_pump`, `rev_lune_task`) or known spine atoms (`rapport`, `empathy`).

NPCs: npc_gauge (reveals rev_gauge_deal, rev_gauge_crank), npc_lune (reveal rev_lune_task); items: item_crank; flags: pump_fixed, have_crank; quest: q_pump (side, complete_when flag:pump_fixed).
This station grants the spine item item_crank + spine flag have_crank (gated on flag:pump_fixed), the q_crank source.

• Read /home/megaproxy/claude/projects/llm-whodunit/docs/adventure-build.md 3ms 22.6 KB

Now let me read the existing files I need to mirror and reuse.

JSON validates. All DSL ids referenced are either defined here (`item_passage_token`, `tannery_helped`, `q_tannery`, `rev_wren_drink`) or spine ids (`visited:loc_tannery`, `empathy`, `rapport`). Bram grants the token only; the flag `tannery_helped` is set by Wren's recovery, and `q_tannery` completes off it. Passage_cleared is left for the Cinder Gate per the spine.

File: /home/megaproxy/claude/projects/llm-whodunit/cases/the-hollow-line/_fragments/loc_tannery.json

npcs: npc_bram (reveals rev_bram_ask, rev_bram_token), npc_wren (reveals rev_wren_drink, rev_wren_mend) | items: item_passage_token | flags: tannery_helped | quests: q_tannery (side, complete_when flag:tannery_helped) | lookables: look_tannery_longfire, look_tannery_cot, look_tannery_token
Station grants: flag tannery_helped (set by npc_wren reveal rev_wren_mend) and item_passage_token (granted by npc_bram reveal rev_bram_token, gated on flag:tannery_helped) — the spine passage asset feeding the Cinder Gate.

• Read /home/megaproxy/claude/projects/llm-whodunit/app/engine.py 1.9s 33.5 KB

• Read /home/megaproxy/claude/projects/llm-whodunit/app/adv_models.py 6ms 11.9 KB

• Write /home/megaproxy/claude/projects/llm-whodunit/cases/the-hollow-line/_fragments/loc_marrow.json 10ms 191 B

JSON parses. All DSL ids used (`flag:know_route`, `flag:have_filter`, `flag:have_crank`, `flag:passage_cleared`, `reveal:rev_coil_ready`) are spine flags or a reveal defined here.

loc_southgate (locked, unlock_when flag:know_route) — npcs: npc_coil (warm platform keeper); reveals: rev_coil_welcome, rev_coil_ready, rev_coil_name; items: none; flags: none; quests: none. Lookables: look_southgate_handcar, look_southgate_shutter, look_southgate_names.
Grants nothing mechanical — no spine flags/items granted here; this is the ride-out goal station. Reveals gate on spine flags (know_route; then all four) and grant only journal lines.

Now let me read db.py (adventure helpers), dsl.py, registry.py, guardrail.py, input_guard.py, and llm.py.

• Bash .venv/bin/python -c "import json;json.load(open('cases/the-hollow-line/_fragments/loc_marrow.json'));print('ok')" 2.3s 2 B

• Read /home/megaproxy/claude/projects/llm-whodunit/app/db.py 3ms 21.6 KB

• Read /home/megaproxy/claude/projects/llm-whodunit/app/dsl.py 3ms 8.4 KB

Now let me read registry.py, guardrail.py, input_guard.py, and llm.py.

• Read /home/megaproxy/claude/projects/llm-whodunit/app/registry.py 4ms 5.3 KB

• Read /home/megaproxy/claude/projects/llm-whodunit/app/llm.py 4ms 5.1 KB

Wrote /home/megaproxy/claude/projects/llm-whodunit/cases/the-hollow-line/_fragments/loc_marrow.json (parses ok). location loc_marrow (lookables: look_marrow_board, look_marrow_handcar, look_marrow_shrine); npcs: npc_silt, npc_meek, npc_dray; items: item_med; flags: none; quests: q_route, q_filter, q_crank, q_passage; reveals: rev_silt_lead, rev_meek_kit, rev_meek_filter, rev_dray_parts, rev_dray_gate.

Spine impact: this hub grants only item_med (Meek's heal item) and sets no spine flags — it orients the player and seeds the four main quests; rev_silt_lead's existence is what unlocks loc_archive per the bible's `reveal:rev_silt_lead` gate, and the reveals point toward where the four spine flags (have_route/have_filter/have_crank/passage_cleared) are actually earned at later stations.

• Read /home/megaproxy/claude/projects/llm-whodunit/app/input_guard.py 3ms 8.8 KB

• Read /home/megaproxy/claude/projects/llm-whodunit/app/guardrail.py 3ms 5.2 KB

Now let me check config settings and the resolve_adventure helper (registry §7 says it should exist; let me check if it's been added yet).

• Bash grep -n "resolve_adventure\|RAPPORT_THRESHOLD\|HISTORY_TURNS\|GUARDRAIL_RETRIES" app/registry.py app/config.py 28ms 256 B

`resolve_adventure` doesn't exist yet in registry.py (it's owned by another task). My task says to resolve via `db.get_session(sid)['case_id']` using "registry.resolve-style title fallback against the adventures dict". So I'll implement the resolution inline (slug first, then title fallback) rather than depending on a registry helper that isn't there yet. This mirrors `engine._require_case` but against my own `_adventures` dict.

Now I have everything I need. Let me write `app/adv_engine.py`.

• Write /home/megaproxy/claude/projects/llm-whodunit/app/adv_engine.py 11ms 160 B

I notice I overcomplicated the `_completed_quests` reveal handling with a confusing `_all_fired_reveals_from` stub. Let me fix that — `_completed_quests` should take the fired reveals as an argument so quest gates that reference `reveal:` work correctly, and the awkward stub goes away.

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/adv_engine.py 8ms 170 B

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/adv_engine.py 7ms 170 B

Now update the other `_completed_quests` call sites (examine, objectives, check_win, _goal_ready) and the function signature itself.

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/adv_engine.py 10ms 170 B

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/adv_engine.py 10ms 170 B

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/adv_engine.py 10ms 170 B

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/adv_engine.py 8ms 170 B

Now the `_completed_quests` function itself and the `_goal_ready` call site.

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/adv_engine.py 9ms 170 B

Now remove the obsolete `_all_fired_reveals_from` stub and fix the `_goal_ready` call site.

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/adv_engine.py 7ms 170 B

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/adv_engine.py 9ms 170 B

Now verify the import works.

• Bash .venv/bin/python -c "import app.adv_engine; print('OK'); print([n for n in dir(app.adv_engine) if not n.startswith('__')… 2.0s 560 B

Imports cleanly. Let me run a quick smoke test against an in-memory-style DB to confirm the sync functions work end to end (no LLM needed for examine/objectives/check_win/evaluate_unlocks), and that the existing mystery engine still imports.

• Bash .venv/bin/python -c " import os, tempfile os.environ['DB_PATH'] = tempfile.mktemp(suffix='.db') from app import db, adv_… 2.1s 33 B

All sync paths work end to end: examine grants items/flags, inventory reflects them, hidden-room unlock fires on flag, win latches only when at goal, and zero-leak holds (no `win_when`/`win_text`/`grants` in serialized output). The mystery engine still imports.

Public functions exposed in `app/adv_engine.py` (absolute path: `/home/megaproxy/claude/projects/llm-whodunit/app/adv_engine.py`), for the API agent to call:

Registry (call at startup from main.py):
- `set_adventures(advs: dict[str, AdventureFile]) -> None`
- `get_adventures() -> dict[str, AdventureFile]`

Per-session operations (all take `sid: str`):
- `async process_turn(sid, npc_id: str, message: str, look_id: str | None = None) -> dict` — returns `{"reply": str, "events": {...}}`. May raise `ValueError` (unknown npc) or `llm.LLMUnavailable` (map to 503). Free-text messages are input-guarded; on a hit it returns an in-character deflection with empty events and does NOT call the model.
- `examine(sid, look_id: str) -> dict` — returns `{"look": {id,name,desc}, "events": {...}}`. Raises `ValueError` for unknown or not-yet-surfaced (hidden) lookables.
- `evaluate_unlocks(sid) -> dict` — returns `{"unlocked_rooms": [...], "unlocked_lookables": [...]}`. Auto-discovers surfaced hidden lookables.
- `objectives(sid) -> dict` — returns `{"goal": {...ready/won}, "quests": [{...done}]}` (public, no `win_when`; `win_text` only once won).
- `inventory(sid) -> list[dict]` — `[{id,name,desc}]` for held items only.
- `journal(sid) -> list[dict]` — casebook log entries `[{entry, ts}]` (oldest first).
- `check_win(sid) -> dict` — `{"won": bool}` plus `"win_text"` once won; latches session status to `'won'` when `goal.win_when` is satisfied AND `current_location == goal.location_id`.

`events` shape (every `process_turn`/`examine` return): `{granted_items: [...], set_flags: [...], fired_reveals: [...], completed_quests: [...], unlocked_rooms: [...], unlocked_lookables: [...], won: bool}`.

Resolution: `_require_adv(sid)` resolves via `db.get_session(sid)['case_id']` against the registered adventures dict (slug first, then `meta.title` fallback), raising `RuntimeError` if none loaded/found.

Notes for the API agent:
- The "Ride the line out" / win-readiness signal (`goal.ready` in `objectives(sid)`) is `win_when` satisfied regardless of location; the actual win additionally requires being at `goal.location_id`. The `POST /api/adv/win` endpoint should call `check_win(sid)`.
- `process_turn` already handles tone classification, one-reveal-per-turn firing in declaration order, grants, journal, unlocks, and output guardrail internally — the API just passes through `reply` + `events`.
- Public serializers (`adv_models.public_*`) are used internally; the engine never returns secret fields.

I'll start by reading the authoritative spec and the existing code files.

• Read /home/megaproxy/claude/projects/llm-whodunit/app/adv_engine.py 488ms 40.1 KB

• Read /home/megaproxy/claude/projects/llm-whodunit/docs/adventure-build.md 10ms 22.6 KB

• Read /home/megaproxy/claude/projects/llm-whodunit/app/adv_models.py 2ms 11.9 KB

• Read /home/megaproxy/claude/projects/llm-whodunit/app/api.py 2ms 23.6 KB

• Read /home/megaproxy/claude/projects/llm-whodunit/app/main.py 2ms 2.9 KB

• Read /home/megaproxy/claude/projects/llm-whodunit/app/registry.py 3ms 5.3 KB

Now let me look at db.py helpers I'll need, models.MenuInfo, and the existing tests/cases structure.

• Bash grep -n "def \(create_session\|set_location\|mark_visited\|get_visited\|get_session\|set_status\)" app/db.py; echo "---M… 33ms 1.4 KB

• Bash ls -la cases/the-hollow-line/; echo "---"; find . -path ./.venv -prune -o -name "test_*.py" -print; echo "---PYTEST COUN… 2.1s 401 B

There's a `the-hollow-line` folder but no `adventure_file.json` yet. Let me check what's in it and find the test files.

No `adventure_file.json` yet (content owned by other tasks). So I confirm imports + mystery still works. Let me check db helpers for the adventure helpers (add_item, get_items, set_flag, get_flags, get_log, add_log, get_discovered, add_discovered, get_unlocked, unlock_room, get_npc_state) exist.

• Bash grep -n "^def " app/db.py | grep -iE "add_item|get_items|set_flag|get_flags|get_log|add_log|get_discovered|add_discovere… 26ms 904 B

All db helpers exist. Now I have everything I need. Let me check the `get_session` return — does it include `current_location`? The engine's check_win uses `session.get("current_location")`.

• Read /home/megaproxy/claude/projects/llm-whodunit/app/db.py 3ms 1.0 KB

Now I have a complete picture. Let me write the three files. First, `adv_api.py`.

The world shape per §6: `{locations[], current, npcs_here[], objectives, inventory[], won, status, game_id, title}`. I need a `_world` builder for adventure. Let me check how the engine's `_require_adv` raises — it raises `RuntimeError`. I'll map: no session → 404, no adventure (RuntimeError) → 503.

I'll build the router so it resolves the adventure via `adv_engine.get_adventures()` + `_resolve_adventure` semantics, but cleanly mapping to HTTP codes (404 unknown session, 503 no adventure).

• Write /home/megaproxy/claude/projects/llm-whodunit/app/adv_api.py 15ms 157 B

Now `registry.py` — additive changes: load adventures, build summaries for both, change `load_games` to return a third dict, add `resolve_adventure`.

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/registry.py 5ms 168 B

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/registry.py 10ms 168 B

Now add the adventure summary builder and update `load_games`. Let me add `_summary_for_adventure` after `_summary_for`, and rewrite `load_games`.

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/registry.py 13ms 168 B

Now add `resolve_adventure` after `resolve_case`.

Now `main.py`: update imports, startup to unpack 3-tuple, store `app.state.adventures`, call `adv_engine.set_adventures`, include the adventure router.

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/registry.py 10ms 168 B

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/main.py 10ms 164 B

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/main.py 16ms 164 B

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/main.py 6ms 164 B

Now `api.py`. I need to: update imports (add `adv_engine`, `adv_models`), update `_games` and `_resolve_game` to know about adventures, and branch `create_session` on mode. The mystery `_resolve_game` returns `(slug, case)` but adventures don't have a CaseFile. I'll make `_resolve_game` work for both maps by resolving against the summary first to get the mode, then return mode info.

Let me restructure: add a helper to get summaries+cases+adventures, and rewrite `_resolve_game` to return `(slug, summary)` and then branch. But `_resolve_game` is described as "Keep _resolve_game working for both maps." Let me keep its signature returning the slug and let `create_session` branch.

Let me update the imports and `_games` first.

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/api.py 6ms 163 B

Now `_games` returns `(summaries, cases)`. Other callers use it for mystery. I'll add a separate accessor for adventures rather than change `_games`'s signature (it's used in many mystery places). Let me update `_resolve_game` and `create_session`.

`_resolve_game` currently returns `(slug, case)` and is only called by `create_session`. The instruction says keep it working for both maps. I'll have it return `(slug, summary)` and branch in `create_session`. But changing its return type — it's only called once, so safe. Let me check there are no other callers.

• Bash grep -n "_resolve_game\|_games(" app/api.py 14ms 449 B

`_games` raises 503 if `cases` is empty — but with adventures present and no mystery cases, that would wrongly 503. I need `_games` to be more lenient. However `_games` is used by mystery endpoints (`_case_for_session`, `list_games`). For `list_games`, summaries should include adventures too. Summaries already cover both (from registry). But `_games` raises 503 when `cases` is empty.

The safest minimal approach: keep `_games` for mystery resolution but make the 503 condition check both maps. Let me add an adventures accessor and adjust `_games` to not 503 when adventures exist (so `/api/games` still lists adventure-only libraries). Let me update `_games`.

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/api.py 16ms 163 B

Now rewrite `_resolve_game` and `create_session`. `_resolve_game` will resolve against both maps and return `(slug, summary, case_or_adv)`. Let me restructure to return the slug + summary, then `create_session` looks up the right map.

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/api.py 9ms 163 B

I reference `adv_api._world` in `create_session`, which would create a circular import (adv_api imports... actually adv_api imports `adv_engine`, `adv_models`, `db`, `registry`, `llm` — not `api`). But api imports adv_api. Let me check: `adv_api` does not import `api`, so `from . import adv_api` in api.py is fine. But I haven't imported adv_api in api.py. Let me add it.

• Edit /home/megaproxy/claude/projects/llm-whodunit/app/api.py 6ms 163 B

Now check for circular imports: `main` imports `adv_api` and `api`; `api` imports `adv_api`; `adv_api` imports `adv_engine`, `adv_models`, `db`, `registry`, `llm`. No cycle back to `api`. Good.

Now `_case_for_session` uses `_games` which now returns `cases or {}`. For a mystery session it resolves via `registry.resolve_case(cases, ...)`. Fine.

Let me run the import check and tests.

• Bash .venv/bin/python -c "from app.main import create_app; app = create_app(); print('app OK', [r.path for r in app.routes if… 2.2s 129 B

App builds and adventure routes are mounted. Now a TestClient run: both games in `/api/games`, mystery session works. Since no `adventure_file.json` exists, only the mystery game loads. Let me verify.

• Bash .venv/bin/python -c " from fastapi.testclient import TestClient from app.main import create_app import tempfile, os os.e… 2.2s 277 B

Mystery works and returns `mode:"mystery"`. No adventure_file.json present yet (owned by another task). Let me create a minimal temporary adventure fixture to prove the adventure path end-to-end (world + location fetch return 200), then remove it so I don't touch content files owned by other tasks.

• Bash error cat > /tmp/adv_smoke.py <<'PY' import json, tempfile, os, shutil from pathlib import Path from fastapi.testclient import… 3.6s 167 B

Need to run from repo root on path. Let me set PYTHONPATH.

• Bash PYTHONPATH=/home/megaproxy/claude/projects/llm-whodunit .venv/bin/python /tmp/adv_smoke.py 2>&1 | grep -v "^\[registry\]… 2.2s 639 B

Full adventure flow works end-to-end: both games listed, adventure session created with correct world shape, world/location/examine/objectives/inventory/journal/characters/note/travel/win all 200, win latches with `win_text`, unknown session → 404, and zero leaks in the payloads. Now run the actual test suite.

• Bash .venv/bin/python -m pytest -q 2>&1 | tail -8; rm -f /tmp/adv_smoke.py 2.0s 98 B

All 26 tests pass. Let me confirm the 503 path (adventure endpoint hit for a mystery/unknown-adventure session) behaves correctly.

• Bash PYTHONPATH=. DB_PATH=$(mktemp --suffix=.db) .venv/bin/python -c " from fastapi.testclient import TestClient from app.mai… 2.1s 36 B

All behavior confirmed. Summary of the work:

## Endpoints added — `app/adv_api.py` (`APIRouter(prefix="/api/adv")`)

All resolve the session (404 unknown), then resolve its adventure via `registry.resolve_adventure` (503 if none loaded for the session). Every response flows through `adv_models.public_*` / `adv_engine` public methods — zero-leak verified (no `when`/`say`/`grants`/`win_when`/`win_text`-pre-win/`persona`/`knows`/`public_line`/`unlock_when`).

- `GET /world` → `{locations[], current, npcs_here[], objectives, inventory[], won, status, game_id, title}` (the §6 world shape, built by `_world`).
- `POST /travel {session_id, location_id}` → world; 404 unknown loc, 400 locked; marks visited and re-runs `evaluate_unlocks` so `visited:` gates fire.
- `GET /location/{id}` → `{id,name,desc,locked,lookables[],accessible,npcs[]}`.
- `POST /examine {session_id, look_id}` → `{look, events}`; 404 unknown lookable / not-in-location, 400 locked location or hidden-and-unsurfaced (engine `ValueError`).
- `POST /npc/{id}/chat {session_id, message}` → `{reply, events}`; 404 unknown npc, `LLMUnavailable`→503, `ValueError`→400.
- `GET /objectives`, `GET /inventory`, `GET /journal` (`{log, note}`), `POST /note {content}` → `{ok}`.
- `GET /characters` → roster with id/name/role/location_id/location_name/present/met/learned (fired reveals' spoiler-free `journal` lines only)/transcript.
- `POST /win {session_id}` → `{won, win_text?}` (win_text only once won).

## Wiring edits

- **`app/registry.py`** (additive): imports `adv_models`; added `_summary_for_adventure`; `load_games` now treats a folder with `adventure_file.json` as an adventure (loaded via `adv_models.load_adventure`), builds its `GameSummary` (mode from its menu), and returns a 3-tuple `(summaries, cases, adventures)`; summaries still cover both kinds; added `resolve_adventure(advs, case_id)` with title fallback.
- **`app/main.py`** (additive): imports `adv_api`, `adv_engine`; startup unpacks the 3-tuple, stores `app.state.adventures`, calls `adv_engine.set_adventures(...)`; `include_router(adv_api.router)`.
- **`app/api.py`** (additive): imports `adv_api`, `adv_engine`, `adv_models`; `_games` no longer 503s when only adventures are loaded; added `_adventures(request)` accessor and `_start_location_adv`; `_resolve_game` resolves across both maps and returns the slug; `POST /api/session` branches by mode — adventure path creates the session (`case_id=slug`), seeds the first-unlocked start location, runs `adv_engine.evaluate_unlocks`, and returns `{session_id, game_id, title, mode:"adventure", intro, world}` (adventure world shape); mystery path unchanged except it now also returns `mode:"mystery"`.

## Verification
`.venv/bin/python -m pytest -q` → 26 passed. App builds with adventure routes mounted. With a throwaway adventure fixture: both games appear in `/api/games`; mystery session still 200 (`mode:"mystery"`); adventure session + `GET /api/adv/world` + location fetch + examine→unlock + travel + win all 200 with `win_text` latched; unknown session → 404; mystery session hitting `/api/adv/world` → 503; no field leaks in any payload.

Files touched: `/home/megaproxy/claude/projects/llm-whodunit/app/adv_api.py` (new), `/home/megaproxy/claude/projects/llm-whodunit/app/registry.py`, `/home/megaproxy/claude/projects/llm-whodunit/app/main.py`, `/home/megaproxy/claude/projects/llm-whodunit/app/api.py`.

Note: no `cases/*/adventure_file.json` exists yet (content owned by another task), so only the mystery game loads at runtime today; the adventure wiring is verified against a temporary fixture and will pick up `the-hollow-line` automatically once its `adventure_file.json` lands.

I'll start by reading the authoritative spec and the fragments.

• Read /home/megaproxy/claude/projects/llm-whodunit/docs/adventure-build.md 3ms 22.6 KB

• Bash ls -la /home/megaproxy/claude/projects/llm-whodunit/cases/the-hollow-line/_fragments/ 13ms 673 B

Let me read all 8 fragments and the adv_models.py to understand the validation requirements.

• Read /home/megaproxy/claude/projects/llm-whodunit/cases/the-hollow-line/_fragments/loc_marrow.json 331ms 13.5 KB

• Read /home/megaproxy/claude/projects/llm-whodunit/cases/the-hollow-line/_fragments/loc_cistern.json 3ms 8.5 KB

• Read /home/megaproxy/claude/projects/llm-whodunit/cases/the-hollow-line/_fragments/loc_pumpworks.json 2ms 8.7 KB

• Read /home/megaproxy/claude/projects/llm-whodunit/cases/the-hollow-line/_fragments/loc_greystair.json 2ms 8.6 KB

• Read /home/megaproxy/claude/projects/llm-whodunit/cases/the-hollow-line/_fragments/loc_tannery.json 2ms 9.1 KB

• Read /home/megaproxy/claude/projects/llm-whodunit/cases/the-hollow-line/_fragments/loc_archive.json 3ms 7.3 KB

• Read /home/megaproxy/claude/projects/llm-whodunit/cases/the-hollow-line/_fragments/loc_southgate.json 3ms 7.8 KB

• Read /home/megaproxy/claude/projects/llm-whodunit/cases/the-hollow-line/_fragments/loc_cinder.json 4ms 6.7 KB

• Read /home/megaproxy/claude/projects/llm-whodunit/app/adv_models.py 3ms 11.9 KB

I have all the data. Now let me catalog the items and DSL references. Let me gather all item ids referenced across DSL strings and grants.

Items defined in fragments: item_med (marrow), item_filter, item_scrip (cistern), item_crank (pumpworks), item_mapfrag (greystair), item_passage_token (tannery). No items in archive, cinder, southgate.

DSL/grants item references: item_scrip, item_filter, item_med, item_crank, item_mapfrag, item_passage_token. All defined. No missing items.

Now let me assemble the file. Locations in §A order: marrow, cistern, pumpworks, greystair, archive, tannery, cinder, southgate.

Flags union: have_filter, have_crank, know_route, passage_cleared, pump_fixed, tannery_helped, greystair_reached.

Quests union (dedup by id): from fragments — q_route, q_filter, q_crank, q_passage (these appear in marrow AND individually in others; dedup keeping first), q_pump, q_tannery, q_mapfrag. The task says quests = all fragment quests PLUS the four main quests with specific signatures. The four main already exist in marrow with matching complete_when. I'll use the marrow definitions for the four main (they match the required signatures) and dedup the duplicates from cistern/archive/cinder.

• Write /home/megaproxy/claude/projects/llm-whodunit/cases/the-hollow-line/adventure_file.json 13ms 184 B

A note on two design decisions: I added `flags: ["pump_fixed"]` to `rev_lune_task`'s grants (the fragment had it empty, but the spine requires `pump_fixed` to be set somewhere so `rev_gauge_crank` can fire — Lune walks you through the actual repair, so granting it there closes the chain). I also added `greystair_reached` flag grant to `rev_ash_lore` so that declared flag is reachable. Let me validate, then double-check those are sound by also confirming win-path reachability.

• Bash .venv/bin/python -c "from app import adv_models; a=adv_models.load_adventure('cases/the-hollow-line'); print('loaded', l… 2.2s 116 B

Validates clean. Now let me verify every DSL string parses and every referenced id exists, to satisfy the spec's hard invariants.

• Bash .venv/bin/python -c " import re from app import adv_models a = adv_models.load_adventure('cases/the-hollow-line') item_i… 1.8s 240 B

All ids resolve. Now let me verify every DSL string actually parses under the real `dsl.evaluate` with a stub ctx (invariant E.6), and confirm the win-path reachability for all four spine flags.

• Bash .venv/bin/python -c " from app import adv_models, dsl import inspect a = adv_models.load_adventure('cases/the-hollow-lin… 1.8s 94 B

All 35 DSL strings parse without error. Win-path reachability confirmed by inspection: `have_filter` ← rev_vell_filter; `have_crank` ← rev_gauge_crank (gated on `pump_fixed`, set by rev_lune_task); `know_route` ← rev_quill_route (gated on rapport + visited:loc_greystair/item_mapfrag, both reachable); `passage_cleared` ← rev_kessler_pass; and loc_southgate unlocks on `flag:know_route`. The mystery game is untouched.

The Hollow Line adventure assembled and validated.

cases/the-hollow-line/adventure_file.json — loads clean via adv_models.load_adventure.

Counts: 8 locations (ordered per §A: marrow, cistern, pumpworks, greystair, archive, tannery, cinder, southgate), 13 NPCs, 6 items (item_med, item_filter, item_scrip, item_crank, item_mapfrag, item_passage_token), 7 quests (q_route/q_filter/q_crank/q_passage main + q_pump/q_mapfrag/q_tannery side), 7 flags documented.

Verified: loc_southgate.unlock_when = "flag:know_route"; start loc_marrow is not locked (locked=False, unlock_when=None). All 35 DSL strings parse under dsl.evaluate with a stub ctx (no errors). Every item:/flag:/quest:/reveal:/visited: id referenced in any DSL string or grants block resolves to a registry entry — no missing ids; no items needed adding (all grant/DSL item refs were already defined in fragments).

Two authoring fixes made during assembly to keep the spine reachable: rev_lune_task now grants flag pump_fixed (the fragment left it empty, but pump_fixed gates rev_gauge_crank → item_crank/have_crank, so the crank chain would otherwise be unreachable — Lune walks you through the actual repair), and rev_ash_lore now grants the declared greystair_reached flag. Win path for all four spine flags is reachable. _fragments/ left intact.

I'll start by reading the authoritative spec and the existing files I need to conform to and reuse.

• Read /home/megaproxy/claude/projects/llm-whodunit/docs/adventure-build.md 3ms 22.6 KB

• Read /home/megaproxy/claude/projects/llm-whodunit/app/adv_api.py 2ms 15.6 KB

Now let me read the existing frontend files and look at the objectives shape to understand `won_ready`.

• Read /home/megaproxy/claude/projects/llm-whodunit/web/app.js 314ms 45.0 KB

• Read /home/megaproxy/claude/projects/llm-whodunit/web/index.html 3ms 11.6 KB

Now let me check the adv_engine for the objectives shape (won_ready) and look at styles.css structure.

• Bash grep -n "won_ready\|def objectives\|def inventory\|def check_win\|\"ready\"\|'ready'\|won_ready" /home/megaproxy/claude/… 33ms 203 B

• Read /home/megaproxy/claude/projects/llm-whodunit/app/adv_engine.py 3ms 1.8 KB

• Read /home/megaproxy/claude/projects/llm-whodunit/app/adv_engine.py 3ms 4.3 KB

Let me check the `public_goal` to confirm the exact field name for the ready flag, and check the public serializers.

• Bash grep -n "def public_goal\|def public_quest\|def public_location\|def public_npc\|ready\|won\b" /home/megaproxy/claude/pr… 27ms 680 B

• Read /home/megaproxy/claude/projects/llm-whodunit/app/adv_models.py 3ms 2.5 KB

• Bash grep -n "^\.\|^#\|^:root\|game-screen\|--accent\|--ink\|--paper\|background:\|color:" /home/megaproxy/claude/projects/ll… 35ms 146 B

Now I have the full picture. Key facts:
- `/api/adv/world` returns: `locations[]` (each w/ id/name/desc/locked/accessible/visited/has_npcs/lookables), `current`, `npcs_here[]` (id/name/role/location), `objectives` ({goal, quests}), `inventory[]`, `won`, `status`, `game_id`, `title`. No `won_ready` at top level — readiness is `objectives.goal.ready`.
- `/api/adv/location/{id}` returns: id/name/desc/accessible/lookables[]/npcs[].
- `examine` returns `{look:{id,name,desc}, events}`.
- chat returns `{reply, events}`.
- objectives: `{goal:{...ready,won}, quests:[{...done}]}`.
- inventory: `[{id,name,desc}]`.
- journal: `{log:[...], note}`.
- characters: `[{id,name,role,location_id,location_name,present,met,learned[],transcript[]}]`.
- win: `{won, win_text?}`.

Let me check the styles.css structure for the relevant classes and the menu/game-screen theme scoping.

• Read /home/megaproxy/claude/projects/llm-whodunit/web/styles.css 4ms 2.3 KB

• Read /home/megaproxy/claude/projects/llm-whodunit/web/styles.css 2ms 1.5 KB

I have enough understanding of the structure. The noir theme uses `:root` variables directly (not scoped to `#game-screen`), so I'll create an adventure scope that overrides those same variables under `#adventure-screen` plus its own structural copies. Let me look at a few key structural rules (board, rail, middle, room-box, chat, tabs) to know exactly what to reuse vs re-skin.

• Bash grep -n "^\.board\|^\.rail\b\|^\.rail-left\|^\.rail-right\|^\.middle\|^\.room-box\|^\.topbar\|^\.btn-accuse\|^\.casefile… 22ms 2.4 KB

The structural classes (`.board`, `.rail`, `.middle`, `.room-box`, `.section-label`, `.tabs`, `.chat-*`, `.btn-accuse`) all draw color from `:root` variables. So the cleanest approach: scope an override block on `#adventure-screen` that redefines the same CSS variables (`--brass`, `--blood`, `--teal`, `--paper`, etc.) to the cold palette, plus re-skin the `.middle`/`.rail-*` backgrounds (which use hardcoded hex). I'll reuse all structural class names within `#adventure-screen` and just give it the new theme scope.

Now let me build. First, the HTML — add `#adventure-screen` as sibling of `#game-screen`, plus a win modal.

• Edit /home/megaproxy/claude/projects/llm-whodunit/web/index.html 12ms 167 B

Now wire up `adventure.js` script tag (after app.js, since adventure.js references nothing from app.js but app.js will call `window.Adventure`).

• Edit /home/megaproxy/claude/projects/llm-whodunit/web/index.html 9ms 167 B

Now the adventure controller. It's a self-contained IIFE exposing `window.Adventure` with `start(gameId,{fresh})` and `resume(gameId,sid)`. It uses its own state and DOM ids (all prefixed `adv-`), reuses the menu's save model via shared helpers I'll reference from app.js's globals (getSaves/rememberSave/forgetSave) — but to avoid coupling/order issues, I'll have it call back to a small set of shared functions exposed by app.js. Per the spec it should "reuse the menu's per-game save model." Since app.js loads after adventure.js, I'll reference those functions lazily (at call time), which is safe.

Let me check app.js's `showMenu`, `showError`, `api`, save helpers are global (they are — declared with `function`/`const` at top level). I'll reuse `window`-accessible ones. To keep it clean, adventure.js will define its own `api`/`showError`/`el`/save helpers minimally, but reuse is preferred. I'll expose a small shared surface from app.js. Simplest robust approach: adventure.js defines its own thin helpers (no globals collision) and reads/writes the same localStorage keys.

• Write /home/megaproxy/claude/projects/llm-whodunit/web/adventure.js 17ms 159 B

Now I need app.js to: (1) expose `showMenu` and `state` on `window` (adventure.js reads `window.state.games` and `window.showMenu`), and (2) branch on `mode` in `startGame`/`resumeGame`. Let me check what `/api/games` returns for mode — the menu data. I'll branch on `g.mode`.

Let me update app.js. First expose `state` and `showMenu` globally, then add mode branching.

• Edit /home/megaproxy/claude/projects/llm-whodunit/web/app.js 11ms 163 B

• Edit /home/megaproxy/claude/projects/llm-whodunit/web/app.js 11ms 163 B

Now the mode branching. `startGame` is the single entry from the menu (card play and continue bar). I'll branch there: look up the game's mode from `state.games`, and for adventure hand off to `window.Adventure.start`. For `resumeGame` (called from `startGame` when a save exists), I also need to branch — but cleanest is to branch in `startGame` before any mystery-specific resume logic. Let me look at the mode field name in `/api/games`.

• Bash grep -rn "\"mode\"\|'mode'\|mode=\|\.mode\b\|menu.mode\|\"genre\"\|summaries\|def games\|/api/games" /home/megaproxy/cla… 32ms 592 B

Good — `/api/games` summaries include `mode`. Now branch in `startGame` and `resumeGame`.

• Edit /home/megaproxy/claude/projects/llm-whodunit/web/app.js 10ms 163 B

Now `resumeGame` is also exposed-by-spec (app.js `.resume(gameId,sid)` handoff). The spec says "resume must re-enter the correct screen by mode." `startGame` already routes to adventure before its internal `resumeGame` call, so the mystery `resumeGame` only ever runs for mystery games. The continue bar calls `startGame`, which is covered. 

However the spec explicitly mentions `window.Adventure.resume(gameId,sid)` as the resume handoff. `Adventure.start` already calls its own `resume` when a save exists. The mystery `resumeGame` is never reached for adventure games. That satisfies the contract. Good.

Now the CSS theme. Let me look at the relevant noir CSS rules that hardcode hex (`.middle`, `.rail-right`, `.rail-left`, room-box current/visited) so I override them under `#adventure-screen`, plus redefine the `:root`-derived accent vars. Let me read the chat/tabs/btn-primary region for vars used.

• Read /home/megaproxy/claude/projects/llm-whodunit/web/styles.css 3ms 2.4 KB

The buttons/elements derive from `:root` vars (`--brass`, `--blood`, `--text`, etc.), but some rules hardcode hex (`.middle`, `.board`, `.rail-right/left`, `.room-box` states). The cleanest theme scope: redefine the CSS custom properties on `#adventure-screen` to a cold palette, and override the handful of hardcoded-hex structural rules. Since `#adventure-screen` reuses `.btn-accuse` for the win button, redefining `--blood`/`--blood-lit` to greens makes the win button green — which fits ("Ride the line out" as the green-accent CTA).

Let me append the adventure theme block at the end of styles.css.

• Bash tail -5 /home/megaproxy/claude/projects/llm-whodunit/web/styles.css; echo "---LINES---"; wc -l /home/megaproxy/claude/pr… 14ms 237 B

• Bash cat >> /home/megaproxy/claude/projects/llm-whodunit/web/styles.css <<'CSS' /* ==========================================… 42ms 4 B

The modal CSS vars: the win/intro/character/confirm modals are siblings outside `#adventure-screen`, so they won't inherit the cold palette vars. That's fine — they reuse the existing noir modal styles which look consistent. The `.adv-win-modal .intro-title` rule I added is harmless. Let me drop the bogus selector and keep it clean. Actually it's benign; leave it.

Now verify syntax.

• Bash node --check web/adventure.js && echo "adventure.js OK" && node --check web/app.js && echo "app.js OK" 4.2s 25 B

Both pass. Let me verify there are no duplicate/leftover global collisions and that the modal-overlay click-outside handler in app.js (which iterates all `.modal-overlay`) won't double-bind the adventure modals — app.js's `wireStaticHandlers` runs once on DOMContentLoaded and binds click-outside to ALL `.modal-overlay`, including the adventure ones. My adventure.js `ensureWired` also binds click-outside to the four adventure modals. That's a double-bind but both do the same `add("hidden")` — harmless (idempotent). However app.js's handler excludes only `intro-modal` (the mystery one) from outside-click-close; `adv-intro-modal` would be closable by app.js's handler. My adventure handler excludes `adv-intro-modal`. So app.js could close adv-intro on outside click. Minor, but let me make app.js's handler skip adventure modals to avoid the conflict.

• Edit /home/megaproxy/claude/projects/llm-whodunit/web/app.js 8ms 163 B

Now let me verify the win-modal CSS selector I appended isn't malformed, and re-check the full appended block parses (CSS won't error a browser but let me sanity-check no stray braces). Let me also confirm the structural classes used by adventure.js HTML all exist (`.room-header`, `.room-objects`, `.room-people`, `.map-legend`, `.chat-input-row`, `.empty-note`). Let me grep.

• Bash cd /home/megaproxy/claude/projects/llm-whodunit; for c in room-header room-objects room-people map-legend chat-input-row… 2.2s 238 B

`room-objects`/`room-people` have no dedicated CSS but are just wrapper divs (the noir HTML uses them too and they're unstyled containers) — fine. All the meaningful classes exist. 

Now verify the CSS braces balance after the append.

• Bash cd /home/megaproxy/claude/projects/llm-whodunit; o=$(grep -o '{' web/styles.css | wc -l); c=$(grep -o '}' web/styles.css… 2.9s 18 B

• Bash curl -sS -m 2 -o /dev/null -w "%{http_code}" http://127.0.0.1:8000/api/games 2>/dev/null || echo "no-server" 1.8s 3 B

Balanced. Let me check whether a server happens to be reachable for the optional Playwright check (don't start one).

Something is on :8000 but `/api/games` 404s — not our app (or a different mount). No reachable app server to drive, so I'll skip the optional Playwright check per instructions (do NOT start a blocking server).

Let me do a final confirmation that the adventure modals' click-outside fix and the `window.state`/`window.showMenu` exposures are consistent, and that `Adventure.start` is referenced correctly in app.js.

• Bash cd /home/megaproxy/claude/projects/llm-whodunit; echo "=== app.js handoff ==="; grep -n "window.Adventure\|modeFor\|wind… 2.0s 668 B

All wiring is consistent. The implementation is complete and both JS files pass `node --check`.

Summary of changes:

Files changed:
- `/home/megaproxy/claude/projects/llm-whodunit/web/index.html` — Added `#adventure-screen` (sibling of `#game-screen`, hidden by default) with the three-column shell reusing `.board`/`.rail`/`.middle`/`.room-box`/chat markup: left = station map (`#adv-map-grid`), middle = room (lookables list `#adv-examine-list`, NPC chips `#adv-npc-list`, chat panel `#adv-chat-panel`), right = Objectives (`#adv-goal` + `#adv-quest-list` with done ticks), Pack/inventory (`#adv-pack`), and Journal/Notes/Cast tabs (`.adv-tab`). The accuse button is replaced with `#adv-win-btn` ("Ride the line out"). Added adventure intro, win, character-dossier, and start-over confirm modals. Loads `/static/adventure.js` before `app.js`.
- `/home/megaproxy/claude/projects/llm-whodunit/web/adventure.js` — New IIFE controller (no app.js global collisions; all DOM ids prefixed `adv-`) driving `#adventure-screen` via `/api/adv/*`: boot/enter, world render (map + travel), location detail (lookables/examine + NPCs), chat (reusing the copied `parseActions` speech/action parser), objectives/inventory/journal/notes/cast refresh, dossier, and the win flow (`POST /api/adv/win` → win modal). Reuses the menu's per-game save model via the shared `whodunit.saves`/`whodunit.last_game` localStorage keys.
- `/home/megaproxy/claude/projects/llm-whodunit/web/app.js` — Exposed `window.state` and `window.showMenu`; added `modeFor(gameId)`; `startGame` now branches on the selected game's `mode` (from `state.games`, loaded from `/api/games`) and hands off to `window.Adventure.start(gameId,{fresh})` for `mode:"adventure"` (mystery path unchanged). `showMenu` hides `#adventure-screen` too; the modal click-outside handler skips `#adv-*` overlays (owned by adventure.js).
- `/home/megaproxy/claude/projects/llm-whodunit/web/styles.css` — Added a cold/green-tinted theme scope for `#adventure-screen` (accent `#5a8f7b`) that redefines the shared color variables to a damp underground palette, re-skins the few hardcoded-hex structural rules (board/middle/rails/room-box states, straight-line station layout), and styles the adventure-only Objectives/Pack widgets. The win button reuses `.btn-accuse`, which the scoped vars recolor green.

Resume re-enters the correct screen by mode: the continue bar and cards call `startGame`, which routes adventure games to `Adventure.start` (which itself resumes from the saved sid when present); mystery games keep the existing `resumeGame` path.

Global entrypoint exposed by the adventure controller: `window.Adventure`, with methods `window.Adventure.start(gameId, { fresh })` and `window.Adventure.resume(gameId, sid)`.

Verification: `node --check web/adventure.js` and `node --check web/app.js` both pass; CSS braces balanced (301/301). The optional Playwright check was skipped — no app server was reachable (port 8000 returned 404 for `/api/games`, i.e. not this app) and the instructions forbid starting a blocking server.

I'll start by reading the authoritative spec, then verify the build.

• Read /home/megaproxy/claude/projects/llm-whodunit/docs/adventure-build.md 4ms 22.6 KB

Now let me explore the project structure and read the key files.

• Bash ls -la && echo "---APP---" && ls -la app/ 2>/dev/null && echo "---WEB---" && ls -la web/ 2>/dev/null && echo "---CASES--… 32ms 3.1 KB

Let me start the verification. First, run the mystery tests and check key files in parallel.

• Bash .venv/bin/python -m pytest -q 2>&1 | tail -20 2.3s 98 B

• Read /home/megaproxy/claude/projects/llm-whodunit/app/dsl.py 1.9s 8.4 KB

• Read /home/megaproxy/claude/projects/llm-whodunit/cases/the-hollow-line/adventure_file.json 238ms 72.5 KB

Mystery tests pass (26/26) and DSL has the adventure atoms. Now let me read the adventure files and registry/models.

The adventure file looks complete. Now let me read the registry, adv_models, adv_engine, adv_api, and main.

• Read /home/megaproxy/claude/projects/llm-whodunit/app/registry.py 3ms 8.4 KB

• Read /home/megaproxy/claude/projects/llm-whodunit/app/adv_models.py 2ms 11.9 KB

Models and registry look solid. Now let me read adv_engine, adv_api, and main.

• Read /home/megaproxy/claude/projects/llm-whodunit/app/adv_engine.py 344ms 40.1 KB

Now let me read adv_api.py, main.py, and the db helpers.

• Read /home/megaproxy/claude/projects/llm-whodunit/app/adv_api.py 3ms 15.6 KB

• Read /home/megaproxy/claude/projects/llm-whodunit/app/main.py 2ms 3.3 KB

Now let me check the api.py session creation branch and db.py adventure helpers.

• Bash grep -n "def add_item\|def get_items\|def set_flag\|def get_flags\|def get_visited\|def mark_visited\|def get_discovered… 12ms 1010 B

• Bash grep -n "adventure\|adv_engine\|mode\|game_id\|def create_session\|/api/session\|/api/games\|def list_games" app/api.py … 17ms 3.1 KB

All db helpers exist. Let me read the api.py session creation block in detail and check the `_start_location_adv`.

• Read /home/megaproxy/claude/projects/llm-whodunit/app/api.py 5ms 2.6 KB

Everything is wired. Now let me run the comprehensive verification script covering checks 2-7.

• Bash .venv/bin/python - <<'PY' import json, sys, re sys.path.insert(0, ".") from app import adv_models, dsl, registry # Check… 2.1s 815 B

Checks 2, 3, 4, 5 all pass. DSL parses clean, no dangling ids, all four spine flags have sources, and southgate unlocks from know_route. Let me verify the full reachability chain and then run the TestClient endpoint + zero-leak checks.

• Bash .venv/bin/python - <<'PY' import sys, json sys.path.insert(0, ".") # Use isolated temp DB so we don't touch the real one… 1.7s 28 B

• Bash grep -n "DB_PATH" app/config.py app/db.py 34ms 226 B

The DB_PATH is read at settings init. Let me set it via env before import and run the full TestClient verification (checks 1, 6, 7) plus reachability simulation.

• Bash DB_PATH="/tmp/adv_verify_$$.db" .venv/bin/python - <<'PY' import sys, json, re sys.path.insert(0, ".") from fastapi.test… 3.5s 670 B

Excellent. Checks 1, 6, 7 all pass with zero leaks. 13 NPCs (≥12 required), 7 quests, 8 locations. Now let me do a full win-reachability simulation (drive the engine through the chain) and the frontend node checks.

• Bash DB_PATH="/tmp/adv_reach_$$.db" .venv/bin/python - <<'PY' import sys sys.path.insert(0, ".") from app import db, adv_engi… 2.3s 1.5 KB

Full win chain is reachable end-to-end and the win latches with win_text. Now the frontend node checks.

• Bash node --check web/app.js && echo "app.js OK" && node --check web/adventure.js && echo "adventure.js OK" 1.7s 25 B

All checks pass. Let me run a final cleanup of temp DBs and do one extra zero-leak check on the won-state win endpoint to be thorough (confirming win_text only appears after winning, not before).

• Bash rm -f /tmp/adv_verify_*.db /tmp/adv_reach_*.db 2>/dev/null; echo "cleaned" # Verify the mystery test count one more time… 2.2s 106 B

All eight verification checks pass cleanly with no fixes required. The adventure build conforms exactly to docs/adventure-build.md.

Summary of what I verified:
- **Check 1 (mystery not broken):** 26/26 pytest pass; `/api/games` lists both `the-gilded-cage` and `the-hollow-line`; mystery `POST /api/session` and `GET /api/world` both 200.
- **Check 2 (adventure loads):** registry loads `cases/the-hollow-line`; `adv_models.load_adventure` succeeds; menu mode resolves to `adventure`.
- **Check 3 (DSL):** every `win_when` / `unlock_when` / `complete_when` / reveal `when` string parses under `dsl.evaluate` with an all-False stub Ctx — zero `DSLError`.
- **Check 4 (ids resolve):** every `item:`/`flag:`/`quest:`/`reveal:`/`visited:`/`<loc>` reference (in DSL gates, grants, goal location, npc locations) resolves to a declared id — zero dangling.
- **Check 5 (win reachable):** all four spine flags have sources (`rev_vell_filter`→have_filter, `rev_gauge_crank`→have_crank, `rev_quill_route`→know_route, `rev_kessler_pass`→passage_cleared); `loc_southgate.unlock_when == "flag:know_route"`. I additionally drove the engine through the full dependency chain and confirmed the win latches with `win_text` at `loc_southgate`.
- **Check 6 (endpoints):** adventure session creates with `mode:"adventure"`; `/api/adv/world`, `/objectives`, `/inventory`, `/journal`, `/location/{start}`, `/characters` all 200 with sane shapes (8 locations, 7 quests, 13 NPCs); chat/win/travel routes exist.
- **Check 7 (zero-leak):** none of the adventure responses contain any forbidden token (`win_when`/`persona`/`public_line`/`knows`/`when`/`say`/`grants`/`unlock_when`/`reveal_when`/`win_text`).
- **Check 8 (frontend):** `node --check` passes for both `web/app.js` and `web/adventure.js`.

Relevant files (all clean as authored): `/home/megaproxy/claude/projects/llm-whodunit/cases/the-hollow-line/adventure_file.json`, `/home/megaproxy/claude/projects/llm-whodunit/app/adv_models.py`, `/home/megaproxy/claude/projects/llm-whodunit/app/adv_engine.py`, `/home/megaproxy/claude/projects/llm-whodunit/app/adv_api.py`, `/home/megaproxy/claude/projects/llm-whodunit/app/registry.py`, `/home/megaproxy/claude/projects/llm-whodunit/app/api.py`, `/home/megaproxy/claude/projects/llm-whodunit/app/main.py`, `/home/megaproxy/claude/projects/llm-whodunit/app/dsl.py`, `/home/megaproxy/claude/projects/llm-whodunit/app/db.py`.

• StructuredOutput mystery_ok, adventure_loads, dsl_all_parse, ids_resolve, win_reachable, zero_leak, endpoints_ok, frontend_parses, issues, fixed, summary 4ms 39 B

All eight verification checks pass cleanly. The adventure build ("The Hollow Line") is fully integrated, conforms exactly to the spec, and the mystery game ("The Gilded Cage") remains intact. No fixes were required — the build was correct as authored.

The workflow completed with a clean verdict — all 8 checks green, no fixes needed, and the verifier even drove the engine through the full win chain. I don't take that on faith; let me run my own independent verification before committing.

• Bash cd /home/megaproxy/claude/projects/llm-whodunit echo "=== new files ==="; ls -la app/adv_*.py web/adventure.js cases/the… 2.4s 580 B

Content is substantial (8 locations, 13 NPCs, 7 quests). Now my own API smoke + zero-leak + win-latch check:

• Bash cd /home/megaproxy/claude/projects/llm-whodunit DB_PATH=/tmp/adv_verify.db .venv/bin/python - <<'PY' 2>&1 | tail -40 imp… 3.6s 641 B

The `knows` hit is likely my crude scan matching the word in prose (e.g. "nobody knows") rather than the JSON key. Let me check precisely whether it's an actual leaked field:

• Bash cd /home/megaproxy/claude/projects/llm-whodunit DB_PATH=/tmp/adv_v2.db .venv/bin/python - <<'PY' 2>&1 | tail -20 import … 2.8s 354 B

Confirmed clean — the `knows` hit was the literal word in a room description ("everyone here knows it"), not a leaked field. No secret keys are present. Everything checks out independently. Now a visual pass on the menu (two games) and the adventure screen:

• Bash cd /home/megaproxy/claude/projects/llm-whodunit DB_PATH=/tmp/adv_shot.db .venv/bin/python -m uvicorn app.main:app --port… 5.7s 10 B

• Bash cd /home/megaproxy/claude/projects/llm-whodunit .venv/bin/python - <<'PY' 2>&1 | tail -25 import os os.environ["PLAYWRIG… 6.0s 685 B

• Read /tmp/menu_two.png 140ms 58.7 KB

Both games render and the adventure screen is fully populated (8-station map, locked markers, NPC presence, the "Ride the line out" win action, room prose). Let me look at both screenshots:

• Read /tmp/adventure.png 137ms 106.0 KB

Both screens look excellent — the menu shows two distinctly-themed cards (warm brass mystery, cold green survival), and the adventure screen is a complete playable UI: the 8-station map, Marrow's room with lookables + NPCs (Silt/Meek/Dray), and an Objectives panel listing the goal and all the quests. NPC chat needs your LM Studio box (same as the mystery), but everything else is live.

Let me clean up and commit:

• Bash cd /home/megaproxy/claude/projects/llm-whodunit kill $(cat /tmp/srv2.pid) 2>/dev/null; rm -f /tmp/adv_shot.db /tmp/srv2.… 1.8s 249 B

• Bash cd /home/megaproxy/claude/projects/llm-whodunit .venv/bin/python -c "from app import registry; s,c,a=registry.load_games… 2.0s 232 B

Clean. Committing and pushing:

• Bash cd /home/megaproxy/claude/projects/llm-whodunit git add -A && git -c commit.gpgsign=false commit -q -F - <<'MSG' Add gam… 2.5s 96 B

Pushed. Now updating project memory with the adventure-mode architecture and this session's log: