greprag 5.74.7 → 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-chip-hooks.js

@@ -64,9 +64,9 @@ function context(input) {
         `Worktree: ${(0, model_1.chipExecutionPath)(chip)}`,
         `Branch: ${chip.worktree.branch}`,
         `Parent session: ${chip.parent.sessionId || 'not recorded'}`,
-        `Finish by committing the durable result and reporting the commit artifact to the parent, including checks, caveats, and a Cleanup line naming archive/task, worktree, and branch actions. The optional host command is ${cli} codex chip report ${chip.id}.`,
+        `Finish by committing the durable result, then send the parent the commit artifact, checks, caveats, Cleanup line, and Archive: yes|no in the actual native task message. After delivery, Archive: yes means archive this child task yourself. The optional host command is ${cli} codex chip report ${chip.id}.`,
         // adr: adr/codex-landing-doctrine.md — one delivery owner, including FIX missions.
-        'Landing: the parent is the delivery owner for merge, archive, cleanup, and any profile-declared push/deploy/release — do not edit the parent checkout or independently cross those boundaries. A mission whose first line begins `FIX:` (emitted by `greprag fix spawn`) is writable in its isolated checkout/worktree and hands its verified checkpoint to that owner without a human approval gate. If no live parent exists and the chip carries the full-goal mission, it becomes delivery owner. `greprag fix spawn` only prints the mission; visible Codex task dispatch creates the isolated checkout/worktree.',
+        'Landing: the parent is the delivery owner for merge, post-merge branch/manifest bookkeeping, and any profile-declared push/deploy/release; the child owns routine archival of its own task after the terminal message is delivered. Do not edit the parent checkout or independently cross delivery boundaries. A mission whose first line begins `FIX:` (emitted by `greprag fix spawn`) is writable in its isolated checkout/worktree and hands its verified checkpoint to that owner without a human approval gate. If no live parent exists and the chip carries the full-goal mission, it becomes delivery owner. `greprag fix spawn` only prints the mission; visible Codex task dispatch creates the isolated checkout/worktree.',
     ];
     if ((0, model_1.chipMissionKind)(chip) === 'fix') {
         lines.push('Harness: Codex. Mission: visible native FIX chip with ordinary writable authority, not an internal subagent.', 'Scope: repair GrepRAG-owned harness surfaces in this checkout: load entries, skill templates, docs, hook context, CLI messages, and tests. Codex owns native task creation, worktrees, permissions, Git, and task lifecycle.', 'Own diagnosis, implementation, tests, commit, and parent report. Inspect Codex behavior only far enough to correct GrepRAG guidance or report a precise external blocker.', 'FIX peer handoff: if a peer offers to coordinate, integrate, rework, or take over a harness repair, hand off branch/commit, dirty files, checks, blockers, and caveats. Do not defend patch ownership; peers may take ownership within their assigned GrepRAG harness scope.', 'Visible delegation route: load `codex-chip-spawn` and create the child with `codex_app__create_thread` using the current project worktree target; load `chip-leader` for multi-chip seams. Never use `multi_agent_v1__spawn_agent` for a visible chip.');

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/codex-chip/help.js

@@ -21,11 +21,12 @@ quick chips, an explicit LEAD for multi-chip orchestration, and Chip A/B/C with
 optional ADVISOR orientation. FIX missions are visible one-friction tasks from
 \`greprag fix spawn\`: they select \`chip.fix\` and load mechanic doctrine.
 Every role is an ordinary writable session; roles only orient the work. Native Codex chips commit their durable
-result, then reply to the LEAD in the native task thread with status, commit
-hash, checks, caveats, cleanup parameters, and archive clearance. Include a
-\`Cleanup:\` line naming archive/task, worktree, and branch actions. Use
-\`Clearance: safe to archive\` or \`Clearance: keep open because ...\`. The
-parent integrates, archives when safe, and cleans up the task. Peer review is a
-separate explicit review chip/session when needed. The
+result, then use the native task-message channel to send the LEAD status,
+commit hash, checks, caveats, cleanup parameters, and
+\`Archive: yes\` or \`Archive: no — <reason>\`. The archive decision must be in
+that sent message, not only the child's final response. After delivery,
+\`Archive: yes\` means the child archives its own task; the parent integrates
+the commit and handles post-merge branch bookkeeping. Peer review is a separate
+explicit review chip/session when needed. The
 \`greprag codex chip report\` command remains host bookkeeping for explicit
 CLI-managed chips, not mandatory native Codex completion ceremony.`;

package/dist/commands/codex-chip/prompt.js

@@ -20,7 +20,7 @@ function chipPrompt(manifest, _cliCommand = 'greprag') {
         ? `- After setup and bootstrap succeed, reply to the LEAD in the native Codex task thread: \`IN-FLIGHT: ${(0, model_1.chipTitle)(manifest)} — setup complete; work started\`. If setup fails, reply \`BLOCKED\` with the exact failure instead.\n`
         : '';
     const reportInstruction = native
-        ? '- Commit the durable result, then reply to the LEAD in the native Codex task thread with `DONE` or `BLOCKED`, commit hash if any, checks, material caveats, cleanup parameters, and archive clearance.'
+        ? '- Commit the durable result, then use the native Codex task-message tool to send the LEAD `DONE` or `BLOCKED`, commit hash if any, checks, material caveats, cleanup parameters, and `Archive: yes` or `Archive: no — <reason>`. Do not substitute a final response in your own task.'
         : '- Commit the completed durable result, including report-only artifacts, then run `greprag codex chip report <id> --summary "<result>" --check "<check>"`. The report must carry the commit artifact back to the parent.';
     return `${(0, model_1.chipTitle)(manifest)}
 
@@ -37,7 +37,7 @@ ${manifest.task}
 
 Report when done:
 ${reportInstruction}
-- Include a \`Cleanup:\` line naming the archive/task action, worktree action, and branch action. Use \`Cleanup: archive task; Codex may prune managed worktree; parent may delete branch after merge\` when done, or \`Cleanup: keep task/worktree/branch because ...\` when anything must remain open.
-- Include \`Clearance: safe to archive\` when no follow-up is needed, or \`Clearance: keep open because ...\` when the lead should not archive yet.
-- Landing: do not independently merge, push, deploy, or delete the worktree — the parent is the delivery owner and integrates the result, follows the repo profile, and cleans up the task. If this task begins \`FIX:\` (a fix-spawn mission), hand the verified checkpoint to that owner without a human approval gate. If no live parent exists and this task carries the full-goal mission, become delivery owner. \`greprag fix spawn\` only prints the mission; visible Codex task dispatch creates the isolated checkout/worktree.`;
+- Include a \`Cleanup:\` line naming the task, worktree, and branch actions. When done use \`Cleanup: child archives own task; Codex may prune managed worktree; parent may delete branch after merge\`; when anything must remain open use \`Cleanup: keep task/worktree/branch because ...\`.
+- Put the archive decision in the actual message sent to the LEAD: \`Archive: yes\` or \`Archive: no — <reason>\`. After that message is delivered, \`Archive: yes\` means call \`set_thread_archived\` for your own task; \`Archive: no\` means leave it open. Never make the parent perform routine child-task archival.
+- Landing: do not independently merge, push, deploy, or manually delete the worktree — the parent is the delivery owner and integrates the result, follows the repo profile, and deletes the branch after merge. If this task begins \`FIX:\` (a fix-spawn mission), hand the verified checkpoint to that owner without a human approval gate. If no live parent exists and this task carries the full-goal mission, become delivery owner. \`greprag fix spawn\` only prints the mission; visible Codex task dispatch creates the isolated checkout/worktree.`;
 }

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.7",
+  "version": "5.74.9",
   "description": "GrepRAG — agent memory for Claude Code, Codex, and OpenCode.",
   "main": "dist/index.js",
   "bin": {

package/skill/greprag/docs/codex-chip.md

@@ -20,13 +20,13 @@ child sends the native parent-task reply
 `IN-FLIGHT: <exact title> — setup complete; work started`; setup failure sends
 `BLOCKED` with the exact failure. It has no lease, read-only, mandatory
 nested-goal, or nonce/ACK requirement. Completion is another native
-parent-child task reply: commit the durable result, then reply to the LEAD with
-`DONE` or `BLOCKED`, commit hash if any, checks, caveats, and
-cleanup parameters (`Cleanup: archive task; Codex may prune managed worktree;
-parent may delete branch after merge` or `Cleanup: keep task/worktree/branch
-because ...`) plus archive clearance (`Clearance: safe to archive` or
-`Clearance: keep open because ...`). The lead remains responsible for
-integrating, archiving, and cleanup.
+parent-child task message: commit the durable result, then send the LEAD
+`DONE` or `BLOCKED`, commit hash if any, checks, caveats, cleanup parameters,
+and `Archive: yes` or `Archive: no — <reason>` in the actual sent message, not
+only the child's final response. After successful delivery, `Archive: yes`
+means the child archives its own Codex task; `Archive: no` leaves it open. The
+lead remains responsible for integration and post-merge branch bookkeeping,
+not routine child-task archival.
 Review is a separate explicit review chip/session when the lead asks for it.
 FIX landing (adr/codex-landing-doctrine.md): a mission whose first line
 begins `FIX:` (from `greprag fix spawn`) uses the handoff's detected

package/skill/templates/codex-chip-spawn.md

@@ -133,27 +133,32 @@ Paste this at the end of the child prompt.
 
 ```text
 ## Report when done
-Commit the durable result first. Then reply to the LEAD in the native Codex task
-thread with `DONE` or `BLOCKED`, commit hash if any, concise result, checks,
-caveats, cleanup parameters, and archive clearance.
+Commit the durable result first. Then use the native Codex task-message tool to
+send the LEAD `DONE` or `BLOCKED`, commit hash if any, concise result, checks,
+material caveats, cleanup parameters, and the archive decision. Do not
+substitute a final response in your own task: the lifecycle report must be the
+actual message sent to the LEAD.
 
 Include one cleanup line:
-`Cleanup: archive task; Codex may prune managed worktree; parent may delete branch after merge`
+`Cleanup: child archives own task; Codex may prune managed worktree; parent may delete branch after merge`
 or
-`Cleanup: archive task; local mode has no worktree or branch to prune`
+`Cleanup: child archives own task; local mode has no worktree or branch to prune`
 or
 `Cleanup: keep task/worktree/branch because ...`
 
-Include one clearance line:
-`Clearance: safe to archive`
+Include one archive line in that same sent message:
+`Archive: yes`
 or
-`Clearance: keep open because ...`
+`Archive: no — <reason>`
 
-In worktree mode, do not merge, push, deploy, or delete the worktree. In local
-mode, do not archive the task or perform unrelated project cleanup. The parent
-decides whether to archive and cleans up from the child's cleanup parameters.
-If review is needed, the parent spawns a fresh review chip/session with an
-explicit review brief.
+After the message is delivered, `Archive: yes` means call
+`set_thread_archived` for your own task; `Archive: no` means leave it open. Do
+not make the parent perform routine child-task archival.
+
+Do not merge, push, deploy, or manually delete the worktree. The parent
+integrates the commit and may delete the branch after merge; Codex owns managed
+worktree pruning. If review is needed, the parent creates a fresh review
+chip/session.
 ```
 
 ## FIX contract
@@ -188,12 +193,13 @@ require a writable task.
 
 ## Parent cleanup
 
-After the parent integrates/reviews and archives a completed worktree task, it
-may run:
+After integration, the parent may clear remaining GrepRAG manifest/branch
+bookkeeping with:
 
 ```bash
 greprag codex chip cleanup <id> --native-archived
 ```
 
-Codex owns the managed-worktree lifecycle. The child does not prune it.
-Local-mode FIX tasks have no worktree or branch to prune; archive the task only.
+The child archives its own task after sending `Archive: yes`; the parent does
+not perform routine child-task archival. Codex owns managed-worktree pruning.
+Local-mode FIX tasks have no worktree or branch to prune.