gm-copilot-cli 2.0.726 → 2.0.1063

package/agents/gm.md

@@ -1,8 +1,6 @@
 ---
-name: gm
 description: Agent (not skill) - immutable programming state machine. Always invoke for all work coordination.
-agent: true
-enforce: critical
+mode: primary
 ---
 
 # GM — Skill-First Orchestrator

package/agents/memorize.md

@@ -1,7 +1,6 @@
 ---
 name: memorize
 description: Background memory agent. Classifies context and writes to AGENTS.md + rs-learn. No memory dir, no MEMORY.md.
-agent: true
 ---
 
 # Memorize — Background Memory Agent
@@ -11,6 +10,19 @@ Writes facts to two places only: **AGENTS.md** (non-obvious technical caveats) a
 Resolve at start of every run:
 
 - **Project root** = `process.cwd()` when invoked. `AGENTS.md` is `<project root>/AGENTS.md`.
+- **Reach check** = run `gh api repos/<owner>/<repo> --jq .permissions.push` on `<project root>`'s `git remote get-url origin`. Cache the answer for the run. If the result is anything other than literal `true` (false, no remote, non-github URL, gh CLI missing, gh not authed, repo private and inaccessible), the project is **out-of-reach**.
+
+## STEP 0: SCOPE GUARD — DO NOT POLLUTE OUT-OF-REACH PROJECTS
+
+If the reach check returns out-of-reach:
+
+- **Do** ingest classified facts into rs-learn (Step 2) — rs-learn is per-user, not per-project, so private notes about a project the user is reading-but-not-owning are safe there.
+- **Do not** read or edit `<project root>/AGENTS.md` (Step 3). Skip the file entirely.
+- **Do not** run the AGENTS.md ↔ rs-learn migration audit (Step 4). The audit edits AGENTS.md.
+
+Reason: agents running in a cwd that points at a third-party repo (e.g. running Claude inside a checkout of `nousresearch/hermes-agent` while building a downstream port) must not write project-specific notes into the upstream project's AGENTS.md. That AGENTS.md belongs to the upstream maintainers. Personal porting notes belong in the user's downstream repo's AGENTS.md, or — when the work spans multiple repos and there's no clean home — in rs-learn only.
+
+When the reach check returns **in-reach**, proceed normally with all four steps below.
 
 ## STEP 1: CLASSIFY
 
@@ -38,6 +50,8 @@ exec:memorize
 
 Line 1 of the body is the source tag (e.g. `feedback/terse-responses`, `project/merge-freeze`). Lines 2+ are the fact itself. Use kebab-case slugs.
 
+A discipline sigil — `@<name>` as the first space-token in the invoking prompt, or a trailing `discipline=<name>` line — routes the write to that discipline's store. Without one, the write lands in the default store. Forward the sigil verbatim to `exec:memorize`; never invent or default a discipline name.
+
 To invalidate previously-memorized content (correction or retraction):
 
 ```
@@ -52,6 +66,12 @@ exec:forget
 by-query <2-6 search words>
 ```
 
+**CRITICAL: rs-learn failures must be explicit and recoverable.** If `exec:memorize` fails (socket unavailable, network error, timeout):
+1. Report the failure to the user with error details
+2. Fallback immediately to STEP 3 (AGENTS.md) to preserve the fact in the always-on context buffer
+3. Never proceed as if the write succeeded
+4. This contract ensures memory preservation when the rs-learn retrieval store is temporarily unavailable
+
 ## STEP 3: AGENTS.md
 
 A non-obvious technical caveat qualifies if it required multiple failed runs to discover and would not be apparent from reading code or docs.
@@ -73,7 +93,7 @@ AGENTS.md is the **always-on context buffer** — every prompt sees it. rs-learn
 4. Decide:
    - **Recall accurate AND complete** → the rs-learn store has internalized this fact; **remove it from AGENTS.md**. Frees buffer space and confirms learning.
    - **Recall partial / outdated / missing** → keep the AGENTS.md item AND ingest a refined version of the fact via `exec:memorize` so next round it can pass. Note the outcome in your run log.
-5. Record the audit cycle: how many items checked, how many removed, how many refined. Append this single-line summary to AGENTS.md under a `## Learning audit` section so future audits can see drift over time.
+5. Report the audit cycle in the run output (items checked, removed, refined). Do not write the audit result to AGENTS.md — it is changelog-shaped and AGENTS.md forbids dated audit sections.
 
 Why: AGENTS.md grows monotonically without this loop. rs-learn already filters by relevance per-prompt, so duplicating stable facts in AGENTS.md just inflates the always-on context. The migration drains AGENTS.md into the retrieval store as the store proves it can recall. Failed migrations leave the fact in AGENTS.md (safe default) and improve the store. Success rate over time = a metric for how well gm is learning this project.
 

