codex-orchestrator 0.1.20 → 0.1.22

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

@@ -5,17 +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, mergeArtifacts, readRunnerConfig, renderCommitEvidence } from './command-utils.js';
-import { readPlanAutoCompletionReport, readScopedCompletionReport, } from './completion-report.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, sessionPromptPath, sessionReportPath, writeDurablePrompt, } from './prompt.js';
-import { evaluateReviewGates } from './review-gates.js';
 import { sessionLogPath } from './run-log.js';
-import { validateChangedPaths, validateCompletionReportSafety, validateNoAgentOwnedGitPublication, } from './safety.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();
@@ -43,6 +42,8 @@ export async function runPlanAutoCommand(options) {
     let logPath = '';
     const childIssues = [];
     let pullRequest;
+    let store;
+    const executionResults = [];
     await claimIssue(issueAdapter, config, options.issueNumber, 'plan-parent', now);
     try {
         await git.createIssueWorktree({
@@ -74,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',
@@ -130,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,
@@ -167,6 +167,7 @@ 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);
+                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),
@@ -185,6 +186,7 @@ export async function runPlanAutoCommand(options) {
                 catch (error) {
                     if (error instanceof GitMergeConflictError) {
                         await handleMergeConflict(git, issueAdapter, config, options.issueNumber, error, childResult, orderedBatchResults);
+                        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,
@@ -195,22 +197,38 @@ 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);
@@ -227,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, logPath, 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 {
@@ -303,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}`;
@@ -413,74 +375,28 @@ async function executeChild(input) {
         await cleanupSessionCodexHome(isolatedHomePath);
     }
     const afterHead = await input.git.getHead(worktreePath);
-    const publicationViolations = input.config.runner.allowAgentLocalCommits
-        ? []
-        : 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 changeSet = await input.git.collectSessionChangeSet({ worktreePath, baseHead: beforeHead });
-    let changedFiles = changeSet.changedPaths;
-    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) {
-        changeSet = await input.git.collectSessionChangeSet({ worktreePath, baseHead: beforeHead });
-        changedFiles = changeSet.changedPaths;
-    }
-    const residualRisks = [...report.residualRisks];
-    if (validation.some((line) => line.status === 'failed')) {
-        residualRisks.push('One or more configured checks failed.');
-    }
-    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 === '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(' '));
     }
-    if (!(await input.git.isWorktreeClean(worktreePath))) {
-        await input.git.commitAll({
-            worktreePath,
-            message: `Codex: implement issue #${childIssueNumber} for parent #${input.parentIssue.number}`,
-        });
-        changeSet = await input.git.collectSessionChangeSet({ worktreePath, baseHead: beforeHead });
+    if (publishability.status === 'blocked') {
+        throw new Error(publishability.reasons.join('; '));
     }
     return {
         child: input.child,
@@ -489,33 +405,14 @@ async function executeChild(input) {
         promptPath,
         reportPath,
         logPath,
-        changedFiles,
-        validation,
-        artifacts,
-        commits: changeSet.commits,
-        skippedChecks: report.skippedChecks,
-        residualRisks,
+        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;
-}
 async function blockFailedBatch(issueAdapter, config, parentIssueNumber, failures, successfulUnmerged) {
     for (const failure of failures) {
         if (!failure.child) {
@@ -523,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) {
@@ -553,53 +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),
-        'Log',
-        ...bulletList([result.logPath]),
-        '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) => {
@@ -607,102 +515,9 @@ 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),
-        'Local Commits',
-        ...renderCommitEvidence(result.commits),
-        'Log',
-        ...bulletList([result.logPath]),
-        '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(/^- /, '')}`)),
-        'Logs',
-        ...childResults.map((result) => `- #${result.child.issue.number}: ${result.logPath}`),
-        'Local Commits',
-        ...childResults.flatMap((result) => renderCommitEvidence(result.commits).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(/^- /, '')}`)),
-        '',
-        'Logs:',
-        ...childResults.map((result) => `- #${result.child.issue.number}: ${result.logPath}`),
-        '',
-        'Local commits:',
-        ...childResults.flatMap((result) => renderCommitEvidence(result.commits).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, logPath, childIssues) {
     return { parentIssueNumber, branchName, worktreePath, promptPath, reportPath, logPath, childIssues };
 }