greprag 5.74.8 → 5.74.9

package/dist/codex-checkpoint-hook.js

@@ -0,0 +1,184 @@
+"use strict";
+/** Codex checkpoint coordination — detect a successful Git commit transition
+ * and inject the delivery handoff at that exact lifecycle boundary.
+ *
+ * PreToolUse records the prior HEAD around shell-capable tools. PostToolUse
+ * proves HEAD changed via a commit reflog action and emits immediately; the
+ * next PreToolUse is a fallback if that lifecycle event was unavailable.
+ * User prompt and executor-wrapper wording are irrelevant.
+ * adr: adr/codex-checkpoint-coordination.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.checkpointCoordinationText = checkpointCoordinationText;
+exports.recordCodexGitBoundary = recordCodexGitBoundary;
+exports.evaluateCodexCommitResult = evaluateCodexCommitResult;
+exports.evaluatePendingCodexCheckpoint = evaluatePendingCodexCheckpoint;
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+function homeDir() {
+    return process.env.USERPROFILE || process.env.HOME || '';
+}
+function normalizedCwd(input) {
+    return path.resolve(input.cwd || process.cwd()).replace(/\\/g, '/').toLowerCase();
+}
+function statePath(input) {
+    const home = homeDir();
+    const session = (input.session_id || '').trim();
+    if (!home || !session)
+        return null;
+    const key = crypto.createHash('sha256')
+        .update(`${session}\0${normalizedCwd(input)}`)
+        .digest('hex')
+        .slice(0, 24);
+    return path.join(home, '.greprag', 'state', `codex-checkpoint-${key}.json`);
+}
+function git(cwd, args) {
+    try {
+        return (0, child_process_1.execFileSync)('git', args, {
+            cwd,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+            windowsHide: true,
+        }).trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+function currentHead(cwd) {
+    return git(cwd, ['rev-parse', 'HEAD']);
+}
+function currentBranch(cwd) {
+    return git(cwd, ['branch', '--show-current']) || '(detached HEAD)';
+}
+function latestHeadAction(cwd) {
+    return git(cwd, ['reflog', '-1', '--format=%gs', 'HEAD']) || '';
+}
+function isCommitHeadAction(cwd) {
+    return /^commit(?: \([^)]+\))?:/i.test(latestHeadAction(cwd));
+}
+function isShellCapableTool(input) {
+    const name = (input.tool_name || '').toLowerCase();
+    return /(?:^|[.:/_-])(bash|shell|exec|exec_command|write_stdin)$/.test(name);
+}
+function writePending(file, pending) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(pending, null, 2) + '\n');
+}
+function readPending(file) {
+    try {
+        return JSON.parse(fs.readFileSync(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function clearPending(file) {
+    try {
+        fs.unlinkSync(file);
+    }
+    catch { /* already absent */ }
+}
+function consumePending(input, hookEventName) {
+    const file = statePath(input);
+    if (!file)
+        return null;
+    const pending = readPending(file);
+    if (!pending || pending.cwd !== normalizedCwd(input))
+        return null;
+    clearPending(file);
+    const cwd = input.cwd || process.cwd();
+    const afterHead = currentHead(cwd);
+    if (!afterHead || afterHead === pending.beforeHead || !isCommitHeadAction(cwd))
+        return null;
+    return {
+        hookSpecificOutput: {
+            hookEventName,
+            additionalContext: checkpointCoordinationText(currentBranch(cwd), afterHead.slice(0, 12)),
+        },
+    };
+}
+function checkpointCoordinationText(branch, sha) {
+    return `[DELIVERY COORDINATION — CHECKPOINT CREATED]
+
+Checkpoint: ${branch} @ ${sha}
+
+Coordinate now, before merge, push, deploy, publish, or release.
+
+- Child task: send the LEAD your branch, SHA, checks, status, owned dirt, and blockers. The LEAD owns integration.
+- LEAD/standalone task: call codex_app.list_threads unfiltered, scope to this repo/worktree, exclude yourself, and ask every live peer for its latest checkpoint, owned dirt, blockers, and sequencing needs.
+- Elect exactly one delivery owner. If no peers exist, you are the owner.
+- Use greprag send for cross-harness peers.
+
+Do not begin a delivery action until coordination is settled.`;
+}
+/** PreToolUse leg: remember HEAD around any shell-capable action. The result
+ * leg classifies the actual Git transition, so nested executor syntax and
+ * dynamically composed commands do not matter. */
+function recordCodexGitBoundary(input) {
+    if (input.hook_event_name !== 'PreToolUse')
+        return;
+    if (!isShellCapableTool(input))
+        return;
+    const file = statePath(input);
+    if (!file)
+        return;
+    const cwd = input.cwd || process.cwd();
+    writePending(file, {
+        sessionId: input.session_id || '',
+        cwd: normalizedCwd(input),
+        toolName: input.tool_name || '',
+        beforeHead: currentHead(cwd),
+        recordedAt: new Date().toISOString(),
+    });
+}
+/** Preferred result leg: emit on the successful commit's own PostToolUse. */
+function evaluateCodexCommitResult(input) {
+    if (input.hook_event_name !== 'PostToolUse')
+        return null;
+    if (!isShellCapableTool(input))
+        return null;
+    return consumePending(input, 'PostToolUse');
+}
+/** Fallback result leg: if PostToolUse was unavailable, emit before the first
+ * later tool call. Failed/empty commits leave HEAD unchanged and clear
+ * silently. */
+function evaluatePendingCodexCheckpoint(input) {
+    if (input.hook_event_name !== 'PreToolUse')
+        return null;
+    return consumePending(input, 'PreToolUse');
+}

