codex-orchestrator 2.0.7 → 2.0.9

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

@@ -5,6 +5,7 @@ import { canonicalJson, sha256 } from './containment.js';
 import { validateImplementationReport } from './implementation-report.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';
@@ -912,7 +913,10 @@ export class RunIssue {
                             && active.record.directReview?.status === 'clear';
                         const feedbackRepair = active.record.reviewFeedback?.phase === 'repairing'
                             && active.record.directReview?.stage === 'review-repair';
-                        if (!reviewRecovery && !checkRecovery && !proofRecovery && !feedbackRepair) {
+                        const qualificationRecovery = active.record.lifecycle === 'implementing'
+                            && !active.record.directReview
+                            && !this.hasRecordedImplementationStart(active.record, config);
+                        if (!reviewRecovery && !checkRecovery && !proofRecovery && !feedbackRepair && !qualificationRecovery) {
                             if (this.repairBudgetExhausted(active, config.runner.maxCycles)) {
                                 return await this.terminal(active, { status: 'blocked', kind: 'exhausted', resumable: true });
                             }
@@ -970,10 +974,10 @@ export class RunIssue {
             }
             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;
+                const qualification = await this.qualifyChecks(active, config, issueSnapshot, frozenCriteria);
+                if ('status' in qualification)
+                    return qualification;
+                active = qualification.active;
             }
             attemptLoop: while (true) {
                 if (!await this.authorized(active, config)) {
@@ -1006,7 +1010,7 @@ export class RunIssue {
                     const feedbackProjection = feedbackBatch
                         ? projectReviewFeedbackBatch(feedbackBatch, active.record.directReview.targetRevision)
                         : undefined;
-                    const feedbackLaunch = feedbackBatch ? {
+                    const implementationLaunch = feedbackBatch ? {
                         reviewFeedbackRound: active.record.reviewFeedback.repairRound,
                         reviewFeedback: feedbackProjection.workerFeedback,
                         onPrepared: async (invocation) => {
@@ -1030,9 +1034,20 @@ export class RunIssue {
                                 },
                             });
                         },
-                    } : {};
+                    } : {
+                        onLaunched: async () => {
+                            const currentActive = active;
+                            const qualification = currentActive.record.checkQualification;
+                            if (!qualification)
+                                throw new Error('implementation launch requires check qualification');
+                            active = await this.persist(currentActive, {
+                                checkQualification: { ...qualification, implementationStarted: true },
+                            });
+                        },
+                    };
                     const deniedPathsBaseline = await this.dependencies.git.fingerprintDeniedPaths(worktreePath, config.deny.readPaths);
                     let implementation = recoveredFeedbackImplementation ?? await this.runImplementation({
+                        operation: 'implementation',
                         runId,
                         worktreePath,
                         issue: publicIssueSnapshot(issueSnapshot),
@@ -1041,7 +1056,7 @@ export class RunIssue {
                         reworkFindings: active.record.reworkFindings,
                         repairOnly: false,
                         workflowGeneration: active.record.workflowGeneration,
-                        ...feedbackLaunch,
+                        ...implementationLaunch,
                     });
                     recoveredFeedbackImplementation = undefined;
                     if (implementation.kind === 'safe-halt') {
@@ -1095,6 +1110,7 @@ export class RunIssue {
                         if (repairBlock)
                             return repairBlock;
                         implementation = await this.runImplementation({
+                            operation: 'implementation',
                             runId,
                             worktreePath,
                             issue: publicIssueSnapshot(issueSnapshot),
@@ -1103,7 +1119,7 @@ export class RunIssue {
                             reworkFindings: ['The previous implementation report did not match the generated schema.'],
                             repairOnly: true,
                             workflowGeneration: active.record.workflowGeneration,
-                            ...feedbackLaunch,
+                            ...implementationLaunch,
                         });
                         if (implementation.kind === 'safe-halt') {
                             active = await this.persist(active, {
@@ -1156,6 +1172,7 @@ export class RunIssue {
                         if (repairBlock)
                             return repairBlock;
                         implementation = await this.runImplementation({
+                            operation: 'implementation',
                             runId,
                             worktreePath,
                             issue: publicIssueSnapshot(issueSnapshot),
@@ -1164,7 +1181,7 @@ export class RunIssue {
                             reworkFindings: [`The report changedFiles must equal the complete current product change set: ${canonicalJson(changedFiles)}.`],
                             repairOnly: true,
                             workflowGeneration: active.record.workflowGeneration,
-                            ...feedbackLaunch,
+                            ...implementationLaunch,
                         });
                         if (implementation.kind === 'safe-halt') {
                             active = await this.persist(active, {
@@ -1252,8 +1269,16 @@ export class RunIssue {
                         });
                     }
                 }
-                const configuredChecks = Object.entries(config.checks);
-                const reusableChecks = active.record.checks.filter((check) => configuredChecks.some(([id, command]) => check.id === id && check.command === command));
+                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) => check.status === 'passed'
+                    && configuredChecks.some(([id, command]) => check.id === id && check.command === command));
                 if (reusableChecks.length !== active.record.checks.length) {
                     active = await this.persist(active, {
                         checks: reusableChecks,
@@ -1262,30 +1287,28 @@ export class RunIssue {
                         proofReceipt: undefined,
                     });
                 }
-                for (const [id, command] of Object.entries(config.checks)) {
+                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')))
+                        && check.status === 'passed'))
                         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, phase: 'changed', 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 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 };
+                    const row = { id, command, status: check.status, outputSha256: check.outputSha256 };
                     active = await this.persist(active, { checks: [...active.record.checks, row] });
-                    if (status === 'failed') {
+                    if (check.status === 'failed') {
                         if (this.repairBudgetExhausted(active, config.runner.maxCycles)) {
                             return active.record.reviewFeedback?.activeBatch
                                 ? await this.blockReviewFeedback(active, 'exhausted', 'review-feedback-check-repair-exhausted')
@@ -1337,7 +1360,7 @@ 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, config.checks)) {
+                if (!sameCheckPolicy(active.record.checks, checkPolicy.checks)) {
                     return await this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true }, 'configured-check-policy-drift');
                 }
                 const payload = {
@@ -1355,9 +1378,9 @@ export class RunIssue {
                     changedFiles: proofChangedFiles,
                     checks: active.record.checks.map((check) => ({
                         ...check,
-                        status: check.status === 'unchanged-failure' ? 'unchanged-failure' : 'passed',
+                        status: 'passed',
                     })),
-                    checkPolicySha256: sha256(canonicalJson(config.checks)),
+                    checkPolicySha256: sha256(canonicalJson(checkPolicy.checks)),
                     packageVersion: active.record.packageVersion,
                     proofSchemaVersion: 1,
                 };
@@ -1871,7 +1894,7 @@ export class RunIssue {
             packageVersion: workflow.receipt.packageVersion,
             workflowGeneration: structuredClone(workflow.receipt),
             skillHashes: structuredClone(workflow.skillHashes),
-            baselineChecks: [], checks: [], createdAt: now, updatedAt: now,
+            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],
@@ -1884,7 +1907,7 @@ export class RunIssue {
             delete record.intent;
         if (Object.hasOwn(changes, 'process') && changes.process === undefined)
             delete record.process;
-        for (const key of ['checkedChangeSha256', 'proofId', 'proofReceipt', 'terminalOutcome', 'outcomeEvidenceId', 'routeExecution', 'routeReceipt', 'reviewFeedback']) {
+        for (const key of ['checkedChangeSha256', 'proofId', 'proofReceipt', 'terminalOutcome', 'outcomeEvidenceId', 'routeExecution', 'routeReceipt', 'reviewFeedback', 'checkQualification', 'baselineChecks']) {
             if (Object.hasOwn(changes, key) && changes[key] === undefined)
                 delete record[key];
         }
@@ -2186,45 +2209,244 @@ export class RunIssue {
         }
         return this.persist(starting, { directReview: withoutInvocation });
     }
-    async captureBaselineChecks(starting, config) {
+    async qualifyChecks(starting, config, issue, frozenCriteria) {
         let active = starting;
-        if ((await this.dependencies.git.listChangedFiles(active.record.worktreePath)).length !== 0)
-            return { active };
-        const configuredChecks = Object.entries(config.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 });
+        let checkPolicy;
+        try {
+            checkPolicy = resolveIssueCheckPolicy(active.record.issueSnapshot.body, config.checks);
         }
-        for (const [id, command] of Object.entries(config.checks)) {
-            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;
+        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 checkPolicySha256 = sha256(canonicalJson(checkPolicy.checks));
+        const existingQualification = active.record.checkQualification;
+        const prior = existingQualification?.checkPolicySha256 === checkPolicySha256
+            ? existingQualification
+            : undefined;
+        let repairAttempts = prior?.repairAttempts ?? 0;
+        const pendingInvocation = existingQualification?.repairInvocation ?? null;
+        if (pendingInvocation) {
+            if (pendingInvocation.phase === 'launched') {
+                try {
+                    await this.dependencies.waitForReviewProcessAbsence(pendingInvocation.processGroupId);
+                }
+                catch {
+                    return this.terminal(active, { status: 'blocked', kind: 'safety', resumable: false }, 'qualification-repair-process-absence-unconfirmed');
+                }
+            }
+            if (!this.dependencies.implementationAgent.recover) {
+                return this.terminal(active, { status: 'blocked', kind: 'safety', resumable: false }, 'qualification-repair-report-recovery-unavailable');
+            }
+            let recovered;
             try {
-                check = await this.dependencies.checks.run({
-                    id,
-                    command,
-                    cwd: active.record.worktreePath,
-                    phase: 'baseline',
-                    signal: this.signal,
+                recovered = await this.dependencies.implementationAgent.recover({
+                    runId: active.record.runId,
+                    canonicalRepository: active.record.canonicalRepository,
+                    invocation: pendingInvocation,
                 });
             }
             catch {
-                continue;
+                return this.terminal(active, { status: 'blocked', kind: 'safety', resumable: false }, 'qualification-repair-report-recovery-failed');
             }
-            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');
+            if (recovered) {
+                const settled = await this.settleQualificationRepair(active, config, recovered);
+                if ('status' in settled)
+                    return settled;
+                active = settled.active;
             }
+            else {
+                const deniedPathsBaseline = active.record.checkQualification?.deniedPathsBaseline;
+                if (!deniedPathsBaseline
+                    || await this.dependencies.git.fingerprintDeniedPaths(active.record.worktreePath, config.deny.readPaths) !== deniedPathsBaseline) {
+                    return this.terminal(active, { status: 'blocked', kind: 'safety', resumable: false }, 'denied-path-modified');
+                }
+                if (!sameFreshness(await this.dependencies.git.snapshot(active.record.worktreePath), pendingInvocation.baseline)) {
+                    return this.terminal(active, { status: 'blocked', kind: 'safety', resumable: false }, 'qualification-repair-worktree-ambiguous');
+                }
+                active = await this.clearQualificationRepairInvocation(active);
+            }
+        }
+        if (!prior) {
             active = await this.persist(active, {
-                baselineChecks: [
-                    ...(active.record.baselineChecks ?? []),
-                    { id, command, status: check.status, outputSha256: check.outputSha256 },
-                ],
+                checkQualification: {
+                    version: 1, checkPolicySha256, repairAttempts, checks: [],
+                    implementationStarted: false, repairInvocation: null,
+                },
+                baselineChecks: undefined,
             });
         }
+        while (true) {
+            const checks = [];
+            const failures = [];
+            for (const [id, command] of configuredChecks) {
+                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: 'qualification',
+                        signal: this.signal,
+                    });
+                }
+                catch (error) {
+                    if (error instanceof CheckProcessQuiescenceError) {
+                        return this.terminal(active, { status: 'blocked', kind: 'safety', resumable: false }, 'check-process-quiescence-unconfirmed');
+                    }
+                    return this.invokedFailure(active, 'qualification-check-execution-failed', error instanceof Error ? error.message : 'The qualification check process did not start or settle. Retry the same run.');
+                }
+                if (this.signal.aborted)
+                    return this.terminal(active, { status: 'cancelled' });
+                checks.push({ id, command, status: check.status, outputSha256: check.outputSha256 });
+                if (check.status === 'failed') {
+                    failures.push(`Pre-implementation scoped check ${id} failed (${command}):\n${check.output.toString('utf8').slice(0, 8 * 1024)}`);
+                }
+            }
+            active = await this.persist(active, {
+                checkQualification: {
+                    version: 1, checkPolicySha256, repairAttempts, checks,
+                    implementationStarted: false, repairInvocation: null,
+                },
+                baselineChecks: undefined,
+            });
+            if (failures.length === 0)
+                return { active };
+            if (repairAttempts >= config.runner.maxCycles) {
+                return this.terminal(active, { status: 'blocked', kind: 'exhausted', resumable: true }, 'qualification-repair-exhausted');
+            }
+            if (!await this.authorized(active, config)) {
+                return this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true });
+            }
+            const deniedPathsBaseline = await this.dependencies.git.fingerprintDeniedPaths(active.record.worktreePath, config.deny.readPaths);
+            const repair = await this.runImplementation({
+                operation: 'qualification-repair',
+                runId: active.record.runId,
+                worktreePath: active.record.worktreePath,
+                issue,
+                frozenCriteria,
+                cycle: repairAttempts + 1,
+                reworkFindings: failures,
+                repairOnly: false,
+                workflowGeneration: active.record.workflowGeneration,
+                onPrepared: async (invocation) => {
+                    active = await this.persist(active, {
+                        checkQualification: {
+                            ...active.record.checkQualification,
+                            implementationStarted: false,
+                            deniedPathsBaseline,
+                            repairInvocation: {
+                                ...structuredClone(invocation), phase: 'prepared',
+                                pid: null, processGroupId: null, launchedAt: null,
+                            },
+                        },
+                    });
+                },
+                onLaunched: async (invocation) => {
+                    const current = active.record.checkQualification?.repairInvocation;
+                    if (!current || current.phase !== 'prepared' || current.attemptId !== invocation.attemptId) {
+                        throw new Error('qualification repair launch mismatch');
+                    }
+                    repairAttempts = (repairAttempts + 1);
+                    active = await this.persist(active, {
+                        checkQualification: {
+                            ...active.record.checkQualification, repairAttempts,
+                            repairInvocation: {
+                                ...current, phase: 'launched', pid: invocation.pid,
+                                processGroupId: invocation.processGroupId, launchedAt: invocation.launchedAt,
+                            },
+                        },
+                    });
+                },
+            });
+            if (repair.kind === 'safe-halt') {
+                active = await this.persist(active, {
+                    lifecycle: 'safe-halt',
+                    process: {
+                        ...repair.process,
+                        purpose: 'implementation',
+                        resumeLifecycle: 'implementing',
+                        resumeReviewStage: null,
+                    },
+                });
+                while (true) {
+                    try {
+                        await repair.waitForAbsence();
+                        break;
+                    }
+                    catch {
+                        await new Promise((resolveWait) => setTimeout(resolveWait, 25));
+                    }
+                }
+                if (await this.dependencies.git.fingerprintDeniedPaths(active.record.worktreePath, config.deny.readPaths) !== deniedPathsBaseline) {
+                    return this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true }, 'denied-path-modified');
+                }
+                return this.terminal(active, { status: 'transport-failed', resumable: false }, 'process-quiescence-delayed');
+            }
+            if (repair.kind !== 'completed'
+                && await this.dependencies.git.fingerprintDeniedPaths(active.record.worktreePath, config.deny.readPaths) !== deniedPathsBaseline) {
+                return this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true }, 'denied-path-modified');
+            }
+            if (repair.kind === 'cancelled')
+                return this.terminal(active, { status: 'cancelled' });
+            if (repair.kind !== 'completed') {
+                return this.invokedFailure(active, 'qualification-repair-agent-failed', 'Qualification repair did not complete. Retry the same run.');
+            }
+            const settled = await this.settleQualificationRepair(active, config, repair);
+            if ('status' in settled)
+                return settled;
+            active = settled.active;
+        }
+    }
+    async settleQualificationRepair(active, config, repair) {
+        const deniedPathsBaseline = active.record.checkQualification?.deniedPathsBaseline;
+        if (!deniedPathsBaseline
+            || await this.dependencies.git.fingerprintDeniedPaths(active.record.worktreePath, config.deny.readPaths) !== deniedPathsBaseline) {
+            return this.terminal(active, { status: 'blocked', kind: 'safety', resumable: false }, 'denied-path-modified');
+        }
+        active = await this.clearQualificationRepairInvocation(active);
+        let report;
+        try {
+            report = validateImplementationReport(repair.report);
+        }
+        catch {
+            return this.invokedFailure(active, 'qualification-repair-report-invalid', 'Qualification repair report was invalid. Retry the same run.');
+        }
+        if (report.status === 'external-block') {
+            return this.terminal(active, { status: 'blocked', kind: 'external', resumable: true }, 'qualification-repair-external-block');
+        }
+        if (await this.dependencies.git.getHead(active.record.worktreePath) !== expectedImplementationHead(active.record)) {
+            return this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true }, 'qualification-repair-head-changed');
+        }
+        const changedFiles = await this.dependencies.git.listChangedFiles(active.record.worktreePath);
+        if (changedFiles.length === 0 || !sameStrings(changedFiles, report.changedFiles)) {
+            return this.invokedFailure(active, 'qualification-repair-change-set-invalid', 'Qualification repair must report the complete cumulative worktree change set.');
+        }
         return { active };
     }
+    async clearQualificationRepairInvocation(active) {
+        const qualification = { ...active.record.checkQualification, implementationStarted: false, repairInvocation: null };
+        delete qualification.deniedPathsBaseline;
+        return this.persist(active, { checkQualification: qualification });
+    }
+    hasRecordedImplementationStart(record, config) {
+        const qualification = record.checkQualification;
+        if (!qualification)
+            return false;
+        let policy;
+        try {
+            policy = resolveIssueCheckPolicy(record.issueSnapshot.body, config.checks);
+        }
+        catch {
+            return false;
+        }
+        return qualification.implementationStarted === true
+            && qualification.checkPolicySha256 === sha256(canonicalJson(policy.checks))
+            && sameCheckPolicy(qualification.checks, policy.checks)
+            && qualification.checks.every((check) => check.status === 'passed');
+    }
     async recoverTerminalReviewReport(active, issue, config, frozenCriteria) {
         const directReview = active.record.directReview;
         const allowLegacyMalformed = directReview?.terminalCode === undefined