gm-skill 0.1.2 → 2.0.1081

package/gm-execute.SKILL.md

@@ -1,88 +0,0 @@
----
-name: gm-execute
-description: EXECUTE phase AND the foundational execution contract for every skill. Every exec:<lang> 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.
----
-
-# GM EXECUTE — Resolve every unknown by witness
-
-Entry: `.prd` with named unknowns. Exit: every mutable KNOWN → invoke `gm-emit`.
-
-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.
-
-## Transitions
-
-- All mutables KNOWN → `gm-emit`
-- Still UNKNOWN → re-run from a different angle (max 2 passes)
-- New unknown OR unresolvable after 2 passes → `planning`
-
-## Mutable discipline
-
-Each mutable carries: name, expected, current, resolution method.
-
-Resolves to KNOWN only when all four pass:
-
-- **ΔS = 0** — witnessed output equals expected
-- **λ ≥ 2** — two independent paths agree
-- **ε intact** — adjacent invariants hold
-- **Coverage ≥ 0.70** — enough corpus inspected to rule out contradiction
-
-Unresolved after 2 passes regresses to `planning`. Never narrate past an unresolved mutable.
-
-Every witness that resolves a mutable writes back to `.gm/mutables.yml` the same step: set `status: witnessed` and fill `witness_evidence` with concrete proof (file:line, codesearch hit, exec output snippet). No write-back = the mutable stays unknown and the EMIT-gate stays closed. The hook reads this file; the agent's memory of "I resolved it" does not unblock anything.
-
-Route candidates from PLAN are `weak_prior` only. Plausibility is the right to test, not the right to believe. A claim with no witness in the current session is a hypothesis — say so when stating it, and say what would settle it. The next reader (you, next turn) needs to know which lines were earned and which were carried forward.
-
-## Verification budget
-
-Spend on `.prd` items in descending order of consequence-if-wrong × distance-from-witnessed. Items whose failure would collapse the headline finding must reach witnessed status before EMIT; sub-argument-level items need at minimum a stated fallback path.
-
-## Code execution
-
-Code AND utility verbs both run through the file-spool. Write a file to `.gm/exec-spool/in/<lang-or-verb>/<N>.<ext>` — language stems (`in/nodejs/42.js`, `in/python/43.py`, `in/bash/44.sh`, plus typescript, go, rust, c, cpp, java, deno) or verb stems (`in/codesearch/45.txt`, `in/recall/46.txt`, `in/memorize/47.md`, plus wait, sleep, status, close, browser, runner, type, kill-port, forget, feedback, learn-status, learn-debug, learn-build, discipline, pause, health). The spool watcher executes and streams stdout to `out/<N>.out`, stderr to `out/<N>.err`, then writes `out/<N>.json` metadata sidecar at completion (taskId, lang, ok, exitCode, durationMs, timedOut, startedAt, endedAt). Both streams return as systemMessage with `--- stdout ---` / `--- stderr ---` separators. File I/O via a nodejs spool file + `require('fs')`. Only `git` and `gh` run directly in Bash. Never `Bash(node/npm/npx/bun)`, never `Bash(exec:<anything>)`.
-
-Pack runs: `Promise.allSettled`, each idea own try/catch, under 12s per call. Runner: write `in/runner/<N>.txt` with body `start` | `stop` | `status`.
-
-Every exec daemonizes. The hook tails the task logfile up to 30s wall-clock and returns whatever is there — short tasks complete inside the window and look synchronous; long tasks return a task_id with partial output. Continue with `exec:tail` (drain, bounded), `exec:watch` (resume blocking until match or timeout), or `exec:close` (terminate). Never re-spawn a long task to check on it — that orphans the first one. `exec:wait` is a pure timer; `exec:sleep` blocks on a specific task's output; `exec:watch` is the match-or-timeout primitive. Every execution-platform RPC returns the live list of running tasks for this session — close stragglers via `exec:close\n<id>` so the list stays scannable. Session-end (clear/logout/prompt_input_exit) kills the session's tasks; compaction/handoff preserves them.
-
-Every utility verb dispatches via `in/<verb>/<N>.txt`; the body of the file is the verb's argument. There is no inline form and no Bash-prefix form — both are denied by the hook.
-
-## Codebase search
-
-`exec:codesearch` only. Grep, Glob, Find, Explore, raw grep/rg/find inside `exec:bash` are all hook-blocked.
-
-```
-exec:codesearch
-<two-word query>
-```
-
-Start two words, change/add one per pass, minimum four attempts before concluding absent. Known absolute path → `Read`. Known directory → `exec:nodejs` + `fs.readdirSync`.
-
-## Utility verb failure handling
-
-**Utility verb failures must surface**: exec:memorize, exec:recall, exec:codesearch, and other utility verbs may fail (socket unavailable, timeout, network error). Failures do not block witness completion but must be reported to the user with error context. Fallback mechanisms (AGENTS.md for memorize) ensure memory preservation even when rs-learn is temporarily unavailable.
-
-## Import-based execution
-
-Hypotheses become real by importing actual modules from disk. Reimplemented behavior is UNKNOWN. Write the import probe to the spool:
-
-```
-# write .gm/exec-spool/in/nodejs/42.js
-const { fn } = await import('/abs/path/to/module.js');
-console.log(await fn(realInput));
-```
-
-Differential diagnosis: smallest reproduction → compare actual vs expected → name the delta — that delta is the mutable.
-
-## Edits depend on witnesses
-
-Hypothesis → run → witness → edit. An edit before a witness is a guess. Scan via `exec:codesearch` before creating or modifying — duplicate concern regresses to `planning`. Code-quality preference: native → library → structure → write.
-
-## Parallel subagents
-
-Up to 3 `gm:gm` subagents for independent items in one message. Browser escalation: `exec:browser` → `browser` skill → screenshot only as last resort.
-
-## CI is automated
-
-`git push` triggers the Stop hook to watch Actions for the pushed HEAD on the same repo (downstream cascades are not auto-watched). Green → Stop approves with summary; failure → run names + IDs surfaced, investigate via `gh run view <id> --log-failed`. Deadline 180s (override `GM_CI_WATCH_SECS`).