package/copilot-profile.md

@@ -1,6 +1,6 @@
 ---
 name: gm
-version: 2.0.726
+version: 2.0.1063
 description: State machine agent with hooks, skills, and automated git enforcement
 author: AnEntrypoint
 repository: https://github.com/AnEntrypoint/gm-copilot-cli

package/hooks/hooks.json

@@ -9,11 +9,18 @@
             "type": "command",
             "command": "${COPILOT_EXTENSION_DIR}/bin/plugkit hook pre-tool-use",
             "timeout": 3600
-          },
+          }
+        ]
+      }
+    ],
+    "tool:result": [
+      {
+        "matcher": "*",
+        "hooks": [
           {
             "type": "command",
-            "command": "node ${COPILOT_EXTENSION_DIR}/hooks/pre-tool-use-hook.js",
-            "timeout": 2000
+            "command": "${COPILOT_EXTENSION_DIR}/bin/plugkit hook post-tool-use",
+            "timeout": 5000
           }
         ]
       }
@@ -38,11 +45,6 @@
             "type": "command",
             "command": "${COPILOT_EXTENSION_DIR}/bin/plugkit hook prompt-submit",
             "timeout": 60000
-          },
-          {
-            "type": "command",
-            "command": "node ${COPILOT_EXTENSION_DIR}/hooks/prompt-submit-hook.js",
-            "timeout": 3000
           }
         ]
       }

package/hooks/hooks.spec.json

@@ -0,0 +1,65 @@
+{
+  "schemaVersion": 1,
+  "description": "Hook spec for gm GitHub Copilot CLI extension",
+  "envVar": "COPILOT_EXTENSION_DIR",
+  "plugkitInvoker": "binary",
+  "events": [
+    {
+      "eventKey": "tool:invoke",
+      "commands": [
+        {
+          "kind": "plugkit",
+          "subcommand": "pre-tool-use",
+          "timeout": 3600
+        }
+      ]
+    },
+    {
+      "eventKey": "tool:result",
+      "commands": [
+        {
+          "kind": "plugkit",
+          "subcommand": "post-tool-use",
+          "timeout": 5000
+        }
+      ]
+    },
+    {
+      "eventKey": "session:start",
+      "commands": [
+        {
+          "kind": "plugkit",
+          "subcommand": "session-start",
+          "timeout": 180000
+        }
+      ]
+    },
+    {
+      "eventKey": "prompt:submit",
+      "commands": [
+        {
+          "kind": "plugkit",
+          "subcommand": "prompt-submit",
+          "timeout": 60000
+        }
+      ]
+    },
+    {
+      "eventKey": "session:end",
+      "commands": [
+        {
+          "kind": "plugkit",
+          "subcommand": "stop",
+          "subcommandRename": "session-end",
+          "timeout": 15000
+        },
+        {
+          "kind": "plugkit",
+          "subcommand": "stop-git",
+          "subcommandRename": "session-end-git",
+          "timeout": 210000
+        }
+      ]
+    }
+  ]
+}

package/index.html

@@ -8,7 +8,7 @@
 <meta name="theme-color" content="#181a1f" media="(prefers-color-scheme: dark)">
 <meta name="theme-color" content="#f4f5f7" media="(prefers-color-scheme: light)">
 <script type="module">
-  import { installStyles } from 'https://unpkg.com/anentrypoint-design/dist/247420.js';
+  import { installStyles } from 'https://unpkg.com/anentrypoint-design@latest/dist/247420.js';
   installStyles();
   document.documentElement.classList.add('ds-247420');
 </script>
@@ -19,7 +19,7 @@ body { display: flex; flex-direction: column; min-height: 100vh; }
 .gm-hero h1 { font-size: 36px; font-weight: 600; margin: 0 0 6px 0; color: var(--panel-text); letter-spacing: -0.01em; line-height: 1.15; }
 .gm-hero .lede { font-size: 14px; line-height: 1.55; color: var(--panel-text-2); max-width: 64ch; margin: 0 0 20px 0; }
 .gm-hero .actions { display: flex; gap: 8px; flex-wrap: wrap; }
