codex-orchestrator 2.0.5 → 2.0.6

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

@@ -104,7 +104,7 @@ export class RunIssue {
                         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))
+                    if (!await this.authorized(active, config))
                         return await this.revoked(active);
                     try {
                         commitSha = await this.dependencies.git.commit({ worktreePath, message: intent.message });
@@ -136,7 +136,7 @@ export class RunIssue {
             if (!remoteSha) {
                 if (this.signal.aborted)
                     return await this.terminal(await this.clearIntent(active), { status: 'cancelled' });
-                if (!await this.authorized(issueNumber, runId, branchName, config))
+                if (!await this.authorized(active, config))
                     return await this.revoked(active);
                 try {
                     await this.dependencies.git.push({ worktreePath, branchName });
@@ -170,7 +170,7 @@ export class RunIssue {
             if (!observed) {
                 if (this.signal.aborted)
                     return await this.terminal(await this.clearIntent(active), { status: 'cancelled' });
-                if (!await this.authorized(issueNumber, runId, branchName, config))
+                if (!await this.authorized(active, config))
                     return await this.revoked(active);
                 try {
                     await this.dependencies.pullRequests.createDraft({
@@ -210,7 +210,7 @@ export class RunIssue {
             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))
+                if (!await this.authorized(active, config))
                     return await this.revoked(active);
                 try {
                     await this.dependencies.issues.postComment(issueNumber, handoffBody);
@@ -236,7 +236,7 @@ export class RunIssue {
             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))
+                if (!await this.authorized(active, config))
                     return await this.revoked(active);
                 try {
                     await this.dependencies.issues.setLabels(issueNumber, terminalLabels);
@@ -304,7 +304,7 @@ export class RunIssue {
             }
             head = await this.dependencies.git.getHead(active.record.worktreePath);
             if (head === intent.parentSha) {
-                if (!await this.authorized(issueNumber, active.record.runId, active.record.branchName, config)) {
+                if (!await this.authorized(active, config)) {
                     return this.blockReviewFeedback(active, 'safety', 'review-feedback-publication-authority-revoked');
                 }
                 const validation = await coordinator.revalidate({ batch, epoch: 'pre-update', expectedHeadSha: oldHead });
@@ -350,7 +350,7 @@ export class RunIssue {
             }
             remote = await this.dependencies.git.getRemoteBranchSha(active.record.worktreePath, active.record.branchName);
             if (remote === oldHead) {
-                if (!await this.authorized(issueNumber, active.record.runId, active.record.branchName, config)) {
+                if (!await this.authorized(active, config)) {
                     return this.blockReviewFeedback(active, 'safety', 'review-feedback-publication-authority-revoked');
                 }
                 const validation = await coordinator.revalidate({ batch, epoch: 'pre-update', expectedHeadSha: oldHead });
@@ -410,7 +410,7 @@ export class RunIssue {
                 return this.blockReviewFeedback(active, 'safety', 'review-feedback-summary-diverged');
             }
             if (matches.length === 0) {
-                if (!await this.authorized(issueNumber, active.record.runId, active.record.branchName, config)) {
+                if (!await this.authorized(active, config)) {
                     return this.blockReviewFeedback(active, 'safety', 'review-feedback-publication-authority-revoked');
                 }
                 try {
@@ -459,7 +459,7 @@ export class RunIssue {
                 return validationFailure;
             let issue = await this.readIssue(issueNumber);
             if (!issue || !sameStrings(issue.labels, finalLabels)) {
-                if (!await this.authorized(issueNumber, active.record.runId, active.record.branchName, config)) {
+                if (!await this.authorized(active, config)) {
                     return this.blockReviewFeedback(active, 'safety', 'review-feedback-publication-authority-revoked');
                 }
                 try {
@@ -546,7 +546,7 @@ export class RunIssue {
         }
         if (feedback.phase !== 'idle' || observed.status === 'none')
             return { result: publicOutcome(terminal) };
-        if (!await this.authorizedForExactLabels(starting.record.issueNumber, starting.record.runId, starting.record.branchName, [config.github.labels.review.name])) {
+        if (!await this.authorizedForExactLabels(starting, [config.github.labels.review.name])) {
             return { result: publicOutcome(terminal) };
         }
         const projected = projectReviewFeedbackBatch(observed.batch, starting.record.directReview.targetRevision);
@@ -595,9 +595,9 @@ export class RunIssue {
         }
         const issue = await this.readIssue(active.record.issueNumber);
         const labelsAreRunning = !!issue && issue.state === 'OPEN' && sameStrings(issue.labels, runningLabels)
-            && this.hasTrustedClaim(issue, active.record.runId, active.record.issueNumber, active.record.branchName);
+            && this.hasTrustedClaim(issue, active.record);
         const labelsAreReview = !!issue && issue.state === 'OPEN' && sameStrings(issue.labels, reviewLabels)
-            && this.hasTrustedClaim(issue, active.record.runId, active.record.issueNumber, active.record.branchName);
+            && this.hasTrustedClaim(issue, active.record);
         if (!labelsAreRunning && !labelsAreReview) {
             return { result: await this.blockReviewFeedback(active, 'safety', 'review-feedback-activation-authority-revoked') };
         }
@@ -616,7 +616,7 @@ export class RunIssue {
             }
             const observed = await this.readIssue(active.record.issueNumber);
             if (!observed || !sameStrings(observed.labels, runningLabels)
-                || !this.hasTrustedClaim(observed, active.record.runId, active.record.issueNumber, active.record.branchName)) {
+                || !this.hasTrustedClaim(observed, active.record)) {
                 return { result: await this.blockReviewFeedback(active, 'safety', 'review-feedback-activation-labels-diverged') };
             }
         }
@@ -779,15 +779,22 @@ export class RunIssue {
                     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');
+                    let worktree;
+                    try {
+                        worktree = await this.dependencies.git.inspectWorktree({ worktreePath, branchName, baseSha });
+                    }
+                    catch (error) {
+                        return await this.invokedFailure(active, 'local-git-worktree-inspection-failed', claimedWorktreeInspectionFailureSummary(error));
+                    }
+                    if (worktree === 'diverged') {
+                        return await this.invokedFailure(active, 'local-git-worktree-diverged', 'The claimed worktree path is present but does not match the expected branch and base. Correct or preserve the local artifact, then retry the same run.');
+                    }
                     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' });
+                        catch (error) {
+                            return await this.invokedFailure(active, 'local-git-worktree-creation-failed', worktreeCreationFailureSummary(error));
                         }
                     }
                     active = await this.initializeClaimedRun(active, issue);
@@ -815,7 +822,7 @@ export class RunIssue {
                         frozenCriteria = structuredClone(active.record.frozenCriteria);
                     }
                     if (existing.lifecycle === 'spec-authoring') {
-                        if (!await this.authorized(input.issueNumber, runId, branchName, config))
+                        if (!await this.authorized(active, config))
                             return await this.revoked(active);
                         return await this.continueSpecRequired(active);
                     }
@@ -853,7 +860,7 @@ export class RunIssue {
                     if (!['triaging', 'routed', 'implementing', 'reworking', 'checking', 'proving'].includes(active.record.lifecycle)) {
                         return await this.terminal(active, { status: 'internal-error', code: 'resume-phase-not-reconciled' });
                     }
-                    if (!await this.authorized(input.issueNumber, runId, branchName, config))
+                    if (!await this.authorized(active, config))
                         return await this.revoked(active);
                     if (active.record.lifecycle !== 'triaging' && active.record.lifecycle !== 'routed') {
                         if (!active.record.routeExecution || !active.record.routeReceipt)
@@ -902,8 +909,8 @@ export class RunIssue {
                 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' });
+                catch (error) {
+                    return await this.invokedFailure(active, 'local-git-worktree-creation-failed', worktreeCreationFailureSummary(error));
                 }
                 active = await this.initializeClaimedRun(active, issue);
                 issueSnapshot = structuredClone(active.record.issueSnapshot);
@@ -921,7 +928,7 @@ export class RunIssue {
                 return await this.terminal(active, { status: 'internal-error', code: 'direct-review-state-missing' });
             }
             attemptLoop: while (true) {
-                if (!await this.authorized(input.issueNumber, runId, branchName, config)) {
+                if (!await this.authorized(active, config)) {
                     return await this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true });
                 }
                 if (this.signal.aborted)
@@ -1443,12 +1450,31 @@ export class RunIssue {
         catch {
             throw new RouteInitializationUnrecoverableError();
         }
-        const issueSnapshot = issue?.state === 'OPEN' ? snapshotIssue(issue) : active.record.issueSnapshot;
+        const issueSnapshot = issue?.state === 'OPEN'
+            ? refreshClaimedIssueSnapshot(active.record.issueSnapshot, issue)
+            : active.record.issueSnapshot;
         return this.persist(active, { lifecycle: 'triaging', routeExecution: initialRouteExecution(), issueSnapshot });
     }
     async routeRun(starting, issue, frozenCriteria, worktreePath, config, issueNumber, branchName) {
         let active = starting;
         while (active.record.lifecycle === 'triaging') {
+            let currentIssue;
+            try {
+                currentIssue = await this.readIssue(active.record.issueNumber);
+            }
+            catch (error) {
+                if (error instanceof TransportReadError) {
+                    return { result: await this.invokedFailure(active, 'authorization-read-failed') };
+                }
+                throw error;
+            }
+            if (!currentIssue || !this.isAuthorizedIssue(currentIssue, active.record, config)) {
+                return { result: await this.revoked(active) };
+            }
+            active = await this.persist(active, {
+                issueSnapshot: refreshClaimedIssueSnapshot(active.record.issueSnapshot, currentIssue),
+            });
+            issue = structuredClone(active.record.issueSnapshot);
             const state = {
                 read: async () => requireRouteExecution(active.record.routeExecution),
                 compareAndSwap: async (expected, next) => {
@@ -1550,7 +1576,7 @@ export class RunIssue {
             return { result: await this.terminal(active, { status: 'internal-error', code: 'route-state-not-dispatchable' }) };
         }
         try {
-            if (!await this.authorized(issueNumber, active.record.runId, branchName, config)) {
+            if (!await this.authorized(active, config)) {
                 return { result: await this.revoked(active) };
             }
         }
@@ -1575,7 +1601,7 @@ export class RunIssue {
         if (receipt.route !== 'awaiting-user')
             active = await this.persist(active, { lifecycle });
         try {
-            if (!await this.authorized(issueNumber, active.record.runId, branchName, config)) {
+            if (!await this.authorized(active, config)) {
                 return { result: await this.revoked(active) };
             }
         }
@@ -1808,33 +1834,47 @@ export class RunIssue {
             throw new PostEffectStateError(active);
         }
     }
-    async authorized(issueNumber, runId, branchName, config) {
-        const issue = await this.readIssue(issueNumber);
-        if (!issue || issue.state !== 'OPEN')
+    async authorized(active, config) {
+        const issue = await this.readIssue(active.record.issueNumber);
+        return !!issue && this.isAuthorizedIssue(issue, active.record, config);
+    }
+    isAuthorizedIssue(issue, record, config) {
+        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))
             return false;
-        return this.hasTrustedClaim(issue, runId, issueNumber, branchName);
+        return this.hasTrustedClaim(issue, record);
     }
-    async authorizedForExactLabels(issueNumber, runId, branchName, expectedLabels) {
-        const issue = await this.readIssue(issueNumber);
+    async authorizedForExactLabels(active, expectedLabels) {
+        const issue = await this.readIssue(active.record.issueNumber);
         return !!issue && issue.state === 'OPEN' && sameStrings(issue.labels, expectedLabels)
-            && this.hasTrustedClaim(issue, runId, issueNumber, branchName);
+            && this.hasTrustedClaim(issue, active.record);
     }
-    hasTrustedClaim(issue, runId, issueNumber, branchName) {
-        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] ?? ''));
+    hasTrustedClaim(issue, record) {
+        const exactBody = claimComment(record.runId, record.issueNumber, record.branchName);
+        const markers = issue.comments.filter(isClaimMarkerComment);
         if (issue.comments.some((comment) => {
             const firstLine = comment.body.split('\n')[0] ?? '';
-            return firstLine.startsWith(`<!-- codex-orchestrator:run:${runId}:claim`) && !markerPattern.test(firstLine);
+            return firstLine.startsWith(`<!-- codex-orchestrator:run:${record.runId}:claim`) && !claimMarkerPattern.test(firstLine);
         }))
             return false;
-        if (markers.some((comment) => (comment.body.split('\n')[0] ?? '').match(markerPattern)?.[1] !== runId))
+        const currentMarkers = markers.filter((comment) => claimRunId(comment) === record.runId);
+        if (currentMarkers.some((comment) => comment.body !== exactBody
+            || !['OWNER', 'MEMBER', 'COLLABORATOR'].includes(comment.authorAssociation)))
             return false;
-        const current = markers.filter((comment) => comment.body === exactBody);
-        return current.length === 1 && ['OWNER', 'MEMBER', 'COLLABORATOR'].includes(current[0].authorAssociation);
+        const historicalClaims = historicalClaimCounts(record);
+        for (const comment of markers) {
+            const markerRunId = claimRunId(comment);
+            if (markerRunId === record.runId)
+                continue;
+            const key = observedHistoricalClaimKeys(comment, record)
+                .find((candidate) => (historicalClaims.get(candidate) ?? 0) > 0);
+            if (!key)
+                return false;
+            historicalClaims.set(key, historicalClaims.get(key) - 1);
+        }
+        return currentMarkers.length === 1;
     }
     async readIssue(issueNumber) {
         try {
@@ -1848,7 +1888,7 @@ export class RunIssue {
         const batch = active.record.reviewFeedback?.activeBatch;
         if (!batch)
             return undefined;
-        if (!await this.authorized(issueNumber, active.record.runId, active.record.branchName, config)) {
+        if (!await this.authorized(active, config)) {
             return this.blockReviewFeedback(active, 'safety', 'review-feedback-worker-authority-revoked');
         }
         if (!this.dependencies.reviewFeedback) {
@@ -2204,8 +2244,8 @@ export class RunIssue {
     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.' });
+    async invokedFailure(active, code, summary = 'Publication delivery requires reconciliation.') {
+        const evidence = await this.dependencies.writeEvidence({ runId: active.record.runId, code, summary });
         return { status: 'transport-failed', resumable: true, evidencePath: evidence.path };
     }
     async terminal(active, outcome, evidenceCode = outcome.status, retainIntent = false) {
@@ -2285,6 +2325,63 @@ class PostEffectStateError extends Error {
         this.active = active;
     }
 }
+const claimMarkerPattern = /^<!-- 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;
+function isClaimMarkerComment(comment) {
+    return claimMarkerPattern.test(comment.body.split('\n')[0] ?? '');
+}
+function claimRunId(comment) {
+    return (comment.body.split('\n')[0] ?? '').match(claimMarkerPattern)?.[1];
+}
+function trustedHistoricalClaimBodyKey(comment, issueNumber, branchName) {
+    const runId = claimRunId(comment);
+    if (!runId || !['OWNER', 'MEMBER', 'COLLABORATOR'].includes(comment.authorAssociation))
+        return undefined;
+    if (comment.body !== claimComment(runId, issueNumber, branchName))
+        return undefined;
+    return `${comment.authorAssociation}\u0000${comment.body}`;
+}
+function frozenHistoricalClaimKey(comment, issueNumber, branchName) {
+    const bodyKey = trustedHistoricalClaimBodyKey(comment, issueNumber, branchName);
+    if (!bodyKey)
+        return undefined;
+    return comment.id ? `id\u0000${comment.id}\u0000${bodyKey}` : `legacy\u0000${bodyKey}`;
+}
+function observedHistoricalClaimKeys(comment, record) {
+    const bodyKey = trustedHistoricalClaimBodyKey(comment, record.issueNumber, record.branchName);
+    if (!bodyKey)
+        return [];
+    const keys = comment.id ? [`id\u0000${comment.id}\u0000${bodyKey}`] : [];
+    if (timestampAtOrBefore(comment.createdAt, record.createdAt)
+        && timestampAtOrBefore(comment.updatedAt, record.createdAt)) {
+        keys.push(`legacy\u0000${bodyKey}`);
+    }
+    return keys;
+}
+function timestampAtOrBefore(value, cutoff) {
+    if (!value)
+        return false;
+    const timestamp = Date.parse(value);
+    return !Number.isNaN(timestamp) && timestamp <= Date.parse(cutoff);
+}
+function historicalClaimCounts(record) {
+    const counts = new Map();
+    for (const comment of record.issueSnapshot.comments ?? []) {
+        const key = frozenHistoricalClaimKey(comment, record.issueNumber, record.branchName);
+        if (!key || claimRunId(comment) === record.runId)
+            continue;
+        counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+    return counts;
+}
+function refreshClaimedIssueSnapshot(baseline, issue) {
+    return {
+        ...structuredClone(baseline),
+        comments: [
+            ...(baseline.comments ?? []).filter(isClaimMarkerComment),
+            ...issue.comments.filter((comment) => !isClaimMarkerComment(comment)),
+        ],
+    };
+}
 function snapshotIssue(issue) {
     if (issue.state !== 'OPEN')
         throw new Error('cannot snapshot a closed issue');
@@ -2422,6 +2519,21 @@ function commentsWithMarker(issue, marker) {
 function sortedUnique(values) {
     return [...new Set(values)].sort();
 }
+function worktreeCreationFailureSummary(error) {
+    return boundedLocalGitFailureSummary('Local Git worktree creation failed; correct the local Git state and retry the same run.', error);
+}
+function claimedWorktreeInspectionFailureSummary(error) {
+    return boundedLocalGitFailureSummary('The claimed worktree could not be inspected; correct or preserve the local artifact and retry the same run.', error);
+}
+function boundedLocalGitFailureSummary(prefix, error) {
+    const raw = error instanceof Error ? error.message : String(error);
+    const diagnostic = raw
+        .replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/gu, ' ')
+        .trim();
+    if (diagnostic.length === 0)
+        return prefix;
+    return `${prefix}\n${diagnostic.slice(0, 4 * 1024 - prefix.length - 1)}`;
+}
 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');