gm-hermes 2.0.515

package/skills/software-development/gm/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: gm
+description: Agent (not skill) - immutable programming state machine. Always invoke for all work coordination.
+---
+
+# GM — Skill-First Orchestrator
+
+**Invoke the `planning` skill immediately.** Use the Skill tool with `skill: "planning"`.
+
+**CRITICAL: Skills are invoked via the Skill tool ONLY. Do NOT use the Agent tool to load skills.**
+
+All work coordination, planning, execution, and verification happens through the skill tree starting with `planning`:
+- `planning` skill → `gm-execute` skill → `gm-emit` skill → `gm-complete` skill → `update-docs` skill
+- `memorize` sub-agent — background only, non-sequential. `Agent(subagent_type='memorize', model='haiku', run_in_background=true, prompt='## CONTEXT TO MEMORIZE\n<what was learned>')`
+
+All code execution uses `exec:<lang>` via the Bash tool — never direct `Bash(node ...)` or `Bash(npm ...)`.
+
+Do not use `EnterPlanMode`. Do not run code directly via Bash. Invoke `planning` skill first.
+
+## RESPONSE POLICY — ALWAYS ACTIVE
+
+Terse like smart caveman. Technical substance stays. Fluff dies. Default: **full**. Switch: `/caveman lite|full|ultra`.
+
+Drop: articles, filler, pleasantries, hedging. Fragments OK. Short synonyms. Technical terms exact. Code unchanged. Pattern: `[thing] [action] [reason]. [next step].`
+
+Levels: **lite** = no filler, full sentences | **full** = drop articles, fragments OK | **ultra** = abbreviate all, arrows for causality | **wenyan-full** = 文言文, 80-90% compression | **wenyan-ultra** = max classical terse.
+
+Auto-Clarity: drop caveman for security warnings, irreversible confirmations, ambiguous sequences. Resume after. Code/commits/PRs write normal. "stop caveman" / "normal mode": revert.

package/skills/software-development/gm-complete/SKILL.md