package/gm.SKILL.md

@@ -1,63 +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
-compatible-platforms:
-  - gm-cc
-  - gm-gc
-  - gm-oc
-  - gm-kilo
-  - gm-codex
-  - gm-copilot-cli
-  - gm-vscode
-  - gm-cursor
-  - gm-zed
-  - gm-jetbrains
-end-to-end: true
----
-
-# GM — Orchestrator
-
-Invoke `planning` immediately. Phases cascade: PLAN → EXECUTE → EMIT → VERIFY → UPDATE-DOCS.
-
-The user's request is authorization. When scope is unclear, pick the maximum reachable shape and declare it — the user can interrupt. Doubts resolve via witnessed probe or recall, never by asking back except for destructive-irreversible actions uncovered by the PRD.
-
-**What ships runs**: no stubs, mocks, placeholder returns, fixture-only paths, or demo-mode short-circuits. Real input through real code into real output. A shim is allowed only when delegating to real upstream behavior.
-
-**CI is the build**: for Rust crates and the gm publish chain, push triggers CI auto-watch. Green signals authority. Local cargo build is not a witness.
-
-**Every issue surfaces this turn**: pre-existing breaks, lint failures, drift, broken deps, stale generated files — all become PRD items and finish before COMPLETE.
-
-**LLM provider**: acptoapi (127.0.0.1:4800) is the preferred provider when available. rs-plugkit session_start spawns acptoapi daemon and auto-detects ACP agents (opencode, kilo-code, codex, gemini-cli, qwen-code). All downstream platforms (rs-learn, freddie, gm-skill daemon mode) read OPENAI_BASE_URL environment variable and default to 127.0.0.1:4800. Anthropic SDK is fallback only when acptoapi socket is unavailable (CI, headless mode).
-
-**rs-learn failure contract**: exec:memorize, exec:recall, and exec:codesearch failures must be reported explicitly with error details to the user. Fallback to AGENTS.md for memory preservation when socket/network unavailable. Never silently absorb errors because memory preservation requires explicit fallback. This rule applies across all phases (PLAN through UPDATE-DOCS).
-
-**Spool dispatch chain**: write to `.gm/exec-spool/in/<lang>/<N>.<ext>` or `in/<verb>/<N>.txt`. Watcher executes and streams `out/<N>.out` + `out/<N>.err` + `out/<N>.json` metadata. Languages: nodejs, python, bash, typescript, go, rust, c, cpp, java, deno. Verbs: codesearch, recall, memorize, wait, sleep, status, close, browser, runner, type, kill-port, forget, feedback, learn-status, learn-debug, learn-build, discipline, pause, health.
-
-**Session isolation**: SESSION_ID environment variable (or uuid fallback) threads through task dispatch for cleanup scope. rs-exec RPC handlers verify session_id match on all task-scoped operations.
-
-**Code does mechanics; meaning routes through textprocessing skill**: summarize, classify, extract intent, rewrite, translate, semantic dedup, rank, label — all via `Agent(subagent_type='gm:textprocessing', ...)`.
-
-**Recall before fresh execution**: before witnessing unknown via execution, recall first. Hits arrive as weak_prior; empty results confirm fresh unknown.
-
-**Memorize is the back-half of witness**: resolution incomplete until fact lives outside this context window. Fire `Agent(subagent_type='gm:memorize', model='haiku', run_in_background=true, prompt='## CONTEXT TO MEMORIZE\n<fact>')` alongside witness, in parallel, never blocking.
-
-**Parallel independent items**: up to 3 `gm:gm` subagents per message for independent PRD items. Serial for dependent items — no re-asking between them.
-
-**Terse response**: fragments OK. `[thing] [action] [reason]. [next step].` Code, commits, PRs use normal prose.
-
-## End-to-End Phase Chaining (Skills-Based Platforms)
-
-When `end-to-end: true` is present in SKILL.md frontmatter, skill output includes structured JSON on stdout (final line):
-
-```json
-{"nextSkill": "gm-execute" | "gm-emit" | "gm-complete" | "update-docs" | null, "context": {PRD and state dict}, "phase": "PLAN" | "EXECUTE" | "EMIT" | "COMPLETE"}
-```
-
-Platform adapters (vscode, cursor, zed, jetbrains) that support `end-to-end: true` detection:
-1. Invoke `Skill(skill="gm:gm")`
-2. Parse stdout for trailing JSON blob
-3. If `nextSkill` is non-null, invoke `Skill(skill="gm:<nextSkill>")` with context dict auto-passed
-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.