-.gm-btn { display: inline-flex; align-items: center; gap: 6px; padding: 8px 14px; background: var(--panel-accent); color: var(--panel-1); border-radius: 6px; font-size: 13px; font-weight: 500; text-decoration: none; }
+.gm-btn { display: inline-flex; align-items: center; gap: 6px; padding: 8px 14px; background: var(--panel-accent); color: var(--panel-accent-fg); border-radius: 6px; font-size: 13px; font-weight: 500; text-decoration: none; }
 .gm-btn:hover { background: var(--panel-accent-2); text-decoration: none; }
 .gm-btn.ghost { background: transparent; color: var(--panel-text); box-shadow: inset 0 0 0 1px var(--panel-3); }
 .gm-btn.ghost:hover { background: var(--panel-hover); }
@@ -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.726</span><span>probably emerging</span></div>
+    <div class="panel-head"><span>release · v2.0.1063</span><span>probably emerging</span></div>
     <div class="panel-body">
       <div class="row">
         <span class="code"><span style="color:var(--panel-accent)">●</span></span>
@@ -134,6 +134,8 @@ body { display: flex; flex-direction: column; min-height: 100vh; }
       <a class="panel-row-link" href="https://anentrypoint.github.io/gm-qwen" target="_blank" rel="noopener"><span class="code">011</span><span class="title">qwen code<span class="sub">gm-qwen</span></span><span class="meta">cli · live</span></a>
       <a class="panel-row-link" href="https://anentrypoint.github.io/gm-hermes" target="_blank" rel="noopener"><span class="code">012</span><span class="title">hermes agent<span class="sub">gm-hermes</span></span><span class="meta">cli · live</span></a>
       <a class="panel-row-link" href="https://anentrypoint.github.io/gm-antigravity" target="_blank" rel="noopener"><span class="code">013</span><span class="title">antigravity<span class="sub">gm-antigravity</span></span><span class="meta">ide · live</span></a>
+      <a class="panel-row-link" href="https://anentrypoint.github.io/gm-windsurf" target="_blank" rel="noopener"><span class="code">014</span><span class="title">windsurf<span class="sub">gm-windsurf</span></span><span class="meta">ide · live</span></a>
+      <a class="panel-row-link" href="https://anentrypoint.github.io/gm-thebird" target="_blank" rel="noopener"><span class="code">015</span><span class="title">thebird (browser via freddie + plugkit.wasm)<span class="sub">gm-thebird</span></span><span class="meta">ide · live</span></a>
     </div>
   </div>
 </section>

package/manifest.yml

@@ -1,5 +1,5 @@
 name: gm
-version: 2.0.726
+version: 2.0.1063
 description: State machine agent with hooks, skills, and automated git enforcement
 author: AnEntrypoint
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gm-copilot-cli",
-  "version": "2.0.726",
+  "version": "2.0.1063",
   "description": "State machine agent with hooks, skills, and automated git enforcement",
   "author": "AnEntrypoint",
   "license": "MIT",
@@ -37,4 +37,4 @@
     "index.html",
     "COPILOT.md"
   ]
-}
+}

package/skills/browser/SKILL.md

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

package/skills/code-search/SKILL.md

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

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

@@ -3,48 +3,40 @@ name: create-lang-plugin
 description: Create a lang/ plugin that wires any CLI tool or language runtime into gm-cc — adds exec:<id> dispatch, optional LSP diagnostics, and optional prompt context injection. Zero hook configuration required.
 ---
 
-# CREATE LANG PLUGIN
+# Create lang plugin
 
 Single CommonJS file at `<projectDir>/lang/<id>.js`. Auto-discovered — no hook editing.
 
-## Plugin Shape
+## Plugin shape
 
 ```js
 'use strict';
 module.exports = {
-  id: 'mytool',                         // must match filename
+  id: 'mytool',
   exec: {
     match: /^exec:mytool/,
     run(code, cwd) { /* returns string or Promise<string> */ }
   },
-  lsp: {                                // optional — synchronous only
+  lsp: {
     check(fileContent, cwd) { /* returns Diagnostic[] */ }
   },
-  extensions: ['.ext'],                 // optional — for lsp.check
-  context: `=== mytool ===\n...`       // optional — string or () => string
+  extensions: ['.ext'],
+  context: `=== mytool ===\n...`
 };
 ```
 
 `type Diagnostic = { line: number; col: number; severity: 'error'|'warning'; message: string }`
 
-## How It Works
+`exec.run` runs in a child process, 30s timeout, async OK. Called when Claude writes `exec:mytool\n<code>`. `lsp.check` is synchronous-only, called per prompt-submit. `context` is injected into every prompt, truncated to 2000 chars.
 
-- `exec.run` — child process, 30s timeout, async OK. Called when Claude writes `exec:mytool\n<code>`.
-- `lsp.check` — synchronous, called per prompt submit. Use `spawnSync`/`execFileSync`. No async.
-- `context` — injected into every prompt (truncated 2000 chars).
+## Identify the tool
 