@@ -0,0 +1,185 @@
+---
+name: gm-complete
+description: VERIFY and COMPLETE phase. End-to-end system verification and git enforcement. Any new unknown triggers immediate snake back to planning — restart chain.
+---
+
+# GM COMPLETE — Verification and Completion
+
+You are in the **VERIFY → COMPLETE** phase. Files are written. Prove the whole system works end-to-end. Any new unknown = snake to `planning`, restart chain.
+
+**GRAPH POSITION**: `PLAN → EXECUTE → EMIT → [VERIFY] → UPDATE-DOCS → COMPLETE`
+- **Entry**: All EMIT gates passed. Entered from `gm-emit`.
+
+## TRANSITIONS
+
+**EXIT — .gm/prd.yml items remain**: Verified items completed, .gm/prd.yml still has pending items → invoke `gm-execute` skill immediately (next wave). Do not stop.
+
+**EXIT — COMPLETE**: .gm/prd.yml empty + test.js passes + all work pushed + CI green → invoke `update-docs` skill.
+
+**STATE REGRESSIONS**:
+- Verification reveals broken file output → invoke `gm-emit` skill, reset to EMIT state, re-verify on return
+- Verification reveals logic error → invoke `gm-execute` skill, reset to EXECUTE state, re-emit and re-verify on return
+- Verification reveals new unknown → invoke `planning` skill, reset to PLAN state
+- Verification reveals wrong requirements → invoke `planning` skill, reset to PLAN state
+
+**TRIAGE on failure**: broken file output → regress to `gm-emit` | wrong logic → regress to `gm-execute` | new unknown or wrong requirements → regress to `planning`
+
+**RULE**: Any surprise = new unknown = regress to `planning`. Never patch around surprises.
+
+## MUTABLE DISCIPLINE
+
+- `witnessed_e2e=UNKNOWN` until real end-to-end run produces witnessed output
+- `git_clean=UNKNOWN` until `exec:bash\ngit status --porcelain` returns empty
+- `git_pushed=UNKNOWN` until `git log origin/main..HEAD --oneline` returns empty
+- `ci_passed=UNKNOWN` until all GitHub Actions runs triggered by the push reach `conclusion: success`
+- `prd_empty=UNKNOWN` until `.gm/prd.yml` is deleted (not just empty — file must not exist)
+
+All five must resolve to KNOWN before COMPLETE. Any UNKNOWN = absolute barrier.
+
+## END-TO-END DIAGNOSTIC VERIFICATION
+
+Run the real system with real data. Witness actual output. This is a full-system fault-detection pass.
+
+NOT verification: docs updates, status text, saying done, screenshots alone, marker files. Unwitnessed claims are inadmissible.
+
+```
+exec:nodejs
+const { fn } = await import('/abs/path/to/module.js');
+console.log(await fn(realInput));
+```
+
+**Failure triage protocol**: when end-to-end fails, do not patch blindly. Isolate the fault:
+1. Identify which subsystem produced the unexpected output
+2. Reproduce the failure in isolation (single function, single module)
+3. Name the delta between expected and actual — this is the mutable
+4. Triage: broken file output → regress to EMIT | wrong logic → regress to EXECUTE | new unknown → regress to PLAN
+5. Never fix a symptom without identifying and fixing the root cause
+
+For browser/UI: invoke `browser` skill with real workflows. Server + client features require both exec:nodejs AND browser diagnostics. After every success: enumerate what remains — never stop at first green. First green is not COMPLETE.
+
+## INTEGRATION TEST GATE
+
+Before git enforcement, run the project's `test.js` if it exists:
+
+```
+exec:nodejs
+const { execSync } = require('child_process');
+try { execSync('node test.js', { stdio: 'inherit', timeout: 30000 }); console.log('test.js: PASS'); } catch (e) { console.error('test.js: FAIL'); process.exit(1); }
+```
+
+Failure = regression to `gm-execute`. Do not proceed to git enforcement with failing tests.
+
+If `test.js` does not exist and the project has testable surface, regress to `gm-execute` to create it.
+
+## CODE EXECUTION
+
+**exec:<lang> is the only way to run code.** Bash tool body: `exec:<lang>\n<code>`
+
+`exec:nodejs` (default) | `exec:bash` | `exec:python` | `exec:typescript` | `exec:go` | `exec:rust` | `exec:java` | `exec:deno` | `exec:cmd`
+
+Only git in bash directly. Background tasks: `exec:sleep\n<id>`, `exec:status\n<id>`, `exec:close\n<id>`. Runner: `exec:runner\nstart|stop|status`.
+
+**Execution efficiency — pack every run:**
+- Combine multiple independent operations into one exec call using `Promise.allSettled` or parallel subprocess spawning
+- Each independent idea gets its own try/catch with independent error reporting — never let one failure block another
+- Target under 12s per exec call; split work across multiple calls only when dependencies require it
+- Prefer a single well-structured exec that does 5 things over 5 sequential execs
+
+## CODEBASE EXPLORATION
+
+```
+exec:codesearch
+<natural language description>
+```
+
+PDFs in the repo are part of the same index — when verifying a change conforms to a published spec, search the spec PDF directly and cite `doc.pdf:<page>` as evidence. A verification that references a PDF without having searched it is unwitnessed.
+
+## GIT ENFORCEMENT
+
+```
+exec:bash
+git status --porcelain
+```
+Must return empty.
+
+```
+exec:bash
+git log origin/main..HEAD --oneline
+```
+Must return empty. If not: stage → commit → push → re-verify. Local commit without push ≠ complete.
+
+## CI ENFORCEMENT
+
+After push, monitor all triggered GitHub Actions runs until they complete:
+
+1. List runs triggered by the push:
+```
+exec:bash
+gh run list --limit 5 --json databaseId,name,status,conclusion,headBranch
+```
+
+2. For each run that is `in_progress` or `queued`, poll until it completes:
+```
+exec:bash
+gh run watch <run_id> --exit-status
+```
+
+3. If a run fails, view the logs to diagnose:
+```
+exec:bash
+gh run view <run_id> --log-failed
+```
+
+4. Fix the root cause → snake to the appropriate phase (emit for file issues, execute for logic issues, planning for new unknowns) → re-push → re-monitor.
+
+5. All runs must reach `conclusion: success` before advancing. A failed CI run is a KNOWN mutable that blocks completion — never ignore it.
+
+**Cascade awareness**: pushes to this repo may trigger downstream workflows (see AGENTS.md Rust Binary Update Pipeline). After local CI passes, check downstream repos for triggered runs:
+```
+exec:bash
+gh run list --repo AnEntrypoint/<downstream-repo> --limit 3 --json databaseId,name,status,conclusion
+```
+Monitor any cascade runs the same way — poll, diagnose failures, fix if the cause is in this repo.
+
+## CODEBASE HYGIENE SWEEP
+
+Before declaring complete, sweep the entire codebase for violations:
+
+1. **Files >200 lines** → split immediately
+2. **Comments in code** → remove all
+3. **Scattered test files** (.test.js, .spec.js, __tests__/, fixtures/, mocks/) → delete, consolidate coverage into root `test.js`
+4. **Mock/stub/simulation files** → delete
+5. **Unnecessary doc files** (not CHANGELOG/CLAUDE/README/TODO.md) → delete
+6. **Duplicate concern** (overlapping responsibility, similar logic, parallel implementations, consolidatable code) → snake to `planning` with restructuring instructions — do not patch locally
+7. **Hardcoded values** → derive from ground truth, config, or convention
+8. **Fallback/demo modes** → remove, fail loud instead
+9. **TODO.md** → must be empty/deleted before completion
+10. **CHANGELOG.md** → must have entries for this session's changes
+11. **Observability gaps** → every server subsystem added this session exposes a `/debug/<subsystem>` endpoint; every client module added this session registers into `window.__debug` by key. Ad-hoc console.log is not observability — permanent queryable structures are. Any gap found → fix before advancing.
+12. **memorize** → launch memorize sub-agent in background with session learnings before invoking update-docs: `Agent(subagent_type='memorize', model='haiku', run_in_background=true, prompt='## CONTEXT TO MEMORIZE\n<session learnings>')`
+13. **Deploy/publish** → if deployable, deploy. If npm package, publish.
+14. **GitHub Pages** → check if repo has a GH Pages site. If `.github/workflows/pages.yml` is absent OR `docs/index.html` is absent: invoke the `pages` skill to scaffold the site before advancing.
+
+Any violation found = fix immediately before advancing.
+
+## COMPLETION DEFINITION
+
+All of: witnessed end-to-end output | all failure paths exercised | test.js passes | .gm/prd.yml empty | git clean and pushed | all CI runs green | codebase hygiene sweep clean | TODO.md empty/deleted | CHANGELOG.md updated | `user_steps_remaining=0`
+
+## DO NOT STOP
+
+After end-to-end verification passes: read `.gm/prd.yml` from disk. If any items remain, immediately invoke `gm-execute` skill — do not respond to the user. Only respond when `.gm/prd.yml` is deleted AND git is clean AND all commits are pushed.
+
+## CONSTRAINTS
+
+**Never**: claim done without witnessed output | uncommitted changes | unpushed commits | failed CI runs | .gm/prd.yml items remaining | TODO.md with items remaining | stop at first green | absorb surprises silently | respond to user while .gm/prd.yml has items | skip hygiene sweep | leave comments/mocks/scattered test files/fallbacks | skip test.js execution
+
+**Always**: triage failure before regressing | witness end-to-end | run test.js before git enforcement | regress to planning on any new unknown | enumerate remaining after every success | check .gm/prd.yml after every verification pass | run hygiene sweep before declaring complete | deploy/publish if applicable | update CHANGELOG.md
+
+---
+
+**EXIT → EXECUTE**: .prd items remain → invoke `gm-execute` skill immediately (keep going, never stop with .prd items).
+**EXIT → COMPLETE**: .prd deleted + feature work pushed + CI green → invoke `update-docs` skill.
+**REGRESS → EMIT**: file output wrong → invoke `gm-emit` skill, reset to EMIT state.
+**REGRESS → EXECUTE**: logic wrong → invoke `gm-execute` skill, reset to EXECUTE state.
+**REGRESS → PLAN**: new unknown or wrong requirements → invoke `planning` skill, reset to PLAN state.