package/index.js

@@ -1 +0,0 @@
-module.exports = require('./lib/index.js');

package/lib/index.js

@@ -1,37 +0,0 @@
-const daemon = require('./daemon-bootstrap.js');
-const manifest = require('./manifest.js');
-const loader = require('./loader.js');
-const prepareModule = require('./prepare.js');
-
-function getSkills() {
-  return manifest.getAllSkills();
-}
-
-function getSkill(name) {
-  return manifest.getSkill(name);
-}
-
-function loadSkill(skillName, baseDir) {
-  return loader.dynamicLoadSkill(skillName, baseDir);
-}
-
-function bootstrapDaemon(daemonName, cmd) {
-  return daemon.spawnDaemon(daemonName, cmd);
-}
-
-module.exports = {
-  getSkills: getSkills,
-  getSkill: getSkill,
-  loadSkill: loadSkill,
-  bootstrapDaemon: bootstrapDaemon,
-  checkState: daemon.checkState,
-  waitForReady: daemon.waitForReady,
-  getSocket: daemon.getSocket,
-  shutdown: daemon.shutdown,
-  emitEvent: daemon.emitEvent,
-  isDaemonRunning: daemon.isDaemonRunning,
-  checkPortReachable: daemon.checkPortReachable,
-  manifest: manifest,
-  loader: loader,
-  prepare: prepareModule.prepare
-};

package/lib/loader.js

