greprag 5.74.21 → 5.76.0

package/dist/commands/watcher-registry.js

@@ -79,13 +79,14 @@ exports.gcDeadSessions = gcDeadSessions;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
+const session_id_1 = require("../session-id");
 const WATCHER_DIRNAME = 'watchers';
 // Matches a greprag watcher's command line in every launch shape (npm shim, bash
 // relauncher, the supervisor's CreateProcess re-invocation). Anchored on the
 // INVOKED BINARY (`greprag` or `index.js`) immediately followed by `inbox watch`
 // — never a bare `inbox watch` substring. Retained for the owner-pid resolver's
 // claude.exe match; the cleanup path no longer scans the process table at all.
-const CLAUDE_PROC_RE = /^claude(\.exe)?$/i;
+const CLAUDE_PROC_RE = /^(claude|grok)(\.exe)?$/i;
 /** Default per-session watcher floor: keep this many freshest live watchers, reap
  *  only the surplus above it, never below it. K=2 = the live one + one margin. */
 exports.DEFAULT_WATCHER_CAP = 2;
@@ -97,9 +98,26 @@ function watchersDir() {
     const h = grepragHome();
     return h ? path.join(h, WATCHER_DIRNAME) : null;
 }
-function pidfilePath(short) {
-    const dir = watchersDir();
-    return dir ? path.join(dir, `${short}.json`) : null;
+function sessionKey(short) {
+    return (0, session_id_1.truncateSessionId)(short) || short;
+}
+/** Pidfile names that belong to the same session: canonical short (16-hex
+ *  for UUIDv7, 8-hex otherwise) plus the raw/--session string. A Grok watch
+ *  armed with `$GROK_SESSION_ID` (dashed UUID) used to write
+ *  `<full-uuid>.json` while Stop's isLocallyArmed looked at `<16-hex>.json`
+ *  → perpetual UNARMED nag + singleton-guard bounce. */
+function matchingPidfileNames(short) {
+    const want = sessionKey(short);
+    const names = new Set();
+    if (want)
+        names.add(want);
+    if (short)
+        names.add(short);
+    for (const name of allShorts()) {
+        if (name === short || sessionKey(name) === want)
+            names.add(name);
+    }
+    return [...names];
 }
 /** True iff `pid` is a live process. `process.kill(pid, 0)` sends no signal — it
  *  only probes existence. EPERM = exists but another user (alive); ESRCH = gone. */
@@ -114,20 +132,32 @@ function pidAlive(pid) {
         return e?.code === 'EPERM';
     }
 }
