gm-skill 2.0.1863 → 2.0.1865

package/AGENTS.md

@@ -152,13 +152,13 @@ A task that reduces to read/investigate/report, or a change confined to files th
 
 Push to any rs-* sibling -> `cascade.yml` -> rs-plugkit `release.yml` -> single `plugkit.wasm` (npm `plugkit-wasm` + `plugkit-bin` Releases) -> auto-bump `gm.json::plugkitVersion` -> `publish.yml` ships gm-skill+gm-plugkit+SKILL.md mirror. Step sequence + PUBLISHER_TOKEN: the recall store (`recall: cascade pipeline`).
 
-**Repos involved (push to any triggers cascade):** `AnEntrypoint/{rs-exec, rs-codeinsight, rs-search, rs-plugkit, gm}`. rs-learn is retired (crate removed from rs-plugkit, repo cascade/publish workflows deleted, README points at rs-plugkit). Roles, npm package names, legacy-retirement detail: the recall store (`recall: cascade repos involved roles`, `recall: legacy gm-skill variants retired`).
+**Repos involved (push to any triggers cascade):** `AnEntrypoint/{rs-codeinsight, rs-search, rs-plugkit, gm}`. rs-learn and rs-exec are retired (crates removed from / never depended on by rs-plugkit; their spool-dispatch and memory surfaces reimplemented natively in rs-plugkit wasm_dispatch; repos archived as tombstones, README points at rs-plugkit). Roles, npm package names, legacy-retirement detail: the recall store (`recall: cascade repos involved roles`, `recall: legacy gm-skill variants retired`).
 
 **To update every possible thing**: push to the relevant repo. No manual version bumps, no local `cargo update`/`cargo build` -- push, let CI build.
 
 ## Spool-dispatch architecture replaces hooks
 
-Orchestration state tracked via `.gm/` marker files, not hook events; CLI's `checkDispatchGates()` gates Write/Edit/git pre-execution. Marker set + SpoolDispatcher mechanism: the recall store (`recall: gate enforcement layer`, `recall: spool dispatch gates marker files`).
+Orchestration state tracked via `.gm/` marker files, not hook events; the gate that admits Write/Edit/git pre-execution runs natively inside `plugkit.wasm` (rs-plugkit `gates.rs` + the `hook_pre_tool_use`/`hook_stop` exports), driven off the same `.gm/` markers. (The former JS `lib/spool-dispatch.js`/`checkDispatchGates()` reimplementation was removed once the gate moved into the wasm binary.) Marker set + gate mechanism: the recall store (`recall: gate enforcement layer`, `recall: spool dispatch gates marker files`).
 
 **gm tool-use sequencing**: `Skill(skill="gm")` clears needs-gm gate. One shipped skill, no subagent variant. Marker mechanics: the recall store (`recall: gm-skill tool-use sequencing mechanics`).
 

package/README.md

@@ -61,7 +61,6 @@ gm/
 |-- bin/               <- bootstrap + plugkit launcher (gmsniff / ccsniff are separate npm packages, `bun x gmsniff`, `bun x ccsniff`)
 |-- lib/               <- runtime: spool dispatch, skill bootstrap, daemon mgmt
 |-- agents/            <- subagent prompts (gm, memorize, research-worker, textprocessing)
-|-- prompts/           <- bash-deny, session-start, prompt-submit, pre-compact
 |-- lang/              <- language packs (browser, ssh)
 |-- gm-plugkit/        <- separate npm package that ships the wasm-wrapper
 |-- gm.json            <- version + plugkit pin

package/gm-plugkit/instructions/residual/browser-open.md

@@ -1 +1 @@
-browser sessions still open — dispatch `browser` with `session list` body to enumerate open ids, then `session close <id>` for each before retrying residual-scan
+browser sessions still open -- dispatch `browser` with `session list` body to enumerate open ids, then `session close <id>` for each before retrying residual-scan

package/gm-plugkit/instructions/residual/dirty-tree.md

@@ -1 +1 @@
-worktree dirty — modified={modified} untracked={untracked} — commit or revert before residual scan; a push from a dirty tree orphans the unstaged delta
+worktree dirty -- modified={modified} untracked={untracked} -- commit or revert before residual scan; a push from a dirty tree orphans the unstaged delta

package/gm-plugkit/instructions/residual/imperative.md

@@ -1 +1 @@
-Residual scan. Worktree clean, remote pushed, PRD empty, mutables witnessed — the four checks. Anything reachable and in-spirit expands the PRD and runs. Out-of-reach is credentials, down service, product decision.
+Residual scan. Worktree clean, remote pushed, PRD empty, mutables witnessed -- the four checks. Anything reachable and in-spirit expands the PRD and runs. Out-of-reach is credentials, down service, product decision.

