gm-copilot-cli 2.0.1073 → 2.0.1075

package/copilot-profile.md

@@ -1,6 +1,6 @@
 ---
 name: gm
-version: 2.0.1073
+version: 2.0.1075
 description: Spool-dispatch orchestration engine with unified state machine, skills, and automated git enforcement
 author: AnEntrypoint
 repository: https://github.com/AnEntrypoint/gm-copilot-cli

package/index.html

@@ -74,7 +74,7 @@ body { display: flex; flex-direction: column; min-height: 100vh; }
 <section>
   <div class="gm-section-label"><span class="slash">//</span>status</div>
   <div class="panel">
-    <div class="panel-head"><span>release · v2.0.1073</span><span>probably emerging</span></div>
+    <div class="panel-head"><span>release · v2.0.1075</span><span>probably emerging</span></div>
     <div class="panel-body">
       <div class="row">
         <span class="code"><span style="color:var(--panel-accent)">●</span></span>

package/lib/skill-bootstrap.js

@@ -8,32 +8,17 @@ const spool = require('./spool.js');
 
 const PLUGKIT_TOOLS_DIR = path.join(os.homedir(), '.claude', 'gm-tools');
 const PLUGKIT_VERSION_FILE = path.join(PLUGKIT_TOOLS_DIR, 'plugkit.version');
+const PLUGKIT_WASM_PATH = path.join(PLUGKIT_TOOLS_DIR, 'plugkit.wasm');
+const PLUGKIT_WASM_WRAPPER = path.join(PLUGKIT_TOOLS_DIR, 'plugkit-wasm-wrapper.js');
 const BOOTSTRAP_STATUS_FILE = path.join(os.homedir(), '.gm', 'bootstrap-status.json');
 const BOOTSTRAP_ERROR_FILE = path.join(os.homedir(), '.gm', 'bootstrap-error.json');
 const LOG_DIR = path.join(os.homedir(), '.claude', 'gm-log');