@@ -1,66 +0,0 @@
-const path = require('path');
-const fs = require('fs');
-
-function loadSkill(skillName, skillPath) {
-  if (!fs.existsSync(skillPath)) {
-    throw new Error(`Skill path does not exist: ${skillPath}`);
-  }
-
-  const indexPath = path.join(skillPath, 'index.js');
-  if (!fs.existsSync(indexPath)) {
-    throw new Error(`Skill index.js not found at ${indexPath}`);
-  }
-
-  try {
-    const skillModule = require(indexPath);
-    return skillModule;
-  } catch (e) {
-    throw new Error(`Failed to load skill ${skillName} from ${indexPath}: ${e.message}`);
-  }
-}
-
-function dynamicLoadSkill(skillName, baseDir) {
-  const searchDirs = [];
-
-  if (baseDir) {
-    searchDirs.push(path.join(baseDir, 'skills', skillName));
-  }
-
-  searchDirs.push(path.join(__dirname, '..', 'skills', skillName));
-  searchDirs.push(path.join(__dirname, '..', '..', 'gm-starter', 'skills', skillName));
-  searchDirs.push(path.join(process.cwd(), 'skills', skillName));
-
-  for (const searchDir of searchDirs) {
-    if (fs.existsSync(searchDir)) {
-      return loadSkill(skillName, searchDir);
-    }
-  }
-
-  throw new Error(`Skill "${skillName}" not found in any search directory: ${searchDirs.join(', ')}`);
-}
-
-function getSkillPath(skillName, baseDir) {
-  const searchDirs = [];
-
-  if (baseDir) {
-    searchDirs.push(path.join(baseDir, 'skills', skillName));
-  }
-
-  searchDirs.push(path.join(__dirname, '..', 'skills', skillName));
-  searchDirs.push(path.join(__dirname, '..', '..', 'gm-starter', 'skills', skillName));
-  searchDirs.push(path.join(process.cwd(), 'skills', skillName));
-
-  for (const searchDir of searchDirs) {
-    if (fs.existsSync(searchDir)) {
-      return searchDir;
-    }
-  }
-
-  return null;
-}
-
-module.exports = {
-  loadSkill,
-  dynamicLoadSkill,
-  getSkillPath
-};

package/lib/manifest.js

