greprag 5.74.21 → 5.75.0

package/dist/commands/status.js

@@ -146,6 +146,9 @@ function readVersion() {
         return 'unknown';
     }
 }
+function grokHooksPath() {
+    return path.join(home(), '.grok', 'hooks', 'greprag.json');
+}
 function platformFromArgs(args) {
     if (args.includes('--claude'))
         return 'claude';
@@ -153,6 +156,8 @@ function platformFromArgs(args) {
         return 'codex';
     if (args.includes('--opencode'))
         return 'opencode';
+    if (args.includes('--grok'))
+        return 'grok';
     if (args.includes('--all-platforms'))
         return 'all';
     return 'all';
@@ -167,6 +172,8 @@ function buildStatus(cwd, platform = 'all') {
     const identityCache = (0, identity_1.readCache)(identityCachePath);
     const codexSkillPath = path.join(home(), '.codex', 'skills', 'greprag');
     const claudeSkillPath = path.join(home(), '.claude', 'skills', 'greprag');
+    const grokSkillPath = path.join(home(), '.grok', 'skills', 'greprag');
+    const grokHooks = readJson(grokHooksPath(), {});
     const opencodePluginPath = path.join(home(), '.config', 'opencode', 'plugins', 'greprag-memory.js');
     const claudeHooks = {
         session_start_recap: hasHook(settings.hooks?.SessionStart, 'recap'),
@@ -187,6 +194,15 @@ function buildStatus(cwd, platform = 'all') {
         post_compact_session_id: hasCodexHook(codexHooks.hooks?.PostCompact, 'session-id'),
     };
     const opencodePluginInstalled = fs.existsSync(opencodePluginPath);
+    const grokHookStatus = {
+        session_start_recap: hasCodexHook(grokHooks.hooks?.SessionStart, 'recap'),
+        session_id: hasCodexHook(grokHooks.hooks?.SessionStart, 'session-id'),
+        session_start_drain: hasCodexHook(grokHooks.hooks?.SessionStart, 'drain'),
+        user_prompt_submit: hasCodexHook(grokHooks.hooks?.UserPromptSubmit, 'notify'),
+        crush_wrap: hasCodexHook(grokHooks.hooks?.PreToolUse, 'crush-wrap'),
+        stop_store: hasCodexHook(grokHooks.hooks?.Stop, 'store'),
+        stop_drain: hasCodexHook(grokHooks.hooks?.Stop, 'drain'),
+    };
     return {
         installed: true,
         version: readVersion(),
@@ -212,6 +228,8 @@ function buildStatus(cwd, platform = 'all') {
             codex_pre_tool_use_safety: codexHookStatus.pre_tool_use_safety,
             codex_pre_tool_use_chip_guard: codexHookStatus.pre_tool_use_chip_guard,
             codex_stop_store: codexHookStatus.stop_store,
+            grok_session_start_recap: grokHookStatus.session_start_recap,
+            grok_stop_store: grokHookStatus.stop_store,
         },
         platforms: {
             claude: {
@@ -241,6 +259,16 @@ function buildStatus(cwd, platform = 'all') {
                 plugin_installed: opencodePluginInstalled,
                 note: 'OpenCode loads the GrepRAG plugin from its global plugin directory.',
             },
+            grok: {
+                configured: !!api.key && grokHookStatus.session_start_recap && grokHookStatus.stop_store
+                    && fs.existsSync(grokSkillPath),
+                config_path: grokHooksPath(),
+                config_present: fs.existsSync(grokHooksPath()),
+                skill_path: grokSkillPath,
+                skill_installed: fs.existsSync(grokSkillPath),
+                hooks: grokHookStatus,
+                note: 'Grok recap is a sidecar + ~/.grok/rules (SessionStart stdout is ignored). Idle inbox: Grok monitor + quiet watch. Stop drain injects unread mail.',
+            },
         },
         project: {
             cwd: path.resolve(cwd),
@@ -293,7 +321,7 @@ function renderPlatform(name, p) {
 }
 function renderHuman(s, docMirror) {
     const yes = (b) => b ? 'yes' : 'no';
-    const platformNames = s.platform === 'all' ? ['claude', 'codex', 'opencode'] : [s.platform];
+    const platformNames = s.platform === 'all' ? ['claude', 'codex', 'opencode', 'grok'] : [s.platform];
     return [
         `greprag ${s.version}`,
         `Shared env: ${s.shared_env_path}`,

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 {