1	---
2	phase: 07-workflow-smoke-convention-locks
3	plan: 08
4	type: execute
5	wave: 4
6	depends_on: [07-01, 07-03, 07-07]
7	files_modified:
8	  - maps/_smoke/synth-8000x6400.ldtk
9	  - .planning/phases/07-workflow-smoke-convention-locks/SMOKE-NOTES.md
10	autonomous: false
11	requirements: [MAP-02]
12	tags: [smoke-test, operator-uat, bncentral-chunking]
13
14	must_haves:
15	  truths:
16	    - "maps/_smoke/synth-8000x6400.ldtk exists, is a valid LDtk 1.5.3 file matching ADR 0011 3×3 GridVania chunking (cols 2668/2664/2668, rows 2132/2136/2132)"
17	    - "All 9 chunks authored with BORDERED floor tiles only (no entities, no auto-tile rules, no animated tiles)"
18	    - "SMOKE-NOTES.md records operator screenshot + per-chunk subjective lag impressions + boolean PASS/FAIL verdict"
19	    - "Smoke test does not block Phase 7 closing if PASS (per D-25); FAIL triggers re-opening D-09/D-10 chunk grid"
20	    - "All chunk worldX/worldY corner coordinates match the arithmetic in ADR 0011 inline check"
21	    - "Absorbs CONTEXT.md decisions D-22, D-23, D-24, D-25 (Smoke-Test category — synthetic zone shape, subjective PASS/FAIL gate, artifact locations, non-blocking semantics)"
22	  artifacts:
23	    - path: "maps/_smoke/synth-8000x6400.ldtk"
24	      provides: "Operator-authored 3×3 GridVania smoke test artifact; first .ldtk file in repo (establishes maps/ top-level dir)"
25	      contains: "1.5.3"
26	    - path: ".planning/phases/07-workflow-smoke-convention-locks/SMOKE-NOTES.md"
27	      provides: "Operator notes + screenshot + PASS/FAIL verdict on the chunking workflow"
28	      contains: "PASS"
29	  key_links:
30	    - from: "maps/_smoke/synth-8000x6400.ldtk"
31	      to: "docs/adr/0011-bncentral-gridvania-chunking.md"
32	      via: "World dimensions + chunk dims match ADR 0011 D-09/D-10 verbatim"
33	      pattern: "8000.*6400"
34	    - from: ".planning/phases/07-workflow-smoke-convention-locks/SMOKE-NOTES.md"
35	      to: "docs/adr/0011-bncentral-gridvania-chunking.md"
36	      via: "PASS/FAIL verdict feeds back into ADR 0011 re-eval gate"
37	      pattern: "ADR 0011"
38	---
39
40	<objective>
41	Operator authors the synthetic 8000×6400 smoke-test LDtk world matching the ADR 0011 3×3 GridVania chunk grid exactly, opens + saves a representative subset of chunks, records subjective lag impressions + screenshot in `SMOKE-NOTES.md`, and issues a boolean PASS/FAIL verdict. This is the final gate before Phase 7 closes; PASS = chunking workflow tolerable, FAIL = re-open D-09/D-10 chunk grid per D-25.
42
43	Purpose: ROADMAP success criterion 5 — confirm the chunked authoring workflow is tolerable on the operator machine BEFORE any real zone is converted in v1.2. The synthetic world stresses LDtk editor lag at the exact chunk dimensions BNCentral will use; if FAIL, the chunk-grid decision is re-opened before v1.2 BNCentral conversion starts.
44	Output: `maps/_smoke/synth-8000x6400.ldtk` (operator-authored via LDtk 1.5.3 GUI) + `SMOKE-NOTES.md` with PASS/FAIL verdict.
45	</objective>
46
47	<execution_context>
48	@$HOME/.claude/get-shit-done/workflows/execute-plan.md
49	@$HOME/.claude/get-shit-done/templates/summary.md
50	</execution_context>
51
52	<context>
53	@.planning/PROJECT.md
54	@.planning/ROADMAP.md
55	@.planning/STATE.md
56	@.planning/phases/07-workflow-smoke-convention-locks/07-CONTEXT.md
57	@.planning/phases/07-workflow-smoke-convention-locks/07-PATTERNS.md
58	@docs/adr/0009-ldtk-gridsize-convention.md
59	@docs/adr/0011-bncentral-gridvania-chunking.md
60	@tools/ldtk-version.txt
61	@CLAUDE.md
62	</context>
63
64	<tasks>
65
66	<task type="auto">
67	  <name>Task 1: Write SMOKE-NOTES.md template scaffold for the operator</name>
68	  <files>.planning/phases/07-workflow-smoke-convention-locks/SMOKE-NOTES.md</files>
69
70	  <read_first>
71	    - .planning/phases/07-workflow-smoke-convention-locks/07-CONTEXT.md §"Smoke-Test (Success Criterion 5)" D-22..D-25 (synthetic zone shape, pass-gate definition, artifact locations, non-blocking semantics)
72	    - .planning/phases/07-workflow-smoke-convention-locks/07-PATTERNS.md §".planning/phases/.../SMOKE-NOTES.md" (template skeleton — per-chunk table with worldX/worldY columns, screenshot embed, verdict block, escalation path)
73	    - docs/adr/0011-bncentral-gridvania-chunking.md (chunk dims + worked corner coordinates this template references)
74	    - tools/ldtk-version.txt (LDtk pinned version the operator must confirm matches their installed editor)
75	    - .planning/research/v1.1/PITFALLS.md (Pitfall #6 — lag-impression structure; multi-state coverage requirement)
76	  </read_first>
77
78	  <action>
79	Create `.planning/phases/07-workflow-smoke-convention-locks/SMOKE-NOTES.md` with the template structure from PATTERNS.md §"SMOKE-NOTES.md" so the operator can fill it in during Task 2. Required structure:
80
81	  - H1 `# Phase 7 Smoke Test — maps/_smoke/synth-8000x6400.ldtk`
82	  - Blank line
83	  - Metadata block (operator fills in):
84	    - `**Operator:** <name>`
85	    - `**Date:** YYYY-MM-DD`
86	    - `**LDtk version:** 1.5.3 (must match tools/ldtk-version.txt)`
87	    - `**Source ADR:** 0011 (3×3 GridVania chunking)`
88	    - `[doc->REQ-MAP-02]` on its own line
89	  - Blank line
90	  - H2 `## Authoring recipe followed`
91	  - Checklist (operator marks done with `[x]`):
92	    - [ ] All 9 levels created with explicit worldX/worldY per ADR 0011 D-10
93	    - [ ] gridSize = 4 (project default) per ADR 0009 D-01
94	    - [ ] Each level filled with one BORDERED tile species (no entities, no auto-tile rules, no animated tiles per D-22)
95	    - [ ] All 9 chunks opened at least once
96	    - [ ] Subset (minimum: center + one corner + one edge) opened + filled + saved per D-23
97	  - Blank line
98	  - H2 `## Per-chunk subjective lag`
99	  - Markdown table with header `| Chunk | worldX | worldY | pxWid | pxHei | Open | Paint-fill | Save | Notes |` and 9 data rows (one per chunk) matching ADR 0011 worked-example coords verbatim:
100	    - NW    | 0     | 0    | 2668 | 2132 | ... | ... | ... | ...
101	    - N     | 2668  | 0    | 2664 | 2132 | ... | ... | ... | ...
102	    - NE    | 5332  | 0    | 2668 | 2132 | ... | ... | ... | ...
103	    - W     | 0     | 2132 | 2668 | 2136 | ... | ... | ... | ...
104	    - CENTER| 2668  | 2132 | 2664 | 2136 | ... | ... | ... | ...
105	    - E     | 5332  | 2132 | 2668 | 2136 | ... | ... | ... | ...
106	    - SW    | 0     | 4268 | 2668 | 2132 | ... | ... | ... | ...
107	    - S     | 2668  | 4268 | 2664 | 2132 | ... | ... | ... | ...
108	    - SE    | 5332  | 4268 | 2668 | 2132 | ... | ... | ... | ...
109	  - Operator fills Open/Paint-fill/Save with qualitative descriptors (`instant`, `<1s noticeable`, `>2s lag`, etc.).
110	  - Blank line
111	  - H2 `## Screenshot`
112	  - Image embed: `![ldtk-3x3-smoke](./smoke-screenshot.png)` — operator places screenshot file next to SMOKE-NOTES.md
113	  - Blank line
114	  - H2 `## Verdict`
115	  - Body: `**PASS / FAIL** — <verdict>.` (operator deletes one of PASS/FAIL and writes their rationale).
116	  - Blank line
117	  - H2 `## Escalation (if FAIL)`
118	  - Body: "Per CONTEXT.md Phase 7 D-25: re-open ADR 0011 chunk-grid decision (D-09/D-10). Candidates: 4×4 (smaller chunks, more transitions), 2×2 (larger chunks but central hub straddles all four — known anti-pattern). Document re-opening in a Phase 7 follow-up PLAN or carry to v1.2 BNCentral planning."
119
120	The file is a SCAFFOLD — Task 2 (operator UAT checkpoint) is where it gets filled in. Plan executor writes the template; the operator (in Task 2) authors the `.ldtk` file + fills the scaffold + records PASS/FAIL.
121	  </action>
122
123	  <verify>
124	    <automated>grep -q "Phase 7 Smoke Test" .planning/phases/07-workflow-smoke-convention-locks/SMOKE-NOTES.md && grep -q "doc->REQ-MAP-02" .planning/phases/07-workflow-smoke-convention-locks/SMOKE-NOTES.md && grep -q "2668" .planning/phases/07-workflow-smoke-convention-locks/SMOKE-NOTES.md && grep -q "PASS / FAIL" .planning/phases/07-workflow-smoke-convention-locks/SMOKE-NOTES.md</automated>
125	  </verify>
126
127	  <acceptance_criteria>
128	    - File `.planning/phases/07-workflow-smoke-convention-locks/SMOKE-NOTES.md` exists.
129	    - File contains H1 `# Phase 7 Smoke Test — maps/_smoke/synth-8000x6400.ldtk`.
130	    - File contains `[doc->REQ-MAP-02]` on its own line.
131	    - File contains the 9-row chunk table with worldX/worldY values matching ADR 0011 worked-example (literal `2668`, `2664`, `2132`, `2136`, `5332`, `4268` all appear).
132	    - File contains `**PASS / FAIL**` verdict block placeholder.
133	    - File contains H2 `## Escalation (if FAIL)` with reference to re-opening D-09/D-10.
134	  </acceptance_criteria>
135
136	  <done>
137	    Scaffold ready for operator to fill during Task 2 UAT.
138	  </done>
139	</task>
140
141	<task type="checkpoint:human-verify" gate="blocking">
142	  <name>Task 2: Operator authors maps/_smoke/synth-8000x6400.ldtk + completes SMOKE-NOTES.md UAT</name>
143
144	  <what-built>
145	    - `docs/adr/0009-ldtk-gridsize-convention.md` (Plan 07-01) — gridSize=4 unified convention
146	    - `docs/adr/0011-bncentral-gridvania-chunking.md` (Plan 07-03) — 3×3 GridVania chunk grid (cols 2668/2664/2668, rows 2132/2136/2132)
147	    - `tools/ldtk-version.txt` (Plan 07-04) — pinned to 1.5.3
148	    - `.planning/phases/07-workflow-smoke-convention-locks/SMOKE-NOTES.md` (Task 1 above) — UAT scaffold ready to fill
149	    - `pnpm preflight` (Plan 07-07) — runs green; operator MAY run `pnpm preflight` before + after smoke test as sanity check
150	  </what-built>
151
152	  <how-to-verify>
153	    Operator steps (LDtk 1.5.3 GUI required; this task is a manual UAT — Claude cannot author `.ldtk` files in a desktop GUI):
154
155	    1. **Confirm LDtk version**: open LDtk 1.5.3 on operator machine; About dialog must show `1.5.3` matching `tools/ldtk-version.txt`. If mismatch, fix the pin file or upgrade LDtk before proceeding.
156
157	    2. **Create the LDtk file**: in LDtk 1.5.3, create New Project at `maps/_smoke/synth-8000x6400.ldtk` (create `maps/_smoke/` directory first if it does not exist).
158	       - Project settings: gridSize = 4 (per ADR 0009 D-01) on ALL layer types (IntGrid, Tile, Entity)
159	       - World layout: GridVania (per ADR 0011)
160	       - Create one IntGrid layer + one Tile layer; no Entity layer needed for this smoke test (D-22: no entities)
161
162	    3. **Define a BORDERED tile species**: import a simple atlas (any existing PNG; the actual atlas binding is Phase 8 work). Define one tile selection visibly distinct from background — used to paint-fill all 9 chunks. The smoke test is about editor responsiveness, not asset correctness.
163
164	    4. **Author all 9 chunks** with the exact worldX/worldY/pxWid/pxHei from ADR 0011 worked example. Verify with the table in SMOKE-NOTES.md:
165	       - NW(0, 0, 2668×2132), N(2668, 0, 2664×2132), NE(5332, 0, 2668×2132)
166	       - W(0, 2132, 2668×2136), CENTER(2668, 2132, 2664×2136), E(5332, 2132, 2668×2136)
167	       - SW(0, 4268, 2668×2132), S(2668, 4268, 2664×2132), SE(5332, 4268, 2668×2132)
168	       Use LDtk's "Set level coordinates" inputs; do NOT drag-position (drag introduces sub-pixel error).
169
170	    5. **Open + paint-fill + save the representative subset** per D-23: at minimum CENTER chunk + one corner (NW recommended) + one edge (N recommended). Optional bonus: open + paint-fill + save all 9 if operator wants stronger signal.
171
172	    6. **Record per-chunk lag descriptors** in `SMOKE-NOTES.md` Per-chunk subjective lag table (qualitative — `instant`, `<1s noticeable but tolerable`, `>2s lag`, etc.). Multi-state coverage per PITFALL 6: each chunk MUST have Open, Paint-fill, and Save columns filled.
173
174	    7. **Take a screenshot** of the LDtk editor showing the 3×3 world layout. Save as `.planning/phases/07-workflow-smoke-convention-locks/smoke-screenshot.png` (file referenced in SMOKE-NOTES.md image embed).
175
176	    8. **Write the verdict** in the `## Verdict` section: replace `**PASS / FAIL** — <verdict>.` with `**PASS — <one-sentence summary>**` if the workflow felt tolerable, or `**FAIL — <one-sentence summary>**` if it felt unworkable.
177
178	    9. **If FAIL**: do NOT block Phase 7 closing programmatically. Per D-25 the smoke test is informational; FAIL triggers a follow-up PLAN to re-open ADR 0011 D-09/D-10. Operator may continue closing Phase 7 but MUST add a tracked item under `.planning/todos/pending/` recording the FAIL and the proposed alternative chunk grid (4×4 candidate or 2×2 candidate).
179
180	    10. **If PASS**: commit `maps/_smoke/synth-8000x6400.ldtk` + `SMOKE-NOTES.md` + `smoke-screenshot.png` together with message `feat(07): operator smoke test PASS for ADR 0011 3×3 GridVania`.
181
182	    11. **Re-run `pnpm preflight`** as a final sanity check; the smoke `.ldtk` lives under `maps/_smoke/` which is excluded by `lint-atlas-hash.mjs` (Plan 07-06 `.filter((p) => !p.includes('_smoke'))`) — preflight MUST still exit 0.
183
184	    Expected outcome: operator's subjective verdict PASS, all 9 chunk rows filled with at least Open + Save observations, screenshot embedded, preflight green.
185	  </how-to-verify>
186
187	  <resume-signal>
188	    Operator types one of:
189	    - `approved` (PASS verdict recorded + preflight green + files committed)
190	    - `approved-fail` (FAIL verdict recorded + follow-up todo created; Phase 7 still closes per D-25)
191	    - `blocked: <reason>` (e.g., LDtk version mismatch unresolvable, GUI crash unrecoverable — escalate before continuing)
192	  </resume-signal>
193	</task>
194
195	</tasks>
196
197	<threat_model>
198	## Trust Boundaries
199
200	| Boundary | Description |
201	|----------|-------------|
202	| LDtk GUI → repo file | LDtk authors the `.ldtk` JSON; integrity = whatever LDtk emits. No additional validation in Phase 7 (Phase 8 LdtkLoader is where load-time integrity gates land) |
203	| operator → SMOKE-NOTES.md verdict | Subjective gate per D-23 — qualitative judgment is the success criterion |
204
205	## STRIDE Threat Register
206
207	| Threat ID | Category | Component | Disposition | Mitigation Plan |
208	|-----------|----------|-----------|-------------|-----------------|
209	| T-07-08-T | Tampering | `.ldtk` file authored with wrong chunk dimensions (operator typo in worldX/worldY) | mitigate | SMOKE-NOTES.md table pins the exact 9 worldX/worldY/pxWid/pxHei values; operator cross-checks the table while authoring; any mismatch is visible in the LDtk world preview AND in `git diff` of the `.ldtk` JSON |
210	| T-07-08-T2 | Tampering | atlas-hash drift between smoke `.ldtk` and atlas-mvp.png | accept | `lint-atlas-hash.mjs` (Plan 07-06) excludes `maps/_smoke/` by design — the smoke `.ldtk` is throwaway content; if it ever escapes the `_smoke/` filter into production paths, lint will catch it then |
211	| T-07-08-R | Repudiation | future operator forgets what passed or failed | mitigate | SMOKE-NOTES.md PASS/FAIL block survives milestone archive as decision audit trail per D-24 |
212	| T-07-08-SC | Tampering (supply chain) | LDtk binary (desktop app, not an npm dep) | accept | LDtk is operator-installed Electron app; supply-chain risk identical to any other operator dev tool; pinned version is `1.5.3` per ADR 0012 + operator-trust per D-12 |
213	</threat_model>
214
215	<verification>
216	- File `maps/_smoke/synth-8000x6400.ldtk` exists after Task 2
217	- `SMOKE-NOTES.md` contains a non-placeholder `## Verdict` line (PASS or FAIL chosen, rationale non-empty)
218	- `SMOKE-NOTES.md` Per-chunk table has at least 3 chunks with all of (Open, Paint-fill, Save) filled — minimum representative subset per D-23
219	- `smoke-screenshot.png` exists at `.planning/phases/07-workflow-smoke-convention-locks/smoke-screenshot.png`
220	- `pnpm preflight` still exits 0 after the smoke `.ldtk` lands (verifies `lint-atlas-hash.mjs` _smoke/ filter works)
221	- `pnpm trace:check` continues to exit 0 (HYG-01, HYG-02, MAP-15 doc + impl coverage stable)
222	</verification>
223
224	<success_criteria>
225	Operator authors all 9 chunks at exact ADR 0011 dimensions; opens + saves at least CENTER + one corner + one edge; records subjective lag impressions in SMOKE-NOTES.md; PASS or FAIL verdict recorded with rationale; screenshot committed; `pnpm preflight` still green; Phase 7 closes per D-25 (FAIL does not block close — only triggers follow-up).
226	</success_criteria>
227
228	<output>
229	Create `.planning/phases/07-workflow-smoke-convention-locks/07-08-SUMMARY.md` when done. SUMMARY should include the PASS/FAIL verdict + a note on whether D-09/D-10 are confirmed locked or need re-opening.
230	</output>
231

---
phase: 07-workflow-smoke-convention-locks
plan: 08
type: execute
wave: 4
depends_on: [07-01, 07-03, 07-07]
files_modified:
  - maps/_smoke/synth-8000x6400.ldtk
  - .planning/phases/07-workflow-smoke-convention-locks/SMOKE-NOTES.md
autonomous: false
requirements: [MAP-02]
tags: [smoke-test, operator-uat, bncentral-chunking]

must_haves:
  truths:
    - "maps/_smoke/synth-8000x6400.ldtk exists, is a valid LDtk 1.5.3 file matching ADR 0011 3×3 GridVania chunking (cols 2668/2664/2668, rows 2132/2136/2132)"
    - "All 9 chunks authored with BORDERED floor tiles only (no entities, no auto-tile rules, no animated tiles)"
    - "SMOKE-NOTES.md records operator screenshot + per-chunk subjective lag impressions + boolean PASS/FAIL verdict"
    - "Smoke test does not block Phase 7 closing if PASS (per D-25); FAIL triggers re-opening D-09/D-10 chunk grid"
    - "All chunk worldX/worldY corner coordinates match the arithmetic in ADR 0011 inline check"
    - "Absorbs CONTEXT.md decisions D-22, D-23, D-24, D-25 (Smoke-Test category — synthetic zone shape, subjective PASS/FAIL gate, artifact locations, non-blocking semantics)"
  artifacts:
    - path: "maps/_smoke/synth-8000x6400.ldtk"
      provides: "Operator-authored 3×3 GridVania smoke test artifact; first .ldtk file in repo (establishes maps/ top-level dir)"
      contains: "1.5.3"
    - path: ".planning/phases/07-workflow-smoke-convention-locks/SMOKE-NOTES.md"
      provides: "Operator notes + screenshot + PASS/FAIL verdict on the chunking workflow"
      contains: "PASS"
  key_links:
    - from: "maps/_smoke/synth-8000x6400.ldtk"
      to: "docs/adr/0011-bncentral-gridvania-chunking.md"
      via: "World dimensions + chunk dims match ADR 0011 D-09/D-10 verbatim"
      pattern: "8000.*6400"
    - from: ".planning/phases/07-workflow-smoke-convention-locks/SMOKE-NOTES.md"
      to: "docs/adr/0011-bncentral-gridvania-chunking.md"
      via: "PASS/FAIL verdict feeds back into ADR 0011 re-eval gate"
      pattern: "ADR 0011"
---

<objective>
Operator authors the synthetic 8000×6400 smoke-test LDtk world matching the ADR 0011 3×3 GridVania chunk grid exactly, opens + saves a representative subset of chunks, records subjective lag impressions + screenshot in `SMOKE-NOTES.md`, and issues a boolean PASS/FAIL verdict. This is the final gate before Phase 7 closes; PASS = chunking workflow tolerable, FAIL = re-open D-09/D-10 chunk grid per D-25.

Purpose: ROADMAP success criterion 5 — confirm the chunked authoring workflow is tolerable on the operator machine BEFORE any real zone is converted in v1.2. The synthetic world stresses LDtk editor lag at the exact chunk dimensions BNCentral will use; if FAIL, the chunk-grid decision is re-opened before v1.2 BNCentral conversion starts.
Output: `maps/_smoke/synth-8000x6400.ldtk` (operator-authored via LDtk 1.5.3 GUI) + `SMOKE-NOTES.md` with PASS/FAIL verdict.
</objective>

<execution_context>
@$HOME/.claude/get-shit-done/workflows/execute-plan.md
@$HOME/.claude/get-shit-done/templates/summary.md
</execution_context>

<context>
@.planning/PROJECT.md
@.planning/ROADMAP.md
@.planning/STATE.md
@.planning/phases/07-workflow-smoke-convention-locks/07-CONTEXT.md
@.planning/phases/07-workflow-smoke-convention-locks/07-PATTERNS.md
@docs/adr/0009-ldtk-gridsize-convention.md
@docs/adr/0011-bncentral-gridvania-chunking.md
@tools/ldtk-version.txt
@CLAUDE.md
</context>

<tasks>

<task type="auto">
  <name>Task 1: Write SMOKE-NOTES.md template scaffold for the operator</name>
  <files>.planning/phases/07-workflow-smoke-convention-locks/SMOKE-NOTES.md</files>

  <read_first>
    - .planning/phases/07-workflow-smoke-convention-locks/07-CONTEXT.md §"Smoke-Test (Success Criterion 5)" D-22..D-25 (synthetic zone shape, pass-gate definition, artifact locations, non-blocking semantics)
    - .planning/phases/07-workflow-smoke-convention-locks/07-PATTERNS.md §".planning/phases/.../SMOKE-NOTES.md" (template skeleton — per-chunk table with worldX/worldY columns, screenshot embed, verdict block, escalation path)
    - docs/adr/0011-bncentral-gridvania-chunking.md (chunk dims + worked corner coordinates this template references)
    - tools/ldtk-version.txt (LDtk pinned version the operator must confirm matches their installed editor)
    - .planning/research/v1.1/PITFALLS.md (Pitfall #6 — lag-impression structure; multi-state coverage requirement)
  </read_first>

  <action>
Create `.planning/phases/07-workflow-smoke-convention-locks/SMOKE-NOTES.md` with the template structure from PATTERNS.md §"SMOKE-NOTES.md" so the operator can fill it in during Task 2. Required structure:

  - H1 `# Phase 7 Smoke Test — maps/_smoke/synth-8000x6400.ldtk`
  - Blank line
  - Metadata block (operator fills in):
    - `**Operator:** <name>`
    - `**Date:** YYYY-MM-DD`
    - `**LDtk version:** 1.5.3 (must match tools/ldtk-version.txt)`
    - `**Source ADR:** 0011 (3×3 GridVania chunking)`
    - `[doc->REQ-MAP-02]` on its own line
  - Blank line
  - H2 `## Authoring recipe followed`
  - Checklist (operator marks done with `[x]`):
    - [ ] All 9 levels created with explicit worldX/worldY per ADR 0011 D-10
    - [ ] gridSize = 4 (project default) per ADR 0009 D-01
    - [ ] Each level filled with one BORDERED tile species (no entities, no auto-tile rules, no animated tiles per D-22)
    - [ ] All 9 chunks opened at least once
    - [ ] Subset (minimum: center + one corner + one edge) opened + filled + saved per D-23
  - Blank line
  - H2 `## Per-chunk subjective lag`
  - Markdown table with header `| Chunk | worldX | worldY | pxWid | pxHei | Open | Paint-fill | Save | Notes |` and 9 data rows (one per chunk) matching ADR 0011 worked-example coords verbatim:
    - NW    | 0     | 0    | 2668 | 2132 | ... | ... | ... | ...
    - N     | 2668  | 0    | 2664 | 2132 | ... | ... | ... | ...
    - NE    | 5332  | 0    | 2668 | 2132 | ... | ... | ... | ...
    - W     | 0     | 2132 | 2668 | 2136 | ... | ... | ... | ...
    - CENTER| 2668  | 2132 | 2664 | 2136 | ... | ... | ... | ...
    - E     | 5332  | 2132 | 2668 | 2136 | ... | ... | ... | ...
    - SW    | 0     | 4268 | 2668 | 2132 | ... | ... | ... | ...
    - S     | 2668  | 4268 | 2664 | 2132 | ... | ... | ... | ...
    - SE    | 5332  | 4268 | 2668 | 2132 | ... | ... | ... | ...
  - Operator fills Open/Paint-fill/Save with qualitative descriptors (`instant`, `<1s noticeable`, `>2s lag`, etc.).
  - Blank line
  - H2 `## Screenshot`
  - Image embed: `![ldtk-3x3-smoke](./smoke-screenshot.png)` — operator places screenshot file next to SMOKE-NOTES.md
  - Blank line
  - H2 `## Verdict`
  - Body: `**PASS / FAIL** — <verdict>.` (operator deletes one of PASS/FAIL and writes their rationale).
  - Blank line
  - H2 `## Escalation (if FAIL)`
  - Body: "Per CONTEXT.md Phase 7 D-25: re-open ADR 0011 chunk-grid decision (D-09/D-10). Candidates: 4×4 (smaller chunks, more transitions), 2×2 (larger chunks but central hub straddles all four — known anti-pattern). Document re-opening in a Phase 7 follow-up PLAN or carry to v1.2 BNCentral planning."

The file is a SCAFFOLD — Task 2 (operator UAT checkpoint) is where it gets filled in. Plan executor writes the template; the operator (in Task 2) authors the `.ldtk` file + fills the scaffold + records PASS/FAIL.
  </action>

  <verify>
    <automated>grep -q "Phase 7 Smoke Test" .planning/phases/07-workflow-smoke-convention-locks/SMOKE-NOTES.md && grep -q "doc->REQ-MAP-02" .planning/phases/07-workflow-smoke-convention-locks/SMOKE-NOTES.md && grep -q "2668" .planning/phases/07-workflow-smoke-convention-locks/SMOKE-NOTES.md && grep -q "PASS / FAIL" .planning/phases/07-workflow-smoke-convention-locks/SMOKE-NOTES.md</automated>
  </verify>

  <acceptance_criteria>
    - File `.planning/phases/07-workflow-smoke-convention-locks/SMOKE-NOTES.md` exists.
    - File contains H1 `# Phase 7 Smoke Test — maps/_smoke/synth-8000x6400.ldtk`.
    - File contains `[doc->REQ-MAP-02]` on its own line.
    - File contains the 9-row chunk table with worldX/worldY values matching ADR 0011 worked-example (literal `2668`, `2664`, `2132`, `2136`, `5332`, `4268` all appear).
    - File contains `**PASS / FAIL**` verdict block placeholder.
    - File contains H2 `## Escalation (if FAIL)` with reference to re-opening D-09/D-10.
  </acceptance_criteria>

  <done>
    Scaffold ready for operator to fill during Task 2 UAT.
  </done>
</task>

<task type="checkpoint:human-verify" gate="blocking">
  <name>Task 2: Operator authors maps/_smoke/synth-8000x6400.ldtk + completes SMOKE-NOTES.md UAT</name>

  <what-built>
    - `docs/adr/0009-ldtk-gridsize-convention.md` (Plan 07-01) — gridSize=4 unified convention
    - `docs/adr/0011-bncentral-gridvania-chunking.md` (Plan 07-03) — 3×3 GridVania chunk grid (cols 2668/2664/2668, rows 2132/2136/2132)
    - `tools/ldtk-version.txt` (Plan 07-04) — pinned to 1.5.3
    - `.planning/phases/07-workflow-smoke-convention-locks/SMOKE-NOTES.md` (Task 1 above) — UAT scaffold ready to fill
    - `pnpm preflight` (Plan 07-07) — runs green; operator MAY run `pnpm preflight` before + after smoke test as sanity check
  </what-built>

  <how-to-verify>
    Operator steps (LDtk 1.5.3 GUI required; this task is a manual UAT — Claude cannot author `.ldtk` files in a desktop GUI):

    1. **Confirm LDtk version**: open LDtk 1.5.3 on operator machine; About dialog must show `1.5.3` matching `tools/ldtk-version.txt`. If mismatch, fix the pin file or upgrade LDtk before proceeding.

    2. **Create the LDtk file**: in LDtk 1.5.3, create New Project at `maps/_smoke/synth-8000x6400.ldtk` (create `maps/_smoke/` directory first if it does not exist).
       - Project settings: gridSize = 4 (per ADR 0009 D-01) on ALL layer types (IntGrid, Tile, Entity)
       - World layout: GridVania (per ADR 0011)
       - Create one IntGrid layer + one Tile layer; no Entity layer needed for this smoke test (D-22: no entities)

    3. **Define a BORDERED tile species**: import a simple atlas (any existing PNG; the actual atlas binding is Phase 8 work). Define one tile selection visibly distinct from background — used to paint-fill all 9 chunks. The smoke test is about editor responsiveness, not asset correctness.

    4. **Author all 9 chunks** with the exact worldX/worldY/pxWid/pxHei from ADR 0011 worked example. Verify with the table in SMOKE-NOTES.md:
       - NW(0, 0, 2668×2132), N(2668, 0, 2664×2132), NE(5332, 0, 2668×2132)
       - W(0, 2132, 2668×2136), CENTER(2668, 2132, 2664×2136), E(5332, 2132, 2668×2136)
       - SW(0, 4268, 2668×2132), S(2668, 4268, 2664×2132), SE(5332, 4268, 2668×2132)
       Use LDtk's "Set level coordinates" inputs; do NOT drag-position (drag introduces sub-pixel error).

    5. **Open + paint-fill + save the representative subset** per D-23: at minimum CENTER chunk + one corner (NW recommended) + one edge (N recommended). Optional bonus: open + paint-fill + save all 9 if operator wants stronger signal.

    6. **Record per-chunk lag descriptors** in `SMOKE-NOTES.md` Per-chunk subjective lag table (qualitative — `instant`, `<1s noticeable but tolerable`, `>2s lag`, etc.). Multi-state coverage per PITFALL 6: each chunk MUST have Open, Paint-fill, and Save columns filled.

    7. **Take a screenshot** of the LDtk editor showing the 3×3 world layout. Save as `.planning/phases/07-workflow-smoke-convention-locks/smoke-screenshot.png` (file referenced in SMOKE-NOTES.md image embed).

    8. **Write the verdict** in the `## Verdict` section: replace `**PASS / FAIL** — <verdict>.` with `**PASS — <one-sentence summary>**` if the workflow felt tolerable, or `**FAIL — <one-sentence summary>**` if it felt unworkable.

    9. **If FAIL**: do NOT block Phase 7 closing programmatically. Per D-25 the smoke test is informational; FAIL triggers a follow-up PLAN to re-open ADR 0011 D-09/D-10. Operator may continue closing Phase 7 but MUST add a tracked item under `.planning/todos/pending/` recording the FAIL and the proposed alternative chunk grid (4×4 candidate or 2×2 candidate).

    10. **If PASS**: commit `maps/_smoke/synth-8000x6400.ldtk` + `SMOKE-NOTES.md` + `smoke-screenshot.png` together with message `feat(07): operator smoke test PASS for ADR 0011 3×3 GridVania`.

    11. **Re-run `pnpm preflight`** as a final sanity check; the smoke `.ldtk` lives under `maps/_smoke/` which is excluded by `lint-atlas-hash.mjs` (Plan 07-06 `.filter((p) => !p.includes('_smoke'))`) — preflight MUST still exit 0.

    Expected outcome: operator's subjective verdict PASS, all 9 chunk rows filled with at least Open + Save observations, screenshot embedded, preflight green.
  </how-to-verify>

  <resume-signal>
    Operator types one of:
    - `approved` (PASS verdict recorded + preflight green + files committed)
    - `approved-fail` (FAIL verdict recorded + follow-up todo created; Phase 7 still closes per D-25)
    - `blocked: <reason>` (e.g., LDtk version mismatch unresolvable, GUI crash unrecoverable — escalate before continuing)
  </resume-signal>
</task>

</tasks>

<threat_model>
## Trust Boundaries

| Boundary | Description |
|----------|-------------|
| LDtk GUI → repo file | LDtk authors the `.ldtk` JSON; integrity = whatever LDtk emits. No additional validation in Phase 7 (Phase 8 LdtkLoader is where load-time integrity gates land) |
| operator → SMOKE-NOTES.md verdict | Subjective gate per D-23 — qualitative judgment is the success criterion |

## STRIDE Threat Register

| Threat ID | Category | Component | Disposition | Mitigation Plan |
|-----------|----------|-----------|-------------|-----------------|
| T-07-08-T | Tampering | `.ldtk` file authored with wrong chunk dimensions (operator typo in worldX/worldY) | mitigate | SMOKE-NOTES.md table pins the exact 9 worldX/worldY/pxWid/pxHei values; operator cross-checks the table while authoring; any mismatch is visible in the LDtk world preview AND in `git diff` of the `.ldtk` JSON |
| T-07-08-T2 | Tampering | atlas-hash drift between smoke `.ldtk` and atlas-mvp.png | accept | `lint-atlas-hash.mjs` (Plan 07-06) excludes `maps/_smoke/` by design — the smoke `.ldtk` is throwaway content; if it ever escapes the `_smoke/` filter into production paths, lint will catch it then |
| T-07-08-R | Repudiation | future operator forgets what passed or failed | mitigate | SMOKE-NOTES.md PASS/FAIL block survives milestone archive as decision audit trail per D-24 |
| T-07-08-SC | Tampering (supply chain) | LDtk binary (desktop app, not an npm dep) | accept | LDtk is operator-installed Electron app; supply-chain risk identical to any other operator dev tool; pinned version is `1.5.3` per ADR 0012 + operator-trust per D-12 |
</threat_model>

<verification>
- File `maps/_smoke/synth-8000x6400.ldtk` exists after Task 2
- `SMOKE-NOTES.md` contains a non-placeholder `## Verdict` line (PASS or FAIL chosen, rationale non-empty)
- `SMOKE-NOTES.md` Per-chunk table has at least 3 chunks with all of (Open, Paint-fill, Save) filled — minimum representative subset per D-23
- `smoke-screenshot.png` exists at `.planning/phases/07-workflow-smoke-convention-locks/smoke-screenshot.png`
- `pnpm preflight` still exits 0 after the smoke `.ldtk` lands (verifies `lint-atlas-hash.mjs` _smoke/ filter works)
- `pnpm trace:check` continues to exit 0 (HYG-01, HYG-02, MAP-15 doc + impl coverage stable)
</verification>

<success_criteria>
Operator authors all 9 chunks at exact ADR 0011 dimensions; opens + saves at least CENTER + one corner + one edge; records subjective lag impressions in SMOKE-NOTES.md; PASS or FAIL verdict recorded with rationale; screenshot committed; `pnpm preflight` still green; Phase 7 closes per D-25 (FAIL does not block close — only triggers follow-up).
</success_criteria>

<output>
Create `.planning/phases/07-workflow-smoke-convention-locks/07-08-SUMMARY.md` when done. SUMMARY should include the PASS/FAIL verdict + a note on whether D-09/D-10 are confirmed locked or need re-opening.
</output>


Wave 4: 2 tasks. Task 1 = scaffold SMOKE-NOTES.md (auto). Task 2 = operator UAT in LDtk GUI (cannot be subagent-driven). Dispatch executor for Task 1; it'll return at checkpoint for operator.


Bash

cd C:/Users/decid/Documents/projects/rebno && git rev-parse HEAD

Wave 4 base


Agent

Execute plan 07-08 Task 1 scaffold

Prompt:
<objective>
Execute plan 07-08 of phase 07-workflow-smoke-convention-locks.
Task 1 is autonomous (write SMOKE-NOTES.md scaffold + commit).
Task 2 is `checkpoint:human-verify` (blocking) — at the checkpoint, RETURN with the standard checkpoint payload. Do NOT attempt to perform the operator's LDtk GUI work; do NOT write the smoke-screenshot.png or the `.ldtk` file; do NOT write the final SUMMARY.md (that happens after operator verdict).
Do NOT update STATE.md or ROADMAP.md.
</objective>

<worktree_branch_check>
FIRST ACTION: HEAD assertion before reset/checkout.
```bash
HEAD_REF=$(git symbolic-ref --quiet HEAD || echo "DETACHED")
ACTUAL_BRANCH=$(git rev-parse --abbrev-ref HEAD)
if [ "$HEAD_REF" = "DETACHED" ] || echo "$ACTUAL_BRANCH" | grep -Eq '^(main|master|develop|trunk|release/.*)$'; then
  echo "FATAL (#2924)." >&2; exit 1
fi
if ! echo "$ACTUAL_BRANCH" | grep -Eq '^worktree-agent-[A-Za-z0-9._/-]+$'; then
  echo "FATAL: not worktree-agent-* (#2924)." >&2; exit 1
fi
ACTUAL_BASE=$(git merge-base HEAD f34645cf0bbe2e29cd87c62c4cf0ca02e3c0e424)
if [ "$ACTUAL_BASE" != "f34645cf0bbe2e29cd87c62c4cf0ca02e3c0e424" ]; then
  git reset --hard f34645cf0bbe2e29cd87c62c4cf0ca02e3c0e424
fi
```
**KNOWN failure modes:** all Write/Edit calls MUST target worktree-relative absolute paths. NEVER run `git stash` inside worktree.
</worktree_branch_check>

<parallel_execution>
Sole executor in git worktree. Run `git commit` normally with hooks.
IMPORTANT: Do NOT modify STATE.md or ROADMAP.md.
For this plan: Task 1 commits the scaffold; Task 2 returns checkpoint state — NO SUMMARY.md commit until operator verdict lands.
</parallel_execution>

<execution_context>
@$HOME/.claude/get-shit-done/workflows/execute-plan.md
@$HOME/.claude/get-shit-done/templates/summary.md
@$HOME/.claude/get-shit-done/references/checkpoints.md
@$HOME/.claude/get-shit-done/references/worktree-path-safety.md
</execution_context>

<files_to_read>
- .planning/phases/07-workflow-smoke-convention-locks/07-08-PLAN.md
- .planning/phases/07-workflow-smoke-convention-locks/07-CONTEXT.md
- .planning/phases/07-workflow-smoke-convention-locks/07-PATTERNS.md
- docs/adr/0011-bncentral-gridvania-chunking.md
- .planning/PROJECT.md
- .planning/STATE.md
- ./CLAUDE.md
</files_to_read>

<success_criteria>
- [ ] Task 1: SMOKE-NOTES.md scaffold written + committed (all 9 chunk rows with literal worldX/worldY values per ADR 0011, doc->REQ-MAP-02 tag, PASS/FAIL placeholder, Escalation H2)
- [ ] Task 2: return checkpoint:human-verify payload — do NOT attempt LDtk work
- [ ] No `git stash` invocations
</success_criteria>


<owl_reachability_notice>
You have an active owl perch. Launch this Agent with run_in_background: true so you stay reachable for incoming messages while it works.
</owl_reachability_notice>


Async agent launched successfully.
agentId: a54eb66d0208db13b (internal ID - do not mention to user. Use SendMessage with to: 'a54eb66d0208db13b' to continue this agent.)
The agent is working in the background. You will be notified automatically when it completes.
Do not duplicate this agent's work — avoid working with the same files or topics it is using. Work on non-overlapping tasks, or briefly tell the user what you launched and end your response.
output_file: C:\Users\decid\AppData\Local\Temp\claude\C--Users-decid-Documents-projects-rebno\f861f8f8-d0e8-43fc-89f5-878315496d8a\tasks\a54eb66d0208db13b.output
Do NOT Read or tail this file via the shell tool — it is the full sub-agent JSONL transcript and reading it will overflow your context. If the user asks for progress, say the agent is still running; you'll get a completion notification.

Execute plan 07-08 Task 1 scaffold

Prompt:
<objective>
Execute plan 07-08 of phase 07-workflow-smoke-convention-locks.
Task 1 is autonomous (write SMOKE-NOTES.md scaffold + commit).
Task 2 is `checkpoint:human-verify` (blocking) — at the checkpoint, RETURN with the standard checkpoint payload. Do NOT attempt to perform the operator's LDtk GUI work; do NOT write the smoke-screenshot.png or the `.ldtk` file; do NOT write the final SUMMARY.md (that happens after operator verdict).
Do NOT update STATE.md or ROADMAP.md.
</objective>

<worktree_branch_check>
FIRST ACTION: HEAD assertion before reset/checkout.
```bash
HEAD_REF=$(git symbolic-ref --quiet HEAD || echo "DETACHED")
ACTUAL_BRANCH=$(git rev-parse --abbrev-ref HEAD)
if [ "$HEAD_REF" = "DETACHED" ] || echo "$ACTUAL_BRANCH" | grep -Eq '^(main|master|develop|trunk|release/.*)$'; then
  echo "FATAL (#2924)." >&2; exit 1
fi
if ! echo "$ACTUAL_BRANCH" | grep -Eq '^worktree-agent-[A-Za-z0-9._/-]+$'; then
  echo "FATAL: not worktree-agent-* (#2924)." >&2; exit 1
fi
ACTUAL_BASE=$(git merge-base HEAD f34645cf0bbe2e29cd87c62c4cf0ca02e3c0e424)
if [ "$ACTUAL_BASE" != "f34645cf0bbe2e29cd87c62c4cf0ca02e3c0e424" ]; then
  git reset --hard f34645cf0bbe2e29cd87c62c4cf0ca02e3c0e424
fi
```
**KNOWN failure modes:** all Write/Edit calls MUST target worktree-relative absolute paths. NEVER run `git stash` inside worktree.
</worktree_branch_check>

<parallel_execution>
Sole executor in git worktree. Run `git commit` normally with hooks.
IMPORTANT: Do NOT modify STATE.md or ROADMAP.md.
For this plan: Task 1 commits the scaffold; Task 2 returns checkpoint state — NO SUMMARY.md commit until operator verdict lands.
</parallel_execution>

<execution_context>
@$HOME/.claude/get-shit-done/workflows/execute-plan.md
@$HOME/.claude/get-shit-done/templates/summary.md
@$HOME/.claude/get-shit-done/references/checkpoints.md
@$HOME/.claude/get-shit-done/references/worktree-path-safety.md
</execution_context>

<files_to_read>
- .planning/phases/07-workflow-smoke-convention-locks/07-08-PLAN.md
- .planning/phases/07-workflow-smoke-convention-locks/07-CONTEXT.md
- .planning/phases/07-workflow-smoke-convention-locks/07-PATTERNS.md
- docs/adr/0011-bncentral-gridvania-chunking.md
- .planning/PROJECT.md
- .planning/STATE.md
- ./CLAUDE.md
</files_to_read>

<success_criteria>
- [ ] Task 1: SMOKE-NOTES.md scaffold written + committed (all 9 chunk rows with literal worldX/worldY values per ADR 0011, doc->REQ-MAP-02 tag, PASS/FAIL placeholder, Escalation H2)
- [ ] Task 2: return checkpoint:human-verify payload — do NOT attempt LDtk work
- [ ] No `git stash` invocations
</success_criteria>


Dispatched 07-08 scaffold executor. Awaiting checkpoint return.


<task-notification>
<task-id>a54eb66d0208db13b</task-id>
<tool-use-id>toolu_015SxeKXN1a96TnMmVzc3wQ7</tool-use-id>
<output-file>C:\Users\decid\AppData\Local\Temp\claude\C--Users-decid-Documents-projects-rebno\f861f8f8-d0e8-43fc-89f5-878315496d8a\tasks\a54eb66d0208db13b.output</output-file>
<status>completed</status>
<summary>Agent "Execute plan 07-08 Task 1 scaffold" completed</summary>
<result>Task 1 committed cleanly. Task 2 is `checkpoint:human-verify gate="blocking"` — operator LDtk GUI work. Per the objective, I do NOT attempt the LDtk authoring, do NOT write `smoke-screenshot.png` or the `.ldtk` file, and do NOT write SUMMARY.md (that happens after operator verdict). Returning the structured checkpoint payload.

## CHECKPOINT REACHED

**Type:** human-verify
**Plan:** 07-08
**Progress:** 1/2 tasks complete

### Completed Tasks

| Task | Name                                                                                | Commit  | Files                                                                       |
| ---- | ------------------------------------------------------------------------------------- | ------- | --------------------------------------------------------------------------- |
| 1    | Write SMOKE-NOTES.md template scaffold for the operator                               | 283dda4 | .planning/phases/07-workflow-smoke-convention-locks/SMOKE-NOTES.md (new)    |

Scaffold contents:
- H1 `# Phase 7 Smoke Test — maps/_smoke/synth-8000x6400.ldtk`
- Metadata block (operator/date/LDtk version/source ADR)
- `[doc->REQ-MAP-02]` on its own line
- `## Authoring recipe followed` 5-item checklist (D-22 / D-23 inputs)
- `## Per-chunk subjective lag` table — all 9 rows with literal worldX/worldY/pxWid/pxHei values verbatim from ADR 0011 D-10 (2668, 2664, 2132, 2136, 5332, 4268 all present)
- `## Screenshot` with `![ldtk-3x3-smoke](./smoke-screenshot.png)` embed
- `## Verdict` with `**PASS / FAIL** — <verdict>.` placeholder
- `## Escalation (if FAIL)` referencing D-25 re-open of D-09/D-10

Automated verify: `grep` for "Phase 7 Smoke Test", "doc->REQ-MAP-02", "2668", "PASS / FAIL" — all PASS.

### Current Task

**Task 2:** Operator authors maps/_smoke/synth-8000x6400.ldtk + completes SMOKE-NOTES.md UAT
**Status:** awaiting verification (blocking-human, GUI-bound)
**Blocked by:** Operator must perform LDtk 1.5.3 desktop GUI work — Claude cannot author `.ldtk` files in a desktop GUI, take editor screenshots, or evaluate subjective lag impressions.

### Checkpoint Details

The scaffold at `.planning/phases/07-workflow-smoke-convention-locks/SMOKE-NOTES.md` is ready to fill. Operator steps (from plan `<how-to-verify>`):

1. **Confirm LDtk version**: open LDtk 1.5.3; About dialog must show `1.5.3` matching `tools/ldtk-version.txt`. If mismatch, fix the pin file or upgrade LDtk before proceeding.

2. **Create the LDtk file**: in LDtk 1.5.3, New Project at `maps/_smoke/synth-8000x6400.ldtk` (create `maps/_smoke/` dir first). Project settings: gridSize = 4 on ALL layer types (per ADR 0009 D-01); World layout = GridVania (per ADR 0011). One IntGrid layer + one Tile layer; no Entity layer (D-22).

3. **Define a BORDERED tile species**: import any simple atlas PNG; define one distinct tile selection for paint-fill.

4. **Author all 9 chunks** at the EXACT ADR 0011 dimensions (use LDtk "Set level coordinates" — do NOT drag-position):

   | Chunk  | worldX | worldY | pxWid | pxHei |
   |--------|--------|--------|-------|-------|
   | NW     | 0      | 0      | 2668  | 2132  |
   | N      | 2668   | 0      | 2664  | 2132  |
   | NE     | 5332   | 0      | 2668  | 2132  |
   | W      | 0      | 2132   | 2668  | 2136  |
   | CENTER | 2668   | 2132   | 2664  | 2136  |
   | E      | 5332   | 2132   | 2668  | 2136  |
   | SW     | 0      | 4268   | 2668  | 2132  |
   | S      | 2668   | 4268   | 2664  | 2132  |
   | SE     | 5332   | 4268   | 2668  | 2132  |

5. **Open + paint-fill + save representative subset** per D-23: minimum CENTER + one corner (NW recommended) + one edge (N recommended). Bonus: all 9 if stronger signal wanted.

6. **Fill SMOKE-NOTES.md per-chunk lag table** with qualitative descriptors (`instant`, `<1s noticeable but tolerable`, `>2s lag`, etc.). Each opened chunk MUST have Open, Paint-fill, and Save columns filled (PITFALLS.md #6 multi-state coverage).

7. **Take a screenshot** of the LDtk editor showing the 3×3 world layout. Save as `.planning/phases/07-workflow-smoke-convention-locks/smoke-screenshot.png`.

8. **Write the verdict**: replace `**PASS / FAIL** — <verdict>.` with `**PASS — <one-sentence summary>**` (workflow tolerable) or `**FAIL — <one-sentence summary>**` (workflow unworkable).

9. **If FAIL**: do NOT block Phase 7 (per D-25 informational only). Add a tracked item under `.planning/todos/pending/` recording the FAIL + proposed alternative chunk grid.

10. **If PASS**: commit `maps/_smoke/synth-8000x6400.ldtk` + `SMOKE-NOTES.md` (updated) + `smoke-screenshot.png` with message `feat(07): operator smoke test PASS for ADR 0011 3×3 GridVania`.

11. **Re-run `pnpm preflight`** as final sanity check — `lint-atlas-hash.mjs` excludes `maps/_smoke/` so it MUST still exit 0.

### Awaiting

Operator types one of:
- `approved` — PASS verdict recorded + preflight green + files committed
- `approved-fail` — FAIL verdict recorded + follow-up todo created (Phase 7 still closes per D-25)
- `blocked: <reason>` — e.g., LDtk version mismatch unresolvable, GUI crash unrecoverable

Per the spawn objective: no SUMMARY.md, STATE.md, or ROADMAP.md updates will happen until the operator verdict lands.

### Relevant Paths

- Scaffold (committed): `C:\Users\decid\Documents\projects\rebno\.claude\worktrees\agent-a54eb66d0208db13b\.planning\phases\07-workflow-smoke-convention-locks\SMOKE-NOTES.md`
- Plan: `C:\Users\decid\Documents\projects\rebno\.claude\worktrees\agent-a54eb66d0208db13b\.planning\phases\07-workflow-smoke-convention-locks\07-08-PLAN.md`
- ADR (chunk-grid source of truth): `C:\Users\decid\Documents\projects\rebno\.claude\worktrees\agent-a54eb66d0208db13b\docs\adr\0011-bncentral-gridvania-chunking.md`
- LDtk pin: `C:\Users\decid\Documents\projects\rebno\.claude\worktrees\agent-a54eb66d0208db13b\tools\ldtk-version.txt`
- Operator-target paths (to be created by operator in Task 2):
  - `maps\_smoke\synth-8000x6400.ldtk`
  - `.planning\phases\07-workflow-smoke-convention-locks\smoke-screenshot.png`</result>
<usage><total_tokens>81195</total_tokens><tool_uses>9</tool_uses><duration_ms>90893</duration_ms></usage>
<worktree><worktreePath>C:\Users\decid\Documents\projects\rebno\.claude\worktrees\agent-a54eb66d0208db13b</worktreePath><worktreeBranch>worktree-agent-a54eb66d0208db13b</worktreeBranch></worktree>
</task-notification>


<owl_messages>
<owl_message from="dunsen-w143" priority="info">[WORKING_PERCH_NOTICE] Subagent working perch created.
Perch: dunsen-w143
Agent type: gsd-executor
To message it: $OWL deliver dunsen-w143 dunsen</owl_message>
</owl_messages>

[OWL SYSTEM] Informational owl messages above — no acknowledgment needed. Continue your current task.

<owl_reachability_notice>
You have an active owl perch. When spawning subagents or doing work, use run_in_background: true so you stay reachable for incoming messages.
</owl_reachability_notice>


CAVEMAN MODE ACTIVE (full). Drop articles/filler/pleasantries/hedging. Fragments OK. Code/commits/security: write normal.


[checkpoint] phase 07 wave 4/4 plan 07-08 checkpoint (7/8 plans done)

Scaffold committed. Merging to main so operator can work directly.


Bash

cd C:/Users/decid/Documents/projects/rebno
git worktree unlock C:/Users/decid/Documents/projects/rebno/.claude/worktrees/agent-a54eb66d0208db13b 2>&1 || true
git merge worktree-agent-a54eb66d0208db13b --no-ff --no-edit -m "chore: merge executor worktree (worktree-agent-a54eb66d0208db13b) — 07-08 Task 1 scaffold" 2>&1 | tail -5
git worktree remove C:/Users/decid/Documents/projects/rebno/.claude/worktrees/agent-a54eb66d0208db13b --force 2>&1
git branch -D worktree-agent-a54eb66d0208db13b 2>&1
git worktree prune
ls .planning/phases/07-workflow-smoke-convention-locks/SMOKE-NOTES.md 2>&1

Merge + cleanup scaffold worktree


Merge made by the 'ort' strategy.
 .../SMOKE-NOTES.md                                 | 44 ++++++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 .planning/phases/07-workflow-smoke-convention-locks/SMOKE-NOTES.md
error: failed to delete 'C:/Users/decid/Documents/projects/rebno/.claude/worktrees/agent-a54eb66d0208db13b': Permission denied
Deleted branch worktree-agent-a54eb66d0208db13b (was 283dda4).
.planning/phases/07-workflow-smoke-convention-locks/SMOKE-NOTES.md


Scaffold landed on main. Worktree dir delete permission-denied (FS lock); branch removed. Scaffold ready for operator to fill.

## Checkpoint — Operator UAT (Plan 07-08 Task 2, blocking)

**Scaffold:** `.planning/phases/07-workflow-smoke-convention-locks/SMOKE-NOTES.md` (committed, ready to fill)

**Operator work (LDtk 1.5.3 GUI required):**
1. Confirm LDtk 1.5.3 matches `tools/ldtk-version.txt`
2. New Project → `maps/_smoke/synth-8000x6400.ldtk` (gridSize=4 on all layers, GridVania)
3. Author 9 chunks at ADR 0011 dims (NW/N/NE/W/CENTER/E/SW/S/SE — verbatim worldX/worldY/pxWid/pxHei in scaffold table; use "Set level coordinates", not drag)
4. Open + paint-fill + save subset: CENTER + 1 corner + 1 edge minimum (D-23)
5. Fill per-chunk lag table (qualitative descriptors; Open/Paint-fill/Save columns all populated per PITFALLS #6)
6. Screenshot → `.planning/phases/07-workflow-smoke-convention-locks/smoke-screenshot.png`
7. Write verdict in `## Verdict` (PASS or FAIL + rationale)
8. Commit `maps/_smoke/synth-8000x6400.ldtk` + `SMOKE-NOTES.md` + `smoke-screenshot.png` with `feat(07): operator smoke test PASS for ADR 0011 3×3 GridVania`
9. Re-run `pnpm preflight` (must still exit 0 — `_smoke/` excluded by lint-atlas-hash)

Note: `pnpm preflight` currently fails on preexisting trace:check findings (HYG-02 lock-only scope). Re-evaluate after Phase 7 close.


AskUserQuestion

Question: Plan 07-08 operator UAT — LDtk smoke test on synth 8000×6400 3×3 GridVania world. How proceed?

Choices:
Authored .ldtk, filled SMOKE-NOTES.md with PASS verdict + screenshot, committed feat(07) commit. Phase 7 closes.
Authored .ldtk, FAIL verdict recorded + follow-up todo created under .planning/todos/pending/. Phase 7 still closes per D-25.
Skip LDtk authoring this session; record SMOKE-NOTES.md status=deferred + carry as v1.2 prerequisite. Phase 7 closes with operator todo.
Cannot do UAT now (LDtk install issue, time, etc.). Halt phase execution; resume later.


User has answered your questions: "Plan 07-08 operator UAT — LDtk smoke test on synth 8000×6400 3×3 GridVania world. How proceed?"="please walk me through steps 2 thru 5, one action at a time". You can now continue with the user's answers in mind.

Question: Plan 07-08 operator UAT — LDtk smoke test on synth 8000×6400 3×3 GridVania world. How proceed?

Choices:
Authored .ldtk, filled SMOKE-NOTES.md with PASS verdict + screenshot, committed feat(07) commit. Phase 7 closes.
Authored .ldtk, FAIL verdict recorded + follow-up todo created under .planning/todos/pending/. Phase 7 still closes per D-25.
Skip LDtk authoring this session; record SMOKE-NOTES.md status=deferred + carry as v1.2 prerequisite. Phase 7 closes with operator todo.
Cannot do UAT now (LDtk install issue, time, etc.). Halt phase execution; resume later.

please walk me through steps 2 thru 5, one action at a time


- autoplan: Auto-review pipeline — reads the full CEO, design, eng, and DX review skills from disk
and runs them sequentially with auto-decisions using 6 decision principles. Surfaces
taste decisions (close approaches, borderline scope, codex disagreements) at a final
approval gate. One command, fully reviewed plan out.
Use when asked to "auto review", "autoplan", "run all reviews", "review this plan
automatically", or "make the decisions for me".
Proactively suggest when the user has a plan file and wants to run the full review
gauntlet without answering 15-30 intermediate questions. (gstack)
- benchmark: Performance regression detection using the browse daemon. Establishes
baselines for page load times, Core Web Vitals, and resource sizes.
Compares before/after on every PR. Tracks performance trends over time.
Use when: "performance", "benchmark", "page speed", "lighthouse", "web vitals",
"bundle size", "load time". (gstack)
- browse: Fast headless browser for QA testing and site dogfooding. Navigate any URL, interact with
elements, verify page state, diff before/after actions, take annotated screenshots, check
responsive layouts, test forms and uploads, handle dialogs, and assert element states.
~100ms per command. Use when you need to test a feature, verify a deployment, dogfood a
user flow, or file a bug with evidence. Use when asked to "open in browser", "test the
site", "take a screenshot", or "dogfood this". (gstack)
- canary: Post-deploy canary monitoring. Watches the live app for console errors,
performance regressions, and page failures using the browse daemon. Takes
periodic screenshots, compares against pre-deploy baselines, and alerts
on anomalies. Use when: "monitor deploy", "canary", "post-deploy check",
"watch production", "verify deploy". (gstack)
- careful: Safety guardrails for destructive commands. Warns before rm -rf, DROP TABLE,
force-push, git reset --hard, kubectl delete, and similar destructive operations.
User can override each warning. Use when touching prod, debugging live systems,
or working in a shared environment. Use when asked to "be careful", "safety mode",
"prod mode", or "careful mode". (gstack)
- caveman: Ultra-compressed communication mode. Cuts token usage ~75% by dropping filler, articles, and pleasantries while keeping full technical accuracy. Use when user says "caveman mode", "talk like caveman", "use caveman", "less tokens", "be brief", or invokes /caveman.
- ccs-delegation: Auto-activate CCS CLI delegation for deterministic tasks. Parses user input, auto-selects optimal profile (glm/kimi/custom) from ~/.ccs/config.json, enhances prompts with context, executes via `ccs {profile} -p "task"` or `ccs {profile}:continue`, and reports results. Triggers on "use ccs [task]" patterns, typo/test/refactor keywords. Excludes complex architecture, security-critical code, performance optimization, breaking changes.
- checkpoint: Save and resume working state checkpoints. Captures git state, decisions made,
and remaining work so you can pick up exactly where you left off — even across
Conductor workspace handoffs between branches.
Use when asked to "checkpoint", "save progress", "where was I", "resume",
"what was I working on", or "pick up where I left off".
Proactively suggest when a session is ending, the user is switching context,
or before a long break. (gstack)
- codex: OpenAI Codex CLI wrapper — three modes. Code review: independent diff review via
codex review with pass/fail gate. Challenge: adversarial mode that tries to break
your code. Consult: ask codex anything with session continuity for follow-ups.
The "200 IQ autistic developer" second opinion. Use when asked to "codex review",
"codex challenge", "ask codex", "second opinion", or "consult codex". (gstack)
- connect-chrome: Launch GStack Browser — AI-controlled Chromium with the sidebar extension baked in.
Opens a visible browser window where you can watch every action in real time.
The sidebar shows a live activity feed and chat. Anti-bot stealth built in.
Use when asked to "open gstack browser", "launch browser", "connect chrome",
"open chrome", "real browser", "launch chrome", "side panel", or "control my browser".
- cso: Chief Security Officer mode. Infrastructure-first security audit: secrets archaeology,
dependency supply chain, CI/CD pipeline security, LLM/AI security, skill supply chain
scanning, plus OWASP Top 10, STRIDE threat modeling, and active verification.
Two modes: daily (zero-noise, 8/10 confidence gate) and comprehensive (monthly deep
scan, 2/10 bar). Trend tracking across audit runs.
Use when: "security audit", "threat model", "pentest review", "OWASP", "CSO review". (gstack)
- design-consultation: Design consultation: understands your product, researches the landscape, proposes a
complete design system (aesthetic, typography, color, layout, spacing, motion), and
generates font+color preview pages. Creates DESIGN.md as your project's design source
of truth. For existing sites, use /plan-design-review to infer the system instead.
Use when asked to "design system", "brand guidelines", or "create DESIGN.md".
Proactively suggest when starting a new project's UI with no existing
design system or DESIGN.md. (gstack)
- design-html: Design finalization: generates production-quality Pretext-native HTML/CSS.
Works with approved mockups from /design-shotgun, CEO plans from /plan-ceo-review,
design review context from /plan-design-review, or from scratch with a user
description. Text actually reflows, heights are computed, layouts are dynamic.
30KB overhead, zero deps. Smart API routing: picks the right Pretext patterns
for each design type. Use when: "finalize this design", "turn this into HTML",
"build me a page", "implement this design", or after any planning skill.
Proactively suggest when user has approved a design or has a plan ready. (gstack)
- design-review: Designer's eye QA: finds visual inconsistency, spacing issues, hierarchy problems,
AI slop patterns, and slow interactions — then fixes them. Iteratively fixes issues
in source code, committing each fix atomically and re-verifying with before/after
screenshots. For plan-mode design review (before implementation), use /plan-design-review.
Use when asked to "audit the design", "visual QA", "check if it looks good", or "design polish".
Proactively suggest when the user mentions visual inconsistencies or
wants to polish the look of a live site. (gstack)
- design-shotgun: Design shotgun: generate multiple AI design variants, open a comparison board,
collect structured feedback, and iterate. Standalone design exploration you can
run anytime. Use when: "explore designs", "show me options", "design variants",
"visual brainstorm", or "I don't like how this looks".
Proactively suggest when the user describes a UI feature but hasn't seen
what it could look like. (gstack)
- devex-review: Live developer experience audit. Uses the browse tool to actually TEST the
developer experience: navigates docs, tries the getting started flow, times
TTHW, screenshots error messages, evaluates CLI help text. Produces a DX
scorecard with evidence. Compares against /plan-devex-review scores if they
exist (the boomerang: plan said 3 minutes, reality says 8). Use when asked to
"test the DX", "DX audit", "developer experience test", or "try the
onboarding". Proactively suggest after shipping a developer-facing feature. (gstack)
- diagnose: Disciplined diagnosis loop for hard bugs and performance regressions. Reproduce → minimise → hypothesise → instrument → fix → regression-test. Use when user says "diagnose this" / "debug this", reports a bug, says something is broken/throwing/failing, or describes a performance regression.
- document-release: Post-ship documentation update. Reads all project docs, cross-references the
diff, updates README/ARCHITECTURE/CONTRIBUTING/CLAUDE.md to match what shipped,
polishes CHANGELOG voice, cleans up TODOS, and optionally bumps VERSION. Use when
asked to "update the docs", "sync documentation", or "post-ship docs".
Proactively suggest after a PR is merged or code is shipped. (gstack)
- find-skills: Helps users discover and install agent skills when they ask questions like "how do I do X", "find a skill for X", "is there a skill that can...", or express interest in extending capabilities. This skill should be used when the user is looking for functionality that might exist as an installable skill.
- freeze: Restrict file edits to a specific directory for the session. Blocks Edit and
Write outside the allowed path. Use when debugging to prevent accidentally
"fixing" unrelated code, or when you want to scope changes to one module.
Use when asked to "freeze", "restrict edits", "only edit this folder",
or "lock down edits". (gstack)
- grill-me: Interview the user relentlessly about a plan or design until reaching shared understanding, resolving each branch of the decision tree. Use when user wants to stress-test a plan, get grilled on their design, or mentions "grill me".
- grill-with-docs: Grilling session that challenges your plan against the existing domain model, sharpens terminology, and updates documentation (CONTEXT.md, ADRs) inline as decisions crystallise. Use when user wants to stress-test a plan against their project's language and documented decisions.
- gsd-add-tests: Generate tests for a completed phase based on UAT criteria and implementation
- gsd-ai-integration-phase: Generate an AI-SPEC.md design contract for phases that involve building AI systems.
- gsd-audit-fix: Autonomous audit-to-fix pipeline — find issues, classify, fix, test, commit
- gsd-audit-milestone: Audit milestone completion against original intent before archiving
- gsd-audit-uat: Cross-phase audit of all outstanding UAT and verification items
- gsd-autonomous: Run all remaining phases autonomously — discuss→plan→execute per phase
- gsd-capture: Capture ideas, tasks, notes, and seeds to their destination
- gsd-cleanup: Archive accumulated phase directories from completed milestones
- gsd-code-review: Review source files changed during a phase for bugs, security issues, and code quality problems
- gsd-complete-milestone: Archive completed milestone and prepare for next version
- gsd-config: Configure GSD settings — workflow toggles, advanced knobs, integrations, and model profile
- gsd-debug: Systematic debugging with persistent state across context resets
- gsd-discuss-phase: Gather phase context through adaptive questioning before planning.
- gsd-docs-update: Generate or update project documentation verified against the codebase
- gsd-eval-review: Audit an executed AI phase's evaluation coverage and produce an EVAL-REVIEW.md remediation plan.
- gsd-execute-phase: Execute all plans in a phase with wave-based parallelization
- gsd-explore: Socratic ideation and idea routing — think through ideas before committing to plans
- gsd-extract-learnings: Extract decisions, lessons, patterns, and surprises from completed phase artifacts
- gsd-fast: Execute a trivial task inline — no subagents, no planning overhead
- gsd-forensics: Post-mortem investigation for failed GSD workflows — diagnoses what went wrong.
- gsd-graphify: Build, query, and inspect the project knowledge graph in .planning/graphs/
- gsd-health: Diagnose planning directory health and optionally repair issues
- gsd-help: Show available GSD commands and usage guide
- gsd-import: Ingest external plans with conflict detection against project decisions before writing anything.
- gsd-inbox: Triage and review open GitHub issues and PRs against project templates and contribution guidelines.
- gsd-ingest-docs: Bootstrap or merge a .planning/ setup from existing ADRs, PRDs, SPECs, and docs in a repo.
- gsd-manager: Interactive command center for managing multiple phases from one terminal
- gsd-map-codebase: Analyze codebase with parallel mapper agents to produce .planning/codebase/ documents
- gsd-milestone-summary: Generate a comprehensive project summary from milestone artifacts for team onboarding and review
- gsd-mvp-phase: Plan a phase as a vertical MVP slice — user story, SPIDR splitting, then plan-phase
- gsd-new-milestone: Start a new milestone cycle — update PROJECT.md and route to requirements
- gsd-new-project: Initialize a new project with deep context gathering and PROJECT.md
- gsd-ns-context: codebase intelligence | map graphify docs learnings
- gsd-ns-ideate: exploration capture | explore sketch spike spec capture
- gsd-ns-manage: config workspace | workstreams thread update ship inbox
- gsd-ns-project: project lifecycle | milestones audits summary
- gsd-ns-review: quality gates | code review debug audit security eval ui
- gsd-ns-workflow: workflow | discuss plan execute verify phase progress
- gsd-pause-work: Create context handoff when pausing work mid-phase
- gsd-phase: CRUD for phases in ROADMAP.md — add, insert, remove, or edit phases
- gsd-plan-phase: Create detailed phase plan (PLAN.md) with verification loop
- gsd-plan-review-convergence: Cross-AI plan convergence loop — replan with review feedback until no HIGH concerns remain.
- gsd-pr-branch: Create a clean PR branch by filtering out .planning/ commits — ready for code review
- gsd-profile-user: Generate developer behavioral profile and create Claude-discoverable artifacts
- gsd-progress: Check progress, advance workflow, or dispatch freeform intent — the unified GSD situational command
- gsd-quick: Execute a quick task with GSD guarantees (atomic commits, state tracking) but skip optional agents
- gsd-resume-work: Resume work from previous session with full context restoration
- gsd-review: Request cross-AI peer review of phase plans from external AI CLIs
- gsd-review-backlog: Review and promote backlog items to active milestone
- gsd-secure-phase: Retroactively verify threat mitigations for a completed phase
- gsd-settings: Configure GSD workflow toggles and model profile
- gsd-ship: Create PR, run review, and prepare for merge after verification passes
- gsd-sketch: Sketch UI/design ideas with throwaway HTML mockups, or propose what to sketch next (frontier mode)
- gsd-spec-phase: Clarify WHAT a phase delivers with ambiguity scoring; produces a SPEC.md before discuss-phase.
- gsd-spike: Spike an idea through experiential exploration, or propose what to spike next (frontier mode)
- gsd-stats: Display project statistics — phases, plans, requirements, git metrics, and timeline
- gsd-surface: Toggle which skills are surfaced — apply a profile, list, or disable a cluster without reinstall
- gsd-thread: Manage persistent context threads for cross-session work
- gsd-ui-phase: Generate UI design contract (UI-SPEC.md) for frontend phases
- gsd-ui-review: Retroactive 6-pillar visual audit of implemented frontend code
- gsd-ultraplan-phase: [BETA] Offload plan phase to Claude Code's ultraplan cloud; review in browser and import back.
- gsd-undo: Safe git revert. Roll back phase or plan commits using the phase manifest with dependency checks.
- gsd-update: Update GSD to latest version with changelog display
- gsd-validate-phase: Retroactively audit and fill Nyquist validation gaps for a completed phase
- gsd-verify-work: Validate built features through conversational UAT
- gsd-workspace: Manage GSD workspaces — create, list, or remove isolated workspace environments
- gsd-workstreams: Manage parallel workstreams — list, create, switch, status, progress, complete, and resume
- gstack: Fast headless browser for QA testing and site dogfooding. Navigate pages, interact with
elements, verify state, diff before/after, take annotated screenshots, test responsive
layouts, forms, uploads, dialogs, and capture bug evidence. Use when asked to open or
test a site, verify a deployment, dogfood a user flow, or file a bug with screenshots. (gstack)
- gstack-upgrade: Upgrade gstack to the latest version. Detects global vs vendored install,
runs the upgrade, and shows what's new. Use when asked to "upgrade gstack",
"update gstack", or "get latest version".
- guard: Full safety mode: destructive command warnings + directory-scoped edits.
Combines /careful (warns before rm -rf, DROP TABLE, force-push, etc.) with
/freeze (blocks edits outside a specified directory). Use for maximum safety
when touching prod or debugging live systems. Use when asked to "guard mode",
"full safety", "lock it down", or "maximum safety". (gstack)
- handoff: Compact the current conversation into a handoff document for another agent to pick up.
- health: Code quality dashboard. Wraps existing project tools (type checker, linter,
test runner, dead code detector, shell linter), computes a weighted composite
0-10 score, and tracks trends over time. Use when: "health check",
"code quality", "how healthy is the codebase", "run all checks",
"quality score". (gstack)
- improve-codebase-architecture: Find deepening opportunities in a codebase, informed by the domain language in CONTEXT.md and the decisions in docs/adr/. Use when the user wants to improve architecture, find refactoring opportunities, consolidate tightly-coupled modules, or make a codebase more testable and AI-navigable.
- investigate: Systematic debugging with root cause investigation. Four phases: investigate,
analyze, hypothesize, implement. Iron Law: no fixes without root cause.
Use when asked to "debug this", "fix this bug", "why is this broken",
"investigate this error", or "root cause analysis".
Proactively invoke this skill (do NOT debug directly) when the user reports
errors, 500 errors, stack traces, unexpected behavior, "it was working
yesterday", or is troubleshooting why something stopped working. (gstack)
- land-and-deploy: Land and deploy workflow. Merges the PR, waits for CI and deploy,
verifies production health via canary checks. Takes over after /ship
creates the PR. Use when: "merge", "land", "deploy", "merge and verify",
"land it", "ship it to production". (gstack)
- learn: Manage project learnings. Review, search, prune, and export what gstack
has learned across sessions. Use when asked to "what have we learned",
"show learnings", "prune stale learnings", or "export learnings".
Proactively suggest when the user asks about past patterns or wonders
"didn't we fix this before?"
- mux-send: Send keystrokes to a psmux terminal session. Use when the user says "send to",
"type in", "send keys to", "mux send", or wants to send input to another terminal
session by name.
- office-hours: YC Office Hours — two modes. Startup mode: six forcing questions that expose
demand reality, status quo, desperate specificity, narrowest wedge, observation,
and future-fit. Builder mode: design thinking brainstorming for side projects,
hackathons, learning, and open source. Saves a design doc.
Use when asked to "brainstorm this", "I have an idea", "help me think through
this", "office hours", or "is this worth building".
Proactively invoke this skill (do NOT answer directly) when the user describes
a new product idea, asks whether something is worth building, wants to think
through design decisions for something that doesn't exist yet, or is exploring
a concept before any code is written.
Use before /plan-ceo-review or /plan-eng-review. (gstack)
- open-gstack-browser: Launch GStack Browser — AI-controlled Chromium with the sidebar extension baked in.
Opens a visible browser window where you can watch every action in real time.
The sidebar shows a live activity feed and chat. Anti-bot stealth built in.
Use when asked to "open gstack browser", "launch browser", "connect chrome",
"open chrome", "real browser", "launch chrome", "side panel", or "control my browser".
- pair-agent: Pair a remote AI agent with your browser. One command generates a setup key and
prints instructions the other agent can follow to connect. Works with OpenClaw,
Hermes, Codex, Cursor, or any agent that can make HTTP requests. The remote agent
gets its own tab with scoped access (read+write by default, admin on request).
Use when asked to "pair agent", "connect agent", "share browser", "remote browser",
"let another agent use my browser", or "give browser access". (gstack)
- plan-ceo-review: CEO/founder-mode plan review. Rethink the problem, find the 10-star product,
challenge premises, expand scope when it creates a better product. Four modes:
SCOPE EXPANSION (dream big), SELECTIVE EXPANSION (hold scope + cherry-pick
expansions), HOLD SCOPE (maximum rigor), SCOPE REDUCTION (strip to essentials).
Use when asked to "think bigger", "expand scope", "strategy review", "rethink this",
or "is this ambitious enough".
Proactively suggest when the user is questioning scope or ambition of a plan,
or when the plan feels like it could be thinking bigger. (gstack)
- plan-design-review: Designer's eye plan review — interactive, like CEO and Eng review.
Rates each design dimension 0-10, explains what would make it a 10,
then fixes the plan to get there. Works in plan mode. For live site
visual audits, use /design-review. Use when asked to "review the design plan"
or "design critique".
Proactively suggest when the user has a plan with UI/UX components that
should be reviewed before implementation. (gstack)
- plan-devex-review: Interactive developer experience plan review. Explores developer personas,
benchmarks against competitors, designs magical moments, and traces friction
points before scoring. Three modes: DX EXPANSION (competitive advantage),
DX POLISH (bulletproof every touchpoint), DX TRIAGE (critical gaps only).
Use when asked to "DX review", "developer experience audit", "devex review",
or "API design review".
Proactively suggest when the user has a plan for developer-facing products
(APIs, CLIs, SDKs, libraries, platforms, docs). (gstack)
- plan-eng-review: Eng manager-mode plan review. Lock in the execution plan — architecture,
data flow, diagrams, edge cases, test coverage, performance. Walks through
issues interactively with opinionated recommendations. Use when asked to
"review the architecture", "engineering review", or "lock in the plan".
Proactively suggest when the user has a plan or design doc and is about to
start coding — to catch architecture issues before implementation. (gstack)
- propose-issue: Challenge an issue statement before fixing it. Probes scope, root cause, and assumptions
through interactive questioning grounded in the codebase. Use when the user says "propose issue",
"challenge this bug", "question this fix", "is this the right problem", or wants to pressure-test
a problem statement before jumping to implementation.
- qa: Systematically QA test a web application and fix bugs found. Runs QA testing,
then iteratively fixes bugs in source code, committing each fix atomically and
re-verifying. Use when asked to "qa", "QA", "test this site", "find bugs",
"test and fix", or "fix what's broken".
Proactively suggest when the user says a feature is ready for testing
or asks "does this work?". Three tiers: Quick (critical/high only),
Standard (+ medium), Exhaustive (+ cosmetic). Produces before/after health scores,
fix evidence, and a ship-readiness summary. For report-only mode, use /qa-only. (gstack)
- qa-only: Report-only QA testing. Systematically tests a web application and produces a
structured report with health score, screenshots, and repro steps — but never
fixes anything. Use when asked to "just report bugs", "qa report only", or
"test but don't fix". For the full test-fix-verify loop, use /qa instead.
Proactively suggest when the user wants a bug report without any code changes. (gstack)
- retro: Weekly engineering retrospective. Analyzes commit history, work patterns,
and code quality metrics with persistent history and trend tracking.
Team-aware: breaks down per-person contributions with praise and growth areas.
Use when asked to "weekly retro", "what did we ship", or "engineering retrospective".
Proactively suggest at the end of a work week or sprint. (gstack)
- review: Pre-landing PR review. Analyzes diff against the base branch for SQL safety, LLM trust
boundary violations, conditional side effects, and other structural issues. Use when
asked to "review this PR", "code review", "pre-landing review", or "check my diff".
Proactively suggest when the user is about to merge or land code changes. (gstack)
- screenshot-capture: Capture, process, and analyze screenshots of any running application on Windows 10/11. Use this skill whenever the user asks to take a screenshot, capture what's on screen, grab an app window, extract text from a visible app, annotate a screenshot, read what's on screen, OCR a running application, document a UI state, or visually inspect any running program. Also trigger when the user says things like "show me what [app] looks like", "grab that window", "read the text in [app]", "mark up a screenshot", "capture my desktop", or any task involving visual inspection of running software. This skill handles full-screen captures, individual window captures by app name, OCR text extraction, and image annotation (highlights, arrows, text labels). Even if the user doesn't say "screenshot" explicitly, use this skill if they want to see, capture, read, or annotate anything currently displayed on their screen.
- setup-browser-cookies: Import cookies from your real Chromium browser into the headless browse session.
Opens an interactive picker UI where you select which cookie domains to import.
Use before QA testing authenticated pages. Use when asked to "import cookies",
"login to the site", or "authenticate the browser". (gstack)
- setup-deploy: Configure deployment settings for /land-and-deploy. Detects your deploy
platform (Fly.io, Render, Vercel, Netlify, Heroku, GitHub Actions, custom),
production URL, health check endpoints, and deploy status commands. Writes
the configuration to CLAUDE.md so all future deploys are automatic.
Use when: "setup deploy", "configure deployment", "set up land-and-deploy",
"how do I deploy with gstack", "add deploy config".
- ship: Ship workflow: detect + merge base branch, run tests, review diff, bump VERSION,
update CHANGELOG, commit, push, create PR. Use when asked to "ship", "deploy",
"push to main", "create a PR", "merge and push", or "get it deployed".
Proactively invoke this skill (do NOT push/PR directly) when the user says code
is ready, asks about deploying, wants to push code up, or asks to create a PR. (gstack)
- to-prd: Turn the current conversation context into a PRD and publish it to the project issue tracker. Use when user wants to create a PRD from the current context.
- trace: Find old conversations in Claude Code session history. Use when the user says
"find the conversation where", "when did we discuss", "trace back to", or wants
to locate a past session by topic, command, commit, or keyword.
- traceable-reqs: traceable-reqs
- unfreeze: Clear the freeze boundary set by /freeze, allowing edits to all directories
again. Use when you want to widen edit scope without ending the session.
Use when asked to "unfreeze", "unlock edits", "remove freeze", or
"allow all edits". (gstack)
- win-marketplace-add: Add a plugin marketplace on Windows, bypassing the EBUSY rename bug. Use when the user wants to add a marketplace, runs "/plugin marketplace add" and gets an EBUSY error, or needs to register a marketplace that was manually cloned. Trigger on: "add marketplace", "plugin marketplace add", "EBUSY marketplace", "register marketplace", "marketplace not found".
- write-a-skill: Create new agent skills with proper structure, progressive disclosure, and bundled resources. Use when user wants to create, write, or build a new skill.
- ccs:continue: Continue last CCS delegation session [AUTO ENHANCE]
- ccs: Delegate task with intelligent profile selection [AUTO ENHANCE]
- frontend-design:frontend-design: Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.
- caveman:caveman: Ultra-compressed communication mode. Cuts token usage ~75% by speaking like caveman while keeping full technical accuracy. Supports intensity levels: lite, full (default), ultra, wenyan-lite, wenyan-full, wenyan-ultra. Use when user says "caveman mode", "talk like caveman", "use caveman", "less tokens", "be brief", or invokes /caveman. Also auto-triggers when token efficiency is requested.
- caveman:caveman-commit: Ultra-compressed commit message generator. Cuts noise from commit messages while preserving intent and reasoning. Conventional Commits format. Subject ≤50 chars, body only when "why" isn't obvious. Use when user says "write a commit", "commit message", "generate commit", "/commit", or invokes /caveman-commit. Auto-triggers when staging changes.
- caveman:caveman-help: Quick-reference card for all caveman modes, skills, and commands. One-shot display, not a persistent mode. Trigger: /caveman-help, "caveman help", "what caveman commands", "how do I use caveman".
- caveman:caveman-review: Ultra-compressed code review comments. Cuts noise from PR feedback while preserving the actionable signal. Each comment is one line: location, problem, fix. Use when user says "review this PR", "code review", "review the diff", "/review", or invokes /caveman-review. Auto-triggers when reviewing pull requests.
- caveman:compress: Compress natural language memory files (CLAUDE.md, todos, preferences) into caveman format to save input tokens. Preserves all technical substance, code, URLs, and structure. Compressed version overwrites the original file. Human-readable backup saved as FILE.original.md. Trigger: /caveman:compress <filepath> or "compress memory file"
- everything:search: Instantly search files and folders on Windows via voidtools Everything 1.5a HTTP JSON API. Use when the user wants to find files by name, path, size, date, or extension across the whole system — much faster than Glob/Grep for filesystem-wide queries. Triggers on "find file", "where is", "locate", "search my drive", "find all .ext files", "everything search".
- update-config: Use this skill to configure the Claude Code harness via settings.json. Automated behaviors ("from now on when X", "each time X", "whenever X", "before/after X") require hooks configured in settings.json - the harness executes these, not Claude, so memory/preferences cannot fulfill them. Also use for: permissions ("allow X", "add permission", "move permission to"), env vars ("set X=Y"), hook troubleshooting, or any changes to settings.json/settings.local.json files. Examples: "allow npm commands", "add bq permission to global settings", "move permission to user settings", "set DEBUG=true", "when claude stops show X". For simple settings like theme/model, suggest the /config command.
- keybindings-help: Use when the user wants to customize keyboard shortcuts, rebind keys, add chord bindings, or modify ~/.claude/keybindings.json. Examples: "rebind ctrl+s", "add a chord shortcut", "change the submit key", "customize keybindings".
- simplify: Review changed code for reuse, quality, and efficiency, then fix any issues found.
- fewer-permission-prompts: Scan your transcripts for common read-only Bash and MCP tool calls, then add a prioritized allowlist to project .claude/settings.json to reduce permission prompts.
- loop: Run a prompt or slash command on a recurring interval (e.g. /loop 5m /foo). Omit the interval to let the model self-pace. - When the user wants to set up a recurring task, poll for status, or run something repeatedly on an interval (e.g. "check the deploy every 5 minutes", "keep running /babysit-prs"). Do NOT invoke for one-off tasks.
- schedule: Create, update, list, or run scheduled remote agents (routines) that execute on a cron schedule. - When the user wants to schedule a recurring remote agent, set up automated tasks, create a cron job for Claude Code, or manage their scheduled agents/routines. Also use when the user wants a one-time scheduled run ("run this once at 3pm", "remind me to check X tomorrow").
- claude-api: Build, debug, and optimize Claude API / Anthropic SDK apps. Apps built with this skill should include prompt caching. Also handles migrating existing Claude API code between Claude model versions (4.5 → 4.6, 4.6 → 4.7, retired-model replacements).
TRIGGER when: code imports `anthropic`/`@anthropic-ai/sdk`; user asks for the Claude API, Anthropic SDK, or Managed Agents; user adds/modifies/tunes a Claude feature (caching, thinking, compaction, tool use, batch, files, citations, memory) or model (Opus/Sonnet/Haiku) in a file; questions about prompt caching / cache hit rate in an Anthropic SDK project.
SKIP: file imports `openai`/other-provider SDK, filename like `*-openai.py`/`*-generic.py`, provider-neutral code, general programming/ML.
- init: Initialize a new CLAUDE.md file with codebase documentation
- review: Review a pull request
- security-review: Complete a security review of the pending changes on the current branch


Phase 7 Wave 1: 5 ADR/req plans

07-01..07-05 — ADRs 0009-0012 + HYG-02 stages tighten

Phase 7 Wave 2: lint scripts

07-06 — tools/scripts lint files + HYG-01 tag

Phase 7 Wave 3: preflight wiring

07-07 — package.json + LOCAL-DEPLOY.md MANDATORY section

Phase 7 Wave 4: operator smoke gate

07-08 — operator authors synth 8000x6400 LDtk world, PASS/FAIL verdict (autonomous:false)

Phase 7 verify+complete

code-review, regression, verify_phase_goal, update_roadmap


Failed to run: Plugin directory does not exist: C:\Users\decid\.claude\plugins\cache\cplugs\spt\1.10.15 (spt@cplugs — run /plugin to reinstall)


Walking through steps 2–5, one action at a time.

---

### Step 2a — Create new LDtk project

1. Launch LDtk 1.5.3 on your machine.
2. File → **New project**
3. Save location: `C:\Users\decid\Documents\projects\rebno\maps\_smoke\synth-8000x6400.ldtk`
   - Create dir `maps\_smoke\` first if missing.

Reply **done** when project saved at that path. Or **issue: <what>** if blocked.


<local-command-caveat>Caveat: The messages below were generated by the user while running local commands. DO NOT respond to these messages or otherwise consider them in your response unless the user explicitly asks you to.</local-command-caveat>


<command-name>/reload-plugins</command-name>
            <command-message>reload-plugins</command-message>
            <command-args></command-args>


<local-command-stdout>Reloaded: 6 plugins · 0 skills · 39 agents · 9 hooks · 1 plugin MCP server · 1 plugin LSP server</local-command-stdout>


done