gm-thebird 2.0.1026 → 2.0.1028

package/gm.json

@@ -1,6 +1,6 @@
 {
   "name": "gm",
-  "version": "2.0.1026",
+  "version": "2.0.1028",
   "description": "State machine agent with hooks, skills, and automated git enforcement",
   "author": "AnEntrypoint",
   "license": "MIT",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gm-thebird",
-  "version": "2.0.1026",
+  "version": "2.0.1028",
   "description": "State machine agent with hooks, skills, and automated git enforcement",
   "author": "AnEntrypoint",
   "license": "MIT",

package/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "gm",
-  "version": "2.0.1026",
+  "version": "2.0.1028",
   "description": "State machine agent with hooks, skills, and automated git enforcement",
   "author": {
     "name": "AnEntrypoint",

package/skills/gm/SKILL.md

@@ -1,69 +1,60 @@
 ---
 name: gm
-description: Agent (not skill) - immutable programming state machine. Always invoke for all work coordination.
+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. Skill tool only.
+Invoke `planning` immediately. Phases cascade: PLAN → EXECUTE → EMIT → VERIFY → UPDATE-DOCS.
 
-Phases: PLAN → EXECUTE → EMIT → VERIFY → UPDATE-DOCS. Each loaded by Skill invocation; reading the summary is not being in the phase.
+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.
 
-## The world the answer lives in
+**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.
 
-The user's request is the authorization. The PRD records it. Doubts during execution resolve by witnessed probe, by recall, or by re-reading the PRD. Questions back to the user only when the next action is destructive-irreversible AND uncovered by the PRD, or when intent is genuinely irrecoverable from PRD, memory, code, and the public web. `exec:pause` is the channel; in-conversation asking is beneath that. Web-search before pausing on anything the public web could plausibly answer.
+**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.
 
-The obvious read of "deeply integrate", "all of them", "every X", "across the whole Y" is wider, not narrower. Pick the maximum reachable shape, declare the read in one line so the user can interrupt, execute. Multi-repo scope, build cost, CI duration, binary-size impact are never grounds to re-confirm. When scope exceeds reach, write every witnessable subset into the PRD as separate items and finish them all. Residuals within the spirit of the ask and reachable from this session re-enter `planning`, append PRD items, and execute — silently-but-declared, never name-and-stop, never asked back. The only name-and-stop residual is one that is genuinely outside the spirit of the ask OR genuinely unreachable from this session; everything else is this turn's work. Before declaring done, scan once more: any reachable in-spirit residual found means re-enter PLAN, not stop.
+**Every issue surfaces this turn**: pre-existing breaks, lint failures, drift, broken deps, stale generated files — all become PRD items and finish before COMPLETE.
 
-When a PRD holds remaining items, do every reachable one — never offer the user a numbered choice between strategies, never serialize "approach A then approach B then approach C" through the user's inbox. Independent items run as parallel `gm:gm` subagents in one message; sequential items execute back-to-back without re-asking permission between them. The user's authorization for the PRD is authorization for every item in it. A response that asks "1, 2, 3, or 4?" when the PRD is non-empty is the failure this rule guards against — pick the obvious reading, declare it in one line, execute all of them.
+**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.
 
-What ships runs. Stubs, mocks, placeholder returns, fixture-only paths, demo-mode short-circuits, and "TODO: implement" bodies are forbidden in shipped code — they ship green checks that lie. A shim is allowed only when it delegates to real upstream behavior; before adding one, check whether a published library already covers the surface, because local reimplementations drift and age. The behavioral test for fakeness: real input through real code into real output, witnessed. Anything less is provisional.
+**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.
 
-CI is the build. For Rust crates in this org (rs-exec, rs-codeinsight, rs-search, rs-learn, rs-plugkit) and the gm publish chain, `git push` triggers the build matrix; `cargo build` and `cargo test` are not run locally. Local toolchain mismatches, missing deps, or rustc version skew never block a push — push, watch CI via the Stop hook, fix on red. "I cannot witness without a local build" is wrong here: the witness is the green CI run on the pushed HEAD, and the cascade fans the green binary to all 12 downstream platform repos. Pausing for a local build wall is forced closure dressed as caution.
+**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', ...)`.
 
-Every issue surfaced during work is fixed in-band, this turn, at root cause. Pre-existing build breaks, neighboring lint failures, lockfile drift, broken deps, and stale generated files surfaced while doing the user's task become new PRD items the same turn and finish before COMPLETE. Same rule for obvious refactor wins: hand-rolled code that an existing library covers, multi-file ad-hoc systems one import would replace. The bar is *obvious + reachable from this session*. Items left in `.gm/prd.yml` from prior sessions are this session's work the moment they're seen.
+**Recall before fresh execution**: before witnessing unknown via execution, recall first. Hits arrive as weak_prior; empty results confirm fresh unknown.
 
-Editing browser-facing code requires `exec:browser` witness in the same turn — boot the surface, navigate, assert the specific invariant via `page.evaluate`, capture the numbers. EXECUTE witnesses on edit, EMIT re-witnesses post-write, VERIFY runs the final gate. The exemption (pure-prose static document with no behavior change) is tagged in the response with the reason.
+**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.
 
-Code does mechanics; meaning goes through the textprocessing skill. Summarize, classify, extract intent, rewrite, translate, semantic dedup, rank, label, decide-if-two-texts-mean-the-same — all routed through `Agent(subagent_type='gm:textprocessing', model='haiku', ...)`, N items in N parallel calls. A keyword-list or regex-on-meaning-phrases loop deciding semantic questions is a stub of this skill.
+**Parallel independent items**: up to 3 `gm:gm` subagents per message for independent PRD items. Serial for dependent items — no re-asking between them.
 
-Every program emits structured JSONL to `~/.claude/gm-log/<date>/<subsystem>.jsonl`. Inspect via `plugkit log {tail|grep|stats}` before re-running with print debugging. Code the agent writes extends the project's existing observability surface; if none exists, the smallest correct shim is one JSONL appender to `.gm/log/`. Emit on state transitions, error boundaries, external IO, nontrivial decisions; skip loop bodies and parser steps.
+**Terse response**: fragments OK. `[thing] [action] [reason]. [next step].` Code, commits, PRs use normal prose.
 
-## Recall and memorize
+## End-to-End Phase Chaining (Skills-Based Platforms)
 
-Before resolving any unknown via fresh execution, recall first.
+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"}
 ```
-exec:recall
-<2-6 word query>
-```
-
-Hits arrive as `weak_prior` — they earn the right to be tested, not believed. Empty results confirm the unknown is fresh.
-
-A witness that flips an unknown to known is incomplete until the fact lives outside this context window. Memorize is the back-half of the same act, not a later chore — it fires alongside the witness, in the background, in haiku, never blocking the next probe. Resolutions hand off as they happen.
-
-```
-Agent(subagent_type='gm:memorize', model='haiku', run_in_background=true, prompt='## CONTEXT TO MEMORIZE\n<fact>')
-```
-
-One subagent per fact, fan out in parallel — batching dilutes the signal. The mutables file is the receipt: every entry that flips to `status: witnessed` carries a matching haiku in flight. A status change without a memorize is unfinished work the next turn cannot see.
-
-## Execution order
-
-The spool is the universal dispatch surface. Write a file to `.gm/exec-spool/in/<lang-or-verb>/<N>.<ext>`; the watcher executes and streams `out/<N>.out` + `out/<N>.err` + `out/<N>.json`. 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.
-
-Order of cheapness:
-
-1. Recall — `in/recall/<N>.txt` with the query
-2. Codebase search — `in/codesearch/<N>.txt` with two-word query, 90% of lookups
-3. Code execution — `in/<lang>/<N>.<ext>`
-4. Web (`WebFetch`, `WebSearch`) — env facts not in codebase
-5. User — last resort
-
-Bash accepts ONLY git commands directly (`git status`, `git commit`, `git push`, `git log`, `gh ...`). Everything else — code AND every utility verb — dispatches via the spool. Never `Bash(node/npm/npx/bun)`, never `Bash(exec:<anything>)`. `git push` triggers auto CI watch via Stop hook.
-
-Skill chain: `planning` → `gm-execute` → `gm-emit` → `gm-complete` → `update-docs`.
 
-## Response shape
+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
 
-Terse. Fragments OK. `[thing] [action] [reason]. [next step].` Code, commits, PRs use normal prose. Drop terseness for security or destructive moves.
+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/skills/gm-cc/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: gm-cc
+description: AI-native software engineering via skill-driven orchestration on cc; bootstraps plugkit for task execution and session isolation
+allowed-tools:
+  - Skill
+compatible-platforms:
+  - gm-cc
+---
+
+# GM — cc Platform
+
+AI-native software engineering orchestrated via skill chain: PLAN → EXECUTE → EMIT → VERIFY → UPDATE-DOCS.
+
+**Bootstrap pattern**: bootstrapPlugkit() loads plugkit binary (`.gm-tools/plugkit`) at session start, verifies sha256 against manifest. Returns plugkit.version + plugkit.sha256. Failure blocks all downstream dispatch — re-run bootstrap before retry.
+
+**Session-ID threading (no session-start hook)**: At skill invoke time, generate or detect SESSION_ID (env var `SESSION_ID` or `uuid()`). Pass `sessionId: "<id>"` in every rs-exec RPC body (spawn, tail, watch, etc.) and every spool-written task body. All task-scoped cleanup (deleteTask, getTask, appendOutput, killSessionTasks) requires matching sessionId. Absence is forbidden — hard reject by rs-exec handler.
+
+**Spool dispatch surface**: Write to `.gm/exec-spool/in/<lang>/<N>.<ext>` (languages: nodejs, python, bash, typescript, go, rust, c, cpp, java, deno) or `in/<verb>/<N>.txt` (verbs: codesearch, recall, memorize, wait, sleep, status, close, browser, runner, etc.). Watcher executes and streams `out/<N>.out` (stdout) + `out/<N>.err` (stderr) line-by-line, then `out/<N>.json` metadata (exitCode, durationMs, timedOut, startedAt, endedAt) at completion.
+
+**End-to-end skill chaining (skills-based platforms)**: When gm SKILL.md includes `end-to-end: true`, adapter detects signal and parses stdout for trailing JSON: `{"nextSkill": "...", "context": {...}, "phase": "..."}`. If nextSkill is non-null, invoke `Skill(skill="gm:<nextSkill>")` with context dict, repeat until null. This auto-chains 5 invocations into 1 user invocation.
+
+Every task returns complete: taskId, exitCode, durationMs, timedOut, stdout, stderr. Background tasks return immediately with task_id; continue with exec:tail, exec:watch, or exec:close.

package/skills/gm-codex/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: gm-codex
+description: AI-native software engineering via skill-driven orchestration on codex; bootstraps plugkit for task execution and session isolation
+allowed-tools:
+  - Skill
+compatible-platforms:
+  - gm-codex
+---
+
+# GM — codex Platform
+
+AI-native software engineering orchestrated via skill chain: PLAN → EXECUTE → EMIT → VERIFY → UPDATE-DOCS.
+
+**Bootstrap pattern**: bootstrapPlugkit() loads plugkit binary (`.gm-tools/plugkit`) at session start, verifies sha256 against manifest. Returns plugkit.version + plugkit.sha256. Failure blocks all downstream dispatch — re-run bootstrap before retry.
+
+**Session-ID threading (no session-start hook)**: At skill invoke time, generate or detect SESSION_ID (env var `SESSION_ID` or `uuid()`). Pass `sessionId: "<id>"` in every rs-exec RPC body (spawn, tail, watch, etc.) and every spool-written task body. All task-scoped cleanup (deleteTask, getTask, appendOutput, killSessionTasks) requires matching sessionId. Absence is forbidden — hard reject by rs-exec handler.
+
+**Spool dispatch surface**: Write to `.gm/exec-spool/in/<lang>/<N>.<ext>` (languages: nodejs, python, bash, typescript, go, rust, c, cpp, java, deno) or `in/<verb>/<N>.txt` (verbs: codesearch, recall, memorize, wait, sleep, status, close, browser, runner, etc.). Watcher executes and streams `out/<N>.out` (stdout) + `out/<N>.err` (stderr) line-by-line, then `out/<N>.json` metadata (exitCode, durationMs, timedOut, startedAt, endedAt) at completion.
+
+**End-to-end skill chaining (skills-based platforms)**: When gm SKILL.md includes `end-to-end: true`, adapter detects signal and parses stdout for trailing JSON: `{"nextSkill": "...", "context": {...}, "phase": "..."}`. If nextSkill is non-null, invoke `Skill(skill="gm:<nextSkill>")` with context dict, repeat until null. This auto-chains 5 invocations into 1 user invocation.
+
+Every task returns complete: taskId, exitCode, durationMs, timedOut, stdout, stderr. Background tasks return immediately with task_id; continue with exec:tail, exec:watch, or exec:close.

package/skills/gm-copilot-cli/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: gm-copilot-cli
+description: AI-native software engineering via skill-driven orchestration on copilot-cli; bootstraps plugkit for task execution and session isolation
+allowed-tools:
+  - Skill
+compatible-platforms:
+  - gm-copilot-cli
+---
+
+# GM — copilot-cli Platform
+
+AI-native software engineering orchestrated via skill chain: PLAN → EXECUTE → EMIT → VERIFY → UPDATE-DOCS.
+
+**Bootstrap pattern**: bootstrapPlugkit() loads plugkit binary (`.gm-tools/plugkit`) at session start, verifies sha256 against manifest. Returns plugkit.version + plugkit.sha256. Failure blocks all downstream dispatch — re-run bootstrap before retry.
+
+**Session-ID threading (no session-start hook)**: At skill invoke time, generate or detect SESSION_ID (env var `SESSION_ID` or `uuid()`). Pass `sessionId: "<id>"` in every rs-exec RPC body (spawn, tail, watch, etc.) and every spool-written task body. All task-scoped cleanup (deleteTask, getTask, appendOutput, killSessionTasks) requires matching sessionId. Absence is forbidden — hard reject by rs-exec handler.
+
+**Spool dispatch surface**: Write to `.gm/exec-spool/in/<lang>/<N>.<ext>` (languages: nodejs, python, bash, typescript, go, rust, c, cpp, java, deno) or `in/<verb>/<N>.txt` (verbs: codesearch, recall, memorize, wait, sleep, status, close, browser, runner, etc.). Watcher executes and streams `out/<N>.out` (stdout) + `out/<N>.err` (stderr) line-by-line, then `out/<N>.json` metadata (exitCode, durationMs, timedOut, startedAt, endedAt) at completion.
+
+**End-to-end skill chaining (skills-based platforms)**: When gm SKILL.md includes `end-to-end: true`, adapter detects signal and parses stdout for trailing JSON: `{"nextSkill": "...", "context": {...}, "phase": "..."}`. If nextSkill is non-null, invoke `Skill(skill="gm:<nextSkill>")` with context dict, repeat until null. This auto-chains 5 invocations into 1 user invocation.
+
+Every task returns complete: taskId, exitCode, durationMs, timedOut, stdout, stderr. Background tasks return immediately with task_id; continue with exec:tail, exec:watch, or exec:close.

package/skills/gm-cursor/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: gm-cursor
+description: AI-native software engineering via skill-driven orchestration on cursor; bootstraps plugkit for task execution and session isolation
+allowed-tools:
+  - Skill
+compatible-platforms:
+  - gm-cursor
+---
+
+# GM — cursor Platform
+
+AI-native software engineering orchestrated via skill chain: PLAN → EXECUTE → EMIT → VERIFY → UPDATE-DOCS.
+
+**Bootstrap pattern**: bootstrapPlugkit() loads plugkit binary (`.gm-tools/plugkit`) at session start, verifies sha256 against manifest. Returns plugkit.version + plugkit.sha256. Failure blocks all downstream dispatch — re-run bootstrap before retry.
+
+**Session-ID threading (no session-start hook)**: At skill invoke time, generate or detect SESSION_ID (env var `SESSION_ID` or `uuid()`). Pass `sessionId: "<id>"` in every rs-exec RPC body (spawn, tail, watch, etc.) and every spool-written task body. All task-scoped cleanup (deleteTask, getTask, appendOutput, killSessionTasks) requires matching sessionId. Absence is forbidden — hard reject by rs-exec handler.
+
+**Spool dispatch surface**: Write to `.gm/exec-spool/in/<lang>/<N>.<ext>` (languages: nodejs, python, bash, typescript, go, rust, c, cpp, java, deno) or `in/<verb>/<N>.txt` (verbs: codesearch, recall, memorize, wait, sleep, status, close, browser, runner, etc.). Watcher executes and streams `out/<N>.out` (stdout) + `out/<N>.err` (stderr) line-by-line, then `out/<N>.json` metadata (exitCode, durationMs, timedOut, startedAt, endedAt) at completion.
+
+**End-to-end skill chaining (skills-based platforms)**: When gm SKILL.md includes `end-to-end: true`, adapter detects signal and parses stdout for trailing JSON: `{"nextSkill": "...", "context": {...}, "phase": "..."}`. If nextSkill is non-null, invoke `Skill(skill="gm:<nextSkill>")` with context dict, repeat until null. This auto-chains 5 invocations into 1 user invocation.
+
+Every task returns complete: taskId, exitCode, durationMs, timedOut, stdout, stderr. Background tasks return immediately with task_id; continue with exec:tail, exec:watch, or exec:close.

package/skills/gm-gc/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: gm-gc
+description: AI-native software engineering via skill-driven orchestration on gc; bootstraps plugkit for task execution and session isolation
+allowed-tools:
+  - Skill
+compatible-platforms:
+  - gm-gc
+---
+
+# GM — gc Platform
+
+AI-native software engineering orchestrated via skill chain: PLAN → EXECUTE → EMIT → VERIFY → UPDATE-DOCS.
+
+**Bootstrap pattern**: bootstrapPlugkit() loads plugkit binary (`.gm-tools/plugkit`) at session start, verifies sha256 against manifest. Returns plugkit.version + plugkit.sha256. Failure blocks all downstream dispatch — re-run bootstrap before retry.
+
+**Session-ID threading (no session-start hook)**: At skill invoke time, generate or detect SESSION_ID (env var `SESSION_ID` or `uuid()`). Pass `sessionId: "<id>"` in every rs-exec RPC body (spawn, tail, watch, etc.) and every spool-written task body. All task-scoped cleanup (deleteTask, getTask, appendOutput, killSessionTasks) requires matching sessionId. Absence is forbidden — hard reject by rs-exec handler.
+
+**Spool dispatch surface**: Write to `.gm/exec-spool/in/<lang>/<N>.<ext>` (languages: nodejs, python, bash, typescript, go, rust, c, cpp, java, deno) or `in/<verb>/<N>.txt` (verbs: codesearch, recall, memorize, wait, sleep, status, close, browser, runner, etc.). Watcher executes and streams `out/<N>.out` (stdout) + `out/<N>.err` (stderr) line-by-line, then `out/<N>.json` metadata (exitCode, durationMs, timedOut, startedAt, endedAt) at completion.
+
+**End-to-end skill chaining (skills-based platforms)**: When gm SKILL.md includes `end-to-end: true`, adapter detects signal and parses stdout for trailing JSON: `{"nextSkill": "...", "context": {...}, "phase": "..."}`. If nextSkill is non-null, invoke `Skill(skill="gm:<nextSkill>")` with context dict, repeat until null. This auto-chains 5 invocations into 1 user invocation.
+
+Every task returns complete: taskId, exitCode, durationMs, timedOut, stdout, stderr. Background tasks return immediately with task_id; continue with exec:tail, exec:watch, or exec:close.

package/skills/gm-jetbrains/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: gm-jetbrains
+description: AI-native software engineering via skill-driven orchestration on jetbrains; bootstraps plugkit for task execution and session isolation
+allowed-tools:
+  - Skill
+compatible-platforms:
+  - gm-jetbrains
+---
+
+# GM — jetbrains Platform
+
+AI-native software engineering orchestrated via skill chain: PLAN → EXECUTE → EMIT → VERIFY → UPDATE-DOCS.
+
+**Bootstrap pattern**: bootstrapPlugkit() loads plugkit binary (`.gm-tools/plugkit`) at session start, verifies sha256 against manifest. Returns plugkit.version + plugkit.sha256. Failure blocks all downstream dispatch — re-run bootstrap before retry.
+
+**Session-ID threading (no session-start hook)**: At skill invoke time, generate or detect SESSION_ID (env var `SESSION_ID` or `uuid()`). Pass `sessionId: "<id>"` in every rs-exec RPC body (spawn, tail, watch, etc.) and every spool-written task body. All task-scoped cleanup (deleteTask, getTask, appendOutput, killSessionTasks) requires matching sessionId. Absence is forbidden — hard reject by rs-exec handler.
+
+**Spool dispatch surface**: Write to `.gm/exec-spool/in/<lang>/<N>.<ext>` (languages: nodejs, python, bash, typescript, go, rust, c, cpp, java, deno) or `in/<verb>/<N>.txt` (verbs: codesearch, recall, memorize, wait, sleep, status, close, browser, runner, etc.). Watcher executes and streams `out/<N>.out` (stdout) + `out/<N>.err` (stderr) line-by-line, then `out/<N>.json` metadata (exitCode, durationMs, timedOut, startedAt, endedAt) at completion.
+
+**End-to-end skill chaining (skills-based platforms)**: When gm SKILL.md includes `end-to-end: true`, adapter detects signal and parses stdout for trailing JSON: `{"nextSkill": "...", "context": {...}, "phase": "..."}`. If nextSkill is non-null, invoke `Skill(skill="gm:<nextSkill>")` with context dict, repeat until null. This auto-chains 5 invocations into 1 user invocation.
+
+Every task returns complete: taskId, exitCode, durationMs, timedOut, stdout, stderr. Background tasks return immediately with task_id; continue with exec:tail, exec:watch, or exec:close.

package/skills/gm-kilo/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: gm-kilo
+description: AI-native software engineering via skill-driven orchestration on kilo; bootstraps plugkit for task execution and session isolation
+allowed-tools:
+  - Skill
+compatible-platforms:
+  - gm-kilo
+---
+
+# GM — kilo Platform
+
+AI-native software engineering orchestrated via skill chain: PLAN → EXECUTE → EMIT → VERIFY → UPDATE-DOCS.
+
+**Bootstrap pattern**: bootstrapPlugkit() loads plugkit binary (`.gm-tools/plugkit`) at session start, verifies sha256 against manifest. Returns plugkit.version + plugkit.sha256. Failure blocks all downstream dispatch — re-run bootstrap before retry.
+
+**Session-ID threading (no session-start hook)**: At skill invoke time, generate or detect SESSION_ID (env var `SESSION_ID` or `uuid()`). Pass `sessionId: "<id>"` in every rs-exec RPC body (spawn, tail, watch, etc.) and every spool-written task body. All task-scoped cleanup (deleteTask, getTask, appendOutput, killSessionTasks) requires matching sessionId. Absence is forbidden — hard reject by rs-exec handler.
+
+**Spool dispatch surface**: Write to `.gm/exec-spool/in/<lang>/<N>.<ext>` (languages: nodejs, python, bash, typescript, go, rust, c, cpp, java, deno) or `in/<verb>/<N>.txt` (verbs: codesearch, recall, memorize, wait, sleep, status, close, browser, runner, etc.). Watcher executes and streams `out/<N>.out` (stdout) + `out/<N>.err` (stderr) line-by-line, then `out/<N>.json` metadata (exitCode, durationMs, timedOut, startedAt, endedAt) at completion.
+
+**End-to-end skill chaining (skills-based platforms)**: When gm SKILL.md includes `end-to-end: true`, adapter detects signal and parses stdout for trailing JSON: `{"nextSkill": "...", "context": {...}, "phase": "..."}`. If nextSkill is non-null, invoke `Skill(skill="gm:<nextSkill>")` with context dict, repeat until null. This auto-chains 5 invocations into 1 user invocation.
+
+Every task returns complete: taskId, exitCode, durationMs, timedOut, stdout, stderr. Background tasks return immediately with task_id; continue with exec:tail, exec:watch, or exec:close.

package/skills/gm-oc/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: gm-oc
+description: AI-native software engineering via skill-driven orchestration on oc; bootstraps plugkit for task execution and session isolation
+allowed-tools:
+  - Skill
+compatible-platforms:
+  - gm-oc
+---
+
+# GM — oc Platform
+
+AI-native software engineering orchestrated via skill chain: PLAN → EXECUTE → EMIT → VERIFY → UPDATE-DOCS.
+
+**Bootstrap pattern**: bootstrapPlugkit() loads plugkit binary (`.gm-tools/plugkit`) at session start, verifies sha256 against manifest. Returns plugkit.version + plugkit.sha256. Failure blocks all downstream dispatch — re-run bootstrap before retry.
+
+**Session-ID threading (no session-start hook)**: At skill invoke time, generate or detect SESSION_ID (env var `SESSION_ID` or `uuid()`). Pass `sessionId: "<id>"` in every rs-exec RPC body (spawn, tail, watch, etc.) and every spool-written task body. All task-scoped cleanup (deleteTask, getTask, appendOutput, killSessionTasks) requires matching sessionId. Absence is forbidden — hard reject by rs-exec handler.
+
+**Spool dispatch surface**: Write to `.gm/exec-spool/in/<lang>/<N>.<ext>` (languages: nodejs, python, bash, typescript, go, rust, c, cpp, java, deno) or `in/<verb>/<N>.txt` (verbs: codesearch, recall, memorize, wait, sleep, status, close, browser, runner, etc.). Watcher executes and streams `out/<N>.out` (stdout) + `out/<N>.err` (stderr) line-by-line, then `out/<N>.json` metadata (exitCode, durationMs, timedOut, startedAt, endedAt) at completion.
+
+**End-to-end skill chaining (skills-based platforms)**: When gm SKILL.md includes `end-to-end: true`, adapter detects signal and parses stdout for trailing JSON: `{"nextSkill": "...", "context": {...}, "phase": "..."}`. If nextSkill is non-null, invoke `Skill(skill="gm:<nextSkill>")` with context dict, repeat until null. This auto-chains 5 invocations into 1 user invocation.
+
+Every task returns complete: taskId, exitCode, durationMs, timedOut, stdout, stderr. Background tasks return immediately with task_id; continue with exec:tail, exec:watch, or exec:close.

package/skills/gm-vscode/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: gm-vscode
+description: AI-native software engineering via skill-driven orchestration on vscode; bootstraps plugkit for task execution and session isolation
+allowed-tools:
+  - Skill
+compatible-platforms:
+  - gm-vscode
+---
+
+# GM — vscode Platform
+
+AI-native software engineering orchestrated via skill chain: PLAN → EXECUTE → EMIT → VERIFY → UPDATE-DOCS.
+
+**Bootstrap pattern**: bootstrapPlugkit() loads plugkit binary (`.gm-tools/plugkit`) at session start, verifies sha256 against manifest. Returns plugkit.version + plugkit.sha256. Failure blocks all downstream dispatch — re-run bootstrap before retry.
+
+**Session-ID threading (no session-start hook)**: At skill invoke time, generate or detect SESSION_ID (env var `SESSION_ID` or `uuid()`). Pass `sessionId: "<id>"` in every rs-exec RPC body (spawn, tail, watch, etc.) and every spool-written task body. All task-scoped cleanup (deleteTask, getTask, appendOutput, killSessionTasks) requires matching sessionId. Absence is forbidden — hard reject by rs-exec handler.
+
+**Spool dispatch surface**: Write to `.gm/exec-spool/in/<lang>/<N>.<ext>` (languages: nodejs, python, bash, typescript, go, rust, c, cpp, java, deno) or `in/<verb>/<N>.txt` (verbs: codesearch, recall, memorize, wait, sleep, status, close, browser, runner, etc.). Watcher executes and streams `out/<N>.out` (stdout) + `out/<N>.err` (stderr) line-by-line, then `out/<N>.json` metadata (exitCode, durationMs, timedOut, startedAt, endedAt) at completion.
+
+**End-to-end skill chaining (skills-based platforms)**: When gm SKILL.md includes `end-to-end: true`, adapter detects signal and parses stdout for trailing JSON: `{"nextSkill": "...", "context": {...}, "phase": "..."}`. If nextSkill is non-null, invoke `Skill(skill="gm:<nextSkill>")` with context dict, repeat until null. This auto-chains 5 invocations into 1 user invocation.
+
+Every task returns complete: taskId, exitCode, durationMs, timedOut, stdout, stderr. Background tasks return immediately with task_id; continue with exec:tail, exec:watch, or exec:close.

package/skills/gm-zed/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: gm-zed
+description: AI-native software engineering via skill-driven orchestration on zed; bootstraps plugkit for task execution and session isolation
+allowed-tools:
+  - Skill
+compatible-platforms:
+  - gm-zed
+---
+
+# GM — zed Platform
+
+AI-native software engineering orchestrated via skill chain: PLAN → EXECUTE → EMIT → VERIFY → UPDATE-DOCS.
+
+**Bootstrap pattern**: bootstrapPlugkit() loads plugkit binary (`.gm-tools/plugkit`) at session start, verifies sha256 against manifest. Returns plugkit.version + plugkit.sha256. Failure blocks all downstream dispatch — re-run bootstrap before retry.
+
+**Session-ID threading (no session-start hook)**: At skill invoke time, generate or detect SESSION_ID (env var `SESSION_ID` or `uuid()`). Pass `sessionId: "<id>"` in every rs-exec RPC body (spawn, tail, watch, etc.) and every spool-written task body. All task-scoped cleanup (deleteTask, getTask, appendOutput, killSessionTasks) requires matching sessionId. Absence is forbidden — hard reject by rs-exec handler.
+
+**Spool dispatch surface**: Write to `.gm/exec-spool/in/<lang>/<N>.<ext>` (languages: nodejs, python, bash, typescript, go, rust, c, cpp, java, deno) or `in/<verb>/<N>.txt` (verbs: codesearch, recall, memorize, wait, sleep, status, close, browser, runner, etc.). Watcher executes and streams `out/<N>.out` (stdout) + `out/<N>.err` (stderr) line-by-line, then `out/<N>.json` metadata (exitCode, durationMs, timedOut, startedAt, endedAt) at completion.
+
+**End-to-end skill chaining (skills-based platforms)**: When gm SKILL.md includes `end-to-end: true`, adapter detects signal and parses stdout for trailing JSON: `{"nextSkill": "...", "context": {...}, "phase": "..."}`. If nextSkill is non-null, invoke `Skill(skill="gm:<nextSkill>")` with context dict, repeat until null. This auto-chains 5 invocations into 1 user invocation.
+
+Every task returns complete: taskId, exitCode, durationMs, timedOut, stdout, stderr. Background tasks return immediately with task_id; continue with exec:tail, exec:watch, or exec:close.

package/skills/planning/SKILL.md

@@ -25,6 +25,8 @@ Cannot stop while `.gm/prd.yml` has items, git is dirty, or commits are unpushed
 
 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.