greprag 5.75.0 → 5.77.0

package/dist/commands/codex-doctor.js

@@ -113,5 +113,6 @@ async function doctorCodex(args, deps) {
     console.log(`    PermissionRequest ctx:    ${hasHook(hooks, 'PermissionRequest', 'codex-permission-context') ? 'yes' : 'no'}`);
     console.log(`    SubagentStart metadata:   ${hasHook(hooks, 'SubagentStart', 'codex-subagent-start') ? 'yes' : 'no'}`);
     console.log(`    Stop store:               ${hasHook(hooks, 'Stop', 'codex-store') ? 'yes' : 'no'}`);
+    console.log(`    PostCompact re-announce:  ${hasHook(hooks, 'PostCompact', 'recompact') ? 'yes' : 'no'}`);
     console.log(`    PostCompact session-id:   ${hasHook(hooks, 'PostCompact', 'session-id') ? 'yes' : 'no'}`);
 }

package/dist/commands/delivery-reminder.js

@@ -12,15 +12,15 @@ exports.buildDeliveryAnnounce = buildDeliveryAnnounce;
 // adr: adr/delivery-announce-pilot.md
 function coordinationLine(platform) {
     if (platform === 'codex') {
-        return 'Codex: at the merge/deploy gate, call codex_app.list_threads unfiltered, filter to peers in the same repo, then use codex_app.send_message_to_thread once for ready or overlapping work. Delivery owner: rename this task `DEPLOY: <existing title>`; transfer the prefix on handoff; remove the prefix when delivery is done.';
+        return 'Codex: at the merge/deploy gate, call codex_app.list_threads unfiltered, filter to peers in the same repo, and inspect their current summaries/status. Use codex_app.send_message_to_thread only for visible evidence of an unlanded ready commit, overlapping integration, or a concrete blocker. Peers with nothing actionable stay silent; do not solicit or send negative acknowledgements or routine completion follow-ups. Delivery owner: rename this task `DEPLOY: <existing title>` for operator visibility only; transfer the prefix on handoff; remove it before reporting delivery complete or abandoned.';
     }
     if (platform === 'claude-code') {
-        return 'Claude Code: at the merge/deploy gate, discover peers in the same repo and send one concise delivery notice to peers with ready or overlapping work.';
+        return 'Claude Code: at the merge/deploy gate, inspect peers in the same repo and send one concise delivery notice only for visible evidence of an unlanded ready commit, overlapping integration, or a concrete blocker. Peers with nothing actionable stay silent; do not solicit or send negative acknowledgements or routine completion follow-ups.';
     }
     if (platform === 'opencode') {
-        return 'OpenCode: at the merge/deploy gate, use the GrepRAG project/session registry and send one concise delivery notice to peers with ready or overlapping work.';
+        return 'OpenCode: at the merge/deploy gate, use the GrepRAG project/session registry and send one concise notice only for visible evidence of an unlanded ready commit, overlapping integration, or a concrete blocker. Peers with nothing actionable stay silent; do not solicit or send negative acknowledgements or routine completion follow-ups.';
     }
-    return 'At the merge/deploy gate, coordinate once with peers in the same repo who have ready or overlapping work.';
+    return 'At the merge/deploy gate, inspect peers in the same repo and send one concise notice only for visible evidence of an unlanded ready commit, overlapping integration, or a concrete blocker. Peers with nothing actionable stay silent; do not solicit or send negative acknowledgements or routine completion follow-ups.';
 }
 function buildDeliveryAnnounce(env) {
     if (!env.deliveryRepo)
@@ -30,7 +30,7 @@ function buildDeliveryAnnounce(env) {
         `[DELIVERY — ${project}]`,
         'Commit useful, passing work.',
         coordinationLine(env.platform),
-        'Include ready peer commits and clear known blockers, then merge to the default branch and deploy immediately. Missing replies and unfinished peer work do not block delivery.',
+        'Include visible ready peer commits and clear known blockers, then merge to the default branch and deploy immediately. Silence means nothing actionable and does not block delivery.',
         'Use this repo\'s delivery profile and verify production.',
     ].join('\n');
 }

package/dist/commands/grok-spawn.js

