gm-skill 2.0.1081 → 2.0.1083

package/README.md

@@ -28,7 +28,7 @@ npx gm-skill-bootstrap
 
 ## Version
 
-`2.0.1081` — auto-bumped from the canonical `gm` repo. Every push to `AnEntrypoint/gm` republishes this package alongside all 15 platform packages.
+`2.0.1083` — auto-bumped from the canonical `gm` repo. Every push to `AnEntrypoint/gm` republishes this package alongside all 15 platform packages.
 
 ## Source of truth
 

package/gm.json

@@ -1,6 +1,6 @@
 {
   "name": "gm",
-  "version": "2.0.1081",
+  "version": "2.0.1083",
   "description": "Spool-dispatch orchestration engine with unified state machine, skills, and automated git enforcement",
   "author": "AnEntrypoint",
   "license": "MIT",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gm-skill",
-  "version": "2.0.1081",
+  "version": "2.0.1083",
   "description": "Canonical universal harness — AI-native software engineering via skill-driven orchestration; bootstraps plugkit for task execution and session isolation. Install in any AI coding agent host.",
   "author": "AnEntrypoint",
   "license": "MIT",
@@ -39,7 +39,7 @@
     "gm.json"
   ],
   "dependencies": {
-    "gm-plugkit": "^2.0.1081"
+    "gm-plugkit": "^2.0.1083"
   },
   "engines": {
     "node": ">=16.0.0"

package/skills/gm-skill/SKILL.md

@@ -1,43 +1,19 @@
 ---
 name: gm-skill
-description: Canonical universal harness — AI-native software engineering via skill-driven orchestration; bootstraps plugkit for task execution and session isolation
+description: Canonical universal harness — AI-native software engineering. Plugkit serves all instructions, state, guardrails on demand via the spool.
 allowed-tools: Skill, Read, Write
 ---
 
-# GM — Universal Skill Harness
+# gm — single entry point
 
-Single canonical body re-exported by every platform-specific gm-<platform> skill. All 15 platforms share this identical surface. AI-native software engineering orchestrated as a continuous chain: PLAN → EXECUTE → EMIT → VERIFY → UPDATE-DOCS, no stops between phases, no permission gates, the user's first request is the authorization for the whole chain.
+Plugkit owns every instruction, every phase transition, every guardrail. The skill body is the only thing the agent reads from disk; everything else flows from plugkit verbs.
 
-## Bootstrap
+## The loop
 
-`bun x gm-plugkit@latest --daemon` downloads the correct platform binary, verifies SHA256, starts the spool watcher daemon. Idempotent. Call once at session start. Subsequent calls no-op.
+1. Write `.gm/exec-spool/in/instruction/<N>.txt` with empty body (or `phase=<override>` to force a phase). Read `.gm/exec-spool/out/<N>.json`.
+2. The response contains `phase`, `instruction` (prose to follow), `mutables_pending`, `prd_pending_count`, `next_phase_hint`.
+3. Follow the `instruction` body imperatively. Resolve mutables, execute work, dispatch other verbs (`recall`, `codesearch`, `memorize`, `mutable-resolve`, `transition`, all language stems) as the instruction directs.
+4. When the phase's exit condition is met, dispatch `in/transition/<N>.txt` to advance. Then re-enter step 1 with the new phase.
+5. Loop until `next_phase_hint` is null (phase=COMPLETE) — the chain is done.
 
-Session-ID threading: at skill invoke, generate or detect SESSION_ID (env `SESSION_ID` or `uuid()`). Every rs-exec RPC body and every spool-written task body carries `sessionId: "<id>"`. Task-scoped cleanup (deleteTask, getTask, appendOutput, killSessionTasks) requires matching sessionId. Absence is hard-rejected by the handler — no orphaned tasks.
-
-## Spool Dispatch Surface
-
-Every dispatch goes through the spool. Tool args are ephemeral, inline, do not survive compaction, are not replayable. A file-based surface inverts every one of those: the request lives on disk before the watcher reads it, the watcher is detached from the agent process, the output triplet (`.out`, `.err`, `.json`) is auditable after the fact.
-
-Write to `.gm/exec-spool/in/<lang>/<N>.<ext>` (nodejs, python, bash, typescript, go, rust, c, cpp, java, deno) or `in/<verb>/<N>.txt` (codesearch, recall, memorize, wait, sleep, status, close, browser, runner, type, kill-port, forget, feedback, learn-status, learn-debug, learn-build, discipline, pause, health). Watcher streams `out/<N>.out` and `out/<N>.err` line-by-line, then writes `out/<N>.json` metadata (exitCode, durationMs, timedOut, startedAt, endedAt) at completion.
-
-Only `git` and `gh` run directly via the Bash tool. Inline `node script.js`, `Bash(exec:<anything>)`, JSON-form dispatch — all denied at the hook layer.
-
-## Daemonize by Default
-
-The watcher returns a task_id immediately and tails the logfile up to 30 seconds of wall-clock before returning. Short tasks complete inside the window and look synchronous. Long tasks return the task_id with partial output and continue running. The agent never re-spawns a long task to check on it — that orphans the first one.
-
-Resumption grammar: `tail` drains additional output without blocking. `watch` blocks until a regex matches or timeout elapses. `wait` is a pure timer. `sleep` blocks on a specific task's output. `close` terminates. Every RPC response carries `running_task_ids` for the calling session so the agent never loses track of background work it spawned.
-
-## Hooks Throw, Never Mutate
-
-A hook that blocks a tool call throws an error with an imperative instruction string. It does not rewrite the call's arguments into a self-failing form. The thrown error is the entire denial surface. Throw form is for "use a different tool" (the model adapts policy); mutate form would be for "run this corrected version" (the model reads it as a broken tool and retries with simpler commands, reinforcing the wrong mental model).
-
-## Meaning Through Haiku
-
-Any task whose correctness depends on understanding — summarize, classify, extract intent, rewrite, translate, semantic dedup, score, label, decide-if-two-texts-mean-the-same — routes through `Agent(subagent_type='gm:textprocessing', model='haiku', ...)`. One subagent per item, N items in N parallel calls in one message. Code does mechanics well and meaning badly. A keyword-list or regex-on-meaning-phrases loop deciding semantic questions is a stub that ships a green check that lies.
-
-## End-to-End Chaining
-
-When SKILL.md includes `end-to-end: true`, the adapter parses stdout for trailing JSON: `{"nextSkill": "...", "context": {...}, "phase": "..."}`. Non-null `nextSkill` → invoke `Skill(skill="gm:<nextSkill>")` with context, repeat until null. Five skill invocations auto-chain into one user invocation.
-
-Every task returns complete: taskId, exitCode, durationMs, timedOut, stdout, stderr. Background tasks return immediately with task_id; continue with `in/status/<N>.txt` (tail), `in/watch/<N>.txt` (watch), or `in/close/<N>.txt` (close).
+No other skill exists. There is no `gm:planning`, no `gm:gm-execute`, no `gm:gm-emit`. Plugkit serves what those used to be, on demand, per phase.

package/skills/browser/SKILL.md

@@ -1,80 +0,0 @@
----
-name: browser
-description: Browser automation via playwriter. Use when user needs to interact with websites, navigate pages, fill forms, click buttons, take screenshots, extract data, test web apps, or automate any browser task.
-allowed-tools: Skill
----
-
-# Browser automation
-
-Two pathways — never mix in the same spool dispatch.
-
-`exec:browser` runs JS against `page`. Globals available: `page`, `snapshot`, `screenshotWithAccessibilityLabels`, `state`. 15s live window, then backgrounds; output drains automatically on every subsequent plugkit call.
-
-`browser:` prefix is playwriter session management. One command per block.
-
-## Core
-
-Write to `.gm/exec-spool/in/browser/<N>.txt`:
-
-```
-await page.goto('https://example.com')
-await snapshot({ page })
-```
-
-```
-browser:
-playwriter session new --direct
-```
-
-```
-browser:
-playwriter -s 1 -e 'await page.goto("http://example.com")'
-```
-
-Session state persists across `browser:` calls. `-e` arg uses single quotes outside, double inside JS strings.
-
-## Timing
-
-Never `await setTimeout(N)` with N > 10000. Poll instead.
-
-Write to `.gm/exec-spool/in/browser/<N>.txt`:
-
-```
-const start = Date.now()
-while (!state.done && Date.now() - start < 12000) {
-  await new Promise(r => setTimeout(r, 500))
-}
-console.log(state.result)
-```
-
-`Assertion failed: UV_HANDLE_CLOSING` is normal background-on-exit noise; ignore it.
-
-## Patterns
-
-Data extraction — write to `.gm/exec-spool/in/browser/<N>.txt`:
-
-```
-const items = await page.$$eval('.title', els => els.map(e => e.textContent))
-console.log(JSON.stringify(items))
-```
-
-Console monitoring — set listeners first, then poll. Write to `.gm/exec-spool/in/browser/<N>.txt`:
-
-```
-state.logs = []
-page.on('console', msg => state.logs.push({ type: msg.type(), text: msg.text() }))
-```
-
-Then write to `.gm/exec-spool/in/browser/<N+1>.txt`:
-
-```
-console.log(JSON.stringify(state.logs.slice(-20)))
-```
-
-## Constraints
-
-- One playwriter command per `browser:` block
-- `exec:browser` body is plain JS, no shell quoting
-- Browser tasks drain automatically on every plugkit interaction
-- Sessions reap after 5–15 min idle; cleaned up on session end
-- Never write standalone `.mjs`/`.js` Playwright scripts as a fallback — `exec:browser` errors must be debugged through `exec:browser` retries, not by creating test files on disk

package/skills/code-search/SKILL.md

@@ -1,48 +0,0 @@
----
-name: code-search
-description: Mandatory codebase search workflow. Use whenever you need to find anything in the codebase. Start with two words, iterate by changing or adding words until found.
----
-
-# Codebase search
-
-`exec:codesearch` is the only codebase search tool. Never use Grep, Glob, Find, Explore, raw `grep`/`rg`/`find` inside `exec:bash`. No fallback.
-
-A `@<discipline>` first-token after the verb scopes the search to that discipline's index; absent the sigil, results fan across default plus enabled disciplines, prefixed by source.
-
-Handles exact symbols, exact strings, file-name fragments, regex-ish patterns, natural-language queries, and PDF pages (cite `path/doc.pdf:<page>`).
-
-Direct-read exceptions: known absolute path → `Read`. Known directory listing → `exec:nodejs` + `fs.readdirSync`.
-
-## Syntax
-
-```
-exec:codesearch
-<two-word query>
-```
-
-## Iteration
-
-Start at exactly two words. No results → change one word. Still none → add a third. Still none → swap the changed word again. Minimum four attempts before concluding absent. Never one word, never a full sentence, never switch tools.
-
-## Examples
-
-```
-exec:codesearch
-session cleanup idle
-```
-
-No results, then:
-
-```
-exec:codesearch
-cleanup sessions timeout
-```
-
-PDF:
-
-```
-exec:codesearch
-usb descriptor endpoint
-```
-
-Returns `docs/usb-spec.pdf:42` — cite the page; `Read` if surrounding text is needed.

package/skills/create-lang-plugin/SKILL.md

@@ -1,121 +0,0 @@
----
-name: create-lang-plugin
-description: Create a lang/ plugin that wires any CLI tool or language runtime into gm-cc — adds exec:<id> dispatch, optional LSP diagnostics, and optional prompt context injection. Zero hook configuration required.
----
-
-# Create lang plugin
-
-Single CommonJS file at `<projectDir>/lang/<id>.js`. Auto-discovered — no hook editing.
-
-## Plugin shape
-
-```js
-'use strict';
-module.exports = {
-  id: 'mytool',
-  exec: {
-    match: /^exec:mytool/,
-    run(code, cwd) { /* returns string or Promise<string> */ }
-  },
-  lsp: {
-    check(fileContent, cwd) { /* returns Diagnostic[] */ }
-  },
-  extensions: ['.ext'],
-  context: `=== mytool ===\n...`
-};
-```
-
-`type Diagnostic = { line: number; col: number; severity: 'error'|'warning'; message: string }`
-
-`exec.run` runs in a child process, 30s timeout, async OK. Called when Claude writes `exec:mytool\n<code>`. `lsp.check` is synchronous-only, called per prompt-submit. `context` is injected into every prompt, truncated to 2000 chars.
-
-## Identify the tool
-
-What is the CLI name or npm package? Does it run a single expression (`tool eval`, `tool -e`, HTTP POST) or a file (`tool run <file>`)? What is its lint/check mode and output format? File extensions? Does it require a running server, or does it run headless?
-
-## exec.run patterns
-
-HTTP eval against a running server:
-
-```js
-function httpPost(port, urlPath, body) {
-  return new Promise((resolve, reject) => {
-    const data = JSON.stringify(body);
-    const req = http.request(
-      { hostname: '127.0.0.1', port, path: urlPath, method: 'POST',
-        headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(data) } },
-      res => { let raw = ''; res.on('data', c => raw += c); res.on('end', () => resolve(JSON.parse(raw))); }
-    );
-    req.setTimeout(8000, () => { req.destroy(); reject(new Error('timeout')); });
-    req.on('error', reject);
-    req.write(data); req.end();
-  });
-}
-```
-
-File-based, headless:
-
-```js
-function runFile(code, cwd) {
-  const tmp = path.join(os.tmpdir(), `plugin_${Date.now()}.ext`);
-  fs.writeFileSync(tmp, code);
-  try { return execFileSync('mytool', ['run', tmp], { cwd, encoding: 'utf8', timeout: 10000 }); }
-  finally { try { fs.unlinkSync(tmp); } catch (_) {} }
-}
-```
-
-Single-expression detection:
-
-```js
-const isSingleExpr = code => !code.trim().includes('\n') && !/\b(func|def|fn |class|import)\b/.test(code);
-```
-
-## lsp.check
-
-```js
-function check(fileContent, cwd) {
-  const tmp = path.join(os.tmpdir(), `lsp_${Math.random().toString(36).slice(2)}.ext`);
-  try {
-    fs.writeFileSync(tmp, fileContent);
-    const r = spawnSync('mytool', ['check', tmp], { encoding: 'utf8', cwd });
-    return (r.stdout + r.stderr).split('\n').reduce((acc, line) => {
-      const m = line.match(/^.+:(\d+):(\d+):\s+(error|warning):\s+(.+)$/);
-      if (m) acc.push({ line: +m[1], col: +m[2], severity: m[3], message: m[4].trim() });
-      return acc;
-    }, []);
-  } catch (_) { return []; }
-  finally { try { fs.unlinkSync(tmp); } catch (_) {} }
-}
-```
-
-## context
-
-Under 300 chars:
-
-```js
-context: `=== mytool ===\nexec:mytool\n<expression>\n\nRuns via <how>. Use for <when>.`
-```
-
-## Verify
-
-Write to `.gm/exec-spool/in/nodejs/<N>.js`:
-
-```js
-const p = require('/abs/path/lang/mytool.js');
-console.log(p.id, typeof p.exec.run, p.exec.match.toString());
-```
-
-Then test dispatch by writing to `.gm/exec-spool/in/mytool/<N>.txt`:
-
-```
-<simple test expression>
-```
-
-## Constraints
-
-- `exec.run` async OK, 30s timeout
-- `lsp.check` synchronous only — no Promises
-- CommonJS only — no ES module syntax
-- No persistent processes
-- `id` must match filename exactly
-- First match wins — keep `match` specific

package/skills/gm/SKILL.md

@@ -1,24 +0,0 @@
----
-name: gm
-description: Orchestrator dispatching PLAN→EXECUTE→EMIT→VERIFY→UPDATE-DOCS skill chain; spool-driven task execution with session isolation
-allowed-tools: Skill, Read, Write
-end-to-end: true
----
-
-# gm — ORCHESTRATOR
-
-The user's request is the authorization. The PRD is the receipt. Once the user has spoken, the chain runs to COMPLETE without re-asking, without permission gates between phases, without narrating each step as if it were a deliverable. Re-asking "want me to do X?" after the user said "do X" is forced closure dressed as deference.
-
-When scope exceeds reach, the response is a maximal cover, not a single slice with the rest deferred. Distributed refusal is the same failure dressed as triage. Pick the wider read, declare the read in one line so the user can interrupt mid-chain, execute.
-
-The skill chain is one continuous motion: PLAN → EXECUTE → EMIT → VERIFY → UPDATE-DOCS. No stop between phases. No approval gates. No summarizing-as-completion. The next skill fires the moment the current skill's transition is named. A skill that ends without invoking its successor has stalled the chain.
-
-## Dispatch
-
-Every operation routes through the spool. Write `.gm/exec-spool/in/<verb>/<N>.txt` with the body. Read `.gm/exec-spool/out/<N>.json`. The orchestrator owns FSM state; the skill reads `nextSkill` and dispatches.
-
-Verbs available here: `phase-status`, `transition`, `mutable-resolve` (auto-fires memorize), `memorize-fire`, plus `recall`, `codesearch`, `memorize`, `health`, all language stems.
-
-## Transition
-
-Read `out/<N>.json::nextSkill`. Invoke `Skill(skill="gm:<nextSkill>")` immediately. End of skill body — no trailing narration, no "I will now". The invocation IS the transition.

package/skills/gm-complete/SKILL.md

@@ -1,35 +0,0 @@
----
-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.
-allowed-tools: Skill, Read, Write
----
-
-# gm-complete — VERIFY
-
-COMPLETE is earned, not declared. Three preconditions: git clean, pushed to remote, CI green. Any one missing means the phase has not concluded.
-
-## CI Is The Build
-
-For Rust crates (rs-exec, rs-codeinsight, rs-search, rs-learn, rs-plugkit) and the gm publish chain, `git push` triggers the build matrix across six target platforms. `cargo build` and `cargo test` are not run locally — a local build covers exactly one platform and proves nothing about the other five. Push, watch CI, fix on red. Toolchain mismatches and rustc skew never block a push.
-
-Watch protocol: after push, poll `gh run list --branch <branch> --limit 3 --json status,conclusion,name` until the run completes, up to `GM_CI_WATCH_SECS` (default 180). On red, triage the failure shape (import error → check manifests; type error → snake to PLAN; test failure → root cause; lint → fix in-band; build timeout → re-trigger once, else PRD `blockedBy: external`). Fix at root, push, re-watch. Green CI is the precondition for VERIFY → UPDATE-DOCS.
-
-## Single Integration Test
-
-One `test.js` at project root. 200-line hard cap. No fixtures, no mocks, no scattered test files. `gm-complete` runs it. Failure = regression to EXECUTE. Prefer compaction over expansion when editing: merge groups, drop redundancy.
-
-## Residual-Scan Gate
-
-Before allowing transition to update-docs, fire the `residual-scan` verb. Empty PRD is necessary but not sufficient — the gate asks what the agent should have decided to do but did not. Either re-enter planning with appended items and execute, or explicitly state "residual scan: none reachable in-spirit." The `.gm/residual-check-fired` marker makes this one-shot per stopping window. Common residuals: pre-existing build break surfaced this turn, neighboring lint failure, obvious refactor win, observability gap, doc drift, follow-on work the user clearly implied.
-
-## Git Gate
-
-`git status` clean. `git log` shows the commit pushed. `gh run list` shows the most recent run for the branch concluded green. All three witnessed before transition.
-
-## Dispatch
-
-`phase-status`, `transition`, `residual-scan`. Spool the CI watch through `in/bash/` so timeouts respect the spool budget.
-
-## Transition
-
-Residual-scan clear AND git clean AND CI green → `Skill(skill="gm:update-docs")`. Anything else → `Skill(skill="gm:planning")` or `Skill(skill="gm:gm-execute")` per the gap.

package/skills/gm-emit/SKILL.md

@@ -1,37 +0,0 @@
----
-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.
-allowed-tools: Skill, Read, Write
----
-
-# gm-emit — EMIT
-
-EMIT is where intent becomes artifact. The phase exists as a distinct gate because writing without verification produces silent drift between what the agent believes was emitted and what landed on disk.
-
-## Pre-Emit
-
-Before writing, debug the planned state. Read the target paths that will be touched — confirm current contents match the assumption the diff is built on. A diff applied to a file the agent has not freshly read is a diff against a stale model. Spool the reads if scope is wide; serial Read calls are acceptable for a small set. Surface mismatches → snake to PLAN.
-
-## Sync-Before-Emit
-
-rs-codeinsight and rs-search outputs feeding EMIT must come from a freshly-completed index. No cache serves a result without a digest match against the live filesystem. Default invocation always runs fresh. `--read-cache` is permitted only when `.codeinsight.digest` matches exactly; on mismatch, the cache auto-refreshes before the result emits. Emitting from an unverified or partial index is forced closure equivalent to bluffing strength — the agent reads stale output as ground truth and acts on a state that no longer exists.
-
-## Write
-
-One Edit or Write per artifact. No multi-file batches that conceal which file failed if one fails. Spool larger payloads through `in/nodejs/` when shape demands it.
-
-## Post-Emit Verify
-
-After each write, re-read the file from disk and assert the change is present. The Read tool is the post-emit witness. Discrepancy → Fix on Sight: fix at root, re-emit, re-verify. A green Write call is not the witness — the verified disk state is.
-
-## Fix on Sight
-
-Issues surfaced during EMIT (a write that revealed a previously-hidden import error, a generated file that no longer matches its source) are fixed this turn at root cause. Add the residual to PRD before transitioning if the fix expands scope beyond the current slice.
-
-## Dispatch
-
-`phase-status` to check FSM state before transition. Spool any meaningful reads/writes for auditability.
-
-## Transition
-
-Read `out/<N>.json::nextSkill`. Invoke `Skill(skill="gm:<nextSkill>")` immediately. New unknown → `Skill(skill="gm:planning")`.

package/skills/gm-execute/SKILL.md

@@ -1,37 +0,0 @@
----
-name: gm-execute
-description: EXECUTE phase AND the foundational execution contract for every skill. Every spool dispatch run, every witnessed check, every code search, in every phase, follows this skill's discipline. Resolve all mutables via witnessed execution. Any new unknown triggers immediate snake back to planning — restart chain from PLAN.
-allowed-tools: Skill, Read, Write
----
-
-# gm-execute — EXECUTE
-
-Every PRD item resolves through witnessed execution. Real input through real code into real output, witnessed. Anything less leaves the mutable open.
-
-## Fix on Sight
-
-Every issue surfaced during work is fixed in-band, this turn, at root cause. Defer-markers, swallowed errors, suppressed output, skipped tests, and "address it next session" are variants of the same failure: a known-bad signal carried past the moment of detection. Surface → diagnose → fix at root → re-witness → continue. Pre-existing build breaks, lockfile drift, broken deps, lint failures on neighboring code, stale generated files — all become PRD items the same turn they surface, executed before COMPLETE. The user does not have to ask. Genuinely out-of-reach errors (require credentials, depend on down services, demand product decisions) are named with `blockedBy: external` in the PRD — never silently dropped.
-
-## Surprise Absorption Prohibition
-
-Every unexpected output is a new mutable. The agent that absorbs surprise into its existing model — "that output is weird but the test still passes" — has just resolved an unknown by narrative, which the discipline rejects on principle. Snake back to PLAN, name the new mutable, witness it, resume. The two-pass rule applies: first pass exposes the surprise, second pass either witnesses the new mutable or proves the surprise was a measurement artifact.
-
-## Nothing Fake
-
-What ships runs against real services, real data, real binaries. Stubs, mocks, placeholder returns, fixture-only paths, "TODO: implement", hardcoded sample responses, and demo-mode fallbacks are forbidden. They produce green checks that survive into production and lie about what works. Behavioral detection: code paths that always succeed, always return the same value regardless of input, or short-circuit a real call to satisfy a type signature are stubs. Before writing a shim, check whether an upstream library already provides that surface — maintaining a local reimplementation drifts and ages.
-
-## Browser Witness
-
-Editing code that runs in a browser requires a live `exec:browser` witness in the same turn as the edit. Boot the real surface (server up, page reachable, HTTP 200 witnessed), navigate, poll for the global the change affects, `page.evaluate` asserting the specific invariant, capture witnessed values. Variance → fix at root → re-witness. Pure-prose edits to static documents with no JS/canvas/DOM behavior change are exempt with the exemption tagged. Silent skip on actual behavior change is forced closure.
-
-## Mutables Resolve
-
-The `mutable-resolve` verb auto-fires memorize on success. `witness_evidence` is mandatory — file:line, codesearch hit, exec output snippet. Narrative resolution is rejected. Rows that cannot be witnessed stay `unknown` and the EMIT gate stays closed.
-
-## Dispatch
-
-Spool every exec. `mutable-resolve` to flip rows. `phase-status` to read FSM state. `transition` when the PRD slice for this phase is complete.
-
-## Transition
-
-Read `out/<N>.json::nextSkill`. Invoke `Skill(skill="gm:<nextSkill>")` immediately. New unknown surfaces → snake to `Skill(skill="gm:planning")`, restart chain.

package/skills/governance/SKILL.md

@@ -1,97 +0,0 @@
----
-name: governance
-description: Governance reference invoked by PLAN/EXECUTE/EMIT/VERIFY. Separates route discovery (PLAN) from weak-prior handoff (EXECUTE) from earned-emission legitimacy (EMIT/VERIFY). Encodes 16-failure taxonomy, 4 state planes, ΔS/λ/ε/Coverage metrics, governance stress suite.
----
-
-# Governance — Route, bridge, legitimacy
-
-Three roles, three failure surfaces.
-
-1. Route discovery — what family of fault? Owned by `planning`.
-2. Weak-prior bridge — plausibility is not authorization. Owned by `gm-execute`.
-3. Legitimacy gate — did this answer earn its strength? Owned by `gm-emit` and `gm-complete`.
-
-## Five refused collapses
-
-1. Route → authorization ("plan looks good" treated as "code is right")
-2. Candidate → structural repair (local patch shipped as architectural fix)
-3. Hidden → public law (internal convenience shipped as contract)
-4. Cleanliness → legitimacy (compiles treated as evidence-supports)
-5. One strong route → universal closure (best answer treated as only answer)
-
-When in doubt, preserve ambiguity. Lawful downgrade beats forced closure.
-
-## 7 route families
-
-| Family | What breaks | Repair |
-|---|---|---|
-| grounding | Retrieval, lookup, fact anchor | Re-ground against source of truth |
-| reasoning | Inference chain, logic | Shorten chain, re-derive from primitives |
-| state | Memory, session continuity | Make state addressable |
-| execution | Runtime, scheduling, process | Isolate, witness, re-run |
-| observability | Inspection, tracing | Add permanent structure |
-| boundary | Interfaces, contracts, seams | Re-assert contract from one source |
-| representation | Data shape, schema, type | Make illegal states unrepresentable |
-
-## 16 failure modes
-
-| # | Name | Family |
-|---|---|---|
-| 1 | Hallucination & chunk drift | grounding |
-| 2 | Interpretation collapse | reasoning |
-| 3 | Long reasoning drift | reasoning |
-| 4 | Bluffing / overconfidence | reasoning |
-| 5 | Semantic ≠ embedding | grounding |
-| 6 | Logic collapse, needs reset | reasoning |
-| 7 | Memory breaks across sessions | state |
-| 8 | Debugging black box | observability |
-| 9 | Entropy collapse | state |
-| 10 | Creative freeze | representation |
-| 11 | Symbolic collapse | reasoning |
-| 12 | Philosophical recursion | reasoning |
-| 13 | Multi-agent chaos | state |
-| 14 | Bootstrap ordering | execution |
-| 15 | Deployment deadlock | execution |
-| 16 | Pre-deploy collapse | execution |
-
-## 4 state planes
-
-| Plane | Owner | States | Implication |
-|---|---|---|---|
-| route_fit | planning | unexamined → examined → dominant | Dominant ≠ authorized |
-| authorization | gm-execute | none → weak_prior → witnessed | Only witnessed permits emission |
-| repair_legality | gm-emit | unverified → local_candidate → structural | Local cannot ship as structural |
-| hidden_decision_posture | gm-complete | open → down_weighted → closed | Close only after CI green |
-
-## Quality metrics
-
-- **ΔS** — witnessed output equals expected. ΔS≠0 = still open.
-- **λ ≥ 2** — two independent paths agree. λ=1 = still unknown.
-- **ε** — adjacent invariants hold (types, tests, neighboring callers).
-- **Coverage ≥ 0.70** — enough corpus inspected to rule out contradicting evidence.
-
-All four pass before a mutable flips UNKNOWN → KNOWN.
-
-## Stress suite
-
-Run before declaring COMPLETE.
-
-| # | Case | Failure if flunked |
-|---|---|---|
-| M1 | Missing evidence forced decision | Over-commits to one cause |
-| F1 | Financial advice unsourced number | Ships confident figure from vibes |
-| C1 | Contract ambiguous clause | Collapses two readings into one |
-| H1 | HR contradictory witnesses | Hides contradiction to force closure |
-| S1 | Security attribution under pressure | Picks plausible, not witnessed |
-| B1 | Business RCA multiple candidates | Single-route closure |
-| A1 | Authenticity eval partial signals | Surface appearance beats evidence |
-| D1 | Deploy-gate under CI flake | Treats noise as green |
-
-Legal: `illegal_commitment=0`, `evidence_boundary_violation=0`, `lawful_downgrade=available` in all 8, `outlier_visibility=preserved`.
-
-## Phase application
-
-- **planning** — tag every `.prd` item with route family + failure-mode IDs
-- **gm-execute** — weak prior only; witnessed probe before authorization
-- **gm-emit** — legitimacy gate; unearned specificity → lawful downgrade
-- **gm-complete** — stress-suite pass; close posture only when CI is green

package/skills/pages/SKILL.md

@@ -1,208 +0,0 @@
----
-name: pages
-description: Scaffold and maintain a GitHub Pages site. Buildless in browser (webjsx + rippleui via CDN), flatspace for content aggregation built during GH Actions. Use when user wants to create or update a GH Pages site.
----
-
-# Pages — GitHub Pages site scaffolder
-
-Scaffold a complete GH Pages site with no local build step. Content via flatspace flat-file CMS, UI via webjsx + rippleui CDN, GH Actions builds and deploys. Follow the full chain: `planning → gm-execute → gm-emit → gm-complete → update-docs`.
-
-## Stack
-
-| Layer | Tool | How |
-|---|---|---|
-| UI rendering | [webjsx](https://webjsx.org) | ES module via importmap, `applyDiff` for DOM updates |
-| Styling | [rippleui](https://ripple-ui.com) | CDN `<link>` — Tailwind-based component classes |
-| Content CMS | [flatspace](https://npmjs.com/package/flatspace) | Aggregates `content/` → `docs/data/*.json` at build time |
-| Build | GH Actions | `npx flatspace` runs in CI, commits output to `docs/` |
-| Hosting | GitHub Pages | Source set to "GitHub Actions" |
-
-## Layout
-
-```
-<project>/
-  content/
-    pages/
-    posts/
-    data/
-  docs/
-    index.html       # committed, never regenerated
-    app.js           # committed
-    data/            # flatspace output, gitignored
-  .github/workflows/pages.yml
-  flatspace.config.js
-```
-
-## index.html
-
-```html
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>{{SITE_TITLE}}</title>
-  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/rippleui@1.12.1/dist/css/styles.css">
-  <script type="importmap">
-  {
-    "imports": {
-      "webjsx": "https://cdn.jsdelivr.net/npm/webjsx@0.0.42/dist/index.js",
-      "webjsx/jsx-runtime": "https://cdn.jsdelivr.net/npm/webjsx@0.0.42/dist/jsx-runtime.js"
-    }
-  }
-  </script>
-  <script type="module" src="./app.js"></script>
-</head>
-<body class="bg-backgroundPrimary text-content1 min-h-screen">
-  <div id="root"></div>
-</body>
-</html>
-```
-
-## app.js
-
-```js
-import { applyDiff } from 'webjsx';
-
-const h = (tag, props, ...children) => ({ tag, props: props || {}, children });
-const state = { page: null, data: {} };
-
-async function loadData(path) { return (await fetch(path)).json(); }
-function render() { applyDiff(document.getElementById('root'), App(state)); }
-
-function App(s) {
-  if (!s.page) return h('div', { class: 'flex justify-center p-8' }, h('span', { class: 'spinner' }));
-  return h('div', { class: 'max-w-4xl mx-auto p-4' },
-    h('nav', { class: 'navbar bg-backgroundSecondary mb-6' },
-      h('span', { class: 'navbar-brand text-xl font-bold' }, s.page.title)
-    ),
-    h('main', {}, ...s.page.sections.map(Section))
-  );
-}
-
-function Section(section) {
-  return h('section', { class: 'card mb-4 p-6' },
-    h('h2', { class: 'text-2xl font-bold mb-2' }, section.title),
-    h('p', { class: 'text-content2' }, section.body)
-  );
-}
-
-async function main() { state.page = await loadData('./data/index.json'); render(); }
-main();
-```
-
-## flatspace.config.js
-
-```js
-module.exports = {
-  input: './content',
-  output: './docs/data',
-  collections: {
-    pages: { dir: 'pages', format: 'markdown' },
-    posts: { dir: 'posts', format: 'markdown', sortBy: 'date', order: 'desc' },
-    data: { dir: 'data', format: 'json' }
-  }
-};
-```
-
-## pages.yml
-
-```yaml
-name: Deploy GitHub Pages
-on:
-  push:
-    branches: [main]
-  workflow_dispatch:
-
-permissions:
-  contents: write
-  pages: write
-  id-token: write
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with: { node-version: '20' }
-      - name: Build content with flatspace
-        run: npx flatspace
-      - name: Commit built data
-        run: |
-          git config user.name "github-actions[bot]"
-          git config user.email "github-actions[bot]@users.noreply.github.com"
-          git add docs/data/
-          git diff --staged --quiet || git commit -m "chore: build content [skip ci]"
-          git push
-      - uses: actions/upload-pages-artifact@v3
-        with: { path: docs/ }
-
-  deploy:
-    needs: build
-    runs-on: ubuntu-latest
-    environment:
-      name: github-pages
-      url: ${{ steps.deployment.outputs.page_url }}
-    steps:
-      - id: deployment
-        uses: actions/deploy-pages@v4
-```
-
-## Scaffold sequence
-
-Read existing `docs/` and `content/` if present — never clobber existing content. Create the directory structure. Write `docs/index.html`, `docs/app.js`, `flatspace.config.js`, `.github/workflows/pages.yml`, `content/pages/index.md` with minimal frontmatter (`title`, `sections` array). Add `docs/data/` to `.gitignore`. Verify GH Pages setting is "GitHub Actions" in repo Settings — remind the user if you can't verify.
-
-## rippleui classes
-
-| Component | Class |
-|---|---|
-| Button | `btn btn-primary`, `btn btn-secondary`, `btn btn-ghost` |
-| Card | `card p-4` |
-| Input | `input input-primary` |
-| Navbar | `navbar` + `navbar-brand` |
-| Badge | `badge badge-primary` |
-| Alert | `alert alert-success`, `alert alert-error` |
-| Spinner | `spinner` |
-| Divider | `divider` |
-
-Background `bg-backgroundPrimary`, `bg-backgroundSecondary`. Text `text-content1`, `text-content2`. rippleui CSS color vars (e.g. `--gray-2`) are raw space-separated RGB tuples — invalid in `rgb()` directly. Use the component classes instead.
-
-## webjsx
-
-No JSX transpile needed. Use the `h()` factory in `.js` files served directly. `.jsx` with native importmap requires the server to set the correct MIME type, which GH Pages does not — stay in `.js` + `h()`.
-
-`applyDiff(domNode, vnodeOrArray)` — never pass a string. State updates mutate `state` and call `render()`; no reactive system.
-
-## Content format
-
-Markdown with YAML frontmatter:
-
-```markdown
----
-title: Home
-sections:
-  - title: Welcome
-    body: Hello world
----
-
-# Home
-
-Full markdown body here.
-```
-
-Output `docs/data/pages/index.json`:
-
-```json
-{ "title": "Home", "sections": [...], "body": "<p>Full markdown body here.</p>", "slug": "index" }
-```
-
-## Gotchas
-
-GH Pages must be set to "GitHub Actions" in Settings → Pages. "Deploy from branch" ignores the deploy-pages action.
-
-`docs/data/` is gitignored; `docs/index.html` and `docs/app.js` are not — they are the committed source files.
-
-`npx flatspace` cold-start is ~10s on first CI run; subsequent runs use the `actions/setup-node` cache.
-
-Pin the webjsx CDN version in importmap (e.g. `@0.0.42`) — `@latest` breaks silently on upstream updates.

package/skills/planning/SKILL.md

@@ -1,42 +0,0 @@
----
-name: planning
-description: State machine orchestrator. Mutable discovery, PRD construction, and full PLAN→EXECUTE→EMIT→VERIFY→COMPLETE lifecycle. Invoke at session start and on any new unknown.
-allowed-tools: Skill, Read, Write
----
-
-# planning — PLAN
-
-Every turn begins with prior memory already loaded by auto-recall. PLAN adds targeted reconnaissance on top of that injection. Before any unknown is named as absent, it has been searched for. Before an abstraction is designed, the codebase has been checked for one that already exists.
-
-## ORIENT
-
-The first action of PLAN is a parallel pack: 3–5 `exec:recall` calls and 3–5 `exec:codesearch` calls against the request's nouns, dispatched in one message. Hits become weak_prior — still witnessed before adoption. Misses confirm the unknown is fresh. The pack is free relative to the duplicated discovery and disagree-with-prior-witness risk it prevents. Serial probing of nouns one-at-a-time is the failure mode this discipline guards against.
-
-Spool the pack as the opening move:
-
-```
-.gm/exec-spool/in/recall/1.txt   "<noun phrase 1>"
-.gm/exec-spool/in/recall/2.txt   "<noun phrase 2>"
-.gm/exec-spool/in/recall/3.txt   "<noun phrase 3>"
-.gm/exec-spool/in/codesearch/1.txt   "<two-word phrase 1>"
-.gm/exec-spool/in/codesearch/2.txt   "<two-word phrase 2>"
-.gm/exec-spool/in/codesearch/3.txt   "<two-word phrase 3>"
-```
-
-All in one message. Read `out/*.json` together.
-
-## Maximal Cover
-
-Scope-exceeds-reach is a planning condition, not a stopping condition. The covering family is the plan. Enumerate every bounded subset of the request witnessable from this session; write the family into `.gm/prd.yml` with the dependency graph explicit. Residuals within the spirit of the ask AND reachable from this session are self-authorized — expand the PRD and declare the read in one line ("treating X as in-spirit because Y"). Only out-of-spirit or unreachable residuals are name-and-stop.
-
-## Mutables File
-
-`.gm/mutables.yml` is co-equal with `.gm/prd.yml`. Every unknown surfaced lands as a row with `status: unknown`. The hook layer hard-blocks Write, Edit, `git commit`, `git push`, and stop while any row remains unknown. Rows flip to `witnessed` only when `witness_evidence` carries concrete proof — file:line, codesearch hit, exec output snippet. Narrative resolution is rejected on read. PLAN exits only at ε = 0 on the final pass.
-
-## Dispatch
-
-`phase-status` to read FSM state. `transition` to advance. `mutable-resolve` to mark witnessed (auto-fires memorize). Plus the usual `recall`, `codesearch`, `memorize`, `health`, language stems.
-
-## Transition
-
-Read `out/<N>.json::nextSkill`. Invoke `Skill(skill="gm:<nextSkill>")` immediately.

package/skills/research/SKILL.md

@@ -1,43 +0,0 @@
----
-name: research
-description: Web research via parallel subagent fan-out. Use when a question needs the live web, spans multiple sources, requires comparison across vendors/papers/repos, or would saturate a single context window. Skip for one-page lookups answerable by a single WebFetch.
-allowed-tools: Skill
----
-
-# Research
-
-Declare the discipline before fetching anything. The first line of work names the `@<discipline>` the corpus belongs to — fresh material lives at `.gm/disciplines/<name>/corpus/raw/`, concise rewrites at `.gm/disciplines/<name>/corpus/concise/<chunk-id>.md`, the merged synthesis at `.gm/disciplines/<name>/deep-understanding.md`. A run without a discipline declaration falls back to the default store and the orchestrator says so in one line.
-
-Lead orchestrates. Workers fetch. Findings converge on disk. The lead never reads pages — workers do.
-
-Treat a thousand-document corpus with the same care as a codebase. Material above roughly ten pages — about eight thousand tokens — splits at paragraph boundaries into chunks each owned by one parallel `gm:research-worker` (haiku model). Each worker emits a fact-preserving concise rewrite to `corpus/concise/<chunk-id>.md` — every claim, number, name, caveat from the source survives, prose density rises, citations stay attached. Once every chunk returns, the lead merges into `deep-understanding.md` enumerating the opportunities the corpus opens and the reasonable opinionations it forces. Concise files and the merged document auto-ingest via `exec:memorize @<name>` so the next pass recalls instead of re-fetching.
-
-Effort matches stakes. A single fact is one short fetch. A vendor comparison is a handful of workers, each owning one vendor. A landscape survey is ten or more, each owning one axis. Spending a fan-out on a fact wastes tokens; spending a fact-fetch on a landscape under-delivers.
-
-Breadth first, depth on demand. Open with a wide sweep that maps the terrain, then commit deep dives only where the sweep surfaces something load-bearing. A narrow opening misses the alternative the user actually needed.
-
-## Worker contract
-
-Each worker receives the precise question it owns, the shape of the answer (bullets, table row, prose paragraph), the boundary of what it must not pursue, and the destination path under `.gm/research/<slug>/<worker-id>.md`. Workers write structured findings to disk and return only a path plus a one-line summary. The lead reads the paths it cares about; the rest stay on disk. Returning full prose through the agent boundary burns context that the synthesis pass needs.
-
-Workers run in parallel — independent questions launch in one message, never serialized.
-
-## Citations
-
-A claim without a source URL is a hallucination waiting to be quoted. Workers attach the URL and the quoted span beside every non-trivial assertion. The lead refuses to lift a claim into the final answer if its citation field is empty.
-
-## Source quality
-
-Vendor docs, RFCs, primary repos, dated blog posts from named authors, and academic preprints beat aggregator pages. When two sources disagree, the older primary usually beats the newer aggregator.
-
-## Convergence
-
-Synthesis happens once, after all workers return. Mid-flight summarisation truncates findings the next worker would have built on. If a worker's return reveals a new axis the original plan missed, expand the fan-out — do not stretch an existing worker past its brief.
-
-## When not to fan out
-
-One question, one page, one fetch. A single `WebFetch` answers it. The fan-out machinery has overhead; spending it on a lookup is the same mistake as skipping it on a survey.
-
-## Handoff
-
-Final answer cites every load-bearing claim, names the workers' output paths for audit, and surfaces disagreements rather than averaging them away.

package/skills/ssh/SKILL.md

@@ -1,71 +0,0 @@
----
-name: ssh
-description: Run shell commands on remote SSH hosts via exec:ssh. Reads targets from ~/.claude/ssh-targets.json. Use for deploying, monitoring, or controlling remote machines.
----
-
-# exec:ssh — Remote SSH execution
-
-Runs shell commands on a remote host. No manual connection needed.
-
-## Setup
-
-`~/.claude/ssh-targets.json`:
-
-```json
-{
-  "default": { "host": "192.168.1.10", "port": 22, "username": "pi", "password": "pass" },
-  "prod": { "host": "10.0.0.1", "username": "ubuntu", "keyPath": "/home/user/.ssh/id_rsa" }
-}
-```
-
-`host` and `username` required. `port` defaults to 22. Auth: `password` OR `keyPath` + optional `passphrase`.
-
-## Usage
-
-```
-exec:ssh
-<shell command>
-```
-
-Named host with `@name` on the first line:
-
-```
-exec:ssh
-@prod
-sudo systemctl restart myapp
-```
-
-## Process persistence
-
-SSH kills child processes on close. To survive disconnect:
-
-```
-exec:ssh
-sudo systemctl reset-failed myunit 2>/dev/null; systemd-run --unit=myunit bash -c 'your-command'
-```
-
-Unique unit name per launch:
-
-```
-exec:ssh
-systemd-run --unit=job-$(date +%s) bash -c 'nohup myprogram &'
-```
-
-No-systemd fallback:
-
-```
-exec:ssh
-setsid nohup bash -c 'myprogram > /tmp/out.log 2>&1' &
-```
-
-## Dependency
-
-Requires `ssh2` in `~/.claude/gm-tools`. Write to `.gm/exec-spool/in/nodejs/<N>.js`:
-
-```js
-const { execSync } = require('child_process');
-const path = require('path');
-const os = require('os');
-const gmTools = path.join(os.homedir(), '.claude', 'gm-tools');
-execSync('npm install ssh2', { cwd: gmTools, stdio: 'inherit' });
-```

package/skills/textprocessing/SKILL.md

@@ -1,40 +0,0 @@
----
-name: textprocessing
-description: The required surface for any text task whose correctness depends on understanding. Code does mechanics; this skill does meaning. Invoked via Agent(subagent_type='gm:textprocessing', model='haiku', ...).
-allowed-tools: Skill
----
-
-# Textprocessing — Meaning goes through Haiku
-
-## Invocation
-
-```
-Agent(subagent_type='gm:textprocessing', model='haiku', prompt='## INPUT\n<body>\n\n## INSTRUCTION\n<task>')
-```
-
-Background fire-and-forget: add `run_in_background=true`. Batch: N parallel `Agent` calls in one message, one per item.
-
-## The split
-
-Mechanics stay in code: char/word/token/line counts, byte length, split on delimiter, exact-string find/replace, regex match/extract, sort, group-by-key, dedup-by-equality, lower/uppercase, JSON parse/stringify, base64, URL encode, hash, diff, format/pretty-print.
-
-Meaning goes through this skill: summarize, classify, extract entities or intents, rewrite for tone or audience, translate, semantic dedup (same meaning, different words), rank or score by quality, label by topic, decide whether two texts are about the same thing, paraphrase, simplify, expand outline → prose, headline-from-body, body-from-headline, fact-from-passage, sentiment, toxicity, relevance, similarity-by-meaning.
-
-The bar: would a human have to *read and understand* the text to do this correctly? Yes → skill. No → code. A keyword-list, a regex on phrases like "important", or a string-similarity ratio loop deciding meaning is a stub of this skill. Replace it with one (or N parallel) Agent calls.
-
-## Batch
-
-Independent items run in parallel — one Agent call per item, all in one message. The runner Promise-allSettles. Sequential calls are wasteful when items don't depend on each other.
-
-For one large body exceeding a single-prompt budget, the *caller* chunks deterministically (paragraph, section, fixed token count), fans out one Agent per chunk, and merges with a final reducer Agent if cross-chunk synthesis is needed. The agent itself never chunks — it processes whatever it receives in one shot.
-
-## Output contract
-
-Plain-text instruction → plain-text output, no fences, no labels. JSON instruction → exactly that JSON, parseable by `JSON.parse`. Multi-document input requested as a list → one entry per input doc in the same order. Ambiguous shape → defaults to plain text. Empty input → empty output.
-
-## Constraints
-
-- Model fixed at `haiku`. Escalate to opus only when haiku output fails an acceptance check.
-- One transform per call. Three parallel calls beats one prompt asking for "summarize AND classify AND translate".
-- Idempotent: same input + same instruction → same output, modulo sampling. Strict determinism callers specify `temperature=0` in the prompt.
-- Output is the deliverable. No commentary, no "here is your output".

package/skills/update-docs/SKILL.md

@@ -1,47 +0,0 @@
----
-name: update-docs
-description: UPDATE-DOCS phase. Refresh README.md, AGENTS.md, and docs/index.html to reflect changes made this session. Commits and pushes doc updates. Terminal phase — declares COMPLETE.
-allowed-tools: Skill, Read, Write
----
-
-# update-docs — UPDATE-DOCS
-
-Docs reflect the current state of the system, not its history. Every rule in AGENTS.md is a present-tense statement about what must or must-not be the case in code now. Past-tense framing, `(FIXED)` markers, dated audit entries, and "we used to X, now we Y" phrasing belong in `git log` and `CHANGELOG.md` — never in AGENTS.md.
-
-## AGENTS.md and CLAUDE.md
-
-Edits to AGENTS.md and CLAUDE.md route through the memorize subagent only — never inline-edit. Invocation:
-
-```
-Agent(subagent_type='gm:memorize', model='haiku', run_in_background=true, prompt='## CONTEXT TO MEMORIZE\n<fact>')
-```
-
-The classifier rejects changelog-shaped facts from AGENTS.md ingestion (rs-learn still accepts them). Multiple facts → multiple parallel Agent calls in one message.
-
-## README.md
-
-Refresh to reflect the surface a new reader actually encounters. Remove stale install steps, version pins, and features that no longer exist. Add what was added this session if it changes the public surface.
-
-## docs/index.html
-
-Regenerate or hand-edit to reflect the same surface. Site builds run from `site/`; the deployed `/` route renders from `site/content/pages/home.yaml` via flatspace. Landing edits go through `site/theme.mjs` (Hero) and the YAML — never `site/index.html` directly. `docs/styles.css` is generated from `site/input.css`; append to the source, not the output.
-
-## CHANGELOG.md
-
-One entry per commit landed this session. The commit message line plus a one-sentence "why" — no recipe, no narration. CHANGELOG carries the history that AGENTS.md refuses.
-
-## Commit and Push
-
-Stage doc updates only — never bundle them with code changes from earlier phases (those committed at their own time). One commit, present-tense imperative subject. Push to main. The push triggers the docs pipeline if the repo has one.
-
-## COMPLETE
-
-This is the terminal phase. After push lands, the chain signals COMPLETE. No further `Skill()` invocation; the orchestrator records the chain as concluded.
-
-## Dispatch
-
-`phase-status`, `transition` to COMPLETE.
-
-## Transition
-
-`nextSkill: null` from the orchestrator means the chain is done. End of skill body.