package/gm-plugkit/instructions/residual/tasks-running.md

@@ -1 +1 @@
-background tasks still running — wait for completion or kill them via the host_exec_js interface before retrying residual-scan
+background tasks still running -- wait for completion or kill them via the host_exec_js interface before retrying residual-scan

package/gm-plugkit/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gm-plugkit",
-  "version": "2.0.1863",
+  "version": "2.0.1865",
   "description": "Bootstrap and daemon-spawn tool for gm plugkit binary. Downloads the correct platform binary, verifies SHA256, and starts the spool watcher daemon. Includes plugkit-wasm-wrapper for WASM-based spool watching.",
   "main": "index.js",
   "bin": {
@@ -16,8 +16,6 @@
     "plugkit-wasm-wrapper.js",
     "plugkit.version",
     "plugkit.sha256",
-    "SKILL.md",
-    "SKILL-*.md",
     "instructions/"
   ],
   "keywords": [

package/gm-plugkit/plugkit-wasm-wrapper.js

@@ -2728,7 +2728,24 @@ function makeHostFunctions(instanceRef) {
               + `})();\n`;
             cmd = process.execPath; args = ['-e', memRunner];
           } else {
-            cmd = process.execPath; args = ['-e', code];
+            // Wrap in an async IIFE so top-level `return` (and top-level
+            // `await`) work -- `node/bun -e "return 2+2;"` is a SyntaxError
+            // at top level, but the gm exec_js contract lets code `return` a
+            // result. This mirrors the mem/profile paths and the browser verb.
+            // The returned value is emitted via a __GM_RESULT__ sentinel so the
+            // user's own stdout stays clean; a throw still prints its stack to
+            // stderr and exits 1, preserving the documented error channel.
+            const defRunner = `(async () => {\n`
+              + `  try {\n`
+              + `    const __r = await (async () => {\n${code}\n})();\n`
+              + `    try { console.log('__GM_RESULT__' + JSON.stringify(__r === undefined ? null : __r)); }\n`
+              + `    catch (__se) { console.log('__GM_RESULT__' + JSON.stringify({ __unserializable: String(__se && __se.message || __se) })); }\n`
+              + `  } catch (__e) {\n`
+              + `    console.error(String(__e && __e.stack || __e));\n`
+              + `    process.exitCode = 1;\n`
+              + `  }\n`
+              + `})();\n`;
+            cmd = process.execPath; args = ['-e', defRunner];
           }
         }
         else if (lang === 'python') { cmd = 'python'; args = ['-c', code]; }
@@ -2742,6 +2759,20 @@ function makeHostFunctions(instanceRef) {
         } finally {
           if (profileUserFile) { try { fs.unlinkSync(profileUserFile); } catch (_) {} }
         }
+        // Shared across all result branches: a genuine timeout kills the child
+        // near the deadline. A SIGTERM far under timeoutMs is a spurious /
+        // host-injected kill (e.g. the stale-watcher SIGTERM-at-28ms), not a
+        // timeout -- do not mislabel it as timed_out.
+        const __execDurMs = Date.now() - __execT0;
+        const __execTimedOut = result.signal === 'SIGTERM' && __execDurMs >= Math.floor(timeoutMs * 0.9);
+        // spawnSync sets result.error (and leaves status/signal null) when the
+        // child could NOT be started or was reaped abnormally (spawn race
+        // during watcher boot, ETIMEDOUT, EBADF, ENOENT for a missing runtime).
+        // Surface it so a status:-1 is diagnosable instead of a silent empty
+        // failure -- the caller sees WHY, not just exit_code:-1.
+        const __spawnError = result.error
+          ? { code: result.error.code || null, errno: result.error.errno || null, syscall: result.error.syscall || null, message: String(result.error.message || result.error) }
+          : null;
         if (wantProfile) {
           const raw = result.stdout || '';
           const idx = raw.indexOf('__GM_PROFILE__');
@@ -2752,14 +2783,15 @@ function makeHostFunctions(instanceRef) {
             stdout: idx >= 0 ? raw.slice(0, idx) : raw,
             stderr: result.stderr || '',
             exit_code: result.status === null ? -1 : result.status,
-            timed_out: result.signal === 'SIGTERM',
-            duration_ms: Date.now() - __execT0,
+            timed_out: __execTimedOut,
+            duration_ms: __execDurMs,
             result: parsed ? parsed.result : null,
             profile: parsed ? parsed.profile : { timeframe: null, culprits: [] },
             profile_error: parsed ? parsed.profile_error : 'profile sentinel not found in stdout',
             user_error: parsed ? parsed.user_error : null,
             mem: parsed ? parsed.mem : null,
             wall_vs_cpu: parsed ? parsed.wall_vs_cpu : null,
+            ...(__spawnError ? { spawn_error: __spawnError } : {}),
           });
         }
         if (opts.mem === true && isJsLang) {
@@ -2772,21 +2804,41 @@ function makeHostFunctions(instanceRef) {
             stdout: idx >= 0 ? raw.slice(0, idx) : raw,
             stderr: result.stderr || '',
             exit_code: result.status === null ? -1 : result.status,
-            timed_out: result.signal === 'SIGTERM',
-            duration_ms: Date.now() - __execT0,
+            timed_out: __execTimedOut,
+            duration_ms: __execDurMs,
             result: meta ? meta.result : null,
             mem: meta ? meta.mem : null,
             wall_ms: meta ? meta.wall_ms : null,
             ...(meta && meta.error ? { error: meta.error } : {}),
+            ...(__spawnError ? { spawn_error: __spawnError } : {}),
           });
         }
