chore(meta): release v0.1.11

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
chore(db): backup database after worktree merge
2026-02-19 13:13:56 +01:00 · 2026-02-19 13:10:43 +01:00 · 2026-02-19 13:10:30 +01:00 · 2026-02-19 13:10:26 +01:00 · 2026-02-19 13:06:42 +01:00 · 2026-02-19 13:06:30 +01:00
429 changed files with 60504 additions and 864 deletions
@@ -114,7 +114,7 @@ Synthesize findings.

 ### Qatux (Documenter & Librarian)
 - Core team member — participates in discussion rounds as documenter
- Manages document search via `/search-docs` skill
+- Manages document search via `/docs-search` skill
 - Maintains DECISIONS.md, DISCUSSION.md, briefings, and Qdrant search index
 - Answers "did we discuss this?" with citations

@@ -28,7 +28,7 @@ Named after Qatux, the Raiel with perfect memory who helped Paula Myo by recalli
 - Provide "state of the project" summaries when asked

 ### Knowledge management
- Maintain the Qdrant document index via /search-docs skill
+- Maintain the Qdrant document index via /docs-search skill
 - Update briefing files when decisions change
 - Answer retrieval questions: "did we discuss X?", "what did we decide about Y?"
 - Catch staleness in briefings and flag for update
@@ -36,6 +36,10 @@
      "Bash(db/connectors/sqlite-init)",
      "Bash(db/connectors/decisions-sync)",

+      "Bash(db/connectors/audio-generate *)",
+      "Bash(db/connectors/audio-health)",
+      "Bash(db/connectors/audio-post *)",
+
      "Bash(make *)",
      "Bash(make)",

@@ -46,10 +50,11 @@
      "Bash(find *)",
      "Bash(list *)",
      "Bash(tree *)",
+      "Bash(sed -n *)",

-      "Skill(commit)",
+      "Skill(git-commit)",
      "Skill(worktree-update)",