@@ -0,0 +1,208 @@
+"use strict";
+/** Open a fresh Grok Build TUI from another agent session.
+ *
+ *  Grok's tool-runner Job Object kills `Start-Process` / `cmd /c start`
+ *  children when the tool call returns. The surviving launch is a scheduled
+ *  task (`schtasks /Create /IT` then `/Run`) that `start`s a new `cmd /k`
+ *  window running grok.exe — a visible command-prompt bootloader outside the
+ *  job. adr: adr/grok-platform.md */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveGrokExe = resolveGrokExe;
+exports.buildGrokSpawnScript = buildGrokSpawnScript;
+exports.grokSpawnHelp = grokSpawnHelp;
+exports.runGrokSpawn = runGrokSpawn;
+exports.runGrok = runGrok;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+function winQuote(value) {
+    return `"${value.replace(/"/g, '""')}"`;
+}
+function resolveGrokExe() {
+    const home = os.homedir();
+    const named = process.platform === 'win32' ? 'grok.exe' : 'grok';
+    const pinned = path.join(home, '.grok', 'bin', named);
+    if (fs.existsSync(pinned))
+        return pinned;
+    try {
+        const out = (0, child_process_1.execFileSync)(process.platform === 'win32' ? 'where.exe' : 'which', ['grok'], {
+            encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        const first = out.split(/\r?\n/).map(s => s.trim()).find(s => s);
+        if (first && fs.existsSync(first))
+            return first;
+    }
+    catch { /* fall through */ }
+    return named;
+}
+function buildGrokSpawnScript(opts) {
+    const cwd = path.resolve(opts.cwd);
+    const title = opts.title || `grok ${path.basename(cwd)}`;
+    const grok = opts.grokExe || resolveGrokExe();
+    const promptArg = opts.prompt ? ` ${winQuote(opts.prompt)}` : '';
+    // Self-relaunch: schtasks runs this hidden; `start cmd /k %~f0 --boot`
+    // opens a visible command-prompt bootloader that then execs grok.exe.
+    // Immediate task-delete used to cancel the launch — caller waits.
+    return [
+        '@echo off',
+        'if /I "%~1"=="--boot" goto boot',
+        `start ${winQuote(title)} cmd /k "%~f0" --boot`,
+        'goto :eof',
+        ':boot',
+        `cd /d ${winQuote(cwd)}`,
+        `echo [greprag] booting Grok TUI in ${cwd}`,
+        `${winQuote(grok)}${promptArg}`,
+        'echo.',
+        'echo [greprag] grok exited. This window is yours.',
+    ].join('\r\n') + '\r\n';
+}
+function grokSpawnHelp() {
+    return `greprag grok spawn — open a fresh Grok Build TUI in a new command prompt.
+
+  greprag grok spawn [--cwd <path>] [--prompt "<text>"|--prompt-file <path>] [--title <name>]
+  greprag grok spawn --dry-run
+
+Windows: schtasks /IT starts a new \`cmd /k\` window (bootloader) that runs
+grok.exe. That escapes the agent tool Job Object. The child is a real TUI
+with its own $GROK_SESSION_ID; it arms its own inbox watch. This session
+keeps one watch. Message it with:
+  greprag send "…" --to <handle>@greprag.com/<child-uuid> --from-session $GROK_SESSION_ID
+`;
+}
+function sleepMs(ms) {
+    const end = Date.now() + ms;
+    while (Date.now() < end) { /* wait for Task Scheduler to start the .cmd */ }
+}
+function runGrokSpawn(args) {
+    if (args.includes('--help') || args.includes('-h') || args[0] === 'help') {
+        console.log(grokSpawnHelp());
+        return;
+    }
+    const cwd = path.resolve(getArg(args, '--cwd') || process.cwd());
+    const promptFile = getArg(args, '--prompt-file');
+    let prompt = getArg(args, '--prompt') || positionalPrompt(args);
+    if (promptFile) {
+        if (!fs.existsSync(promptFile)) {
+            console.error(`greprag grok spawn: prompt file not found: ${promptFile}`);
+            process.exit(1);
+        }
+        prompt = fs.readFileSync(promptFile, 'utf8').replace(/^\uFEFF/, '').trimEnd();
+    }
+    const title = getArg(args, '--title');
+    const dryRun = args.includes('--dry-run');
+    const grokExe = resolveGrokExe();
+    const opts = { cwd, prompt, title, grokExe, dryRun };
+    if (process.platform !== 'win32') {
+        const cmd = [grokExe, '--cwd', cwd, prompt].filter((p) => !!p);
+        if (dryRun) {
+            console.log(cmd.join(' '));
+            return;
+        }
+        console.error('greprag grok spawn: Windows-only bootloader (Job Object). Run this yourself:');
+        console.error(`  ${cmd.map(a => /\s/.test(a) ? JSON.stringify(a) : a).join(' ')}`);
+        process.exitCode = 1;
+        return;
+    }
+    const script = buildGrokSpawnScript(opts);
+    if (dryRun) {
+        process.stdout.write(script);
+        return;
+    }
+    if (!fs.existsSync(cwd) || !fs.statSync(cwd).isDirectory()) {
+        console.error(`greprag grok spawn: cwd is not a directory: ${cwd}`);
+        process.exit(1);
+    }
+    const tn = `greprag-grok-${Date.now().toString(36)}`;
+    const file = path.join(os.tmpdir(), `${tn}.cmd`);
+    fs.writeFileSync(file, script, 'utf8');
+    try {
+        (0, child_process_1.execFileSync)('schtasks', [
+            '/Create', '/TN', tn, '/TR', file, '/SC', 'ONCE', '/ST', '23:59',
+            '/F', '/IT',
+        ], { stdio: ['ignore', 'pipe', 'pipe'] });
+        (0, child_process_1.execFileSync)('schtasks', ['/Run', '/TN', tn], { stdio: ['ignore', 'pipe', 'pipe'] });
+        // /Run is async. Deleting immediately cancelled the launch (field 2026-08-21).
+        sleepMs(2500);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`greprag grok spawn: schtasks failed: ${msg}`);
+        process.exit(1);
+    }
+    finally {
+        try {
+            (0, child_process_1.execFileSync)('schtasks', ['/Delete', '/TN', tn, '/F'], { stdio: 'ignore' });
+        }
+        catch { /* leftover task is harmless */ }
+    }
+    console.log(`Spawned Grok TUI (cmd /k bootloader) for ${cwd}${prompt ? ` — prompt: ${prompt}` : ''}`);
+    console.log('The new session arms its own inbox watch. This session keeps one.');
+}
+function runGrok(args) {
+    const sub = args[0];
+    if (!sub || sub === 'help' || sub === '--help' || sub === '-h') {
+        console.log(grokSpawnHelp());
+        return;
+    }
+    if (sub === 'spawn')
+        return runGrokSpawn(args.slice(1));
+    console.error(`Unknown "grok ${sub}". Run \`greprag grok spawn --help\`.`);
+    process.exit(1);
+}
+function getArg(args, flag) {
+    const idx = args.indexOf(flag);
+    if (idx === -1 || idx + 1 >= args.length)
+        return undefined;
+    const value = args[idx + 1];
+    return value.startsWith('--') ? undefined : value;
+}
+function positionalPrompt(args) {
+    const skip = new Set(['--cwd', '--prompt', '--prompt-file', '--title']);
+    const out = [];
+    for (let i = 0; i < args.length; i++) {
+        if (skip.has(args[i])) {
+            i += 1;
+            continue;
+        }
+        if (args[i] === '--dry-run' || args[i] === '--help' || args[i] === '-h')
+            continue;
+        if (args[i].startsWith('--'))
+            continue;
+        out.push(args[i]);
+    }
+    return out.length ? out.join(' ') : undefined;
+}

package/dist/commands/inbox-drain.js

@@ -9,7 +9,13 @@
  *  inbox`. This closes it: on every arm (SessionStart startup|resume|compact)
  *  drain THIS session's unread, session-DIRECTED messages into the agent's
  *  context, tagged peer/human, mark them read, and advance the stored cursor so
- *  there is no double-delivery. adr: adr/monitor-resilience.md
+ *  there is no double-delivery.
+ *
+ *  INJECT ONLY WHEN UNARMED. A live watcher already printed the body (Claude
+ *  Monitor / Grok monitor stdout). Grok also wires drain on Stop because
+ *  SessionStart stdout cannot inject — that Stop path is the unarmed floor.
+ *  Passing `armed: true` still marks inbound unread + advances the cursor, but
+ *  does not inject (and never claims "no live watcher"). adr: adr/monitor-resilience.md
  *
  *  SCOPE = session-directed INBOUND only (to_session_id == me). NOT the front
  *  desk (cold opens + email — that's the human-scoped `mail` hook's job) and NOT
@@ -126,7 +132,31 @@ async function runInboxDrain(opts) {
         return none;
     // Chronological (oldest → newest) so a coordination thread reads in order.
     inbound.sort((a, b) => tsOf(a) - tsOf(b));
-    // 3. Cap the injected volume to the NEWEST `cap`. Older inbound-unread stay
+    // 3. Armed watcher already delivered the body (live stdout). Mark every
+    //    inbound-unread read and advance the cursor, but do not inject — the
+    //    unarmed copy would lie, and Grok Stop would duplicate a live interrupt.
+    const cursor = newestId(messages);
+    if (opts.armed) {
+        if (cursor) {
+            try {
+                writeCursor(opts.session, cursor);
+            }
+            catch { /* best-effort */ }
+        }
+        const ids = inbound.map(m => m.id).filter(Boolean);
+        if (ids.length > 0) {
+            try {
+                await doFetch(`${base}/v1/inbox/read`, {
+                    method: 'POST',
+                    headers: { Authorization: `Bearer ${opts.apiKey}`, 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ ids }),
+                });
+            }
+            catch { /* mark-read is best-effort */ }
+        }
+        return { context: null, drained: inbound.length, truncated: 0, cursorAdvancedTo: cursor };
+    }
+    // 4. Cap the injected volume to the NEWEST `cap`. Older inbound-unread stay
     //    unread (NOT marked, NOT silently dropped): they remain in `greprag inbox`
     //    and the next arm re-drains them. The overflow count is stated below.
     let drain = inbound;
@@ -135,20 +165,20 @@ async function runInboxDrain(opts) {
         truncated = inbound.length - cap;
         drain = inbound.slice(inbound.length - cap); // newest `cap`, still chronological
     }
-    // 4. Build the injected context (peer/human tagged).
+    // 5. Build the injected context (peer/human tagged). Unarmed-only — this copy
+    //    is true because we returned above when a live watcher was present.
     const context = buildDrainContext(drain, truncated, opts.session);
-    // 5. Advance the poll cursor to the newest endpoint message id so the just-
+    // 6. Advance the poll cursor to the newest endpoint message id so the just-
     //    armed poll resumes strictly AFTER everything already in the inbox — no
     //    double-delivery. Only when there is something to drain (never disturb a
     //    healthy poll's cursor on an empty arm).
-    const cursor = newestId(messages);
     if (cursor) {
         try {
             writeCursor(opts.session, cursor);
         }
         catch { /* best-effort */ }
     }
-    // 6. Mark the drained (injected) ids read LAST — after inject + cursor — so a
+    // 7. Mark the drained (injected) ids read LAST — after inject + cursor — so a
     //    crash before this point re-drains next arm rather than losing a message.
     //    Inbound ids only, so a peer's view of my outbound is never touched.
     //    Fail-quiet: an unreachable / not-yet-deployed /read route leaves the

package/dist/commands/inbox-primer-reminder.js

@@ -48,7 +48,7 @@ function buildInboxPrimer(env) {
                     ? '[OPENCODE INBOX — greprag is your agent-to-agent mesh. Inbound delivery is AUTOMATIC here: the greprag plugin arms a relay for this session (nothing to arm or re-arm) and inbound peer messages arrive as injected turns.]'
                     : '[⚠ ARM YOUR INBOX WATCHER NOW — you are UNREACHABLE until you do. Peers are live in your mesh trying to coordinate with this session, and the operator can DM you — but they reach you ONLY while armed. Unarmed, you are invisible and their messages silently pile up. The watcher can DROP ANYTIME (crash / reload / OOM) — EVERY turn you are flagged unarmed you MUST re-arm, or coordination breaks.]',
         grok
-            ? `ARM (idle wake): Grok \`monitor\` tool, persistent:true, description:"greprag inbox ${env.short}", command: \`${arm}\`. \`--quiet\` is REQUIRED — Grok treats stderr as wake events; the Claude bash wrapper is PowerShell-invalid. Use full UUID / 16-hex, never 8-hex. Second session: spawn_subagent (child arms its own watch; parent keeps ONE). Floor: Stop-hook drain injects unread mail even if you never arm. Then \`greprag inbox\`.`
+            ? `ARM (idle wake): Grok \`monitor\` tool, persistent:true, description:"greprag inbox ${env.short}", command: \`${arm}\`. \`--quiet\` is REQUIRED — Grok treats stderr as wake events; the Claude bash wrapper is PowerShell-invalid. Use full UUID / 16-hex, never 8-hex. A chip → \`greprag load grok-chip-spawn\` then \`greprag grok spawn\` (child arms its own watch; parent keeps ONE). A helper → spawn_subagent. Floor: Stop-hook drain injects unread mail even if you never arm. Then \`greprag inbox\`.`
             : codex
                 ? 'CODEX: Native Codex tools are the source of truth: `codex_app.list_threads` discovers tasks plus their repo/workspace, and `codex_app.send_message_to_thread` handles Codex-to-Codex coordination. GrepRAG inbox rows for Codex surface through turn hooks only: SessionStart `drain` and UserPromptSubmit `codex-notify`. There is no Codex startup watcher to install. If hooks do not fire, open Codex Desktop Settings -> Settings -> Hooks, trust the GrepRAG commands, start a fresh Codex session, then drain what is waiting: `greprag inbox`.'
                 : opencode

package/dist/commands/inbox-watch.js

@@ -50,6 +50,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CONSUMER_GONE_EXIT_CODE = void 0;
+exports.resolveWatchPlatform = resolveWatchPlatform;
 exports.getConfig = getConfig;
 exports.fmtDuration = fmtDuration;
 exports.parseEventBlock = parseEventBlock;
@@ -59,6 +60,7 @@ exports.runInboxWatch = runInboxWatch;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const session_id_1 = require("../session-id");
+const harness_1 = require("../harness");
 const mechanic_friction_1 = require("../mechanic-friction");
 const inbox_watch_supervisor_1 = require("./inbox-watch-supervisor");
 const API_URL_DEFAULT = 'https://api.greprag.com';
@@ -84,6 +86,14 @@ exports.CONSUMER_GONE_EXIT_CODE = 65;
 // than waiting for the next real message that may never come. Env-overridable
 // for tests (the idle path otherwise takes the full 30s to observe).
 const CONSUMER_PROBE_MS = Number(process.env.GREPRAG_WATCH_PROBE_MS) || 30_000;
+const WATCH_PLATFORMS = new Set(['claude-code', 'codex', 'opencode', 'grok']);
+/** Platform tag for this watch attach. Explicit opt wins; else infer. */
+function resolveWatchPlatform(explicit) {
+    if (explicit && WATCH_PLATFORMS.has(explicit))
+        return explicit;
+    const h = (0, harness_1.inferCurrentHarness)();
+    return (h && WATCH_PLATFORMS.has(h)) ? h : undefined;
+}
 // -- Config (mirrors the loader in index.ts/discover.ts) -------------------
 function loadEnvFile(filePath) {
     try {
@@ -392,7 +402,7 @@ async function readStream(url, apiKey, signal, initialId, json, idleTimeoutMs, s
         signal.removeEventListener('abort', onOuterAbort);
     }
 }
-function buildUrl(apiUrl, project, session, since, receptionist, assistant, mechanic) {
+function buildUrl(apiUrl, project, session, since, receptionist, assistant, mechanic, platform) {
     const u = new URL(apiUrl.replace(/\/+$/, '') + '/v1/inbox/stream');
     if (project)
         u.searchParams.set('project', project);
@@ -406,6 +416,8 @@ function buildUrl(apiUrl, project, session, since, receptionist, assistant, mech
         u.searchParams.set('role', 'mechanic');
     else if (assistant)
         u.searchParams.set('role', 'assistant');
+    if (platform)
+        u.searchParams.set('platform', platform);
     return u.toString();
 }
 /** Public entry for `greprag inbox watch`. Dispatches by mode:
@@ -545,7 +557,7 @@ async function runWatchLoop(opts) {
             watchErr(`${LOG_PREFIX} reconnecting (last_seen_id=${lastSeen})`, opts);
         }
         isFirstAttempt = false;
-        const url = buildUrl(cfg.apiUrl, opts.project, opts.session, cursor, !!opts.receptionist, !!opts.assistant, !!opts.mechanic);
+        const url = buildUrl(cfg.apiUrl, opts.project, opts.session, cursor, !!opts.receptionist, !!opts.assistant, !!opts.mechanic, resolveWatchPlatform(opts.platform));
         try {
             const lastId = await readStream(url, cfg.apiKey, controller.signal, cursor, !!opts.json, idleTimeoutMs, opts.session);
             if (lastId)

package/dist/commands/init.js

@@ -668,9 +668,10 @@ Before other work this session:
    \`greprag inbox watch --session $GROK_SESSION_ID --json --quiet\`
    Not Claude Monitor. No bash while-true. \`--quiet\` required (stderr is a wake).
    If a greprag inbox monitor is already listed in this session, do not start another. Instant exit = already armed, not a crash.
-4. Second session: \`spawn_subagent\` background=true. Child arms its own quiet watch with ITS \`$GROK_SESSION_ID\`. Parent sends:
+4. Chip: \`greprag load grok-chip-spawn\` then \`greprag grok spawn\` (real TUI + inbox). Helper: \`spawn_subagent\` background=true. Child arms its own quiet watch with ITS \`$GROK_SESSION_ID\`. Parent sends:
    \`greprag send "…" --to travis@greprag.com/<child-full-uuid> --from-session $GROK_SESSION_ID\`
    Parent keeps ONE watch, for itself. Child watch events may appear on the parent TUI — resume the child to act. Do not arm a second parent watch.
+5. Tool shell: stdin redirected + \`-NonInteractive\`. \`Read-Host\` throws. \`Start-Process\` windows die with the tool Job Object. Secret paste: \`~/.claude/scripts/prompt-secret.ps1\`. Sticky console: \`schtasks /Create … /IT\` then \`schtasks /Run\`. npm Hello: \`npm login --auth-type=web\` in that window; browser Use security key; page token ≠ Hello PIN.
 `;
 function getGrokHooksPath() {
     const home = process.env.HOME || process.env.USERPROFILE || os.homedir();
@@ -691,6 +692,15 @@ function applyGrokHooks(config) {
     const changes = [];
     if (!config.hooks)
         config.hooks = {};
+    // Empty matcher = every SessionStart source (startup, resume, /new, dashboard
+    // dispatch, fork). `startup|resume` missed /new and dashboard agents, so this
+    // session never got a recap sidecar. adr: adr/grok-platform.md
+    const sessionStartMatcher = '';
+    if (!config.hooks.SessionStart)
+        config.hooks.SessionStart = [];
+    const retargeted = ['recap', 'session-id', 'drain'].reduce((n, sub) => (n + retargetGrepragHookMatcher(config.hooks.SessionStart, sub, ['startup|resume'], sessionStartMatcher)), 0);
+    if (retargeted)
+        changes.push(`Retargeted Grok SessionStart matcher (${retargeted})`);
     const add = (event, matcher, sub, timeout, label) => {
         if (hasGrepragHook(config.hooks[event], sub)) {
             changes.push(`Grok ${event} ${label} already configured (skipped)`);
@@ -701,14 +711,15 @@ function applyGrokHooks(config) {
         config.hooks[event].push({ matcher, hooks: [grokCommand(sub, timeout)] });
         changes.push(`Added Grok ${event} hook (${label})`);
     };
-    add('SessionStart', 'startup|resume', 'recap', 15, 'memory recap');
-    add('SessionStart', 'startup|resume', 'session-id', 5, 'session-id');
-    add('SessionStart', 'startup|resume', 'drain', 8, 'inbox drain');
+    add('SessionStart', sessionStartMatcher, 'recap', 15, 'memory recap');
+    add('SessionStart', sessionStartMatcher, 'session-id', 5, 'session-id');
+    add('SessionStart', sessionStartMatcher, 'drain', 8, 'inbox drain');
     add('UserPromptSubmit', '', 'notify', 8, 'prompt cache');
     add('PreToolUse', 'Bash|run_terminal_command', 'crush-wrap', 5, 'crush-wrap');
     add('PreToolUse', '*', 'guard', 5, 'guard');
     add('Stop', '', 'store', 15, 'turn capture');
     add('Stop', '', 'drain', 8, 'inbox drain');
+    add('PostCompact', '', 'recompact', 15, 'Interrupt re-announce');
     add('PostCompact', '', 'session-id', 5, 'session-id');
     return changes;
 }
@@ -797,7 +808,7 @@ async function runGrokInit(opts) {
     console.log('  Reload hooks in Grok (/hooks then r) or start a fresh session.');
     console.log('  Recap lands in ~/.greprag/grok-context/<16-hex>.md — Grok ignores SessionStart stdout.');
     console.log('  Idle inbox: Grok monitor + `greprag inbox watch --session $GROK_SESSION_ID --json --quiet`.');
-    console.log('  Second session: spawn_subagent; child arms its own watch; parent keeps one.\n');
+    console.log('  Second session: `greprag grok spawn` (TUI) or spawn_subagent; child arms its own watch; parent keeps one.\n');
 }
 /** greprag init --global
  *  Creates ~/.greprag/project.json with a stable UUID.
@@ -1401,14 +1412,27 @@ function applyCodexHooks(config) {
     else {
         changes.push('Codex Stop hook already configured (skipped)');
     }
-    const postCompactHook = {
+    const postCompactAnnounceHook = {
+        matcher: 'manual|auto',
+        hooks: [commandHook('recompact', 10, 'Re-announcing GrepRAG primers')],
+    };
+    if (!hasGrepragHookWithMatcher(config.hooks.PostCompact, 'recompact', postCompactAnnounceHook.matcher)) {
+        if (!config.hooks.PostCompact)
+            config.hooks.PostCompact = [];
+        config.hooks.PostCompact.push(postCompactAnnounceHook);
+        changes.push('Added Codex PostCompact hook (Interrupt re-announce)');
+    }
+    else {
+        changes.push('Codex PostCompact Interrupt re-announce hook already configured (skipped)');
+    }
+    const postCompactSessionHook = {
         matcher: 'manual|auto',
         hooks: [commandHook('session-id', 3, 'Restoring GrepRAG session id')],
     };
-    if (!hasGrepragHookWithMatcher(config.hooks.PostCompact, 'session-id', postCompactHook.matcher)) {
+    if (!hasGrepragHookWithMatcher(config.hooks.PostCompact, 'session-id', postCompactSessionHook.matcher)) {
         if (!config.hooks.PostCompact)
             config.hooks.PostCompact = [];
-        config.hooks.PostCompact.push(postCompactHook);
+        config.hooks.PostCompact.push(postCompactSessionHook);
         changes.push('Added Codex PostCompact hook (session-id awareness)');
     }
     else {
@@ -1422,6 +1446,7 @@ function normalizeCodexHookCommands(hooks) {
     const desired = {
         recap: { timeout: 10, statusMessage: 'Loading GrepRAG memory' },
         'codex-recap': { timeout: 10, statusMessage: 'Loading GrepRAG memory' },
+        recompact: { timeout: 10, statusMessage: 'Re-announcing GrepRAG primers' },
         'session-id': { timeout: 3, statusMessage: 'Loading GrepRAG session id' },
         drain: { timeout: 5, statusMessage: 'Draining GrepRAG inbox' },
         'codex-notify': { timeout: 300, statusMessage: 'Checking GrepRAG inbox', runner: 'greprag-codex-hook' },

package/dist/commands/load-primer-reminder.js

@@ -19,7 +19,7 @@
  *  load-primer` / `chip-spawn-pointer`). Announce-only: detect → silent,
  *  reminder → null. adr: docs/load-system.md, docs/reminder-interrupt.md */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.codexChipSpawnPointerModule = exports.chipSpawnPointerModule = exports.loadPrimerModule = exports.CODEX_CHIP_SPAWN_POINTER = exports.OPENCODE_CHIP_SPAWN_POINTER = exports.CHIP_SPAWN_POINTER = exports.LOAD_PRIMER = void 0;
+exports.codexChipSpawnPointerModule = exports.chipSpawnPointerModule = exports.loadPrimerModule = exports.CODEX_CHIP_SPAWN_POINTER = exports.GROK_CHIP_SPAWN_POINTER = exports.OPENCODE_CHIP_SPAWN_POINTER = exports.CHIP_SPAWN_POINTER = exports.LOAD_PRIMER = void 0;
 /** PRIMER — teaches the loader itself. Resident (fires every SessionStart +
  *  re-teaches after compaction). Terse: it is in context every session. */
 exports.LOAD_PRIMER = [
@@ -43,6 +43,11 @@ exports.OPENCODE_CHIP_SPAWN_POINTER = [
     '[greprag chips — agent coordination is built in (messaging plumbing in the inbox primer).]',
     '• Delegating a component of a plan to an isolated chip session, or `greprag fix spawn` just printed a FIX-chip mission? → run `greprag load chip-bootloader` FIRST for the method: OpenCode chips spawn natively via `greprag opencode chip goal create` + `greprag opencode chip spawn` (HTTP child session; manual paste only when the API is down). ≥2 chips at one objective → `greprag load chip-leader-opencode` BEFORE the first spawn.',
 ].join('\n');
+/** POINTER — Grok Build TUI chip. Real window + inbox mesh, not spawn_subagent. */
+exports.GROK_CHIP_SPAWN_POINTER = [
+    '[greprag chips — agent coordination is built in (messaging plumbing in the inbox primer).]',
+    '• About to spawn a chip? → run `greprag load grok-chip-spawn` FIRST. Vehicle is `greprag grok spawn` (cmd /k TUI bootloader). Child arms its own quiet inbox watch; parent keeps one and talks via `greprag send`. `spawn_subagent` is a helper, not a chip. ≥2 chips at one objective → `greprag load chip-leader` BEFORE the first spawn.',
+].join('\n');
 /** POINTER — Codex Desktop's native chip path. This is intentionally distinct
  *  from Claude Code spawn_task: different lifecycle, runtime, and handoff. */
 exports.CODEX_CHIP_SPAWN_POINTER = [
@@ -70,6 +75,8 @@ exports.chipSpawnPointerModule = {
             return null;
         if (env.platform === 'opencode')
             return exports.OPENCODE_CHIP_SPAWN_POINTER;
+        if (env.platform === 'grok')
+            return exports.GROK_CHIP_SPAWN_POINTER;
         return exports.CHIP_SPAWN_POINTER;
     },
     reminder: () => null,

package/dist/commands/load.js

@@ -73,6 +73,10 @@ const LIBRARY = {
         files: ['skill/templates/codex-chip-spawn.md'],
         purpose: 'Spawn an independent writable native Codex Desktop task with an isolated worktree and native completion/cleanup.',
     },
+    'grok-chip-spawn': {
+        files: ['skill/templates/grok-chip-spawn.md'],
+        purpose: 'Spawn a Grok TUI chip (cmd /k bootloader + isolated worktree). Child arms its own inbox watch; parent talks via greprag send. Not spawn_subagent.',
+    },
     'skill-change': {
         files: ['skill/templates/skill-change.md'],
         purpose: 'Internal bundled schema for safely updating a skill after a run: when to edit, Convention A/B shapes, and when to propose instead.',

package/dist/commands/opencode-interrupt.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.OPENCODE_QUOTA_WAITLIST_ANNOUNCE = exports.opencodeRegistry = void 0;
 exports.buildOpenCodeEnv = buildOpenCodeEnv;
 exports.getOpenCodeAnnounces = getOpenCodeAnnounces;
+exports.getOpenCodePersistentAnnounces = getOpenCodePersistentAnnounces;
 exports.getOpenCodeReminders = getOpenCodeReminders;
 const reminder_registry_1 = require("./reminder-registry");
 /** The opencode registry is DERIVED from the canon, never hand-whitelisted.
@@ -44,11 +45,18 @@ function buildOpenCodeEnv(params) {
         updateAvailable: params.updateAvailable ?? null,
         procedureAnnounces: params.procedureAnnounces ?? [],
         mirroredSkills: params.mirroredSkills,
+        personaAnnounce: params.personaAnnounce ?? null,
     };
 }
 function getOpenCodeAnnounces(env) {
     return [...(0, reminder_registry_1.collectAnnounces)(env, exports.opencodeRegistry), exports.OPENCODE_QUOTA_WAITLIST_ANNOUNCE];
 }
+/** OpenCode rebuilds output.system for every model call. Persona is the one
+ *  startup primer that must remain behaviorally active on later calls, so the
+ *  plugin replays this shared-registry module from its bounded session cache. */
+function getOpenCodePersistentAnnounces(env) {
+    return (0, reminder_registry_1.collectAnnounces)(env, exports.opencodeRegistry.filter((m) => m.id === 'persona-announce'));
+}
 function getOpenCodeReminders(env) {
     return (0, reminder_registry_1.collectReminders)(env, exports.opencodeRegistry);
 }

package/dist/commands/os-primer-reminder.js

@@ -20,7 +20,8 @@ function buildOsPrimer(env) {
     // vehicle is the chip-bootloader entry: native `greprag opencode chip` spawn).
     const spawnEntry = env?.platform === 'codex' ? 'codex-chip-spawn'
         : env?.platform === 'opencode' ? 'chip-bootloader'
-            : 'chip-spawn';
+            : env?.platform === 'grok' ? 'grok-chip-spawn'
+                : 'chip-spawn';
     return [
         '[grepragOS — the operating laws. Full doctrine: `greprag load os`.]',
         '• Doctrine vs state: methods ship in the CLI (`greprag load`); live state lives in the repo. A skill that depends on repo state carries a "STATE — read these first" block naming exact paths.',

package/dist/commands/persona-reminder.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.personaAnnounceModule = void 0;
+exports.personaAnnounceModule = {
+    id: 'persona-announce',
+    detect: () => ({ tier: 'silent' }),
+    announce: (env) => env.personaAnnounce || null,
+    reminder: () => null,
+};