-## Step 1 — Identify Tool
+What is the CLI name or npm package? Does it run a single expression (`tool eval`, `tool -e`, HTTP POST) or a file (`tool run <file>`)? What is its lint/check mode and output format? File extensions? Does it require a running server, or does it run headless?
 
-1. CLI name or npm package?
-2. Run single expression? (`tool eval <expr>`, `tool -e <code>`, HTTP POST...)
-3. Run file? (`tool run <file>`)
-4. Lint/check mode + output format?
-5. File extensions?
-6. Requires running server or headless?
+## exec.run patterns
 
-## Step 2 — exec.run Patterns
+HTTP eval against a running server:
 
-HTTP eval (running server):
 ```js
 function httpPost(port, urlPath, body) {
   return new Promise((resolve, reject) => {
@@ -61,7 +53,8 @@ function httpPost(port, urlPath, body) {
 }
 ```
 
-File-based (headless):
+File-based, headless:
+
 ```js
 function runFile(code, cwd) {
   const tmp = path.join(os.tmpdir(), `plugin_${Date.now()}.ext`);
@@ -71,12 +64,13 @@ function runFile(code, cwd) {
 }
 ```
 
-Single expr detection:
+Single-expression detection:
+
 ```js
 const isSingleExpr = code => !code.trim().includes('\n') && !/\b(func|def|fn |class|import)\b/.test(code);
 ```
 
-## Step 3 — lsp.check
+## lsp.check
 
 ```js
 function check(fileContent, cwd) {
@@ -94,14 +88,15 @@ function check(fileContent, cwd) {
 }
 ```
 
-## Step 4 — context String
+## context
 
 Under 300 chars:
+
 ```js
 context: `=== mytool ===\nexec:mytool\n<expression>\n\nRuns via <how>. Use for <when>.`
 ```
 
-## Step 5 — Write + Verify
+## Verify
 
 ```
 exec:nodejs
@@ -110,6 +105,7 @@ console.log(p.id, typeof p.exec.run, p.exec.match.toString());
 ```
 
 Then test dispatch:
+
 ```
 exec:mytool
 <simple test expression>
@@ -117,9 +113,9 @@ exec:mytool
 
 ## Constraints
 
-- `exec.run` async OK (30s timeout)
+- `exec.run` async OK, 30s timeout
 - `lsp.check` synchronous only — no Promises
 - CommonJS only — no ES module syntax
 - No persistent processes
 - `id` must match filename exactly
-- First match wins — make `match` specific
+- First match wins — keep `match` specific

package/skills/gm/SKILL.md

@@ -1,91 +1,54 @@
 ---
 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
+end-to-end: true
 ---
 
-# GM — Skill-First Orchestrator
+# GM — Orchestrator
 
-Invoke `planning` skill immediately. Skill tool only — never Agent tool for skills.
+Invoke `planning` immediately. Phases cascade: PLAN → EXECUTE → EMIT → VERIFY → UPDATE-DOCS.
 
-## STATE MACHINE
+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.
 
-Top of chain. No mutables resolved. Phases: PLAN → EXECUTE → EMIT → VERIFY → UPDATE-DOCS.
-Each phase loads protocols via Skill invocation only. Reading summary ≠ being in phase.
+**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.
 
-`gm-execute` = execution contract (all phases). `governance` = route/legitimacy reference (load once).
+**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.
 
-## RECALL — HARD RULE
+**Every issue surfaces this turn**: pre-existing breaks, lint failures, drift, broken deps, stale generated files — all become PRD items and finish before COMPLETE.
 
-Before resolving any unknown via fresh execution, check past sessions. Memorized facts only help if recalled.
+**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).
 
-```
-exec:recall
-<2-6 word query>
-```
-
-Triggers: unknown feels familiar | sub-task on a known project | about to ask user something likely already discussed | about to design where prior decision exists. Hits = weak_prior; still witness before adopting. ~200 tokens, ~5ms when serve is running.
-
-## MEMORIZE — HARD RULE
-
-Unknown→known = memorize same turn it resolves. Background, non-blocking.
-
-Triggers: exec: output answers prior unknown | code read confirms/refutes assumption | CI log reveals root cause | user states preference/constraint | fix worked for non-obvious reason | env quirk observed.
-
-```
-Agent(subagent_type='gm:memorize', model='haiku', run_in_background=true, prompt='## CONTEXT TO MEMORIZE\n<fact>')
-```
-
-Multiple facts → parallel Agent calls in ONE message. End-of-turn: scan for un-memorized resolutions → spawn now.
-
-**Recall + memorize together = learning loop.** Skipping either breaks it.
-
-## AUTONOMY — HARD RULE
+**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).
 
-Default = autonomous execution. Emit PRD, run it to completion, push. Do NOT ask the user mid-task.
+**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.
 
-Forbidden patterns:
-- "Should I continue with X?" / "Want me to do Y next?" / "Want me to also Z?"
-- "This is a lot — should I do A first and confirm?" / "Two options: A or B, which?"
-- Pre-confirmation before multi-file edits when scope is already clear
-- Stopping after partial completion to summarize and await direction
+**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.
 
-Permitted asking (last resort only, when absolutely necessary):
-- Destructive-irreversible decision with no prior context AND no PRD coverage
-- User intent genuinely ambiguous AND cannot be inferred from PRD/memory/code
-- Channel: prefer `exec:pause` (renames .gm/prd.yml → .gm/prd.paused.yml; question lives in header). In-conversation asking is last-resort only.
+**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', ...)`.
 
