codex-orchestrator 2.0.6 → 2.0.8

package/dist/src/v2/run-issue.js

@@ -3,8 +3,9 @@ import { checkedChangePayloadSha256, } from './checked-change.js';
 import { parseAgentAutoConfig } from './config.js';
 import { canonicalJson, sha256 } from './containment.js';
 import { validateImplementationReport } from './implementation-report.js';
-import { acceptApprovedDirectReview, acceptNeedsWorkDirectReview, beginDirectReviewRepair, createInitialDirectReview, directReviewClosureRequestSha256, directReviewTargetFingerprint, launchDirectReviewInvocation, prepareDirectReviewClosure, prepareDirectReviewInvocation, projectTerminalDirectReview, } from './direct-delivery.js';
+import { acceptApprovedDirectReview, acceptNeedsWorkDirectReview, beginDirectReviewRepair, canRecoverTerminalDirectReviewReport, createInitialDirectReview, directReviewClosureRequestSha256, directReviewTargetFingerprint, launchDirectReviewInvocation, MAX_DIRECT_REVIEW_REPORT_REPAIRS, prepareDirectReviewClosure, prepareDirectReviewInvocation, projectTerminalDirectReview, recoverTerminalDirectReviewReport, } from './direct-delivery.js';
 import { ProofLaunchAuthorizationError, ProofQuiescenceError } from './acceptance-proof.js';
+import { CheckProcessQuiescenceError, resolveIssueCheckPolicy } from './issue-check-policy.js';
 import { RouteInitializationUnrecoverableError, WorkflowGenerationUnrecoverableError, } from './run-store.js';
 import { initialRouteExecution, } from './route-coordinator.js';
 import { downstreamLifecycleForRoute, validateRouteTransition, validateTrustedAnswerResumeTransition, } from './route-decision.js';