-      "Skill(start-sprint)"
+      "Skill(sprint-start)"
    ],
    "deny": [
      "Bash(git push --force *)",
@@ -0,0 +1,255 @@
+---
+name: audio-gen
+description: >
+  Generate audio assets for The Settled Reach using the Stable Audio Open API
+  (self-hosted Gradio app at tower-of-joy:11500). Use when generating any game
+  audio: ambient loops, SFX, UI sounds, monologue chimes, footsteps, or any
+  sound asset from docs/assets/audio/. Also use when the user asks about audio
+  generation, sound design pipeline, or audio asset iteration. Triggers on:
+  "generate audio", "make sounds", "create ambient", "audio pipeline",
+  "generate sfx", "stable audio", "gen audio", "sound design".
+---
+
+# Audio Generation — The Settled Reach
+
+Generate sonically consistent audio assets using the Stable Audio Open API via
+wrapper scripts at `db/connectors/audio-*`.
+
+Asset descriptions, filenames, bus routing, and design intent are documented in
+`docs/assets/audio/`. This skill provides the prompt system, generation
+workflow, and quality validation.
+
+## API Access
+
+**Never call the API directly.** Use the wrapper scripts:
+
+```bash
+# Check API health
+db/connectors/audio-health
+
+# Generate a single asset (WAV only)
+db/connectors/audio-generate "prompt text" \
+  --duration 10 --steps 100 --cfg 7 \
+  --output path/to/output.wav
+
+# Generate + post-process in one command (WAV → trim → normalize → OGG)
+db/connectors/audio-generate "prompt text" \
+  --duration 10 --steps 100 --cfg 7 \
+  --output path/to/gen/intermediate.wav \
+  --output-ogg client/assets/audio/final.ogg
+
+# Batch-generate from a manifest (preferred for multiple assets)
+db/connectors/audio-batch docs/assets/audio/batch-s10-327.json
+```
+
+### Parameters
+
+| Parameter | Default | Range | Notes |
+|-----------|---------|-------|-------|
+| `--duration` | 10 | 0-47s | Max 47s per generation. For longer loops, generate 45s with crossfade overlap. |
+| `--steps` | 100 | 10-200 | More steps = better quality, slower. Use 50 for quick previews, 100-150 for final. |
+| `--cfg` | 7 | 1-15 | Classifier-free guidance. Higher = more prompt-adherent but less natural. 5-9 is the sweet spot. |
+| `--output` | auto | — | Output WAV file path. Auto-names from prompt if omitted. |
+| `--post` | off | — | Run trim + normalize + convert after generation. |
+| `--output-ogg` | auto | — | OGG output path (implies `--post`). Defaults to same basename as WAV. |
+| `--timeout` | 600 | — | Max wait in seconds. Generation can take 2-5 minutes on 11GB VRAM. |
+
+### Critical Constraints
+
+- **NEVER parallelize requests.** The server has 11GB VRAM and runs one
+  generation at a time. Always wait for a generation to complete before
+  starting the next. Sequential only.
+- **Generation takes 2-5 minutes** per clip depending on duration and steps.
+  Be patient. The timeout default (600s) is generous.
+- **Max 47 seconds** per generation. For 60-90s ambient loops, generate 45s
+  clips and crossfade-stitch in post-processing.
+
+## Prompt Assembly
+
+Every generation uses three parts:
+
+```
+[SONIC FAMILY PREFIX] + [CATEGORY TEMPLATE] + [ASSET DESCRIPTION from docs/assets/audio/]
+```
+
+Never call the API with just the asset description. Always prepend the sonic
+family prefix and matching category template.
+
+- **Sonic palette and families:** Read `references/sonic-palette.md`
+- **Category templates:** Read `references/category-templates.md` and match by
+  asset type (ambient, sfx, ui)
+- **Asset description:** Look up the specific asset in `docs/assets/audio/{category}.md`
+
+## Batch Workflow (Preferred)
+
+For generating multiple assets, use a manifest file. This reduces prompt
+approvals to 2: one Write (manifest) + one Bash (batch run).
+
+### 1. Create the manifest
+
+Write a JSON manifest to `docs/assets/audio/batch-{sprint}-{ticket}.json`:
+
+```json
+{
+  "description": "Sprint 10 ambient + world SFX batch",
+  "output_dir": "client/assets/audio",
+  "gen_dir": "client/assets/audio/gen",
+  "defaults": {
+    "steps": 100,
+    "cfg": 7,
+    "lufs": -16,
+    "quality": 6
+  },
+  "assets": [
+    {
+      "id": "AMB-001",
+      "filename": "amb_station_base.ogg",
+      "method": "sao",
+      "duration": 45,
+      "steps": 150,
+      "cfg": 5,
+      "prompt": "[sonic family prefix] + [template] + [description]"
+    },
+    {
+      "id": "UI-005",
+      "filename": "sfx_monologue_chime.ogg",
+      "method": "synth",
+      "synth": {
+        "type": "harmonic",
+        "duration": 0.8,
+        "fundamental": 1200,
+        "harmonics": [
+          {"freq": 2400, "db": -12},
+          {"freq": 3600, "db": -24}
+        ],
+        "attack_ms": 15,
+        "sustain_ratio": 0.2,
+        "decay": "exponential"
+      }
+    }
+  ]
+}
+```
+
+Asset `id` values must match IDs in `docs/assets/audio/{category}.md` (e.g.,
+AMB-001, SFX-002, UI-005). This couples the manifest to the asset inventory.
+
+### 2. Run the batch
+
+```bash
+# Full run
+db/connectors/audio-batch docs/assets/audio/batch-s10-327.json
+
+# Dry run — preview what would be generated
+db/connectors/audio-batch docs/assets/audio/batch-s10-327.json --dry-run
+
+# Generate only specific assets
+db/connectors/audio-batch docs/assets/audio/batch-s10-327.json --only AMB-001,AMB-002
+
+# Skip assets that already have OGG files
+db/connectors/audio-batch docs/assets/audio/batch-s10-327.json --skip-existing
+```
+
+### 3. Update asset docs with prompts
+
+After the batch completes, write the exact prompts used back into the
+Prompt/Notes column of `docs/assets/audio/{category}.md`. The manifest records
+what was generated; the asset docs record what we have.
+
+### Manifest fields
+
+| Field | Required | Notes |
+|-------|----------|-------|
+| `id` | yes | Asset ID from docs (AMB-001, SFX-002, UI-005) |
+| `filename` | yes | Output filename (must match asset doc) |
+| `method` | yes | `sao` (Stable Audio Open) or `synth` (harmonic synthesis) |
+| `duration` | SAO only | Duration in seconds |
+| `prompt` | SAO only | Full assembled prompt |
+| `steps` | no | Override default steps |
+| `cfg` | no | Override default CFG |
+| `synth` | synth only | Synthesis parameters (see below) |
+
+### Synth parameters
+
+| Field | Default | Notes |
+|-------|---------|-------|
+| `type` | harmonic | Only `harmonic` supported currently |
+| `duration` | — | Duration in seconds |
+| `fundamental` | — | Fundamental frequency in Hz |
+| `harmonics` | [] | List of `{"freq": Hz, "db": dB}` objects |
+| `attack_ms` | 10 | Attack time in milliseconds |
+| `sustain_ratio` | 0.2 | Fraction of duration at full level before decay |
+| `decay` | exponential | `exponential` or `linear` |
+
+## Single Asset Workflow
+
+For one-off generation or iteration on a specific asset:
+
+1. Find the asset in `docs/assets/audio/{ambient,sfx,ui}.md` — note filename,
+   duration, bus, method, and design intent.
+2. Read `references/sonic-palette.md` for the sonic family prefix.
+3. Read `references/category-templates.md` for the matching template.
+4. Assemble the full prompt.
+5. Run `db/connectors/audio-health` to verify the API is up.
+6. Run `db/connectors/audio-generate` with `--post` or `--output-ogg` to
+   generate and post-process in one step.
+7. Verify the output (file size, duration).
+8. Update the asset status and prompt in `docs/assets/audio/{category}.md`.
+
+## Iteration Workflow
+
+For each asset, generate 4-6 candidates:
+
+1. **Generate candidates** — vary the prompt slightly (add/remove descriptors,
+   adjust CFG between 5-9). Run each generation sequentially — never in
+   parallel.
+2. **Solo test** — does each candidate sound right alone?
+3. **Stack test** — play the candidate alongside other layers. Does it mask or
+   clash?
+4. **Fatigue test** (loops only) — can you listen for 5+ minutes without a
+   jarring repeat?
+5. **Close-your-eyes test** — does it create a mental image or sensation?
+6. Select the best candidate (post-processing is already done if `--post` was
+   used).
+
+## Post-Processing (Standalone)
+
+If you need to post-process separately (e.g., re-normalizing an existing file):
+
+```bash
+# Full pipeline: trim → normalize → convert
+db/connectors/audio-post pipeline input.wav --output output.ogg
+
+# Individual steps
+db/connectors/audio-post trim input.wav
+db/connectors/audio-post normalize input.wav --lufs -16
+db/connectors/audio-post convert input.wav --output output.ogg
+```
+
+## Manual Synthesis (Insert-Tech Sounds)
+
+For sounds under 200ms (cursor hover, weapon aim), Stable Audio Open cannot
+produce meaningful output. Use manual synthesis via `tooling/synth_ui_sounds.py`
+or the batch manifest's `method: "synth"` with harmonic parameters.
+
+For complex synthesis beyond the `harmonic` type (FM, filtered noise, bandpass
+impulse), write a custom script in `tooling/` following the pattern in
+`tooling/synth_ui_sounds.py`.
+
+## Quality Checklist
+
+After generating, verify:
+- Sound matches the sonic family (insert-tech = synthetic/precise, organic = warm/natural)
+- Frequency range doesn't mask other layers (check docs/assets/audio/)
+- Duration matches spec
+- No unwanted artifacts (clicks, pops, digital noise at start/end)
+- Loop point is clean (ambient loops only)
+- Volume sits well relative to other assets (LUFS normalized)
+- Passes the close-your-eyes test
+
+## File Placement
+
+Generated assets go to `client/assets/audio/` with exact filenames from the
+asset docs. Intermediates go to `client/assets/audio/gen/` (gitignored).
+
+AudioManager discovers assets by directory scan — filenames must match exactly.
@@ -0,0 +1,67 @@
+# Category Templates — Audio Generation
+
+Match the asset's category to the right template. Append after the sonic family
+prefix and before the specific asset description.
+
+## Ambient Loops
+
+**Template:**
+> Continuous ambient soundscape loop, seamless looping audio, no distinct
+> beginning or end, steady background atmosphere, [DURATION]s duration
+
+**Notes:**
+- Generate at 45s (the SAO sweet spot below the 47s ceiling)
+- Add 3-5s of overlap material for crossfade looping in post
+- These play continuously — they must be boring enough to fade into the
+  background but rich enough to reward attention
+- Station baseline prefix is required (see sonic-palette.md)
+
+**Steps:** 100-150 (higher quality for loops — artifacts are more noticeable)
+**CFG:** 5-7 (lower guidance = more natural variation, less mechanical)
+
+## Sound Effects (SFX)
+
+**Template:**
+> Single isolated sound effect, clean recording, [DURATION] duration,
+> clear attack and natural decay, no background noise, no reverb tail
+> beyond natural
+
+**Notes:**
+- For footsteps: specify surface material, pace, weight
+- For environmental: specify the physical mechanism (door hinge, cargo latch)
+- Keep short and punchy — these are event-driven, not continuous
+
+**Steps:** 80-100 (shorter sounds need fewer steps)
+**CFG:** 7-9 (more guidance = more precise sound matching)
+
+## UI Sounds
+
+**Template:**
+> Interface feedback sound, digital UI element, [DURATION] duration,
+> immediate attack, clean decay, isolated sound with no background
+
+**Notes:**
+- Most UI sounds are under 200ms — use manual synthesis, not SAO
+- For SAO-generated UI sounds (>200ms like fog_recognition, chimes):
+  generate at 3-5s duration, then trim to the best portion
+- Insert-tech prefix is required for lattice/interface sounds
+- Organic prefix for fog_recognition (cognitive, not technological)
+
+**Steps:** 80-100
+**CFG:** 7-9 (precision matters for UI sounds)
+
+## Chimes / Notification Sounds
+
+**Template:**
+> Single musical tone, crystalline quality, [DURATION] duration, gentle
+> attack, resonant sustain, natural fade out, no accompaniment, no rhythm
+
+**Notes:**
+- Generate at 3-5s to give SAO enough temporal context
+- Trim to the best 0.5-1.0s section
+- The attack transient is where the character lives — select for that
+- Normal vs urgent variants: same base prompt, vary "gentle/soft" vs
+  "brighter/sharper/more present"
+
+**Steps:** 100 (tonal quality matters)
+**CFG:** 6-8 (some freedom for natural harmonic content)
@@ -0,0 +1,45 @@
+# Sonic Palette — Prompt Prefixes
+
+Two sonic families. Every generated sound uses one of these as a prompt prefix.
+
+## Insert-Tech (Synthetic)
+
+For UI sounds, neural lattice interface, augmented cognition.
+
+**Prompt prefix:**
+> Clean digital audio, synthetic electronic tone, precise and clinical sound
+> design, no reverb, no room ambience, studio-dry recording, futuristic
+> interface sound
+
+**Character:** Mathematical precision. The sound of well-designed technology.
+No organic texture, no room reflections. Exists "inside the head," not in
+physical space.
+
+**Frequency range:** 800Hz-4kHz primary. Sharp attack, controlled decay.
+
+**Used for:** cursor_hover, implant_open, weapon_aim, sfx_monologue_chime,
+sfx_monologue_chime_urgent
+
+## Organic (Biological/Environmental)
+
+For environmental sounds, human cognition, physical world.
+
+**Prompt prefix:**
+> Warm organic audio, natural sound recording, slight room ambience,
+> lived-in industrial space, realistic acoustic properties, authentic
+> environmental sound
+
+**Character:** Human warmth. Natural attack and decay. Reverberant — exists
+in physical space. The sound of a real place with real materials.
+
+**Frequency range:** 60Hz-3kHz primary. Soft or natural attack, room tail.
+
+**Used for:** fog_recognition, all amb_* ambient loops, all sfx_footstep_*
+
+## Station Baseline
+
+For ambient loops specifically, add the station context:
+
+> Interior of a large industrial space station, metal and composite
+> construction, background mechanical hum from power systems, air circulation
+> audible, no music, no prominent voices unless specified
@@ -1,9 +1,9 @@
 ---
-name: search-docs
+name: docs-search
 description: >
  Search project documents using semantic search (Qdrant + ollama) or grep fallback.
  Use when the user asks "did we discuss X?", "find references to Y", "search docs",
-  or invokes /search-docs. Wraps the qdrant_connector.py for semantic document search.
+  or invokes /docs-search. Wraps the qdrant_connector.py for semantic document search.
 user-invocable: true
 allowed-tools: Bash, Read, Grep, Glob
 ---
@@ -1,8 +1,8 @@
 ---
-name: commit
+name: git-commit
 description: >
  Commit changes with clean, structured messages. Use when the user says
-  "commit", "save my work", "commit changes", or invokes /commit. Enforces
+  "commit", "save my work", "commit changes", or invokes /git-commit. Enforces
  conventional commit format, groups changes into logical commits, and maintains
  CHANGELOG.md. Never squash unrelated changes into one commit.
 user-invocable: true
@@ -1,5 +1,5 @@
 ---
-name: asset-gen
+name: image-gen
 description: >
  Generate themed visual assets for the Lords of Ash CK3 total conversion mod
  using the generate_image MCP tool (Nano Banana / Gemini 2.5 Flash Image).
@@ -1,14 +1,14 @@
 ---
-name: push-pr
+name: pr-push
 description: >
  Push commits and create or update a pull request. Use when the user says
  "push pr", "push and create pr", "update pr", "create a pr", "open a pr",
-  or invokes /push-pr. NOT triggered by plain "push" (that's just git push).
+  or invokes /pr-push. NOT triggered by plain "push" (that's just git push).
  Pushes the current branch, creates a PR if none exists, or confirms the
  existing PR was updated. NEVER merges the PR into main — this skill only
  pushes to the branch and manages the PR lifecycle.
 user-invocable: true
-allowed-tools: Bash, Read, Grep, Glob, AskUserQuestion
+allowed-tools: Bash, Read, Grep, Glob, AskUserQuestion, Skill
 ---

 # Push PR Skill
@@ -34,17 +34,29 @@ git branch --show-current

 If on `main`, stop: "You're on main. Switch to a team branch first."

-### 2. Check for unpushed commits
+### 2. Commit uncommitted changes
+
+```bash
+git status
+```
+
+If there are uncommitted changes (staged or unstaged), run the **commit skill**
+first. Use the `/git-commit` skill to group changes into logical commits with
+proper conventional commit messages. Wait for commit to complete before
+proceeding.
+
+If the working tree is clean (no uncommitted changes), skip to step 3.
+
+### 3. Check for unpushed commits

 ```bash
 git fetch --all
-git status
 git log --oneline origin/<branch>..<branch>
 ```

-If no unpushed commits, skip to step 4 (PR check).
+If no unpushed commits, skip to step 5 (PR check).

-### 3. Check for conflicts with main
+### 4. Check for conflicts with main

 ```bash
 git merge-tree --write-tree origin/main HEAD 2>&1
@@ -59,7 +71,7 @@ git merge origin/main --no-edit
 If merge conflicts, **stop and report** — let the user resolve.
 If clean, continue.

-### 4. Push
+### 5. Push

 ```bash
 git push origin <branch>
@@ -67,7 +79,7 @@ git push origin <branch>

 If push fails, stop and report. Never force-push without explicit request.

-### 5. Check for existing PR
+### 6. Check for existing PR

 ```bash
 tea pr list --login schweitz --repo jpmschweitzer/settled-reach --state open --output simple
@@ -76,9 +88,9 @@ tea pr list --login schweitz --repo jpmschweitzer/settled-reach --state open --o
 Match current branch name in PR list.

 - **PR exists**: Report "Pushed N commits to `<branch>`. PR #X updated." Done.
- **No PR**: Continue to step 6.
+- **No PR**: Continue to step 7.

-### 6. Create a new PR
+### 7. Create a new PR

 ```bash
 git log --oneline main..<branch>
@@ -103,7 +115,26 @@ tea pr create \

 Report PR URL when done.

+### 8. Update ticket status to review
+
+Scan all commit messages in the PR for ticket references (`#NNN`):
+
+```bash
+git log --oneline main..<branch>
+```
+
+Extract ticket IDs from `#NNN` patterns. For each ticket that is
+currently `in_progress`, update it to `review`:
+
+```bash
+db/connectors/ticket status <id> review
+```
+
+Report which tickets were moved to review. Skip tickets that are
+already `done`, `review`, `cancelled`, or `backlog` (only transition
+`in_progress` → `review`).
+
 ## Arguments

-If the user passes arguments (e.g., `/push-pr "my title"`), use them as the
+If the user passes arguments (e.g., `/pr-push "my title"`), use them as the
 PR title instead of generating one.
@@ -1,9 +1,9 @@
 ---
-name: review-pr
+name: pr-review
 description: >
  Review a branch diff with team-appropriate agents before merge. Use when the
  user says "review-pr", "review this PR", "review this branch", or invokes
-  /review-pr. Spawns reviewers matched to the branch type (code, copy, visual,
+  /pr-review. Spawns reviewers matched to the branch type (code, copy, visual,
  audio) in parallel. Reports approve/reject with inline comments.
 user-invocable: true
 allowed-tools: Bash, Read, Grep, Glob, Task
@@ -140,6 +140,10 @@ Respond with:
   - File path and approximate location
   - Severity: critical / warning / suggestion
   - Description of the issue
+
+Verdict rules:
+- Any **critical** or **warning** issue → REQUEST_CHANGES
+- Only **suggestion**-level issues (or none) → APPROVE
 If no issues found, say APPROVE with a brief positive summary.
 ```

@@ -152,19 +156,16 @@ Note: `tea pr reject` does not work on your own PRs. Use `tea comment` instead.
 **IMPORTANT — `tea comment` hangs with inline heredocs and multi-line strings.**
 Always use a two-step approach: write to a temp file first, then pass via `$(cat)`:

-```bash
-# Step 1: Write review to temp file (use Bash heredoc, NOT the Write tool)
-cat > /tmp/review-<branch>.md << 'EOF'
-## Review: <branch> -> main
-...review content...
-EOF
+```
+# Step 1: Write review to .tmp/ using the Write tool (no permission prompt)
+Write(file_path: "<repo_root>/.tmp/review-<branch>.md", content: "...review content...")

 # Step 2: Post to Gitea (separate Bash call)
-tea comment --login schweitz --repo jpmschweitzer/settled-reach <PR_NUMBER> "$(cat /tmp/review-<branch>.md)"
+tea comment --login schweitz --repo jpmschweitzer/settled-reach <PR_NUMBER> "$(cat .tmp/review-<branch>.md)"
 ```

-These MUST be separate sequential Bash calls — do not chain them in a single
-command. The heredoc write must complete before `tea comment` reads the file.
+Use the Write tool for step 1 (avoids Bash permission prompts). The `.tmp/`
+directory is gitignored and exists in the repo root for this purpose.

 ## 7. Merging approved PRs

@@ -1,5 +1,5 @@
 ---
-name: create-skill
+name: skill-create
 description: >
  Guidance for creating effective Claude Code skills (.skill packages).
  Use when the user wants to create, build, design, or iterate on a skill —
@@ -178,7 +178,11 @@ For design patterns, consult:
 **Writing guidelines:** Always use imperative/infinitive form.

 **Frontmatter:**
- `name`: The skill name
+- `name`: The skill name — use **domain-action** naming: `{domain}-{action}`.
+  The domain is the system/area the skill operates on, the action is what it does.
+  Examples: `pr-review`, `sprint-plan`, `docs-search`, `git-commit`, `debt-scan`.
+  Multi-action wrappers (like `ticket`) can use the domain name alone.
+  The directory name must match the `name` field.
 - `description`: Primary triggering mechanism. Include what the skill does AND
  specific triggers/contexts. All "when to use" info goes here (not in body).

@@ -1,9 +1,9 @@
 ---
-name: plan-sprint
+name: sprint-plan
 description: >
  Plan the next sprint and generate team briefing files. Use when the user says
  "plan sprint", "prep sprint briefing", "plan next sprint", "sprint planning",
-  or invokes /plan-sprint. Gathers current sprint status, scans the backlog,
+  or invokes /sprint-plan. Gathers current sprint status, scans the backlog,
  proposes ticket selection, and writes briefing files per team to
  docs/sprints/sprint-N/.
 user-invocable: true
@@ -19,8 +19,8 @@ When this skill is invoked, spawn SI using the Task tool:
 ```
 Task(
  subagent_type: "si",
-  prompt: "Run /plan-sprint for Sprint N. Read the skill at
-    .claude/skills/plan-sprint/SKILL.md for the full workflow,
+  prompt: "Run /sprint-plan for Sprint N. Read the skill at
+    .claude/skills/sprint-plan/SKILL.md for the full workflow,
    then execute it. Use the arguments provided: {args}",
  description: "Plan sprint N"
 )
@@ -0,0 +1,285 @@
+---
+name: sprint-start
+description: >
+  Manage the sprint lifecycle from main, or start sprint work on a team
+  branch. Use when the user says "start sprint", "start working on the
+  server/client/copy", "begin sprint", or invokes /sprint-start. On main:
+  assesses sprint state and does the next right thing (close, activate, or
+  guide). On a team branch: merges main, loads the briefing, presents the
+  work plan.
+user-invocable: true
+allowed-tools: Bash, Read, Grep, Glob, TeamCreate, Task, TaskCreate, TaskUpdate, TaskList, SendMessage, AskUserQuestion
+---
+
+# Start Sprint Skill
+
+Prepare a team branch for sprint work: sync with main, load the sprint
+briefing, and present actionable next steps.
+
+## Workflow
+
+### 1. Determine the team
+
+The current branch IS the team. Read it with:
+```bash
+git branch --show-current
+```
+
+Valid team branches: `server`, `client`, `copy`, `audio`, `visual`, `ci`.
+
+If on `main`, follow the **Main branch workflow** below instead of
+the team branch workflow (steps 2–8).
+
+---
+
+## Main branch workflow (sprint lifecycle management)
+
+When `/sprint-start` is run on `main`, assess the current sprint state
+and do the next right thing. Query the database to determine the state:
+
+```bash
+db/connectors/sqlite-query "SELECT id, name, status FROM sprints ORDER BY id DESC LIMIT 3"
+```
+
+Then follow the **first matching case**:
+
+### Case A: An active sprint exists
+
+The active sprint needs to be closed before moving on.
+
+#### A1. Close the active sprint
+
+```bash
+db/connectors/sprint stop
+```
+
+This marks the active sprint as completed and lists carry-over candidates.
+Note the sprint number (N) from the output.
+
+#### A2. Bump the version
+
+The project version scheme is `v0.1.{sprint_number}`. After closing
+sprint N, the version is `v0.1.N`.
+
+Update `project.yaml`:
+- Set the `version` field to `0.1.N` (this is the source of truth).
+
+Update `server/Cargo.toml`:
+- Set `version = "0.1.N"` in `[package]`.
+
+Update `CHANGELOG.md`:
+- Move all entries under `## [Unreleased]` into a new section
+  `## [v0.1.N] — YYYY-MM-DD` (using today's date).
+- Leave `## [Unreleased]` as an empty section above the new version.
+- Keep the existing sub-headings (Added, Fixed, Changed, Removed) —
+  only move entries that have content.
+
+#### A3. Commit the release
+
+Stage and commit `project.yaml`, `server/Cargo.toml`, and `CHANGELOG.md`:
+```
+chore(meta): release v0.1.N
+```
+
+#### A4. Tag the release
+
+```bash
+git tag v0.1.N
+```
+
+#### A5. Push
+
+```bash
+git push && git push --tags
+```
+
+#### A6. Check for a planned sprint
+
+After closing, re-query the database. If a sprint in `planning` status
+exists, continue to **Case B**. Otherwise, report the close and suggest
+running `/sprint-plan`.
+
+---
+
+### Case B: No active sprint, but a planned sprint exists
+
+A sprint is ready to activate. Verify it looks complete:
+
+1. Check that briefing files exist at `docs/sprints/sprint-N/`:
+   ```bash
+   ls docs/sprints/sprint-N/
+   ```
+2. Check the ticket count:
+   ```bash
+   db/connectors/sprint status --sprint N
+   ```
+
+If briefings are missing or the sprint has 0 tickets, report the gap
+and suggest running `/sprint-plan` to complete planning.
+
+If everything looks ready, activate the sprint:
+
+```bash
+db/connectors/sprint start
+```
+
+Then report:
+- Sprint activated (name, ticket count per team)
+- Remind the user to switch to a team branch and run `/sprint-start`
+  there (or `cd` into the relevant worktree)
+
+---
+
+### Case C: No active sprint and no planned sprint
+
+Nothing is ready. Report the state and suggest running `/sprint-plan`
+to plan the next sprint.
+
+---
+
+## Team branch workflow
+
+### 2. Sync with main
+
+```bash
+git fetch --all
+git merge origin/main --no-edit
+```
+
+If the merge has conflicts, report them and stop — do not force-resolve.
+
+### 3. Load sprint context
+
+Run the sprint CLI to get the full context dump in one shot:
+
+```bash
+db/connectors/sprint start-work
+```
+
+This auto-detects the active sprint and current team from the branch.
+It outputs: sprint metadata, briefing paths, decision refs, actionable
+tickets, blocked tickets, and done tickets.
+
+If no active sprint is found, report that and stop.
+
+### 4. Read the sprint briefing
+
+Read the briefing file(s) listed in the `start-work` output
+(e.g. `docs/sprints/sprint-6/server.md` and `joint.md`).
+If no matching briefing exists for the team, suggest running
+`/sprint-plan` to generate one.
+
+### 5. Load ticket details
+
+For tickets that need more detail than the `start-work` summary provides:
+```bash
+db/connectors/ticket show <id>
+```
+
+### 6. Read key decisions
+
+Read the decision files referenced in the sprint briefing so the agent has
+full architectural context before starting work.
+
+### 7. Mark tickets in progress and present the work plan
+
+Mark all actionable (unblocked, non-done) tickets in the sprint as
+`in_progress`:
+
+```bash
+db/connectors/ticket status <id> in_progress
+```
+
+Then output a summary:
+- Sprint name and goal
+- Branch status (clean merge or conflicts)
+- Tickets marked in_progress (list with IDs)
+- Blocked tickets (and what blocks them)
+- Key decisions loaded
+- Suggested first task (lowest ID unblocked ticket)
+
+### 8. Confirm and spawn the team
+
+Before spawning agents, use `AskUserQuestion` to confirm the work plan and
+agent lineup with the user. If declined, stop.
+
+Once confirmed:
+
+#### 8a. Parse agents from the briefing
+
+Extract agent names from the `**Agents:**` line. Format:
+```
+**Agents:** Name (role), Name (role), ...
+```
+
+Map each name to its `subagent_type` (lowercase):
+- "Dudley (simulation)" → `dudley`
+- "Stig (UI)" → `stig`
+- "Tyre (architecture)" → `tyre`
+- "Hoshe (QA)" → `hoshe`
+- "Mellanie (author)" → `mellanie`
+- etc. (see `.claude/agents/` for full roster)
+
+#### 8b. Create the team
+
+```
+TeamCreate(team_name: "sprint-{N}-{team}")
+```
+
+This makes you the team lead.
+
+#### 8c. Create tasks from tickets
+
+For each ticket in the briefing, create a task:
+
+```
+TaskCreate(
+  subject: "#{id}: {title}",
+  description: "Full ticket details from step 5, plus briefing notes
+    and integration points for this ticket.",
+  activeForm: "Working on #{id}: {short_title}"
+)
+```
+
+After creating all tasks, mirror the dependency chain from the briefing
+using `TaskUpdate` with `addBlockedBy`.
+
+#### 8d. Spawn agents
+
+For each agent from the `**Agents:**` line, spawn a teammate in the
+background. Spawn all agents in parallel (one message, multiple Task calls):
+
+```
+Task(
+  subagent_type: "{name_lowercase}",
+  team_name: "sprint-{N}-{team}",
+  name: "{name_lowercase}",
+  prompt: "You are on the {team} team for Sprint {N}.
+    Branch: `{team}`
+
+    1. Read the sprint briefing: docs/sprints/sprint-{N}/{team}.md
+    2. Read the decision files referenced in the briefing.
+    3. Check TaskList for available work.
+    4. Claim an unblocked task (TaskUpdate with owner: your name),
+       mark it in_progress, and implement it.
+    5. When done, mark the task completed and check TaskList for
+       the next available task.
+
+    Use `db/connectors/ticket show <id>` for full ticket specs.",
+  description: "Sprint {N} {team}: {name}",
+  run_in_background: true
+)
+```
+
+#### 8e. Report
+
+Output to the user:
+- Team name: `sprint-{N}-{team}`
+- Agents spawned (names and roles)
+- Tasks created (count actionable vs blocked)
+- How to interact: `SendMessage` to talk to agents, `TaskList` to
+  check progress
+
+You are now the team lead. Agents work autonomously — monitor via
+`TaskList`, communicate via `SendMessage`, and handle blockers as
+they arise.
@@ -1,11 +1,11 @@
 ---
-name: render-sprite
+name: sprite-gen
 description: >
  Render a 3D model to 2D sprites via the Godot render pipeline. Produces
  sprites at 3 resolutions (1024, 256, 64) from 4 cardinal directions (north,
  east, south, west) with outline applied at working resolution. Use when the
  user says "render sprite", "render model", "run the render pipeline",
-  "test the pipeline", "/render-sprite", or asks to render a specific model
+  "test the pipeline", "/sprite-gen", or asks to render a specific model
  (e.g., "render wall_structural"). Output: 12 PNG files in renderer/output/.
 ---

@@ -14,7 +14,7 @@ description: >
 Run the render script with the model name:

 ```bash
-.claude/skills/render-sprite/scripts/render.sh <model_name>
+.claude/skills/sprite-gen/scripts/render.sh <model_name>
 ```

 ### Available Models
@@ -52,4 +52,4 @@ ls renderer/models/*.tscn | xargs -I{} basename {} .tscn

 1. Create model scene at `renderer/models/<name>.tscn`
 2. Apply texture from `renderer/textures/` via StandardMaterial3D
-3. Run: `.claude/skills/render-sprite/scripts/render.sh <name>`
+3. Run: `.claude/skills/sprite-gen/scripts/render.sh <name>`
@@ -1,8 +1,8 @@
 ---
-name: start-workshop
+name: workshop-start
 description: >
  Start a multi-agent design workshop from a workshop brief. Use when the user says
-  "start workshop", "run workshop", "let's start the workshop", or invokes /start-workshop.
+  "start workshop", "run workshop", "let's start the workshop", or invokes /workshop-start.
  Parses the workshop brief to extract participants, questions, and round format.
  Creates a team, tasks, and spawns agents as teammates via the Task tool.
 ---
@@ -49,8 +49,9 @@ One task per participant containing:
 - Instruction to read the full brief at its path
 - The specific questions assigned to that participant (extracted from all layers)
 - The output format from the brief's round description
+- **IMPORTANT — file output requirement:** Instruct each agent to write their full output to `docs/workshops/{name}/{agent}-round{N}.md` (e.g., `docs/workshops/test-architecture/gestalt-round1.md`). Agents must write to disk, not just send messages. This ensures Qatux and other agents can read all outputs directly without relying on message forwarding.

-One task for Qatux: "Document Round 1 — read all agent responses and capture decisions, questions, and dissent."
+One task for Qatux: "Document Round N — read all agent output files at `docs/workshops/{name}/*-round{N}.md` and capture decisions, questions, and dissent."

 Assign all tasks using TaskUpdate with `owner` = agent name.

@@ -75,10 +76,11 @@ For large workshops (>6 agents), spawn participants in batches to avoid overwhel
 ### 7. Between Rounds

 When all Round N tasks are complete:
-1. Qatux produces round summary in `workshop-notes.md`
-2. Create Round N+1 tasks (integration pass, synthesis, etc.)
-3. Assign to agents with TaskUpdate
-4. Agents continue working
+1. Verify all agents wrote output files to `docs/workshops/{name}/`. If any are missing, nudge the agent or extract from their message and write the file yourself.
+2. Qatux reads all `*-round{N}.md` files and produces round summary in `round-{N}-notes.md`
+3. Create Round N+1 tasks (integration pass, synthesis, etc.) — include the same file output requirement
+4. Assign to agents with TaskUpdate
+5. Agents continue working

 ### 8. Wrap Up

@@ -73,7 +73,7 @@ Cross-reference open PR head branches with the ahead-of-main branches.

 Show a summary table of branches ahead of main. For each branch, indicate:
 - `[PR]` if it has an open pull request — warn that it should go through
-  normal review channels (use `/review-pr` instead)
+  normal review channels (use `/pr-review` instead)
 - Commit count and summary

 Use `AskUserQuestion` to let the user pick which branches to merge.
@@ -1,8 +1,10 @@
 # Build and cache
 .cache/
+.tmp/
 server/target/
 tooling/content-converter/target/
 tooling/line-previewer/target/
+tooling/test-client/target/
 content-ron/

 # Godot client (further ignores managed by client team)
@@ -6,8 +6,212 @@ Format based on [Keep a Changelog](https://keepachangelog.com/).

 ## [Unreleased]

+## [v0.1.11] — 2026-02-19
+
+### Added
+- Sprint 12 "Build" briefings — 50 tickets across server, client, copy, visual, ci teams; production-layer foundations + all v0.1 copy authoring
+- `.tmp/` gitignored repo directory for agent temp files — avoids Bash permission prompts during PR review comment posting
+- `sed -n` blanket permission in shared settings
+
+### Changed
+- All skills renamed to domain-action convention (e.g. `commit`→`git-commit`, `review-pr`→`pr-review`, `gen-audio`→`audio-gen`, `render-sprite`→`sprite-gen`) — 12 renames total
+- `pr-review` skill uses Write tool into `.tmp/` instead of Bash heredocs to `/tmp/`
+
+## [v0.1.10] — 2026-02-19
+
+### Added
+- `project.yaml` — technical project descriptor with version, architecture, simulation, and content model as the canonical version source of truth
+- Scratchpad: asset generation pipeline idea (registry, status tracking, prompt versioning, pre-sprint cohesion)
+- Scratchpad: remote terminal proxy idea for mobile monitoring of Claude Code permission prompts and interactive elements
+- `make perf-baseline` — full plugin stack tick benchmark (50 measured ticks, 5 warmup) capturing per-tick timing, entity counts, process RSS, and shadowcast benchmarks; outputs structured JSON to `tests/perf/baseline.json` with `--compare` mode for regression detection (>20% threshold, D-026 budget check)
+- Michroma font integration (#517) — Michroma-Regular.ttf as game font with +1px tracking FontVariation, global Theme with cyan-white (#E0F7FA) implant text color, IMPLANT_TEXT_COLOR/DIM/PULSE constants
+- Mouse-relative facing and movement (#526, D-054) — mouse position determines facing direction (client-side float), WASD remapped to cursor-relative (W=toward, S=away, A/D=strafe), SET_FACING action sends octant to server, smooth facing indicator rotation
+- Room reset client UX (#502) — amber reset_plate tile type, 0.15s screen flash on room reset, 'Reset Room' interaction verb
+- Auto-checklist progress tracking (#503) — ChecklistEvaluator parses room YAML and evaluates 7 condition types against GameState with latching, ChecklistOverlay renders progress in gauntlet mode only, 48 new tests
+- 4 ambient zone loops: station base, workplace, bar, corridor — SAO-generated organic soundscape with crossfade loop points (#327)
+- 2 footstep SFX: metal walk and run — SAO hybrid with best-transient extraction (#327)
+- `audio-batch` command — batch audio generation from JSON manifests, supports SAO and harmonic synthesis, with `--dry-run`, `--only`, and `--skip-existing` flags
+- `--post` and `--output-ogg` flags on `audio-generate` — chain post-processing (trim, normalize, convert) into a single command
+
+### Changed
+- `push-pr` skill now runs `/commit` first when uncommitted changes are detected
+- Insert open/close now sends explicit PauseSimulation/ResumeSimulation (#518, D-058) — replaces toggle-style pause with idempotent pair
+- Interaction list colors reference Constants.IMPLANT_TEXT_COLOR instead of hardcoded values
+- World radial menu uses theme font instead of ThemeDB.fallback_font
+- Monologue chimes replaced with production-quality manual synthesis — insert-tech aesthetic per D-074, pure sine harmonics with mathematical envelopes (#327)
+
+### Fixed
+- Bidirectional relationship check (#515) — Check 9 tested `target in npc_rels` which missed NPCs with no relationship entries; changed to `target in self.npcs`
+
+## [v0.1.9] — 2026-02-18
+
+### Fixed
+- `make game` now builds client before launching — was missing `build-client` dependency, causing class_name registration failures after `make clean`
+- `build-client` uses `--import --quit` instead of just `--quit` — ensures `.godot/` cache and `global_script_class_cache.cfg` are created from scratch
+- `make clean` preserves `client/.godot/` directory (clears contents only) to avoid Godot startup issues
+
+### Added
+- `--description TEXT` flag for `ticket create` CLI — previously required raw SQL workaround to set ticket descriptions
+
+### Changed
+- UI audio assets revised — monologue chimes re-generated (0.8s, insert-tech aesthetic), fog_recognition re-generated (was silent), all 8 assets normalized to 44.1kHz stereo LUFS -16 (#453)
+- review-pr skill: explicit verdict rules — critical/warning → REQUEST_CHANGES, suggestion-only → APPROVE
+
+### Added
+- `make golden-diff` + `make golden-update` targets (#486) — developer workflow for golden file comparison and regeneration; safe restore on cargo failure
+- Gauntlet checklist YAML schema (#497) — 7 condition types evaluable from ObserverSnapshot, per-room checklists for 3 rooms, `make checklist-validate` and `make checklist-generate` targets, wired into `pre-pr-content` gate
+- Gauntlet room timer + personal bests (#496) — GauntletHUD shows TIMER: MM:SS (PB: MM:SS), starts on room entry, resets on room change, persists stats to user://dev/gauntlet-stats.json, session summary on disconnect, hidden in non-gauntlet mode
+- WRONG button F12 MVP (#495) — bug report capture: pause sim, show modal prompt, save snapshot.json + render.txt + description.txt to user://bug-reports/, Esc to cancel
+- GameState.room_id and gauntlet_mode fields — parsed from ObserverSnapshot, enabling gauntlet UI
+- BUG_REPORT action in InputMapper (F12 binding) with SimBridge wire guard (client-only)
+- 24 new anti-tedium tests — GauntletHUD lifecycle (16: timer, PB, visibility, room change, session tracking) + BugReportDialog (8: pause/unpause, wire guard, text render, edge cases)
+- whatsinagame starter kit — reusable multi-agent team bootstrap for any project (3-tier profiles, 18 skills, 16 agent archetypes, stakeholder personas, ticketing DB, decision tracking)
+- Domain-action naming convention for skills documented in create-skill guide
+- `gauntlet` feature flag (default-on) — allows stripping Gauntlet test world from release builds with `--no-default-features`
+- `EXPECTED_ENTITY_COUNT` and `RESET_PLATE_STABLE_IDS` constants — entity counts derived from StableId ranges instead of hardcoded values
+- Debounce exact-boundary test for room reset (tick 9 rejected, tick 10 accepted)
+- Reset plate StableId verification in `stable_id_ranges_match_spec`
+- Runtime content test (`content_runtime.rs`) separated from structural loading tests
+- Client P2 tests (#492) — 16 gdUnit4 tests for camera (smoothing, zoom, viewport, follow, no-pan), entity alpha/color (peripheral, forward, NPC color, player constant), UI (monologue, interaction, inventory, dialogue, pause, fog blob, fog z_index)
+- Client P3 tests (#493) — 12 gdUnit4 tests for z-layer ordering (floor/ysort/fog/UI), entity lerp (snap, converge, LERP_SPEED=12.0), Tyre additions (recognition, facing, delta scaling, blob removal)
+- Anti-tedium regression tests (#494) — 5 tests: F12 no-crash guard, no queued input, gauntlet UI hidden in default/normal snapshot/multi-tick modes
+
+### Changed
+- Room reset API consolidated to `plan_reset` only — `execute_reset` removed (was a maintenance trap; production uses Commands via `plan_reset`)
+- `room_at()` documented with z-range and corridor overlap assumptions
+- TCP runtime test now has 10s read timeout and registers player in EntityRegistry
+
+### Removed
+- Dead `RoomMember` component from reset.rs (defined but never used)
+- Protocol v8: dialogue_response field decoding (DialogueResponseEvent with line_id, text, speaker_entity_id) from server #305/D-028
+- Test client binary scaffolding (#480) — standalone crate at `tooling/test-client/` with CLI (--connect, --replay, --text, --json, --quiet, --golden, --ticks), exit codes (0/1/2), golden file JSON diff, JSONL replay loader
+- Snapshot text renderer (#481) — `format_snapshot_text(&ObserverSnapshot)` pub-exported from server crate, entity labels as kind:entity_id sorted by distance, room name stub, 10 unit tests
+- Sprint 9 (Gauntlet) briefing files — server, client, CI, audio, joint — 23 tickets across 4 teams
+- Weapon aim lock audio (`sfx_weapon_aim_lock.ogg`) — clinical targeting confirmation tone for weapon aim state (#440)
+- Stance change audio (`sfx_stance_change.ogg`) — subtle mechanical click for stance toggle feedback (#440)
+
+### Fixed
+- MessagePack int_64 encoder dead code branch (#516) — `-(1 << 63)` overflowed making int_64 branch unreachable; negative values beyond int_32 now correctly encode as 0xd3 instead of 0xcf
+- Cross-encoder fixture pipeline hardened — encode failures now exit non-zero instead of writing empty .msgpack files (#475 review)
+- GDScript fixture test no longer silently skips on missing/empty fixture dir — asserts instead (#475 review)
+- GDScript fixture generator covers all PlayerAction variants (added MoveSouth, MoveEast, MoveWest, Unpause, ToggleStanceDown, WalkAway)
+- `make pre-pr` now checks GDScript fixture staleness alongside Rust fixtures
+- Protocol version bumped from 7 to 8 to match server — fixes 5 test failures from version mismatch
+- Interact action encoding changed from unit variant to struct variant to match server's PlayerAction::Interact { target_entity_id, verb }
+- Monologue duplication test (test_monologue_not_duplicated_after_consumption) fixed — was using poll_snapshot() which doesn't consume _last_snapshot in test mode
+- `make pre-pr` target — full pre-PR verification chain: lint → build → test → content validation → fixture staleness (#460, #465)
+- Branch-specific pre-PR variants: `make pre-pr-server`, `make pre-pr-client`, `make pre-pr-content`
+- Content cross-reference validation (9 checks) — canonical_id uniqueness, relationship targets, location slugs, dialogue locations, fact_ids, triangle membership, npc_count, dialogue line_ids, bidirectional relationships (#464)
+
+### Fixed
+- Dialogue schema missing `focused` (mood) and `greeting` (situation) values added in Sprint 7-8 content
+- Speaker wire ID silent fallback — dialogue now warns and skips when target entity missing from registry (was silently using 0)
+- Cross-plugin system ordering — trigger_recognition_monologue now runs after detect_anomalies (latent determinism bug)
+- Walk-away ordering — process_walk_away now runs after process_talk_interaction (prevents same-tick race)
+- ActiveDialogue overwrite — new Talk while in existing dialogue now emits IncompleteInteraction before replacing
+- Server-side Talk range check — handle_talk now enforces CLOSE_RANGE before setting TalkRequest (was client-only)
+- ExamineNpc label collision — VerbKind::ExamineNpc now uses "Examine NPC" label (was "Observe", same as generic Observe)
+- Dead conditional in main.rs collapsed (both branches were identical)
+- WalkAway variant added to all_player_action_variants_roundtrip serialization test
+
+### Changed
+- DialogueCooldownTracker.used changed from Vec to BTreeMap for O(log n) lookup (D-041 compliance)
+- MonologueState.shown_ids changed from Vec to HashSet for O(1) contains check (was O(n) per tick)
+- Secret trust tier documented as unreachable with TODO for Phase 2 KG-gated unlock
+
+### Added
+- Determinism test: different_seed_produces_different_replay — exercises SimRng via dialogue weighted selection
+- Dialogue selection pipeline (#305, D-028) — 4-layer filtering engine: access tier from KG relationship, situation derivation from game state, trust tier, weighted topic+mood scoring via SimRng. Full Talk verb → selected line → ObserverSnapshot pipeline with cooldown tracking
+- ContentSlug component (#452) — stable content identity from YAML (e.g. "kael-davan") independent of runtime Entity handles, for knowledge graph interaction memory across save/load
+- Walk-away KG recording (#427, D-064) — IncompleteInteraction knowledge events with Talk/Confront type, ActiveDialogue tracking, walk-away detection clears dialogue and records in KG
+- Anomaly detection for urgent recognition (#450, D-060) — AnomalyMarker flags PersonOfInterest/Contradicted entities for 0.3s cognitive delay instead of 0.6s normal
+- Recognition monologue during cognitive delay (#451, D-060) — monologue fires at delay START (grey blob phase), not completion. v0.1 fallback lines, anomaly prioritization, cooldown tracking
+- Server --test-mode, --port, --seed CLI flags (#459) — LISTENING:{port} stdout signal, OS-assigned ports, deterministic seed override, stderr-only tracing
+- Determinism gauntlet test (#466) — 20-tick replay determinism regression test with movement, stance, pause/unpause exercise
+- Pause guard test suite (#461-463, #468) — 7 tests covering movement, unpause, roundtrip, stance, interact, batch, tick_rate during pause
+- EntityRegistry lifecycle tests (#469) — stale mapping, re-register, unknown unregister edge cases
+- Boundary value encode/roundtrip tests (#471) — 41 values across all MessagePack integer format boundaries
+- Encoding asymmetry tests (#473) — Rust decoder accepts GDScript-style signed encodings for unsigned fields
+- Boundary fixture generation (#472) — 14 raw + 5 snapshot fixtures at integer format boundaries
+- Malformed batch rejection test (#479) — truncated, garbage, and mixed payloads rejected atomically
+- Per-fix determinism unit tests (#467) — equidistant NPC ordering, visible tile sorting, same-tile mover resolution
+
+### Fixed
+- Determinism: visible_ids HashSet → BTreeSet for stable iteration order (#456)
+- Determinism: visible entities in snapshot sorted by entity_id (#457)
+- Determinism: movers sorted by Entity bits in validate_movement (#458)
+- Pause guard blocks all actions except Pause/Unpause while paused (previously only blocked movement)
+
+### Changed
+- Protocol version bumped from v7 to v8 (dialogue_response field in ObserverSnapshot)
+
+### Added
+- AudioManager autoload (#255, D-068/D-069/D-073) — 5-bus architecture (Music, Ambient, WorldSFX, PlayerActions, UISounds), directory-scan asset registry, spatial/non-spatial playback, audio dip profiles (dialogue, confrontation, listening_focus) with low-pass filter sweep, zone crossfade stub
+- Dialogue response selection (#435, D-061/D-062) — structured options with response_id, priority sorting, max 3 visible, invisible locked options, RichTextLabel for BBCode support
+- Walk-away mechanic (#437, D-064) — WASD triggers WalkAway input during dialogue, 300ms fade, dialogue_active flag gates movement, re-show on server interrupt
+- Confrontation text styling (#436, D-063) — italic first-person options, 1.5s monologue beat with dialogue dim to 70%, audio dip via AudioManager, walk-away cancels in-flight beat
+- MessagePack boundary value tests (#470) — 41 values (25 positive, 16 negative), encode-only header verification, roundtrip, Rust-style unsigned decode overlap tests
+- Client P0 regression tests (#477) — monologue carry-forward (Bug #5), camera stability during pause (Bug #2)
+- Client P1 tests (#478) — fog shader state (4), entity lifecycle (2), pending recognition blob (1)
+
+### Changed
+- Fog byte magic numbers replaced with named constants (#476) — VIS_HIDDEN/PERIPHERAL/FORWARD, EXP_UNEXPLORED/EXPLORED/VISIBLE in FogState
+- Dialogue options now carry structured {text, response_id, priority, confrontation} instead of plain strings
+- Protocol v7 dialogue decode validates and skips malformed options
+
+### Added
+- QA test architecture workshop complete — 3-round, 7-agent workshop producing 60 tickets (epic #455): Gauntlet test world (7 rooms, 48 entities), test client binary (tooling/test-client/), determinism fixes, content validation, make pre-pr pipeline, 38 client tests, anti-tedium features, human tester workflow
+- Workshop skill updated — agents now write output files to disk instead of sending messages, fixing documenter access
+- Camera anchor test suite — 10 gdUnit4 tests verifying camera init, smoothing cycle, and player tracking
+- Entity position lerping — framerate-independent exponential smoothing so entities slide between tiles instead of snapping
+
+### Fixed
+- Server never sends snapshots — blocking TCP read in receive_bridge_inputs stalled the entire bevy Update schedule; switched to non-blocking I/O with WouldBlock handling
+- Camera doesn't center on player at startup — Camera2D smoothed_camera_pos starts at (0,0); now disable smoothing during init, snap to player, re-enable after first anchored frame
+- Player moves while game is paused — movement commands now discarded when TickRate is Paused (pause/unpause still process)
+- Spacebar only pauses, doesn't toggle — added UNPAUSE action with toggle logic based on tick_rate state
+- MessagePack encodes tick 128 as -128 — off-by-one in signed int boundary checks (<=128 instead of <128) across int8/16/32/64 branches
+- Monologue/dialogue lost on snapshot overwrite — one-shot events now carried forward when a newer snapshot replaces an unconsumed one
+- Fog shader white screen on load failure — ColorRect defaults to transparent, shader load failure logged instead of crashing
+- Fog desync during camera smooth pan — fog rect now tracks camera position instead of player position
+
+### Changed
+- Server game loop throttled to ~20 ticks/sec (50ms frames) — non-blocking TCP loop no longer spins; remaining frame budget available for NPC AI
+- Hold-to-move input model — movement polled each frame with stance-based throttle (Sprint=200ms, Walk=400ms, Careful=600ms, Crouch=800ms) and composite diagonals (W+D → northeast)
+- D-053 updated with client throttle rates and input model documentation
+
+### Added
+- Dialogue box UI skeleton (#434, D-061) — bottom screen, max 20% height, ~65% width, NPC speech + max 3 response options, insert-styled colors, WASD walk-away with 300ms fade, no close button, diegetic on InsertOverlay z-layer 6
+- Fog entity visualization (#431, D-059/D-060) — cognitive delay rendering: sonar-style sound pings (3 concentric rings, 1.5s fade), unrecognized grey blobs with 0.8s breathing pulse, D-033 color transition at 50% recognition progress, ±0.5 tile position drift, FogEntities node at z:950
+
+### Changed
+- Client protocol version bumped from 6 to 7 (pending_recognitions decode for cognitive delay)
+- GameState: current_dialogue and pending_recognitions fields wired from ObserverSnapshot v7
+- Scene tree: DialogueBox added to InsertOverlay, FogEntities at z:950 between fog shader and InsertOverlay
+- Test mode: mock dialogue (Kael NPC, 3 options) and mock cognitive delay entity (6-tick recognition cycle)
+
 ### Added
 - Archetype evidence presentation spec (#443, D-065/D-034/D-033) — detective case file vs smuggler notebook design document: item definitions, knowledge graph presentation, contradiction markers, THE FRIEND arc walkthroughs, systems interaction map, authoring guidelines
+- Cognitive delay system (#423, D-060) — CognitiveDelay component buffers perception events before emitting KnowledgeEvents (0.6s base / 0.3s urgent at 10 tps), pending_recognitions in ObserverSnapshot v7 for client fog entity visualization, cancellation on entity LOS exit
+- ListeningFocus eavesdrop system (#426, D-053) — stationary_ticks tracking for eavesdrop positioning bonus, 30-tick threshold (20 for Careful stance), Sprint blocks accumulation, registered after validate_movement
+- YAML content loader with hot-reload (#326, D-028) — LinePool system parsing dialogue/monologue YAML into BTreeMap-indexed pools, 4-layer query filtering (access > situation > trust > topic+mood), timestamp-polling hot-reload (dev-only), graceful failure preserves previous content
+- Line pool format specification (#308) — formal spec at docs/architecture/line-pool-format.md defining YAML structure, tag enums, 4-layer filtering pipeline, prerequisite-to-KG mapping, ID format, and Rust loader interface
+- InteractionMemory KG schema design (#442, D-064) — design doc at docs/architecture/interaction-memory-schema.md extending FactKnowledge with interaction tracking, 5-state InteractionState enum, monologue prerequisite extension, NpcTolerance reconciliation
+- Audio discussion decisions D-067 through D-074: recognition chime timing, 5-bus architecture, audio dip profiles, confrontation as cognitive vulnerability, monologue chime placeholder strategy, universal conversation murmur, zone crossfade, hybrid audio generation
+- Asset pipeline documentation system (docs/assets/) with category-based index, sonic palette, and generation templates for audio, visual, and video pipelines
+- Stable Audio Open connector and post-processing wrappers (audio-generate, audio-health, audio-post) with timeout handling for 11GB VRAM constraint
+- gen-audio skill with prompt assembly system (sonic palette prefixes + category templates + asset descriptions)
+- 6 interaction UI audio assets (#440): cursor_hover, weapon_aim, implant_open, fog_recognition, sfx_monologue_chime, sfx_monologue_chime_urgent — generated via SAO, needs duration trimming (#453)
+- Dialogue/confrontation ambient dip implementation spec with full Godot AudioBus tween code
+- Synthesis tooling (tooling/synth_ui_sounds.py) for programmatic insert-tech sound generation
+
+### Changed
+- Protocol version bumped from 6 to 7 (pending_recognitions field in ObserverSnapshot)
+- MessagePack fixtures regenerated for protocol v7
+- Monologue trigger system uses .values() iterator (clippy fix)
+- Monologue schema: relationship prerequisite now requires target and state fields
+- 389 tests total (70 new) — cognitive delay pipeline, line pool loader, ListeningFocus, content watching, serialization
+- Renamed asset-gen skill to gen-image for consistent gen-* naming pattern
 - Client protocol v6 bridge — decode player_stance (4 variants) and player_inventory from ObserverSnapshot, TOGGLE_STANCE_UP/DOWN input actions, 25 gdUnit4 tests
 - Three-scope z-layer rendering pipeline (D-049) — world z:0-900 inside CanvasGroup, insert overlay CanvasLayer 10, UI CanvasLayer 20, modal CanvasLayer 30. Y-sort contract enforced, reserved VFX/airborne/lower-floor ranges documented
 - Cursor state machine (#429, D-056) — 4 states (Default/EntityHover/ObjectHover/WeaponAim), 150ms transitions, insert-styled geometric shapes
@@ -3,7 +3,8 @@
 A top-down immersive sim — occlusion-based detective game with combat elements, set in an original science fiction universe. Single-character perspective, asymmetric information as core mechanic, Rimworld-style storyteller. Godot 4 client + Rust/bevy_ecs simulation server via subprocess/IPC (D-020).

 **Official Title:** The Settled Reach (D-021)
-**Repository name:** commonwealth (historical code name, retained for path stability)
+**Repository name:** settled-reach (formerly commonwealth, renamed for clarity)
+**Version source of truth:** `project.yaml` (root `version` field, scheme: `0.1.{sprint_number}`)

 ## Project Structure

@@ -2,7 +2,12 @@ GODOT := $(shell command -v godot4 2>/dev/null || command -v godot 2>/dev/null)

 .PHONY: help setup build client server game stop test lint ci ci-client ci-server clean \
       decisions-sync decisions-coverage decisions-active decisions-orphan \
-       db-backup db-install validate-content content-ron check-fact-ids setup-hooks
+       db-backup db-install validate-content content-ron check-fact-ids setup-hooks \
+       pre-pr pre-pr-lint pre-pr-build pre-pr-test pre-pr-validate pre-pr-fixtures \
+       pre-pr-server pre-pr-client pre-pr-content \
+       fixtures-client golden-diff golden-update \
+       checklist-validate checklist-generate \
+       perf-baseline

 # --- Configuration ---

@@ -35,6 +40,17 @@ help:
 	@echo "  make validate-content   Validate content YAML against schemas"
 	@echo "  make check-fact-ids    Check fact_id references against knowledge catalogs"
 	@echo "  make content-ron       Convert content YAML to RON (build-time)"
+	@echo "  make fixtures-client    Generate GDScript->Rust cross-encoder fixtures (#475)"
+	@echo "  make golden-diff        Show diff if golden file output has changed"
+	@echo "  make golden-update      Regenerate golden file and stage for commit"
+	@echo "  make checklist-validate Validate checklist YAML against schema"
+	@echo "  make checklist-generate Validate checklists + print condition summary"
+	@echo "  make perf-baseline      Run performance benchmarks and save baseline"
+	@echo ""
+	@echo "  make pre-pr             Run all pre-PR checks (lint, build, test, validate, fixtures)"
+	@echo "  make pre-pr-server      Server-scoped pre-PR (lint, build, test, fixtures)"
+	@echo "  make pre-pr-client      Client-scoped pre-PR (lint, build, test)"
+	@echo "  make pre-pr-content     Content-scoped pre-PR (schema + cross-ref validation)"
 	@echo ""
 	@echo "  make setup-hooks       Install pre-commit hooks (included in setup)"
 	@echo ""
@@ -56,6 +72,8 @@ setup-tooling:
 	@command -v python3 >/dev/null 2>&1 || { echo "Install Python 3"; exit 1; }
 	@command -v curl >/dev/null 2>&1 || { echo "Install curl (required for Godot download)"; exit 1; }
 	@command -v unzip >/dev/null 2>&1 || { echo "Install unzip (required for Godot download)"; exit 1; }
+	@python3 -c "import yaml" 2>/dev/null || { echo "Install PyYAML: pip install pyyaml"; exit 1; }
+	@python3 -c "import jsonschema" 2>/dev/null || { echo "Install jsonschema: pip install jsonschema"; exit 1; }

 setup-hooks:
 	@git config core.hooksPath .config/hooks
@@ -70,7 +88,7 @@ build-server:

 build-client:
 	@test -n "$(GODOT)" || { echo "Godot not found. Run 'make setup' first."; exit 1; }
-	$(GODOT) --headless --path client --quit
+	$(GODOT) --headless --path client --import --quit

 # --- Run ---

@@ -81,7 +99,7 @@ client:
 	@test -n "$(GODOT)" || { echo "Godot not found. Run 'make setup' first."; exit 1; }
 	$(GODOT) --path client

-game: stop build-server
+game: stop build
 	@test -n "$(GODOT)" || { echo "Godot not found. Run 'make setup' first."; exit 1; }
 	@echo "Starting server..."
 	@cd server && cargo run &
@@ -104,6 +122,41 @@ test-server:
 fixtures:
 	cd server && cargo test --test gen_fixtures -- --ignored

+fixtures-client:
+	@test -n "$(GODOT)" || { echo "Godot not found. Run 'make setup' first."; exit 1; }
+	@echo "Generating GDScript fixtures for Rust decoder..."
+	$(GODOT) --headless --path client -s res://tests/gen_client_fixtures.gd
+	@echo "Verifying Rust can decode GDScript fixtures..."
+	cd server && cargo test --test serialization gdscript_generated_fixtures
+	@echo "--- Fixtures-client: PASS ---"
+
+golden-diff:
+	@echo "Regenerating golden output for comparison..."
+	@mkdir -p .cache/golden
+	@cp server/tests/golden/proof_room_tick_10.json .cache/golden/before.json
+	@cd server && UPDATE_GOLDEN=1 cargo test --test golden_suite -- proof_room_tick_10_matches_golden; \
+		rc=$$?; \
+		cp ../server/tests/golden/proof_room_tick_10.json ../.cache/golden/after.json 2>/dev/null; \
+		cp ../.cache/golden/before.json ../server/tests/golden/proof_room_tick_10.json; \
+		if [ $$rc -ne 0 ]; then echo "Cargo test failed (golden file restored)."; exit $$rc; fi
+	@if diff -q .cache/golden/before.json .cache/golden/after.json >/dev/null 2>&1; then \
+		echo "--- Golden file: UP TO DATE ---"; \
+	else \
+		echo "--- Golden file has CHANGED ---"; \
+		echo ""; \
+		diff --color -u .cache/golden/before.json .cache/golden/after.json || true; \
+		echo ""; \
+		echo "Run 'make golden-update' to accept changes."; \
+		exit 1; \
+	fi
+
+golden-update:
+	@echo "Regenerating golden file..."
+	@cd server && UPDATE_GOLDEN=1 cargo test --test golden_suite -- proof_room_tick_10_matches_golden
+	@git add server/tests/golden/
+	@echo "--- Golden file updated and staged ---"
+	@echo "Review with: git diff --cached -- server/tests/golden/"
+
 test-client:
 	@test -n "$(GODOT)" || { echo "Godot not found. Run 'make setup' first."; exit 1; }
 	$(GODOT) --headless --path client -s res://addons/gdUnit4/bin/GdUnitCmdTool.gd --ignoreHeadlessMode -a res://tests/
@@ -121,6 +174,70 @@ lint-client:
 	@echo "Checking GDScript for errors..."
 	@$(GODOT) --headless --path client --quit 2>&1 | grep -i "SCRIPT ERROR" && { echo "GDScript errors found"; exit 1; } || echo "No script errors found"

+# --- Pre-PR verification ---
+
+pre-pr: pre-pr-lint pre-pr-build pre-pr-test pre-pr-validate pre-pr-fixtures
+	@echo ""
+	@echo "=== PRE-PR: ALL CHECKS PASSED ==="
+	@echo "Safe to create PR."
+
+pre-pr-lint: lint-server lint-client
+	@echo "--- Lint: PASS ---"
+
+pre-pr-build: build-server build-client
+	@echo "--- Build: PASS ---"
+
+pre-pr-test: test-server test-client
+	@echo "--- Tests: PASS ---"
+
+pre-pr-validate: validate-content check-fact-ids
+	@echo "--- Content validation: PASS ---"
+
+pre-pr-fixtures:
+	@echo "Checking Rust->GDScript fixture staleness..."
+	@cd server && cargo test --test gen_fixtures -- --ignored
+	@if git diff --quiet client/tests/fixtures/; then \
+		echo "--- Rust fixtures: UP TO DATE ---"; \
+	else \
+		echo ""; \
+		echo "--- RUST FIXTURES STALE ---"; \
+		echo "  Protocol changed but fixtures not regenerated."; \
+		echo "  Stale fixtures make all client tests FALSE POSITIVES."; \
+		echo ""; \
+		echo "  Changed files:"; \
+		git diff --stat client/tests/fixtures/; \
+		echo ""; \
+		echo "  Fix: commit the updated fixtures with your protocol change."; \
+		exit 1; \
+	fi
+	@echo "Checking GDScript->Rust fixture staleness..."
+	@$(MAKE) fixtures-client
+	@if git diff --quiet server/tests/fixtures/gdscript/; then \
+		echo "--- GDScript fixtures: UP TO DATE ---"; \
+	else \
+		echo ""; \
+		echo "--- GDSCRIPT FIXTURES STALE ---"; \
+		echo "  Protocol changed but GDScript fixtures not regenerated."; \
+		echo "  Stale fixtures make cross-encoder tests FALSE POSITIVES."; \
+		echo ""; \
+		echo "  Changed files:"; \
+		git diff --stat server/tests/fixtures/gdscript/; \
+		echo ""; \
+		echo "  Fix: commit the updated fixtures with your protocol change."; \
+		exit 1; \
+	fi
+
+# Branch-specific variants (faster, scope-appropriate)
+
+pre-pr-server: lint-server build-server test-server pre-pr-fixtures
+	@echo "=== Server pre-PR: PASSED ==="
+
+pre-pr-client: lint-client build-client test-client
+	@echo "=== Client pre-PR: PASSED ==="
+
+pre-pr-content: validate-content check-fact-ids checklist-validate
+	@echo "=== Content pre-PR: PASSED ==="
+
 # --- CI (run locally) ---

 ci: ci-server ci-client
@@ -159,6 +276,15 @@ validate-content:
 check-fact-ids:
 	@tooling/check-fact-ids

+checklist-validate:
+	@tooling/validate-checklist --check
+
+checklist-generate:
+	@tooling/validate-checklist
+
+perf-baseline:
+	@tooling/perf-baseline
+
 content-ron:
 	cd tooling/content-converter && cargo build --release
 	tooling/content-converter/target/release/content-converter --input content --output content-ron --verbose
@@ -168,5 +294,5 @@ content-ron:
 clean:
 	cd server && cargo clean || true
 	rm -rf .cache/*
-	rm -rf client/.godot client/reports
+	rm -rf client/.godot/* client/reports
 	@echo "Clean complete."
@@ -69,25 +69,26 @@ static func _encode_message(buffer: StreamPeerBuffer, value):
 		TYPE_INT:
 			if - (1 << 5) <= value and value <= (1 << 7) - 1:
 				buffer.put_8(value)
-			elif - (1 << 7) <= value and value <= (1 << 7):
+			elif - (1 << 7) <= value and value < (1 << 7):
 				buffer.put_u8(types["int_8"])
 				buffer.put_8(value)
 			elif 0 <= value and value <= (1 << 8) - 1:
 				buffer.put_u8(types["uint_8"])
 				buffer.put_u8(value)
-			elif - (1 << 15) <= value and value <= (1 << 15):
+			elif - (1 << 15) <= value and value < (1 << 15):
 				buffer.put_u8(types["int_16"])
 				buffer.put_16(value)
 			elif 0 <= value and value <= (1 << 16) - 1:
 				buffer.put_u8(types["uint_16"])
 				buffer.put_u16(value)
-			elif - (1 << 31) <= value and value <= (1 << 31):
+			elif - (1 << 31) <= value and value < (1 << 31):
 				buffer.put_u8(types["int_32"])
 				buffer.put_32(value)
 			elif 0 <= value and value <= (1 << 32) - 1:
 				buffer.put_u8(types["uint_32"])
 				buffer.put_u32(value)
-			elif - (1 << 63) <= value and value <= (1 << 63):
+			elif value < 0:
+				# Negative beyond int_32 range — encode as int_64 (0xd3)
 				buffer.put_u8(types["int_64"])
 				buffer.put_64(value)
 			else:
@@ -133,7 +134,9 @@ static func _encode_message(buffer: StreamPeerBuffer, value):
 				return ERR_INVALID_DATA
 			
 			for obj in value:
-				_encode_message(buffer, obj)
+				var inner_err = _encode_message(buffer, obj)
+				if inner_err:
+					return inner_err

 		TYPE_DICTIONARY:
 			var size = value.size()
@@ -150,8 +153,12 @@ static func _encode_message(buffer: StreamPeerBuffer, value):
 				return ERR_INVALID_DATA
 			
 			for key in value:
-				_encode_message(buffer, key)
-				_encode_message(buffer, value[key])
+				var key_err = _encode_message(buffer, key)
+				if key_err:
+					return key_err
+				var val_err = _encode_message(buffer, value[key])
+				if val_err:
+					return val_err
 		
 		TYPE_PACKED_BYTE_ARRAY:
 			var size = value.size()
@@ -225,11 +232,9 @@ static func _decode_message(buffer: StreamPeerBuffer, err: Dictionary):
 		return buffer.get_utf8_string(size)
 		
 	elif first_byte == types["nil"]: # nil
-		print("null size:%s"%buffer_size)
 		return null
-		
+
 	elif first_byte == types["false"]: # false
-		print("false size:%s"%buffer_size)		
 		return false
 		
 	elif first_byte == types["true"]: # true
@@ -0,0 +1,19 @@
+[remap]
+
+importer="oggvorbisstr"
+type="AudioStreamOggVorbis"
+uid="uid://uflbvtm1aquk"
+path="res://.godot/imported/cursor_hover.ogg-f20fa5adecb73cc9163569968f5867a3.oggvorbisstr"
+
+[deps]
+
+source_file="res://assets/audio/cursor_hover.ogg"
+dest_files=["res://.godot/imported/cursor_hover.ogg-f20fa5adecb73cc9163569968f5867a3.oggvorbisstr"]
+
+[params]
+
+loop=false
+loop_offset=0
+bpm=0
+beat_count=0
+bar_beats=4
@@ -0,0 +1,19 @@
+[remap]
+
+importer="oggvorbisstr"
+type="AudioStreamOggVorbis"
+uid="uid://bw0mfil2343po"
+path="res://.godot/imported/fog_recognition.ogg-fd0dc7f57c3509774a533bc71a7687e7.oggvorbisstr"
+
+[deps]
+
+source_file="res://assets/audio/fog_recognition.ogg"
+dest_files=["res://.godot/imported/fog_recognition.ogg-fd0dc7f57c3509774a533bc71a7687e7.oggvorbisstr"]
+
+[params]
+
+loop=false
+loop_offset=0
+bpm=0
+beat_count=0
+bar_beats=4
@@ -0,0 +1,19 @@
+[remap]
+
+importer="oggvorbisstr"
+type="AudioStreamOggVorbis"
+uid="uid://dei8ikwaqyn67"
+path="res://.godot/imported/implant_open.ogg-46eadc4ed252693e3a936e75ddfdf4bc.oggvorbisstr"
+
+[deps]
+
+source_file="res://assets/audio/implant_open.ogg"
+dest_files=["res://.godot/imported/implant_open.ogg-46eadc4ed252693e3a936e75ddfdf4bc.oggvorbisstr"]
+
+[params]
+
+loop=false
+loop_offset=0
+bpm=0
+beat_count=0
+bar_beats=4
@@ -0,0 +1,19 @@
+[remap]
+
+importer="oggvorbisstr"
+type="AudioStreamOggVorbis"
+uid="uid://b7iopmg6ftp4k"
+path="res://.godot/imported/sfx_monologue_chime.ogg-5981f28716fbe14273c052560195d890.oggvorbisstr"
+
+[deps]
+
+source_file="res://assets/audio/sfx_monologue_chime.ogg"
+dest_files=["res://.godot/imported/sfx_monologue_chime.ogg-5981f28716fbe14273c052560195d890.oggvorbisstr"]
+
+[params]
+
+loop=false
+loop_offset=0
+bpm=0
+beat_count=0
+bar_beats=4
@@ -0,0 +1,19 @@
+[remap]
+
+importer="oggvorbisstr"
+type="AudioStreamOggVorbis"
+uid="uid://4m87qby6qdhc"
+path="res://.godot/imported/sfx_monologue_chime_urgent.ogg-696a4dbc297417724610e01fa44fa575.oggvorbisstr"
+
+[deps]
+
+source_file="res://assets/audio/sfx_monologue_chime_urgent.ogg"
+dest_files=["res://.godot/imported/sfx_monologue_chime_urgent.ogg-696a4dbc297417724610e01fa44fa575.oggvorbisstr"]
+
+[params]
+
+loop=false
+loop_offset=0
+bpm=0
+beat_count=0
+bar_beats=4
@@ -0,0 +1,19 @@
+[remap]
+
+importer="oggvorbisstr"
+type="AudioStreamOggVorbis"
+uid="uid://dbu2lr4scswyn"
+path="res://.godot/imported/sfx_stance_change.ogg-042fce976b2bd1b0806c72aa5dd64755.oggvorbisstr"
+
+[deps]
+
+source_file="res://assets/audio/sfx_stance_change.ogg"
+dest_files=["res://.godot/imported/sfx_stance_change.ogg-042fce976b2bd1b0806c72aa5dd64755.oggvorbisstr"]
+
+[params]
+
+loop=false
+loop_offset=0
+bpm=0
+beat_count=0
+bar_beats=4
@@ -0,0 +1,19 @@
+[remap]
+
+importer="oggvorbisstr"
+type="AudioStreamOggVorbis"
+uid="uid://c5lduxqgx0vme"
+path="res://.godot/imported/sfx_weapon_aim_lock.ogg-649a54b41e9bf6dd8ab414c03bb48cfa.oggvorbisstr"
+
+[deps]
+
+source_file="res://assets/audio/sfx_weapon_aim_lock.ogg"
+dest_files=["res://.godot/imported/sfx_weapon_aim_lock.ogg-649a54b41e9bf6dd8ab414c03bb48cfa.oggvorbisstr"]
+
+[params]
+
+loop=false
+loop_offset=0
+bpm=0
+beat_count=0
+bar_beats=4
@@ -0,0 +1,19 @@
+[remap]
+
+importer="oggvorbisstr"
+type="AudioStreamOggVorbis"
+uid="uid://c2bqso5hkljq1"
+path="res://.godot/imported/weapon_aim.ogg-0bff40b0820b0f9db4c2b0ae2542bfa0.oggvorbisstr"
+
+[deps]
+
+source_file="res://assets/audio/weapon_aim.ogg"
+dest_files=["res://.godot/imported/weapon_aim.ogg-0bff40b0820b0f9db4c2b0ae2542bfa0.oggvorbisstr"]
+
+[params]
+
+loop=false
+loop_offset=0
+bpm=0
+beat_count=0
+bar_beats=4
@@ -0,0 +1,93 @@
+Copyright 2011 The Michroma Project Authors (https://github.com/googlefonts/Michroma-font)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+https://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.
@@ -0,0 +1,8 @@
+[gd_resource type="FontVariation" load_steps=2 format=3]
+
+[ext_resource type="FontFile" path="res://assets/fonts/Michroma-Regular.ttf" id="1_base"]
+
+[resource]
+base_font = ExtResource("1_base")
+spacing_glyph = 1
+spacing_space = 1
@@ -0,0 +1,20 @@
+[gd_resource type="Theme" load_steps=2 format=3]
+
+[ext_resource type="FontVariation" path="res://assets/fonts/michroma_ui.tres" id="1_font"]
+
+[resource]
+default_font = ExtResource("1_font")
+default_font_size = 14
+
+Label/colors/font_color = Color(0.878, 0.969, 0.98, 1)
+Label/font_sizes/font_size = 14
+
+RichTextLabel/colors/default_color = Color(0.878, 0.969, 0.98, 1)
+RichTextLabel/font_sizes/normal_font_size = 14
+
+Button/colors/font_color = Color(0.878, 0.969, 0.98, 1)
+Button/colors/font_hover_color = Color(0.91, 0.773, 0.278, 1)
+Button/font_sizes/font_size = 14
+
+LineEdit/colors/font_color = Color(0.878, 0.969, 0.98, 1)
+LineEdit/font_sizes/font_size = 14
@@ -144,6 +144,14 @@ tutorial_prompts:
  minimap_hint: "The overlay shows the area around you."
  knowledge_hint: "Open your notes to review what you know."

+# ============================================================
+# DIALOGUE
+# Text displayed during dialogue interactions.
+# D-063: Confrontation beat monologue — character's internal hesitation.
+# ============================================================
+dialogue:
+  confrontation_beat: "This changes things. No taking it back."
+
 # ============================================================
 # MENU AND SYSTEM TEXT
 # Non-diegetic. Standard game UI. Clean, no flavor text.
@@ -22,6 +22,12 @@ GameState="*res://scripts/autoloads/game_state.gd"
 InputMapper="*res://scripts/autoloads/input_mapper.gd"
 UIStrings="*res://scripts/autoloads/ui_strings.gd"
 FogState="*res://scripts/autoloads/fog_state.gd"
+AudioManager="*res://scripts/autoloads/audio_manager.gd"
+
+[gui]
+
+theme/custom="res://assets/theme/game_theme.tres"
+theme/custom_font="res://assets/fonts/michroma_ui.tres"

 [display]

@@ -105,6 +111,16 @@ stance_down={
 "events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":88,"key_label":0,"unicode":120,"location":0,"echo":false,"script":null)
 ]
 }
+bug_report={
+"deadzone": 0.5,
+"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":4194343,"key_label":0,"unicode":0,"location":0,"echo":false,"script":null)
+]
+}
+teleport_hub={
+"deadzone": 0.5,
+"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":4194317,"key_label":0,"unicode":0,"location":0,"echo":false,"script":null)
+]
+}

 [rendering]

@@ -1,4 +1,4 @@
-[gd_scene load_steps=15 format=3 uid="uid://bswrmh7w8dbgm"]
+[gd_scene load_steps=20 format=3 uid="uid://bswrmh7w8dbgm"]

 [ext_resource type="Script" path="res://scripts/main.gd" id="1_main"]
 [ext_resource type="Script" path="res://scripts/rendering/world_renderer.gd" id="2_world"]
@@ -14,6 +14,11 @@
 [ext_resource type="PackedScene" path="res://ui/inventory_grid.tscn" id="12_inv"]
 [ext_resource type="PackedScene" path="res://ui/stance_indicator.tscn" id="13_stance"]
 [ext_resource type="PackedScene" path="res://ui/world_radial.tscn" id="14_radial"]
+[ext_resource type="PackedScene" path="res://ui/dialogue_box.tscn" id="15_dialogue"]
+[ext_resource type="Script" path="res://scripts/rendering/fog_entities.gd" id="16_fogent"]
+[ext_resource type="PackedScene" path="res://ui/gauntlet_hud.tscn" id="17_gauntlet"]
+[ext_resource type="PackedScene" path="res://ui/checklist_overlay.tscn" id="18_checklist"]
+[ext_resource type="PackedScene" path="res://ui/bug_report_dialog.tscn" id="19_bugreport"]

 [node name="Game" type="Node2D"]
 script = ExtResource("1_main")
@@ -84,6 +89,13 @@ z_index = 300
 z_index = 900
 script = ExtResource("4_fog")

+; --- z:950 — Fog entities (D-059/D-060 cognitive delay visualization) ---
+; Between fog (z:900) and InsertOverlay (CanvasLayer 10).
+; Sound pings, grey blobs, recognized entity glow + silhouette.
+[node name="FogEntities" type="Node2D" parent="World"]
+z_index = 950
+script = ExtResource("16_fogent")
+
 ; --- Camera ---
 [node name="Camera2D" type="Camera2D" parent="."]
 position_smoothing_enabled = true
@@ -105,6 +117,9 @@ layer = 10
 ; D-058: World radial menu — right-click, 2 spokes (Observe + Insert)
 [node name="WorldRadial" parent="InsertOverlay" instance=ExtResource("14_radial")]

+; D-061: Dialogue box — bottom screen, max 20% height, diegetic insert UI
+[node name="DialogueBox" parent="InsertOverlay" instance=ExtResource("15_dialogue")]
+
 ; --- UI layer (CanvasLayer 20) ---
 ; HUD, monologue, cursor — always visible, not affected by fog or camera.
 [node name="UILayer" type="CanvasLayer" parent="."]
@@ -119,6 +134,12 @@ layer = 20
 ; D-053: Stance indicator — top-right, color-coded
 [node name="StanceIndicator" parent="UILayer" instance=ExtResource("13_stance")]

+; #496: Gauntlet HUD — room timer + personal bests, hidden in non-gauntlet mode
+[node name="GauntletHUD" parent="UILayer" instance=ExtResource("17_gauntlet")]
+
+; #503: Auto-checklist overlay — condition progress in gauntlet mode
+[node name="ChecklistOverlay" parent="UILayer" instance=ExtResource("18_checklist")]
+
 ; D-065: Inventory grid — 3x3, bottom-right, 40x40px, 1-9 hotkeys
 [node name="InventoryGrid" parent="UILayer" instance=ExtResource("12_inv")]

@@ -128,6 +149,8 @@ script = ExtResource("10_cursor")

 ; --- Modal layer (CanvasLayer 30) ---
 ; Full-screen overlays: pause menu, inventory modal, death screen.
-; Empty for Sprint 6 — exists so the layer is reserved in the tree.
 [node name="ModalLayer" type="CanvasLayer" parent="."]
 layer = 30
+
+; #495: WRONG button (F12) — bug report capture dialog
+[node name="BugReportDialog" parent="ModalLayer" instance=ExtResource("19_bugreport")]
@@ -0,0 +1,314 @@
+extends Node
+
+## AudioManager autoload singleton (D-068, D-069, D-073).
+## 5-bus architecture with directory-scan registry pattern.
+## No-op fallback when audio assets absent (D-038).
+## Spatial audio positioning for close-range sounds (D-018).
+
+# --- Bus names (D-068) ---
+const BUS_MUSIC := "Music"
+const BUS_AMBIENT := "Ambient"
+const BUS_WORLD_SFX := "WorldSFX"
+const BUS_PLAYER_ACTIONS := "PlayerActions"
+const BUS_UI_SOUNDS := "UISounds"
+const BUSES := [BUS_MUSIC, BUS_AMBIENT, BUS_WORLD_SFX, BUS_PLAYER_ACTIONS, BUS_UI_SOUNDS]
+
+# D-069: Audio dip profiles — dB offsets relative to player slider setting.
+# Mid-range of spec values used (e.g. -6 to -8 → -7).
+# NOTE: listening_focus requires 30+ stationary ticks before activation (D-069/D-071).
+# The tick gate is the caller's responsibility — AudioManager only manages bus volumes.
+const DIP_SPECS := {
+	"dialogue": {
+		"ease_in": 0.3, "ease_out": 0.5,
+		"buses": { "Ambient": -7.0 },
+	},
+	"confrontation": {
+		"ease_in": 0.5, "ease_out": 1.0,
+		"buses": { "Ambient": -11.0, "WorldSFX": -5.0 },
+		"filter_hz": 800.0,
+	},
+	"listening_focus": {
+		"ease_in": 0.5, "ease_out": 0.5,
+		"buses": { "WorldSFX": 2.5 },
+	},
+}
+
+# Low-pass filter default cutoff — effectively bypassed at this value.
+const FILTER_CUTOFF_DEFAULT := 20500.0
+
+# Asset registry: filename stem (e.g. "amb_station_base") → AudioStream
+var _registry: Dictionary = {}
+
+# Player volume settings per bus (dB). Base for proportional dip calculation.
+var _bus_volumes: Dictionary = {}
+
+# Active dip state (D-069)
+var _active_dip: String = ""
+var _dip_tweens: Array = []
+
+# Low-pass filter on Ambient bus (D-069 confrontation sweep)
+var _ambient_filter: AudioEffectLowPassFilter = null
+
+# Ambient loop players keyed by asset_key (D-073 zone crossfade)
+var _ambient_players: Dictionary = {}
+
+signal dip_changed(profile: String)
+
+
+func _ready() -> void:
+	_setup_buses()
+	_scan_registry()
+
+
+# --- Bus setup ---
+
+func _setup_buses() -> void:
+	for bus_name in BUSES:
+		if AudioServer.get_bus_index(bus_name) < 0:
+			AudioServer.add_bus()
+			var idx := AudioServer.bus_count - 1
+			AudioServer.set_bus_name(idx, bus_name)
+			AudioServer.set_bus_send(idx, "Master")
+		_bus_volumes[bus_name] = 0.0
+	# Low-pass filter on Ambient bus — cutoff starts high (bypassed).
+	# Confrontation dip sweeps it down to 800 Hz (D-069).
+	# Guard: skip if filter already exists (e.g. duplicate _ready in tests).
+	var amb_idx := AudioServer.get_bus_index(BUS_AMBIENT)
+	if amb_idx >= 0 and _ambient_filter == null:
+		_ambient_filter = AudioEffectLowPassFilter.new()
+		_ambient_filter.cutoff_hz = FILTER_CUTOFF_DEFAULT
+		AudioServer.add_bus_effect(amb_idx, _ambient_filter)
+
+
+# --- Asset registry (D-068 directory-scan pattern) ---
+
+func _scan_registry() -> void:
+	_scan_dir("res://audio/")
+	print("AudioManager: %d assets registered" % _registry.size())
+
+
+func _scan_dir(path: String) -> void:
+	var dir := DirAccess.open(path)
+	if dir == null:
+		if path == "res://audio/":
+			print("AudioManager: res://audio/ not found — all play methods no-op")
+		return
+	dir.list_dir_begin()
+	var file_name := dir.get_next()
+	while file_name != "":
+		var full_path := path.path_join(file_name)
+		if dir.current_is_dir():
+			_scan_dir(full_path)
+		elif not file_name.ends_with(".import"):
+			if file_name.get_extension().to_lower() in ["ogg", "wav", "mp3"]:
+				var stream := load(full_path) as AudioStream
+				if stream:
+					_registry[file_name.get_basename()] = stream
+		file_name = dir.get_next()
+
+
+func has_asset(asset_key: String) -> bool:
+	return _registry.has(asset_key)
+
+
+func get_registry_size() -> int:
+	return _registry.size()
+
+
+# --- Playback: non-spatial ---
+
+## Play a one-shot sound on the given bus. No-ops if asset not in registry.
+func play(asset_key: String, bus: String = BUS_UI_SOUNDS) -> void:
+	var stream := _get_stream(asset_key)
+	if stream == null:
+		return
+	var player := AudioStreamPlayer.new()
+	player.stream = stream
+	player.bus = bus
+	add_child(player)
+	player.finished.connect(player.queue_free)
+	player.play()
+
+
+## Start or replace a looping non-spatial sound. Returns the player or null.
+func play_loop(asset_key: String, bus: String = BUS_AMBIENT) -> AudioStreamPlayer:
+	var stream := _get_stream(asset_key)
+	if stream == null:
+		return null
+	stop_loop(asset_key)
+	var loop_stream := stream.duplicate() as AudioStream
+	_enable_loop(loop_stream)
+	var player := AudioStreamPlayer.new()
+	player.stream = loop_stream
+	player.bus = bus
+	add_child(player)
+	player.play()
+	_ambient_players[asset_key] = player
+	return player
+
+
+## Stop a looping sound by asset key.
+func stop_loop(asset_key: String) -> void:
+	if _ambient_players.has(asset_key):
+		var player: AudioStreamPlayer = _ambient_players[asset_key]
+		if is_instance_valid(player):
+			player.stop()
+			player.queue_free()
+		_ambient_players.erase(asset_key)
+
+
+## Stop all looping sounds.
+func stop_all_loops() -> void:
+	for key in _ambient_players.keys():
+		stop_loop(key)
+
+
+# --- Playback: spatial (D-018 close-range) ---
+
+## Play a one-shot spatial sound at a world position (pixels).
+## Added to current_scene for correct AudioListener2D positioning.
+func play_at(asset_key: String, world_position: Vector2, bus: String = BUS_WORLD_SFX) -> void:
+	var stream := _get_stream(asset_key)
+	if stream == null:
+		return
+	var player := AudioStreamPlayer2D.new()
+	player.stream = stream
+	player.bus = bus
+	player.global_position = world_position
+	var scene := get_tree().current_scene
+	if scene:
+		scene.add_child(player)
+	else:
+		add_child(player)
+	player.finished.connect(player.queue_free)
+	player.play()
+
+
+# --- Audio dip profiles (D-069) ---
+
+## Apply a dip profile. Interrupts any active dip, restoring unaffected buses.
+## Profiles: "dialogue", "confrontation", "listening_focus"
+func apply_dip(profile: String) -> void:
+	if not DIP_SPECS.has(profile):
+		push_warning("AudioManager: unknown dip profile '%s'" % profile)
+		return
+	_kill_tweens()
+	_active_dip = profile
+	var spec: Dictionary = DIP_SPECS[profile]
+	var buses: Dictionary = spec.get("buses", {})
+	var ease_in: float = spec.get("ease_in", 0.3)
+	# Tween ALL buses — affected ones get offset, unaffected ones restore to base.
+	for bus_name in BUSES:
+		var offset_db: float = buses.get(bus_name, 0.0)
+		var target_db: float = _bus_volumes.get(bus_name, 0.0) + offset_db
+		var idx := AudioServer.get_bus_index(bus_name)
+		if idx < 0:
+			continue
+		var current_db := AudioServer.get_bus_volume_db(idx)
+		if absf(current_db - target_db) < 0.1:
+			continue
+		var tween := create_tween()
+		tween.tween_method(_make_bus_setter(bus_name), current_db, target_db, ease_in)
+		_dip_tweens.append(tween)
+	# Confrontation: sweep low-pass filter on Ambient (D-069)
+	if spec.has("filter_hz") and _ambient_filter:
+		var tween := create_tween()
+		tween.tween_property(_ambient_filter, "cutoff_hz", spec["filter_hz"], ease_in)
+		_dip_tweens.append(tween)
+	elif _ambient_filter and _ambient_filter.cutoff_hz < FILTER_CUTOFF_DEFAULT - 100.0:
+		# Leaving confrontation for another dip — restore filter
+		var tween := create_tween()
+		tween.tween_property(_ambient_filter, "cutoff_hz", FILTER_CUTOFF_DEFAULT, ease_in)
+		_dip_tweens.append(tween)
+	dip_changed.emit(profile)
+
+
+## Clear the active dip, restoring all bus volumes to player slider settings.
+func clear_dip() -> void:
+	if _active_dip.is_empty():
+		return
+	var spec: Dictionary = DIP_SPECS.get(_active_dip, {})
+	var ease_out: float = spec.get("ease_out", 0.5)
+	_kill_tweens()
+	_active_dip = ""
+	for bus_name in BUSES:
+		var target_db: float = _bus_volumes.get(bus_name, 0.0)
+		var idx := AudioServer.get_bus_index(bus_name)
+		if idx < 0:
+			continue
+		var current_db := AudioServer.get_bus_volume_db(idx)
+		if absf(current_db - target_db) < 0.1:
+			continue
+		var tween := create_tween()
+		tween.tween_method(_make_bus_setter(bus_name), current_db, target_db, ease_out)
+		_dip_tweens.append(tween)
+	# Restore low-pass filter
+	if _ambient_filter and _ambient_filter.cutoff_hz < FILTER_CUTOFF_DEFAULT - 100.0:
+		var tween := create_tween()
+		tween.tween_property(_ambient_filter, "cutoff_hz", FILTER_CUTOFF_DEFAULT, ease_out)
+		_dip_tweens.append(tween)
+	dip_changed.emit("")
+
+
+func get_active_dip() -> String:
+	return _active_dip
+
+
+# --- Volume control (player sliders, D-069 proportional base) ---
+
+## Set the player's volume preference for a bus. During active dip, immediately
+## recalculates effective volume (proportional to new base).
+func set_volume(bus: String, volume_db: float) -> void:
+	_bus_volumes[bus] = volume_db
+	var idx := AudioServer.get_bus_index(bus)
+	if idx < 0:
+		return
+	if _active_dip.is_empty():
+		AudioServer.set_bus_volume_db(idx, volume_db)
+	else:
+		var spec: Dictionary = DIP_SPECS.get(_active_dip, {})
+		var buses: Dictionary = spec.get("buses", {})
+		var offset_db: float = buses.get(bus, 0.0)
+		AudioServer.set_bus_volume_db(idx, volume_db + offset_db)
+
+
+func get_volume(bus: String) -> float:
+	return _bus_volumes.get(bus, 0.0)
+
+
+# --- Zone crossfade (D-073 stub) ---
+
+## Handle zone transition. Server sends zone_id per tile in ObserverSnapshot.
+## Full crossfade implementation deferred to Sprint 9+ (D-073).
+## Stub exists so server integration can call it without conditional checks.
+func set_zone(_zone_id: String) -> void:
+	pass
+
+
+# --- Internal helpers ---
+
+func _get_stream(asset_key: String) -> AudioStream:
+	return _registry.get(asset_key) as AudioStream
+
+
+func _make_bus_setter(bus_name: String) -> Callable:
+	return func(db: float) -> void:
+		var idx := AudioServer.get_bus_index(bus_name)
+		if idx >= 0:
+			AudioServer.set_bus_volume_db(idx, db)
+
+
+func _kill_tweens() -> void:
+	for tween in _dip_tweens:
+		if tween != null and tween.is_valid():
+			tween.kill()
+	_dip_tweens.clear()
+
+
+static func _enable_loop(stream: AudioStream) -> void:
+	if stream is AudioStreamOggVorbis:
+		stream.loop = true
+	elif stream is AudioStreamWAV:
+		stream.loop_mode = AudioStreamWAV.LOOP_FORWARD
+	elif stream is AudioStreamMP3:
+		stream.loop = true
@@ -0,0 +1 @@
+uid://cdkut8u7sxwmb
@@ -4,6 +4,17 @@ extends Node
 ## Read by fog_shader.gd for shader uniforms. Not a renderer — pure data.
 ## Architecture: docs/architecture/fog-shader-spec.md | D-059

+# Fog texture byte values — visibility and exploration layers.
+# Used by fog shader to distinguish visual treatment per tile.
+# Test assertions reference these: assert_that(byte).is_equal(FogState.VIS_FORWARD)
+const VIS_HIDDEN: int = 0        # Not in LOS — fully fogged
+const VIS_PERIPHERAL: int = 180  # In LOS, peripheral sector — light fog dimming
+const VIS_FORWARD: int = 255     # In LOS, forward sector — clear vision
+
+const EXP_UNEXPLORED: int = 0   # Never seen — total darkness
+const EXP_EXPLORED: int = 128   # Previously seen, now out of LOS — deep fog
+const EXP_VISIBLE: int = 255    # Currently in LOS — clear (written each frame)
+
 var map_bounds: Rect2i = Rect2i(0, 0, 1, 1)
 var visibility_texture: ImageTexture
 var exploration_texture: ImageTexture
@@ -31,13 +42,13 @@ func _resize(bounds: Rect2i) -> void:

 	_vis_bytes = PackedByteArray()
 	_vis_bytes.resize(sz)
-	_vis_bytes.fill(0)
+	_vis_bytes.fill(VIS_HIDDEN)
 	_vis_image = Image.create_from_data(_width, _height, false, Image.FORMAT_R8, _vis_bytes)
 	visibility_texture = ImageTexture.create_from_image(_vis_image)

 	_exp_bytes = PackedByteArray()
 	_exp_bytes.resize(sz)
-	_exp_bytes.fill(0)
+	_exp_bytes.fill(EXP_UNEXPLORED)
 	_exp_image = Image.create_from_data(_width, _height, false, Image.FORMAT_R8, _exp_bytes)
 	exploration_texture = ImageTexture.create_from_image(_exp_image)

@@ -62,21 +73,21 @@ func update_from_state() -> void:
 	var positions: Dictionary = GameState.visible_positions
 	var sectors: Dictionary = GameState.visibility_sectors

-	# TODO(v0.2): gradual decay over game-time instead of immediate 255→128
+	# TODO(v0.2): gradual decay over game-time instead of immediate EXP_VISIBLE→EXP_EXPLORED

 	# 1. Clear visibility, then write current LOS
-	_vis_bytes.fill(0)
+	_vis_bytes.fill(VIS_HIDDEN)
 	for pos in positions:
 		var px: int = pos.x - ox
 		var py: int = pos.y - oy
 		if px < 0 or py < 0 or px >= _width or py >= _height:
 			continue
 		var sector: String = sectors.get(pos, "Forward")
-		_vis_bytes[py * _width + px] = 255 if sector == "Forward" else 180
+		_vis_bytes[py * _width + px] = VIS_FORWARD if sector == "Forward" else VIS_PERIPHERAL
 	_vis_image.set_data(_width, _height, false, Image.FORMAT_R8, _vis_bytes)
 	visibility_texture.update(_vis_image)

-	# 2. Exploration: tiles leaving LOS decay to 128, visible tiles stay 255
+	# 2. Exploration: tiles leaving LOS decay to EXP_EXPLORED, visible tiles stay EXP_VISIBLE
 	#    Only touch tiles that changed (O(visible) not O(map_size))
 	for pos in _prev_visible:
 		if not positions.has(pos):
@@ -84,14 +95,14 @@ func update_from_state() -> void:
 			var py: int = pos.y - oy
 			if px >= 0 and py >= 0 and px < _width and py < _height:
 				var idx: int = py * _width + px
-				if _exp_bytes[idx] > 128:
-					_exp_bytes[idx] = 128
+				if _exp_bytes[idx] > EXP_EXPLORED:
+					_exp_bytes[idx] = EXP_EXPLORED

 	for pos in positions:
 		var px: int = pos.x - ox
 		var py: int = pos.y - oy
 		if px >= 0 and py >= 0 and px < _width and py < _height:
-			_exp_bytes[py * _width + px] = 255
+			_exp_bytes[py * _width + px] = EXP_VISIBLE
 	_exp_image.set_data(_width, _height, false, Image.FORMAT_R8, _exp_bytes)
 	exploration_texture.update(_exp_image)

@@ -0,0 +1 @@
+uid://de816lfn5xeqs
@@ -29,6 +29,31 @@ var current_monologue: Variant = null  # {id, text, duration_seconds} or null
 var player_stance: String = "Walk"  # Sprint/Walk/Careful/Crouch
 var player_inventory: Array = []  # [{item_id, name, slot}]

+# v7 fields (#435, D-061/D-062)
+var current_dialogue: Variant = null  # {npc_name, npc_entity_id, speech, options: [{text, response_id, priority}]} or null
+
+# D-064: true while dialogue box is visible or fading out (300ms).
+# InputMapper suppresses movement when this is true.
+var dialogue_active: bool = false
+
+# v8 fields (#496): Gauntlet mode — room timer + personal bests
+var room_id: Variant = null  # String room_id from snapshot, null in non-gauntlet mode
+var gauntlet_mode: bool = false  # true when snapshot includes gauntlet_mode flag
+
+# OQ-07 (#522): Insert active state — false suppresses verb labels (z-layer 6).
+# Cursor shape changes still fire when false (D-056 option a).
+# v0.1 assumption: always true — both playable characters (detective and smuggler)
+# have neural inserts. Future characters without inserts would receive false from
+# the server's "insert_active" snapshot field, disabling all z-layer-6 UI.
+var insert_active: bool = true
+
+# #507: RNG seed for replay determinism — populated from snapshot "rng_seed" field.
+# Null in v0.1 (server does not yet send this field; protocol change required).
+var rng_seed: Variant = null
+
+# v7 fields (#431, D-059/D-060)
+var pending_recognitions: Array = []  # [{entity_id, x, y, z, remaining_ticks, total_delay_ticks}]
+
 func apply_snapshot(snapshot: Dictionary) -> void:
 	current_snapshot = snapshot

@@ -96,6 +121,42 @@ func apply_snapshot(snapshot: Dictionary) -> void:
 	else:
 		player_inventory = []

+	# v7: current_dialogue (#434, D-061)
+	if snapshot.has("current_dialogue") and snapshot.current_dialogue is Dictionary:
+		current_dialogue = snapshot.current_dialogue
+	else:
+		current_dialogue = null
+
+	# v7: pending_recognitions (#431, D-059/D-060)
+	if snapshot.has("pending_recognitions") and snapshot.pending_recognitions is Array:
+		pending_recognitions = snapshot.pending_recognitions
+	else:
+		pending_recognitions = []
+
+	# v8: gauntlet mode (#496) — room_id and gauntlet_mode
+	if snapshot.has("gauntlet_mode") and snapshot.gauntlet_mode == true:
+		gauntlet_mode = true
+	else:
+		gauntlet_mode = false
+	if snapshot.has("room_id") and snapshot.room_id is String:
+		room_id = snapshot.room_id
+	else:
+		room_id = null
+
+	# OQ-07 (#522): insert_active — defaults true (v0.1 always has insert).
+	# Server may send false for characters without an insert in future sprints.
+	if snapshot.has("insert_active") and snapshot.insert_active is bool:
+		insert_active = snapshot.insert_active
+	else:
+		insert_active = true
+
+	# #507: rng_seed — server sends current RNG seed for replay determinism.
+	# Field: "rng_seed" (u64 as integer). Null if server does not include it.
+	if snapshot.has("rng_seed"):
+		rng_seed = snapshot.rng_seed
+	else:
+		rng_seed = null
+
 	# v2: visible_tiles with visibility sectors
 	# Derives visible_positions when not explicitly provided (real server mode)
 	if snapshot.has("visible_tiles") and snapshot.visible_tiles is Array and snapshot.visible_tiles.size() > 0:
@@ -1,60 +1,218 @@
 extends Node

 # Semantic actions — NO raw key codes cross the bridge
-# Diagonal directions registered in project.godot with empty event arrays (intentional).
-# Keybindings deferred until input design is finalized — likely numpad or composite WASD.
+# Movement uses hold-to-move (polled each frame in _process).
+# Discrete actions (interact, stance, etc.) use press events (_unhandled_input).
+#
+# D-054: Mouse-relative facing and movement.
+# Mouse position determines facing direction (client-side float).
+# WASD is relative to facing: W = toward cursor, S = away, A/D = strafe.
+# Server receives facing octant only — the full float stays client-side.
+#
+# Movement throttle: client-side rate limit per stance (D-053).
+# Sprint=5/s, Walk=2.5/s, Careful=1.7/s, Crouch=1.25/s.
+# Server cooldown is authoritative, but the client throttle prevents
+# flooding and gives correct movement feel in test mode.
 enum Action {
 	MOVE_NORTH, MOVE_NORTHEAST, MOVE_EAST, MOVE_SOUTHEAST,
 	MOVE_SOUTH, MOVE_SOUTHWEST, MOVE_WEST, MOVE_NORTHWEST,
-	INTERACT, USE_PERCEPTION_MODE, OPEN_MENU, PAUSE,
+	INTERACT, USE_PERCEPTION_MODE, OPEN_MENU, PAUSE, UNPAUSE,
 	TOGGLE_STANCE_UP, TOGGLE_STANCE_DOWN,
+	BUG_REPORT,  # #495: F12 WRONG button — client-only, not sent to server
+	SET_FACING,  # D-054: facing octant update (no movement)
+	TELEPORT_HUB,  # #501: Home key — Gauntlet dev teleport (not production fast-travel)
 }

 var input_queue: Array[Dictionary] = []

+# D-054: Client-side facing angle (radians). 0=East, -PI/2=North, PI/2=South.
+# Updated every frame from mouse position. EntityRenderer reads this for indicator.
+var facing_angle: float = -PI / 2.0  # Default: North
+var facing_octant: String = "North"   # Derived from facing_angle
+var _last_sent_octant: String = "North"  # Track to avoid redundant sends
+
+# Minimum milliseconds between movement commands, per stance.
+# Tuned so Walk feels like walking, Sprint feels fast but readable.
+const MOVE_INTERVAL_MS := {
+	"Sprint": 200,    # 5/sec — fast but trackable
+	"Walk": 400,      # 2.5/sec — comfortable walking pace
+	"Careful": 600,   # ~1.7/sec — deliberate, scanning
+	"Crouch": 800,    # 1.25/sec — creeping
+}
+var _last_move_msec: int = 0
+
+
+# Hold-to-move: poll held direction keys each frame, throttled by stance.
+# D-054: WASD is now mouse-relative. W = toward cursor, A/D = strafe.
+# Server-side cooldown (D-053) is authoritative; this prevents client flooding.
+# D-064: movement suppressed during dialogue (walk-away handled by dialogue_box).
+func _process(_delta: float) -> void:
+	# D-054: Update facing angle from mouse position every frame
+	_update_facing_from_mouse()
+
+	if GameState.dialogue_active:
+		return
+
+	# D-054: Send facing octant to server when it changes (even without movement)
+	if facing_octant != _last_sent_octant:
+		_last_sent_octant = facing_octant
+		input_queue.append({
+			"action": Action.SET_FACING,
+			"timestamp_msec": Time.get_ticks_msec(),
+			"action_data": {"facing": facing_octant},
+		})
+
+	# Poll held WASD keys
+	var raw_dir := Vector2i.ZERO
+	if Input.is_action_pressed("move_north"):
+		raw_dir.y -= 1
+	if Input.is_action_pressed("move_south"):
+		raw_dir.y += 1
+	if Input.is_action_pressed("move_east"):
+		raw_dir.x += 1
+	if Input.is_action_pressed("move_west"):
+		raw_dir.x -= 1
+
+	if raw_dir != Vector2i.ZERO:
+		var now := Time.get_ticks_msec()
+		var interval: int = MOVE_INTERVAL_MS.get(GameState.player_stance, 200)
+		if now - _last_move_msec >= interval:
+			_last_move_msec = now
+			# D-054: Transform WASD input relative to mouse facing
+			var world_dir := _wasd_to_world_dir(raw_dir)
+			var action: Action = _dir_to_action(world_dir)
+			input_queue.append({
+				"action": action,
+				"timestamp_msec": now,
+			})
+
+
+# Discrete actions: fire once on key press (not held).
 func _unhandled_input(event: InputEvent) -> void:
 	var action: Action = -1

-	# Map input actions to semantic Action enum
-	# is_action_pressed handles press detection for all input types (key, gamepad, etc.)
-	if event.is_action_pressed("move_north"):
-		action = Action.MOVE_NORTH
-	elif event.is_action_pressed("move_northeast"):
-		action = Action.MOVE_NORTHEAST
-	elif event.is_action_pressed("move_east"):
-		action = Action.MOVE_EAST
-	elif event.is_action_pressed("move_southeast"):
-		action = Action.MOVE_SOUTHEAST
-	elif event.is_action_pressed("move_south"):
-		action = Action.MOVE_SOUTH
-	elif event.is_action_pressed("move_southwest"):
-		action = Action.MOVE_SOUTHWEST
-	elif event.is_action_pressed("move_west"):
-		action = Action.MOVE_WEST
-	elif event.is_action_pressed("move_northwest"):
-		action = Action.MOVE_NORTHWEST
-	elif event.is_action_pressed("interact"):
+	if event.is_action_pressed("interact"):
 		action = Action.INTERACT
 	elif event.is_action_pressed("perception_mode"):
 		action = Action.USE_PERCEPTION_MODE
 	elif event.is_action_pressed("open_menu"):
 		action = Action.OPEN_MENU
 	elif event.is_action_pressed("pause"):
-		action = Action.PAUSE
+		var tick_rate = GameState.game_time.get("tick_rate", "Full")
+		action = Action.UNPAUSE if tick_rate == "Paused" else Action.PAUSE
 	elif event.is_action_pressed("stance_up"):
 		action = Action.TOGGLE_STANCE_UP
 	elif event.is_action_pressed("stance_down"):
 		action = Action.TOGGLE_STANCE_DOWN
+	elif event.is_action_pressed("bug_report"):
+		action = Action.BUG_REPORT
+	elif event.is_action_pressed("teleport_hub"):
+		if GameState.gauntlet_mode:
+			action = Action.TELEPORT_HUB

-	# Queue the action if valid
 	if action != -1:
 		input_queue.append({
 			"action": action,
-			"timestamp_msec": Time.get_ticks_msec()
+			"timestamp_msec": Time.get_ticks_msec(),
 		})
 		get_viewport().set_input_as_handled()

+
 func flush_queue() -> Array[Dictionary]:
 	var queue = input_queue.duplicate()
 	input_queue.clear()
 	return queue
+
+
+## Reset facing state to default (North). Use in tests per D-030 testability.
+func reset_facing_state() -> void:
+	facing_angle = -PI / 2.0
+	facing_octant = "North"
+	_last_sent_octant = "North"
+
+
+# D-054: Compute facing angle from mouse position relative to player screen position.
+# Uses viewport canvas transform to convert world coords to screen coords.
+# Intentional coupling: reads GameState.player_position directly — InputMapper is an
+# autoload that runs before game loop rendering, so position is always current-tick.
+func _update_facing_from_mouse() -> void:
+	var vp := get_viewport()
+	if vp == null:
+		return
+	var canvas_xf := vp.get_canvas_transform()
+	var player_world_px := GameState.player_position * Constants.TILE_SIZE
+	var player_screen := canvas_xf * player_world_px
+	var mouse_screen := vp.get_mouse_position()
+	var delta := mouse_screen - player_screen
+	# Only update if mouse is meaningfully distant from player (avoid jitter at center)
+	if delta.length_squared() > 4.0:
+		facing_angle = delta.angle()
+		facing_octant = _angle_to_octant(facing_angle)
+
+
+# D-054: Transform raw WASD input (screen-space) to world direction relative to mouse facing.
+# W (+Y up in input, mapped to forward), S (backward), A (strafe left), D (strafe right).
+# Raw input: W=(-Y), S=(+Y), A=(-X), D=(+X) in screen coords.
+# Forward = facing_angle direction. Output: nearest octant direction vector.
+func _wasd_to_world_dir(raw_dir: Vector2i) -> Vector2i:
+	# Build a continuous direction vector relative to facing.
+	# raw_dir.y: -1 = W (forward), +1 = S (backward)
+	# raw_dir.x: -1 = A (strafe left), +1 = D (strafe right)
+	var forward := Vector2(cos(facing_angle), sin(facing_angle))
+	var right := Vector2(-forward.y, forward.x)  # 90° clockwise
+
+	# Combine: forward/back from W/S, strafe from A/D
+	var world_float := forward * float(-raw_dir.y) + right * float(raw_dir.x)
+
+	# Snap to nearest octant direction
+	return _snap_to_octant_dir(world_float)
+
+
+# Snap a floating-point direction vector to the nearest of 8 cardinal/diagonal directions.
+static func _snap_to_octant_dir(dir: Vector2) -> Vector2i:
+	if dir.length_squared() < 0.001:
+		return Vector2i.ZERO
+	var angle := dir.angle()
+	# Quantize to nearest 45° (PI/4)
+	var octant := roundi(angle / (PI / 4.0))
+	match octant:
+		0: return Vector2i(1, 0)        # East
+		1: return Vector2i(1, 1)        # Southeast
+		2, -6: return Vector2i(0, 1)    # South
+		3, -5: return Vector2i(-1, 1)   # Southwest
+		4, -4: return Vector2i(-1, 0)   # West
+		-3, 5: return Vector2i(-1, -1)  # Northwest
+		-2: return Vector2i(0, -1)      # North
+		-1: return Vector2i(1, -1)      # Northeast
+		_: return Vector2i.ZERO
+
+
+# D-054: Convert a facing angle (radians) to the nearest octant name.
+# Godot 2D: 0=East, PI/2=South, -PI/2=North.
+static func _angle_to_octant(angle: float) -> String:
+	var octant := roundi(angle / (PI / 4.0))
+	match octant:
+		0: return "East"
+		1: return "Southeast"
+		2, -6: return "South"
+		3, -5: return "Southwest"
+		4, -4: return "West"
+		-3, 5: return "Northwest"
+		-2: return "North"
+		-1: return "Northeast"
+		_: return "East"
+
+
+# Map a direction vector to the corresponding movement Action.
+# Handles all 8 directions via composite W+D, W+A, etc.
+static func _dir_to_action(dir: Vector2i) -> Action:
+	match dir:
+		Vector2i(0, -1): return Action.MOVE_NORTH
+		Vector2i(1, -1): return Action.MOVE_NORTHEAST
+		Vector2i(1, 0): return Action.MOVE_EAST
+		Vector2i(1, 1): return Action.MOVE_SOUTHEAST
+		Vector2i(0, 1): return Action.MOVE_SOUTH
+		Vector2i(-1, 1): return Action.MOVE_SOUTHWEST
+		Vector2i(-1, 0): return Action.MOVE_WEST
+		Vector2i(-1, -1): return Action.MOVE_NORTHWEST
+		_: return Action.MOVE_NORTH
@@ -9,6 +9,9 @@ var _test_tick: int = 0
 var _test_player_pos: Vector2i = Vector2i(10, 10)
 var _test_facing: String = "North"
 var _test_input_queue: Array = []  # Queued actions for test mode
+var _test_in_dialogue: bool = false  # Mock dialogue state (#434)
+var _test_gauntlet_mode: bool = false  # #501: Gauntlet mode for dev teleport guard
+var _test_npc_relationship: String = "Unknown"  # #521: NPC relationship for D-033 color
 var _last_snapshot: Variant = null  # Most recent decoded snapshot (consumed by poll_snapshot)
 var _outbound_buffer: Array[Dictionary] = []  # Raw inputs awaiting batch encode + transport

@@ -38,6 +41,9 @@ func reset_test_state() -> void:
 	_test_player_pos = Vector2i(10, 10)
 	_test_facing = "North"
 	_test_input_queue.clear()
+	_test_in_dialogue = false
+	_test_gauntlet_mode = false
+	_test_npc_relationship = "Unknown"

 # Change connection state and emit signal
 func _set_state(new_state: ConnectionState) -> void:
@@ -173,13 +179,22 @@ func send_input(player_input: Dictionary) -> Error:
 		return ERR_CONNECTION_ERROR
 	if test_mode:
 		var action: int = player_input.get("action", -1)
-		var wire_name: String = _action_enum_to_wire(action)
+		var wire_name: String = action_enum_to_wire(action)
 		if not wire_name.is_empty():
-			_test_input_queue.append(wire_name)
+			if wire_name == "SetFacing":
+				# D-054: Use action_data.facing from the input dict, not InputMapper global
+				var facing: String = ""
+				var action_data: Variant = player_input.get("action_data")
+				if action_data is Dictionary:
+					facing = str(action_data.get("facing", ""))
+				if not facing.is_empty():
+					_test_facing = facing
+			else:
+				_test_input_queue.append(wire_name)
 		return OK
-	var action_name := _action_enum_to_wire(player_input.get("action", -1))
+	var action_name := action_enum_to_wire(player_input.get("action", -1))
 	if action_name.is_empty():
-		# _action_enum_to_wire already emits push_warning for invalid actions
+		# action_enum_to_wire already emits push_warning for invalid actions
 		return ERR_INVALID_PARAMETER
 	# Use the server's current tick so drain_for_tick processes this input immediately.
 	# The client-side timestamp_msec is only useful for ordering within a frame.
@@ -212,14 +227,21 @@ func poll_snapshot() -> Variant:
 	return null

 # Called by transport layer when raw bytes arrive from the server.
-# Latest-wins semantics: newer snapshots replace unconsumed ones. This is correct
-# for real-time rendering (stale frames are worthless). Upgrade to queue if needed.
+# Latest-wins for positional state (stale frames are worthless), but one-shot
+# events (monologue, dialogue) are carried forward from overwritten snapshots
+# so they aren't silently dropped when server ticks faster than client consumes.
 func receive_bytes(bytes: PackedByteArray) -> void:
 	var snapshot = Protocol.decode_snapshot(bytes)
-	if snapshot != null:
-		if _last_snapshot != null:
-			push_warning("SimBridge: overwriting unconsumed snapshot (tick %s replaced by %s)" % [_last_snapshot.tick, snapshot.tick])
-		_last_snapshot = snapshot
+	if snapshot == null:
+		push_warning("SimBridge: decode_snapshot returned null for %d bytes" % bytes.size())
+		return
+	if _last_snapshot != null:
+		# Carry forward one-shot events the client hasn't consumed yet.
+		if snapshot.get("current_monologue") == null and _last_snapshot.get("current_monologue") != null:
+			snapshot["current_monologue"] = _last_snapshot["current_monologue"]
+		if snapshot.get("current_dialogue") == null and _last_snapshot.get("current_dialogue") != null:
+			snapshot["current_dialogue"] = _last_snapshot["current_dialogue"]
+	_last_snapshot = snapshot

 # Drain the outbound buffer. Returns raw input entries for batch encoding.
 func drain_outbound() -> Array[Dictionary]:
@@ -229,7 +251,7 @@ func drain_outbound() -> Array[Dictionary]:

 # Map InputMapper.Action enum values to wire-format action names (matching Rust PlayerAction).
 # OPEN_MENU is client-only — no Rust equivalent, not sent over the wire.
-static func _action_enum_to_wire(action: int) -> String:
+static func action_enum_to_wire(action: int) -> String:
 	match action:
 		InputMapper.Action.MOVE_NORTH: return "MoveNorth"
 		InputMapper.Action.MOVE_NORTHEAST: return "MoveNortheast"
@@ -242,12 +264,17 @@ static func _action_enum_to_wire(action: int) -> String:
 		InputMapper.Action.INTERACT: return "Interact"
 		InputMapper.Action.USE_PERCEPTION_MODE: return "UsePerceptionMode"
 		InputMapper.Action.PAUSE: return "Pause"
+		InputMapper.Action.UNPAUSE: return "Unpause"
 		InputMapper.Action.TOGGLE_STANCE_UP: return "ToggleStanceUp"
 		InputMapper.Action.TOGGLE_STANCE_DOWN: return "ToggleStanceDown"
 		InputMapper.Action.OPEN_MENU:
-			# Client-only action, not part of wire protocol
-			push_warning("SimBridge: OPEN_MENU is client-only, not sent to server")
-			return ""
+			return ""  # Client-only action, not part of wire protocol
+		InputMapper.Action.BUG_REPORT:
+			return ""  # Client-only action (#495), not part of wire protocol
+		InputMapper.Action.SET_FACING:
+			return "SetFacing"  # D-054: facing octant update (no movement)
+		InputMapper.Action.TELEPORT_HUB:
+			return "TeleportToHub"  # #501: Gauntlet dev teleport (not production fast-travel)
 		_:
 			push_warning("SimBridge: unknown action enum %s" % action)
 			return ""
@@ -263,12 +290,26 @@ func _test_snapshot() -> Dictionary:

 	# Process queued inputs
 	for action_name in _test_input_queue:
+		if action_name == "TeleportToHub":
+			# #501: Reset to hub spawn position, clear dialogue
+			_test_player_pos = Vector2i(10, 10)
+			_test_in_dialogue = false
+			continue
+		if action_name == "Interact":
+			# Mock dialogue trigger (#434): if near NPC, start dialogue
+			var npc_pos := Vector2i(12, 9)
+			var dist := absi(_test_player_pos.x - npc_pos.x) + absi(_test_player_pos.y - npc_pos.y)
+			if dist <= 2 and _test_has_los(_test_player_pos, npc_pos):
+				_test_in_dialogue = true
+			continue
 		var delta := _action_to_delta(action_name)
 		var new_pos := _test_player_pos + delta
 		if _test_is_walkable(new_pos):
 			_test_player_pos = new_pos
 			if delta != Vector2i.ZERO:
-				_test_facing = _delta_to_facing(delta)
+				# Walk-away dismisses dialogue (D-064)
+				if _test_in_dialogue:
+					_test_in_dialogue = false
 	_test_input_queue.clear()

 	var px := _test_player_pos.x
@@ -296,6 +337,7 @@ func _test_snapshot() -> Dictionary:
 			"z": 0,
 			"kind": { "variant": "Npc", "data": null },
 			"visibility": sector,
+			"relationship": _test_npc_relationship,
 		})

 	# v4: nearby_interactions when NPC is nearby and visible (#404/#405)
@@ -320,6 +362,40 @@ func _test_snapshot() -> Dictionary:
 			"duration_seconds": 5.0,
 		}

+	# v7: mock dialogue (#435, D-061/D-062) — triggered by Interact near NPC
+	# Sustained: dialogue persists across ticks while _test_in_dialogue is true.
+	# Movement (walk-away) clears it. Client consume-once guards against re-show.
+	# Options: structured {text, response_id, priority} per #435.
+	var dialogue: Variant = null
+	if _test_in_dialogue:
+		dialogue = {
+			"npc_name": "Kael",
+			"npc_entity_id": 2,
+			"speech": "Haven't seen you around the transit hub before. You new to Sova, or just passing through?",
+			"options": [
+				{"text": "Just arrived. Still getting my bearings.", "response_id": "kael_greet_01", "priority": 1, "confrontation": false},
+				{"text": "Passing through. Know where I can find work?", "response_id": "kael_greet_02", "priority": 2, "confrontation": false},
+				{"text": "I saw you near the cargo bay last night.", "response_id": "kael_confront_01", "priority": 3, "confrontation": true},
+			],
+		}
+
+	# v7: mock pending_recognitions (#431, D-059/D-060) — cognitive delay fog entity
+	# Entity at (13, 12) in fog: starts as grey blob, transitions to recognized over 6 ticks.
+	# Cycles every 12 ticks: 6 ticks recognizing, 6 ticks off (simulates repeat encounters).
+	var pending_recs: Array = []
+	var cycle_pos := _test_tick % 12
+	if cycle_pos < 6:
+		var total_delay := 6
+		var remaining := total_delay - cycle_pos
+		pending_recs.append({
+			"entity_id": 100,
+			"x": 13.5,
+			"y": 12.5,
+			"z": 0,
+			"remaining_ticks": remaining,
+			"total_delay_ticks": total_delay,
+		})
+
 	return {
 		"tick": _test_tick,
 		"version": Protocol.PROTOCOL_VERSION,
@@ -338,6 +414,9 @@ func _test_snapshot() -> Dictionary:
 		"visible_positions": _test_visible_positions(),
 		"nearby_interactions": nearby,
 		"current_monologue": monologue,
+		"current_dialogue": dialogue,
+		"pending_recognitions": pending_recs,
+		"gauntlet_mode": _test_gauntlet_mode,
 	}

 # Generate a small test room: 8x6 room with walls, a door, and floor
@@ -0,0 +1,354 @@
+extends RefCounted
+
+## #503: Auto-checklist progress tracking — evaluates ObserverSnapshot against
+## checklist YAML conditions and latches satisfied conditions.
+##
+## Usage:
+##   var evaluator := ChecklistEvaluator.new()
+##   evaluator.load_room("inventory_warehouse")
+##   evaluator.evaluate()  # call each tick
+##   var results := evaluator.get_results()
+##
+## Condition types (per checklist.schema.json):
+##   player_near, player_facing, entity_present, entity_absent,
+##   expected_monologue, expected_dialogue, expected_interaction_verb
+##
+## Spec ref: D-030 (testability), checklist.schema.json (#497).
+
+var _room_conditions: Array = []       # Conditions from per-room checklist
+var _cross_conditions: Array = []      # Conditions from cross_room_checks.yaml
+var _latched: Dictionary = {}          # condition_id -> true (once met, stays met)
+var _current_room_id: String = ""
+var _content_base: String = ""         # Absolute path to content/ directory
+var _loaded: bool = false
+
+
+func _init() -> void:
+	# Content directory lives at repo root (content/), one level above the Godot
+	# project (client/). In editor/dev mode we resolve via the project path.
+	# In exported builds, content is expected at res://content/ (copied by export
+	# preset) — the globalize fallback won't exist, so check res:// first.
+	if DirAccess.dir_exists_absolute("res://content"):
+		_content_base = ProjectSettings.globalize_path("res://content")
+	else:
+		var project_path := ProjectSettings.globalize_path("res://")
+		_content_base = project_path.path_join("../content")
+
+
+## Load checklist for a room. Clears per-room latches; cross-room latches persist.
+func load_room(room_id: String) -> void:
+	if room_id == _current_room_id and _loaded:
+		return
+
+	_current_room_id = room_id
+	_room_conditions.clear()
+
+	# Clear per-room latches (keep cross-room latches)
+	var cross_ids := {}
+	for cond in _cross_conditions:
+		cross_ids[cond.get("id", "")] = true
+	var kept := {}
+	for cid in _latched:
+		if cross_ids.has(cid):
+			kept[cid] = true
+	_latched = kept
+
+	# Load per-room checklist
+	var room_path := _content_base.path_join(
+		"gauntlet/rooms/%s/checklist.yaml" % room_id)
+	var room_data := _load_checklist_file(room_path)
+	if room_data.has("conditions"):
+		_room_conditions = room_data["conditions"]
+		_warn_empty_ids(_room_conditions, room_path)
+
+	# Load cross-room checks (only on first load)
+	if _cross_conditions.is_empty():
+		var cross_path := _content_base.path_join("gauntlet/cross_room_checks.yaml")
+		var cross_data := _load_checklist_file(cross_path)
+		if cross_data.has("conditions"):
+			_cross_conditions = cross_data["conditions"]
+			_warn_empty_ids(_cross_conditions, cross_path)
+
+	_loaded = true
+
+
+## Evaluate all conditions against current GameState. Latches newly met conditions.
+func evaluate() -> void:
+	for cond in _room_conditions + _cross_conditions:
+		var cid: String = cond.get("id", "")
+		if cid.is_empty() or _latched.has(cid):
+			continue
+		if _evaluate_condition(cond):
+			_latched[cid] = true
+
+
+## Returns array of {id, description, met} for all loaded conditions.
+## Conditions with empty id are excluded (invalid, cannot be latched).
+func get_results() -> Array:
+	var results: Array = []
+	for cond in _room_conditions + _cross_conditions:
+		var cid: String = cond.get("id", "")
+		if cid.is_empty():
+			continue
+		results.append({
+			"id": cid,
+			"description": cond.get("description", ""),
+			"condition_type": cond.get("condition_type", ""),
+			"met": _latched.has(cid),
+		})
+	return results
+
+
+## Total number of loaded conditions (excludes conditions with empty id).
+func get_total_count() -> int:
+	var count: int = 0
+	for cond in _room_conditions + _cross_conditions:
+		if not cond.get("id", "").is_empty():
+			count += 1
+	return count
+
+
+## Number of latched (met) conditions.
+func get_met_count() -> int:
+	return _latched.size()
+
+
+## Whether all conditions are met.
+func is_complete() -> bool:
+	return get_met_count() >= get_total_count() and get_total_count() > 0
+
+
+## Whether any checklist is loaded.
+func is_loaded() -> bool:
+	return _loaded
+
+
+## Reset all state (room change to null, or disconnect).
+func reset() -> void:
+	_room_conditions.clear()
+	_cross_conditions.clear()
+	_latched.clear()
+	_current_room_id = ""
+	_loaded = false
+
+
+static func _warn_empty_ids(conditions: Array, path: String) -> void:
+	for i in conditions.size():
+		if conditions[i].get("id", "").is_empty():
+			push_warning("ChecklistEvaluator: condition at index %d in %s has empty id — will be excluded from results" % [i, path])
+
+
+# -- Condition evaluation ------------------------------------------------------
+
+func _evaluate_condition(cond: Dictionary) -> bool:
+	match cond.get("condition_type", ""):
+		"player_near":
+			return _eval_player_near(cond)
+		"player_facing":
+			return _eval_player_facing(cond)
+		"entity_present":
+			return _eval_entity_present(cond)
+		"entity_absent":
+			return _eval_entity_absent(cond)
+		"expected_monologue":
+			return _eval_expected_monologue(cond)
+		"expected_dialogue":
+			return _eval_expected_dialogue(cond)
+		"expected_interaction_verb":
+			return _eval_expected_interaction_verb(cond)
+	push_warning("ChecklistEvaluator: unknown condition_type '%s'" % cond.get("condition_type", ""))
+	return false
+
+
+## x/y and radius are in tile coordinates (matching GameState.player_position),
+## not pixels. D-066 dual-scale: YAML authors write tile coords, pixel conversion
+## happens only at render time.
+func _eval_player_near(cond: Dictionary) -> bool:
+	var tx: float = float(cond.get("x", 0))
+	var ty: float = float(cond.get("y", 0))
+	var radius: float = float(cond.get("radius", 0.0))
+	var target := Vector2(tx, ty)
+	return GameState.player_position.distance_to(target) <= radius
+
+
+func _eval_player_facing(cond: Dictionary) -> bool:
+	var direction: String = str(cond.get("direction", ""))
+	# Schema uses 4-cardinal (North/South/East/West).
+	# GameState uses 8-directional. Exact match only.
+	return GameState.player_facing == direction
+
+
+func _eval_entity_present(cond: Dictionary) -> bool:
+	var entity_id: int = int(cond.get("entity_id", -1))
+	return _find_entity(entity_id)
+
+
+func _eval_entity_absent(cond: Dictionary) -> bool:
+	var entity_id: int = int(cond.get("entity_id", -1))
+	return not _find_entity(entity_id)
+
+
+func _eval_expected_monologue(cond: Dictionary) -> bool:
+	var contains: String = str(cond.get("contains", ""))
+	if GameState.current_monologue == null:
+		return false
+	var text: String = str(GameState.current_monologue.get("text", ""))
+	return text.find(contains) >= 0
+
+
+func _eval_expected_dialogue(cond: Dictionary) -> bool:
+	var contains: String = str(cond.get("contains", ""))
+	if GameState.current_dialogue == null:
+		return false
+	var text: String = str(GameState.current_dialogue.get("speech", ""))
+	return text.find(contains) >= 0
+
+
+func _eval_expected_interaction_verb(cond: Dictionary) -> bool:
+	var entity_id: int = int(cond.get("entity_id", -1))
+	var verb: String = str(cond.get("verb", ""))
+	for interaction in GameState.nearby_interactions:
+		if not interaction is Dictionary:
+			continue
+		if int(interaction.get("entity_id", -1)) != entity_id:
+			continue
+		var verbs: Array = interaction.get("verbs", [])
+		for v in verbs:
+			if not v is Dictionary:
+				continue
+			if str(v.get("label", "")) == verb or str(v.get("kind", "")) == verb:
+				if v.get("available", true):
+					return true
+	return false
+
+
+# -- Helpers -------------------------------------------------------------------
+
+func _find_entity(entity_id: int) -> bool:
+	for entity in GameState.visible_entities:
+		if not entity is Dictionary:
+			continue
+		if int(entity.get("entity_id", -1)) == entity_id:
+			return true
+	return false
+
+
+# -- YAML parsing (checklist-specific) -----------------------------------------
+# Handles the constrained checklist YAML format: top-level key:value pairs,
+# a conditions array of flat dictionaries. No nested arrays or anchors.
+#
+# Limitation: unquoted values containing " #" are truncated at the comment marker.
+# Use quoted strings ("value # with hash") if values must contain literal hashes.
+
+func _load_checklist_file(path: String) -> Dictionary:
+	if not FileAccess.file_exists(path):
+		return {}
+	var file := FileAccess.open(path, FileAccess.READ)
+	if file == null:
+		push_warning("ChecklistEvaluator: cannot open %s" % path)
+		return {}
+	var text := file.get_as_text()
+	file.close()
+	return parse_checklist_yaml(text)
+
+
+static func parse_checklist_yaml(text: String) -> Dictionary:
+	var result := {}
+	var conditions: Array = []
+	var current_item: Dictionary = {}
+	var in_conditions := false
+
+	for line in text.split("\n"):
+		var stripped := line.strip_edges(false, true)
+		if stripped.is_empty() or stripped.strip_edges().begins_with("#"):
+			continue
+
+		var indent := line.length() - line.lstrip(" ").length()
+		var content := stripped.strip_edges()
+
+		# Detect conditions: array header
+		if content == "conditions:":
+			in_conditions = true
+			continue
+
+		if not in_conditions:
+			# Top-level key: value
+			var colon := content.find(":")
+			if colon >= 0:
+				var key := content.substr(0, colon).strip_edges()
+				var val_str := content.substr(colon + 1).strip_edges()
+				result[key] = _parse_value(val_str)
+		else:
+			if content.begins_with("- "):
+				# New array item — flush previous
+				if not current_item.is_empty():
+					conditions.append(current_item)
+				current_item = {}
+				var rest := content.substr(2).strip_edges()
+				var colon := rest.find(":")
+				if colon >= 0:
+					var key := rest.substr(0, colon).strip_edges()
+					var val_str := rest.substr(colon + 1).strip_edges()
+					current_item[key] = _parse_value(val_str)
+			elif indent >= 2 and not current_item.is_empty():
+				# Continuation of current array item
+				var colon := content.find(":")
+				if colon >= 0:
+					var key := content.substr(0, colon).strip_edges()
+					var val_str := content.substr(colon + 1).strip_edges()
+					current_item[key] = _parse_value(val_str)
+			elif indent == 0:
+				# Back to top level — shouldn't happen in valid checklist YAML
+				in_conditions = false
+				if not current_item.is_empty():
+					conditions.append(current_item)
+					current_item = {}
+				var colon := content.find(":")
+				if colon >= 0:
+					var key := content.substr(0, colon).strip_edges()
+					var val_str := content.substr(colon + 1).strip_edges()
+					result[key] = _parse_value(val_str)
+
+	# Flush last item
+	if not current_item.is_empty():
+		conditions.append(current_item)
+
+	if not conditions.is_empty():
+		result["conditions"] = conditions
+
+	return result
+
+
+static func _parse_value(val: String) -> Variant:
+	if val.is_empty():
+		return ""
+
+	# Strip inline comments (not inside quotes)
+	if not val.begins_with("\""):
+		var comment_pos := val.find(" #")
+		if comment_pos >= 0:
+			val = val.substr(0, comment_pos).strip_edges()
+
+	# Quoted string
+	if val.begins_with("\""):
+		var end_quote := val.find("\"", 1)
+		if end_quote > 0:
+			return val.substr(1, end_quote - 1)
+		return val.substr(1)
+
+	# Boolean
+	if val == "true":
+		return true
+	if val == "false":
+		return false
+
+	# Float (contains decimal point)
+	if val.contains(".") and val.is_valid_float():
+		return val.to_float()
+
+	# Integer
+	if val.is_valid_int():
+		return val.to_int()
+
+	# Plain string
+	return val
@@ -26,6 +26,7 @@ const Z_HIGH_AIRBORNE: int = 350    # Above-ceiling flying (scale 1.03-1.30, alp
 const Z_UPPER_CONTENT: int = 400    # Upper-floor entities (rare with fixed camera)
 # z:500-899 reserved: edge cases
 const Z_FOG: int = 900              # FogOverlay — OUTSIDE FogGroup, fog shader
+const Z_FOG_ENTITIES: int = 950     # FogEntities — cognitive delay blobs/pings (D-059/D-060)
 # Lower floors: z:-100 per floor (floor-1: z:-100 to z:-1, floor-2: z:-200 to z:-101)
 # z:-75 to z:-51 reserved: lower floor VFX
 #
@@ -58,18 +59,40 @@ const ENTITY_COLOR_HOSTILE: Color = Color("#d45d5d")    # Hostile/Dangerous —
 const ENTITY_COLOR_OBJECT: Color = Color("#8b8ba0")    # Static objects — muted grey
 const ENTITY_COLOR_PLAYER: Color = Color("#e0e8ff")    # Player character (detective)

-# D-033 color lookup by entity kind (Phase 1: defaults, Phase 2 #361: relationship-based)
+# D-033 color lookup by relationship string (#521)
+static func color_for_relationship(relationship: String) -> Color:
+	match relationship:
+		"Friendly": return ENTITY_COLOR_FRIENDLY
+		"PersonOfInterest": return ENTITY_COLOR_POI
+		"Hostile": return ENTITY_COLOR_HOSTILE
+		"Unknown": return ENTITY_COLOR_UNKNOWN
+		_: return ENTITY_COLOR_UNKNOWN
+
+# D-033 color lookup by entity data — uses relationship for NPCs (#521)
 static func color_for_entity_kind(entity_data: Dictionary) -> Color:
 	var kind_variant: String = entity_data.get("kind", {}).get("variant", "")
 	match kind_variant:
 		"Player": return ENTITY_COLOR_PLAYER
-		"Npc": return ENTITY_COLOR_UNKNOWN
 		"Object", "Terrain": return ENTITY_COLOR_OBJECT
+		"Npc": return color_for_relationship(entity_data.get("relationship", "Unknown"))
 		_: return ENTITY_COLOR_OBJECT

+# D-048/D-056: Insert-styled UI color palette
+# Used by dialogue box, interaction list, radial menu, and other diegetic insert UI.
+const INSERT_COLOR_TEXT: Color = Color("#c8d0e0")       # Default insert text — white-blue
+const INSERT_COLOR_HOVER: Color = Color("#e8c547")      # Hover/highlight — amber POI
+const INSERT_COLOR_ACTIVE: Color = Color("#6bc9a6")     # Active/pressed — friendly green
+
 # D-015: Peripheral vision dimming
 const PERIPHERAL_ALPHA: float = 0.5

 # Facing direction indicator
 const FACING_INDICATOR_SIZE: float = 6.0
 const FACING_INDICATOR_OFFSET: float = 14.0
+
+# #517: Implant UI font color grading — avoid pure white, project through a lens
+const IMPLANT_TEXT_COLOR: Color = Color("#E0F7FA")   # Cyan-white — primary text
+const IMPLANT_TEXT_DIM: Color = Color("#9EBFC4")     # Dimmed variant — secondary text
+const IMPLANT_PULSE_MIN: float = 0.85               # Alpha pulse floor
+const IMPLANT_PULSE_MAX: float = 1.0                # Alpha pulse ceiling
+const IMPLANT_PULSE_PERIOD: float = 2.5             # Seconds per pulse cycle
@@ -1,35 +1,105 @@
 extends Node2D

@onready var world_renderer = $World
+@onready var fog_entities = $World/FogEntities  # D-059/D-060: cognitive delay fog visualization
@onready var camera = $Camera2D
@onready var hud = $UILayer/HUD
@onready var monologue_display = $UILayer/MonologueDisplay
@onready var interaction_prompt = $InsertOverlay/InteractionPrompt  # v0.1 single-line fallback
@onready var interaction_list = $InsertOverlay/InteractionList  # D-057: z-layer 6
@onready var world_radial = $InsertOverlay/WorldRadial  # D-058: z-layer 6
+@onready var dialogue_box = $InsertOverlay/DialogueBox  # D-061: z-layer 6
@onready var inventory_grid = $UILayer/InventoryGrid  # D-065: z-layer 7
@onready var stance_indicator = $UILayer/StanceIndicator  # D-053: z-layer 7
@onready var cursor_renderer = $UILayer/CursorRenderer  # D-056: z-layer 7
+@onready var gauntlet_hud = $UILayer/GauntletHUD  # #496: room timer + personal bests
+@onready var checklist_overlay = $UILayer/ChecklistOverlay  # #503: auto-checklist progress
+@onready var bug_report_dialog = $ModalLayer/BugReportDialog  # #495: F12 WRONG button
+
+var _last_dialogue_npc_id: int = -1  # D-064: NPC entity_id for WalkAway input
+var _camera_anchored: bool = false
+var _last_monologue_tick: int = -1  # Prevent re-consuming monologue when same tick polled twice
+var _last_dialogue_tick: int = -1
+var _flash_rect: ColorRect = null  # #502/#501: ephemeral screen flash overlay (shared: teleport preempts amber)
+var _teleport_in_progress: bool = false  # #501: defer smoothing re-enable by one frame after teleport
+var _pending_record_inputs: Array = []   # #507: accumulates server-bound inputs across frames; flushed into record_tick() on snapshot arrival

 func _ready() -> void:
 	print("The Settled Reach — client initialized")

-	# Connect to simulation (will use test mode initially)
+	# Disable camera smoothing during init. Camera2D's position_smoothing
+	# lerps an internal smoothed_camera_pos toward global_position each frame.
+	# That smoothed position initializes at (0,0) — the Camera2D's default in
+	# the .tscn. Even after we set global_position to the player coords,
+	# smoothing causes the viewport to still show (0,0) on the first rendered
+	# frame because the lerp hasn't converged. With smoothing OFF, the viewport
+	# uses global_position directly. Re-enabled in _process() after anchor.
+	camera.position_smoothing_enabled = false
+
+	# Connect to simulation (test mode sets CONNECTED immediately)
 	SimBridge.connect_to_sim()

+	# Camera anchor: snap to player position before the first frame renders.
+	# In test mode poll_snapshot() returns synchronously — position is set
+	# immediately. In live mode the snapshot isn't available yet — _process
+	# handles it. No reset_smoothing() needed: smoothing is OFF.
+	var first_snapshot: Variant = SimBridge.poll_snapshot()
+	if first_snapshot != null:
+		GameState.apply_snapshot(first_snapshot)
+		camera.global_position = GameState.player_position * Constants.TILE_SIZE
+		_camera_anchored = true
+
+	# D-061: Connect dialogue box signals
+	if dialogue_box:
+		dialogue_box.option_selected.connect(_on_dialogue_option_selected)
+		dialogue_box.dialogue_dismissed.connect(_on_dialogue_dismissed)
+		dialogue_box.confrontation_monologue.connect(_on_confrontation_monologue)
+
+	# #496: Print gauntlet session summary on disconnect
+	if gauntlet_hud:
+		SimBridge.connection_state_changed.connect(_on_connection_state_changed)
+
+
 func _process(_delta: float) -> void:
 	# Main game loop: poll snapshot, apply state, flush input
-	var snapshot = SimBridge.poll_snapshot()
+	var snapshot: Variant = SimBridge.poll_snapshot()
 	if snapshot != null:
+		var old_pos := GameState.player_position
 		GameState.apply_snapshot(snapshot)

+		# #501: Detect teleport (large position jump > 5 tiles) and trigger fade
+		if _camera_anchored and _detect_teleport(old_pos, GameState.player_position):
+			_teleport_transition()
+
+		# Late anchor: live mode — first snapshot arrives during _process.
+		# Smoothing is already OFF (disabled in _ready), so setting
+		# global_position takes effect immediately with no lerp.
+		if not _camera_anchored:
+			camera.global_position = GameState.player_position * Constants.TILE_SIZE
+			_camera_anchored = true
+
 		# Update renderers with new state
 		if world_renderer and world_renderer.has_method("update_from_state"):
 			world_renderer.update_from_state()

+		# OQ-07 (#522): propagate insert state to all z-layer-6 display nodes.
+		# Cursor shape still fires (D-056 option a) — only verb labels suppressed.
+		var insert_state := GameState.insert_active
+		if cursor_renderer and cursor_renderer.has_method("set_insert_active"):
+			cursor_renderer.set_insert_active(insert_state)
+		if interaction_list and interaction_list.has_method("set_insert_active"):
+			interaction_list.set_insert_active(insert_state)
+		if interaction_prompt and interaction_prompt.has_method("set_insert_active"):
+			interaction_prompt.set_insert_active(insert_state)
+
 		# D-057: Update interaction list from game state
+		# Suppress during dialogue — player is in conversation, verb list is noise
 		if interaction_list and interaction_list.has_method("update_from_state"):
-			interaction_list.update_from_state()
+			if dialogue_box and dialogue_box.is_dialogue_active():
+				if interaction_list.is_showing():
+					interaction_list._hide()
+			else:
+				interaction_list.update_from_state()

 		# D-065: Update inventory grid
 		if inventory_grid and inventory_grid.has_method("update_from_state"):
@@ -39,21 +109,52 @@ func _process(_delta: float) -> void:
 		if stance_indicator and stance_indicator.has_method("update_from_state"):
 			stance_indicator.update_from_state()

+		# D-059/D-060: Update fog entity visualization (#431)
+		if fog_entities and fog_entities.has_method("update_from_state"):
+			fog_entities.update_from_state()
+
+		# #496: Update gauntlet HUD (room timer + personal bests)
+		if gauntlet_hud and gauntlet_hud.has_method("update_from_state"):
+			gauntlet_hud.update_from_state()
+
+		# #503: Update checklist overlay (auto-checklist progress tracking)
+		if checklist_overlay and checklist_overlay.has_method("update_from_state"):
+			checklist_overlay.update_from_state()
+
 		# Show monologue if server sent one this tick (#414)
-		# Consume-once: set to null after showing to prevent re-display.
-		# Single monologue per snapshot is guaranteed by server.
-		if GameState.current_monologue != null and monologue_display:
-			var mono: Dictionary = GameState.current_monologue
-			monologue_display.show_monologue(mono.get("text", ""), mono.get("duration_seconds", 5.0))
-			GameState.current_monologue = null
+		_consume_monologue()
+
+		# D-061: Show dialogue if server sent one this tick (#434)
+		_consume_dialogue()

 	# Track camera to player position every frame (D-015: locked, no panning)
-	# Camera2D smoothing handles interpolation — we just set the target
-	camera.global_position = GameState.player_position * Constants.TILE_SIZE
+	if _camera_anchored:
+		camera.global_position = GameState.player_position * Constants.TILE_SIZE
+
+	# Re-enable smoothing after the first anchored frame. The frame that just
+	# rendered used smoothing=OFF (correct viewport from frame one). Now we
+	# turn smoothing back on and sync its internal state so subsequent frames
+	# get smooth camera tracking during gameplay.
+	# #501: Skip re-enable during teleport — _teleport_transition() disables
+	# smoothing for a clean camera snap. Defer by one frame to avoid the
+	# re-enable block in the same _process() call undoing the snap.
+	if _camera_anchored and not camera.position_smoothing_enabled:
+		if _teleport_in_progress:
+			_teleport_in_progress = false
+		else:
+			camera.position_smoothing_enabled = true
+			camera.reset_smoothing()

 	# Send queued input to simulation
+	# #507: Server-bound inputs are accumulated into _pending_record_inputs across frames.
+	# At 60fps/10tps, inputs on non-snapshot frames must not be lost from the ring buffer.
 	var inputs = InputMapper.flush_queue()
 	for input in inputs:
+		# #495: F12 WRONG button — client-only, trigger bug report capture
+		if input.action == InputMapper.Action.BUG_REPORT:
+			if bug_report_dialog and not bug_report_dialog.is_active():
+				bug_report_dialog.start_capture()
+			continue
 		if input.action == InputMapper.Action.INTERACT:
 			# D-057: prefer interaction list (multi-verb), fall back to prompt (v0.1)
 			var target_id: int = -1
@@ -76,3 +177,145 @@ func _process(_delta: float) -> void:
 					"verb": null,
 				}
 		SimBridge.send_input(input)
+		_pending_record_inputs.append(input)
+
+	# #507: Record tick data to ring buffer — once per server tick (snapshot arrival).
+	# Flushes all inputs accumulated since the last snapshot (across multiple display frames),
+	# then clears the accumulator for the next tick.
+	if snapshot != null and bug_report_dialog and bug_report_dialog.has_method("record_tick"):
+		bug_report_dialog.record_tick(
+			GameState.current_tick,
+			JSON.stringify(GameState.current_snapshot),
+			_pending_record_inputs
+		)
+		_pending_record_inputs.clear()
+
+
+# Consume-once per tick: show monologue text, then clear.
+# Tick guard prevents re-triggering when the same tick is polled multiple
+# times (client FPS > sim tick rate).
+func _consume_monologue() -> void:
+	if GameState.current_monologue == null or not monologue_display:
+		return
+	if GameState.current_tick == _last_monologue_tick:
+		return
+	_last_monologue_tick = GameState.current_tick
+	var mono: Dictionary = GameState.current_monologue
+	monologue_display.show_monologue(mono.get("text", ""), mono.get("duration_seconds", 5.0))
+	# #502: Amber flash on room reset
+	var mono_id: String = mono.get("id", "")
+	if mono_id.begins_with("room_reset"):
+		_screen_flash(Constants.ENTITY_COLOR_POI, 0.15)
+	GameState.current_monologue = null
+
+
+# Consume-once per tick with ID tracking: show dialogue, then clear.
+# Tick guard + is_dialogue_active check prevent re-triggering.
+func _consume_dialogue() -> void:
+	if GameState.current_dialogue == null or not dialogue_box:
+		return
+	if GameState.current_tick == _last_dialogue_tick:
+		return
+	if dialogue_box.is_dialogue_active():
+		GameState.current_dialogue = null
+		return
+	_last_dialogue_tick = GameState.current_tick
+	var dlg: Dictionary = GameState.current_dialogue
+	_last_dialogue_npc_id = dlg.get("npc_entity_id", -1)
+	dialogue_box.show_dialogue(
+		dlg.get("npc_name", ""),
+		dlg.get("speech", ""),
+		dlg.get("options", [])
+	)
+	GameState.current_dialogue = null
+
+
+# D-061: Handle dialogue option selection → send to server
+func _on_dialogue_option_selected(response_id: String, text: String) -> void:
+	SimBridge.send_input({
+		"action": InputMapper.Action.INTERACT,
+		"timestamp_msec": Time.get_ticks_msec(),
+		"action_data": {
+			"target_entity_id": null,
+			"verb": "DialogueResponse",
+			"response_id": response_id,
+		},
+	})
+
+
+# D-063: Handle confrontation beat monologue → show on monologue display (layer 7)
+func _on_confrontation_monologue(text: String, duration: float) -> void:
+	if monologue_display:
+		monologue_display.show_monologue(text, duration)
+
+
+# D-064: Handle walk-away → send WalkAway{npc_id} to server
+func _on_dialogue_dismissed() -> void:
+	SimBridge.send_input({
+		"action": InputMapper.Action.INTERACT,
+		"timestamp_msec": Time.get_ticks_msec(),
+		"action_data": {
+			"target_entity_id": _last_dialogue_npc_id if _last_dialogue_npc_id >= 0 else null,
+			"verb": "WalkAway",
+		},
+	})
+
+
+# #496: Finalize gauntlet stats on disconnect
+func _on_connection_state_changed(old_state: SimBridge.ConnectionState, new_state: SimBridge.ConnectionState) -> void:
+	if new_state == SimBridge.ConnectionState.DISCONNECTED and gauntlet_hud:
+		gauntlet_hud.finalize()
+
+
+# #501: Detect large position jump indicating a teleport (not normal movement).
+const TELEPORT_DISTANCE_THRESHOLD: float = 5.0
+
+func _detect_teleport(old_pos: Vector2, new_pos: Vector2) -> bool:
+	return old_pos.distance_to(new_pos) > TELEPORT_DISTANCE_THRESHOLD
+
+
+# #501: Gauntlet dev teleport transition — snap camera + 0.3s fade-from-black.
+# Clears dialogue/monologue/interaction state (server clears its side too).
+# Scoped to Gauntlet testing only — production fast-travel uses diegetic gates.
+func _teleport_transition() -> void:
+	# Snap camera: disable smoothing, force re-anchor.
+	# _teleport_in_progress defers smoothing re-enable by one frame so the
+	# re-enable block at the bottom of _process() doesn't undo the snap.
+	camera.position_smoothing_enabled = false
+	camera.global_position = GameState.player_position * Constants.TILE_SIZE
+	_camera_anchored = true
+	_teleport_in_progress = true
+
+	# Clear client-side buffers
+	GameState.current_monologue = null
+	GameState.current_dialogue = null
+	GameState.dialogue_active = false
+	if dialogue_box and dialogue_box.is_dialogue_active():
+		dialogue_box.hide_dialogue()
+
+	# Fade from black: instant black overlay, fades to transparent over 0.3s
+	if _flash_rect and is_instance_valid(_flash_rect):
+		_flash_rect.queue_free()
+	_flash_rect = ColorRect.new()
+	_flash_rect.color = Color(0, 0, 0, 1.0)
+	_flash_rect.anchors_preset = Control.PRESET_FULL_RECT
+	_flash_rect.mouse_filter = Control.MOUSE_FILTER_IGNORE
+	$UILayer.add_child(_flash_rect)
+	var tween := create_tween()
+	tween.tween_property(_flash_rect, "color:a", 0.0, 0.3)
+	tween.tween_callback(_flash_rect.queue_free)
+
+
+# #502: Full-screen color flash — fades from color to transparent over duration.
+# Used for room reset amber flash. Creates ephemeral ColorRect on UILayer.
+func _screen_flash(color: Color, duration: float) -> void:
+	if _flash_rect and is_instance_valid(_flash_rect):
+		_flash_rect.queue_free()
+	_flash_rect = ColorRect.new()
+	_flash_rect.color = Color(color.r, color.g, color.b, 0.4)
+	_flash_rect.anchors_preset = Control.PRESET_FULL_RECT
+	_flash_rect.mouse_filter = Control.MOUSE_FILTER_IGNORE
+	$UILayer.add_child(_flash_rect)
+	var tween := create_tween()
+	tween.tween_property(_flash_rect, "color:a", 0.0, duration)
+	tween.tween_callback(_flash_rect.queue_free)
@@ -11,7 +11,7 @@ class_name Protocol

 ## Protocol version — must match server PROTOCOL_VERSION in bridge/types.rs.
 ## Reject snapshots where version != this value.
-const PROTOCOL_VERSION: int = 6
+const PROTOCOL_VERSION: int = 8


 # -- Decode: bytes from server → GDScript types --------------------------------
@@ -122,6 +122,64 @@ static func decode_snapshot(bytes: PackedByteArray) -> Variant:
 					"slot": int(raw_item.get("slot", 0)),
 				})

+	# v7: pending_recognitions (#431, D-059/D-060) — cognitive delay fog entities
+	# Bounded: server sends at most ~50 pending recognitions per snapshot (practical limit
+	# given perception range). Excessive arrays are truncated to prevent allocation abuse.
+	const MAX_PENDING_RECOGNITIONS: int = 64
+	var pending_recognitions: Array = []
+	var raw_recognitions: Variant = raw.get("pending_recognitions")
+	if raw_recognitions is Array:
+		var count := 0
+		for raw_pr in raw_recognitions:
+			if count >= MAX_PENDING_RECOGNITIONS:
+				push_warning("Protocol: pending_recognitions truncated at %d entries" % MAX_PENDING_RECOGNITIONS)
+				break
+			if raw_pr is Dictionary and raw_pr.has("entity_id") and raw_pr.has("x") and raw_pr.has("y"):
+				pending_recognitions.append({
+					"entity_id": int(raw_pr["entity_id"]),
+					"x": float(raw_pr["x"]),
+					"y": float(raw_pr["y"]),
+					"z": int(raw_pr.get("z", 0)),
+					"remaining_ticks": int(raw_pr.get("remaining_ticks", 0)),
+					"total_delay_ticks": int(raw_pr.get("total_delay_ticks", 1)),
+				})
+				count += 1
+
+	# v7: current_dialogue (#435, D-061/D-062) — NPC speech + player response options
+	# Options carry response_id for server round-trip and priority for display ordering.
+	# Locked options are invisible (D-062): server filters before sending.
+	var current_dialogue: Variant = null
+	var raw_dialogue: Variant = raw.get("current_dialogue")
+	if raw_dialogue is Dictionary and raw_dialogue.has("speech"):
+		var dialogue_options: Array = []
+		var raw_options: Variant = raw_dialogue.get("options")
+		if raw_options is Array:
+			for raw_opt in raw_options:
+				if raw_opt is Dictionary and raw_opt.has("text"):
+					dialogue_options.append({
+						"text": str(raw_opt["text"]),
+						"response_id": str(raw_opt.get("response_id", "")),
+						"priority": int(raw_opt.get("priority", 0)),
+						"confrontation": bool(raw_opt.get("confrontation", false)),
+					})
+		current_dialogue = {
+			"npc_name": str(raw_dialogue.get("npc_name", "")),
+			"npc_entity_id": int(raw_dialogue.get("npc_entity_id", -1)),
+			"speech": str(raw_dialogue["speech"]),
+			"options": dialogue_options,
+		}
+
+	# v8: dialogue_response (#305, D-028) — NPC's spoken dialogue line from server
+	# Separate from current_dialogue (client-side rich dialogue state).
+	var dialogue_response: Variant = null
+	var raw_dr: Variant = raw.get("dialogue_response")
+	if raw_dr is Dictionary and raw_dr.has("text"):
+		dialogue_response = {
+			"line_id": str(raw_dr.get("line_id", "")),
+			"text": str(raw_dr["text"]),
+			"speaker_entity_id": int(raw_dr.get("speaker_entity_id", -1)),
+		}
+
 	return {
 		"tick": tick,
 		"entities": entities,
@@ -134,6 +192,9 @@ static func decode_snapshot(bytes: PackedByteArray) -> Variant:
 		"visible_tiles": visible_tiles,
 		"nearby_interactions": nearby_interactions,
 		"current_monologue": current_monologue,
+		"current_dialogue": current_dialogue,
+		"dialogue_response": dialogue_response,
+		"pending_recognitions": pending_recognitions,
 	}


@@ -244,13 +305,7 @@ static func _decode_enum_variant(raw) -> Dictionary:
 ##              "Interact", "UsePerceptionMode", "Pause", "Unpause"
 ## action_data: null for unit variants, String for UsePerceptionMode
 static func encode_player_input(tick: int, action_name: String, action_data: Variant = null) -> PackedByteArray:
-	var action_value: Variant
-	if action_data != null:
-		# Data variant → single-element map
-		action_value = { action_name: action_data }
-	else:
-		# Unit variant → bare string
-		action_value = action_name
+	var action_value: Variant = _encode_action(action_name, action_data)

 	var input := {
 		"tick": tick,
@@ -273,14 +328,9 @@ static func encode_player_inputs(inputs: Array) -> PackedByteArray:
 	for input in inputs:
 		var action_name: String = input["action_name"]
 		var action_data: Variant = input.get("action_data")
-		var action_value: Variant
-		if action_data != null:
-			action_value = { action_name: action_data }
-		else:
-			action_value = action_name
 		wire_inputs.append({
 			"tick": input["tick"],
-			"action": action_value,
+			"action": _encode_action(action_name, action_data),
 		})

 	var result = Messagepack.encode(wire_inputs)
@@ -291,6 +341,18 @@ static func encode_player_inputs(inputs: Array) -> PackedByteArray:
 	return result.value


+## Encode a PlayerAction for the wire.
+## Struct variants (Interact) always need their fields even when null.
+## Unit variants (MoveNorth, Pause, etc.) encode as bare strings.
+static func _encode_action(action_name: String, action_data: Variant) -> Variant:
+	if action_data != null:
+		return { action_name: action_data }
+	# Interact is a struct variant — server expects named fields, not a bare string
+	if action_name == "Interact":
+		return { "Interact": { "target_entity_id": null, "verb": null } }
+	return action_name
+
+
 ## Decode a PlayerInput from MessagePack bytes (used in tests / echo scenarios).
 ## Returns { "tick": int, "action": { "variant": String, "data": Variant } } or null.
 static func decode_player_input(bytes: PackedByteArray) -> Variant:
@@ -11,6 +11,9 @@ enum State { DEFAULT, ENTITY_HOVER, OBJECT_HOVER, WEAPON_AIM }
 var current_state: State = State.DEFAULT
 var hovered_entity_id: int = -1
 var weapon_mode_active: bool = false
+# OQ-07 (#522): when false, verb labels are suppressed (should_show_interactions → false).
+# Cursor shape transitions still fire — the character's body still orients to targets.
+var insert_active: bool = true

 signal state_changed(new_state: State)
 signal hovered_entity_changed(entity_id: int)
@@ -214,8 +217,8 @@ func _draw() -> void:


 func _draw_ticks(color: Color, thickness: float) -> void:
-	var dirs := [Vector2.UP, Vector2.RIGHT, Vector2.DOWN, Vector2.LEFT]
-	for dir in dirs:
+	var dirs: Array[Vector2] = [Vector2.UP, Vector2.RIGHT, Vector2.DOWN, Vector2.LEFT]
+	for dir: Vector2 in dirs:
 		var d := dir.rotated(_rot)
 		draw_line(d * _gap, d * (_gap + _len), color, thickness, true)

@@ -305,8 +308,15 @@ func get_z_layer() -> int:


 func should_show_interactions() -> bool:
+	# OQ-07: insert off suppresses verb labels even though cursor shape still changes
+	if not insert_active:
+		return false
 	return not weapon_mode_active or _shift_held


+func set_insert_active(active: bool) -> void:
+	insert_active = active
+
+
 func get_interaction_range() -> int:
 	return 2  # D-056: ~2 sim tiles
@@ -0,0 +1 @@
+uid://bkbfcalfo1kk8
@@ -5,6 +5,10 @@ extends Node2D
 # Creates/updates/removes ColorRect children based on entity data
 # Entity format (from Protocol v2): {entity_id, x, y, z, kind: {variant, data}, visibility}
 #
+# Position lerping: entity sprites smoothly slide between tiles instead of snapping.
+# The server moves entities in discrete tile steps; the lerp makes this look fluid.
+# Speed is tuned so Sprint feels snappy and Walk/Careful/Crouch feel deliberate.
+#
 # D-033 colors: Phase 1 defaults by entity kind. Phase 2 (#361) will derive
 # color from RelationshipState via the knowledge graph.

@@ -12,11 +16,52 @@ const TILE_SIZE: int = Constants.TILE_SIZE
 const ENTITY_SIZE: int = 24
 const ENTITY_OFFSET: float = (TILE_SIZE - ENTITY_SIZE) / 2.0  # center within tile

-var entity_nodes: Dictionary = {}  # entity_id -> Node2D mapping
+# Lerp speed — framerate-independent exponential smoothing.
+# At 12.0: ~70% there after 0.1s, ~95% after 0.25s.
+# Fast enough for Sprint snappiness, slow enough for Walk to show sliding.
+const LERP_SPEED: float = 12.0
+
+var entity_nodes: Dictionary = {}    # entity_id -> Node2D
+var _entity_targets: Dictionary = {} # entity_id -> Vector2 (target pixel position)
+var _entity_relationships: Dictionary = {}  # #521: entity_id -> String (last relationship)
+var _entity_tweens: Dictionary = {}  # #521: entity_id -> {target: Color, elapsed: float}
+
+# #521: Color transition duration in seconds (D-033: "0.5s fade")
+const COLOR_FADE_DURATION: float = 0.5

 func _ready() -> void:
 	print("EntityRenderer: Initialized")

+
+func _process(delta: float) -> void:
+	# Lerp all entity visual positions toward their targets each frame.
+	# Uses framerate-independent exponential smoothing.
+	var weight := 1.0 - exp(-LERP_SPEED * delta)
+	for entity_id in entity_nodes.keys():
+		if not _entity_targets.has(entity_id):
+			continue
+		var node = entity_nodes[entity_id]
+		var target: Vector2 = _entity_targets[entity_id]
+		if not node.position.is_equal_approx(target):
+			node.position = node.position.lerp(target, weight)
+
+	# #521: Advance color transitions (manual lerp, testable without SceneTree)
+	var finished_ids: Array = []
+	for entity_id in _entity_tweens.keys():
+		if not entity_nodes.has(entity_id):
+			finished_ids.append(entity_id)
+			continue
+		var tween_data: Dictionary = _entity_tweens[entity_id]
+		tween_data.elapsed += delta
+		var t := clampf(tween_data.elapsed / COLOR_FADE_DURATION, 0.0, 1.0)
+		var node_c: ColorRect = entity_nodes[entity_id] as ColorRect
+		node_c.color = tween_data.from.lerp(tween_data.target, t)
+		if t >= 1.0:
+			finished_ids.append(entity_id)
+	for eid in finished_ids:
+		_entity_tweens.erase(eid)
+
+
 # Update entities from snapshot data
 func update_entities(entities: Array) -> void:
 	var active_ids: Array = []
@@ -51,34 +96,59 @@ func _create_entity_node(entity_id: int, entity_data: Dictionary) -> void:
 	entity_node.size = Vector2(ENTITY_SIZE, ENTITY_SIZE)
 	entity_node.pivot_offset = Vector2(ENTITY_SIZE / 2.0, ENTITY_SIZE / 2.0)

-	# D-033 color by entity kind (Phase 1 default)
-	# TODO(#361): derive from RelationshipState via knowledge graph
+	# D-033 color by relationship (#521)
 	entity_node.color = _color_for_kind(entity_data)

 	add_child(entity_node)
 	entity_nodes[entity_id] = entity_node
+	_entity_relationships[entity_id] = entity_data.get("relationship", "Unknown")

 	# Add facing indicator for the player entity
 	if entity_id == GameState.player_entity_id:
 		_add_facing_indicator(entity_node)

+	# Snap to initial position (no lerp on first appearance)
+	if entity_data.has("x") and entity_data.has("y"):
+		var target := Vector2(
+			floorf(entity_data.x) * TILE_SIZE + ENTITY_OFFSET,
+			floorf(entity_data.y) * TILE_SIZE + ENTITY_OFFSET
+		)
+		entity_node.position = target
+		_entity_targets[entity_id] = target
+
 	_update_entity_node(entity_id, entity_data)

-# Update an existing entity node (position, visibility dimming, facing)
+# Update an existing entity node (target position, visibility dimming, facing)
 func _update_entity_node(entity_id: int, entity_data: Dictionary) -> void:
 	if not entity_nodes.has(entity_id):
 		return

 	var entity_node = entity_nodes[entity_id]

-	# Update position from x, y fields (Protocol format), centered within tile.
+	# Update target position — the lerp in _process() will smoothly move there.
 	# Server sends tile-center coords (tile 16 → 16.5), floor to get tile index.
 	if entity_data.has("x") and entity_data.has("y"):
-		entity_node.position = Vector2(
+		_entity_targets[entity_id] = Vector2(
 			floorf(entity_data.x) * TILE_SIZE + ENTITY_OFFSET,
 			floorf(entity_data.y) * TILE_SIZE + ENTITY_OFFSET
 		)

+	# #521: Detect relationship change → fade D-033 color (0.5s via _process)
+	var new_rel: String = entity_data.get("relationship", "Unknown")
+	var old_rel: String = _entity_relationships.get(entity_id, "Unknown")
+	if new_rel != old_rel:
+		_entity_relationships[entity_id] = new_rel
+		var new_color := _color_for_kind(entity_data)
+		_entity_tweens[entity_id] = {
+			"from": entity_node.color,
+			"target": new_color,
+			"elapsed": 0.0,
+		}
+
+	# Note: modulate.a (peripheral dimming below) and color (D-033 tint above)
+	# are compositionally independent — both can change simultaneously without
+	# interference. If alpha tweening is added later, coordinate with color tween.
+
 	# v2: Peripheral vision dimming (D-015)
 	# null visibility (v1 backward compat) defaults to full alpha
 	var visibility: Variant = entity_data.get("visibility")
@@ -86,11 +156,14 @@ func _update_entity_node(entity_id: int, entity_data: Dictionary) -> void:
 	if not is_equal_approx(entity_node.modulate.a, target_alpha):
 		entity_node.modulate.a = target_alpha

-	# v2: Update facing indicator rotation (player entity only)
+	# D-054: Update facing indicator from client-side mouse angle (not server).
+	# InputMapper.facing_angle is a continuous float — smoother than octant snapping.
 	if entity_id == GameState.player_entity_id:
 		var indicator = entity_node.get_node_or_null("FacingIndicator")
 		if indicator != null:
-			indicator.rotation = _facing_to_rotation(GameState.player_facing)
+			# facing_angle: 0=East, -PI/2=North. Indicator: 0=North (up).
+			# Rotate from North basis: add PI/2 to convert.
+			indicator.rotation = InputMapper.facing_angle + PI / 2.0

 # Remove an entity node
 func _remove_entity_node(entity_id: int) -> void:
@@ -100,6 +173,9 @@ func _remove_entity_node(entity_id: int) -> void:
 	var entity_node = entity_nodes[entity_id]
 	entity_node.queue_free()
 	entity_nodes.erase(entity_id)
+	_entity_targets.erase(entity_id)
+	_entity_relationships.erase(entity_id)
+	_entity_tweens.erase(entity_id)

 # D-033 color by entity kind — delegates to Constants.color_for_entity_kind
 static func _color_for_kind(entity_data: Dictionary) -> Color:
@@ -121,16 +197,3 @@ func _add_facing_indicator(parent_node: Control) -> void:
 	# Position at center of parent ColorRect — rotation around this point
 	indicator.position = Vector2(ENTITY_SIZE / 2.0, ENTITY_SIZE / 2.0)
 	parent_node.add_child(indicator)
-
-# Convert facing direction string to rotation in radians (0 = North/up)
-static func _facing_to_rotation(facing: String) -> float:
-	match facing:
-		"North": return 0.0
-		"Northeast": return PI / 4.0
-		"East": return PI / 2.0
-		"Southeast": return 3.0 * PI / 4.0
-		"South": return PI
-		"Southwest": return 5.0 * PI / 4.0
-		"West": return 3.0 * PI / 2.0
-		"Northwest": return 7.0 * PI / 4.0
-		_: return 0.0
@@ -0,0 +1,178 @@
+class_name FogEntities
+extends Node2D
+
+## Fog entity visualization — renders entities undergoing cognitive delay recognition
+## in the fog layer. Between FogOverlay (z:900) and InsertOverlay (CanvasLayer 10).
+##
+## Three visual states per D-059/D-060:
+##   1. Sound pings: 2-3 thin concentric expanding rings (sonar-style)
+##   2. Unrecognized entity: grey blob #555566, 0.8s breathing pulse
+##   3. Recognized entity: D-033 color glow + silhouette + breathing pulse + position drift
+##
+## Cognitive delay transition: grey blob → color + silhouette over ~0.3s,
+## driven by remaining_ticks / total_delay_ticks ratio from server.
+##
+## All drawing happens in _draw() — no child scripts needed.
+
+const TILE_SIZE: int = Constants.TILE_SIZE
+
+# D-059: Fog entity colors
+const COLOR_UNRECOGNIZED := Color("#555566")   # Neutral grey blob
+# Intentionally matches Constants.INSERT_COLOR_TEXT / cursor default (#c8d0e0).
+# Sonar pings are insert-generated — same visual language as cursor and HUD overlays.
+const COLOR_PING := Color("#c8d0e0")           # Insert white-blue (D-048/D-056)
+
+# Animation timing
+const PULSE_PERIOD: float = 0.8        # Breathing pulse cycle (seconds)
+const PULSE_MIN_ALPHA: float = 0.4     # Min alpha during breathing
+const PULSE_MAX_ALPHA: float = 0.8     # Max alpha during breathing
+const PING_DURATION: float = 1.5       # Sound ping expand + fade (seconds)
+const PING_MAX_RADIUS: float = 24.0    # Max ring expand radius (pixels)
+const PING_RING_COUNT: int = 3         # Concentric rings per ping
+const PING_RING_WIDTH: float = 1.5     # Ring line width (pixels)
+const DRIFT_RANGE: float = 0.5         # ±0.5 tile position drift (D-059)
+const DRIFT_PERIOD: float = 2.0        # Seconds per drift wander
+
+# Entity blob rendering
+const BLOB_RADIUS: float = 10.0
+const SILHOUETTE_SCALE: float = 1.3    # Silhouette slightly larger than blob
+# Transition thresholds: recognition progress mapped from remaining_ticks/total_delay_ticks.
+# Color transition starts at 50% to compress the visual change into ~0.3s (D-060).
+const COLOR_TRANSITION_START: float = 0.5
+# Silhouette (body shape hint) appears after 80% progress — recognition nearly complete.
+const SILHOUETTE_APPEAR_THRESHOLD: float = 0.3
+# Silhouette size: approximate torso-sized rectangle in pixels at TILE_SIZE=32 scale.
+const SILHOUETTE_SIZE := Vector2(6.0, 10.0)
+
+# Internal state — no child nodes, pure data + _draw()
+var _entities: Dictionary = {}    # entity_id -> {pos, drift_offset, drift_target, drift_timer, progress}
+var _pings: Array = []            # [{pos: Vector2, elapsed: float}]
+var _time: float = 0.0
+
+
+func _process(delta: float) -> void:
+	# Early return when idle — skip queue_redraw() when nothing to draw
+	if _entities.is_empty() and _pings.is_empty():
+		return
+
+	_time += delta
+
+	# Animate drifts
+	for eid in _entities.keys():
+		var e: Dictionary = _entities[eid]
+		e.drift_timer += delta
+		if e.drift_timer >= DRIFT_PERIOD:
+			e.drift_timer = 0.0
+			e.drift_offset = e.drift_target
+			e.drift_target = _random_drift()
+		var t: float = e.drift_timer / DRIFT_PERIOD
+		e.drift_offset = e.drift_offset.lerp(e.drift_target, t)
+
+	# Advance pings, remove expired
+	var i := _pings.size() - 1
+	while i >= 0:
+		_pings[i].elapsed += delta
+		if _pings[i].elapsed >= PING_DURATION:
+			_pings.remove_at(i)
+		i -= 1
+
+	queue_redraw()
+
+
+## Called from main.gd each frame after GameState.apply_snapshot()
+func update_from_state() -> void:
+	var recognitions: Array = GameState.pending_recognitions
+	var active_ids: Array = []
+
+	for rec in recognitions:
+		var eid: int = rec.entity_id
+		active_ids.append(eid)
+
+		if not _entities.has(eid):
+			# New entity — spawn with random drift and trigger sonar ping
+			_entities[eid] = {
+				"pos": Vector2(rec.x, rec.y),
+				"drift_offset": _random_drift(),
+				"drift_target": _random_drift(),
+				"drift_timer": 0.0,
+				"progress": 0.0,
+			}
+			_pings.append({"pos": Vector2(rec.x, rec.y), "elapsed": 0.0})
+
+		# Update server data
+		var e: Dictionary = _entities[eid]
+		e.pos = Vector2(rec.x, rec.y)
+		var total: int = rec.total_delay_ticks
+		var remaining: int = rec.remaining_ticks
+		if total > 0:
+			e.progress = clampf(1.0 - float(remaining) / float(total), 0.0, 1.0)
+		else:
+			e.progress = 1.0
+
+	# Remove entities no longer pending
+	var to_remove: Array = []
+	for eid in _entities.keys():
+		if eid not in active_ids:
+			to_remove.append(eid)
+	for eid in to_remove:
+		_entities.erase(eid)
+
+
+func _draw() -> void:
+	# Breathing pulse — shared across all entities
+	var pulse_t := fmod(_time, PULSE_PERIOD) / PULSE_PERIOD
+	var pulse_alpha := lerpf(PULSE_MIN_ALPHA, PULSE_MAX_ALPHA,
+		0.5 + 0.5 * sin(pulse_t * TAU))
+
+	# Draw entity blobs
+	for eid in _entities.keys():
+		var e: Dictionary = _entities[eid]
+		var world_pos: Vector2 = (e.pos + e.drift_offset) * TILE_SIZE
+
+		# Color transition: grey → D-033 teal based on recognition progress
+		# Transition begins at 50% progress (D-060: ~0.3s visual transition within delay window)
+		var progress: float = e.progress
+		var color_t: float = clampf((progress - COLOR_TRANSITION_START) / (1.0 - COLOR_TRANSITION_START), 0.0, 1.0)
+		var blob_color: Color = COLOR_UNRECOGNIZED.lerp(Constants.ENTITY_COLOR_UNKNOWN, color_t)
+		blob_color.a = pulse_alpha
+
+		# Blob — unrecognized: plain circle. Recognized: larger glow + inner shape
+		if color_t < 1e-3:
+			# Pure unrecognized: grey blob, no silhouette (D-059)
+			draw_circle(world_pos, BLOB_RADIUS, blob_color)
+		else:
+			# Transitioning / recognized: outer glow + inner silhouette hint
+			var glow_color := blob_color
+			glow_color.a *= 0.4
+			draw_circle(world_pos, BLOB_RADIUS * SILHOUETTE_SCALE, glow_color)
+			draw_circle(world_pos, BLOB_RADIUS, blob_color)
+			# Faint silhouette: body shape rectangle emerges late in recognition
+			if color_t > SILHOUETTE_APPEAR_THRESHOLD:
+				var sil_color := blob_color
+				sil_color.a *= 0.6
+				var sil_size := SILHOUETTE_SIZE * color_t
+				draw_rect(Rect2(world_pos - sil_size * 0.5, sil_size), sil_color)
+
+	# Draw sound pings — concentric expanding rings
+	for ping in _pings:
+		var pos: Vector2 = ping.pos * TILE_SIZE
+		var t: float = ping.elapsed / PING_DURATION
+		var fade: float = 1.0 - t  # Linear fade out
+
+		for ring_i in range(PING_RING_COUNT):
+			# Stagger rings: each starts slightly later
+			var ring_t: float = t - ring_i * 0.15
+			if ring_t < 0.0 or ring_t > 1.0:
+				continue
+			var radius: float = ring_t * PING_MAX_RADIUS
+			var ring_fade: float = (1.0 - ring_t) * fade
+			var ring_color := COLOR_PING
+			ring_color.a = ring_fade * 0.7
+			draw_arc(pos, radius, 0.0, TAU, 32, ring_color, PING_RING_WIDTH)
+
+
+func _random_drift() -> Vector2:
+	return Vector2(
+		randf_range(-DRIFT_RANGE, DRIFT_RANGE),
+		randf_range(-DRIFT_RANGE, DRIFT_RANGE)
+	)
@@ -0,0 +1 @@
+uid://cw154tgjdyhe1
@@ -11,13 +11,18 @@ const TILE_SIZE := float(Constants.TILE_SIZE)


 func _ready() -> void:
-	# Create the fog overlay ColorRect
+	# Create the fog overlay ColorRect — transparent fallback so a shader failure
+	# doesn't paint solid white over the entire world (z:900 covers everything).
 	_fog_rect = ColorRect.new()
 	_fog_rect.name = "FogRect"
+	_fog_rect.color = Color.TRANSPARENT
 	add_child(_fog_rect)

 	# Load shader and create material
 	var shader := load("res://shaders/fog.gdshader") as Shader
+	if shader == null:
+		push_error("FogShader: failed to load res://shaders/fog.gdshader — fog disabled")
+		return
 	_shader_mat = ShaderMaterial.new()
 	_shader_mat.shader = shader
 	_fog_rect.material = _shader_mat
@@ -38,14 +43,19 @@ func _ready() -> void:


 func update_fog() -> void:
+	if _shader_mat == null:
+		return  # Shader failed to load — fog disabled
+
 	# 1. Update FogState textures from GameState
 	FogState.update_from_state()

-	# 2. Position ColorRect to cover the current viewport
+	# 2. Position ColorRect to cover the current viewport.
+	# Use the camera's actual position (not player position) so the fog rect
+	# tracks the smoothed camera and never desynchronizes during smooth pan.
 	var vp_size := get_viewport().get_visible_rect().size
 	var cam := get_viewport().get_camera_2d()
 	var zoom := cam.zoom if cam else Vector2(2.0, 2.0)
-	var camera_pos := GameState.player_position * TILE_SIZE
+	var camera_pos := cam.global_position if cam else GameState.player_position * TILE_SIZE
 	var half_view := vp_size / (2.0 * zoom)
 	_fog_rect.position = camera_pos - half_view
 	_fog_rect.size = vp_size / zoom
@@ -0,0 +1 @@
+uid://dje4vilxh5xxu
@@ -5,14 +5,15 @@ extends TileMapLayer
 # Uses a programmatic TileSet with placeholder colored rectangles (D-014)
 #
 # Tile types (atlas coords in the programmatic source):
-#   (0,0) = floor    — dark gray
-#   (1,0) = wall     — lighter gray
-#   (2,0) = door     — brown
-#   (3,0) = object   — teal
+#   (0,0) = floor       — dark gray
+#   (1,0) = wall        — lighter gray
+#   (2,0) = door        — brown
+#   (3,0) = object      — teal
+#   (4,0) = reset_plate — amber (#502)

 const TILE_SIZE: int = Constants.TILE_SIZE

-enum TileType { FLOOR = 0, WALL = 1, DOOR = 2, OBJECT = 3 }
+enum TileType { FLOOR = 0, WALL = 1, DOOR = 2, OBJECT = 3, RESET_PLATE = 4 }

 # Wire-format string to TileType mapping
 const TILE_TYPE_MAP: Dictionary = {
@@ -20,6 +21,7 @@ const TILE_TYPE_MAP: Dictionary = {
 	"wall": TileType.WALL,
 	"door": TileType.DOOR,
 	"object": TileType.OBJECT,
+	"reset_plate": TileType.RESET_PLATE,
 }

 var _initialized: bool = false
@@ -36,7 +38,7 @@ func _setup_tileset() -> void:

 	# Create an atlas source backed by a programmatic image
 	var source := TileSetAtlasSource.new()
-	var img := Image.create(TILE_SIZE * 4, TILE_SIZE, false, Image.FORMAT_RGBA8)
+	var img := Image.create(TILE_SIZE * 5, TILE_SIZE, false, Image.FORMAT_RGBA8)

 	# Floor (0,0) — dark gray
 	_fill_tile(img, 0, Color(0.18, 0.18, 0.22))
@@ -46,13 +48,15 @@ func _setup_tileset() -> void:
 	_fill_tile_with_border(img, 2, Color(0.5, 0.35, 0.2), Color(0.35, 0.25, 0.15))
 	# Object (3,0) — teal
 	_fill_tile(img, 3, Color(0.2, 0.45, 0.45))
+	# Reset plate (4,0) — amber (#502)
+	_fill_tile_with_border(img, 4, Color(0.91, 0.77, 0.28), Color(0.65, 0.55, 0.2))

 	var tex := ImageTexture.create_from_image(img)
 	source.texture = tex
 	source.texture_region_size = Vector2i(TILE_SIZE, TILE_SIZE)

 	# Create tile entries in the atlas
-	for i in range(4):
+	for i in range(5):
 		source.create_tile(Vector2i(i, 0))

 	var source_id := ts.add_source(source)
@@ -38,37 +38,36 @@ void fragment() {
    // Outside known map → unexplored
    if (tex_uv.x < 0.0 || tex_uv.x > 1.0 || tex_uv.y < 0.0 || tex_uv.y > 1.0) {
        COLOR = vec4(UNEXPLORED_COLOR, 1.0);
-        return;
-    }
-
-    float vis = texture(visibility_tex, tex_uv).r;
-    float explored = texture(exploration_tex, tex_uv).r;
-
-    if (vis > PERIPHERAL_LOW) {
-        // In or near vision cone
-        if (vis > CLEAR_THRESHOLD) {
-            // Layer 1: Clear — soft edge gradient
-            float edge = smoothstep(CLEAR_THRESHOLD, 1.0, vis);
-            COLOR = vec4(0.0, 0.0, 0.0, 1.0 - edge);
-        } else {
-            // Layer 2: Light fog (peripheral + forward edge)
-            // D-059: animated Perlin noise, 8-10s cycle
-            float noise_val = texture(noise_tex, tile * 0.03 + vec2(time * 0.11, time * 0.07)).r;
-            float coverage = smoothstep(PERIPHERAL_LOW, CLEAR_THRESHOLD, vis);
-            // Blend from heavy fog (alpha ~0.55) to lighter fog near clear edge
-            float alpha = mix(0.55, 0.25, coverage) + noise_val * 0.1;
-            COLOR = vec4(DARK_OVERLAY, alpha);
-        }
-    } else if (explored > 0.3) {
-        // Layer 3: Deep fog (previously explored, no longer in LOS)
-        // D-059: near-monochrome, ~10% zone temperature tint, 15-20s breathing cycle
-        vec3 zone_tint = texture(zone_tint_tex, tex_uv).rgb;
-        float noise_val = texture(noise_tex, tile * 0.015 + vec2(time * 0.045, time * 0.03)).r;
-        vec3 tint_color = mix(vec3(0.04), zone_tint, 0.1);
-        float alpha = mix(0.78, 0.90, noise_val);  // Fog breathes
-        COLOR = vec4(tint_color, alpha);
    } else {
-        // Layer 5: Unexplored, no maps — information zero
-        COLOR = vec4(UNEXPLORED_COLOR, 1.0);
+        float vis = texture(visibility_tex, tex_uv).r;
+        float explored = texture(exploration_tex, tex_uv).r;
+
+        if (vis > PERIPHERAL_LOW) {
+            // In or near vision cone
+            if (vis > CLEAR_THRESHOLD) {
+                // Layer 1: Clear — soft edge gradient
+                float edge = smoothstep(CLEAR_THRESHOLD, 1.0, vis);
+                COLOR = vec4(0.0, 0.0, 0.0, 1.0 - edge);
+            } else {
+                // Layer 2: Light fog (peripheral + forward edge)
+                // D-059: animated Perlin noise, 8-10s cycle
+                float noise_val = texture(noise_tex, tile * 0.03 + vec2(time * 0.11, time * 0.07)).r;
+                float coverage = smoothstep(PERIPHERAL_LOW, CLEAR_THRESHOLD, vis);
+                // Blend from heavy fog (alpha ~0.55) to lighter fog near clear edge
+                float alpha = mix(0.55, 0.25, coverage) + noise_val * 0.1;
+                COLOR = vec4(DARK_OVERLAY, alpha);
+            }
+        } else if (explored > 0.3) {
+            // Layer 3: Deep fog (previously explored, no longer in LOS)
+            // D-059: near-monochrome, ~10% zone temperature tint, 15-20s breathing cycle
+            vec3 zone_tint = texture(zone_tint_tex, tex_uv).rgb;
+            float noise_val = texture(noise_tex, tile * 0.015 + vec2(time * 0.045, time * 0.03)).r;
+            vec3 tint_color = mix(vec3(0.04), zone_tint, 0.1);
+            float alpha = mix(0.78, 0.90, noise_val);  // Fog breathes
+            COLOR = vec4(tint_color, alpha);
+        } else {
+            // Layer 5: Unexplored, no maps — information zero
+            COLOR = vec4(UNEXPLORED_COLOR, 1.0);
+        }
    }
 }
@@ -0,0 +1 @@
+uid://bcc1wwpk3moh1
@@ -0,0 +1 @@
+
@@ -0,0 +1 @@
+̀
@@ -0,0 +1 @@
+����
@@ -0,0 +1 @@
+��
@@ -0,0 +1 @@
+��
@@ -0,0 +1 @@
+�����
@@ -0,0 +1 @@
+���
@@ -0,0 +1 @@
+��������
--- a/Show More
+++ b/Show More