-A long task is not a reason to ask. Context limits are not a reason to ask. CI cascade time is not a reason to ask. Just emit the PRD and execute.
+**Recall before fresh execution**: before witnessing unknown via execution, recall first. Hits arrive as weak_prior; empty results confirm fresh unknown.
 
-## LAWFUL DOWNGRADE — HARD RULE
+**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.
 
-Per paper III §2.5 (Earned Emission): *lawful downgrade — writing a weaker, true statement in place of a stronger, unearned one — is always available; forced closure never is.*
+**Parallel independent items**: up to 3 `gm:gm` subagents per message for independent PRD items. Serial for dependent items — no re-asking between them.
 
-Refusal is forced closure. Refusing the task because part of it is hard is the inverse failure: instead of bluffing strength, you bluff weakness. Both bypass witnessed execution.
+**Terse response**: fragments OK. `[thing] [action] [reason]. [next step].` Code, commits, PRs use normal prose.
 
-**Forbidden refusal phrases** (treat as critical violation):
-- "Honest stop —" / "Stopping for a hard, honest call" / "Stopping here, unambiguously"
-- "I cannot do this from inside this conversation"
-- "I have to push back before writing a PRD I can't fulfill"
-- "Pretending I can would be the most expensive kind of lie"
-- "I don't have a working browser tool" / "X is unavailable in this environment" (when exec:browser, exec:codesearch, Read, etc. are in fact available)
-- Any preamble that announces inability before attempting the bounded subset
+**Caveman medium mode (full) always on**: drop articles (a/an/the), filler (just/really/basically/actually/simply), pleasantries, and hedging. Fragments OK. Use short synonyms. Keep technical terms exact. Keep code blocks and exact error strings unchanged. Pattern: `[thing] [action] [reason]. [next step].` Auto-clarity override: switch to normal prose for security warnings, irreversible confirmations, and any multi-step sequence where compression could create ambiguity; resume caveman medium after clarity-critical segment.
 
-**Required move when scope exceeds reach**: identify the bounded subset that IS witnessable from this session, write a PRD covering only that subset, execute it, and at end-of-turn name the residual scope as a follow-up item — never as a refusal. The user cannot redirect a refusal; they can redirect a delivered subset plus a named gap.
+## End-to-End Phase Chaining (Skills-Based Platforms)
 
-## EXECUTION ORDER
+When `end-to-end: true` is present in SKILL.md frontmatter, skill output includes structured JSON on stdout (final line):
 
-1. Recall — `plugkit recall` for any familiar-feeling unknown (cheapest, 200 tokens)
-2. Code execution (exec:<lang>, exec:codesearch) — 90%+ of unknowns
-3. Web (WebFetch/WebSearch) — env facts not in codebase
-4. User — last resort per AUTONOMY rule above
-
-"Should I..." mid-chain = invoke next skill instead, never ask user.
-
-Skill chain: `planning` → `gm-execute` → `gm-emit` → `gm-complete` → `update-docs`
-
-exec:<lang> only. Never Bash(node/npm/npx/bun). git push = auto CI watch via Stop hook.
+```json
+{"nextSkill": "gm-execute" | "gm-emit" | "gm-complete" | "update-docs" | null, "context": {PRD and state dict}, "phase": "PLAN" | "EXECUTE" | "EMIT" | "COMPLETE"}
+```
 
-## RESPONSE POLICY
+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. Drop filler. Fragments OK. Pattern: `[thing] [action] [reason]. [next step].`
-Code/commits/PRs = normal prose. Security/destructive = drop terseness.
+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.