greprag 5.74.11 → 5.74.12

package/dist/codex-delivery-coordination.js

@@ -0,0 +1,213 @@
+"use strict";
+/** Codex delivery coordination - interrupt the first delivery action once,
+ * then keep the rest of that delivery run non-blocking.
+ *
+ * The hook cannot call native Codex task tools. It names the exact agent-owned
+ * discovery and messaging actions, persists the open delivery window before
+ * denying, and never waits for peer replies or attestation.
+ *
+ * adr: adr/codex-coordinate-gate.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.DELIVERY_COORDINATION_WINDOW_MS = void 0;
+exports.codexDeliveryTrigger = codexDeliveryTrigger;
+exports.codexDeliveryCoordinationText = codexDeliveryCoordinationText;
+exports.evaluateCodexDeliveryCoordination = evaluateCodexDeliveryCoordination;
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const coordinate_gate_1 = require("./commands/coordinate-gate");
+exports.DELIVERY_COORDINATION_WINDOW_MS = 30 * 60 * 1000;
+function homeDir() {
+    return process.env.USERPROFILE || process.env.HOME || '';
+}
+function normalize(value) {
+    return path.resolve(value).replace(/\\/g, '/').toLowerCase();
+}
+function gitRoot(cwd) {
+    try {
+        const root = (0, child_process_1.execFileSync)('git', ['rev-parse', '--show-toplevel'], {
+            cwd,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+            windowsHide: true,
+        }).trim();
+        return root ? normalize(root) : null;
+    }
+    catch {
+        return null;
+    }
+}
+function statePath(input, repoRoot) {
+    const home = homeDir();
+    const session = (input.session_id || '').trim();
+    if (!home || !session)
+        return null;
+    const key = crypto.createHash('sha256')
+        .update(`${session}\0${repoRoot}`)
+        .digest('hex')
+        .slice(0, 24);
+    return path.join(home, '.greprag', 'state', `codex-delivery-${key}.json`);
+}
+function readWindow(file) {
+    try {
+        return JSON.parse(fs.readFileSync(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function writeWindow(file, window) {
+    try {
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.writeFileSync(file, JSON.stringify(window, null, 2) + '\n');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isShellCapableTool(input) {
+    const name = (input.tool_name || '').toLowerCase();
+    return /(?:^|[.:/_-])(bash|shell|exec|exec_command)$/.test(name);
+}
+function decodeQuoted(value) {
+    if (value.startsWith('"')) {
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            return null;
+        }
+    }
+    if (value.startsWith("'")) {
+        return value.slice(1, -1).replace(/\\'/g, "'").replace(/\\\\/g, '\\');
+    }
+    return null;
+}
+function embeddedCommands(code) {
+    const commands = [];
+    const re = /(?:command|cmd)\s*:\s*("(?:\\.|[^"])*"|'(?:\\.|[^'])*')/g;
+    for (const match of code.matchAll(re)) {
+        const decoded = decodeQuoted(match[1]);
+        if (decoded)
+            commands.push(decoded);
+    }
+    return commands;
+}
+function commandCandidates(input) {
+    if (!isShellCapableTool(input))
+        return [];
+    const toolInput = input.tool_input;
+    if (typeof toolInput === 'string')
+        return embeddedCommands(toolInput);
+    if (!toolInput || typeof toolInput !== 'object')
+        return [];
+    const candidates = [];
+    const fields = toolInput;
+    for (const key of ['command', 'cmd', 'script']) {
+        const value = fields[key];
+        if (typeof value === 'string')
+            candidates.push(value);
+    }
+    for (const key of ['code', 'input']) {
+        const value = fields[key];
+        if (typeof value === 'string')
+            candidates.push(...embeddedCommands(value));
+    }
+    return candidates;
+}
+function codexDeliveryTrigger(input) {
+    for (const command of commandCandidates(input)) {
+        const trigger = (0, coordinate_gate_1.classifyRiskyCommand)(command);
+        if (trigger)
+            return trigger;
+    }
+    return null;
+}
+function codexDeliveryCoordinationText(trigger) {
+    return `[DELIVERY NOW]
+
+Before ${trigger.label}, call codex_app.list_threads unfiltered and keep only peers in the same repo. Use codex_app.send_message_to_thread once for peers with ready or overlapping work; include your branch/commit and ask only for ready commits or concrete blockers.
+
+Include ready handoffs and clear known blockers, then retry immediately. Do not call wait_threads, wait for replies, or send follow-ups. Missing replies and unfinished peer work do not block delivery.`;
+}
+/** First delivery action opens a 30-minute session/repo window and interrupts
+ * once. Later merge/push/deploy/release actions refresh the same window and
+ * proceed without another coordination round. */
+function evaluateCodexDeliveryCoordination(input, now = Date.now()) {
+    if (input.hook_event_name !== 'PreToolUse')
+        return null;
+    const trigger = codexDeliveryTrigger(input);
+    if (!trigger)
+        return null;
+    const cwd = input.cwd || process.cwd();
+    const repoRoot = gitRoot(cwd);
+    if (!repoRoot)
+        return null;
+    const file = statePath(input, repoRoot);
+    if (!file)
+        return null;
+    const previous = readWindow(file);
+    const previousLastAction = previous ? Date.parse(previous.lastActionAt) : NaN;
+    if (previous
+        && previous.repoRoot === repoRoot
+        && Number.isFinite(previousLastAction)
+        && now - previousLastAction < exports.DELIVERY_COORDINATION_WINDOW_MS) {
+        writeWindow(file, {
+            ...previous,
+            lastActionAt: new Date(now).toISOString(),
+        });
+        return null;
+    }
+    const openedAt = new Date(now).toISOString();
+    if (!writeWindow(file, {
+        sessionId: input.session_id || '',
+        repoRoot,
+        openedAt,
+        lastActionAt: openedAt,
+    })) {
+        return null;
+    }
+    return {
+        hookSpecificOutput: {
+            hookEventName: 'PreToolUse',
+            additionalContext: codexDeliveryCoordinationText(trigger),
+            permissionDecision: 'deny',
+            permissionDecisionReason: `Run one same-repo coordination pass, then retry ${trigger.label} immediately; peer replies are not required.`,
+        },
+    };
+}

