codex-orchestrator 0.1.39 → 0.1.41

package/dist/src/runner/plan-auto-command.js

@@ -1,4 +1,5 @@
 import { mkdir, readFile } from 'node:fs/promises';
+import { hostname as osHostname } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { CodexCommandAdapter } from '../codex/command-adapter.js';
 import { resolveBaseBranch } from '../git/base-branch.js';
@@ -18,8 +19,9 @@ import { collectExecutableChildBatches, persistAutonomousChildNode, readAutonomo
 import { runImplementationPublishabilityCheck } from './local-execution-session.js';
 import { RunnerLifecycleEventStore } from './lifecycle-events.js';
 import { RunnerStateStore } from './local-state.js';
+import { classifyPlanAutoBlockedChildRecovery, classifyPlanAutoCompletedChildRecovery, classifyPlanAutoParentRecovery, } from './plan-auto-recovery.js';
 import { buildIssueTreeChildPrompt, buildPlanAutoPrompt, sessionPromptPath, sessionReportPath, writeDurablePrompt, } from './prompt.js';
-import { maxReworkAttemptsForReasons, shouldRequestImplementationRework } from './rework-policy.js';
+import { decideImplementationRework } from './rework-policy.js';
 import { evaluateParentRiskRoutingGate } from './review-gates.js';
 import { buildBlockedHandoffEvidence, buildPromotionAsBlockedHandoffEvidence, buildReviewReadyHandoffEvidence, } from './runner-handoff-decision.js';
 import { sessionLogPath } from './run-log.js';
@@ -28,11 +30,13 @@ class ChildExecutionBlockedError extends Error {
     durableRunSummary;
     freshContextReview;
     acceptanceProof;
-    constructor(message, durableRunSummary, freshContextReview, acceptanceProof) {
+    reworkAttempts;
+    constructor(message, durableRunSummary, freshContextReview, acceptanceProof, reworkAttempts) {
         super(message);
         this.durableRunSummary = durableRunSummary;
         this.freshContextReview = freshContextReview;
         this.acceptanceProof = acceptanceProof;
+        this.reworkAttempts = reworkAttempts;
     }
 }
 export async function runPlanAutoCommand(options) {
@@ -49,16 +53,36 @@ export async function runPlanAutoCommand(options) {
     if (!parentIssue) {
         throw new Error(`Issue #${options.issueNumber} was not found`);
     }
+    const branchName = renderBranchTemplate(config.branches.issueTree, { parentIssueNumber: options.issueNumber });
+    const worktreePath = join(targetRoot, config.runner.workspaceRoot, `tree-${options.issueNumber}`);
+    const store = new RunnerStateStore(targetRoot, config);
+    const parentRecovery = await classifyPlanAutoParentRecovery({
+        targetRoot,
+        config,
+        parentIssue,
+        branchName,
+        worktreePath,
+        baseSha: resolvedBase.sha,
+        state: await store.load(),
+        git,
+        now,
+        hostname: options.hostname,
+        processProbe: options.processProbe,
+    });
     const decision = discoverIssueWork([parentIssue], config)[0];
-    if (!decision || decision.kind !== 'eligible' || decision.mode !== 'plan-parent') {
+    const parentLabels = new Set(parentIssue.labels.map((label) => label.name));
+    const alreadyRunningPlanParent = decision?.kind === 'skipped'
+        && decision.reasonCode === 'already-running'
+        && parentIssue.state === 'OPEN'
+        && parentLabels.has(config.github.labels.planAuto.name)
+        && !parentLabels.has(config.github.labels.child.name);
+    if (!decision || !((decision.kind === 'eligible' && decision.mode === 'plan-parent') || alreadyRunningPlanParent)) {
         const reason = decision?.kind === 'skipped' ? decision.reason : 'not agent:plan-auto';
         throw new Error(`Issue #${options.issueNumber} is not eligible for agent:plan-auto planning: ${reason}`);
     }
     const workflowPrompts = await readPlanWorkflowPrompts(targetRoot, config);
     const issueTreeWorkflowPrompt = await readIssueTreeWorkflowPrompt(targetRoot, config);
     const acceptanceProofWorkflowPrompt = await readAcceptanceProofWorkflowPrompt(targetRoot, config);
-    const branchName = renderBranchTemplate(config.branches.issueTree, { parentIssueNumber: options.issueNumber });
-    const worktreePath = join(targetRoot, config.runner.workspaceRoot, `tree-${options.issueNumber}`);
     let promptPath = '';
     let reportPath = '';
     let logPath = '';
@@ -66,19 +90,38 @@ export async function runPlanAutoCommand(options) {
     let parentSnapshotPath = '';
     const childIssues = [];
     let pullRequest;
-    let store;
     const executionResults = [];
     const events = new RunnerLifecycleEventStore(targetRoot, config);
     const buildBase = () => baseResult(options.issueNumber, branchName, worktreePath, promptPath, reportPath, logPath, childIssues, sessionId, parentSnapshotPath);
-    await claimIssue(issueAdapter, config, options.issueNumber, 'plan-parent', now);
+    if (parentRecovery.kind === 'hard-block') {
+        return finishPlanBlocked(issueAdapter, config, events, buildBase(), [parentRecovery.reason], childIssues, parentRecovery.marker);
+    }
+    if (alreadyRunningPlanParent && parentRecovery.kind !== 'resume-parent') {
+        return finishPlanBlocked(issueAdapter, config, events, buildBase(), ['parent recovery requires runner-owned metadata for running parent'], childIssues, `plan-auto-recovery-blocked parent=${options.issueNumber} reason=missing-runner-owned-metadata`);
+    }
+    if (!alreadyRunningPlanParent) {
+        await claimIssue(issueAdapter, config, options.issueNumber, 'plan-parent', now);
+    }
     try {
-        await git.createIssueWorktree({
-            targetRoot,
-            workspacePath: worktreePath,
-            branchName,
-            baseBranch: resolvedBase.sha,
-            requiredBaseSha: resolvedBase.sha,
-        });
+        if (parentRecovery.kind === 'resume-parent') {
+            await git.ensureIssueWorktree({
+                targetRoot,
+                workspacePath: worktreePath,
+                branchName,
+                baseBranch: resolvedBase.sha,
+                requiredBaseSha: resolvedBase.sha,
+                allowResume: true,
+            });
+        }
+        else {
+            await git.createIssueWorktree({
+                targetRoot,
+                workspacePath: worktreePath,
+                branchName,
+                baseBranch: resolvedBase.sha,
+                requiredBaseSha: resolvedBase.sha,
+            });
+        }
         sessionId = `plan-${options.issueNumber}-${formatSessionTimestamp(now)}`;
         promptPath = sessionPromptPath({ targetRoot, config, issueNumber: options.issueNumber, sessionId });
         reportPath = sessionReportPath({ targetRoot, config, issueNumber: options.issueNumber, sessionId });
@@ -130,7 +173,6 @@ export async function runPlanAutoCommand(options) {
             summary: 'Starting parent planning Codex session.',
             artifacts: sessionArtifacts(promptPath, reportPath, logPath, snapshot.path),
         });
-        store = new RunnerStateStore(targetRoot, config);
         await store.upsertRun({
             issueNumber: options.issueNumber,
             mode: 'plan-parent',
@@ -143,6 +185,10 @@ export async function runPlanAutoCommand(options) {
             retryCount: 0,
             createdAt: now.toISOString(),
             updatedAt: now.toISOString(),
+            ownerPid: process.pid,
+            host: (options.hostname ?? osHostname)(),
+            leaseUpdatedAt: now.toISOString(),
+            baseSha: resolvedBase.sha,
         });
         const beforeHead = await git.getHead(worktreePath);
         let codexResult;
@@ -196,7 +242,60 @@ export async function runPlanAutoCommand(options) {
             childIssues.push(persisted);
         }
         const childNodes = await readAutonomousChildNodes(issueAdapter, config, options.issueNumber, childIssues);
-        const batches = collectExecutableChildBatches(childNodes, config);
+        const childRecoveryState = await store.load();
+        const childRecoveryDecisions = await Promise.all(childNodes.map(async (child) => {
+            const completed = await classifyPlanAutoCompletedChildRecovery({
+                targetRoot,
+                config,
+                parentIssueNumber: options.issueNumber,
+                parentBranchName: branchName,
+                child,
+                state: childRecoveryState,
+                git,
+            });
+            return completed.kind === 'execute-child'
+                ? classifyPlanAutoBlockedChildRecovery({
+                    targetRoot,
+                    config,
+                    parentIssueNumber: options.issueNumber,
+                    child,
+                    state: childRecoveryState,
+                    git,
+                })
+                : completed;
+        }));
+        const recoveredStableIds = [];
+        const resumableBlockedStableIds = [];
+        const childRecoveryByStableId = new Map();
+        for (const decision of childRecoveryDecisions) {
+            if (decision.kind === 'hard-block') {
+                return finishPlanBlocked(issueAdapter, config, events, buildBase(), [decision.reason], childIssues, decision.marker);
+            }
+            if (decision.kind === 'recovered-completed-child') {
+                recoveredStableIds.push(decision.child.metadata.stableId);
+                executionResults.push({
+                    child: decision.child,
+                    branchName: decision.branchName,
+                    worktreePath: decision.worktreePath,
+                    promptPath: decision.promptPath,
+                    reportPath: decision.reportPath,
+                    logPath: decision.logPath,
+                    changedFiles: decision.changedFiles,
+                    validation: decision.validation,
+                    artifacts: [],
+                    commits: [],
+                    skippedChecks: decision.skippedChecks,
+                    residualRisks: decision.residualRisks,
+                    durableRunSummary: decision.durableRunSummary,
+                    recovered: true,
+                });
+            }
+            else if (decision.kind === 'resume-child-rework') {
+                resumableBlockedStableIds.push(decision.child.metadata.stableId);
+                childRecoveryByStableId.set(decision.child.metadata.stableId, decision);
+            }
+        }
+        const batches = collectExecutableChildBatches(childNodes, config, recoveredStableIds, resumableBlockedStableIds);
         if (!batches.ok) {
             return finishPlanBlocked(issueAdapter, config, events, base, batches.errors, childIssues);
         }
@@ -216,6 +315,7 @@ export async function runPlanAutoCommand(options) {
                 acceptanceProofWorkflowPrompt,
                 now,
                 events,
+                recovery: childRecoveryByStableId.get(child.metadata.stableId),
             })));
             const failures = [];
             for (const [index, result] of settled.entries()) {
@@ -266,7 +366,7 @@ export async function runPlanAutoCommand(options) {
                 executionResults.push(childResult);
             }
         }
-        const finalValidation = await runConfiguredChecks(config, worktreePath, shellExecutor, []);
+        const finalValidation = await runConfiguredChecks(config, worktreePath, shellExecutor, [], { phase: 'parent-integration' });
         const failedFinalValidation = finalValidation.filter((line) => line.status === 'failed');
         if (failedFinalValidation.length > 0) {
             await blockCompletedChildren(issueAdapter, config, store, options.issueNumber, executionResults, 'Parent integration configured checks failed before publication.', worktreePath);
@@ -331,7 +431,7 @@ export async function runPlanAutoCommand(options) {
         if (pullRequest) {
             throw new Error(`Issue-tree execution failed after draft PR creation (${pullRequest.url}); not marking parent blocked: ${message}`);
         }
-        if (store && executionResults.length > 0) {
+        if (executionResults.length > 0) {
             await blockCompletedChildren(issueAdapter, config, store, options.issueNumber, executionResults, `Parent publication failed before review handoff: ${message}`, worktreePath);
         }
         return finishPlanBlocked(issueAdapter, config, events, buildBase(), [message], childIssues);
@@ -379,77 +479,76 @@ async function executeChild(input) {
     const childIssueNumber = input.child.issue.number;
     const branchName = `codex/tree-${input.parentIssue.number}-issue-${childIssueNumber}`;
     const worktreePath = join(input.targetRoot, input.config.runner.workspaceRoot, `tree-${input.parentIssue.number}-issue-${childIssueNumber}`);
-    const sessionId = `tree-${input.parentIssue.number}-issue-${childIssueNumber}-${formatSessionTimestamp(input.now)}`;
-    const promptPath = sessionPromptPath({
-        targetRoot: input.targetRoot,
-        config: input.config,
-        issueNumber: childIssueNumber,
-        sessionId,
-    });
-    const reportPath = sessionReportPath({
-        targetRoot: input.targetRoot,
-        config: input.config,
-        issueNumber: childIssueNumber,
-        sessionId,
-    });
-    const logPath = sessionLogPath({
-        targetRoot: input.targetRoot,
-        config: input.config,
-        issueNumber: childIssueNumber,
-        sessionId,
-    });
-    const isolatedHomePath = sessionCodexHomePath({ targetRoot: input.targetRoot, sessionId });
     const store = new RunnerStateStore(input.targetRoot, input.config);
-    await input.git.createIssueWorktree({
-        targetRoot: input.targetRoot,
-        workspacePath: worktreePath,
-        branchName,
-        baseBranch: input.parentBranchName,
-    });
-    await input.issueAdapter.addLabels(childIssueNumber, [input.config.github.labels.running.name]);
-    await input.issueAdapter.postComment(childIssueNumber, `codex-orchestrator: claimed #${childIssueNumber} for tree-child autonomous work under #${input.parentIssue.number} at ${input.now.toISOString()}.`);
-    await mkdir(dirname(reportPath), { recursive: true });
-    await mkdir(isolatedHomePath, { recursive: true });
-    const promptText = buildIssueTreeChildPrompt({
-        parentIssue: input.parentIssue,
-        childIssue: input.child.issue,
-        config: input.config,
-        workflowPromptText: input.issueTreeWorkflowPrompt,
-        childMetadata: input.child.metadata,
-        dependencyIssues: input.dependencyIssues,
-        promptPath,
-        reportPath,
-        branchName,
-        worktreePath,
-    });
-    await writeDurablePrompt({
-        targetRoot: input.targetRoot,
-        config: input.config,
-        issueNumber: childIssueNumber,
-        sessionId,
-        promptText,
-    });
-    await store.upsertRun({
-        issueNumber: childIssueNumber,
-        parentIssueNumber: input.parentIssue.number,
-        mode: 'tree-child',
-        workspacePath: worktreePath,
-        sessionId,
-        branchName,
-        promptPath,
-        reportPath,
-        logPath,
-        retryCount: 0,
-        createdAt: input.now.toISOString(),
-        updatedAt: input.now.toISOString(),
-    });
+    let sessionId = '';
+    let promptPath = '';
+    let reportPath = '';
+    let logPath = '';
+    let snapshotPath = '';
+    if (input.recovery) {
+        await input.git.ensureIssueWorktree({
+            targetRoot: input.targetRoot,
+            workspacePath: worktreePath,
+            branchName,
+            baseBranch: input.parentBranchName,
+            allowResume: true,
+        });
+        await input.issueAdapter.removeLabels(childIssueNumber, [input.config.github.labels.blocked.name]);
+        await input.issueAdapter.addLabels(childIssueNumber, [input.config.github.labels.running.name]);
+    }
+    else {
+        await input.git.createIssueWorktree({
+            targetRoot: input.targetRoot,
+            workspacePath: worktreePath,
+            branchName,
+            baseBranch: input.parentBranchName,
+        });
+        await input.issueAdapter.addLabels(childIssueNumber, [input.config.github.labels.running.name]);
+        await input.issueAdapter.postComment(childIssueNumber, `codex-orchestrator: claimed #${childIssueNumber} for tree-child autonomous work under #${input.parentIssue.number} at ${input.now.toISOString()}.`);
+    }
     let publishability;
-    let rework;
+    let rework = input.recovery?.rework;
+    const reworkAttempts = [];
     const maxReworkAttempts = Math.max(input.config.loopPolicy.rework.maxAttempts, input.config.reviewGates.acceptanceProof.maxIterations - 1);
-    for (let attempt = 0; attempt <= maxReworkAttempts; attempt++) {
+    const firstAttempt = input.recovery ? input.recovery.rework.attempt : 0;
+    for (let attempt = firstAttempt; attempt <= maxReworkAttempts; attempt++) {
         const attemptNow = new Date(input.now.getTime() + attempt);
+        sessionId = `tree-${input.parentIssue.number}-issue-${childIssueNumber}-${formatSessionTimestamp(attemptNow)}${attempt === 0 ? '' : `-attempt-${attempt}`}`;
+        promptPath = sessionPromptPath({
+            targetRoot: input.targetRoot,
+            config: input.config,
+            issueNumber: childIssueNumber,
+            sessionId,
+        });
+        reportPath = sessionReportPath({
+            targetRoot: input.targetRoot,
+            config: input.config,
+            issueNumber: childIssueNumber,
+            sessionId,
+        });
+        logPath = sessionLogPath({
+            targetRoot: input.targetRoot,
+            config: input.config,
+            issueNumber: childIssueNumber,
+            sessionId,
+        });
+        const isolatedHomePath = sessionCodexHomePath({ targetRoot: input.targetRoot, sessionId });
+        await mkdir(dirname(reportPath), { recursive: true });
+        await mkdir(isolatedHomePath, { recursive: true });
+        const promptText = buildIssueTreeChildPrompt({
+            parentIssue: input.parentIssue,
+            childIssue: input.child.issue,
+            config: input.config,
+            workflowPromptText: input.issueTreeWorkflowPrompt,
+            childMetadata: input.child.metadata,
+            dependencyIssues: input.dependencyIssues,
+            promptPath,
+            reportPath,
+            branchName,
+            worktreePath,
+        });
         const attemptPromptText = rework
-            ? `${promptText}\n\n## Rework Request\nThis is an automatic rework attempt (#${rework.attempt}). Continue from the current worktree state; do not start over.\nThe previous attempt was blocked for these reasons:\n${rework.blockedReasons.map((reason) => `- ${reason}`).join('\n')}\nAddress the blockers, then produce a fresh completion report JSON for the runner.`
+            ? `${promptText}\n\n## Rework Request\nThis is an automatic rework attempt (#${rework.attempt}). Continue from the current worktree state; do not start over.\nThe previous attempt was blocked for these reasons:\n${rework.blockedReasons.map((reason) => `- ${reason}`).join('\n')}\n${rework.disableOptionalFigmaMcp ? 'Optional Figma MCP failed in the previous attempt. Continue without optional Figma MCP access unless the issue explicitly requires Figma.\n' : ''}Address the blockers, then produce a fresh completion report JSON for the runner.`
             : promptText;
         await writeDurablePrompt({
             targetRoot: input.targetRoot,
@@ -478,6 +577,23 @@ async function executeChild(input) {
             blockedBy: [],
             createdAt: attemptNow,
         });
+        snapshotPath = snapshot.path;
+        await store.upsertRun({
+            issueNumber: childIssueNumber,
+            parentIssueNumber: input.parentIssue.number,
+            mode: 'tree-child',
+            workspacePath: worktreePath,
+            sessionId,
+            branchName,
+            promptPath,
+            reportPath,
+            logPath,
+            retryCount: attempt,
+            createdAt: input.now.toISOString(),
+            updatedAt: attemptNow.toISOString(),
+            attemptStartedAt: attemptNow.toISOString(),
+            snapshotPath,
+        });
         await safeAppendEvent(input.events, {
             timestamp: attemptNow,
             issueNumber: childIssueNumber,
@@ -487,7 +603,7 @@ async function executeChild(input) {
             phase: 'tree-child',
             status: 'started',
             summary: rework ? `Starting tree-child rework attempt #${rework.attempt}.` : 'Starting tree-child Codex session.',
-            artifacts: sessionArtifacts(promptPath, reportPath, logPath, snapshot.path),
+            artifacts: sessionArtifacts(promptPath, reportPath, logPath, snapshotPath),
         });
         const beforeHead = await input.git.getHead(worktreePath);
         let codexResult;
@@ -505,6 +621,7 @@ async function executeChild(input) {
                 branchName,
                 phase: 'tree-child',
                 logPath,
+                disableOptionalFigmaMcp: rework?.disableOptionalFigmaMcp,
             });
         }
         finally {
@@ -538,12 +655,49 @@ async function executeChild(input) {
                 }),
             },
         });
-        if (publishability.status === 'blocked'
-            && attempt < maxReworkAttemptsForReasons(publishability.reasons, input.config)
-            && shouldRequestImplementationRework(publishability.reasons, input.config)) {
-            rework = { attempt: attempt + 1, blockedReasons: publishability.reasons };
-            await mkdir(isolatedHomePath, { recursive: true });
-            continue;
+        if (publishability.status === 'blocked') {
+            const reworkDecision = decideImplementationRework({
+                reasons: publishability.reasons,
+                config: input.config,
+                attempt,
+            });
+            reworkAttempts.push({
+                attempt,
+                maxAttempts: 'maxAttempts' in reworkDecision ? reworkDecision.maxAttempts : undefined,
+                decisionKind: reworkDecision.kind,
+                reasons: publishability.reasons,
+                promptPath,
+                reportPath,
+                logPath,
+                snapshotPath,
+            });
+            if (reworkDecision.kind === 'retry') {
+                rework = reworkDecision.rework;
+                await safeAppendEvent(input.events, {
+                    timestamp: attemptNow,
+                    issueNumber: childIssueNumber,
+                    parentIssueNumber: input.parentIssue.number,
+                    mode: 'tree-child',
+                    sessionId,
+                    phase: 'tree-child',
+                    status: 'needs-rework',
+                    summary: `Runner scheduled tree-child rework attempt #${reworkDecision.nextAttempt}.`,
+                    artifacts: sessionArtifacts(promptPath, reportPath, logPath, snapshotPath),
+                });
+                await mkdir(isolatedHomePath, { recursive: true });
+                continue;
+            }
+            await safeAppendEvent(input.events, {
+                timestamp: attemptNow,
+                issueNumber: childIssueNumber,
+                parentIssueNumber: input.parentIssue.number,
+                mode: 'tree-child',
+                sessionId,
+                phase: 'tree-child',
+                status: 'blocked',
+                summary: `Runner rework decision: ${reworkDecision.kind}.`,
+                artifacts: sessionArtifacts(promptPath, reportPath, logPath, snapshotPath),
+            });
         }
         break;
     }
@@ -572,13 +726,14 @@ async function executeChild(input) {
             logPath,
             reportPath,
             acceptanceProof: evidence.acceptanceProof,
+            reworkAttempts,
         });
         const message = [
             'Child requested promotion instead of completing issue-tree work.',
             promotion ? `Reason: ${promotion.reason}` : undefined,
             promotion ? `Evidence: ${promotion.evidence.join(', ')}` : undefined,
         ].filter(Boolean).join(' ');
-        throw new ChildExecutionBlockedError(message, durableRunSummary, undefined, evidence.acceptanceProof);
+        throw new ChildExecutionBlockedError(message, durableRunSummary, undefined, evidence.acceptanceProof, reworkAttempts);
     }
     if (publishability.status === 'blocked') {
         const evidence = buildBlockedHandoffEvidence({
@@ -600,8 +755,9 @@ async function executeChild(input) {
             logPath,
             reportPath,
             acceptanceProof: evidence.acceptanceProof,
+            reworkAttempts,
         });
-        throw new ChildExecutionBlockedError(evidence.blockers.join('; '), durableRunSummary, undefined, evidence.acceptanceProof);
+        throw new ChildExecutionBlockedError(evidence.blockers.join('; '), durableRunSummary, undefined, evidence.acceptanceProof, reworkAttempts);
     }
     const freshContextReview = await runFreshContextReviewIfEnabled({
         targetRoot: input.targetRoot,
@@ -635,8 +791,9 @@ async function executeChild(input) {
             logPath,
             reportPath,
             acceptanceProof: evidence.acceptanceProof,
+            reworkAttempts,
         });
-        throw new ChildExecutionBlockedError(evidence.blockers.join('; '), durableRunSummary, freshContextReview, evidence.acceptanceProof);
+        throw new ChildExecutionBlockedError(evidence.blockers.join('; '), durableRunSummary, freshContextReview, evidence.acceptanceProof, reworkAttempts);
     }
     const evidence = buildReviewReadyHandoffEvidence({
         publishability,
@@ -659,6 +816,7 @@ async function executeChild(input) {
         logPath,
         reportPath,
         acceptanceProof: evidence.acceptanceProof,
+        reworkAttempts,
     });
     return {
         child: input.child,
@@ -693,6 +851,7 @@ async function blockFailedBatch(issueAdapter, config, parentIssueNumber, failure
             details: ['Worktree preserved for maintainer inspection.'],
             freshContextReview: failure.freshContextReview,
             durableRunSummary: failure.durableRunSummary,
+            reworkAttempts: failure.reworkAttempts,
             acceptanceProof: failure.acceptanceProof,
         }));
     }
@@ -747,6 +906,10 @@ async function handleMergeConflict(git, issueAdapter, config, parentIssueNumber,
 }
 async function markCompletedChildrenReviewReady(issueAdapter, config, store, parentIssueNumber, childResults) {
     for (const childResult of childResults) {
+        if (childResult.recovered) {
+            await store.removeRun(childResult.child.issue.number);
+            continue;
+        }
         await issueAdapter.removeLabels(childResult.child.issue.number, [config.github.labels.running.name]);
         await issueAdapter.addLabels(childResult.child.issue.number, [config.github.labels.review.name]);
         await issueAdapter.postComment(childResult.child.issue.number, buildChildReviewReport({ parentIssueNumber, result: childResult }));
@@ -755,6 +918,9 @@ async function markCompletedChildrenReviewReady(issueAdapter, config, store, par
 }
 async function blockCompletedChildren(issueAdapter, config, store, parentIssueNumber, childResults, reason, parentWorktreePath) {
     for (const result of childResults) {
+        if (result.recovered) {
+            continue;
+        }
         await issueAdapter.removeLabels(result.child.issue.number, [config.github.labels.running.name]);
         await issueAdapter.addLabels(result.child.issue.number, [config.github.labels.blocked.name]);
         await issueAdapter.postComment(result.child.issue.number, buildChildBlockedReport({
@@ -771,16 +937,20 @@ async function blockCompletedChildren(issueAdapter, config, store, parentIssueNu
         await store.removeRun(result.child.issue.number);
     }
 }
-async function finishPlanBlocked(issueAdapter, config, events, result, reasons, mutatedChildren) {
-    const reportComment = buildParentBlockedReport({
+async function finishPlanBlocked(issueAdapter, config, events, result, reasons, mutatedChildren, commentMarker) {
+    const reportBody = buildParentBlockedReport({
         parentIssueNumber: result.parentIssueNumber,
         reasons,
         logPath: result.logPath,
         mutatedChildren,
     });
+    const reportComment = commentMarker ? `<!-- codex-orchestrator:${commentMarker} -->\n${reportBody}` : reportBody;
     await issueAdapter.removeLabels(result.parentIssueNumber, [config.github.labels.running.name]);
     await issueAdapter.addLabels(result.parentIssueNumber, [config.github.labels.blocked.name]);
-    await issueAdapter.postComment(result.parentIssueNumber, reportComment);
+    const currentIssue = commentMarker ? await issueAdapter.getIssue(result.parentIssueNumber) : undefined;
+    if (!commentMarker || !currentIssue?.comments.some((comment) => comment.body.includes(commentMarker))) {
+        await issueAdapter.postComment(result.parentIssueNumber, reportComment);
+    }
     await safeAppendEvent(events, {
         issueNumber: result.parentIssueNumber,
         mode: 'plan-parent',