greprag 5.74.21 → 5.75.0

package/dist/commands/arm-reminder.js

@@ -40,7 +40,9 @@ function buildArmReminder(d, env) {
         return null;
     const unread = Number((d.detail && d.detail.unread) || 0);
     const arm = env
-        ? `ToolSearch select:Monitor → persistent Monitor (timeout_ms:3600000) command: \`${(0, session_id_1.armMonitorCommand)(env.short, env.ownerPid, env.assistant, env.mechanic)}\``
+        ? (env.platform === 'grok'
+            ? `Grok \`monitor\` tool persistent:true command: \`${(0, session_id_1.armMonitorCommand)(env.short, env.ownerPid, env.assistant, env.mechanic, 'grok')}\``
+            : `ToolSearch select:Monitor → persistent Monitor (timeout_ms:3600000) command: \`${(0, session_id_1.armMonitorCommand)(env.short, env.ownerPid, env.assistant, env.mechanic)}\``)
         : `arm your Monitor inbox watcher`;
     const grounded = `greprag reads your watcher as DOWN (isLocallyArmed=false — a real pidfile check on your session, NOT a timer; the hook CAN see your watcher)`;
     if (unread > 0) {
@@ -67,7 +69,7 @@ exports.watcherArmModule = {
     // keeps its historical full-registry behavior. opencode is EXCLUDED: its inbox
     // delivery is the plugin-armed relay (startSessionRelay), so "arm your Monitor"
     // is unactionable noise there.
-    harnesses: ['claude-code', 'codex'],
+    harnesses: ['claude-code', 'codex', 'grok'],
     detect: armDetect,
     announce: () => null,
     reminder: (d, env) => buildArmReminder(d, env),

package/dist/commands/codex.js

@@ -62,11 +62,6 @@ Object.defineProperty(exports, "removeCodexStartup", { enumerable: true, get: fu
 Object.defineProperty(exports, "statusCodexStartup", { enumerable: true, get: function () { return codex_startup_2.statusCodexStartup; } });
 const API_URL_DEFAULT = 'https://api.greprag.com';
 const HEARTBEAT_IDLE_MS = 70_000;
-const FULL_UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-function sameSessionId(left, right) {
-    return !!left && !!right && (FULL_UUID_RE.test(left) && FULL_UUID_RE.test(right)
-        ? left.toLowerCase() === right.toLowerCase() : (0, session_id_1.truncateSessionId)(left) === (0, session_id_1.truncateSessionId)(right));
-}
 function home() {
     return process.env.HOME || process.env.USERPROFILE || os.homedir();
 }
@@ -233,12 +228,12 @@ async function handleMessage(msg, opts, session8, codexSession) {
     return result;
 }
 function shouldDeliverToThisSession(msg, sessionId) {
-    if (msg.to_session_id && !sameSessionId(msg.to_session_id, sessionId))
+    if (msg.to_session_id && !(0, session_id_1.sameSessionId)(msg.to_session_id, sessionId))
         return false;
     const fromSession = msg.from?.session_id ?? null;
     if (msg.message_type === mechanic_friction_1.MECHANIC_FRICTION_MESSAGE_TYPE)
         return true;
-    if (fromSession && sameSessionId(fromSession, sessionId))
+    if (fromSession && (0, session_id_1.sameSessionId)(fromSession, sessionId))
         return false;
     return true;
 }

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

@@ -30,7 +30,8 @@ const session_id_1 = require("../session-id");
 function buildInboxPrimer(env) {
     const codex = env.platform === 'codex';
     const opencode = env.platform === 'opencode';
-    const arm = (0, session_id_1.armMonitorCommand)(env.short, env.ownerPid, env.assistant, env.mechanic);
+    const grok = env.platform === 'grok';
+    const arm = (0, session_id_1.armMonitorCommand)(env.short, env.ownerPid, env.assistant, env.mechanic, env.platform);
     return [
         // LEAD — the forcing function (restored 2026-06-22). ARM is an ALARM, not reference:
         // you are unreachable until you do it, and it must be re-done every time the watcher
@@ -39,16 +40,20 @@ function buildInboxPrimer(env) {
         // opencode gets NO alarm: its relay self-arms in the plugin (startSessionRelay) —
         // "ToolSearch select:Monitor" is unactionable there (neither tool exists) and an
         // un-followable alarm decays into banner-blindness for the announces around it.
-        codex
-            ? '[CODEX INBOX — greprag is your agent-to-agent mesh. Codex-to-Codex: discover tasks and their repo/workspace with `codex_app.list_threads`, then coordinate with `codex_app.send_message_to_thread`. Reaching ANY non-Codex peer (Claude Code / opencode / another tenant\'s agent): `greprag send` IS the live primary path — native Codex messaging cannot reach them.]'
-            : opencode
-                ? '[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.]',
-        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
-                ? 'DELIVERY: the relay arms itself on this session\'s first turn and injects inbound messages as they land — treat an injected `Message from <handle> (session <8hex>):` turn as async peer mail, not the operator typing. Drain anything already waiting: `greprag inbox`.'
-                : `ARM: Monitor is a deferred tool — \`ToolSearch select:Monitor\`, then call Monitor with persistent:true, timeout_ms:3600000, description:"greprag inbox ${env.short}", command: \`${arm}\`. The \`--session ${env.short}\` is REQUIRED — a bare \`greprag inbox watch\` writes no pidfile, so the arm-check reads you unarmed forever. NEVER run it bare also because it is a foreground stream and hangs the turn. Then drain what is waiting: \`greprag inbox\`.`,
+        grok
+            ? '[GROK INBOX — greprag is your agent-to-agent mesh. Idle wake is Grok `monitor` (NOT Claude Monitor, NOT a bash while-true). Turn-boundary drain also rides Stop additionalContext. Unarmed, idle mail waits until the next Stop or user prompt.]'
+            : codex
+                ? '[CODEX INBOX — greprag is your agent-to-agent mesh. Codex-to-Codex: discover tasks and their repo/workspace with `codex_app.list_threads`, then coordinate with `codex_app.send_message_to_thread`. Reaching ANY non-Codex peer (Claude Code / opencode / Grok / another tenant\'s agent): `greprag send` IS the live primary path — native Codex messaging cannot reach them.]'
+                : opencode
+                    ? '[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\`.`
+            : 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
+                    ? 'DELIVERY: the relay arms itself on this session\'s first turn and injects inbound messages as they land — treat an injected `Message from <handle> (session <8hex>):` turn as async peer mail, not the operator typing. Drain anything already waiting: `greprag inbox`.'
+                    : `ARM: Monitor is a deferred tool — \`ToolSearch select:Monitor\`, then call Monitor with persistent:true, timeout_ms:3600000, description:"greprag inbox ${env.short}", command: \`${arm}\`. The \`--session ${env.short}\` is REQUIRED — a bare \`greprag inbox watch\` writes no pidfile, so the arm-check reads you unarmed forever. NEVER run it bare also because it is a foreground stream and hangs the turn. Then drain what is waiting: \`greprag inbox\`.`,
         '',
         // The facts + directives — a flat list (no MODEL/RULES scaffolding; the labels were
         // human doc-structure, dead weight to an agent). Everything that helps the agent DECIDE

package/dist/commands/inbox-watch-supervisor.js

@@ -36,6 +36,16 @@ const child_process_1 = require("child_process");
 const inbox_watch_1 = require("./inbox-watch");
 const watcher_registry_1 = require("./watcher-registry");
 const LOG_PREFIX = '[greprag inbox watch]';
+function watchQuiet() {
+    return process.env.GREPRAG_WATCH_QUIET === '1'
+        || !!process.env.GROK_SESSION_ID
+        || process.argv.includes('--quiet');
+}
+function slog(msg) {
+    if (watchQuiet())
+        return;
+    console.error(msg);
+}
 // ---- Supervisor-driven watcher liveness (registry freshness) -------------
 // adr: docs/registry-freshness-design.md
 //
@@ -107,12 +117,12 @@ exports.FATAL_EXIT_CODE = 64;
 function installLastResortHandlers() {
     process.on('uncaughtException', (err) => {
         const msg = (err && err.message) || String(err);
-        console.error(`${LOG_PREFIX} uncaughtException: ${msg}`);
+        slog(`${LOG_PREFIX} uncaughtException: ${msg}`);
         process.exit(2);
     });
     process.on('unhandledRejection', (reason) => {
         const msg = (reason && reason.message) || String(reason);
-        console.error(`${LOG_PREFIX} unhandledRejection: ${msg}`);
+        slog(`${LOG_PREFIX} unhandledRejection: ${msg}`);
         process.exit(2);
     });
 }
@@ -263,7 +273,7 @@ async function runSupervisor() {
     // (`armMonitorCommand`) relaunches a fresh supervisor — turn-free recovery, the
     // missing rung for supervisor death. adr: adr/monitor-resilience.md
     const onFatalError = (label) => (err) => {
-        console.error(`${LOG_PREFIX} supervisor ${label}: ${(err && err.message) || String(err)}`);
+        slog(`${LOG_PREFIX} supervisor ${label}: ${(err && err.message) || String(err)}`);
         process.exit(1); // non-zero (not 0/64) → the relauncher relaunches us
     };
     const onUncaught = onFatalError('uncaughtException');
@@ -289,7 +299,7 @@ async function runSupervisor() {
     // genuinely live sibling. adr: adr/monitor-resilience.md
     if (session && (0, watcher_registry_1.isLocallyArmed)(session)) {
         (0, watcher_registry_1.watcherAuditLog)(`arm-skip session=${session} singleton-guard (live sibling pidfile)`);
-        console.error(`${LOG_PREFIX} session ${session} already has a live watcher — not starting a second.`);
+        slog(`${LOG_PREFIX} session ${session} already has a live watcher — not starting a second.`);
         return;
     }
     // Local pidfile (Part 1 of the local-liveness fix): record THIS supervisor's
@@ -333,7 +343,7 @@ async function runSupervisor() {
         }
         if (spawnErr || !currentChild) {
             const reason = spawnErr ? spawnErr.message : 'spawn returned null child';
-            console.error(`${LOG_PREFIX} supervisor: spawn failed (${reason}) — retry in ${(0, inbox_watch_1.fmtDuration)(backoff)}`);
+            slog(`${LOG_PREFIX} supervisor: spawn failed (${reason}) — retry in ${(0, inbox_watch_1.fmtDuration)(backoff)}`);
             await sleepUntilOrShutdown(backoff, () => shutdownRequested);
             backoff = Math.min(backoff * SUPERVISOR_BACKOFF_FACTOR, SUPERVISOR_BACKOFF_MAX_MS);
             continue;
@@ -402,7 +412,7 @@ async function runSupervisor() {
             const hint = native
                 ? `the child is dying at the OS level (${reason}) before it can run — characteristic of system commit-charge / page-file exhaustion (NOT physical RAM; see docs/session-heap-ceiling.md). Standing down so we stop feeding the exhaustion; the next-turn arm reminder retries once the machine recovers.`
                 : `the child cannot stay up (${reason}). Run \`greprag inbox watch --no-supervise\` to see the underlying error. Standing down to avoid a respawn storm.`;
-            console.error(`${LOG_PREFIX} supervisor: child crash-looped ${consecutiveFastDeaths}× (each < ${(0, inbox_watch_1.fmtDuration)(CRASH_LOOP_LIFETIME_MS)}) — ${hint}`);
+            slog(`${LOG_PREFIX} supervisor: child crash-looped ${consecutiveFastDeaths}× (each < ${(0, inbox_watch_1.fmtDuration)(CRASH_LOOP_LIFETIME_MS)}) — ${hint}`);
             (0, watcher_registry_1.watcherAuditLog)(`crash-loop session=${session ?? 'tenant'} deaths=${consecutiveFastDeaths} last=${reason}`);
             terminalReason = `crash-loop-standdown (${reason})`;
             // Exit FATAL (64) so the bash relauncher BREAKs rather than relaunching us
@@ -411,7 +421,7 @@ async function runSupervisor() {
             process.exitCode = exports.FATAL_EXIT_CODE;
             break;
         }
-        console.error(`${LOG_PREFIX} supervisor: child died (${reason}) after ${(0, inbox_watch_1.fmtDuration)(liveMs)} — respawning in ${(0, inbox_watch_1.fmtDuration)(backoff)}`);
+        slog(`${LOG_PREFIX} supervisor: child died (${reason}) after ${(0, inbox_watch_1.fmtDuration)(liveMs)} — respawning in ${(0, inbox_watch_1.fmtDuration)(backoff)}`);
         await sleepUntilOrShutdown(backoff, () => shutdownRequested);
         backoff = Math.min(backoff * SUPERVISOR_BACKOFF_FACTOR, SUPERVISOR_BACKOFF_MAX_MS);
     }

package/dist/commands/inbox-watch.js

@@ -54,6 +54,7 @@ exports.getConfig = getConfig;
 exports.fmtDuration = fmtDuration;
 exports.parseEventBlock = parseEventBlock;
 exports.withTruncatedSessions = withTruncatedSessions;
+exports.isWatchQuiet = isWatchQuiet;
 exports.runInboxWatch = runInboxWatch;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -166,9 +167,9 @@ function parseEventBlock(block) {
         return null;
     return { event, id, data: dataLines.join('\n') };
 }
-/** Truncate every session_id field on a StreamMessage to its 8-hex form.
- *  Used for both the JSON --json line and the pretty-printed display.
- *  Exported for tests. adr: adr/session-id-awareness.md */
+/** Truncate every session_id field on a StreamMessage to its short form
+ *  (8-hex, or 16-hex for UUIDv7). Used for both the JSON --json line and
+ *  the pretty-printed display. Exported for tests. adr: adr/session-id-awareness.md */
 function withTruncatedSessions(msg) {
     const fromShort = (0, session_id_1.truncateSessionId)(msg.from.session_id ?? null);
     const toShort = (0, session_id_1.truncateSessionId)(msg.to_session_id ?? null);
@@ -347,6 +348,9 @@ async function readStream(url, apiKey, signal, initialId, json, idleTimeoutMs, s
                         catch {
                             continue;
                         }
+                        if (session && msg.to_session_id && !(0, session_id_1.sameSessionId)(session, msg.to_session_id)) {
+                            continue;
+                        }
                         const displayMsg = withTruncatedSessions(msg);
                         emitDmReplyDirective(displayMsg, session);
                         if (json)
@@ -362,14 +366,14 @@ async function readStream(url, apiKey, signal, initialId, json, idleTimeoutMs, s
                             const data = JSON.parse(ev.data || '{}');
                             if (typeof data.count === 'number' && data.count > 0) {
                                 const plural = data.count === 1 ? '' : 's';
-                                console.error(`${LOG_PREFIX} replayed ${data.count} missed row${plural}, resuming live tail`);
+                                watchErr(`${LOG_PREFIX} replayed ${data.count} missed row${plural}, resuming live tail`);
                             }
                         }
                         catch { /* malformed control payload — ignore */ }
                     }
                     else if (ev.event === 'error') {
                         // Surface server-side error then let the loop reconnect.
-                        console.error(`${LOG_PREFIX} server error: ${ev.data}`);
+                        watchErr(`${LOG_PREFIX} server error: ${ev.data}`);
                         return lastId;
                     }
                     // "open" event is informational — ignored at print time.
@@ -423,13 +427,30 @@ function buildUrl(apiUrl, project, session, since, receptionist, assistant, mech
  *  carries its stdout into chat is destroyed on reload, by design). See
  *  adr/monitor-resilience.md (2026-06-02 + 2026-06-03 entries).
  *  adr: adr/monitor-resilience.md */
+function isWatchQuiet(opts) {
+    if (opts?.quiet)
+        return true;
+    if (process.env.GREPRAG_WATCH_QUIET === '1')
+        return true;
+    if (process.env.GROK_SESSION_ID)
+        return true;
+    return process.argv.includes('--quiet');
+}
+function watchErr(msg, opts) {
+    if (isWatchQuiet(opts))
+        return;
+    console.error(msg);
+}
 async function runInboxWatch(opts) {
+    const quiet = isWatchQuiet(opts);
+    if (quiet)
+        process.env.GREPRAG_WATCH_QUIET = '1';
     const directMode = !!opts.signal || !!opts.noSupervise;
     if (directMode)
-        return runWatchLoop(opts);
+        return runWatchLoop({ ...opts, quiet });
     if (process.env[inbox_watch_supervisor_1.SUPERVISE_ENV] === '1') {
         (0, inbox_watch_supervisor_1.installLastResortHandlers)();
-        return runWatchLoop(opts);
+        return runWatchLoop({ ...opts, quiet });
     }
     return (0, inbox_watch_supervisor_1.runSupervisor)();
 }
@@ -446,7 +467,7 @@ async function runInboxWatch(opts) {
  *  the deleted `while true` wrapper's job, done right: the watcher notices its
  *  own consumer is gone instead of an external shell keeping it alive forever.
  *  adr: adr/monitor-resilience.md */
-function bindToConsumer(onGone) {
+function bindToConsumer(onGone, quiet = false) {
     let gone = false;
     const trip = () => {
         if (gone)
@@ -457,26 +478,29 @@ function bindToConsumer(onGone) {
     const onErr = () => trip();
     process.stdout.on('error', onErr);
     process.stderr.on('error', onErr);
-    // A single NUL byte on stderr — the diagnostic channel, never surfaced as a
-    // Monitor notification (those key on stdout JSON lines), and invisible in
-    // logs. The write itself IS the probe: its callback fires with an error (and
-    // the stream emits 'error') when the read end has closed, i.e. the consumer is
-    // gone. Harmless while the pipe is alive.
-    const probe = setInterval(() => {
-        try {
-            process.stderr.write(String.fromCharCode(0), (err) => { if (err)
-                trip(); });
-        }
-        catch {
-            trip();
-        }
-    }, CONSUMER_PROBE_MS);
-    if (typeof probe.unref === 'function')
-        probe.unref();
+    // Claude Monitor keys notifications on stdout JSON; a NUL on stderr is
+    // invisible there. Grok monitor merges stderr into wake events, so the
+    // probe would ping the model every 30s and trip Grok's volume killer.
+    // adr: adr/grok-platform.md
+    let probe = null;
+    if (!quiet) {
+        probe = setInterval(() => {
+            try {
+                process.stderr.write(String.fromCharCode(0), (err) => { if (err)
+                    trip(); });
+            }
+            catch {
+                trip();
+            }
+        }, CONSUMER_PROBE_MS);
+        if (typeof probe.unref === 'function')
+            probe.unref();
+    }
     return {
         gone: () => gone,
         dispose: () => {
-            clearInterval(probe);
+            if (probe)
+                clearInterval(probe);
             process.stdout.removeListener('error', onErr);
             process.stderr.removeListener('error', onErr);
         },
@@ -514,11 +538,11 @@ async function runWatchLoop(opts) {
     // the consuming session is gone — abort and exit terminal so we don't orphan.
     // Skip in SDK/test mode (opts.signal present): those callers own the process
     // and their pipes aren't a Monitor consumer.
-    const consumer = opts.signal ? null : bindToConsumer(() => controller.abort());
+    const consumer = opts.signal ? null : bindToConsumer(() => controller.abort(), isWatchQuiet(opts));
     while (!controller.signal.aborted) {
         if (!isFirstAttempt) {
             const lastSeen = cursor ? cursor.slice(0, 8) : 'none';
-            console.error(`${LOG_PREFIX} reconnecting (last_seen_id=${lastSeen})`);
+            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);
@@ -543,11 +567,11 @@ async function runWatchLoop(opts) {
             // (no supervisor) still sees a non-zero exit.
             const m = /^HTTP (4\d\d)/.exec(msg);
             if (m) {
-                console.error(`${LOG_PREFIX} ${msg}`);
+                watchErr(`${LOG_PREFIX} ${msg}`, opts);
                 process.exit(inbox_watch_supervisor_1.FATAL_EXIT_CODE);
             }
             const lastSeen = cursor ? cursor.slice(0, 8) : 'none';
-            console.error(`${LOG_PREFIX} disconnect: ${msg} — retrying in ${fmtDuration(backoff)} (last_seen_id=${lastSeen})`);
+            watchErr(`${LOG_PREFIX} disconnect: ${msg} — retrying in ${fmtDuration(backoff)} (last_seen_id=${lastSeen})`, opts);
         }
         if (controller.signal.aborted)
             break;

package/dist/commands/init.js

@@ -40,6 +40,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GREPRAG_SECTIONS = void 0;
 exports.runInit = runInit;
+exports.applyGrokHooks = applyGrokHooks;
 exports.applyCodexHooks = applyCodexHooks;
 exports.applySettings = applySettings;
 exports.patchClaudeMdContent = patchClaudeMdContent;
@@ -140,6 +141,13 @@ function detectAgentTargets(cwd = process.cwd()) {
         opencodeEvidence.push('~/.config/opencode exists');
     if (opencodeEvidence.length > 0)
         detections.push({ target: 'opencode', evidence: opencodeEvidence });
+    const grokEvidence = [];
+    if (process.env.GROK_SESSION_ID || process.env.GROK_HOOK_EVENT)
+        grokEvidence.push('GROK_* environment is set');
+    if (home && fs.existsSync(path.join(home, '.grok')))
+        grokEvidence.push('~/.grok exists');
+    if (grokEvidence.length > 0)
+        detections.push({ target: 'grok', evidence: grokEvidence });
     return detections;
 }
 function describeTarget(target) {
@@ -147,6 +155,8 @@ function describeTarget(target) {
         return 'Claude Code';
     if (target === 'codex')
         return 'Codex';
+    if (target === 'grok')
+        return 'Grok Build';
     return 'OpenCode';
 }
 function explicitInitHint() {
@@ -155,6 +165,7 @@ function explicitInitHint() {
         '  greprag init --codex --tenant-id <your-handle>',
         '  greprag init --claude --tenant-id <your-handle>',
         '  greprag init --opencode --tenant-id <your-handle>',
+        '  greprag init --grok --tenant-id <your-handle>',
     ].join('\n');
 }
 function normalizeHandle(raw) {
@@ -220,13 +231,16 @@ async function chooseInitTarget() {
     console.log('    1. Codex');
     console.log('    2. Claude Code');
     console.log('    3. OpenCode');
-    const answer = (await prompt('  Choose 1, 2, or 3: ')).trim().toLowerCase();
+    console.log('    4. Grok Build');
+    const answer = (await prompt('  Choose 1, 2, 3, or 4: ')).trim().toLowerCase();
     if (answer === '1' || answer === 'codex')
         return 'codex';
     if (answer === '2' || answer === 'claude' || answer === 'claude code')
         return 'claude';
     if (answer === '3' || answer === 'opencode' || answer === 'open code')
         return 'opencode';
+    if (answer === '4' || answer === 'grok' || answer === 'grok build')
+        return 'grok';
     console.error('  Error: no agent target selected.');
     console.error(explicitInitHint());
     process.exit(1);
@@ -247,9 +261,9 @@ async function runInit(opts) {
     if (opts.global) {
         return runGlobalInit(opts.name);
     }
-    const explicitTargets = [opts.claude, opts.codex, opts.opencode].filter(Boolean).length;
+    const explicitTargets = [opts.claude, opts.codex, opts.opencode, opts.grok].filter(Boolean).length;
     if (explicitTargets > 1) {
-        console.error('  Error: choose only one target: --claude, --codex, or --opencode.');
+        console.error('  Error: choose only one target: --claude, --codex, --opencode, or --grok.');
         process.exit(1);
     }
     // --opencode: configure for OpenCode instead of Claude Code.
@@ -260,12 +274,17 @@ async function runInit(opts) {
     if (opts.codex) {
         return runCodexInit(opts);
     }
+    if (opts.grok) {
+        return runGrokInit(opts);
+    }
     if (!opts.claude) {
         const target = await chooseInitTarget();
         if (target === 'codex')
             return runCodexInit(opts);
         if (target === 'opencode')
             return runOpenCodeInit(opts);
+        if (target === 'grok')
+            return runGrokInit(opts);
     }
     console.log('\n  greprag init — Setting up agent memory for Claude Code\n');
     // Step 1: Get API key
@@ -640,6 +659,146 @@ async function runCodexInit(opts) {
     console.log('  Inbox messages for Codex surface on SessionStart and UserPromptSubmit hook boundaries.');
     console.log('  Hooks will activate after the Codex host restart; starting only a new task is not sufficient after hook changes.\n');
 }
+const GROK_RULES = `# GrepRAG on Grok Build
+
+Before other work this session:
+1. If \`~/.greprag/grok-context/<16-hex>.md\` exists, Read it. Else run \`greprag memory recap\`.
+2. Session id is \`$GROK_SESSION_ID\` (UUIDv7). Short form is **16 hex**, not 8. 8-hex collides for ~65s. Send with \`--from-session $GROK_SESSION_ID\` (full UUID).
+3. Idle wake: Grok \`monitor\` persistent:true, command:
+   \`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:
+   \`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.
+`;
+function getGrokHooksPath() {
+    const home = process.env.HOME || process.env.USERPROFILE || os.homedir();
+    return path.join(home, '.grok', 'hooks', 'greprag.json');
+}
+function getGrokRulesPath() {
+    const home = process.env.HOME || process.env.USERPROFILE || os.homedir();
+    return path.join(home, '.grok', 'rules', 'greprag.md');
+}
+function grokCommand(sub, timeout) {
+    const script = path.resolve(__dirname, '..', 'hook.js');
+    const command = fs.existsSync(script)
+        ? `node ${shellQuote(script)} ${sub}`
+        : (process.platform === 'win32' ? `greprag-hook.cmd ${sub}` : `greprag-hook ${sub}`);
+    return { type: 'command', command, timeout };
+}
+function applyGrokHooks(config) {
+    const changes = [];
+    if (!config.hooks)
+        config.hooks = {};
+    const add = (event, matcher, sub, timeout, label) => {
+        if (hasGrepragHook(config.hooks[event], sub)) {
+            changes.push(`Grok ${event} ${label} already configured (skipped)`);
+            return;
+        }
+        if (!config.hooks[event])
+            config.hooks[event] = [];
+        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('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', '', 'session-id', 5, 'session-id');
+    return changes;
+}
+function writeGrokRules() {
+    const file = getGrokRulesPath();
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    if (fs.existsSync(file) && fs.readFileSync(file, 'utf-8') === GROK_RULES) {
+        return 'Grok rules already current';
+    }
+    fs.writeFileSync(file, GROK_RULES);
+    return `Wrote ${file}`;
+}
+/** greprag init --grok
+ *  Dedicated Grok Build adapter. Does not ride ~/.claude/settings.json.
+ *  adr: adr/grok-platform.md */
+async function runGrokInit(opts) {
+    console.log('\n  greprag init — Setting up agent memory for Grok Build\n');
+    let apiKey = opts.apiKey || readSharedApiKey();
+    if (!apiKey) {
+        const tenantId = await resolveProvisionHandle(opts);
+        console.log(`  Provisioning API key for public handle ${tenantId}@greprag.com...`);
+        const result = await provision(tenantId);
+        if (!result.ok) {
+            console.error(`  Error: ${result.error}`);
+            process.exit(1);
+        }
+        apiKey = result.apiKey;
+        console.log(`  API key created: ${apiKey.slice(0, 17)}...`);
+    }
+    console.log('  Validating API key...');
+    const valid = await validateKey(apiKey);
+    if (!valid) {
+        console.error('  Error: API key validation failed.');
+        process.exit(1);
+    }
+    console.log('  Key validated against api.greprag.com');
+    const changes = [];
+    writeGrepragEnv(apiKey);
+    changes.push('Wrote ~/.greprag/.env for Grok hooks');
+    await cacheIdentity(apiKey);
+    const anchor = (0, project_anchor_1.ensureAnchor)(process.cwd());
+    if (anchor.source === 'git') {
+        changes.push(`Project anchor: ${anchor.projectName} (${anchor.projectId.slice(0, 8)}) — derived from git history`);
+    }
+    else {
+        changes.push(`Project anchor: ${anchor.projectName} (${anchor.projectId.slice(0, 8)}) — stored in .greprag/project.json`);
+        const gitignoreResult = ensureAnchorTrackable(process.cwd());
+        if (gitignoreResult)
+            changes.push(gitignoreResult);
+    }
+    const globalAnchor = (0, project_anchor_1.ensureGlobalAnchor)();
+    changes.push(`Global anchor: ${globalAnchor.projectName} (${globalAnchor.projectId.slice(0, 8)})`);
+    writeProjectPath(anchor.projectName, process.cwd());
+    changes.push(`Registered repo path for ${anchor.projectName} → ~/.greprag/projects.json`);
+    const grokSkill = installCoreSkill('grok');
+    if (grokSkill)
+        changes.push(`Skill: installed → ${grokSkill}`);
+    changes.push(writeGrokRules());
+    try {
+        const res = await fetch(`${API_URL}/v1/inbox/projects/register`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ project_id: anchor.projectId, project_name: anchor.projectName }),
+        });
+        const reg = await res.json();
+        changes.push(reg.ok ? 'Project registered for inbox addressing' : `Inbox registration: ${reg.error || 'failed'}`);
+    }
+    catch {
+        changes.push('Inbox registration skipped (network)');
+    }
+    const hooksPath = getGrokHooksPath();
+    const hooks = readCodexHooks(hooksPath);
+    const hookChanges = applyGrokHooks(hooks);
+    writeCodexHooks(hooksPath, hooks);
+    changes.push(...hookChanges);
+    console.log('\n  Setup complete!\n');
+    for (const change of changes) {
+        console.log(`    - ${change}`);
+    }
+    console.log(`\n  Grok hooks file: ${hooksPath}`);
+    console.log(`  Grok rules:      ${getGrokRulesPath()}`);
+    console.log(`  Project anchor:  ${anchor.anchorPath}`);
+    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');
+}
 /** greprag init --global
  *  Creates ~/.greprag/project.json with a stable UUID.
  *  Designed for Cowork / any agent session whose cwd has no repo-level anchor.
@@ -979,7 +1138,7 @@ function getSkillRoot() {
     return path.join(__dirname, '../../skill');
 }
 function skillTargetRoot(target) {
-    const dir = target === 'codex' ? '.codex' : '.claude';
+    const dir = target === 'codex' ? '.codex' : target === 'grok' ? '.grok' : '.claude';
     return path.join(os.homedir(), dir, 'skills');
 }
 function installCoreSkill(target) {

package/dist/commands/pipe-wrap.js

@@ -68,6 +68,7 @@ exports.readPipeWrapConfig = readPipeWrapConfig;
 exports.runPipeWrap = runPipeWrap;
 const fs = __importStar(require("fs"));
 const project_anchor_1 = require("../project-anchor");
+const hook_runtime_1 = require("../hook-runtime");
 // ---------- Structural safety gates (pure) ----------------------------------
 /** True when single/double quotes balance with bash-style escaping
  *  (backslash escapes inside double quotes and bare text; not inside
@@ -282,11 +283,11 @@ function readPipeWrapConfig(cwd) {
         enabled = false;
     return { enabled };
 }
-/** PreToolUse[Bash] — returns the updatedInput envelope when the command
- *  qualifies for wrapping, null for silence. NO permissionDecision: the
- *  rewritten command still goes through the normal permission flow. */
+/** PreToolUse[Bash / run_terminal_command] — returns the updatedInput envelope
+ *  when the command qualifies for wrapping, null for silence. NO permissionDecision:
+ *  the rewritten command still goes through the normal permission flow. */
 function runPipeWrap(input) {
-    if (input.tool_name !== 'Bash')
+    if (!(0, hook_runtime_1.isShellTool)(input.tool_name))
         return null;
     const command = input.tool_input?.command;
     if (typeof command !== 'string' || !command.trim())
@@ -317,7 +318,7 @@ function runPipeWrap(input) {
     return {
         hookSpecificOutput: {
             hookEventName: 'PreToolUse',
-            updatedInput: { command: rewriteCommand(target, decision) },
+            updatedInput: { ...(input.tool_input || {}), command: rewriteCommand(target, decision) },
         },
     };
 }

package/dist/commands/search-guard.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.hazardousRgTargets = hazardousRgTargets;
 exports.buildSearchGuardReason = buildSearchGuardReason;
 exports.runSearchGuard = runSearchGuard;
+const hook_runtime_1 = require("../hook-runtime");
 const HAZARDOUS_DIRS = new Set([
     '.next',
     '.turbo',
@@ -151,7 +152,7 @@ function buildSearchGuardReason(targets) {
     ].join(' ');
 }
 function runSearchGuard(input) {
-    if (input.tool_name !== 'Bash')
+    if (!(0, hook_runtime_1.isShellTool)(input.tool_name))
         return null;
     const command = input.tool_input?.command;
     if (typeof command !== 'string' || !command.trim())