-/** Read a session's entry LIST. Back-compat: a legacy single-object pidfile reads
- *  as a 1-element list. */
+/** Read a session's entry LIST. Merges alias pidfiles (dashed UUID, 16-hex,
+ *  raw --session). Back-compat: a legacy single-object pidfile reads as a
+ *  1-element list. */
 function readWatcherEntries(short) {
-    try {
-        const p = pidfilePath(short);
-        if (!p)
-            return [];
-        const parsed = JSON.parse(fs.readFileSync(p, 'utf-8'));
-        const arr = Array.isArray(parsed) ? parsed : [parsed];
-        return arr.filter((r) => !!r && typeof r.pid === 'number');
-    }
-    catch {
+    const dir = watchersDir();
+    if (!dir)
         return [];
+    const seen = new Set();
+    const out = [];
+    for (const name of matchingPidfileNames(short)) {
+        try {
+            const parsed = JSON.parse(fs.readFileSync(path.join(dir, `${name}.json`), 'utf-8'));
+            const arr = Array.isArray(parsed) ? parsed : [parsed];
+            for (const r of arr) {
+                if (!r || typeof r.pid !== 'number')
+                    continue;
+                const rec = r;
+                if (seen.has(rec.pid))
+                    continue;
+                seen.add(rec.pid);
+                out.push(rec);
+            }
+        }
+        catch { /* missing alias is fine */ }
     }
+    return out;
 }
 function writeWatcherEntries(short, entries) {
     try {
@@ -135,12 +165,21 @@ function writeWatcherEntries(short, entries) {
         if (!dir)
             return;
         fs.mkdirSync(dir, { recursive: true });
-        const p = path.join(dir, `${short}.json`);
+        const key = sessionKey(short);
+        const canonical = path.join(dir, `${key}.json`);
+        for (const name of matchingPidfileNames(short)) {
+            if (name === key)
+                continue;
+            try {
+                fs.rmSync(path.join(dir, `${name}.json`), { force: true });
+            }
+            catch { /* best-effort */ }
+        }
         if (entries.length === 0) {
-            fs.rmSync(p, { force: true });
+            fs.rmSync(canonical, { force: true });
             return;
         }
-        fs.writeFileSync(p, JSON.stringify(entries));
+        fs.writeFileSync(canonical, JSON.stringify(entries));
     }
     catch { /* best-effort — a failed write only means re-arm, never a crash */ }
 }
@@ -155,12 +194,18 @@ function writeWatcherPidfile(short, pid, ownerPid) {
 function removeWatcherEntry(short, pid) {
     writeWatcherEntries(short, readWatcherEntries(short).filter(r => r.pid !== pid));
 }
-/** Remove a session's whole pidfile (legacy / full sweep). */
+/** Remove a session's whole pidfile (legacy / full sweep), including aliases. */
 function removeWatcherPidfile(short) {
     try {
-        const p = pidfilePath(short);
-        if (p)
-            fs.rmSync(p, { force: true });
+        const dir = watchersDir();
+        if (!dir)
+            return;
+        for (const name of matchingPidfileNames(short)) {
+            try {
+                fs.rmSync(path.join(dir, `${name}.json`), { force: true });
+            }
+            catch { /* best-effort */ }
+        }
     }
     catch { /* best-effort */ }
 }

package/dist/grok-session.js

@@ -0,0 +1,125 @@
+"use strict";
+/** Grok Build session files + the recap sidecar SessionStart can write
+ *  (Grok ignores SessionStart stdout, so the always-on rule points here).
+ *  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.grokSessionDir = grokSessionDir;
+exports.readLatestGrokUserPrompt = readLatestGrokUserPrompt;
+exports.grokSidecarPath = grokSidecarPath;
+exports.writeGrokSidecar = writeGrokSidecar;
+exports.appendGrokSidecar = appendGrokSidecar;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+function grokHome() {
+    if (process.env.GROK_HOME)
+        return process.env.GROK_HOME;
+    return path.join(os.homedir(), '.grok');
+}
+function grokSessionDir(cwd, sessionId) {
+    const encoded = encodeURIComponent(path.resolve(cwd));
+    return path.join(grokHome(), 'sessions', encoded, sessionId);
+}
+function extractText(content) {
+    if (typeof content === 'string')
+        return content.trim();
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .filter((b) => b?.type === 'text' && typeof b.text === 'string')
+        .map((b) => String(b.text))
+        .join('\n')
+        .trim();
+}
+function unwrapUserQuery(text) {
+    const m = text.match(/<user_query>\s*([\s\S]*?)\s*<\/user_query>/i);
+    return (m?.[1] || text).trim();
+}
+/** Latest real user prompt from Grok chat_history.jsonl. */
+function readLatestGrokUserPrompt(cwd, sessionId) {
+    if (!sessionId)
+        return '';
+    const file = path.join(grokSessionDir(cwd, sessionId), 'chat_history.jsonl');
+    let raw;
+    try {
+        raw = fs.readFileSync(file, 'utf-8');
+    }
+    catch {
+        return '';
+    }
+    const lines = raw.split(/\n/);
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const line = lines[i].trim();
+        if (!line)
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (entry.type !== 'user')
+            continue;
+        const text = unwrapUserQuery(extractText(entry.content));
+        if (text)
+            return text;
+    }
+    return '';
+}
+function grokSidecarPath(short) {
+    return path.join(os.homedir(), '.greprag', 'grok-context', `${short}.md`);
+}
+function writeGrokSidecar(short, text) {
+    if (!short || !text)
+        return;
+    try {
+        const file = grokSidecarPath(short);
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.writeFileSync(file, text);
+    }
+    catch { /* sidecar is best-effort */ }
+}
+function appendGrokSidecar(short, text) {
+    if (!short || !text)
+        return;
+    try {
+        const file = grokSidecarPath(short);
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.appendFileSync(file, (fs.existsSync(file) ? '\n\n' : '') + text);
+    }
+    catch { /* sidecar is best-effort */ }
+}

package/dist/harness.js

@@ -8,6 +8,7 @@ exports.REPAIR_TARGET_HARNESSES = [
     'claude-code',
     'codex',
     'opencode',
+    'grok',
     'all',
 ];
 function normalizeHarness(raw) {
@@ -20,6 +21,8 @@ function normalizeHarness(raw) {
         return 'codex';
     if (v === 'opencode' || v === 'open-code' || v === 'open_code')
         return 'opencode';
+    if (v === 'grok' || v === 'grok-build' || v === 'grok_build')
+        return 'grok';
     if (v === 'all' || v === 'any' || v === 'universal')
         return 'all';
     return null;
@@ -30,6 +33,9 @@ function inferCurrentHarness() {
         if (h && h !== 'all')
             return h;
     }
+    // Grok sets CLAUDE_PROJECT_DIR as a compat alias. Detect Grok BEFORE Claude.
+    if (process.env.GROK_SESSION_ID || process.env.GROK_HOOK_EVENT)
+        return 'grok';
     if (process.env.CODEX_THREAD_ID)
         return 'codex';
     if (process.env.GREPRAG_OPENCODE_SESSION_ID || process.env.OPENCODE_SESSION_ID)

package/dist/hook-once.js

@@ -0,0 +1,67 @@
+"use strict";
+/** Once-per-event stamp so leaked Claude greprag hooks + dedicated
+ *  ~/.grok/hooks/greprag.json cannot double-store / double-recap.
+ *  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.claimHookOnce = claimHookOnce;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const TTL_MS = 60_000;
+function stampPath(sessionId, event, sub, turnId) {
+    const safe = [sessionId, event, sub, turnId].join('-').replace(/[^a-zA-Z0-9._-]/g, '_').slice(0, 180);
+    return path.join(os.homedir(), '.greprag', 'hook-once', `${safe}.json`);
+}
+/** True = this process should run the subcommand. False = duplicate, skip. */
+function claimHookOnce(sessionId, event, subcommand, turnId) {
+    if (!sessionId)
+        return true;
+    const key = turnId || 'noturn';
+    const file = stampPath(sessionId, event || 'unknown', subcommand, key);
+    try {
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        if (fs.existsSync(file)) {
+            const age = Date.now() - fs.statSync(file).mtimeMs;
+            if (age < TTL_MS)
+                return false;
+        }
+        fs.writeFileSync(file, JSON.stringify({ ts: Date.now(), subcommand }));
+        return true;
+    }
+    catch {
+        return true;
+    }
+}

package/dist/hook-runtime.js

@@ -33,12 +33,55 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeHookInput = normalizeHookInput;
+exports.isGrokProcess = isGrokProcess;
+exports.isShellTool = isShellTool;
 exports.ensureEnv = ensureEnv;
 exports.getHookConfig = getHookConfig;
 exports.apiCall = apiCall;
 exports.writeAdditionalContext = writeAdditionalContext;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+function asString(v) {
+    return typeof v === 'string' && v ? v : undefined;
+}
+function asObj(v) {
+    return v && typeof v === 'object' && !Array.isArray(v) ? v : undefined;
+}
+/** Grok sends camelCase; Claude/Codex send snake_case. One bag for every hook.
+ *  adr: adr/grok-platform.md */
+function normalizeHookInput(raw) {
+    const r = (raw && typeof raw === 'object') ? raw : {};
+    const event = asString(r.hook_event_name) || asString(r.hookEventName)
+        || asString(process.env.GROK_HOOK_EVENT);
+    const session = asString(r.session_id) || asString(r.sessionId)
+        || asString(process.env.GROK_SESSION_ID)
+        || asString(process.env.CLAUDE_CODE_SESSION_ID)
+        || asString(process.env.CODEX_THREAD_ID);
+    const cwd = asString(r.cwd) || asString(r.workspaceRoot)
+        || asString(process.env.GROK_WORKSPACE_ROOT);
+    const toolInput = asObj(r.tool_input) || asObj(r.toolInput);
+    return {
+        session_id: session,
+        turn_id: asString(r.turn_id) || asString(r.promptId) || asString(r.prompt_id),
+        transcript_path: asString(r.transcript_path) || asString(r.transcriptPath),
+        cwd,
+        hook_event_name: event,
+        prompt: asString(r.prompt),
+        model: asString(r.model),
+        last_assistant_message: asString(r.last_assistant_message) || asString(r.lastAssistantMessage),
+        tool_name: asString(r.tool_name) || asString(r.toolName),
+        tool_input: toolInput,
+        stop_hook_active: r.stop_hook_active === true || r.stopHookActive === true,
+    };
+}
+function isGrokProcess() {
+    return !!(process.env.GROK_SESSION_ID || process.env.GROK_HOOK_EVENT);
+}
+function isShellTool(name) {
+    const n = (name || '').toLowerCase();
+    return n === 'bash' || n === 'run_terminal_command' || n === 'shell';
+}
 const API_URL_DEFAULT = 'https://api.greprag.com';
 function loadEnvFile(filePath) {
     try {

package/dist/hook.js

@@ -50,6 +50,9 @@ const mechanic_role_1 = require("./mechanic-role");
 const assistant_doctrine_1 = require("./assistant-doctrine");
 const session_id_1 = require("./session-id");
 const hook_runtime_1 = require("./hook-runtime");
+const harness_1 = require("./harness");
+const hook_once_1 = require("./hook-once");
+const grok_session_1 = require("./grok-session");
 const codex_prompt_cache_1 = require("./codex-prompt-cache");
 // adr: adr/memory-provenance-capture.md — classify harness-injected user text
 // (skill bodies, continuation summaries, chip prompts) pre-LLM at capture and
@@ -1060,12 +1063,19 @@ async function store(input, source = 'claude-code') {
     if (!anchor.memoryCapture)
         return;
     const turn = parseLatestTurn(input.transcript_path);
-    if (source === 'codex' && (!turn.userPrompt || !turn.agentResponse)) {
+    if ((source === 'codex' || source === 'grok') && (!turn.userPrompt || !turn.agentResponse)) {
         const cached = (0, codex_prompt_cache_1.readCodexPromptCache)(input);
         if (!turn.userPrompt && cached) {
             turn.userPrompt = cached.prompt;
             turn.provenance = (0, turn_provenance_1.classifyUserText)(cached.prompt);
         }
+        if (!turn.userPrompt && source === 'grok') {
+            const fromDisk = (0, grok_session_1.readLatestGrokUserPrompt)(cwd, input.session_id);
+            if (fromDisk) {
+                turn.userPrompt = fromDisk;
+                turn.provenance = (0, turn_provenance_1.classifyUserText)(fromDisk);
+            }
+        }
         if (!turn.agentResponse && typeof input.last_assistant_message === 'string') {
             turn.agentResponse = input.last_assistant_message.trim();
         }
@@ -1082,7 +1092,7 @@ async function store(input, source = 'claude-code') {
             turn.filesTouched = Array.from(filesSet).sort();
         }
     }
-    if (source === 'codex') {
+    if (source === 'codex' || source === 'grok') {
         turn.toolCalls.push(...(0, codex_hook_events_1.readCodexSubagentToolCalls)(input));
     }
     // (Memory-reflex efficacy capture removed 2026-06-22 with the auto-inject it scored.)
@@ -1182,7 +1192,7 @@ async function store(input, source = 'claude-code') {
     // is network-backed. Codex Stop spools it to a detached worker so the app's
     // UI-critical Stop path does not wait on judge/distill calls; Claude Code keeps
     // the prior synchronous lifecycle.
-    if (source === 'codex') {
+    if (source === 'codex' || source === 'grok') {
         (0, inline_atom_background_1.spawnInlineAtomObserver)({
             cwd,
             sessionId: input.session_id,
@@ -1319,7 +1329,17 @@ function shouldEmitDriftWarning(storedId, derivedId) {
         return true;
     return (Date.now() - lastMs) >= DRIFT_WARNING_TTL_MS;
 }
-function writeRecapOutput(text, mode) {
+function grokSidecarHead(short, full) {
+    const arm = (0, session_id_1.armMonitorCommand)(short, null, false, false, 'grok');
+    return (0, session_id_1.buildSessionIdContext)(short, (0, session_id_1.readIdentityAlias)())
+        + `\n\nARM (Grok monitor persistent:true): \`${arm}\`\n`
+        + `Send with --from-session ${full || short} (full UUID or 16-hex, never 8-hex).\n`
+        + 'Chip: `greprag load grok-chip-spawn` then `greprag grok spawn`. Helper: spawn_subagent. Parent keeps ONE watch. Peers: `greprag inbox watchers` then `greprag send`.\n'
+        + 'If a greprag inbox monitor is already listed, do not start another. Instant exit = already armed.\n\n';
+}
+function writeRecapOutput(text, mode, grokShort, grokFull) {
+    if (grokShort)
+        (0, grok_session_1.writeGrokSidecar)(grokShort, grokSidecarHead(grokShort, grokFull) + (text || ''));
     if (!text)
         return;
     if (mode === 'additionalContext') {
@@ -1427,8 +1447,9 @@ function activeCommandDrift() {
  *  Storage and display are both UTC. The agent can compute local time itself
  *  if needed — a server-side UTC display avoids straddle-day confusion. */
 async function recap(input, mode = 'plain', opts = {}) {
-    const platform = opts.platform || 'claude-code';
-    const hasLocalMonitorLifecycle = platform === 'claude-code';
+    const platform = opts.platform || (0, harness_1.inferCurrentHarness)() || 'claude-code';
+    const hasLocalMonitorLifecycle = platform === 'claude-code' || platform === 'grok';
+    const grokShort = platform === 'grok' ? ((0, session_id_1.truncateSessionId)(input.session_id) || null) : null;
     let sessionOwnerPid = null;
     // SessionStart watcher cleanup (best-effort, side-effect only — never writes to
     // stdout, which carries this hook's additionalContext JSON). Three snapshot-free
@@ -1476,7 +1497,10 @@ async function recap(input, mode = 'plain', opts = {}) {
         // session started outside a project gets the session-id line (its own anchor-free
         // hook) but never the inbox rules — the exact gap a fresh unanchored session hit.
         // adr: adr/address-grammar.md
-        writeRecapOutput((0, inbox_primer_reminder_1.buildInboxPrimer)({ short: (0, session_id_1.truncateSessionId)(input.session_id) || '' }) + '\n', mode);
+        writeRecapOutput((0, inbox_primer_reminder_1.buildInboxPrimer)({
+            short: (0, session_id_1.truncateSessionId)(input.session_id) || '',
+            platform,
+        }) + '\n', mode, grokShort, input.session_id);
         return;
     }
     // Mechanic matchset boot pull (D5) — rides the existing SessionStart call
@@ -1696,7 +1720,7 @@ async function recap(input, mode = 'plain', opts = {}) {
         announceReg = (0, reminder_registry_1.compactReannounceModules)(announceReg);
     const announceBlock = (0, reminder_registry_1.collectAnnounces)(announceEnv, announceReg).join('\n\n') || null;
     if (opts.compact) {
-        writeRecapOutput(announceBlock ? announceBlock + '\n' : '', mode);
+        writeRecapOutput(announceBlock ? announceBlock + '\n' : '', mode, grokShort, input.session_id);
         return;
     }
     const preamble = () => (announceBlock ? announceBlock + '\n' : '');
@@ -1705,7 +1729,7 @@ async function recap(input, mode = 'plain', opts = {}) {
     // hook globally. Setup warnings still fire above.
     if (!anchor.sessionStartRecap) {
         const out = preamble();
-        writeRecapOutput(out, mode);
+        writeRecapOutput(out, mode, grokShort, input.session_id);
         return;
     }
     // Recap body is hourlies-only — daily summaries used to render here (one
@@ -1722,7 +1746,7 @@ async function recap(input, mode = 'plain', opts = {}) {
     // if they're pending.
     if (!body) {
         const out = preamble();
-        writeRecapOutput(out, mode);
+        writeRecapOutput(out, mode, grokShort, input.session_id);
         return;
     }
     const parts = [];
@@ -1731,7 +1755,7 @@ async function recap(input, mode = 'plain', opts = {}) {
         parts.push('');
     }
     parts.push(body);
-    writeRecapOutput(parts.join('\n') + '\n', mode);
+    writeRecapOutput(parts.join('\n') + '\n', mode, grokShort, input.session_id);
 }
 /** Arm-state detection moved LOCAL (2026-06-04). The former `isSessionArmed`
  *  asked the server's watcher registry "does this session have a live socket?"
@@ -1814,8 +1838,14 @@ async function procedureCheck(input) {
     }
 }
 async function notify(input, source = 'claude-code', chipContext) {
-    if (source === 'codex')
+    const harness = (0, harness_1.inferCurrentHarness)() || source;
+    if (source === 'codex' || harness === 'grok')
         (0, codex_prompt_cache_1.cacheCodexPrompt)(input);
+    if (harness === 'grok') {
+        // UserPromptSubmit is observe-only on Grok — stdout cannot inject.
+        // Cache the prompt for Stop capture, then return.
+        return;
+    }
     // Codex Desktop reliably executes only the first UserPromptSubmit command.
     // Procedure therefore shares the proven codex-notify bridge instead of
     // depending on a sibling registration that the harness may skip.
@@ -1993,7 +2023,9 @@ async function collisionCheck(input) {
  *  poll live-tails with no double-delivery. Closes the dead-window gap where a
  *  session-directed message that lands between watcher death and re-arm sits
  *  unread until a manual `greprag inbox`. Inbound-only — the front desk (cold
- *  opens + email) stays with the human-scoped `mail` hook. All real logic lives
+ *  opens + email) stays with the human-scoped `mail` hook. Injects only when
+ *  unarmed (`isLocallyArmed`); a live watcher already delivered the body.
+ *  Grok also wires this on Stop as the unarmed floor. All real logic lives
  *  in ./commands/inbox-drain (pure + tested). Best-effort: any miss → silent,
  *  never blocks SessionStart. adr: adr/monitor-resilience.md */
 async function drain(input) {
@@ -2004,9 +2036,14 @@ async function drain(input) {
     const short = (0, session_id_1.truncateSessionId)(input.session_id);
     if (!short)
         return; // no session id → silent
-    const result = await (0, inbox_drain_1.runInboxDrain)({ session: short, apiUrl: cfg.apiUrl, apiKey: cfg.apiKey });
+    const result = await (0, inbox_drain_1.runInboxDrain)({
+        session: short, apiUrl: cfg.apiUrl, apiKey: cfg.apiKey,
+        armed: (0, watcher_registry_1.isLocallyArmed)(short),
+    });
     if (result.context) {
         (0, hook_runtime_1.writeAdditionalContext)(input.hook_event_name || 'SessionStart', result.context);
+        if ((0, harness_1.inferCurrentHarness)() === 'grok')
+            (0, grok_session_1.appendGrokSidecar)(short, result.context);
     }
 }
 function validateChip(title, prompt) {
@@ -2208,14 +2245,19 @@ async function main() {
             chunks.push(chunk);
         }
         const raw = Buffer.concat(chunks).toString('utf-8').trim();
-        if (raw)
-            input = JSON.parse(raw);
+        input = (0, hook_runtime_1.normalizeHookInput)(raw ? JSON.parse(raw) : {});
     }
     catch {
         process.exit(0);
     }
+    if (!(0, hook_once_1.claimHookOnce)(input.session_id, input.hook_event_name, subcommand, input.turn_id)) {
+        process.exit(0);
+    }
+    const harness = (0, harness_1.inferCurrentHarness)();
     if (subcommand === 'recap') {
-        await recap(input);
+        await recap(input, harness === 'grok' ? 'additionalContext' : 'plain', {
+            platform: harness === 'grok' ? 'grok' : undefined,
+        });
     }
     else if (subcommand === 'recompact') {
         // PostCompact — re-present the Interrupt System's announce modules (default-on;
@@ -2228,7 +2270,7 @@ async function main() {
         await recap(input, 'additionalContext', { platform: 'codex' });
     }
     else if (subcommand === 'notify') {
-        await notify(input);
+        await notify(input, harness === 'grok' ? 'grok' : 'claude-code');
     }
     else if (subcommand === 'mail') {
         await mail(input);
@@ -2273,6 +2315,23 @@ async function main() {
         // hook's job now (it injects the arm directive on any turn the session is
         // found to have no live watcher), so SessionStart no longer arms.
         (0, session_id_1.handleSessionIdHook)(input);
+        if (harness === 'grok') {
+            const short = (0, session_id_1.truncateSessionId)(input.session_id);
+            if (short) {
+                let existing = '';
+                try {
+                    existing = fs.readFileSync((0, grok_session_1.grokSidecarPath)(short), 'utf-8');
+                }
+                catch { /* none yet */ }
+                if (!existing.includes('ARM (Grok monitor')) {
+                    const block = grokSidecarHead(short, input.session_id);
+                    if (existing)
+                        (0, grok_session_1.appendGrokSidecar)(short, block);
+                    else
+                        (0, grok_session_1.writeGrokSidecar)(short, block);
+                }
+            }
+        }
     }
     else if (subcommand === 'pre-spawn-check') {
         handlePreSpawnCheck(input);
@@ -2361,7 +2420,15 @@ async function main() {
         // the next turn's PreToolUse `source:"state"` rules read a fresh stress /
         // turnCount reading. Order: store first (the primary job), then the
         // best-effort state stash. docs/ingress-trigger-bridge.md
-        await store(input);
+        await store(input, harness === 'grok' ? 'grok' : 'claude-code');
+        if (harness === 'grok') {
+            // Floor: inject unread mail only when unarmed. Do NOT nag UNARMED here —
+            // Grok Stop fires every turn, and a pidfile-alias miss made that a
+            // re-arm loop (watch already live → singleton-guard exits instantly →
+            // model arms again). Arm teaching is sidecar + rules.
+            // adr: adr/grok-platform.md
+            await drain(input);
+        }
         stateUpdate(input);
     }
 }