package/skills/software-development/gm-emit/SKILL.md

@@ -0,0 +1,126 @@
+---
+name: gm-emit
+description: EMIT phase. Pre-emit debug, write files, post-emit verify from disk. Any new unknown triggers immediate snake back to planning — restart chain.
+---
+
+# GM EMIT — Writing and Verifying Files
+
+You are in the **EMIT** phase. Every mutable is KNOWN. Prove the write is correct, write, confirm from disk. Any new unknown = snake to `planning`, restart chain.
+
+**GRAPH POSITION**: `PLAN → EXECUTE → [EMIT] → VERIFY → COMPLETE`
+- **Entry**: All .gm/prd.yml mutables resolved. Entered from `gm-execute` or via snake from VERIFY.
+
+## TRANSITIONS
+
+**EXIT — invoke `gm-complete` skill immediately when**: All gate conditions are true simultaneously. Do not pause. Invoke the skill.
+
+**SELF-LOOP (remain in EMIT state)**: Post-emit variance with known cause → fix immediately, re-verify, do not advance until zero variance
+
+**STATE REGRESSIONS**:
+- Pre-emit reveals logic error (known mutable) → invoke `gm-execute` skill, reset to EXECUTE, return here after resolution
+- Pre-emit reveals new unknown → invoke `planning` skill, reset to PLAN state
+- Post-emit variance with unknown cause → invoke `planning` skill, reset to PLAN state
+- Scope changed → invoke `planning` skill, reset to PLAN state
+- Re-entered from VERIFY state (broken file output) → fix, re-verify, then re-invoke `gm-complete` skill
+
+## MUTABLE DISCIPLINE
+
+Each gate condition is a mutable. Pre-emit run witnesses expected value. Post-emit run witnesses current value. Zero variance = resolved. Variance with unknown cause = new unknown = snake to `planning`.
+
+## CODE EXECUTION
+
+**exec:<lang> is the only way to run code.** Bash tool body: `exec:<lang>\n<code>`
+
+`exec:nodejs` (default) | `exec:bash` | `exec:python` | `exec:typescript` | `exec:go` | `exec:rust` | `exec:java` | `exec:deno` | `exec:cmd`
+
+Only git in bash directly. `Bash(node/npm/npx/bun)` = violations. File writes via exec:nodejs + require('fs').
+
+**Execution efficiency — pack every run:**
+- Combine multiple independent operations into one exec call using `Promise.allSettled` or parallel subprocess spawning
+- Each independent idea gets its own try/catch with independent error reporting — never let one failure block another
+- Target under 12s per exec call; split work across multiple calls only when dependencies require it
+- Prefer a single well-structured exec that does 5 things over 5 sequential execs
+
+## PRE-EMIT DIAGNOSTIC RUN (mandatory before writing any file)
+
+The pre-emit run is a diagnostic pass. Its purpose is to falsify the write before it happens.
+
+1. Import the actual module from disk via `exec:nodejs` — witness current on-disk behavior as the baseline
+2. Run proposed logic in isolation WITHOUT writing — witness output with real inputs
+3. Probe all failure paths with real error inputs — record expected vs actual for each
+4. Compare: if proposed output matches expected → proceed to write. If not → new unknown, regress to `planning`.
+
+```
+exec:nodejs
+const { fn } = await import('/abs/path/to/module.js');
+console.log(await fn(realInput));
+```
+
+Pre-emit revealing unexpected behavior → name the delta → new unknown → invoke `planning` skill, reset to PLAN state.
+
+## WRITING FILES
+
+`exec:nodejs` with `require('fs')`. Write only when every gate mutable is `resolved=true` simultaneously.
+
+## POST-EMIT DIAGNOSTIC VERIFICATION (immediately after writing)
+
+The post-emit verification is a differential diagnosis against the pre-emit baseline.
+
+1. Re-import the actual file from disk — not the in-memory version (stale in-memory state is inadmissible)
+2. Run identical inputs as pre-emit — output must match pre-emit witnessed values exactly
+3. For browser: reload from disk, re-inject `__gm` globals, re-run, compare captured outputs to pre-emit baseline
+4. Known variance (cause is identified, mutable is KNOWN) → fix immediately and re-verify
+5. Unknown variance (delta exists but cause cannot be determined) → this is a new unknown → invoke `planning` skill, reset to PLAN state
+
+## GATE CONDITIONS (all true simultaneously before advancing)
+
+- Pre-emit debug passed with real inputs and error inputs
+- Post-emit verification matches pre-emit exactly
+- Hot reloadable: state outside reloadable modules, handlers swap atomically
+- Errors throw with clear context — no fallbacks, demo modes, silent swallowing, `|| default`, `catch { return null }`
+- No mocks/fakes/stubs/simulations/scattered test files anywhere — delete on discovery (only root test.js permitted)
+- Files ≤200 lines — split immediately if over, do not advance
+- No duplicate concern — after writing, run exec:codesearch for the primary concern. If ANY other code serves the same concern → do NOT advance, snake to `planning` with consolidation instructions
+- No comments — remove any found
+- No hardcoded values — dynamic/modular code using ground truth only
+- No adjectives/descriptive language in variable/function names
+- No unnecessary files — clean anything not required for the program to function
+- Observability: every new server subsystem exposes a named inspection endpoint; every new client module registers into `window.__debug` by key and deregisters on unmount. Ad-hoc `console.log` is not observability — permanent queryable structure is. Any new code path not reachable via `window.__debug` or a `/debug/<subsystem>` endpoint → do NOT advance, add observability before writing feature code.
+- Structural quality: if/else chains where a dispatch table or pipeline suffices → regress to `gm-execute` for restructuring. One-liners that compress logic at the cost of readability → expand. Any logic that reinvents a native API or library → replace with the native/library call. Structure must make wrong states unrepresentable — if it doesn't, it's not done.
+- memorize sub-agent launched in background before advancing: `Agent(subagent_type='memorize', model='haiku', run_in_background=true, prompt='## CONTEXT TO MEMORIZE\n<what was learned>')`
+- CHANGELOG.md updated with changes
+- TODO.md cleared or deleted
+
+## CODEBASE EXPLORATION
+
+```
+exec:codesearch
+<natural language description>
+```
+
+Alias: `exec:search`. **Glob, Grep, Read, Explore are hook-blocked** — use `exec:codesearch` exclusively. PDF pages are in the same index as source files; when verifying that emitted code matches a spec, search the PDF directly (e.g. `exec:codesearch\nregister layout`) and cite `doc.pdf:<page>` in the pre-emit comparison.
+
+## BROWSER DEBUGGING
+
+Invoke `browser` skill. Escalation: (1) `exec:browser\n<js>` → (2) `browser` skill → (3) navigate/click → (4) screenshot last resort.
+
+## SELF-CHECK (before and after each file)
+
+File ≤200 lines | No duplicate concern | Pre-emit passed | No mocks | No comments | Docs match | All spotted issues fixed
+
+## DO NOT STOP
+
+Never respond to the user from this phase. When all gate conditions pass, immediately invoke `gm-complete` skill. Do not pause, summarize, or ask questions.
+
+## CONSTRAINTS
+
+**Never**: write before pre-emit passes | advance with post-emit variance | absorb surprises silently | comments | hardcoded values | fallback/demo modes | silent error swallowing | defer spotted issues | respond to user or pause for input
+
+**Always**: pre-emit debug before writing | post-emit verify from disk | regress to planning on any new unknown | fix immediately | invoke next skill immediately when gates pass
+
+---
+
+**EXIT → VERIFY**: All gates pass → invoke `gm-complete` skill immediately.
+**SELF-LOOP**: Known post-emit variance → fix, re-verify (remain in EMIT state).
+**REGRESS → EXECUTE**: Known logic error → invoke `gm-execute` skill, reset to EXECUTE state.
+**REGRESS → PLAN**: Any new unknown → invoke `planning` skill, reset to PLAN state.