package/dist/codex-fast-hook.js

@@ -83,10 +83,8 @@ async function main() {
         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');
+        // Compatibility no-op for installed configs predating the delivery-boundary
+        // cutover. `greprag init --codex` removes this hook.
         return;
     }
     const { evaluateCodexChipHook } = await Promise.resolve().then(() => __importStar(require('./codex-chip-hooks')));
@@ -97,10 +95,9 @@ 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 (subcommand === 'codex-pretooluse' && !result?.hookSpecificOutput.permissionDecision) {
+        const { evaluateCodexDeliveryCoordination } = await Promise.resolve().then(() => __importStar(require('./codex-delivery-coordination')));
+        result = mergeOutputs(result, evaluateCodexDeliveryCoordination(input));
     }
     if (!result?.hookSpecificOutput.permissionDecision && input.tool_name === 'Bash') {
         const { runSearchGuard } = await Promise.resolve().then(() => __importStar(require('./commands/search-guard')));

package/dist/commands/coordinate-gate.js

@@ -27,8 +27,8 @@
  *  dedups to stay quiet), the merge gate must reflect live truth each time.
  *
  *  EFFECT is the adapter's choice, not the eval's: Claude/OpenCode inject the
- *  fresh roster as context; Codex denies until artifact-bound conferral evidence
- *  exists because Codex does not support a permission `ask` decision. An
+ *  fresh roster as context. Codex uses the separate local, bounded delivery
+ *  interrupt in codex-delivery-coordination.ts and carries no attestation. An
  *  ingress-source wrapper would inject instead. The eval below only produces
  *  the message.
  *

package/dist/commands/delivery-reminder.js