-const PLATFORM_MAP = {
-  win32: { suffix: '-win32-x64.exe', altSuffix: '-win32-arm64.exe' },
-  darwin: { suffix: '-darwin-x64', altSuffix: '-darwin-arm64' },
-  linux: { suffix: '-linux-x64', altSuffix: '-linux-arm64' },
-};
-
-function getPlatformKey() {
-  const plat = process.platform;
-  if (plat === 'win32') return plat;
-  if (plat === 'darwin') return plat;
-  if (plat === 'linux') return plat;
-  throw new Error(`Unsupported platform: ${plat}`);
-}
-
-function getExpectedBinaryName() {
-  const plat = getPlatformKey();
-  const suffix = PLATFORM_MAP[plat].suffix;
-  return `plugkit${suffix}`;
-}
 
 function getPlugkitPath() {
-  const name = getExpectedBinaryName();
-  return path.join(PLUGKIT_TOOLS_DIR, name);
+  if (fs.existsSync(PLUGKIT_WASM_WRAPPER) && fs.existsSync(PLUGKIT_WASM_PATH)) {
+    return PLUGKIT_WASM_WRAPPER;
+  }
+  throw new Error(`plugkit WASM not found at ${PLUGKIT_WASM_PATH}`);
 }
 
 function emitBootstrapEvent(severity, message, details) {
@@ -65,17 +50,12 @@ function readManifest() {
     const gm = JSON.parse(fs.readFileSync(gmJsonPath, 'utf8'));
     const version = gm.plugkitVersion;
 
-    const sha256Path = path.join(process.cwd(), 'gm-starter', 'bin', 'plugkit.sha256');
+    const sha256Path = path.join(process.cwd(), 'gm-starter', 'bin', 'plugkit.wasm.sha256');
     if (!fs.existsSync(sha256Path)) {
-      throw new Error('gm-starter/bin/plugkit.sha256 not found');
+      throw new Error('gm-starter/bin/plugkit.wasm.sha256 not found');
     }
-    const sha256Lines = fs.readFileSync(sha256Path, 'utf8').split('\n').filter(Boolean);
-    const binaryName = getExpectedBinaryName();
-    const hashLine = sha256Lines.find(line => line.includes(binaryName));
-    if (!hashLine) {
-      throw new Error(`No hash found for ${binaryName}`);
-    }
-    const expectedHash = hashLine.split(/\s+/)[0];
+    const sha256Content = fs.readFileSync(sha256Path, 'utf8').trim();
+    const expectedHash = sha256Content.split(/\s+/)[0];
 
     return { version, expectedHash };
   } catch (e) {
@@ -101,20 +81,20 @@ function computeFileHash(filePath) {
 }
 
 async function downloadPlugkitBinary(version) {
-  const binaryName = getExpectedBinaryName();
-  const url = `https://github.com/AnEntrypoint/plugkit-bin/releases/download/${version}/${binaryName}`;
+  const binaryName = 'plugkit.wasm';
+  const url = `https://github.com/AnEntrypoint/plugkit-bin/releases/download/v${version}/${binaryName}`;
 
-  emitBootstrapEvent('info', 'Starting binary download', { version, binaryName, url });
+  emitBootstrapEvent('info', 'Starting WASM download', { version, url });
 
   return new Promise((resolve, reject) => {
     https
       .get(url, { timeout: 30000 }, (res) => {
         if (res.statusCode === 404) {
-          reject(new Error(`Binary not found: ${binaryName} v${version}`));
+          reject(new Error(`WASM not found: v${version}`));
           return;
         }
         if (res.statusCode !== 200) {
-          reject(new Error(`HTTP ${res.statusCode} downloading ${binaryName}`));
+          reject(new Error(`HTTP ${res.statusCode} downloading plugkit.wasm`));
           return;
         }
 
@@ -122,7 +102,7 @@ async function downloadPlugkitBinary(version) {
         res.on('data', (chunk) => chunks.push(chunk));
         res.on('end', () => {
           const data = Buffer.concat(chunks);
-          emitBootstrapEvent('info', 'Binary download complete', { bytes: data.length });
+          emitBootstrapEvent('info', 'WASM download complete', { bytes: data.length });
           resolve(data);
         });
       })
@@ -204,12 +184,14 @@ async function writeBinaryWithRetry(filePath, data, maxRetries = 3) {
 
 async function verifyBinaryHealth(filePath) {
   try {
-    if (process.platform === 'win32') {
-      execSync(`"${filePath}" health > nul 2>&1`, { timeout: 5000, shell: true });
-    } else {
-      execSync(`"${filePath}" health > /dev/null 2>&1`, { timeout: 5000 });
+    if (!fs.existsSync(filePath)) {
+      throw new Error(`File not found: ${filePath}`);
     }
-    emitBootstrapEvent('info', 'Binary health check passed');
+    const stat = fs.statSync(filePath);
+    if (stat.size < 1024) {
+      throw new Error(`File too small: ${stat.size} bytes`);
+    }
+    emitBootstrapEvent('info', 'Binary health check passed', { size: stat.size });
     return true;
   } catch (e) {
     emitBootstrapEvent('warn', 'Binary health check failed', { error: e.message });
@@ -217,24 +199,38 @@ async function verifyBinaryHealth(filePath) {
   }
 }
 
-async function spawnPlugkitWatcher(filePath) {
+async function spawnPlugkitWatcher(wasmPath) {
   try {
-    emitBootstrapEvent('info', 'Spawning plugkit watcher daemon');
+    emitBootstrapEvent('info', 'Spawning plugkit WASM watcher daemon');
+
+    let wrapperPath;
+    try {
+      const gmPlugkit = require('gm-plugkit');
+      wrapperPath = path.join(path.dirname(gmPlugkit.getPath ? gmPlugkit.getPath() : require.resolve('gm-plugkit')), 'plugkit-wasm-wrapper.js');
+    } catch (e) {
+      emitBootstrapEvent('warn', 'gm-plugkit npm not available, using bundled wrapper', { error: e.message });
+      wrapperPath = path.join(path.dirname(wasmPath), 'plugkit-wasm-wrapper.js');
+    }
+
+    if (!fs.existsSync(wrapperPath)) {
+      throw new Error(`WASM wrapper not found at ${wrapperPath}`);
+    }
 
-    const cmd = process.platform === 'win32' ? filePath : filePath;
-    const proc = spawn(cmd, ['watch', '--once=false'], {
+    const runtime = process.platform === 'win32' ? 'bun.exe' : 'bun';
+    const proc = spawn(runtime, [wrapperPath, 'spool'], {
       detached: true,
       stdio: 'ignore',
       windowsHide: true,
+      env: { ...process.env, CLAUDE_PROJECT_DIR: process.cwd() },
     });
 
     const pid = proc.pid;
     proc.unref();
 
-    emitBootstrapEvent('info', 'Plugkit watcher spawned', { pid });
+    emitBootstrapEvent('info', 'Plugkit WASM watcher spawned', { pid });
     return pid;
   } catch (e) {
-    emitBootstrapEvent('error', 'Failed to spawn plugkit watcher', { error: e.message });
+    emitBootstrapEvent('error', 'Failed to spawn plugkit WASM watcher', { error: e.message });
     throw e;
   }
 }

package/lib/spool-dispatch.js

@@ -72,4 +72,29 @@ async function pollForCompletion(jsonFile, timeoutMs, taskId) {
   };
 }
 
-module.exports = { dispatchSpool };
+function checkDispatchGates(sessionId, operation) {
+  const gm = path.join(process.cwd(), '.gm');
+  const prdPath = path.join(gm, 'prd.yml');
+  const mutsPath = path.join(gm, 'mutables.yml');
+  const needsGmPath = path.join(gm, 'needs-gm');
+  const gmFiredPath = path.join(gm, `gm-fired-${sessionId}`);
+
+  if (!['write', 'edit', 'git'].includes(operation)) return { allowed: true };
+
+  if (fs.existsSync(prdPath) && fs.existsSync(needsGmPath) && !fs.existsSync(gmFiredPath)) {
+    return { allowed: false, reason: 'gm orchestration in progress; skills must complete work before tools execute' };
+  }
+
+  if (fs.existsSync(mutsPath)) {
+    try {
+      const content = fs.readFileSync(mutsPath, 'utf8');
+      if (content.includes('status: unknown')) {
+        return { allowed: false, reason: 'unresolved mutables block tool execution; resolve all mutables before proceeding' };
+      }
+    } catch (_) {}
+  }
+
+  return { allowed: true };
+}
+
+module.exports = { dispatchSpool, checkDispatchGates };

package/manifest.yml

@@ -1,5 +1,5 @@
 name: gm
-version: 2.0.1073
+version: 2.0.1075
 description: Spool-dispatch orchestration engine with unified state machine, skills, and automated git enforcement
 author: AnEntrypoint
 

package/package.json

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

package/skills/gm/SKILL.md

@@ -58,3 +58,15 @@ Platform adapters (vscode, cursor, zed, jetbrains) that support `end-to-end: tru
 4. Repeat until `nextSkill` is null
 
 This collapses 5 manual skill invocations into 1 user invocation + 4 transparent auto-dispatches, achieving perceived single-flow parity with gm-cc's subagent orchestration.
+
+## Skill Transition Protocol
+
+Skill-to-skill transitions NEVER stop for approval or ask the user. Each skill completes its phase and invokes the next skill via `Skill()` tool call directly. Platform adapters auto-detect the transition from stdout JSON and fire the next skill without user interaction. Tool-use approvals are pre-authorized by the initial user request — re-asking defeats the cascade and breaks autonomy. Skills must assume subsequent tools are approved once the PRD is written by PLAN.
+
+## Gate enforcement (spool-dispatch layer)
+
+The file-spool (`lib/spool-dispatch.js::checkDispatchGates()`) blocks Write/Edit/git operations when:
+1. `.gm/prd.yml` exists AND `.gm/needs-gm` exists AND `.gm/gm-fired-<sessionId>` does NOT exist → reason: "gm orchestration in progress; skills must complete work before tools execute"
+2. `.gm/mutables.yml` has entries with `status: unknown` → reason: "unresolved mutables block tool execution; resolve all mutables before proceeding"
+
+Gate 1 auto-clears: PLAN writes THREE markers (`.gm/prd.yml`, `.gm/needs-gm`, `.gm/gm-fired-<sessionId>`) at session start BEFORE transitioning to EXECUTE. The marker proves planning has run and authorized tool use. Gate 2 auto-clears: EXECUTE resolves mutables by updating `.gm/mutables.yml` entries to `status: witnessed`, or the file is deleted when empty by gm-complete. Tool denials surface the reason text to the agent, which adjusts behavior (e.g., resolve remaining mutables before retrying). Tool denials never mutate command arguments — they surface policy as imperative instruction.

package/skills/gm-complete/SKILL.md

@@ -104,3 +104,18 @@ After `git push`, poll `gh run list --branch main --limit 5 --json status,name,d
 ## Completion
 
 All true at once: witnessed e2e | browser_validated when client work touched | failure paths exercised | test.js passes | `.prd` deleted | git clean and pushed | CI green | hygiene sweep clean | TODO.md gone | CHANGELOG.md updated.
+
+## Marker file protocol
+
+On transition to `update-docs`, delete all gm orchestration markers for the next cycle:
+```
+const fs = require('fs');
+const path = require('path');
+const sessionId = process.env.SESSION_ID || 'default';
+const gm = path.join(process.cwd(), '.gm');
+['.gm/prd.yml', '.gm/mutables.yml', '.gm/needs-gm', `.gm/gm-fired-${sessionId}`].forEach(m => {
+  try { fs.unlinkSync(path.join(gm, m.split('/')[1])); } catch (_) {}
+});
+```
+
+The `.gm/gm-fired-<sessionId>` marker was written by PLAN at session start and proves gm orchestration has completed. Cleanup before next cycle resets gates so the next PLAN run can write fresh markers.

package/skills/gm-emit/SKILL.md

@@ -5,16 +5,18 @@ description: EMIT phase. Pre-emit debug, write files, post-emit verify from disk
 
 # GM EMIT — Write and verify from disk
 
-Entry: every mutable KNOWN, from `gm-execute` or re-entered from VERIFY. Exit: gates clear → `gm-complete`.
+Entry: every mutable KNOWN, from `gm-execute` or re-entered from VERIFY. Exit: gates clear → `gm-complete` (automatic, no approval).
 
 Cross-cutting dispositions live in `gm` SKILL.md.
 
+**Skill Transition Guarantee**: When this skill completes, invoke `gm-complete` directly via `Skill()` — do not ask the user. Tool denials from gates (checkDispatchGates) surface as imperative reason text; the agent adjusts behavior and retries, never re-asks the user.
+
 ## Transitions
 
-- All gates clear → `gm-complete`
-- Post-emit variance with known cause → fix in-band, re-verify, stay in EMIT
-- Pre-emit reveals known logic error → `gm-execute`
-- Pre-emit reveals new unknown OR post-emit variance with unknown cause OR scope changed → `planning`
+- All gates clear → `gm-complete` (invoke via `Skill(skill="gm:gm-complete")` immediately, no stop)
+- Post-emit variance with known cause → fix in-band, re-verify, stay in EMIT (self-loop, no transition)
+- Pre-emit reveals known logic error → `gm-execute` (invoke via `Skill(skill="gm:gm-execute")` immediately, no stop)
+- Pre-emit reveals new unknown OR post-emit variance with unknown cause OR scope changed → `planning` (invoke via `Skill(skill="planning")` immediately, no stop)
 
 ## Legitimacy gate (before pre-emit run)
 
@@ -68,3 +70,7 @@ Before pre-emit run, read `.gm/mutables.yml`. Any entry with `status: unknown`
 - Structure: no if/else where dispatch suffices; no one-liners that obscure; no reinvented APIs
 - Every fact resolved this phase memorized via background `Agent(memorize)`
 - CHANGELOG.md updated; TODO.md cleared or deleted
+
+## Marker file protocol
+
+EMIT phase operates after EXECUTE resolves all mutables. `.gm/prd.yml` and `.gm/mutables.yml` remain live (deleted by gm-complete when work finishes). Gate enforcement does not block EMIT — the `.gm/gm-fired-<sessionId>` marker was already written by PLAN at session start, so tool use (Write/Edit) is fully authorized. EMIT does not write or read markers; it only invokes Write/Edit on files and runs post-emit verifications. On transition to gm-complete (all gates clear), invoke the skill immediately (no marker write needed by EMIT).

package/skills/gm-execute/SKILL.md

@@ -5,17 +5,19 @@ description: EXECUTE phase AND the foundational execution contract for every ski
 
 # GM EXECUTE — Resolve every unknown by witness
 
-Entry: `.prd` with named unknowns. Exit: every mutable KNOWN → invoke `gm-emit`.
+Entry: `.prd` with named unknowns. Exit: every mutable KNOWN → invoke `gm-emit` (automatic, no approval).
 
 A `@<discipline>` sigil propagates from PLAN through every recall, codesearch, and memorize call; reads without one fan across default plus enabled disciplines, writes without one go to default only.
 
 This skill is the execution contract for ALL phases — pre-emit witnesses, post-emit verifies, e2e checks all run on this discipline. Cross-cutting dispositions live in `gm` SKILL.md.
 
+**Skill Transition Guarantee**: Tool use is pre-authorized by the initial user request. When this skill completes, invoke `gm-emit` directly via `Skill()` — do not ask the user. Tool denials from gates (checkDispatchGates) surface as imperative reason text; the agent adjusts behavior and retries, never re-asks the user.
+
 ## Transitions
 
-- All mutables KNOWN → `gm-emit`
+- All mutables KNOWN → `gm-emit` (invoke via `Skill(skill="gm:emit")` immediately, no stop)
 - Still UNKNOWN → re-run from a different angle (max 2 passes)
-- New unknown OR unresolvable after 2 passes → `planning`
+- New unknown OR unresolvable after 2 passes → `planning` (invoke via `Skill(skill="planning")` immediately, no stop)
 
 ## Mutable discipline
 
@@ -81,3 +83,7 @@ Up to 3 `gm:gm` subagents for independent items in one message. Browser escalati
 ## CI is automated
 
 After `git push`, poll `gh run list --branch main --limit 5 --json status,name,databaseId` until all runs reach a terminal state. Green → continue; failure → investigate via `gh run view <id> --log-failed`, fix, push again. Deadline 180s (override `GM_CI_WATCH_SECS`). Poll every 10s via a nodejs spool file with a `setInterval` loop writing results to stdout.
+
+## Marker file protocol
+
+EXECUTE phase works against `.gm/prd.yml` and `.gm/mutables.yml` written by PLAN. Both files live for the duration of work and are deleted by gm-complete when work finishes. Gate enforcement (spool-dispatch layer) checks: if `.gm/prd.yml` + `.gm/needs-gm` exist BUT `.gm/gm-fired-<sessionId>` marker is missing, tool use blocks. PLAN writes all three markers at session start before transitioning to EXECUTE, so the gate is already clear when EXECUTE runs. EXECUTE does not write or read markers — it only reads and updates mutables. On transition to gm-emit, invoke the skill immediately (no marker write needed by EXECUTE).

package/skills/planning/SKILL.md

@@ -31,7 +31,7 @@ const { spawn, spawnSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
-const bin = path.join(os.homedir(), '.claude', 'gm-tools', process.platform === 'win32' ? 'plugkit.exe' : 'plugkit');
+const bin = path.join(os.homedir(), '.claude', 'gm-tools', 'plugkit.wasm');
 const root = process.cwd();
 const spoolIn = path.join(root, '.gm', 'exec-spool', 'in');
 const spoolOut = path.join(root, '.gm', 'exec-spool', 'out');
@@ -42,13 +42,13 @@ if (fs.existsSync(pidFile)) {
   try { fs.unlinkSync(pidFile); } catch (_) {}
 }
 if (process.platform === 'win32') {
-  try { spawnSync('taskkill', ['/F', '/IM', 'plugkit.exe'], { windowsHide: true, timeout: 3000, stdio: 'ignore' }); } catch (_) {}
+  try { spawnSync('taskkill', ['/F', '/IM', 'node.exe'], { windowsHide: true, timeout: 3000, stdio: 'ignore' }); } catch (_) {}
 } else {
   try { spawnSync('pkill', ['-f', 'plugkit'], { timeout: 3000, stdio: 'ignore' }); } catch (_) {}
 }
 fs.mkdirSync(spoolIn, { recursive: true });
 fs.mkdirSync(spoolOut, { recursive: true });
-const proc = spawn(bin, ['runner', '--watch', spoolIn, '--out', spoolOut], {
+const proc = spawn('node', [bin, 'runner', '--watch', spoolIn, '--out', spoolOut], {
   detached: true, stdio: 'ignore', windowsHide: true, cwd: root,
 });
 proc.unref();
@@ -152,3 +152,24 @@ Pack runs use `Promise.allSettled`, each idea its own try/catch, under 12s per c
 No comments. 200-line per-file cap. Fail loud. No duplication. Scan before edit. AGENTS.md edits route through the memorize sub-agent only. CHANGELOG.md gets one entry per commit.
 
 Minimal-code process, stop at the first that resolves: native → library → structure (map / pipeline) → write.
+
+## Marker File Protocol
+
+PLAN phase writes THREE marker files before transitioning to EXECUTE:
+1. `.gm/prd.yml` — the work items (already written per PRD format above)
+2. `.gm/needs-gm` — empty marker file signaling PRD is ready for orchestration
+3. `.gm/gm-fired-<sessionId>` — signals that gm orchestration (planning) has run and cleared the gate
+
+When `.gm/prd.yml` and `.gm/needs-gm` both exist, downstream tools check `.gm/gm-fired-<sessionId>` marker. If missing, tool execution blocks with reason: "gm orchestration in progress; skills must complete work before tools execute." This gate prevents tool use from tools that run BEFORE the orchestration phase is complete. Writing the marker clears this gate.
+
+Write all three markers as final step of PLAN:
+```
+const fs = require('fs');
+const path = require('path');
+const sessionId = process.env.SESSION_ID || 'default';
+fs.mkdirSync(path.join(process.cwd(), '.gm'), { recursive: true });
+fs.writeFileSync(path.join(process.cwd(), '.gm', 'needs-gm'), '');
+fs.writeFileSync(path.join(process.cwd(), '.gm', `gm-fired-${sessionId}`), '');
+```
+
+Transition to `gm-execute` (or `gm-gm` subagent) immediately after writing all files. No stop-for-approval; the transition is automatic.

package/tools.json

@@ -1,6 +1,6 @@
 {
   "name": "gm",
-  "version": "2.0.1073",
+  "version": "2.0.1075",
   "description": "Spool-dispatch orchestration engine with unified state machine, skills, and automated git enforcement",
   "tools": [
     {