package/skills/software-development/gm-execute/SKILL.md

@@ -0,0 +1,159 @@
+---
+name: gm-execute
+description: EXECUTE phase. Resolve all mutables via witnessed execution. Any new unknown triggers immediate snake back to planning — restart chain from PLAN.
+---
+
+# GM EXECUTE — Resolving Every Unknown
+
+You are in the **EXECUTE** phase. Resolve every named mutable via witnessed execution. Any new unknown = stop, snake to `planning`, restart chain.
+
+**GRAPH POSITION**: `PLAN → [EXECUTE] → EMIT → VERIFY → COMPLETE`
+- **Entry**: .prd exists with all unknowns named. Entered from `planning` or via snake from EMIT/VERIFY.
+
+## TRANSITIONS
+
+**EXIT — invoke `gm-emit` skill immediately when**: All mutables are KNOWN (zero UNKNOWN remaining). Do not wait, do not summarize. Invoke the skill.
+
+**SELF-LOOP (remain in EXECUTE state)**: Mutable still UNKNOWN after one pass → re-run with different angle (max 2 passes, then regress to PLAN)
+
+**STATE REGRESSIONS**:
+- New unknown discovered → invoke `planning` skill immediately, reset to PLAN state
+- EXECUTE mutable unresolvable after 2 passes → invoke `planning` skill, reset to PLAN state
+- Re-entered from EMIT state (logic error) → re-resolve the mutable, then re-invoke `gm-emit` skill
+- Re-entered from VERIFY state (runtime failure) → re-resolve with real system state, then re-invoke `gm-emit` skill
+
+## MUTABLE DISCIPLINE
+
+Each mutable: name | expected | current | resolution method. Execute → witness → assign → compare. Zero variance = resolved. Unresolved after 2 passes = new unknown = snake to `planning`. Never narrate past an unresolved mutable.
+
+## CODE EXECUTION
+
+**exec:<lang> is the only way to run code.** Bash tool body: `exec:<lang>\n<code>`
+
+`exec:nodejs` (default) | `exec:bash` | `exec:python` | `exec:typescript` | `exec:go` | `exec:rust` | `exec:c` | `exec:cpp` | `exec:java` | `exec:deno` | `exec:cmd`
+
+Lang auto-detected if omitted. `cwd` sets directory. File I/O via exec:nodejs + require('fs'). Only git in bash directly. `Bash(node/npm/npx/bun)` = violations.
+
+**Execution efficiency — pack every run:**
+- Combine multiple independent operations into one exec call using `Promise.allSettled` or parallel subprocess spawning
+- Each independent idea gets its own try/catch with independent error reporting — never let one failure block another
+- Target under 12s per exec call; split work across multiple calls only when dependencies require it
+- Prefer a single well-structured exec that does 5 things over 5 sequential execs
+
+**Background tasks** (auto-backgrounded when execution exceeds 15s):
+```
+exec:sleep
+<task_id> [seconds]
+```
+```
+exec:status
+<task_id>
+```
+```
+exec:close
+<task_id>
+```
+
+**Runner**:
+```
+exec:runner
+start|stop|status
+```
+
+## CODEBASE EXPLORATION
+
+`exec:codesearch` is the preferred semantic search. **Glob, Explore, WebSearch are hook-blocked. Grep/Read ARE available — use them for exact-match or direct reads.**
+
+```
+exec:codesearch
+<two-word query to start>
+```
+
+`exec:codesearch` indexes PDFs the same way it indexes source — spec PDFs, datasheets, papers, and RFCs return as first-class hits with `file:page` citations. When resolving a mutable that depends on external specification (protocol field, register layout, compliance text), search the PDF corpus before reimplementing or assuming. Unwitnessed assumption from a doc you did not search is an UNKNOWN.
+
+**Mandatory search protocol** for codesearch (from `code-search` skill):
+1. Start with exactly **two words** — never one, never a sentence
+2. No results → change one word (synonym or related term)
+3. Still no results → add a third word to narrow scope
+4. Keep changing or adding words each pass until content is found
+5. Minimum 4 attempts before concluding content is absent
+
+**When codesearch is the wrong tool:**
+- Exact symbol / string / regex match: use `Grep` tool directly, or `exec:nodejs` with `execSync("rg -n 'PATTERN'")`.
+- Known file path: use `Read` tool directly.
+- Find files by name pattern: hook-blocked `Glob` would help; use `exec:nodejs + fs.readdirSync` or `exec:nodejs + execSync("rg --files | rg PATTERN")`.
+
+**Platform note — exec:bash on Windows:** runs real bash (git-bash) when installed, falls back to PowerShell otherwise. If you see a POSIX-syntax parse error (`[ -n ...]`, `&&`, `if/then/fi`), bash wasn't found — either install git-bash or rewrite in `exec:nodejs`.
+
+## DIAGNOSTIC PROTOCOL — IMPORT-BASED EXECUTION
+
+Always import actual codebase modules. Never rewrite logic inline. Reimplemented output is unwitnessed and inadmissible as ground truth.
+
+```
+exec:nodejs
+const { fn } = await import('/abs/path/to/module.js');
+console.log(await fn(realInput));
+```
+
+Witnessed import output = resolved mutable. Reimplemented output = UNKNOWN.
+
+**Differential diagnosis**: when behavior diverges from expectation, run the smallest possible isolation test first. Compare actual vs expected. Name the delta. The delta is the mutable — resolve it before touching any file.
+
+## EXECUTION DENSITY
+
+Pack every related hypothesis into one run. Each run ≤15s. Witnessed output = ground truth. Narrated assumption = inadmissible.
+
+Parallel waves: ≤3 `gm:gm` subagents via Agent tool (`Agent(subagent_type="gm:gm", ...)`) — independent items simultaneously, never sequentially.
+
+## CHAIN DECOMPOSITION — FAULT ISOLATION
+
+Break every multi-step operation before running end-to-end. Treat each step as a diagnostic unit:
+1. Number every distinct step
+2. Per step: input shape, output shape, success condition, failure mode
+3. Run each step in isolation — witness output — assign mutable — must be KNOWN before proceeding to next step
+4. Debug adjacent step pairs for handoff correctness — the seam between steps is the most common failure site
+5. Only when all pairs pass: run full chain end-to-end
+
+Step failure revealing new unknown → regress to `planning` state immediately.
+
+## BROWSER DIAGNOSTIC ESCALATION
+
+Invoke `browser` skill. Exhaust each level before advancing to next:
+1. `exec:browser\n<js>` — inspect DOM state, read globals, check network responses. Always first.
+2. `browser` skill — for full session workflows requiring navigation
+3. navigate/click/type — only when real events required and DOM inspection insufficient
+4. screenshot — last resort, only after all JS-based diagnostics exhausted
+
+## GROUND TRUTH ENFORCEMENT
+
+Real services, real data, real timing. Mocks/fakes/stubs/simulations = diagnostic noise = delete immediately. No scattered test files (.test.js, .spec.js, __tests__/) — delete on discovery. All test coverage belongs in the single root `test.js`. If `test.js` does not exist, create it. Every behavior change updates `test.js`. Every bug fix adds a regression case. No fallback/demo modes — errors must surface with full diagnostic context and fail loud.
+
+**SCAN BEFORE EDIT**: Before modifying or creating any file, search the codebase (exec:codesearch) for existing implementations of the same concern. "Duplicate" means overlapping responsibility, similar logic, or parallel implementations — not just identical files. If consolidation is possible, regress to `planning` with restructuring instructions instead of continuing.
+
+**HYPOTHESIZE VIA EXECUTION — NEVER VIA ASSUMPTION**: Formulate a falsifiable hypothesis. Run it. Witness the output. The output either confirms or falsifies. Only a witnessed falsification justifies editing a file. Never edit based on unwitnessed assumptions — form hypothesis → run → witness → edit.
+
+**CODE QUALITY PROCESS**: The goal is minimal code / maximal DX. When writing or reviewing any block of code, run this mental process: (1) What native language/platform feature already does this? Use it. (2) What library already solves this pattern? Use it. (3) Can this branch/loop be a data structure — a map, array, or pipeline — where the structure itself enforces correctness? Make it so. (4) Would a newcomer read this top-to-bottom and immediately understand what it does without running it? If no, restructure. One-liners that compress logic are the opposite of DX — clarity comes from structure, not brevity. Dispatch tables, pipeline chains, and native APIs eliminate entire categories of bugs by making wrong states unrepresentable.
+
+## MEMORY
+
+When any mutable resolves from UNKNOWN to KNOWN (zero variance confirmed), launch memorize subagent in background — non-blocking, execution continues:
+
+`Agent(subagent_type='memorize', model='haiku', run_in_background=true, prompt='## CONTEXT TO MEMORIZE\n<resolved fact>')`
+
+Qualifies for memorization: new API shapes discovered, environment differences, behavioral constraints, runtime quirks, user feedback observed during execution.
+
+## DO NOT STOP
+
+Never respond to the user from this phase. When all mutables are KNOWN, immediately invoke `gm-emit` skill. The chain continues until .prd is deleted and git is clean — that happens in `gm-complete`, not here.
+
+## CONSTRAINTS
+
+**Never**: `Bash(node/npm/npx/bun)` | fake data | mock files | scattered test files (only root test.js) | fallback/demo modes | Glob/Explore (hook-blocked — use exec:codesearch, Grep or Read) | sequential independent items | absorb surprises silently | respond to user or pause for input | edit files before executing to understand current behavior | duplicate existing code | write explicit if/else chains when a dispatch table or native method suffices | write packed one-liners that obscure structure | reinvent what a library or native API already provides
+
+**Always**: witness every hypothesis | import real modules | scan codebase before creating/editing files | regress to planning on any new unknown | fix immediately on discovery | delete mocks/stubs/comments/scattered test files on discovery | consolidate test coverage into root test.js | add regression case to test.js for every bug fix | invoke next skill immediately when done | ask "what native feature solves this?" before writing any new logic | prefer structures where wrong states are unrepresentable
+
+---
+
+**EXIT → EMIT**: All mutables KNOWN → invoke `gm-emit` skill immediately.
+**SELF-LOOP**: Still UNKNOWN → re-run (max 2 passes, then regress to PLAN).
+**REGRESS → PLAN**: Any new unknown → invoke `planning` skill, reset to PLAN state.