@@ -30,56 +31,88 @@ export class RunIssue {
         let observation = await this.readIssue(issueNumber);
         if (!observation || observation.state !== 'OPEN')
             return { result: await this.publicationDiverged(active, 'claim-issue-missing') };
+        const body = claimComment(runId, issueNumber, branchName);
+        const marker = body.split('\n')[0];
+        const commentIntent = { kind: 'comment', issueNumber, marker, bodySha256: sha256(body) };
+        // Compatibility with runs persisted by the former label-first claim order.
+        // If the label effect is already visible, confirm it. Otherwise establish
+        // the trusted claim comment before granting the running status label.
         if (active.record.intent?.kind === 'claim-labels') {
-            if (!sameStrings(observation.labels, expectedLabels)) {
+            if (sameStrings(observation.labels, expectedLabels)) {
+                active = await this.confirmEffect(active);
+            }
+            else if (!this.hasTrustedClaim(observation, active.record)) {
                 const labels = new Set(observation.labels);
                 if (!labels.has(config.github.labels.auto.name)
                     || labels.has(config.github.labels.blocked.name)
-                    || labels.has(config.github.labels.review.name)) {
+                    || labels.has(config.github.labels.review.name)
+                    || labels.has(config.github.labels.waitingHuman.name)) {
                     return { result: await this.publicationDiverged(active, 'claim-labels-diverged') };
                 }
+                active = await this.persist(active, { intent: commentIntent });
+            }
+        }
+        if (!active.record.intent) {
+            observation = await this.readIssue(issueNumber);
+            if (!observation || observation.state !== 'OPEN')
+                return { result: await this.publicationDiverged(active, 'claim-issue-missing') };
+            if (!this.hasTrustedClaim(observation, active.record)) {
+                active = await this.persist(active, { intent: commentIntent });
+            }
+        }
+        if (active.record.intent?.kind === 'comment') {
+            if (active.record.intent.marker !== marker || active.record.intent.bodySha256 !== sha256(body)) {
+                return { result: await this.publicationDiverged(active, 'claim-comment-intent-diverged') };
+            }
+            observation = await this.readIssue(issueNumber);
+            let comments = observation ? commentsWithMarker(observation, marker) : [];
+            if (comments.some((comment) => comment.body !== body) || comments.length > 1) {
+                return { result: await this.publicationDiverged(active, 'claim-comment-diverged') };
+            }
+            if (comments.length === 0) {
                 try {
-                    await this.dependencies.issues.setLabels(issueNumber, expectedLabels);
+                    await this.dependencies.issues.postComment(issueNumber, body);
                 }
                 catch {
-                    return { result: await this.invokedFailure(active, 'claim-labels-delivery-unknown') };
+                    return { result: await this.invokedFailure(active, 'claim-comment-delivery-unknown') };
                 }
                 observation = await this.readIssue(issueNumber);
+                comments = observation ? commentsWithMarker(observation, marker) : [];
             }
-            if (!observation || !sameStrings(observation.labels, expectedLabels)) {
-                return { result: await this.publicationDiverged(active, 'claim-labels-observation-diverged') };
+            if (comments.length !== 1 || comments[0].body !== body
+                || !['OWNER', 'MEMBER', 'COLLABORATOR'].includes(comments[0].authorAssociation)) {
+                return { result: await this.publicationDiverged(active, 'claim-comment-observation-diverged') };
             }
             active = await this.confirmEffect(active);
         }
-        else if (!sameStrings(observation.labels, expectedLabels)) {
-            return { result: await this.publicationDiverged(active, 'claim-labels-missing-before-comment') };
+        observation = await this.readIssue(issueNumber);
+        if (!observation || observation.state !== 'OPEN' || !this.hasTrustedClaim(observation, active.record)) {
+            return { result: await this.publicationDiverged(active, 'claim-comment-observation-diverged') };
+        }
+        if (sameStrings(observation.labels, expectedLabels))
+            return { active };
+        const labels = new Set(observation.labels);
+        if (!labels.has(config.github.labels.auto.name)
+            || labels.has(config.github.labels.blocked.name)
+            || labels.has(config.github.labels.review.name)
+            || labels.has(config.github.labels.waitingHuman.name)) {
+            return { result: await this.publicationDiverged(active, 'claim-labels-diverged') };
         }
-        const body = claimComment(runId, issueNumber, branchName);
-        const marker = body.split('\n')[0];
         if (!active.record.intent) {
-            active = await this.persist(active, { intent: { kind: 'comment', issueNumber, marker, bodySha256: sha256(body) } });
+            active = await this.persist(active, { intent: { kind: 'claim-labels', issueNumber, expected: expectedLabels } });
         }
-        if (active.record.intent?.kind !== 'comment' || active.record.intent.marker !== marker || active.record.intent.bodySha256 !== sha256(body)) {
-            return { result: await this.publicationDiverged(active, 'claim-comment-intent-diverged') };
+        if (active.record.intent?.kind !== 'claim-labels' || !sameStrings(active.record.intent.expected, expectedLabels)) {
+            return { result: await this.publicationDiverged(active, 'claim-labels-intent-diverged') };
         }
-        observation = await this.readIssue(issueNumber);
-        let comments = observation ? commentsWithMarker(observation, marker) : [];
-        if (comments.some((comment) => comment.body !== body) || comments.length > 1) {
-            return { result: await this.publicationDiverged(active, 'claim-comment-diverged') };
+        try {
+            await this.dependencies.issues.setLabels(issueNumber, expectedLabels);
         }
-        if (comments.length === 0) {
-            try {
-                await this.dependencies.issues.postComment(issueNumber, body);
-            }
-            catch {
-                return { result: await this.invokedFailure(active, 'claim-comment-delivery-unknown') };
-            }
-            observation = await this.readIssue(issueNumber);
-            comments = observation ? commentsWithMarker(observation, marker) : [];
+        catch {
+            return { result: await this.invokedFailure(active, 'claim-labels-delivery-unknown') };
         }
-        if (comments.length !== 1 || comments[0].body !== body
-            || !['OWNER', 'MEMBER', 'COLLABORATOR'].includes(comments[0].authorAssociation)) {
-            return { result: await this.publicationDiverged(active, 'claim-comment-observation-diverged') };
+        observation = await this.readIssue(issueNumber);
+        if (!observation || !sameStrings(observation.labels, expectedLabels) || !this.hasTrustedClaim(observation, active.record)) {
+            return { result: await this.publicationDiverged(active, 'claim-labels-observation-diverged') };
         }
         active = await this.confirmEffect(active);
         return { active };
@@ -706,17 +739,6 @@ export class RunIssue {
                 return await this.preClaimInternal('config-changed-during-owner-acquire', input.issueNumber);
             }
             const config = confirmedConfig.config;
-            try {
-                await this.dependencies.validateContainment(config);
-            }
-            catch {
-                const evidence = await this.dependencies.writeEvidence({
-                    runId: `issue-${input.issueNumber}`,
-                    code: 'containment-certificate-invalid',
-                    summary: 'Containment certification is unavailable or stale.',
-                });
-                return { status: 'blocked', kind: 'safety', resumable: true, evidencePath: evidence.path };
-            }
             if (this.signal.aborted)
                 return await this.preClaimCancelled(input.issueNumber);
             let issue;
@@ -753,15 +775,33 @@ export class RunIssue {
                 if (active.record.intent?.kind === 'review-blocked-labels') {
                     return await this.blockReviewFeedback(active, active.record.intent.blockKind, active.record.intent.evidenceCode);
                 }
+                if (active.record.intent?.kind === 'blocked-labels') {
+                    return await this.publishBlockedTerminal(active, {
+                        status: 'blocked',
+                        kind: active.record.intent.blockKind,
+                        resumable: active.record.intent.resumable,
+                    }, active.record.intent.evidenceCode);
+                }
+                if (existing.terminalOutcome?.status === 'blocked'
+                    && issue?.state === 'OPEN'
+                    && blockedLabelProjection(issue.labels, config).status !== 'settled') {
+                    return await this.reconcilePersistedBlockedTerminal(active, issue, existing.terminalOutcome);
+                }
                 if (existing.terminalOutcome) {
-                    if (existing.terminalOutcome.status !== 'review-ready')
-                        return publicOutcome(existing.terminalOutcome);
-                    const continuation = await this.continueReviewReady(active, targetRoot, config);
-                    if ('result' in continuation)
-                        return continuation.result;
-                    active = continuation.active;
-                    issueSnapshot = structuredClone(active.record.issueSnapshot);
-                    frozenCriteria = structuredClone(active.record.frozenCriteria);
+                    if (existing.terminalOutcome.status !== 'review-ready') {
+                        const recovered = await this.recoverTerminalReviewReport(active, issue, config, frozenCriteria);
+                        if (!recovered)
+                            return publicOutcome(existing.terminalOutcome);
+                        active = recovered;
+                    }
+                    else {
+                        const continuation = await this.continueReviewReady(active, targetRoot, config);
+                        if ('result' in continuation)
+                            return continuation.result;
+                        active = continuation.active;
+                        issueSnapshot = structuredClone(active.record.issueSnapshot);
+                        frozenCriteria = structuredClone(active.record.frozenCriteria);
+                    }
                 }
                 if (active.record.reviewFeedback?.phase === 'frozen') {
                     const activation = await this.resumeActivatedReviewFeedback(active, targetRoot, config);
@@ -896,11 +936,13 @@ export class RunIssue {
                 worktreePath = resolve(targetRoot, config.runner.workspaceRoot, `issue-${input.issueNumber}`);
                 baseSha = await this.dependencies.git.getBaseSha({ targetRoot, baseBranch: config.github.baseBranch });
                 assertGitSha(baseSha, 'baseSha');
-                const runningLabels = sortedUnique([config.github.labels.auto.name, config.github.labels.running.name]);
+                const claimBody = claimComment(runId, input.issueNumber, branchName);
                 active = await this.createRun({
                     runId, issueNumber: input.issueNumber, canonicalRepository, baseSha, branchName, worktreePath,
                     issueSnapshot, frozenCriteria, config,
-                    intent: { kind: 'claim-labels', issueNumber: input.issueNumber, expected: runningLabels },
+                    intent: {
+                        kind: 'comment', issueNumber: input.issueNumber, marker: claimBody.split('\n')[0], bodySha256: sha256(claimBody),
+                    },
                 });
                 const claim = await this.reconcileClaim(active, config);
                 if ('result' in claim)
@@ -927,6 +969,13 @@ export class RunIssue {
             if (active.record.lifecycle === 'checking' && !active.record.directReview && active.record.routeReceipt?.route === 'direct') {
                 return await this.terminal(active, { status: 'internal-error', code: 'direct-review-state-missing' });
             }
+            if (active.record.lifecycle === 'implementing' && active.record.routeReceipt?.route === 'direct'
+                && !active.record.directReview) {
+                const baseline = await this.captureBaselineChecks(active, config);
+                if ('status' in baseline)
+                    return baseline;
+                active = baseline.active;
+            }
             attemptLoop: while (true) {
                 if (!await this.authorized(active, config)) {
                     return await this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true });
@@ -1204,23 +1253,50 @@ export class RunIssue {
                         });
                     }
                 }
-                for (const [id, command] of Object.entries(config.checks)) {
-                    if (active.record.checks.some((check) => check.id === id && check.status === 'passed'))
+                let checkPolicy;
+                try {
+                    checkPolicy = resolveIssueCheckPolicy(active.record.issueSnapshot.body, config.checks);
+                }
+                catch (error) {
+                    return await this.invokedFailure(active, 'issue-verification-invalid', error instanceof Error ? error.message : undefined);
+                }
+                const configuredChecks = Object.entries(checkPolicy.checks);
+                const reusableChecks = active.record.checks.filter((check) => configuredChecks.some(([id, command]) => check.id === id && check.command === command));
+                if (reusableChecks.length !== active.record.checks.length) {
+                    active = await this.persist(active, {
+                        checks: reusableChecks,
+                        checkedChangeSha256: undefined,
+                        proofId: undefined,
+                        proofReceipt: undefined,
+                    });
+                }
+                for (const [id, command] of configuredChecks) {
+                    if (active.record.checks.some((check) => check.id === id
+                        && check.command === command
+                        && (check.status === 'passed' || check.status === 'unchanged-failure')))
                         continue;
                     if (this.signal.aborted)
                         return await this.terminal(active, { status: 'cancelled' });
                     let check;
                     try {
-                        check = await this.dependencies.checks.run({ id, command, cwd: worktreePath, signal: this.signal });
+                        check = await this.dependencies.checks.run({ id, command, source: checkPolicy.source, cwd: worktreePath, phase: 'changed', signal: this.signal });
                     }
-                    catch {
-                        return await this.terminal(active, { status: 'internal-error', code: 'configured-check-execution-failed' });
+                    catch (error) {
+                        if (error instanceof CheckProcessQuiescenceError) {
+                            return await this.terminal(active, { status: 'blocked', kind: 'safety', resumable: false }, 'check-process-quiescence-unconfirmed');
+                        }
+                        return await this.invokedFailure(active, 'configured-check-execution-failed', error instanceof Error ? error.message : 'The check process did not start or settle. Retry the same run.');
                     }
                     if (this.signal.aborted)
                         return await this.terminal(active, { status: 'cancelled' });
-                    const row = { id, command, status: check.status, outputSha256: sha256(check.output) };
+                    const outputSha256 = check.outputSha256;
+                    const baseline = active.record.baselineChecks?.find((candidate) => candidate.id === id && candidate.command === command);
+                    const status = check.status === 'failed' && baseline?.status === 'failed' && baseline.outputSha256 === outputSha256
+                        ? 'unchanged-failure'
+                        : check.status;
+                    const row = { id, command, status, outputSha256 };
                     active = await this.persist(active, { checks: [...active.record.checks, row] });
-                    if (check.status !== 'passed') {
+                    if (status === 'failed') {
                         if (this.repairBudgetExhausted(active, config.runner.maxCycles)) {
                             return active.record.reviewFeedback?.activeBatch
                                 ? await this.blockReviewFeedback(active, 'exhausted', 'review-feedback-check-repair-exhausted')
@@ -1272,6 +1348,9 @@ export class RunIssue {
                     || reviewedStageBinding.contentSha256 !== proofContentSha256) {
                     return await this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true }, 'checked-change-review-binding-drift');
                 }
+                if (!sameCheckPolicy(active.record.checks, checkPolicy.checks)) {
+                    return await this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true }, 'configured-check-policy-drift');
+                }
                 const payload = {
                     version: 1,
                     canonicalRepository,
@@ -1285,8 +1364,11 @@ export class RunIssue {
                     untrackedContentSha256: freshness.untrackedContentSha256,
                     worktreeIdentity: freshness.worktreeIdentity,
                     changedFiles: proofChangedFiles,
-                    checks: active.record.checks.map((check) => ({ ...check, status: 'passed' })),
-                    checkPolicySha256: sha256(canonicalJson(config.checks)),
+                    checks: active.record.checks.map((check) => ({
+                        ...check,
+                        status: check.status === 'unchanged-failure' ? 'unchanged-failure' : 'passed',
+                    })),
+                    checkPolicySha256: sha256(canonicalJson(checkPolicy.checks)),
                     packageVersion: active.record.packageVersion,
                     proofSchemaVersion: 1,
                 };
@@ -1800,7 +1882,7 @@ export class RunIssue {
             packageVersion: workflow.receipt.packageVersion,
             workflowGeneration: structuredClone(workflow.receipt),
             skillHashes: structuredClone(workflow.skillHashes),
-            checks: [], createdAt: now, updatedAt: now,
+            baselineChecks: [], checks: [], createdAt: now, updatedAt: now,
         };
         const saved = await this.dependencies.runRecords.compareAndSwap(state.generation, {
             schema: 'codex-orchestrator.agent-auto-state', version: 2, runs: [...state.runs, record],
@@ -1842,7 +1924,10 @@ export class RunIssue {
         if (issue.state !== 'OPEN')
             return false;
         const labels = new Set(issue.labels);
-        if (!labels.has(config.github.labels.auto.name) || !labels.has(config.github.labels.running.name))
+        if (!labels.has(config.github.labels.auto.name)
+            || labels.has(config.github.labels.blocked.name)
+            || labels.has(config.github.labels.review.name)
+            || labels.has(config.github.labels.waitingHuman.name))
             return false;
         return this.hasTrustedClaim(issue, record);
     }
@@ -1957,9 +2042,7 @@ export class RunIssue {
                 affectedDefectIds: [...directReview.review.affectedDefectIds],
                 fixedRepairFindings: directReview.repairFindings.filter((finding) => finding.status === 'fixed')
                     .map((finding) => ({ id: finding.id, affectedContracts: [...finding.affectedContracts] })),
-                mandatoryCoverage: directReview.stage === 'review-closure'
-                    ? [...directReview.review.coverage]
-                    : ['acceptance-criteria', 'correctness', 'test-quality'],
+                reviewFocus: ['acceptance-criteria', 'correctness', 'test-quality'],
                 workflowGeneration: structuredClone(active.record.workflowGeneration),
                 repairOnly: reportRepair !== undefined,
                 originalReportSha256: reportRepair?.originalReportSha256 ?? null,
@@ -2029,14 +2112,17 @@ export class RunIssue {
                 const current = active.record.directReview;
                 if (!current)
                     return this.terminal(active, { status: 'internal-error', code: 'direct-review-result-orphaned' });
-                if (current.review.reportRepairs >= 1 || reportRepair) {
-                    return this.terminal(active, { status: 'internal-error', code: 'direct-review-report-malformed' });
+                if (current.review.reportRepairs >= MAX_DIRECT_REVIEW_REPORT_REPAIRS) {
+                    return this.terminal(active, { status: 'internal-error', code: 'direct-review-report-malformed' }, 'direct-review-report-malformed');
                 }
                 const { invocation: _invocation, ...withoutInvocation } = structuredClone(current);
                 active = await this.persist(active, {
                     directReview: {
                         ...withoutInvocation,
-                        review: { ...withoutInvocation.review, reportRepairs: 1 },
+                        review: {
+                            ...withoutInvocation.review,
+                            reportRepairs: (withoutInvocation.review.reportRepairs + 1),
+                        },
                     },
                 });
                 reportRepair = {
@@ -2111,6 +2197,100 @@ export class RunIssue {
         }
         return this.persist(starting, { directReview: withoutInvocation });
     }
+    async captureBaselineChecks(starting, config) {
+        let active = starting;
+        if ((await this.dependencies.git.listChangedFiles(active.record.worktreePath)).length !== 0)
+            return { active };
+        let checkPolicy;
+        try {
+            checkPolicy = resolveIssueCheckPolicy(active.record.issueSnapshot.body, config.checks);
+        }
+        catch (error) {
+            active = await this.persist(active, { lifecycle: 'routed' });
+            return this.invokedFailure(active, 'issue-verification-invalid', error instanceof Error ? error.message : undefined);
+        }
+        const configuredChecks = Object.entries(checkPolicy.checks);
+        const reusableBaselineChecks = (active.record.baselineChecks ?? []).filter((check) => configuredChecks.some(([id, command]) => check.id === id && check.command === command));
+        if (reusableBaselineChecks.length !== (active.record.baselineChecks ?? []).length) {
+            active = await this.persist(active, { baselineChecks: reusableBaselineChecks });
+        }
+        for (const [id, command] of configuredChecks) {
+            if (active.record.baselineChecks?.some((check) => check.id === id && check.command === command))
+                continue;
+            if (this.signal.aborted)
+                return this.terminal(active, { status: 'cancelled' });
+            let check;
+            try {
+                check = await this.dependencies.checks.run({
+                    id, command, source: checkPolicy.source,
+                    cwd: active.record.worktreePath,
+                    phase: 'baseline',
+                    signal: this.signal,
+                });
+            }
+            catch (error) {
+                if (error instanceof CheckProcessQuiescenceError) {
+                    return this.terminal(active, { status: 'blocked', kind: 'safety', resumable: false }, 'check-process-quiescence-unconfirmed');
+                }
+                active = await this.persist(active, { lifecycle: 'routed' });
+                return this.invokedFailure(active, 'configured-check-execution-failed', error instanceof Error ? error.message : 'The baseline check process did not start or settle. Retry the same run.');
+            }
+            if ((await this.dependencies.git.listChangedFiles(active.record.worktreePath)).length !== 0) {
+                return this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true }, 'baseline-check-mutated-worktree');
+            }
+            active = await this.persist(active, {
+                baselineChecks: [
+                    ...(active.record.baselineChecks ?? []),
+                    { id, command, status: check.status, outputSha256: check.outputSha256 },
+                ],
+            });
+        }
+        return { active };
+    }
+    async recoverTerminalReviewReport(active, issue, config, frozenCriteria) {
+        const directReview = active.record.directReview;
+        const allowLegacyMalformed = directReview?.terminalCode === undefined
+            && active.record.outcomeEvidenceId === `evidence:${active.record.runId}:direct-review-report-malformed`;
+        if (!issue || !directReview || active.record.intent || active.record.process
+            || active.record.terminalOutcome?.status !== 'internal-error'
+            || directReview.status !== 'terminal' || directReview.terminalOutcome?.status !== 'internal-error'
+            || !canRecoverTerminalDirectReviewReport(directReview, { allowLegacyMalformed })
+            || !this.isAuthorizedIssue(issue, active.record, config))
+            return undefined;
+        let worktree;
+        try {
+            worktree = await this.dependencies.git.inspectWorktree({
+                worktreePath: active.record.worktreePath,
+                branchName: active.record.branchName,
+                baseSha: active.record.baseSha,
+            });
+        }
+        catch {
+            return undefined;
+        }
+        if (worktree !== 'matching'
+            || await this.dependencies.git.getHead(active.record.worktreePath) !== expectedImplementationHead(active.record))
+            return undefined;
+        const changedFiles = await this.dependencies.git.listChangedFiles(active.record.worktreePath);
+        if (changedFiles.length === 0 || !active.record.routeReceipt)
+            return undefined;
+        const targetFingerprint = directReviewTargetFingerprint({
+            snapshot: await this.dependencies.git.snapshot(active.record.worktreePath),
+            changedFiles,
+            routeDecisionSha256: active.record.routeReceipt.decisionSha256,
+            workflowGenerationHash: active.record.workflowGeneration.generationHash,
+            cycle: active.record.cycle,
+            frozenCriteria,
+        });
+        if (targetFingerprint !== directReview.targetFingerprint)
+            return undefined;
+        return this.persist(active, {
+            lifecycle: 'implementing',
+            directReview: recoverTerminalDirectReviewReport(directReview, { allowLegacyMalformed }),
+            terminalOutcome: undefined,
+            outcomeEvidenceId: undefined,
+        });
+    }
     async startNextCycle(active, findings, sources) {
         if (active.record.directReview?.status === 'clear') {
             const fallbackProvenance = active.record.lifecycle === 'proving' ? 'proof' : 'check';
@@ -2252,6 +2432,101 @@ export class RunIssue {
         if (active.record.reviewFeedback?.activeBatch && outcome.status !== 'review-ready') {
             return this.blockReviewFeedback(active, outcome.status === 'blocked' && outcome.kind === 'exhausted' ? 'exhausted' : 'safety', evidenceCode);
         }
+        if (outcome.status === 'blocked') {
+            return this.publishBlockedTerminal(active, outcome, evidenceCode);
+        }
+        return this.persistTerminal(active, outcome, evidenceCode, retainIntent);
+    }
+    async publishBlockedTerminal(starting, outcome, evidenceCode) {
+        let active = starting;
+        const autoBlocked = [active.config.github.labels.auto.name, active.config.github.labels.blocked.name].sort();
+        const blockedOnly = [active.config.github.labels.blocked.name];
+        let expected = autoBlocked;
+        const existing = active.record.intent;
+        if (!existing) {
+            active = await this.persist(active, { intent: {
+                    kind: 'blocked-labels',
+                    issueNumber: active.record.issueNumber,
+                    expected,
+                    blockKind: outcome.kind,
+                    resumable: outcome.resumable,
+                    evidenceCode,
+                } });
+        }
+        else if (existing.kind !== 'blocked-labels'
+            || existing.issueNumber !== active.record.issueNumber
+            || existing.blockKind !== outcome.kind
+            || existing.resumable !== outcome.resumable
+            || existing.evidenceCode !== evidenceCode) {
+            return this.invokedFailure(active, 'blocked-labels-intent-diverged');
+        }
+        else {
+            expected = existing.expected;
+            if (!sameStrings(expected, autoBlocked) && !sameStrings(expected, blockedOnly) && expected.length !== 0) {
+                return this.invokedFailure(active, 'blocked-labels-intent-diverged');
+            }
+        }
+        let issue = await this.readIssue(active.record.issueNumber);
+        if (!issue)
+            return this.invokedFailure(active, 'blocked-labels-issue-missing');
+        let projection = blockedLabelProjection(issue.labels, active.config);
+        if (issue.state === 'OPEN' && projection.status === 'transition') {
+            if (!this.dependencies.issues.transitionToBlocked) {
+                return this.invokedFailure(active, 'blocked-labels-transition-unavailable');
+            }
+            try {
+                await this.dependencies.issues.transitionToBlocked(active.record.issueNumber, blockedLabelPolicy(active.config));
+            }
+            catch {
+                return this.invokedFailure(active, 'blocked-labels-delivery-unknown');
+            }
+            issue = await this.readIssue(active.record.issueNumber);
+            projection = issue ? blockedLabelProjection(issue.labels, active.config) : { status: 'diverged' };
+        }
+        if (!issue)
+            return this.invokedFailure(active, 'blocked-labels-observation-missing');
+        if (issue.state === 'OPEN') {
+            if (projection.status !== 'settled') {
+                return this.invokedFailure(active, 'blocked-labels-observation-diverged');
+            }
+            if (!sameStrings(expected, projection.expected)) {
+                expected = projection.expected;
+                const intent = active.record.intent;
+                if (intent?.kind !== 'blocked-labels')
+                    return this.invokedFailure(active, 'blocked-labels-intent-diverged');
+                try {
+                    active = await this.persist(active, { intent: { ...intent, expected } });
+                }
+                catch {
+                    throw new PostEffectStateError(active);
+                }
+            }
+        }
+        try {
+            return await this.persistTerminal(active, outcome, evidenceCode, false);
+        }
+        catch {
+            throw new PostEffectStateError(active);
+        }
+    }
+    async reconcilePersistedBlockedTerminal(active, issue, outcome) {
+        if (!this.dependencies.issues.transitionToBlocked) {
+            return this.invokedFailure(active, 'blocked-labels-transition-unavailable');
+        }
+        try {
+            await this.dependencies.issues.transitionToBlocked(active.record.issueNumber, blockedLabelPolicy(active.config));
+        }
+        catch {
+            return this.invokedFailure(active, 'blocked-labels-delivery-unknown');
+        }
+        const observation = await this.readIssue(active.record.issueNumber);
+        if (!observation || observation.state !== 'OPEN'
+            || blockedLabelProjection(observation.labels, active.config).status !== 'settled') {
+            return this.invokedFailure(active, 'blocked-labels-observation-diverged');
+        }
+        return publicOutcome(outcome);
+    }
+    async persistTerminal(active, outcome, evidenceCode, retainIntent) {
         const evidence = await this.dependencies.writeEvidence({ runId: active.record.runId, code: evidenceCode, summary: outcome.status });
         const terminalOutcome = { ...outcome, evidencePath: evidence.path };
         const changes = {
@@ -2263,7 +2538,7 @@ export class RunIssue {
         if (outcome.status !== 'review-ready' && active.record.directReview && active.record.directReview.status !== 'terminal') {
             changes.directReview = projectTerminalDirectReview(active.record.directReview, outcome.status === 'blocked'
                 ? { status: 'blocked', kind: outcome.kind }
-                : { status: outcome.status });
+                : { status: outcome.status }, outcome.status === 'internal-error' ? outcome.code : undefined);
         }
         if (active.record.waitingHuman && (active.record.lifecycle === 'waiting-human' || active.record.waitingHuman.phase === 'resumed')) {
             if (active.record.waitingHuman.phase === 'resumed') {
@@ -2503,6 +2778,36 @@ function sameStrings(left, right) {
     const b = [...right].sort();
     return a.length === b.length && a.every((value, index) => value === b[index]);
 }
+function blockedLabelPolicy(config) {
+    return {
+        auto: config.github.labels.auto.name,
+        running: config.github.labels.running.name,
+        blocked: config.github.labels.blocked.name,
+        review: config.github.labels.review.name,
+        waitingHuman: config.github.labels.waitingHuman.name,
+    };
+}
+function blockedLabelProjection(labels, config) {
+    const policy = blockedLabelPolicy(config);
+    const present = new Set(labels);
+    if (present.has(policy.review) || present.has(policy.waitingHuman))
+        return { status: 'diverged' };
+    const auto = present.has(policy.auto);
+    const running = present.has(policy.running);
+    const blocked = present.has(policy.blocked);
+    if (running || (auto && !blocked))
+        return { status: 'transition' };
+    if (blocked)
+        return { status: 'settled', expected: auto ? [policy.auto, policy.blocked].sort() : [policy.blocked] };
+    return { status: 'settled', expected: [] };
+}
+function sameCheckPolicy(checks, policy) {
+    const expected = Object.entries(policy).sort(([left], [right]) => left.localeCompare(right));
+    const actual = checks.map((check) => [check.id, check.command])
+        .sort(([left], [right]) => left.localeCompare(right));
+    return actual.length === expected.length
+        && actual.every(([id, command], index) => id === expected[index]?.[0] && command === expected[index]?.[1]);
+}
 function sameFreshness(left, right) {
     return left.headSha === right.headSha
         && left.indexTreeSha === right.indexTreeSha