codex-orchestrator 0.1.19 → 0.1.21

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

@@ -5,15 +5,16 @@ import { GitMergeConflictError, GitWorktreeManager, renderBranchTemplate } from
 import { GhCliIssueAdapter } from '../github/gh-issue-adapter.js';
 import { GhCliPullRequestAdapter } from '../github/gh-pull-request-adapter.js';
 import { defaultShellCommandExecutor } from '../process/command.js';
-import { bulletList, formatSessionTimestamp, readRunnerConfig } from './command-utils.js';
+import { formatSessionTimestamp, readRunnerConfig, runConfiguredChecks, } from './command-utils.js';
+import { buildChildBlockedReport, buildChildReviewReport, buildIssueTreePullRequestBody, buildIssueTreeReviewReport, buildParentBlockedReport, } from './handoff-evidence.js';
+import { readPlanAutoCompletionReport, } from './completion-report.js';
 import { claimIssue, discoverIssueWork } from './issue-state-machine.js';
-import { collectExecutableChildBatches, ensureAutonomousChildBody, isAutonomousChildOfParent, parseAutonomousChildMetadata, topologicalPlanNodes, } from './issue-tree.js';
+import { collectExecutableChildBatches, persistAutonomousChildNode, readAutonomousChildNodes, topologicalPlanNodes, } from './issue-tree.js';
+import { runImplementationPublishabilityCheck } from './local-execution-session.js';
 import { RunnerStateStore } from './local-state.js';
-import { buildIssueTreeChildPrompt, buildPlanAutoPrompt, readScopedCompletionReport, readPlanAutoCompletionReport, sessionPromptPath, sessionReportPath, writeDurablePrompt, } from './prompt.js';
-import { evaluateReviewGates } from './review-gates.js';
-import { validateChangedPaths, validateCompletionReportSafety, validateNoAgentOwnedGitPublication, } from './safety.js';
+import { buildIssueTreeChildPrompt, buildPlanAutoPrompt, sessionPromptPath, sessionReportPath, writeDurablePrompt, } from './prompt.js';
+import { sessionLogPath } from './run-log.js';
 import { cleanupSessionCodexHome, sessionCodexHomePath } from './session-home.js';