+        let __defStdout = result.stdout || '';
+        let __defResult = null;
+        let __defHasResult = false;
+        if (isJsLang) {
+          const __ri = __defStdout.lastIndexOf('__GM_RESULT__');
+          if (__ri >= 0) {
+            const __tail = __defStdout.slice(__ri + '__GM_RESULT__'.length);
+            const __nl = __tail.indexOf('\n');
+            const __jsonStr = __nl >= 0 ? __tail.slice(0, __nl) : __tail;
+            try { __defResult = JSON.parse(__jsonStr); __defHasResult = true; } catch (_) {}
+            // Strip the __GM_RESULT__ sentinel line (console.log emits it on its
+            // own line after the user's output) so the caller's stdout is clean.
+            let __clean = __defStdout.slice(0, __ri) + (__nl >= 0 ? __tail.slice(__nl + 1) : '');
+            if (__clean.endsWith('\n')) __clean = __clean.slice(0, -1);
+            __defStdout = __clean;
+          }
+        }
         return writeWasmJson(instanceRef.value, {
           ok: result.status === 0,
-          stdout: result.stdout || '',
+          stdout: __defStdout,
           stderr: result.stderr || '',
           exit_code: result.status === null ? -1 : result.status,
-          timed_out: result.signal === 'SIGTERM',
-          duration_ms: Date.now() - __execT0,
+          timed_out: __execTimedOut,
+          duration_ms: __execDurMs,
+          ...(__defHasResult ? { result: __defResult } : {}),
+          ...(__spawnError ? { spawn_error: __spawnError } : {}),
           ...(profileSkipped ? { profile_skipped: profileSkipped } : {}),
         });
       } catch (e) {
@@ -4327,7 +4379,18 @@ async function runSpoolWatcher(instance, spoolDir) {
 
   setTimeout(() => {
     try {
-      _writeStatusBusy(360000);
+      // The boot warmup's codesearch triggers a codeinsight reindex + full
+      // in-wasm embed of the project when the stored digest is absent/stale.
+      // That embed is a SYNCHRONOUS wasm call that blocks the event loop, so
+      // the 5s heartbeat interval cannot fire while it runs. On a large repo a
+      // cold embed can take several minutes; if it exceeds the busy_until
+      // window the supervisor's stale-heartbeat check kills the watcher
+      // mid-embed, the digest never persists, and every respawn re-embeds from
+      // scratch -- an unbounded restart loop that spawns duplicate watchers.
+      // The window must therefore comfortably exceed the worst-case cold embed;
+      // it is a one-time cost (the digest persists after a single completion,
+      // so subsequent boots' warmup is near-instant).
+      _writeStatusBusy(1200000);
       const vb = new TextEncoder().encode('codesearch');
       const bb = new TextEncoder().encode(JSON.stringify({ query: 'index warmup', k: 1 }));
       const vp = writeWasmInput(instance, vb, 'boot-warmup:codesearch.verb');

package/gm-plugkit/supervisor.js

@@ -159,6 +159,22 @@ function readShutdownReason() {
   try { return JSON.parse(fs.readFileSync(SHUTDOWN_REASON_PATH, 'utf-8')); } catch (_) { return null; }
 }
 
+// A supervisor-initiated kill is PLANNED (version/wrapper drift, heartbeat-stale),
+// but on Windows process.kill(pid,'SIGTERM') terminates the child immediately with
+// no catchable signal, so the child never writes its own .shutdown-reason.json and
+// the taskkill /F that follows leaves none either -- the NEXT boot then mislabels a
+// deliberate upgrade recycle as a SILENT ABORT / unplanned-restart critical. Write
+// the planned reason on the child's behalf BEFORE killing, so the next boot reads a
+// fresh planned shutdown reason and classifies the restart correctly.
+function killChild(reason) {
+  if (!currentChildPid) return;
+  try { fs.writeFileSync(SHUTDOWN_REASON_PATH, JSON.stringify({ reason, ts: Date.now(), pid: currentChildPid, killed_by_supervisor: true })); } catch (_) {}
+  try { process.kill(currentChildPid, 'SIGTERM'); } catch (_) {}
+  if (process.platform === 'win32') {
+    try { spawnSync('taskkill', ['/F', '/T', '/PID', String(currentChildPid)], { stdio: 'ignore', windowsHide: true, timeout: 3000 }); } catch (_) {}
+  }
+}
+
 let lastSpawnedAt = 0;
 let lastVersionDriftActionAt = 0;
 let restartTimestamps = [];
@@ -258,7 +274,7 @@ function spawnWatcher(bootReason) {
     const idleClean = reason === 'idle';
     const lockRejected = code === 75;
     const cleanExit = code === 0;
-    const plannedReasons = new Set(['idle', 'sigterm', 'version-change', 'wrapper-change', 'peer-stale-takeover', 'external-planned', 'process-exit']);
+    const plannedReasons = new Set(['idle', 'sigterm', 'version-change', 'wrapper-change', 'heartbeat-stale', 'peer-stale-takeover', 'external-planned', 'process-exit']);
     const isPlanned = plannedReasons.has(reason) || lockRejected || cleanExit;
     const eventName = idleClean
       ? 'supervisor.watcher-exited-idle'
@@ -335,10 +351,7 @@ function checkWatcherHealth() {
       stale_limit_ms: STATUS_STALE_MS,
       severity: 'critical',
     });
-    try { process.kill(currentChildPid, 'SIGTERM'); } catch (_) {}
-    if (process.platform === 'win32') {
-      try { spawnSync('taskkill', ['/F', '/T', '/PID', String(currentChildPid)], { stdio: 'ignore', windowsHide: true, timeout: 3000 }); } catch (_) {}
-    }
+    killChild('heartbeat-stale');
     return;
   }
   const reported = status.wrapper_sha || null;
@@ -350,10 +363,7 @@ function checkWatcherHealth() {
       on_disk_sha: onDisk,
       severity: 'info',
     });
-    try { process.kill(currentChildPid, 'SIGTERM'); } catch (_) {}
-    if (process.platform === 'win32') {
-      try { spawnSync('taskkill', ['/F', '/T', '/PID', String(currentChildPid)], { stdio: 'ignore', windowsHide: true, timeout: 3000 }); } catch (_) {}
-    }
+    killChild('wrapper-change');
     return;
   }
   if (status.version_drifted === true) {
@@ -377,10 +387,7 @@ function checkWatcherHealth() {
         try { fs.unlinkSync(path.join(gmTools, f)); } catch (_) {}
       }
     } catch (_) {}
-    try { process.kill(currentChildPid, 'SIGTERM'); } catch (_) {}
-    if (process.platform === 'win32') {
-      try { spawnSync('taskkill', ['/F', '/T', '/PID', String(currentChildPid)], { stdio: 'ignore', windowsHide: true, timeout: 3000 }); } catch (_) {}
-    }
+    killChild('version-change');
   }
 }
 