@@ -1,99 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-
-function parseSkillMarkdown(content) {
-  const normalized = content.replace(/\r\n/g, '\n');
-  const match = normalized.match(/^---\n([\s\S]*?)\n---/);
-
-  if (!match) return {};
-
-  const frontmatter = match[1];
-  const metadata = {};
-
-  frontmatter.split('\n').forEach(line => {
-    const colonIdx = line.indexOf(':');
-    if (colonIdx === -1) return;
-
-    const key = line.substring(0, colonIdx).trim();
-    const value = line.substring(colonIdx + 1).trim();
-
-    if (key === 'allowed-tools') {
-      metadata.allowedTools = value
-        .split(',')
-        .map(t => t.trim().replace(/^['\"]|['\"]$/g, ''));
-    } else {
-      metadata[key] = value;
-    }
-  });
-
-  return metadata;
-}
-
-function readSkillManifest(skillName) {
-  const searchPaths = [
-    path.join(__dirname, '..', 'skills', skillName, 'SKILL.md'),
-    path.join(__dirname, '..', '..', 'gm-starter', 'skills', skillName, 'SKILL.md')
-  ];
-
-  let skillMdPath = null;
-  for (const p of searchPaths) {
-    if (fs.existsSync(p)) {
-      skillMdPath = p;
-      break;
-    }
-  }
-
-  if (!skillMdPath) {
-    return {
-      name: skillName,
-      description: '',
-      allowedTools: [],
-      compatiblePlatforms: [],
-      endToEnd: false,
-      skillMdContent: ''
-    };
-  }
-
-  const content = fs.readFileSync(skillMdPath, 'utf8');
-  const metadata = parseSkillMarkdown(content);
-
-  return {
-    name: metadata.name || skillName,
-    description: metadata.description || '',
-    version: metadata.version || '1.0.0',
-    category: metadata.category || 'skill',
-    allowedTools: metadata.allowedTools || [],
-    compatiblePlatforms: metadata['compatible-platforms']
-      ? metadata['compatible-platforms'].split(',').map(p => p.trim())
-      : [],
-    endToEnd: metadata['end-to-end'] === 'true',
-    skillMdContent: content
-  };
-}
-
-function getManifest() {
-  const skills = ['gm', 'planning', 'gm-execute', 'gm-emit', 'gm-complete', 'update-docs'];
-  return {
-    name: 'gm-skill',
-    version: '1.0.0',
-    description: 'gm skill manifest and daemon bootstrap integration',
-    skills: skills.map(name => readSkillManifest(name))
-  };
-}
-
-function getSkill(name) {
-  return readSkillManifest(name);
-}
-
-function getAllSkills() {
-  const skills = ['gm', 'planning', 'gm-execute', 'gm-emit', 'gm-complete', 'update-docs'];
-  return skills.map(name => readSkillManifest(name));
-}
-
-module.exports = {
-  getManifest,
-  getSkill,
-  getAllSkills,
-  parseSkillMarkdown,
-  readSkillManifest
-};

package/lib/prepare.js

@@ -1,14 +0,0 @@
-async function prepare(options = {}) {
-  const sessionId = options.sessionId || process.env.CLAUDE_SESSION_ID || 'default';
-  const cwd = options.cwd || process.cwd();
-
-  return {
-    sessionId,
-    cwd,
-    initialized: true
-  };
-}
-
-module.exports = {
-  prepare
-};

package/planning.SKILL.md

@@ -1,118 +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
----
-
-# Planning — PLAN phase
-
-Translate the request into `.gm/prd.yml` and hand to `gm-execute`. Re-enter on any new unknown in any phase.
-
-A `@<discipline>` sigil in the request scopes recall, codesearch, and memorize calls during PLAN to that discipline's store. Without one, retrievals fan across default plus enabled disciplines and writes land in default only.
-
-Cross-cutting dispositions (autonomy, fix-on-sight, nothing-fake, browser-witness, scope, recall, memorize) live in `gm` SKILL.md; this skill only carries what is unique to PLAN.
-
-## Transitions
-
-- PLAN done → `gm-execute`
-- New unknown anywhere in chain → re-enter PLAN
-- EXECUTE unresolvable after 2 passes → PLAN
-- VERIFY: `.prd` empty + git clean + pushed → `update-docs`; else → `gm-execute`
-
-Cannot stop while `.gm/prd.yml` has items, git is dirty, or commits are unpushed.
-
-## Orient
-
-Open every plan with one parallel pack of `exec:recall` + `exec:codesearch` against the request's nouns. Hits land as `weak_prior`; misses confirm the unknown is fresh. The pack runs in one message.
-
-**Auto-recall injection (skills-only platforms)**: derive a 2–6 word query from the request's nouns (subject, verb objects, key domain terms). Call `exec:recall <query>` at PLAN start before writing `.gm/prd.yml`, inline. This replaces the prompt-submit hook's auto-recall for platforms without hook infrastructure. Recall hits are injected as context into mutable discovery and PRD item acceptance criteria.
-
-## Mutable discovery
-
-For each aspect of the work, ask: what do I not know, what could go wrong, what depends on what, what am I assuming. Unwitnessed assumptions are mutables.
-
-Fault surfaces to scan: file existence, API shape, data format, dep versions, runtime behavior, env differences, error conditions, concurrency, integration seams, backwards compat, rollback paths, CI correctness.
-
-Tag every item with a route family (grounding | reasoning | state | execution | observability | boundary | representation) and cross-reference the 16-failure taxonomy. `governance` skill holds the table.
-
-`existingImpl=UNKNOWN` is the default; resolve via `exec:codesearch` before adding the item. An existing concern routes to consolidation, not addition.
-
-Plan exits when zero new unknowns surfaced last pass AND every item has acceptance criteria AND deps are mapped.
-
-## .gm/mutables.yml — co-equal with .gm/prd.yml
-
-Every unknown surfaced during PLAN lands as an entry in `.gm/mutables.yml` the same pass. Live during work, deleted when empty. Hook-gated: Write/Edit/NotebookEdit and `git commit`/`git push` are hard-blocked while any entry has `status: unknown`; turn-stop is hard-blocked the same way.
-
-```yaml
-- id: kebab-id
-  claim: One-line statement of what is assumed
-  witness_method: exec:codesearch <query> | exec:nodejs import | exec:recall <query> | Read <path>
-  witness_evidence: ""
-  status: unknown
-```
-
-`status: unknown` → `witnessed` only when `witness_evidence` is filled with concrete proof (file:line, codesearch hit, dispatched test output). Resolution lives in gm-execute. PRD items reference mutables via optional `mutables: [id1, id2]` field; an item is blocked while any referenced mutable is unresolved.
-
-## .prd format
-
-Path: `./.gm/prd.yml`. Write via the Write tool or by emitting a nodejs spool file (`in/nodejs/<N>.js`) that calls `fs.writeFileSync`. Delete the file when empty.
-
-```yaml
-- id: kebab-id
-  subject: Imperative verb phrase
-  status: pending
-  description: Precise criterion
-  effort: small|medium|large
-  category: feature|bug|refactor|infra
-  route_family: grounding|reasoning|state|execution|observability|boundary|representation
-  load: 0.0-1.0
-  failure_modes: []
-  route_fit: unexamined|examined|dominant
-  authorization: none|weak_prior|witnessed
-  blocking: []
-  blockedBy: []
-  acceptance:
-    - binary criterion
-  edge_cases:
-    - failure mode
-```
-
-`load` is consequence-if-wrong: 0.9 = headline collapses, 0.7 = sub-argument rebuilt, 0.4 = local patch, 0.1 = nothing breaks. Verification budget = `load × (1 − tier_confidence)`. λ>0.75 must reach witnessed before EMIT.
-
-`status`: pending → in_progress → completed (then remove). `effort`: small <15min | medium <45min | large >1h.
-
-## Parallel subagent launch
-
-After `.prd` is written, up to 3 parallel `gm:gm` subagents for independent items in one message. Browser tasks serialize.
-
-```
-Agent(subagent_type="gm:gm", prompt="Work on .prd item: <id>. .prd path: <path>. Item: <full YAML>.")
-```
-
-Items not parallelizable → invoke `gm-execute` directly.
-
-## Observability gates in the plan
-
-Server: every subsystem exposes `/debug/<subsystem>`; structured logs `{subsystem, severity, ts}`. Client: `window.__debug` live registry; modules register on mount. `console.log` is not observability. Discovery of a gap during PLAN adds a `.prd` item the same pass — never deferred.
-
-`window.__debug` is THE in-page registry; `test.js` at project root is the sole out-of-page test asset. Any new file whose purpose is to exercise, smoke-test, demo, or sandbox in-page behavior outside that registry fights the discipline — extend the registry instead.
-
-## Test discipline encoded in the plan
-
-One `test.js` at project root, 200-line hard cap, real data, real system. No fixtures, mocks, or scattered tests. A second test runner under any name in any directory is a smuggled parallel surface.
-
-The 200 lines are a *budget* for maximum surface coverage, not a target. Subsystems get one combined group each — names joined with `+` (`home+config+skin`, `mcp+swe+distributions+account+credpool`). When a new subsystem's failure mode overlaps an existing group's side-effects, fold the assertion in rather than creating a new group. When `wc -l test.js > 200`, the discipline is *merge groups + drop redundancy*, never split.
-
-## Execution norms encoded in the plan
-
-Code execution AND utility verbs both write to `.gm/exec-spool/in/<lang-or-verb>/<N>.<ext>`. Languages live under `in/<lang>/` (nodejs, python, bash, typescript, go, rust, c, cpp, java, deno); verbs live under `in/<verb>/` (codesearch, recall, memorize, wait, sleep, status, close, browser, runner, type, kill-port, forget, feedback, learn-status, learn-debug, learn-build, discipline, pause, health). The spool watcher runs the file and streams to `out/<N>.out` (stdout) + `out/<N>.err` (stderr) line-by-line, then writes `out/<N>.json` metadata (exitCode, durationMs, timedOut, startedAt, endedAt) at completion. Both streams return as systemMessage with `--- stdout ---` / `--- stderr ---` separators. `in/` and `out/` are wiped at session start and at real-exit session end. Only `git` (and `gh`) run directly via Bash; never `Bash(node/npm/npx/bun)`, never `Bash(exec:<anything>)`. Spool paths in nodejs files are platform-literal — use `os.tmpdir()` and `path.join`. The spool enforces per-task timeouts; on timeout, partial output is preserved and the watcher emits `[exec timed out after Nms; partial output above]`.
-
-`exec:codesearch` only — Grep/Glob/Find/Explore are hook-blocked. Start two words, change/add one per pass, minimum four attempts before concluding absent.
-
-Pack runs use `Promise.allSettled`, each idea its own try/catch, under 12s per call.
-
-## Dev workflow encoded in the plan
-
-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.

package/skills/gm/index.js

@@ -1,113 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-
-async function gmSkill(input) {
-  const context = {
-    request: input.request || '',
-    taskId: input.taskId || require('crypto').randomUUID(),
-    sessionId: process.env.SESSION_ID || require('crypto').randomUUID(),
-    timestamp: new Date().toISOString(),
-    phases: [],
-    prd: [],
-    mutables: {},
-  };
-
-  const skillsDir = path.join(__dirname);
-  const gmDir = path.dirname(path.dirname(skillsDir));
-
-  let currentSkill = 'planning';
-  let chainDepth = 0;
-  const maxDepth = 6;
-
-  console.log(`[gm] orchestrator starting; request="${context.request}"; task=${context.taskId}`);
-
-  while (currentSkill && chainDepth < maxDepth) {
-    chainDepth++;
-    console.error(`[gm] depth=${chainDepth}; invoking ${currentSkill}`);
-
-    const skillPath = path.join(skillsDir, currentSkill, 'index.js');
-    if (!fs.existsSync(skillPath)) {
-      console.error(`[gm] ERROR: skill not found: ${skillPath}`);
-      return {
-        nextSkill: null,
-        context,
-        phase: 'ERROR',
-        error: `Skill ${currentSkill} not found`,
-      };
-    }
-
-    try {
-      const skillModule = require(skillPath);
-      const result = await skillModule(input, context);
-
-      if (!result || typeof result !== 'object') {
-        console.error(`[gm] ERROR: skill returned invalid result`);
-        return {
-          nextSkill: null,
-          context,
-          phase: 'ERROR',
-          error: `Skill ${currentSkill} returned invalid result`,
-        };
-      }
-
-      context.phases.push({
-        skill: currentSkill,
-        phase: result.phase,
-        timestamp: new Date().toISOString(),
-      });
-
-      currentSkill = result.nextSkill || null;
-
-      if (!currentSkill) {
-        console.error(`[gm] chain complete`);
-        return {
-          nextSkill: null,
-          context,
-          phase: 'COMPLETE',
-        };
-      }
-
-      input = { ...input, context };
-    } catch (error) {
-      console.error(`[gm] ERROR in ${currentSkill}:`, error.message);
-      return {
-        nextSkill: null,
-        context,
-        phase: 'ERROR',
-        error: `${currentSkill} failed: ${error.message}`,
-      };
-    }
-  }
-
-  if (chainDepth >= maxDepth) {
-    console.error(`[gm] ERROR: max chain depth exceeded`);
-    return {
-      nextSkill: null,
-      context,
-      phase: 'ERROR',
-      error: 'Skill chain exceeded maximum depth',
-    };
-  }
-
-  return {
-    nextSkill: null,
-    context,
-    phase: 'COMPLETE',
-  };
-}
-
-if (require.main === module) {
-  const input = {
-    request: process.argv[2] || 'test task',
-    context: null,
-  };
-
-  gmSkill(input).then(result => {
-    console.log(JSON.stringify(result, null, 2));
-  }).catch(err => {
-    console.error('Fatal error:', err);
-    process.exit(1);
-  });
-}
-
-module.exports = gmSkill;