package/dist/codex-fast-hook.js

@@ -65,9 +65,10 @@ async function main() {
     const subcommand = process.argv[2];
     if (subcommand !== 'codex-chip-hook'
         && subcommand !== 'codex-pretooluse'
+        && subcommand !== 'codex-posttooluse'
         && subcommand !== 'codex-notify'
         && subcommand !== 'codex-store') {
-        process.stderr.write('Usage: greprag-codex-hook <codex-chip-hook|codex-pretooluse|codex-notify|codex-store>\n');
+        process.stderr.write('Usage: greprag-codex-hook <codex-chip-hook|codex-pretooluse|codex-posttooluse|codex-notify|codex-store>\n');
         process.exit(1);
     }
     const input = await readInput();
@@ -81,6 +82,13 @@ async function main() {
         await runCodexNotify(input);
         return;
     }
+    if (subcommand === 'codex-posttooluse') {
+        const { evaluateCodexCommitResult } = await Promise.resolve().then(() => __importStar(require('./codex-checkpoint-hook')));
+        const result = evaluateCodexCommitResult(input);
+        if (result)
+            process.stdout.write(JSON.stringify(result) + '\n');
+        return;
+    }
     const { evaluateCodexChipHook } = await Promise.resolve().then(() => __importStar(require('./codex-chip-hooks')));
     const chipResult = evaluateCodexChipHook(input);
     if (subcommand === 'codex-chip-hook') {
@@ -89,6 +97,11 @@ async function main() {
         return;
     }
     let result = chipResult;
+    if (subcommand === 'codex-pretooluse') {
+        const { evaluatePendingCodexCheckpoint, recordCodexGitBoundary, } = await Promise.resolve().then(() => __importStar(require('./codex-checkpoint-hook')));
+        result = mergeOutputs(result, evaluatePendingCodexCheckpoint(input));
+        recordCodexGitBoundary(input);
+    }
     if (!result?.hookSpecificOutput.permissionDecision && input.tool_name === 'Bash') {
         const { runSearchGuard } = await Promise.resolve().then(() => __importStar(require('./commands/search-guard')));
         result = mergeOutputs(result, runSearchGuard(input));

package/dist/commands/coordinate-gate.js

@@ -38,6 +38,7 @@
  *  shared-state mutation actually happens. The eval is ready for a future Write
  *  adapter; only a new triggerFrom* + a `Write|Edit` matcher would be needed. */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasGitSubcommand = hasGitSubcommand;
 exports.classifyRiskyCommand = classifyRiskyCommand;
 exports.triggerFromPreToolUse = triggerFromPreToolUse;
 exports.buildCoordinateDirective = buildCoordinateDirective;
@@ -141,6 +142,30 @@ function classifyGit(tokens) {
         return { kind: 'push', label: 'git push' };
     return null;
 }
+/** True when any executable command segment invokes the requested Git
+ * subcommand, including `git -C <worktree> <subcommand>`. Exported so lifecycle
+ * hooks can key off agent-generated Git actions instead of user prompt words. */
+function hasGitSubcommand(command, expected) {
+    if (!command || !expected)
+        return false;
+    for (const seg of commandSegments(command)) {
+        const tokens = shellWords(seg);
+        if (tokens[0] !== 'git')
+            continue;
+        let i = 1;
+        const optionsWithValue = new Set([
+            '-C', '-c', '--exec-path', '--git-dir', '--work-tree', '--namespace', '--super-prefix', '--config-env',
+        ]);
+        while (i < tokens.length && tokens[i].startsWith('-')) {
+            const option = tokens[i++];
+            if (optionsWithValue.has(option) && i < tokens.length)
+                i++;
+        }
+        if (tokens[i] === expected)
+            return true;
+    }
+    return false;
+}
 /** Classify a Bash command into a risky-action trigger, or null. PURE. Matches
  *  the FIRST risky segment (a chained command fires on whichever risky verb
  *  appears first). */

package/dist/commands/init.js

@@ -636,9 +636,9 @@ async function runCodexInit(opts) {
     }
     console.log(`\n  Codex hooks file: ${hooksPath}`);
     console.log(`  Project anchor: ${anchor.anchorPath}`);
-    console.log('  Start a fresh Codex session, then open Settings -> Settings -> Hooks and trust the GrepRAG hook definitions.');
+    console.log('  Open Settings -> Settings -> Hooks and trust the GrepRAG hook definitions, then fully restart Codex Desktop.');
     console.log('  Inbox messages for Codex surface on SessionStart and UserPromptSubmit hook boundaries.');
-    console.log('  Memory hooks will activate on your next Codex session.\n');
+    console.log('  Hooks will activate after the Codex host restart; starting only a new task is not sufficient after hook changes.\n');
 }
 /** greprag init --global
  *  Creates ~/.greprag/project.json with a stable UUID.
@@ -1130,6 +1130,19 @@ function applyCodexHooks(config) {
     if (removedPostToolInbox) {
         changes.push(`Removed ${removedPostToolInbox} Codex PostToolUse inbox hook(s); UserPromptSubmit now owns inbox steering`);
     }
+    const checkpointHook = {
+        matcher: '',
+        hooks: [commandHook('codex-posttooluse', 5, 'Coordinating Codex checkpoint', 'greprag-codex-hook')],
+    };
+    if (!hasGrepragHook(config.hooks.PostToolUse, 'codex-posttooluse')) {
+        if (!config.hooks.PostToolUse)
+            config.hooks.PostToolUse = [];
+        config.hooks.PostToolUse.push(checkpointHook);
+        changes.push('Added Codex PostToolUse hook (successful checkpoint coordination)');
+    }
+    else {
+        changes.push('Codex PostToolUse checkpoint hook already configured (skipped)');
+    }
     const permissionHook = {
         matcher: '',
         hooks: [commandHook('codex-permission-context', 3, 'Loading GrepRAG approval context')],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "greprag",
-  "version": "5.74.8",
+  "version": "5.74.9",
   "description": "GrepRAG — agent memory for Claude Code, Codex, and OpenCode.",
   "main": "dist/index.js",
   "bin": {