greprag 5.78.7 → 5.80.0

package/dist/skill-activation-manifest.js

@@ -43,6 +43,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readNativeSkillNames = readNativeSkillNames;
 exports.buildMirroredSkillActivation = buildMirroredSkillActivation;
+exports.nativeAdapterInstallCommand = nativeAdapterInstallCommand;
 exports.activationFromApiRows = activationFromApiRows;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -139,6 +140,21 @@ function buildMirroredSkillActivation(entries, nativeNames) {
     const skills = valid.filter(entry => !nativeNames.has(entry.skillName.toLowerCase()));
     return { count: valid.length, skills, nativeCount: valid.length - skills.length };
 }
+/** The one command that materializes native adapters for the named mirrored
+ *  skills on this harness. claude-code is not swept wholesale (adapters there
+ *  are opt-in per name); codex/opencode sync their whole roster. Null when
+ *  nothing is missing. */
+function nativeAdapterInstallCommand(platform, missingNames) {
+    if (missingNames.length === 0)
+        return null;
+    if (platform === 'claude-code') {
+        return `greprag skill mirror sync claude-code --only ${[...missingNames].sort().join(',')}`;
+    }
+    if (platform === 'codex' || platform === 'opencode') {
+        return `greprag skill mirror sync ${platform}`;
+    }
+    return null;
+}
 /** Convert the mirror API response into a harness-specific activation signal. */
 function activationFromApiRows(params) {
     const entries = params.rows

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "greprag",
-  "version": "5.78.7",
+  "version": "5.80.0",
   "description": "Private GrepRAG client for existing Claude Code, Codex, OpenCode, and Grok Build tenants.",
   "main": "dist/index.js",
   "bin": {

package/skill/templates/chip-spawn.md

@@ -2,21 +2,23 @@
 
 **Grok Build?** Stop. Run `greprag load grok-chip-spawn`. This entry is Claude `spawn_task`.
 
-The `pre-spawn-check` PreToolUse hook **validates** chip prompts at the spawn boundary, but **cannot inject content** — `modifiedInput` is silently dropped by the CCD harness for MCP `spawn_task` calls (see `adr/spawn-task-hook-mode.md` 2026-05-27 entry). The agent writes Block 1 + Block 2 into the prompt itself. Validator rejects with `permissionDecision: deny` and a remediation reason if Block 1 or Block 2 markers are missing.
+The `pre-spawn-check` PreToolUse hook **validates** chip prompts at the spawn boundary, but **cannot inject content** — `modifiedInput` is silently dropped by the CCD harness for MCP `spawn_task` calls (see `adr/spawn-task-hook-mode.md` 2026-05-27 entry). The agent writes Block 1 into the prompt itself. Validator rejects with `permissionDecision: deny` and a remediation reason if the `Chip: ` title prefix or the Block 1 worktree marker is missing.
+
+**Chips talk over native `SendMessage`, not greprag.** Claude Code addresses live sessions by name on this machine — `ListAgents` to discover, `SendMessage to: "<name>"` to send, delivered at the recipient's next tool boundary. The parent gets native start and completion notifications for every chip it spawns. So there is no IN-FLIGHT ping, no `greprag send` report-back, and **no watcher to arm**. greprag's role in the chip loop is now content only (the `fix list` pre-pull below, and `fix spawn` as mission generator).
 
 > **Part of a multi-chip mission?** If this chip is one of ≥2 aimed at a single objective, you should already be inside a chip-leader plan — your **base branch** and **merge target** (the integration branch, *never* master) come from it. If you're not, stop and run `greprag load chip-leader` first. A lone chip targeting its own objective proceeds here directly.
 
 ## What the agent provides
 
 - `title: "Chip: <verb-phrase>"` — `Chip: ` prefix enforced. **Multi-chip mission?** Use the leader-assigned label: `"Chip <Label>: <verb-phrase>"` (Label = `A`/`B`/`C`… per workstream, from chip-leader) — e.g. `"Chip B: Build freshness engine"`. The validator accepts `Chip: `, `Chip A: `, `Chip 1: ` (regex `^Chip( [A-Za-z0-9]+)?: `). The label is the shared handle the leader and chip both use end-to-end (title → report-back self-ID → merge references).
-- `prompt:` — Block 1 + task body + Block 2 (templates below).
+- `prompt:` — Block 1 + task body (template below), ending with the report-back line.
 - `cwd:` — optional, lands the chip in a different project root. Repo paths: `~/.greprag/projects.json`.
 
 Add `mode: interactive` as the first line of the task body to pause the chip for human reply (default is autonomous).
 
-## Block 1 — Setup (verbatim, substitute `<slug>`, `<handle>` + parent session id)
+## Block 1 — Setup (verbatim, substitute `<slug>`)
 
-`<slug>` = title slugified (e.g. `Chip: Fix synthesis loop` → `fix-synthesis-loop`). `<8-hex-parent>` = first 8 hex of YOUR session id (printed by SessionStart as "greprag session id: ..."). `<handle>` = operator's greprag handle. `<own-session-id>` stays literal — the chip substitutes it from its own SessionStart output.
+`<slug>` = title slugified (e.g. `Chip: Fix synthesis loop` → `fix-synthesis-loop`). `<parent-name>` = YOUR native session name, the one `ListAgents` prints as "This session is `<name>`" — that is the chip's reply address, not a greprag 8-hex.
 
 ````
 **Setup — do this FIRST:**
@@ -39,9 +41,6 @@ else
     cd ".claude/worktrees/<slug>"
 fi
 
-greprag send "IN-FLIGHT: chip/<slug> launched — working" \
-  --to <handle>@greprag.com/<8-hex-parent> --from-session <own-session-id>
-
 # Pristine worktrees check out source only — if the repo ships a worktree
 # bootstrap (local dependency bootstrap + gitignored dist/ build), run it now
 # or cross-package tests fail with a cryptic MODULE_NOT_FOUND. No-op in repos
@@ -49,7 +48,7 @@ greprag send "IN-FLIGHT: chip/<slug> launched — working" \
 if [ -f scripts/worktree-bootstrap.cjs ]; then node scripts/worktree-bootstrap.cjs; fi
 ```
 
-Your parent's session id is `<8-hex-parent>`. The `IN-FLIGHT` ping is non-negotiable — without it the parent assumes the chip card was never launched.
+Your parent session is named `<parent-name>`. When you finish, report to it with native `SendMessage` (`to: "<parent-name>"`): the commit hash, the branch `chip/<slug>`, and a one-line result.
 
 ---
 ````
@@ -62,40 +61,26 @@ greprag session retitle <your-own-8hex> "Chip <Label> — <workstream>"
 
 The leader dictates the exact string (e.g. `Chip A — Converter format coverage`); substitute your own 8-hex from SessionStart. This force-sets the registry title so the watcher list + Discord `/switch` line up with the leader's labels. Single chips skip this.
 
-## Block 2 — Report back (verbatim, substitute `<slug>` + parent session id)
+## Report back — native `SendMessage`
 
-Handle is the operator's greprag handle (from `~/.greprag/identity.json`, field `handle` — strip the `@greprag.com` suffix).
+Close the task body with this (substitute `<slug>` + `<parent-name>`):
 
 ````
 ---
 
-**Block 2 — Report back via greprag inbox:**
+**Report back:** when the work is committed, send your result to the parent with native `SendMessage`:
 
-```bash
-greprag send "<status>: <commit hash> on chip/<slug> — <one-line>" \
-  --to <handle>@greprag.com/<8-hex-parent> \
-  --from-session <own-session-id> \
-  --artifact commit:<hash>
-```
+- `to`: `"<parent-name>"`
+- `message`: status, commit hash, branch `chip/<slug>`, and a one-line summary.
 
-Substitute `<own-session-id>` from your SessionStart hook output.
+The parent is a live session on this machine — no greprag address, no watcher. If `SendMessage` errors because the parent has ended, stop and leave the commit on the branch; the parent picks it up at merge.
 
 **Cleanup discipline (HARD RULE):** chip prompts forbid `git clean`, `git reset --hard`, `git worktree remove`, `git checkout <other>`, raw `rm -rf` outside the worktree's tracked files.
 ````
 
-## After spawning — arm YOUR OWN watcher (HARD RULE)
-
-The chip reports back to **your** session id via `greprag send`. Nothing else reliably arms you to receive it: the SessionStart arm-directive and the turn-2 UserPromptSubmit fallback are agent-choice and may not fire, and a report that lands in an unwatched inbox sits silently until someone runs `greprag inbox` by hand. So **immediately after `spawn_task` returns, arm your own watcher** — unless you already have one running this session (one watcher covers every chip you spawn; never double-arm):
-
-Use the **registered** form — copy the exact command the SessionStart / UserPromptSubmit arm hook prints **verbatim**. It already carries `--owner-pid <claude-pid>`, which only the hook can resolve (the hook is a live descendant of claude.exe; your shell is not):
-
-```
-Monitor (persistent:true): `greprag inbox watch --session <your-8hex> --json --owner-pid <pid>`
-```
-
-`<your-8hex>` = your own session id (from SessionStart). **Do NOT hand-fill `--owner-pid` from a shell PID** — the reaper reads `--owner-pid` as "the claude.exe that owns me," so a non-claude PID there reads as a dead owner and the watch is reaped. **Do NOT add `--monitor-pid` / `read … /proc/$$/winpid`** — that form was reverted 2026-06-11 (it stamped the transient arm-line bash, not the Monitor task, and false-killed live watchers); the flag is dead code now. **Do NOT use a bare `while true; greprag inbox watch …` loop** — it never registers in the desk-line, so the arm-probe reports you "NOT armed" and other sessions can't see you as live-reachable. Simplest and correct: **paste the arm hook's printed command verbatim** — its `--owner-pid` is the only one the reaper trusts. (A watch armed with no `--owner-pid` at all is fine too — it is kept, never false-killed — it just isn't owner-pid-reapable if hard-killed.) Arming is what makes the chip's "done" report surface live instead of being lost — the spawn is only half the loop.
+## After spawning — do nothing
 
-**Launch state:** the Block 1 `IN-FLIGHT` ping is your only signal the operator actually clicked the chip card. No ping = assume the card is still unpressed — don't wait on results from a chip that was never launched.
+No watcher. No arming. The harness tells you when the operator starts the chip and again when it ends, and the chip's own `SendMessage` lands at your next tool boundary. Never arm a `Monitor` on greprag's inbox for chip traffic — the inbox watcher exists for Discord, inbound email, and cold opens, not for chips.
 
 ## Before composing