-import { runRunnerVisualProof } from './visual-proof-runner.js';
 export async function runPlanAutoCommand(options) {
     const targetRoot = resolve(options.targetRoot);
     const now = options.now ?? new Date();
@@ -38,8 +39,11 @@ export async function runPlanAutoCommand(options) {
     const worktreePath = join(targetRoot, config.runner.workspaceRoot, `tree-${options.issueNumber}`);
     let promptPath = '';
     let reportPath = '';
+    let logPath = '';
     const childIssues = [];
     let pullRequest;
+    let store;
+    const executionResults = [];
     await claimIssue(issueAdapter, config, options.issueNumber, 'plan-parent', now);
     try {
         await git.createIssueWorktree({
@@ -51,6 +55,7 @@ export async function runPlanAutoCommand(options) {
         const sessionId = `plan-${options.issueNumber}-${formatSessionTimestamp(now)}`;
         promptPath = sessionPromptPath({ targetRoot, config, issueNumber: options.issueNumber, sessionId });
         reportPath = sessionReportPath({ targetRoot, config, issueNumber: options.issueNumber, sessionId });
+        logPath = sessionLogPath({ targetRoot, config, issueNumber: options.issueNumber, sessionId });
         const isolatedHomePath = sessionCodexHomePath({ targetRoot, sessionId });
         await mkdir(dirname(reportPath), { recursive: true });
         await mkdir(isolatedHomePath, { recursive: true });
@@ -70,7 +75,7 @@ export async function runPlanAutoCommand(options) {
             sessionId,
             promptText,
         });
-        const store = new RunnerStateStore(targetRoot, config);
+        store = new RunnerStateStore(targetRoot, config);
         await store.upsertRun({
             issueNumber: options.issueNumber,
             mode: 'plan-parent',
@@ -79,6 +84,7 @@ export async function runPlanAutoCommand(options) {
             branchName,
             promptPath,
             reportPath,
+            logPath,
             retryCount: 0,
             createdAt: now.toISOString(),
             updatedAt: now.toISOString(),
@@ -97,13 +103,14 @@ export async function runPlanAutoCommand(options) {
                 issueNumber: options.issueNumber,
                 sessionId,
                 branchName,
+                logPath,
             });
         }
         finally {
             await cleanupSessionCodexHome(isolatedHomePath);
         }
         const afterHead = await git.getHead(worktreePath);
-        const base = baseResult(options.issueNumber, branchName, worktreePath, promptPath, reportPath, childIssues);
+        const base = baseResult(options.issueNumber, branchName, worktreePath, promptPath, reportPath, logPath, childIssues);
         if (beforeHead !== afterHead) {
             return finishPlanBlocked(issueAdapter, config, base, ['Planning session changed git HEAD; planning must not commit.'], []);
         }
@@ -124,15 +131,14 @@ export async function runPlanAutoCommand(options) {
             body: report.parent.body,
         });
         for (const node of topologicalPlanNodes(report.graph)) {
-            const persisted = await persistChildNode(issueAdapter, config, options.issueNumber, node);
+            const persisted = await persistAutonomousChildNode(issueAdapter, config, options.issueNumber, node);
             childIssues.push(persisted);
         }
-        const childNodes = await readExecutableChildren(issueAdapter, config, options.issueNumber, childIssues);
+        const childNodes = await readAutonomousChildNodes(issueAdapter, config, options.issueNumber, childIssues);
         const batches = collectExecutableChildBatches(childNodes, config);
         if (!batches.ok) {
             return finishPlanBlocked(issueAdapter, config, base, batches.errors, childIssues);
         }
-        const executionResults = [];
         for (const batch of batches.batches) {
             const settled = await Promise.allSettled(batch.map((child) => executeChild({
                 targetRoot,
@@ -161,7 +167,8 @@ export async function runPlanAutoCommand(options) {
             if (failures.length > 0) {
                 const successful = settled.flatMap((result) => result.status === 'fulfilled' ? [result.value] : []);
                 await blockFailedBatch(issueAdapter, config, options.issueNumber, failures, successful);
-                return finishPlanBlocked(issueAdapter, config, baseResult(options.issueNumber, branchName, worktreePath, promptPath, reportPath, childIssues), [
+                await blockCompletedChildren(issueAdapter, config, store, options.issueNumber, executionResults, 'A later child batch failed before parent publication.', worktreePath);
+                return finishPlanBlocked(issueAdapter, config, baseResult(options.issueNumber, branchName, worktreePath, promptPath, reportPath, logPath, childIssues), [
                     'Child batch failed before merge; no child from the failed batch was merged, pushed, or published.',
                     ...failures.map((failure) => failure.child ? `#${failure.child.issue.number}: ${failure.message}` : failure.message),
                 ], childIssues);
@@ -179,7 +186,8 @@ export async function runPlanAutoCommand(options) {
                 catch (error) {
                     if (error instanceof GitMergeConflictError) {
                         await handleMergeConflict(git, issueAdapter, config, options.issueNumber, error, childResult, orderedBatchResults);
-                        return finishPlanBlocked(issueAdapter, config, baseResult(options.issueNumber, branchName, worktreePath, promptPath, reportPath, childIssues), [
+                        await blockCompletedChildren(issueAdapter, config, store, options.issueNumber, executionResults, `A later merge conflict stopped parent publication before ${branchName} was pushed.`, worktreePath);
+                        return finishPlanBlocked(issueAdapter, config, baseResult(options.issueNumber, branchName, worktreePath, promptPath, reportPath, logPath, childIssues), [
                             `Merge conflict while merging #${childResult.child.issue.number} from ${childResult.branchName}.`,
                             error.stderr || error.stdout,
                         ], childIssues);
@@ -189,28 +197,44 @@ export async function runPlanAutoCommand(options) {
             }
             for (const childResult of orderedBatchResults) {
                 await git.removeWorktree({ targetRoot, worktreePath: childResult.worktreePath });
-                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(options.issueNumber, childResult));
-                await store.removeRun(childResult.child.issue.number);
                 executionResults.push(childResult);
             }
         }
         const finalValidation = await runConfiguredChecks(config, worktreePath, shellExecutor, []);
+        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);
+            return finishPlanBlocked(issueAdapter, config, baseResult(options.issueNumber, branchName, worktreePath, promptPath, reportPath, logPath, childIssues), [
+                'One or more configured checks failed.',
+                ...failedFinalValidation.map((line) => `${line.command}: ${line.status} - ${line.summary}`),
+            ], childIssues);
+        }
         await git.pushBranch({ worktreePath, branchName });
         pullRequest = await pullRequestAdapter.createDraftPullRequest({
             title: renderParentTemplate(config.pullRequests.issueTreeTitle, options.issueNumber),
-            body: buildIssueTreePullRequestBody(options.issueNumber, childIssues, executionResults, finalValidation),
+            body: buildIssueTreePullRequestBody({
+                parentIssueNumber: options.issueNumber,
+                childIssues,
+                childResults: executionResults,
+                finalValidation,
+            }),
             headBranch: branchName,
             baseBranch: config.branches.base,
         });
-        const reportComment = buildIssueTreeReviewReport(options.issueNumber, pullRequest, batches.batches, executionResults, finalValidation);
+        const reportComment = buildIssueTreeReviewReport({
+            parentIssueNumber: options.issueNumber,
+            pullRequest,
+            batches: batches.batches,
+            childResults: executionResults,
+            finalValidation,
+        });
+        await markCompletedChildrenReviewReady(issueAdapter, config, store, options.issueNumber, executionResults);
         await issueAdapter.removeLabels(options.issueNumber, [config.github.labels.running.name]);
         await issueAdapter.addLabels(options.issueNumber, [config.github.labels.review.name]);
         await issueAdapter.postComment(options.issueNumber, reportComment);
         await store.removeRun(options.issueNumber);
         return {
-            ...baseResult(options.issueNumber, branchName, worktreePath, promptPath, reportPath, childIssues),
+            ...baseResult(options.issueNumber, branchName, worktreePath, promptPath, reportPath, logPath, childIssues),
             status: 'review-ready',
             pullRequest,
             reportComment,
@@ -221,46 +245,11 @@ 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}`);
         }
-        return finishPlanBlocked(issueAdapter, config, baseResult(options.issueNumber, branchName, worktreePath, promptPath, reportPath, childIssues), [message], childIssues);
-    }
-}
-async function persistChildNode(issueAdapter, config, parentIssueNumber, node) {
-    const body = buildChildBody(node, parentIssueNumber);
-    const childLabel = config.github.labels.child.name;
-    const autoLabel = config.github.labels.auto.name;
-    let issue;
-    if (node.issueNumber !== undefined) {
-        const existing = await issueAdapter.getIssue(node.issueNumber);
-        if (!existing) {
-            throw new Error(`Existing issue #${node.issueNumber} was not found`);
-        }
-        if (!isAutonomousChildOfParent(existing, config, parentIssueNumber)) {
-            throw new Error(`Existing issue #${node.issueNumber} is not an autonomous child of #${parentIssueNumber}; refusing to update arbitrary issue.`);
-        }
-        issue = await issueAdapter.updateIssue(node.issueNumber, {
-            title: node.title,
-            body,
-            addLabels: [childLabel],
-            removeLabels: node.afkHitl === 'hitl' ? [autoLabel] : undefined,
-        });
-    }
-    else {
-        issue = await issueAdapter.createIssue({
-            title: node.title,
-            body,
-            labels: [childLabel],
-        });
-    }
-    if (!isAutonomousChildOfParent(issue, config, parentIssueNumber)) {
-        throw new Error(`Child issue #${issue.number} was not persisted with the autonomous marker for #${parentIssueNumber}.`);
-    }
-    if (node.afkHitl === 'afk') {
-        issue = await issueAdapter.updateIssue(issue.number, { addLabels: [autoLabel] });
-        if (!isAutonomousChildOfParent(issue, config, parentIssueNumber)) {
-            throw new Error(`Child issue #${issue.number} lost the autonomous marker for #${parentIssueNumber} while enabling agent:auto.`);
+        if (store && executionResults.length > 0) {
+            await blockCompletedChildren(issueAdapter, config, store, options.issueNumber, executionResults, `Parent publication failed before review handoff: ${message}`, worktreePath);
         }
+        return finishPlanBlocked(issueAdapter, config, baseResult(options.issueNumber, branchName, worktreePath, promptPath, reportPath, logPath, childIssues), [message], childIssues);
     }
-    return issue;
 }
 async function readPlanReport(reportPath) {
     try {
@@ -297,27 +286,6 @@ async function readWorkflowPrompt(targetRoot, promptPath, promptName) {
         throw error;
     }
 }
-async function readExecutableChildren(issueAdapter, config, parentIssueNumber, childIssues) {
-    const nodes = [];
-    const errors = [];
-    for (const child of childIssues) {
-        const current = await issueAdapter.getIssue(child.number);
-        if (!current) {
-            errors.push(`Child issue #${child.number} was not found during execution readback`);
-            continue;
-        }
-        const parsed = parseAutonomousChildMetadata(current, config, parentIssueNumber);
-        if (!parsed.ok) {
-            errors.push(...parsed.errors);
-            continue;
-        }
-        nodes.push(parsed.node);
-    }
-    if (errors.length > 0) {
-        throw new Error(errors.join('; '));
-    }
-    return nodes;
-}
 async function executeChild(input) {
     const childIssueNumber = input.child.issue.number;
     const branchName = `codex/tree-${input.parentIssue.number}-issue-${childIssueNumber}`;
@@ -335,6 +303,12 @@ async function executeChild(input) {
         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({
@@ -375,6 +349,7 @@ async function executeChild(input) {
         branchName,
         promptPath,
         reportPath,
+        logPath,
         retryCount: 0,
         createdAt: input.now.toISOString(),
         updatedAt: input.now.toISOString(),
@@ -393,119 +368,51 @@ async function executeChild(input) {
             issueNumber: childIssueNumber,
             sessionId,
             branchName,
+            logPath,
         });
     }
     finally {
         await cleanupSessionCodexHome(isolatedHomePath);
     }
     const afterHead = await input.git.getHead(worktreePath);
-    const publicationViolations = validateNoAgentOwnedGitPublication(beforeHead, afterHead);
-    if (publicationViolations.length > 0) {
-        throw new Error(publicationViolations.map((violation) => violation.message).join('; '));
-    }
-    if (codexResult.exitCode !== 0) {
-        throw new Error(`Codex exited with code ${codexResult.exitCode}: ${codexResult.stderr || codexResult.stdout}`);
-    }
-    const report = await readRequiredScopedReport(reportPath);
-    if (report.status === 'needs-promotion') {
-        const promotion = report.promotion;
-        throw new Error([
-            'Child requested promotion instead of completing issue-tree work.',
-            promotion ? `Reason: ${promotion.reason}` : undefined,
-            promotion ? `Evidence: ${promotion.evidence.join(', ')}` : undefined,
-        ].filter(Boolean).join(' '));
-    }
-    let changedFiles = await input.git.listChangedFiles(worktreePath);
-    if (changedFiles.length === 0) {
-        throw new Error('Codex completed without file changes');
-    }
-    const violations = [
-        ...validateChangedPaths(changedFiles, input.config),
-        ...validateCompletionReportSafety(report),
-    ];
-    if (violations.length > 0) {
-        throw new Error(violations.map((violation) => violation.message).join('; '));
-    }
-    let validation = await runConfiguredChecks(input.config, worktreePath, input.shellExecutor, report.validation);
-    const runnerVisualProof = await runRunnerVisualProof({
+    const publishability = await runImplementationPublishabilityCheck({
         config: input.config,
         issue: input.child.issue,
-        issueNumber: childIssueNumber,
         worktreePath,
-        changedFiles,
-        report,
+        reportPath,
+        beforeHead,
+        afterHead,
+        codexResult,
+        git: input.git,
         shellExecutor: input.shellExecutor,
+        commitMessage: `Codex: implement issue #${childIssueNumber} for parent #${input.parentIssue.number}`,
     });
-    validation = [...validation, ...runnerVisualProof.validation];
-    const artifacts = mergeArtifacts(report.artifacts, runnerVisualProof.artifacts);
-    if (runnerVisualProof.artifacts.length > 0) {
-        changedFiles = await input.git.listChangedFiles(worktreePath);
-    }
-    const residualRisks = [...report.residualRisks];
-    if (validation.some((line) => line.status === 'failed')) {
-        residualRisks.push('One or more configured checks failed.');
+    if (publishability.status === 'promotion-requested') {
+        const promotion = publishability.report.promotion;
+        throw new Error([
+            'Child requested promotion instead of completing issue-tree work.',
+            promotion ? `Reason: ${promotion.reason}` : undefined,
+            promotion ? `Evidence: ${promotion.evidence.join(', ')}` : undefined,
+        ].filter(Boolean).join(' '));
     }
-    const reviewGate = evaluateReviewGates({
-        config: input.config,
-        issue: input.child.issue,
-        changedFiles,
-        validation,
-        skippedChecks: report.skippedChecks,
-        report: { ...report, artifacts },
-        worktreePath,
-    });
-    if (!reviewGate.ok) {
-        throw new Error(reviewGate.reasons.join('; '));
+    if (publishability.status === 'blocked') {
+        throw new Error(publishability.reasons.join('; '));
     }
-    await input.git.commitAll({
-        worktreePath,
-        message: `Codex: implement issue #${childIssueNumber} for parent #${input.parentIssue.number}`,
-    });
     return {
         child: input.child,
         branchName,
         worktreePath,
         promptPath,
         reportPath,
-        changedFiles,
-        validation,
-        artifacts,
-        skippedChecks: report.skippedChecks,
-        residualRisks,
+        logPath,
+        changedFiles: publishability.changedFiles,
+        validation: publishability.validation,
+        artifacts: publishability.artifacts,
+        commits: publishability.commits,
+        skippedChecks: publishability.skippedChecks,
+        residualRisks: publishability.residualRisks,
     };
 }
-async function readRequiredScopedReport(reportPath) {
-    const reportRead = await readScopedCompletionReport(reportPath);
-    if (reportRead.kind === 'missing') {
-        throw new Error('Codex did not write CODEX_ORCHESTRATOR_REPORT_FILE; runner cannot prove child safety contract.');
-    }
-    return reportRead.report;
-}
-async function runConfiguredChecks(config, worktreePath, shellExecutor, reportValidation) {
-    const lines = [...reportValidation];
-    for (const [name, command] of Object.entries(config.checks)) {
-        const result = await shellExecutor(command, { cwd: worktreePath });
-        lines.push({
-            command,
-            status: result.exitCode === 0 ? 'passed' : 'failed',
-            summary: `${name}: ${result.exitCode === 0 ? 'passed' : result.stderr || result.stdout || `exit ${result.exitCode}`}`,
-        });
-    }
-    return lines;
-}
-function mergeArtifacts(existing, additions) {
-    const seen = new Set(existing.map((artifact) => artifact.url ?? artifact.path ?? artifact.description));
-    const merged = [...existing];
-    for (const artifact of additions) {
-        const key = artifact.url ?? artifact.path ?? artifact.description;
-        if (seen.has(key)) {
-            continue;
-        }
-        seen.add(key);
-        merged.push(artifact);
-    }
-    return merged;
-}
 async function blockFailedBatch(issueAdapter, config, parentIssueNumber, failures, successfulUnmerged) {
     for (const failure of failures) {
         if (!failure.child) {
@@ -513,23 +420,23 @@ async function blockFailedBatch(issueAdapter, config, parentIssueNumber, failure
         }
         await issueAdapter.removeLabels(failure.child.issue.number, [config.github.labels.running.name]);
         await issueAdapter.addLabels(failure.child.issue.number, [config.github.labels.blocked.name]);
-        await issueAdapter.postComment(failure.child.issue.number, [
-            `codex-orchestrator blocked child #${failure.child.issue.number} for parent #${parentIssueNumber}`,
-            'Reasons',
-            `- ${failure.message}`,
-            'Worktree preserved for maintainer inspection.',
-        ].join('\n'));
+        await issueAdapter.postComment(failure.child.issue.number, buildChildBlockedReport({
+            parentIssueNumber,
+            childIssueNumber: failure.child.issue.number,
+            reasons: [failure.message],
+            details: ['Worktree preserved for maintainer inspection.'],
+        }));
     }
     for (const result of successfulUnmerged) {
         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, [
-            `codex-orchestrator blocked child #${result.child.issue.number} for parent #${parentIssueNumber}`,
-            'Reasons',
-            '- A sibling child failed before the batch merge; this child branch was not merged.',
-            `- Branch preserved: ${result.branchName}`,
-            `- Worktree preserved: ${result.worktreePath}`,
-        ].join('\n'));
+        await issueAdapter.postComment(result.child.issue.number, buildChildBlockedReport({
+            parentIssueNumber,
+            childIssueNumber: result.child.issue.number,
+            reasons: ['A sibling child failed before the batch merge; this child branch was not merged.'],
+            branchName: result.branchName,
+            worktreePath: result.worktreePath,
+        }));
     }
 }
 async function handleMergeConflict(git, issueAdapter, config, parentIssueNumber, error, childResult, batchResults) {
@@ -543,51 +450,64 @@ async function handleMergeConflict(git, issueAdapter, config, parentIssueNumber,
     for (const result of batchResults) {
         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, [
-            `codex-orchestrator blocked child #${result.child.issue.number} for parent #${parentIssueNumber}`,
-            'Reasons',
-            result.child.issue.number === childResult.child.issue.number
-                ? `- Merge conflict from branch ${childResult.branchName}`
-                : `- A sibling merge conflict stopped the batch before publication: ${childResult.branchName}`,
-            `- Parent worktree: ${error.worktreePath}`,
-            `- Child worktree: ${result.worktreePath}`,
-            `- Child branch preserved: ${result.branchName}`,
-            abortMessage ? `- Merge abort also failed: ${abortMessage}` : '- Merge abort completed.',
-            'Batch Children',
-            ...bulletList(batchResults.map((batchResult) => `#${batchResult.child.issue.number} ${batchResult.branchName}`)),
-            'Git Output',
-            ...bulletList([error.stderr || error.stdout || 'no git output']),
-        ].join('\n'));
+        await issueAdapter.postComment(result.child.issue.number, buildChildBlockedReport({
+            parentIssueNumber,
+            childIssueNumber: result.child.issue.number,
+            reasons: [
+                result.child.issue.number === childResult.child.issue.number
+                    ? `Merge conflict from branch ${childResult.branchName}`
+                    : `A sibling merge conflict stopped the batch before publication: ${childResult.branchName}`,
+            ],
+            details: [
+                `- Parent worktree: ${error.worktreePath}`,
+                `- Child worktree: ${result.worktreePath}`,
+                `- Child branch preserved: ${result.branchName}`,
+                abortMessage ? `- Merge abort also failed: ${abortMessage}` : '- Merge abort completed.',
+            ],
+            batchChildren: batchResults.map((batchResult) => ({
+                issueNumber: batchResult.child.issue.number,
+                branchName: batchResult.branchName,
+            })),
+            gitOutput: error.stderr || error.stdout || 'no git output',
+        }));
+    }
+}
+async function markCompletedChildrenReviewReady(issueAdapter, config, store, parentIssueNumber, childResults) {
+    for (const childResult of childResults) {
+        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 }));
+        await store.removeRun(childResult.child.issue.number);
+    }
+}
+async function blockCompletedChildren(issueAdapter, config, store, parentIssueNumber, childResults, reason, parentWorktreePath) {
+    for (const result of childResults) {
+        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({
+            parentIssueNumber,
+            childIssueNumber: result.child.issue.number,
+            reasons: [reason],
+            details: [
+                `- Merged child branch was not published: ${result.branchName}`,
+                `- Parent worktree preserved: ${parentWorktreePath}`,
+            ],
+        }));
+        await store.removeRun(result.child.issue.number);
     }
 }
 async function finishPlanBlocked(issueAdapter, config, result, reasons, mutatedChildren) {
-    const reportComment = [
-        `codex-orchestrator blocked parent issue-tree execution for #${result.parentIssueNumber}`,
-        'Reasons',
-        ...bulletList(reasons),
-        'Mutated Child Issues',
-        ...bulletList(mutatedChildren.map((issue) => `#${issue.number} ${issue.title}`)),
-    ].join('\n');
+    const reportComment = buildParentBlockedReport({
+        parentIssueNumber: result.parentIssueNumber,
+        reasons,
+        logPath: result.logPath,
+        mutatedChildren,
+    });
     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);
     return { ...result, status: 'blocked', reportComment };
 }
-function buildChildBody(node, parentIssueNumber) {
-    return [
-        ensureAutonomousChildBody(node.body, parentIssueNumber),
-        '',
-        '## codex-orchestrator metadata',
-        `Stable ID: ${node.stableId}`,
-        `AFK/HITL: ${node.afkHitl}`,
-        `Depends on: ${node.dependsOn.length > 0 ? node.dependsOn.join(', ') : 'none'}`,
-        'Ownership:',
-        ...bulletList(node.ownershipScope),
-        'Spec gate: wave-level',
-        'Verification:',
-        ...bulletList(node.verification),
-    ].join('\n');
-}
 function dependencyIssuesFor(child, allChildren) {
     const issuesByStableId = new Map(allChildren.map((node) => [node.metadata.stableId, node.issue]));
     return child.metadata.dependsOn.flatMap((stableId) => {
@@ -595,89 +515,10 @@ function dependencyIssuesFor(child, allChildren) {
         return issue ? [issue] : [];
     });
 }
-function buildChildReviewReport(parentIssueNumber, result) {
-    return [
-        `codex-orchestrator child review report for #${result.child.issue.number}`,
-        `Parent issue: #${parentIssueNumber}`,
-        `Integration branch: ${result.branchName}`,
-        'Changes',
-        ...bulletList(result.changedFiles),
-        'Validation',
-        ...result.validation.map((line) => `- ${line.command}: ${line.status} - ${line.summary}`),
-        'Proof Artifacts',
-        ...renderProofArtifacts(result.artifacts),
-        'Skipped Checks',
-        ...bulletList(result.skippedChecks),
-        'Residual Risks',
-        ...bulletList(result.residualRisks),
-    ].join('\n');
-}
-function buildIssueTreeReviewReport(parentIssueNumber, pullRequest, batches, childResults, finalValidation) {
-    return [
-        `codex-orchestrator issue-tree review report for #${parentIssueNumber}`,
-        'Pull Request',
-        `- ${pullRequest.url}`,
-        'Execution Batches',
-        ...batches.map((batch, index) => `- Batch ${index + 1}: ${batch.map((child) => `#${child.issue.number}`).join(', ')}`),
-        'Child Issues',
-        ...childResults.map((result) => `- #${result.child.issue.number} ${result.child.issue.title}: ${result.branchName}`),
-        'Validation',
-        ...childResults.flatMap((result) => result.validation.map((line) => `- #${result.child.issue.number} ${line.command}: ${line.status} - ${line.summary}`)),
-        ...finalValidation.map((line) => `- final ${line.command}: ${line.status} - ${line.summary}`),
-        'Skipped Checks',
-        ...bulletList(childResults.flatMap((result) => result.skippedChecks)),
-        'Proof Artifacts',
-        ...childResults.flatMap((result) => renderProofArtifacts(result.artifacts).map((line) => `- #${result.child.issue.number} ${line.replace(/^- /, '')}`)),
-        'Residual Risks',
-        ...bulletList(childResults.flatMap((result) => result.residualRisks)),
-    ].join('\n');
-}
-function buildIssueTreePullRequestBody(parentIssueNumber, childIssues, childResults, finalValidation) {
-    return [
-        `Parent issue: #${parentIssueNumber}`,
-        '',
-        'Child issues:',
-        ...childIssues.map((issue) => `- #${issue.number} ${issue.title}`),
-        '',
-        'Changed files:',
-        ...childResults.flatMap((result) => [
-            `- #${result.child.issue.number}:`,
-            ...result.changedFiles.map((file) => `  - ${file}`),
-        ]),
-        '',
-        'Validation:',
-        ...childResults.flatMap((result) => result.validation.map((line) => `- #${result.child.issue.number} ${line.command}: ${line.status} - ${line.summary}`)),
-        ...finalValidation.map((line) => `- final ${line.command}: ${line.status} - ${line.summary}`),
-        '',
-        'Skipped checks:',
-        ...bulletList(childResults.flatMap((result) => result.skippedChecks)),
-        '',
-        'Proof artifacts:',
-        ...childResults.flatMap((result) => renderProofArtifacts(result.artifacts).map((line) => `- #${result.child.issue.number} ${line.replace(/^- /, '')}`)),
-        '',
-        'Residual risks:',
-        ...bulletList(childResults.flatMap((result) => result.residualRisks)),
-        '',
-        'Merge summary:',
-        ...childResults.map((result) => `- ${result.branchName} merged for #${result.child.issue.number}`),
-        '',
-        'Auto-merge is disabled.',
-    ].join('\n');
-}
 function renderParentTemplate(template, parentIssueNumber) {
     return template.replaceAll('${parentIssueNumber}', String(parentIssueNumber));
 }
-function renderProofArtifacts(artifacts) {
-    if (artifacts.length === 0) {
-        return ['- none'];
-    }
-    return artifacts.map((artifact) => {
-        const target = artifact.url ?? artifact.path ?? 'missing-target';
-        const label = `${artifact.type}: ${artifact.description}`;
-        return artifact.type === 'screenshot' ? `- ![${label.replace(/[\[\]]/g, '')}](${target})` : `- ${label}: ${target}`;
-    });
-}
-function baseResult(parentIssueNumber, branchName, worktreePath, promptPath, reportPath, childIssues) {
-    return { parentIssueNumber, branchName, worktreePath, promptPath, reportPath, childIssues };
+function baseResult(parentIssueNumber, branchName, worktreePath, promptPath, reportPath, logPath, childIssues) {
+    return { parentIssueNumber, branchName, worktreePath, promptPath, reportPath, logPath, childIssues };
 }
 //# sourceMappingURL=plan-auto-command.js.map