@@ -12,27 +12,26 @@ exports.buildDeliveryAnnounce = buildDeliveryAnnounce;
 // adr: adr/delivery-announce-pilot.md
 function coordinationLine(platform) {
     if (platform === 'codex') {
-        return 'Codex coordination: call list_threads unfiltered, filter to this repo/worktree, inspect matching tasks, then send_message_to_thread with your branch/commit/status before merge/push/deploy. Use GrepRAG only for cross-harness peers.';
+        return 'Codex: at the merge/deploy gate, call codex_app.list_threads unfiltered, filter to peers in the same repo, then use codex_app.send_message_to_thread once for ready or overlapping work.';
     }
     if (platform === 'claude-code') {
-        return 'Claude Code coordination: discover peers with `greprag inbox watchers --json`, send to the exact session, and keep the Monitor armed for replies.';
+        return 'Claude Code: at the merge/deploy gate, discover peers in the same repo and send one concise delivery notice to peers with ready or overlapping work.';
     }
     if (platform === 'opencode') {
-        return 'OpenCode coordination: use the GrepRAG project/session registry and session-targeted send; the plugin relay delivers replies.';
+        return 'OpenCode: at the merge/deploy gate, use the GrepRAG project/session registry and send one concise delivery notice to peers with ready or overlapping work.';
     }
-    return 'Coordination: discover same-project peers through this harness and use GrepRAG for cross-harness peers.';
+    return 'At the merge/deploy gate, coordinate once with peers in the same repo who have ready or overlapping work.';
 }
 function buildDeliveryAnnounce(env) {
     if (!env.deliveryRepo)
         return null;
     const project = env.projectName?.trim() || 'current repo';
     return [
-        `[DELIVERY CONTROL — ${project}]`,
-        'For full-goal code work, done means checkpointed, coordinated, integrated, pushed, deployed, and production-verified. Checkpoint each passing fix or feature.',
+        `[DELIVERY — ${project}]`,
+        'Commit useful, passing work.',
         coordinationLine(env.platform),
-        'Before merge, push, deploy, or release: elect one delivery owner. That owner includes every ready peer commit, resolves ordinary mission conflicts, and settles unclaimed dirt by adopt, rescue, or discard.',
-        'Use the canonical commit, deploy, and release skills plus this repo\'s delivery configuration. Never borrow a branch, remote, provider command, or verification rule from another repo.',
-        'A full-goal delivery mission already provisions ordinary repo-scoped commit, merge, push, deploy, and verification; do not wait for a second keyword.',
+        'Include ready peer commits and clear known blockers, then merge to the default branch and deploy immediately. Missing replies and unfinished peer work do not block delivery.',
+        'Use this repo\'s delivery profile and verify production.',
     ].join('\n');
 }
 exports.deliveryControlModule = {

package/dist/commands/init.js

@@ -1130,18 +1130,9 @@ 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 removedPostToolCoord = removeGrepragHook(config.hooks, 'PostToolUse', 'codex-posttooluse');
+    if (removedPostToolCoord) {
+        changes.push(`Removed ${removedPostToolCoord} Codex commit-triggered coordination hook(s); delivery coordination now starts at PreToolUse`);
     }
     const permissionHook = {
         matcher: '',
@@ -1199,8 +1190,8 @@ function applyCodexHooks(config) {
     ];
     // adr: adr/codex-hook-latency.md
     // Collapse the hot PreToolUse safety pair into one fast command process. It
-    // runs the chip/apply_patch guard plus local Bash safety checks. The retired
-    // coordination gate is removed when found so old configs stop blocking.
+    // runs the chip/apply_patch guard, one-shot delivery coordination, and local
+    // Bash safety checks. The legacy split coordination gate is removed.
     const removedPreToolChip = removeGrepragHook(config.hooks, 'PreToolUse', 'codex-chip-hook');
     const removedPreToolCoord = removeGrepragHook(config.hooks, 'PreToolUse', 'codex-coordinate-gate');
     if (removedPreToolChip || removedPreToolCoord) {
@@ -1208,16 +1199,16 @@ function applyCodexHooks(config) {
     }
     const preToolUseHook = {
         matcher: '',
-        hooks: [commandHook('codex-pretooluse', 10, 'Checking GrepRAG Codex safety', 'greprag-codex-hook')],
+        hooks: [commandHook('codex-pretooluse', 10, 'Checking GrepRAG Codex delivery and safety', 'greprag-codex-hook')],
     };
     if (!hasGrepragHookWithMatcher(config.hooks.PreToolUse, 'codex-pretooluse', preToolUseHook.matcher)) {
         if (!config.hooks.PreToolUse)
             config.hooks.PreToolUse = [];
         config.hooks.PreToolUse.push(preToolUseHook);
-        changes.push('Added Codex PreToolUse hook (multiplexed local safety)');
+        changes.push('Added Codex PreToolUse hook (delivery coordination + local safety)');
     }
     else {
-        changes.push('Codex PreToolUse multiplexed safety hook already configured (skipped)');
+        changes.push('Codex PreToolUse delivery/safety hook already configured (skipped)');
     }
     const removedStopChip = removeGrepragHook(config.hooks, 'Stop', 'codex-chip-hook');
     if (removedStopChip) {
@@ -1278,7 +1269,7 @@ function normalizeCodexHookCommands(hooks) {
         'codex-permission-context': { timeout: 3, statusMessage: 'Loading GrepRAG approval context' },
         'codex-subagent-start': { timeout: 3, statusMessage: 'Recording GrepRAG subagent metadata' },
         'codex-chip-hook': { timeout: 3, statusMessage: 'Enforcing Codex chip contract', runner: 'greprag-codex-hook' },
-        'codex-pretooluse': { timeout: 10, statusMessage: 'Checking GrepRAG Codex safety', runner: 'greprag-codex-hook' },
+        'codex-pretooluse': { timeout: 10, statusMessage: 'Checking GrepRAG Codex delivery and safety', runner: 'greprag-codex-hook' },
         'codex-coordinate-gate': { timeout: 10, statusMessage: 'Checking peer coordination' },
         'codex-store': { timeout: 3, statusMessage: 'Storing GrepRAG turn', runner: 'greprag-codex-hook' },
     };

package/dist/opencode-plugin.bundle.js

@@ -2401,27 +2401,26 @@ var loadoutRegistrarModule = {
 // src/commands/delivery-reminder.ts
 function coordinationLine(platform) {
   if (platform === "codex") {
-    return "Codex coordination: call list_threads unfiltered, filter to this repo/worktree, inspect matching tasks, then send_message_to_thread with your branch/commit/status before merge/push/deploy. Use GrepRAG only for cross-harness peers.";
+    return "Codex: at the merge/deploy gate, call codex_app.list_threads unfiltered, filter to peers in the same repo, then use codex_app.send_message_to_thread once for ready or overlapping work.";
   }
   if (platform === "claude-code") {
-    return "Claude Code coordination: discover peers with `greprag inbox watchers --json`, send to the exact session, and keep the Monitor armed for replies.";
+    return "Claude Code: at the merge/deploy gate, discover peers in the same repo and send one concise delivery notice to peers with ready or overlapping work.";
   }
   if (platform === "opencode") {
-    return "OpenCode coordination: use the GrepRAG project/session registry and session-targeted send; the plugin relay delivers replies.";
+    return "OpenCode: at the merge/deploy gate, use the GrepRAG project/session registry and send one concise delivery notice to peers with ready or overlapping work.";
   }
-  return "Coordination: discover same-project peers through this harness and use GrepRAG for cross-harness peers.";
+  return "At the merge/deploy gate, coordinate once with peers in the same repo who have ready or overlapping work.";
 }
 function buildDeliveryAnnounce(env) {
   if (!env.deliveryRepo)
     return null;
   const project = env.projectName?.trim() || "current repo";
   return [
-    `[DELIVERY CONTROL \u2014 ${project}]`,
-    "For full-goal code work, done means checkpointed, coordinated, integrated, pushed, deployed, and production-verified. Checkpoint each passing fix or feature.",
+    `[DELIVERY \u2014 ${project}]`,
+    "Commit useful, passing work.",
     coordinationLine(env.platform),
-    "Before merge, push, deploy, or release: elect one delivery owner. That owner includes every ready peer commit, resolves ordinary mission conflicts, and settles unclaimed dirt by adopt, rescue, or discard.",
-    "Use the canonical commit, deploy, and release skills plus this repo's delivery configuration. Never borrow a branch, remote, provider command, or verification rule from another repo.",
-    "A full-goal delivery mission already provisions ordinary repo-scoped commit, merge, push, deploy, and verification; do not wait for a second keyword."
+    "Include ready peer commits and clear known blockers, then merge to the default branch and deploy immediately. Missing replies and unfinished peer work do not block delivery.",
+    "Use this repo's delivery profile and verify production."
   ].join("\n");
 }
 var deliveryControlModule = {

package/package.json

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

package/dist/codex-checkpoint-hook.js

@@ -1,184 +0,0 @@
-"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');
-}