package/gm.json

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

package/lib/spool.js

@@ -1,6 +1,5 @@
 const fs = require('fs');
 const path = require('path');
-const os = require('os');
 
 function getSpoolBaseDir() {
   const cwd = process.cwd();
@@ -162,54 +161,10 @@ async function execSpool(body, lang, options = {}) {
   return result;
 }
 
-async function execCodesearch(query, options = {}) { return execSpool(query, 'codesearch', options); }
-async function execRecall(query, options = {}) { return execSpool(query, 'recall', options); }
-async function execMemorize(fact, options = {}) { return execSpool(fact, 'memorize', options); }
-
-function getAllOutputs() {
-  const baseDir = getSpoolBaseDir();
-  const outDir = path.join(baseDir, 'out');
-
-  if (!fs.existsSync(outDir)) {
-    return [];
-  }
-
-  const files = fs.readdirSync(outDir);
-  const taskIds = new Set();
-
-  files.forEach(file => {
-    const match = file.match(/^(.+?)\.(out|err|json)$/);
-    if (match) {
-      taskIds.add(match[1]);
-    }
-  });
-
-  return Array.from(taskIds).map(id => readSpoolOutput(id));
-}
-
-async function getEvents(sessionId, cwd) {
-  try {
-    const { getSnapshot } = require('./skill-bootstrap');
-    return await getSnapshot(sessionId, cwd);
-  } catch (e) {
-    return { error: e.message };
-  }
-}
-
 module.exports = {
   writeSpool,
   writeSpoolVerb,
   readSpoolOutput,
   waitForCompletion,
-  execSpool,
-  execCodesearch,
-  execRecall,
-  execMemorize,
-  getAllOutputs,
-  getSpoolBaseDir,
-  generateTaskId,
-  validateLang,
-  getExtForLang,
-  validateVerb,
-  getEvents
+  execSpool
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gm-skill",
-  "version": "2.0.1863",
+  "version": "2.0.1865",
   "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",
@@ -31,7 +31,6 @@
   "files": [
     "skills/",
     "agents/",
-    "prompts/",
     "lib/",
     "lang/",
     "scripts/",

package/skills/fifth-dimension-engine/SKILL.md

@@ -121,7 +121,7 @@ See `references/research-kernel-extraction.md` for how mixed themes become resea
 
 ### Everyday Problems
 
-The same engine works on ordinary decisions, work problems, product questions, and engineering failures — any well-specified target benefits from being shot into a route rather than answered directly.
+The same engine works on ordinary decisions, work problems, product questions, and engineering failures -- any well-specified target benefits from being shot into a route rather than answered directly.
 
 ## Verification
 
@@ -141,7 +141,7 @@ This skill does not:
 ## References
 
 See `references/` directory for:
-- `route-structure.md` — what a route is and how it is structured
-- `research-kernel-extraction.md` — turning ideas into research kernels
-- `route-inspection-guide.md` — how to verify and attack a route
-- `skills/polaris-protocol/SKILL.md` — the Polaris Protocol tree root and state machine
+- `route-structure.md` -- what a route is and how it is structured
+- `research-kernel-extraction.md` -- turning ideas into research kernels
+- `route-inspection-guide.md` -- how to verify and attack a route
+- `skills/polaris-protocol/SKILL.md` -- the Polaris Protocol tree root and state machine

package/skills/fifth-dimension-engine/references/research-kernel-extraction.md

@@ -1,4 +1,4 @@
-# Research Kernel Extraction — Fifth-Dimension Engine
+# Research Kernel Extraction -- Fifth-Dimension Engine
 
 Mixing two unrelated themes turns them into a theorem-shaped research kernel. The same mechanic generalizes to ordinary research questions.
 
@@ -16,12 +16,12 @@ The engine's job is to move a target from symbol to structure:
 1. Name the two themes.
 2. Shoot them together.
 3. Read the returned route: what structure does the engine propose?
-4. Inspect the candidate lemmas — are they real mathematical objects, or metaphor?
+4. Inspect the candidate lemmas -- are they real mathematical objects, or metaphor?
 5. Keep the parts that survive inspection; discard the parts that are only poetry.
 
 ## Everyday research use
 
-The same pattern works without strangeness — shoot an ordinary open research question directly. The engine returns a route: candidate theoretical bounds, objections, open questions. You then verify the lemmas and expand the open debt into real research.
+The same pattern works without strangeness -- shoot an ordinary open research question directly. The engine returns a route: candidate theoretical bounds, objections, open questions. You then verify the lemmas and expand the open debt into real research.
 
 ## What this does NOT claim
 

package/skills/fifth-dimension-engine/references/route-inspection-guide.md

@@ -1,4 +1,4 @@
-# Route Inspection Guide — Fifth-Dimension Engine
+# Route Inspection Guide -- Fifth-Dimension Engine
 
 A route from the Fifth-Dimension Engine is not a final answer. It is a structure you can inspect, attack, expand, and test. Inspection is your job; the engine only produces the route.
 

package/skills/fifth-dimension-engine/references/route-structure.md

@@ -2,7 +2,7 @@
 
 ## What a Route Is
 
-A route is the **output of the Fifth-Dimension Engine** — a structured, inspectable answer to a complex problem.
+A route is the **output of the Fifth-Dimension Engine** -- a structured, inspectable answer to a complex problem.
 
 Instead of a flat statement like "Yes, do this" or "The answer is X," the engine produces:
 

package/skills/gm/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: gm
 description: The primary driver for any non-trivial coding, refactoring, debugging, or multi-step engineering task in a project using this harness -- use it first, for the whole task, not just a piece of it. Plugkit-served instruction stream. Three-layer admission (witness, single-writer, direction) over every possible mutation; effort unbounded, never gated on cost. Closure on first emit; partial = non-monotonic. Not for the post-completion remaining-work check (that is `gm-continue`) or for drift-recovery mid-task (that is `wfgy-method`) -- this skill is the work itself.
-allowed-tools: Skill, Read, Write, Bash(bun *), Bash(npx *)
+allowed-tools: Skill, Read, Write, Bash(bun *), Bash(npx *), Bash(cat *), Bash(date *)
 ---
 
 # gm
@@ -84,7 +84,7 @@ VERIFY is adversarial, never confirmatory: run the real code path and read its a
 
 Phase transitions: PLAN -> EXECUTE, EXECUTE -> EMIT, EMIT -> VERIFY, VERIFY -> CONSOLIDATE, CONSOLIDATE -> COMPLETE. Each requires `transition {to:"PHASE"}` dispatch. EXECUTE resolves mutables in `.gm/mutables.yml` before EMIT. EMIT writes file changes. VERIFY validates via `exec_js`/`browser`. CONSOLIDATE pushes changes via `git_finalize` or `git_push`, then witnesses CI/CD pipeline green. COMPLETE gate requires: worktree clean, remote pushed, mutables resolved, and `.ci-validated` marker written with current commit SHA.
 
-CI/CD validation in CONSOLIDATE phase: After push succeeds, watch the triggered workflow. When pipeline goes green, dispatch `fs_write {path:".gm/exec-spool/.ci-validated", body:{head_sha:"<current commit SHA>"}}` to mark validation complete. `.ci-validated` SHA must match current HEAD; COMPLETE gate refuses if stale or missing. Red runs require fix + re-push + re-watch; no skip for "it looked safe."
+CI/CD validation in CONSOLIDATE phase: After push succeeds, watch the triggered workflow. When pipeline goes green, dispatch `fs_write {path:".gm/exec-spool/.ci-validated", content:"{\"head_sha\":\"<current commit SHA>\"}"}` to mark validation complete -- the marker's file CONTENT is the JSON string `{"head_sha":"<SHA>"}`, passed under the `content` field the fs_write handler reads (not a `body`/`head_sha` object, which the handler ignores). `.ci-validated`'s head_sha must match current HEAD; COMPLETE gate refuses if stale or missing. Red runs require fix + re-push + re-watch; no skip for "it looked safe."
 
 Memory via `memorize-fire` dispatch stores in `.gm/rs-learn.db` and is retrieved via `recall` and `auto_recall`. `discipline-note {discipline, text}` writes `.gm/disciplines/<name>/policy.md`; `instruction` auto-surfaces policies from disciplines listed in `.gm/disciplines/enabled.txt`.
 

package/skills/polaris-goal-compiler/SKILL.md

@@ -117,7 +117,7 @@ Over-claiming (saying something is done when it's only drafted) is the most comm
 
 ### Closure Records
 
-For each atom, record what is done, what is missing, what is only partially true, and what is still unsafe to claim. A closure record preserves continuity across rounds so that unfinished work stays visible instead of being buried in prose — this is what stops a local step from being promoted into fake global completion.
+For each atom, record what is done, what is missing, what is only partially true, and what is still unsafe to claim. A closure record preserves continuity across rounds so that unfinished work stays visible instead of being buried in prose -- this is what stops a local step from being promoted into fake global completion.
 
 ## Interaction with Other Skills
 
@@ -143,10 +143,10 @@ Use Goal Compiler to compile the problem statement, then dispatch to Fifth-Dimen
 ## References
 
 See `references/` directory for:
-- `task-atomization.md` — how to break work into atoms
-- `verification-gates.md` — designing verification for each stage
-- `claim-ceiling-examples.md` — what "complete" actually means in different contexts
-- `skills/polaris-protocol/SKILL.md` — the Polaris Protocol tree root and state machine that wires this skill to Fifth-Dimension Engine and WFGY-Method
+- `task-atomization.md` -- how to break work into atoms
+- `verification-gates.md` -- designing verification for each stage
+- `claim-ceiling-examples.md` -- what "complete" actually means in different contexts
+- `skills/polaris-protocol/SKILL.md` -- the Polaris Protocol tree root and state machine that wires this skill to Fifth-Dimension Engine and WFGY-Method
 
 ## What This Is Not
 

package/skills/polaris-goal-compiler/references/claim-ceiling-examples.md

@@ -20,12 +20,12 @@ The point is not optimism or pessimism. It is that a local success should not be
 
 - Atom A03 "Repair structure" is finished and the file compiles.
 - Claim ceiling: you may say "the structure is repaired and compiles." You may **not** yet say "the bug is fixed" until A04 (verify repair) passes.
-- If A04 is still blocked, saying "fixed" is a ceiling violation — it promotes a local step to global completion.
+- If A04 is still blocked, saying "fixed" is a ceiling violation -- it promotes a local step to global completion.
 
 ### Documentation packaging
 
 - You wrote the release note (A06) but A04 (verify repair) never ran.
-- Claim ceiling: you may say "a draft release note exists." You may **not** say "release ready" — readiness requires the verification gate first.
+- Claim ceiling: you may say "a draft release note exists." You may **not** say "release ready" -- readiness requires the verification gate first.
 - This is exactly the upstream failure mode: writing the announcement before the repair is verified.
 
 ### Research synthesis

package/skills/polaris-goal-compiler/references/task-atomization.md

@@ -4,10 +4,10 @@
 
 A task atom is the smallest executable unit of work. It must satisfy all of:
 
-1. **Atomic** — Cannot be divided further without losing meaning
-2. **Completable** — Can be finished in one session/sprint
-3. **Verifiable** — Has clear entrance and exit criteria
-4. **Interdependent** — Has clear dependencies (blocks/is blocked by other atoms)
+1. **Atomic** -- Cannot be divided further without losing meaning
+2. **Completable** -- Can be finished in one session/sprint
+3. **Verifiable** -- Has clear entrance and exit criteria
+4. **Interdependent** -- Has clear dependencies (blocks/is blocked by other atoms)
 
 ## Examples
 
@@ -27,7 +27,7 @@ A task atom is the smallest executable unit of work. It must satisfy all of:
 
 Start with: "Goal: Build a payment microservice."
 
-1. **Identify phases**: Research → Design → Implement → Test → Deploy
+1. **Identify phases**: Research -> Design -> Implement -> Test -> Deploy
 2. **For each phase, ask: What's the smallest piece?**
    - Research: API options, compliance, existing solutions
    - Design: Data model, interfaces, error handling
@@ -40,19 +40,19 @@ Start with: "Goal: Build a payment microservice."
 ## Dependency Edges
 
 Each atom has:
-- **Blockers** — Things that must finish before this starts
-- **Unblocks** — Things that can't start until this finishes
+- **Blockers** -- Things that must finish before this starts
+- **Unblocks** -- Things that can't start until this finishes
 
 Example:
 ```
 Research APIs (A1) 
-  ↓ unblocks
+  -> unblocks
 Design interface (A2)
-  ↓ unblocks
+  -> unblocks
 Implement core (A3)
-  ↓ unblocks
+  -> unblocks
 Test integration (A4)
-  ↓ unblocks
+  -> unblocks
 Deploy (A5)
 ```
 

package/skills/polaris-goal-compiler/references/verification-gates.md

@@ -43,17 +43,17 @@ For an atom:
 
 ## Bad Gates
 
-- "Complete" — unmeasurable
-- "Good enough" — too vague
-- "No obvious bugs" — not verifiable
+- "Complete" -- unmeasurable
+- "Good enough" -- too vague
+- "No obvious bugs" -- not verifiable
 - Checking something trivial (wasting time)
 
 ## Gate Failure
 
 If an atom fails its gate:
-- **Do not move forward** — you have incomplete work that looks complete
-- **Return to the atom** — what's actually missing?
-- **Fix or redefine** — either finish the work or redefine the atom scope
+- **Do not move forward** -- you have incomplete work that looks complete
+- **Return to the atom** -- what's actually missing?
+- **Fix or redefine** -- either finish the work or redefine the atom scope
 
 This is where fake completion gets caught.
 

package/skills/polaris-protocol/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: polaris-protocol
-description: WFGY 5.0 Polaris Protocol — the active flagship route from onestardao/WFGY. A two-layer reasoning system that compiles goals before execution and shoots complex problems into inspectable routes, with drift control throughout. This skill is the tree root: load it first, then dispatch its child skills as explicit transitions — polaris-goal-compiler (compile), fifth-dimension-engine (shoot), wfgy-method (drift control). Use for any complex, multi-step, high-stakes, or long-horizon task where premature completion or goal drift is a risk.
+description: WFGY 5.0 Polaris Protocol -- the active flagship route from onestardao/WFGY. A two-layer reasoning system that compiles goals before execution and shoots complex problems into inspectable routes, with drift control throughout. This skill is the tree root: load it first, then dispatch its child skills as explicit transitions -- polaris-goal-compiler (compile), fifth-dimension-engine (shoot), wfgy-method (drift control). Use for any complex, multi-step, high-stakes, or long-horizon task where premature completion or goal drift is a risk.
 license: MIT
 compatibility: Portable protocol; upstream released the Goal Compiler ChatGPT-first (teaser) and the Fifth-Dimension Engine as the main product surface. This skill wraps both plus WFGY-Method drift control into one discoverable entry point for any assistant or agent that loads skills.
 metadata:
@@ -8,19 +8,19 @@ metadata:
   provenance: adapted-and-honest-reimplementation-not-verbatim
 ---
 
-# WFGY 5.0 — Polaris Protocol (tree root)
+# WFGY 5.0 -- Polaris Protocol (tree root)
 
 Polaris is the active public route of WFGY 5.0. The **Fifth-Dimension Engine** is the current main product surface; the **Polaris Goal Compiler** is the first public protocol component. **WFGY-Method** supplies the drift-control discipline that keeps the whole system aligned with the original goal.
 
-This skill is the **tree root**. It does not re-explain the children — it wires them into one state machine and tells you which child to dispatch at each step. Treat the three child skills as the transitions of the machine below.
+This skill is the **tree root**. It does not re-explain the children -- it wires them into one state machine and tells you which child to dispatch at each step. Treat the three child skills as the transitions of the machine below.
 
 ## The tree
 
 ```
-polaris-protocol  (this skill — root / entry)
-├── polaris-goal-compiler   (COMPILE state)
-├── fifth-dimension-engine  (SHOOT state)
-└── wfgy-method             (DRIFT CONTROL — applies at every state)
+polaris-protocol  (this skill -- root / entry)
+|-- polaris-goal-compiler   (COMPILE state)
+|-- fifth-dimension-engine  (SHOOT state)
+`-- wfgy-method             (DRIFT CONTROL -- applies at every state)
 ```
 
 Discoverable: each node is a standalone `SKILL.md` inside its own `skills/<skill-name>/` directory. This root is the entry point; the children are reached by explicit dispatch.
@@ -37,7 +37,7 @@ A skill tree can behave like a state machine. Each transition is an explicit ski
 | `COMPILED` | Goal Compiler emitted task atoms, dependencies, verification gates, claim ceilings, and a closure-record template. |
 | `SHOOTING` | A complex atom is being lifted by Fifth-Dimension Engine into a route. |
 | `EXECUTING` | An atom (routine, or the result of a route) is being carried out. |
-| `VERIFYING` | Output is checked against the atom's verification gate and against drift (ΔS, via WFGY-Method). |
+| `VERIFYING` | Output is checked against the atom's verification gate and against drift (deltaS, via WFGY-Method). |
 | `CLOSED` | Claim ceiling met, closure record written, atom done. |
 
 ### Transitions (each is a dispatch)
@@ -58,13 +58,13 @@ VERIFYING --gate fail / drift --> BBCR checkpoint ----> COMPILED (re-compile or
 CLOSED --next atom------------------------------------> COMPILED
 ```
 
-`wfgy-method` is not a single transition — it is the drift-control observer attached to **every** state. Before any step that could have drifted, dispatch it and read the result.
+`wfgy-method` is not a single transition -- it is the drift-control observer attached to **every** state. Before any step that could have drifted, dispatch it and read the result.
 
-## Canonical syntax (pro-rata — use exactly this)
+## Canonical syntax (pro-rata -- use exactly this)
 
 - **Compile first. Execute one active atom. Verify before unlock. Claim only what is supported.** (Goal Compiler)
-- **shoot + [your problem]** — the Fifth-Dimension Engine interface.
-- **ΔS = 1 − cos(I, G)** — drift between current state (I) and goal (G). Without a real embedding call, ΔS is a qualitative label ("ΔS looks high here"), never a computed decimal — unless a real `similarity` verb is available (see WFGY-Method).
+- **shoot + [your problem]** -- the Fifth-Dimension Engine interface.
+- **deltaS = 1 - cos(I, G)** -- drift between current state (I) and goal (G). Without a real embedding call, deltaS is a qualitative label ("deltaS looks high here"), never a computed decimal -- unless a real `similarity` verb is available (see WFGY-Method).
 
 "Compile first. Then shoot." is the spine of the whole protocol.
 
@@ -77,7 +77,7 @@ CLOSED --next atom------------------------------------> COMPILED
 3. At `VERIFYING`, dispatch `Skill(skill="wfgy-method")` to check drift and apply the atom's verification gate.
    - Pass + claim ceiling honored -> `CLOSED` -> next atom (back to `COMPILED`).
    - Fail or drift -> BBCR checkpoint, re-compile or re-shoot (back to `COMPILED`).
-4. When all atoms are `CLOSED`, the task is done — and only then may you claim completion.
+4. When all atoms are `CLOSED`, the task is done -- and only then may you claim completion.
 
 ## What this tree is not
 
@@ -88,8 +88,8 @@ CLOSED --next atom------------------------------------> COMPILED
 
 ## Children (dispatch these)
 
-- `polaris-goal-compiler` — compile the goal into atoms, gates, claim ceilings.
-- `fifth-dimension-engine` — shoot a complex atom into a structured route.
-- `wfgy-method` — hold drift control across every state.
+- `polaris-goal-compiler` -- compile the goal into atoms, gates, claim ceilings.
+- `fifth-dimension-engine` -- shoot a complex atom into a structured route.
+- `wfgy-method` -- hold drift control across every state.
 
 For the full DAG, integration workflows, and mismatch detection, see `../POLARIS-SKILLS-GUIDE.md`.