codex-orchestrator 0.1.51 → 2.0.0

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

@@ -0,0 +1,906 @@
+import { resolve } from 'node:path';
+import { checkedChangePayloadSha256, } from './checked-change.js';
+import { parseAgentAutoConfig } from './config.js';
+import { canonicalJson, sha256 } from './containment.js';
+import { validateImplementationReport } from './implementation-report.js';
+import { ProofQuiescenceError } from './acceptance-proof.js';
+export class OwnerLockSafetyError extends Error {
+}
+export class RunIssue {
+    dependencies;
+    signal;
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+        this.signal = dependencies.signal ?? new AbortController().signal;
+    }
+    async reconcileClaim(starting, config) {
+        let active = starting;
+        const { issueNumber, runId, branchName } = active.record;
+        const expectedLabels = sortedUnique([config.github.labels.auto.name, config.github.labels.running.name]);
+        if (active.record.intent && !['claim-labels', 'comment'].includes(active.record.intent.kind)) {
+            return { result: await this.publicationDiverged(active, 'claim-intent-diverged') };
+        }
+        let observation = await this.readIssue(issueNumber);
+        if (!observation || observation.state !== 'OPEN')
+            return { result: await this.publicationDiverged(active, 'claim-issue-missing') };
+        if (active.record.intent?.kind === 'claim-labels') {
+            if (!sameStrings(observation.labels, expectedLabels)) {
+                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)) {
+                    return { result: await this.publicationDiverged(active, 'claim-labels-diverged') };
+                }
+                try {
+                    await this.dependencies.issues.setLabels(issueNumber, expectedLabels);
+                }
+                catch {
+                    return { result: await this.invokedFailure(active, 'claim-labels-delivery-unknown') };
+                }
+                observation = await this.readIssue(issueNumber);
+            }
+            if (!observation || !sameStrings(observation.labels, expectedLabels)) {
+                return { result: await this.publicationDiverged(active, 'claim-labels-observation-diverged') };
+            }
+            active = await this.confirmEffect(active);
+        }
+        else if (!sameStrings(observation.labels, expectedLabels)) {
+            return { result: await this.publicationDiverged(active, 'claim-labels-missing-before-comment') };
+        }
+        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) } });
+        }
+        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') };
+        }
+        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.postComment(issueNumber, body);
+            }
+            catch {
+                return { result: await this.invokedFailure(active, 'claim-comment-delivery-unknown') };
+            }
+            observation = await this.readIssue(issueNumber);
+            comments = observation ? commentsWithMarker(observation, marker) : [];
+        }
+        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);
+        return { active };
+    }
+    async publish(starting, config, issue, issueNumber) {
+        let active = starting;
+        const { runId, branchName, worktreePath, baseSha } = active.record;
+        const message = `feat: implement #${issueNumber}`;
+        let commitSha = await this.dependencies.git.getHead(worktreePath);
+        if (active.record.intent?.kind === 'commit' || !active.record.intent) {
+            if (!active.record.intent) {
+                if (commitSha === baseSha) {
+                    active = await this.persist(active, {
+                        intent: { kind: 'commit', parentSha: baseSha, treeSha: await this.dependencies.git.getTreeSha(worktreePath), message },
+                    });
+                }
+            }
+            const intent = active.record.intent;
+            if (intent?.kind === 'commit') {
+                if (commitSha === intent.parentSha) {
+                    if (await this.dependencies.git.getTreeSha(worktreePath) !== intent.treeSha)
+                        return await this.publicationDiverged(active, 'commit-tree-diverged');
+                    if (this.signal.aborted)
+                        return await this.terminal(await this.clearIntent(active), { status: 'cancelled' });
+                    if (!await this.authorized(issueNumber, runId, branchName, config))
+                        return await this.revoked(active);
+                    try {
+                        commitSha = await this.dependencies.git.commit({ worktreePath, message: intent.message });
+                    }
+                    catch {
+                        return await this.invokedFailure(active, 'commit-delivery-unknown');
+                    }
+                }
+                const observed = await this.dependencies.git.inspectHead(worktreePath);
+                if (observed.sha !== commitSha || observed.parentSha !== intent.parentSha || observed.treeSha !== intent.treeSha || observed.message !== intent.message) {
+                    return await this.publicationDiverged(active, 'commit-observation-diverged');
+                }
+                active = await this.confirmEffect(active);
+            }
+        }
+        const commit = await this.dependencies.git.inspectHead(worktreePath);
+        if (commit.sha !== commitSha || commit.parentSha !== baseSha || commit.message !== message || commit.treeSha !== await this.dependencies.git.getTreeSha(worktreePath)) {
+            return await this.publicationDiverged(active, 'commit-identity-diverged');
+        }
+        if (active.record.intent?.kind === 'push' || !active.record.intent) {
+            if (!active.record.intent)
+                active = await this.persist(active, { intent: { kind: 'push', branch: branchName, sha: commitSha } });
+            const intent = active.record.intent;
+            if (intent?.kind !== 'push' || intent.branch !== branchName || intent.sha !== commitSha)
+                return await this.publicationDiverged(active, 'push-intent-diverged');
+            let remoteSha = await this.dependencies.git.getRemoteBranchSha(worktreePath, branchName);
+            if (remoteSha && remoteSha !== commitSha)
+                return await this.publicationDiverged(active, 'remote-branch-diverged');
+            if (!remoteSha) {
+                if (this.signal.aborted)
+                    return await this.terminal(await this.clearIntent(active), { status: 'cancelled' });
+                if (!await this.authorized(issueNumber, runId, branchName, config))
+                    return await this.revoked(active);
+                try {
+                    await this.dependencies.git.push({ worktreePath, branchName });
+                }
+                catch {
+                    return await this.invokedFailure(active, 'push-delivery-unknown');
+                }
+                remoteSha = await this.dependencies.git.getRemoteBranchSha(worktreePath, branchName);
+            }
+            if (remoteSha !== commitSha)
+                return await this.publicationDiverged(active, 'push-observation-diverged');
+            active = await this.confirmEffect(active);
+        }
+        else if (await this.dependencies.git.getRemoteBranchSha(worktreePath, branchName) !== commitSha) {
+            return await this.publicationDiverged(active, 'push-missing-before-later-effect');
+        }
+        const prMarker = `<!-- codex-orchestrator:run:${runId}:pr -->`;
+        const prBody = `${prMarker}\n\nCloses #${issueNumber}`;
+        if (active.record.intent?.kind === 'pr' || !active.record.intent) {
+            if (!active.record.intent) {
+                active = await this.persist(active, {
+                    intent: {
+                        kind: 'pr', owner: config.github.owner, repo: config.github.repo, head: branchName,
+                        base: config.github.baseBranch, issueNumber, marker: prMarker,
+                    },
+                });
+            }
+            let observed = await this.dependencies.pullRequests.findOpen({ headBranch: branchName, baseBranch: config.github.baseBranch });
+            if (observed && observed.body !== prBody)
+                return await this.publicationDiverged(active, 'pr-marker-diverged');
+            if (!observed) {
+                if (this.signal.aborted)
+                    return await this.terminal(await this.clearIntent(active), { status: 'cancelled' });
+                if (!await this.authorized(issueNumber, runId, branchName, config))
+                    return await this.revoked(active);
+                try {
+                    await this.dependencies.pullRequests.createDraft({
+                        title: `Implement #${issueNumber}: ${issue.title}`,
+                        body: prBody,
+                        headBranch: branchName,
+                        baseBranch: config.github.baseBranch,
+                    });
+                }
+                catch {
+                    return await this.invokedFailure(active, 'pr-delivery-unknown');
+                }
+                observed = await this.dependencies.pullRequests.findOpen({ headBranch: branchName, baseBranch: config.github.baseBranch });
+            }
+            if (!observed || observed.body !== prBody)
+                return await this.publicationDiverged(active, 'pr-observation-diverged');
+            active = await this.confirmEffect(active);
+        }
+        const pullRequest = await this.dependencies.pullRequests.findOpen({ headBranch: branchName, baseBranch: config.github.baseBranch });
+        if (!pullRequest || pullRequest.body !== prBody)
+            return await this.publicationDiverged(active, 'pr-missing-before-handoff');
+        const handoffMarker = `<!-- codex-orchestrator:run:${runId}:handoff -->`;
+        const handoffBody = `${handoffMarker}\nReview-ready draft PR: ${pullRequest.url}`;
+        if (active.record.intent?.kind === 'comment' || !active.record.intent) {
+            if (!active.record.intent) {
+                active = await this.persist(active, {
+                    intent: { kind: 'comment', issueNumber, marker: handoffMarker, bodySha256: sha256(handoffBody) },
+                });
+            }
+            let observation = await this.readIssue(issueNumber);
+            if (!observation)
+                return await this.publicationDiverged(active, 'issue-missing-during-handoff');
+            let matching = commentsWithMarker(observation, handoffMarker);
+            if (matching.some((comment) => sha256(comment.body) !== sha256(handoffBody)) || matching.length > 1) {
+                return await this.publicationDiverged(active, 'handoff-comment-diverged');
+            }
+            if (matching.length === 0) {
+                if (this.signal.aborted)
+                    return await this.terminal(await this.clearIntent(active), { status: 'cancelled' });
+                if (!await this.authorized(issueNumber, runId, branchName, config))
+                    return await this.revoked(active);
+                try {
+                    await this.dependencies.issues.postComment(issueNumber, handoffBody);
+                }
+                catch {
+                    return await this.invokedFailure(active, 'handoff-comment-delivery-unknown');
+                }
+                observation = await this.readIssue(issueNumber);
+                matching = observation ? commentsWithMarker(observation, handoffMarker) : [];
+            }
+            if (matching.length !== 1 || sha256(matching[0].body) !== sha256(handoffBody)) {
+                return await this.publicationDiverged(active, 'handoff-comment-observation-diverged');
+            }
+            active = await this.confirmEffect(active);
+        }
+        const terminalLabels = [config.github.labels.review.name];
+        if (active.record.intent?.kind === 'labels' || !active.record.intent) {
+            if (!active.record.intent)
+                active = await this.persist(active, { intent: { kind: 'labels', issueNumber, expected: terminalLabels } });
+            let observation = await this.readIssue(issueNumber);
+            if (!observation)
+                return await this.publicationDiverged(active, 'issue-missing-during-labels');
+            if (!sameStrings(observation.labels, terminalLabels)) {
+                if (this.signal.aborted)
+                    return await this.terminal(await this.clearIntent(active), { status: 'cancelled' });
+                if (!await this.authorized(issueNumber, runId, branchName, config))
+                    return await this.revoked(active);
+                try {
+                    await this.dependencies.issues.setLabels(issueNumber, terminalLabels);
+                }
+                catch {
+                    return await this.invokedFailure(active, 'terminal-labels-delivery-unknown');
+                }
+                observation = await this.readIssue(issueNumber);
+            }
+            if (!observation || !sameStrings(observation.labels, terminalLabels))
+                return await this.publicationDiverged(active, 'terminal-labels-diverged');
+        }
+        const evidence = await this.dependencies.writeEvidence({ runId, code: 'review-ready', summary: pullRequest.url });
+        const outcome = { status: 'review-ready', pullRequestUrl: pullRequest.url, evidencePath: evidence.path };
+        try {
+            await this.persist(active, { lifecycle: 'review-ready', intent: undefined, outcomeEvidenceId: evidence.id, terminalOutcome: outcome });
+        }
+        catch {
+            throw new PostEffectStateError(active);
+        }
+        return outcome;
+    }
+    publicationDiverged(active, code) {
+        return this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true }, code);
+    }
+    async runIssue(input) {
+        let owner;
+        let active;
+        try {
+            assertPositiveInteger(input.issueNumber, 'issueNumber');
+            const targetRoot = resolve(input.targetRoot);
+            const initialConfig = await this.readStrictConfig(targetRoot);
+            const canonicalRepository = `${initialConfig.config.github.owner.toLowerCase()}/${initialConfig.config.github.repo.toLowerCase()}`;
+            try {
+                owner = await this.dependencies.ownerLock.acquire({ canonicalRepository, targetRoot });
+            }
+            catch (error) {
+                if (error instanceof OwnerLockSafetyError) {
+                    const evidence = await this.dependencies.writeEvidence({
+                        runId: `issue-${input.issueNumber}`,
+                        code: 'owner-lock-blocked',
+                        summary: 'Repository ownership is ambiguous or already held.',
+                    });
+                    return { status: 'blocked', kind: 'safety', resumable: true, evidencePath: evidence.path };
+                }
+                return await this.preClaimInternal('state-write-failed', input.issueNumber);
+            }
+            const confirmedConfig = await this.readStrictConfig(targetRoot);
+            if (!confirmedConfig.bytes.equals(initialConfig.bytes)
+                || canonicalRepository !== `${confirmedConfig.config.github.owner.toLowerCase()}/${confirmedConfig.config.github.repo.toLowerCase()}`) {
+                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;
+            try {
+                issue = await this.dependencies.issues.read(input.issueNumber);
+            }
+            catch {
+                return await this.preClaimTransport(input.issueNumber);
+            }
+            const persisted = await this.dependencies.runRecords.read();
+            const matchingRuns = persisted.runs.filter((run) => run.issueNumber === input.issueNumber && run.canonicalRepository === canonicalRepository);
+            if (matchingRuns.length > 1)
+                return await this.preClaimInternal('ambiguous-run-state', input.issueNumber);
+            const existing = matchingRuns[0];
+            let issueSnapshot;
+            let frozenCriteria;
+            let runId;
+            let branchName;
+            let worktreePath;
+            let baseSha;
+            if (existing) {
+                const expectedBranch = `codex/issue-${input.issueNumber}`;
+                const expectedWorktree = resolve(targetRoot, config.runner.workspaceRoot, `issue-${input.issueNumber}`);
+                if (existing.branchName !== expectedBranch || existing.worktreePath !== expectedWorktree) {
+                    return await this.preClaimInternal('run-identity-mismatch', input.issueNumber);
+                }
+                if (existing.terminalOutcome)
+                    return publicOutcome(existing.terminalOutcome);
+                active = { state: persisted, record: existing };
+                issueSnapshot = structuredClone(existing.issueSnapshot);
+                frozenCriteria = structuredClone(existing.frozenCriteria);
+                runId = existing.runId;
+                branchName = existing.branchName;
+                worktreePath = existing.worktreePath;
+                baseSha = existing.baseSha;
+                if (existing.lifecycle === 'publishing') {
+                    return await this.publish(active, config, issueSnapshot, input.issueNumber);
+                }
+                if (existing.lifecycle === 'claimed') {
+                    const claim = await this.reconcileClaim(active, config);
+                    if ('result' in claim)
+                        return claim.result;
+                    active = claim.active;
+                    const worktree = await this.dependencies.git.inspectWorktree({ worktreePath, branchName, baseSha });
+                    if (worktree === 'diverged')
+                        return await this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true }, 'claim-worktree-diverged');
+                    if (worktree === 'absent') {
+                        try {
+                            await this.dependencies.git.createWorktree({ targetRoot, worktreePath, branchName, baseBranch: config.github.baseBranch, baseSha });
+                        }
+                        catch {
+                            return await this.terminal(active, { status: 'internal-error', code: 'local-git-effect-failed' });
+                        }
+                    }
+                    active = await this.persist(active, { lifecycle: 'implementing' });
+                }
+                else {
+                    if (existing.lifecycle === 'safe-halt')
+                        return await this.publicationDiverged(active, 'safe-halt-requires-process-absence');
+                    if (!['implementing', 'reworking', 'checking', 'proving'].includes(existing.lifecycle)) {
+                        return await this.terminal(active, { status: 'internal-error', code: 'resume-phase-not-reconciled' });
+                    }
+                    if (existing.cycle >= config.runner.maxCycles) {
+                        return await this.terminal(active, { status: 'blocked', kind: 'exhausted', resumable: true });
+                    }
+                    if (!await this.authorized(input.issueNumber, runId, branchName, config))
+                        return await this.revoked(active);
+                    active = await this.startNextCycle(active, [`Recovered interrupted ${existing.lifecycle} phase.`]);
+                }
+            }
+            else {
+                const ineligible = await this.ineligibilityReason(issue, config);
+                if (ineligible) {
+                    const evidence = await this.dependencies.writeEvidence({ runId: `issue-${input.issueNumber}`, code: 'not-eligible', summary: ineligible });
+                    return { status: 'not-eligible', reason: ineligible, evidencePath: evidence.path };
+                }
+                issueSnapshot = snapshotIssue(issue);
+                frozenCriteria = freezeCriteria(issueSnapshot);
+                runId = this.dependencies.createRunId();
+                assertUuid(runId);
+                branchName = `codex/issue-${input.issueNumber}`;
+                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]);
+                active = await this.createRun({
+                    runId, issueNumber: input.issueNumber, canonicalRepository, baseSha, branchName, worktreePath,
+                    issueSnapshot, frozenCriteria,
+                    intent: { kind: 'claim-labels', issueNumber: input.issueNumber, expected: runningLabels },
+                });
+                const claim = await this.reconcileClaim(active, config);
+                if ('result' in claim)
+                    return claim.result;
+                active = claim.active;
+                try {
+                    await this.dependencies.git.createWorktree({ targetRoot, worktreePath, branchName, baseBranch: config.github.baseBranch, baseSha });
+                }
+                catch {
+                    return await this.terminal(active, { status: 'internal-error', code: 'local-git-effect-failed' });
+                }
+                active = await this.persist(active, { lifecycle: 'implementing' });
+            }
+            attemptLoop: while (true) {
+                if (!await this.authorized(input.issueNumber, runId, branchName, config)) {
+                    return await this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true });
+                }
+                if (this.signal.aborted)
+                    return await this.terminal(active, { status: 'cancelled' });
+                const implementationBaseline = await this.dependencies.git.snapshot(worktreePath);
+                const deniedPathsBaseline = await this.dependencies.git.fingerprintDeniedPaths(worktreePath, config.deny.readPaths);
+                let implementation = await this.runImplementation({
+                    runId,
+                    worktreePath,
+                    issue: issueSnapshot,
+                    frozenCriteria,
+                    cycle: active.record.cycle,
+                    reworkFindings: active.record.reworkFindings,
+                    repairOnly: false,
+                });
+                if (implementation.kind === 'safe-halt') {
+                    active = await this.persist(active, { lifecycle: 'safe-halt', process: implementation.process });
+                    while (true) {
+                        try {
+                            await implementation.waitForAbsence();
+                            break;
+                        }
+                        catch {
+                            await new Promise((resolveWait) => setTimeout(resolveWait, 25));
+                        }
+                    }
+                    if (await this.dependencies.git.fingerprintDeniedPaths(worktreePath, config.deny.readPaths) !== deniedPathsBaseline) {
+                        return await this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true }, 'denied-path-modified');
+                    }
+                    return await this.terminal(active, { status: 'transport-failed', resumable: false }, 'process-quiescence-delayed');
+                }
+                if (await this.dependencies.git.fingerprintDeniedPaths(worktreePath, config.deny.readPaths) !== deniedPathsBaseline) {
+                    return await this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true }, 'denied-path-modified');
+                }
+                if (implementation.kind === 'transport-failed' && implementation.resumable && active.record.transportRetries === 0) {
+                    const afterTransport = await this.dependencies.git.snapshot(worktreePath);
+                    if (!sameFreshness(implementationBaseline, afterTransport)) {
+                        return await this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true }, 'transport-baseline-changed');
+                    }
+                    active = await this.persist(active, { transportRetries: 1 });
+                    continue attemptLoop;
+                }
+                if (implementation.kind !== 'completed')
+                    return await this.mapImplementationFailure(active, implementation);
+                let report;
+                try {
+                    report = validateImplementationReport(implementation.report);
+                }
+                catch {
+                    if (active.record.reportRepairs >= 1) {
+                        return await this.terminal(active, { status: 'internal-error', code: 'implementation-report-malformed' });
+                    }
+                    const repairBaseline = await this.dependencies.git.snapshot(worktreePath);
+                    active = await this.persist(active, { reportRepairs: 1 });
+                    implementation = await this.runImplementation({
+                        runId,
+                        worktreePath,
+                        issue: issueSnapshot,
+                        frozenCriteria,
+                        cycle: active.record.cycle,
+                        reworkFindings: ['The previous implementation report did not match the generated schema.'],
+                        repairOnly: true,
+                    });
+                    if (implementation.kind === 'safe-halt') {
+                        active = await this.persist(active, { lifecycle: 'safe-halt', process: implementation.process });
+                        while (true) {
+                            try {
+                                await implementation.waitForAbsence();
+                                break;
+                            }
+                            catch {
+                                await new Promise((resolveWait) => setTimeout(resolveWait, 25));
+                            }
+                        }
+                        return await this.terminal(active, { status: 'transport-failed', resumable: false }, 'process-quiescence-delayed');
+                    }
+                    if (implementation.kind !== 'completed')
+                        return await this.mapImplementationFailure(active, implementation);
+                    const afterRepair = await this.dependencies.git.snapshot(worktreePath);
+                    if (!sameFreshness(repairBaseline, afterRepair)) {
+                        return await this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true }, 'report-repair-modified-worktree');
+                    }
+                    try {
+                        report = validateImplementationReport(implementation.report);
+                    }
+                    catch {
+                        return await this.terminal(active, { status: 'internal-error', code: 'implementation-report-malformed' });
+                    }
+                }
+                if (report.status === 'external-block') {
+                    return await this.terminal(active, { status: 'blocked', kind: 'external', resumable: true });
+                }
+                if (await this.dependencies.git.getHead(worktreePath) !== baseSha) {
+                    return await this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true });
+                }
+                const changedFiles = await this.dependencies.git.listChangedFiles(worktreePath);
+                if (changedFiles.length === 0 || !sameStrings(changedFiles, report.changedFiles)) {
+                    return await this.terminal(active, { status: 'internal-error', code: 'implementation-change-set-invalid' });
+                }
+                active = await this.persist(active, { lifecycle: 'checking' });
+                for (const [id, command] of Object.entries(config.checks)) {
+                    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 });
+                    }
+                    catch {
+                        return await this.terminal(active, { status: 'internal-error', code: 'configured-check-execution-failed' });
+                    }
+                    if (this.signal.aborted)
+                        return await this.terminal(active, { status: 'cancelled' });
+                    const row = { id, command, status: check.status, outputSha256: sha256(check.output) };
+                    active = await this.persist(active, { checks: [...active.record.checks, row] });
+                    if (check.status !== 'passed') {
+                        if (active.record.cycle >= config.runner.maxCycles) {
+                            return await this.terminal(active, { status: 'blocked', kind: 'exhausted', resumable: true });
+                        }
+                        active = await this.startNextCycle(active, [`Check ${id} failed:\n${check.output.toString('utf8').slice(0, 8 * 1024)}`]);
+                        continue attemptLoop;
+                    }
+                }
+                try {
+                    await this.dependencies.git.stageAll(worktreePath);
+                }
+                catch {
+                    return await this.terminal(active, { status: 'internal-error', code: 'local-git-effect-failed' });
+                }
+                if (await this.dependencies.git.getHead(worktreePath) !== baseSha) {
+                    return await this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true });
+                }
+                const proofChangedFiles = await this.dependencies.git.listChangedFiles(worktreePath);
+                const freshness = await this.dependencies.git.snapshot(worktreePath);
+                const payload = {
+                    version: 1,
+                    canonicalRepository,
+                    runId,
+                    issueNumber: input.issueNumber,
+                    cycle: active.record.cycle,
+                    baseSha,
+                    headSha: freshness.headSha,
+                    indexTreeSha: freshness.indexTreeSha,
+                    trackedContentSha256: freshness.trackedContentSha256,
+                    untrackedContentSha256: freshness.untrackedContentSha256,
+                    worktreeIdentity: freshness.worktreeIdentity,
+                    changedFiles: proofChangedFiles,
+                    checks: active.record.checks.map((check) => ({ ...check, status: 'passed' })),
+                    checkPolicySha256: sha256(canonicalJson(config.checks)),
+                    packageVersion: this.dependencies.packageVersion,
+                    proofSchemaVersion: 1,
+                };
+                const checkedChange = this.dependencies.checkedChangeMint.mint(payload);
+                const checkedChangeSha256 = checkedChangePayloadSha256(payload);
+                const proofId = this.dependencies.createProofId();
+                assertNonEmptyString(proofId, 'proofId');
+                active = await this.persist(active, { lifecycle: 'proving', checkedChangeSha256, proofId });
+                let proof;
+                try {
+                    proof = await this.dependencies.proof.proveChange({ proofId, issue: issueSnapshot, frozenCriteria, checkedChange });
+                }
+                catch (error) {
+                    if (error instanceof ProofQuiescenceError) {
+                        active = await this.persist(active, {
+                            lifecycle: 'safe-halt',
+                            process: {
+                                pid: error.pid,
+                                processGroupId: error.processGroupId,
+                                startedAt: this.timestamp(),
+                                baseline: {
+                                    headSha: freshness.headSha,
+                                    indexTreeSha: freshness.indexTreeSha,
+                                    trackedContentSha256: freshness.trackedContentSha256,
+                                    untrackedContentSha256: freshness.untrackedContentSha256,
+                                    worktreeIdentity: freshness.worktreeIdentity,
+                                },
+                            },
+                        });
+                        while (true) {
+                            try {
+                                await error.waitForAbsence();
+                                break;
+                            }
+                            catch {
+                                await new Promise((resolveWait) => setTimeout(resolveWait, 25));
+                            }
+                        }
+                        return await this.terminal(active, { status: 'transport-failed', resumable: false }, 'proof-process-quiescence-delayed');
+                    }
+                    return await this.terminal(active, { status: 'internal-error', code: 'acceptance-proof-internal-failure' });
+                }
+                if (this.signal.aborted)
+                    return await this.terminal(active, { status: 'cancelled' });
+                if (proof.status === 'needs-rework') {
+                    if (active.record.cycle >= config.runner.maxCycles) {
+                        return await this.terminal(active, { status: 'blocked', kind: 'exhausted', resumable: true });
+                    }
+                    active = await this.startNextCycle(active, proof.findings);
+                    continue attemptLoop;
+                }
+                if (proof.status !== 'passed')
+                    return await this.mapProofFailure(active, proof);
+                active = await this.persist(active, { lifecycle: 'publishing', proofReceipt: proof.receipt, reworkFindings: [] });
+                break;
+            }
+            return await this.publish(active, config, issueSnapshot, input.issueNumber);
+        }
+        catch (error) {
+            if (!active && error instanceof TransportReadError) {
+                return await this.preClaimTransport(input.issueNumber);
+            }
+            if (active && error instanceof PostEffectStateError) {
+                return await this.invokedFailure(error.active, 'post-effect-state-write-failed');
+            }
+            if (active && error instanceof TransportReadError) {
+                return await this.invokedFailure(active, 'authorization-read-failed');
+            }
+            if (active) {
+                try {
+                    return await this.terminal(active, { status: 'internal-error', code: 'state-write-failed' });
+                }
+                catch {
+                    const evidence = await this.dependencies.writeEvidence({ runId: active.record.runId, code: 'state-write-failed', summary: 'Run state failed.' });
+                    return { status: 'internal-error', evidencePath: evidence.path };
+                }
+            }
+            return await this.preClaimInternal('state-write-failed', input.issueNumber);
+        }
+        finally {
+            if (owner) {
+                try {
+                    await owner.release();
+                }
+                catch {
+                    const evidence = await this.dependencies.writeEvidence({
+                        runId: active?.record.runId ?? `issue-${input.issueNumber}`,
+                        code: 'owner-lock-release-failed',
+                        summary: 'Owner lock release failed.',
+                    });
+                    return { status: 'internal-error', evidencePath: evidence.path };
+                }
+            }
+        }
+    }
+    async readStrictConfig(targetRoot) {
+        const value = await this.dependencies.readConfig(targetRoot);
+        return { bytes: Buffer.from(value.bytes), config: parseAgentAutoConfig(structuredClone(value.config)) };
+    }
+    async ineligibilityReason(issue, config) {
+        if (!issue)
+            return 'Issue does not exist.';
+        const labels = new Set(issue.labels);
+        if (issue.state !== 'OPEN')
+            return 'Issue is not open.';
+        if (!labels.has(config.github.labels.auto.name))
+            return 'Issue lacks the auto label.';
+        if ([config.github.labels.running.name, config.github.labels.blocked.name, config.github.labels.review.name].some((label) => labels.has(label))) {
+            return 'Issue already has a terminal or running label.';
+        }
+        const branchName = `codex/issue-${issue.number}`;
+        try {
+            if (await this.dependencies.pullRequests.findOpen({ headBranch: branchName, baseBranch: config.github.baseBranch }))
+                return 'An open pull request already exists.';
+        }
+        catch {
+            throw new TransportReadError();
+        }
+        return undefined;
+    }
+    async createRun(input) {
+        const state = await this.dependencies.runRecords.read();
+        const now = this.timestamp();
+        const record = {
+            ...input,
+            lifecycle: 'claimed', cycle: 1, reportRepairs: 0, transportRetries: 0,
+            reworkFindings: [],
+            packageVersion: this.dependencies.packageVersion,
+            skillHashes: structuredClone(this.dependencies.skillHashes),
+            checks: [], createdAt: now, updatedAt: now,
+        };
+        const saved = await this.dependencies.runRecords.compareAndSwap(state.generation, {
+            schema: 'codex-orchestrator.agent-auto-state', version: 1, runs: [...state.runs, record],
+        });
+        return { state: saved, record: findRun(saved, input.runId) };
+    }
+    async persist(active, changes) {
+        const record = { ...active.record, ...changes, updatedAt: this.timestamp() };
+        if (Object.hasOwn(changes, 'intent') && changes.intent === undefined)
+            delete record.intent;
+        if (Object.hasOwn(changes, 'process') && changes.process === undefined)
+            delete record.process;
+        for (const key of ['checkedChangeSha256', 'proofId', 'proofReceipt', 'terminalOutcome', 'outcomeEvidenceId']) {
+            if (Object.hasOwn(changes, key) && changes[key] === undefined)
+                delete record[key];
+        }
+        const runs = active.state.runs.map((candidate) => candidate.runId === record.runId ? record : candidate);
+        const saved = await this.dependencies.runRecords.compareAndSwap(active.state.generation, {
+            schema: 'codex-orchestrator.agent-auto-state', version: 1, runs,
+        });
+        return { state: saved, record: findRun(saved, record.runId) };
+    }
+    clearIntent(active) {
+        return this.persist(active, { intent: undefined });
+    }
+    async confirmEffect(active) {
+        try {
+            return await this.clearIntent(active);
+        }
+        catch {
+            throw new PostEffectStateError(active);
+        }
+    }
+    async authorized(issueNumber, runId, branchName, config) {
+        const issue = await this.readIssue(issueNumber);
+        if (!issue || 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))
+            return false;
+        const exactBody = claimComment(runId, issueNumber, branchName);
+        const markerPattern = /^<!-- codex-orchestrator:run:([0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}):claim -->$/u;
+        const markers = issue.comments.filter((comment) => markerPattern.test(comment.body.split('\n')[0] ?? ''));
+        if (issue.comments.some((comment) => {
+            const firstLine = comment.body.split('\n')[0] ?? '';
+            return firstLine.startsWith(`<!-- codex-orchestrator:run:${runId}:claim`) && !markerPattern.test(firstLine);
+        }))
+            return false;
+        if (markers.some((comment) => (comment.body.split('\n')[0] ?? '').match(markerPattern)?.[1] !== runId))
+            return false;
+        const current = markers.filter((comment) => comment.body === exactBody);
+        return current.length === 1 && ['OWNER', 'MEMBER', 'COLLABORATOR'].includes(current[0].authorAssociation);
+    }
+    async readIssue(issueNumber) {
+        try {
+            return await this.dependencies.issues.read(issueNumber);
+        }
+        catch {
+            throw new TransportReadError();
+        }
+    }
+    async runImplementation(input) {
+        try {
+            return await this.dependencies.implementationAgent.run({ ...input, signal: this.signal });
+        }
+        catch {
+            return { kind: 'internal-error' };
+        }
+    }
+    async startNextCycle(active, findings) {
+        active = await this.persist(active, { lifecycle: 'reworking', reworkFindings: [...findings] });
+        return this.persist(active, {
+            lifecycle: 'implementing',
+            cycle: (active.record.cycle + 1),
+            packageVersion: this.dependencies.packageVersion,
+            skillHashes: structuredClone(this.dependencies.skillHashes),
+            checks: [],
+            checkedChangeSha256: undefined,
+            proofId: undefined,
+            proofReceipt: undefined,
+        });
+    }
+    async mapImplementationFailure(active, result) {
+        if (result.kind === 'transport-failed')
+            return this.terminal(active, { status: 'transport-failed', resumable: result.resumable });
+        if (result.kind === 'cancelled')
+            return this.terminal(active, { status: 'cancelled' });
+        return this.terminal(active, { status: 'internal-error', code: 'implementation-agent-internal-failure' });
+    }
+    async mapProofFailure(active, proof) {
+        if (proof.status === 'needs-rework')
+            return this.terminal(active, { status: 'internal-error', code: 'proof-rework-loop-not-yet-implemented' });
+        if (proof.status === 'external-block')
+            return this.terminal(active, { status: 'blocked', kind: 'external', resumable: true });
+        if (proof.status === 'transport-failed')
+            return this.terminal(active, { status: 'transport-failed', resumable: proof.resumable });
+        if (proof.status === 'cancelled')
+            return this.terminal(active, { status: 'cancelled' });
+        return this.terminal(active, { status: 'internal-error', code: 'acceptance-proof-internal-failure' });
+    }
+    async revoked(active) {
+        return this.terminal(await this.clearIntent(active), { status: 'blocked', kind: 'safety', resumable: true });
+    }
+    async invokedFailure(active, code) {
+        const evidence = await this.dependencies.writeEvidence({ runId: active.record.runId, code, summary: 'Publication delivery requires reconciliation.' });
+        return { status: 'transport-failed', resumable: true, evidencePath: evidence.path };
+    }
+    async terminal(active, outcome, evidenceCode = outcome.status, retainIntent = false) {
+        const evidence = await this.dependencies.writeEvidence({ runId: active.record.runId, code: evidenceCode, summary: outcome.status });
+        const terminalOutcome = { ...outcome, evidencePath: evidence.path };
+        const changes = {
+            lifecycle: outcome.status,
+            terminalOutcome,
+            outcomeEvidenceId: evidence.id,
+            process: undefined,
+        };
+        if (!retainIntent)
+            changes.intent = undefined;
+        await this.persist(active, changes);
+        return publicOutcome(terminalOutcome);
+    }
+    async preClaimInternal(code, issueNumber) {
+        const evidence = await this.dependencies.writeEvidence({ runId: `issue-${issueNumber}`, code, summary: code });
+        return { status: 'internal-error', evidencePath: evidence.path };
+    }
+    async preClaimCancelled(issueNumber) {
+        const evidence = await this.dependencies.writeEvidence({ runId: `issue-${issueNumber}`, code: 'cancelled', summary: 'Cancelled.' });
+        return { status: 'cancelled', evidencePath: evidence.path };
+    }
+    async preClaimTransport(issueNumber) {
+        const evidence = await this.dependencies.writeEvidence({ runId: `issue-${issueNumber}`, code: 'issue-read-failed', summary: 'Issue read failed.' });
+        return { status: 'transport-failed', resumable: true, evidencePath: evidence.path };
+    }
+    timestamp() {
+        const value = this.dependencies.now();
+        if (Number.isNaN(Date.parse(value)) || new Date(value).toISOString() !== value)
+            throw new Error('runtime clock is invalid');
+        return value;
+    }
+}
+class TransportReadError extends Error {
+}
+class PostEffectStateError extends Error {
+    active;
+    constructor(active) {
+        super('post-effect state write failed');
+        this.active = active;
+    }
+}
+function snapshotIssue(issue) {
+    if (issue.state !== 'OPEN')
+        throw new Error('cannot snapshot a closed issue');
+    return {
+        number: issue.number,
+        title: issue.title,
+        body: issue.body,
+        url: issue.url,
+        state: 'OPEN',
+        labels: sortedUnique(issue.labels),
+    };
+}
+function freezeCriteria(issue) {
+    const lines = issue.body.split(/\r?\n/u);
+    const heading = lines.findIndex((line) => /^#{1,6}\s+acceptance criteria\s*$/iu.test(line.trim()));
+    const texts = [];
+    if (heading >= 0) {
+        for (const line of lines.slice(heading + 1)) {
+            if (/^#{1,6}\s+/u.test(line.trim()))
+                break;
+            const match = line.match(/^\s*[-*]\s+(?:\[[ xX]\]\s*)?(.+?)\s*$/u);
+            const text = match?.[1]?.trim();
+            if (text && !texts.includes(text))
+                texts.push(text);
+        }
+    }
+    if (texts.length === 0)
+        return [{ id: 'fallback-001', order: 1, source: 'fallback', text: `${issue.title}\n\n${issue.body}` }];
+    return texts.map((text, index) => ({ id: `ac-${String(index + 1).padStart(3, '0')}`, order: index + 1, source: 'explicit', text }));
+}
+function claimComment(runId, issueNumber, branchName) {
+    return `<!-- codex-orchestrator:run:${runId}:claim -->\ncodex-orchestrator claimed #${issueNumber} for branch ${branchName}`;
+}
+function findRun(state, runId) {
+    const record = state.runs.find((candidate) => candidate.runId === runId);
+    if (!record)
+        throw new Error('persisted run is missing');
+    return record;
+}
+function publicOutcome(outcome) {
+    if (outcome.status === 'internal-error')
+        return { status: 'internal-error', evidencePath: outcome.evidencePath };
+    return structuredClone(outcome);
+}
+function sameStrings(left, right) {
+    const a = [...left].sort();
+    const b = [...right].sort();
+    return a.length === b.length && a.every((value, index) => value === b[index]);
+}
+function sameFreshness(left, right) {
+    return left.headSha === right.headSha
+        && left.indexTreeSha === right.indexTreeSha
+        && left.trackedContentSha256 === right.trackedContentSha256
+        && left.untrackedContentSha256 === right.untrackedContentSha256
+        && left.worktreeIdentity === right.worktreeIdentity;
+}
+function commentsWithMarker(issue, marker) {
+    return issue.comments.filter((comment) => comment.body.split('\n')[0] === marker);
+}
+function sortedUnique(values) {
+    return [...new Set(values)].sort();
+}
+function assertUuid(value) {
+    if (typeof value !== 'string' || !/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u.test(value))
+        throw new Error('runId is invalid');
+}
+function assertGitSha(value, field) {
+    if (typeof value !== 'string' || !/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/u.test(value))
+        throw new Error(`${field} is invalid`);
+}
+function assertPositiveInteger(value, field) {
+    if (!Number.isSafeInteger(value) || value <= 0)
+        throw new Error(`${field} is invalid`);
+}
+function assertNonEmptyString(value, field) {
+    if (typeof value !== 'string' || value.length === 0 || value.length > 16 * 1024)
+        throw new Error(`${field} is invalid`);
+}
+//# sourceMappingURL=run-issue.js.map