codex-orchestrator 2.0.5 → 2.0.7

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

@@ -3,7 +3,7 @@ import { checkedChangePayloadSha256, } from './checked-change.js';
 import { parseAgentAutoConfig } from './config.js';
 import { canonicalJson, sha256 } from './containment.js';
 import { validateImplementationReport } from './implementation-report.js';
-import { acceptApprovedDirectReview, acceptNeedsWorkDirectReview, beginDirectReviewRepair, createInitialDirectReview, directReviewClosureRequestSha256, directReviewTargetFingerprint, launchDirectReviewInvocation, prepareDirectReviewClosure, prepareDirectReviewInvocation, projectTerminalDirectReview, } from './direct-delivery.js';
+import { acceptApprovedDirectReview, acceptNeedsWorkDirectReview, beginDirectReviewRepair, canRecoverTerminalDirectReviewReport, createInitialDirectReview, directReviewClosureRequestSha256, directReviewTargetFingerprint, launchDirectReviewInvocation, MAX_DIRECT_REVIEW_REPORT_REPAIRS, prepareDirectReviewClosure, prepareDirectReviewInvocation, projectTerminalDirectReview, recoverTerminalDirectReviewReport, } from './direct-delivery.js';
 import { ProofLaunchAuthorizationError, ProofQuiescenceError } from './acceptance-proof.js';
 import { RouteInitializationUnrecoverableError, WorkflowGenerationUnrecoverableError, } from './run-store.js';
 import { initialRouteExecution, } from './route-coordinator.js';
@@ -30,56 +30,88 @@ export class RunIssue {
         let observation = await this.readIssue(issueNumber);
         if (!observation || observation.state !== 'OPEN')
             return { result: await this.publicationDiverged(active, 'claim-issue-missing') };
+        const body = claimComment(runId, issueNumber, branchName);
+        const marker = body.split('\n')[0];
+        const commentIntent = { kind: 'comment', issueNumber, marker, bodySha256: sha256(body) };
+        // Compatibility with runs persisted by the former label-first claim order.
+        // If the label effect is already visible, confirm it. Otherwise establish
+        // the trusted claim comment before granting the running status label.
         if (active.record.intent?.kind === 'claim-labels') {
-            if (!sameStrings(observation.labels, expectedLabels)) {
+            if (sameStrings(observation.labels, expectedLabels)) {
+                active = await this.confirmEffect(active);
+            }
+            else if (!this.hasTrustedClaim(observation, active.record)) {
                 const labels = new Set(observation.labels);
                 if (!labels.has(config.github.labels.auto.name)
                     || labels.has(config.github.labels.blocked.name)
-                    || labels.has(config.github.labels.review.name)) {
+                    || labels.has(config.github.labels.review.name)
+                    || labels.has(config.github.labels.waitingHuman.name)) {
                     return { result: await this.publicationDiverged(active, 'claim-labels-diverged') };
                 }
+                active = await this.persist(active, { intent: commentIntent });
+            }
+        }
+        if (!active.record.intent) {
+            observation = await this.readIssue(issueNumber);
+            if (!observation || observation.state !== 'OPEN')
+                return { result: await this.publicationDiverged(active, 'claim-issue-missing') };
+            if (!this.hasTrustedClaim(observation, active.record)) {
+                active = await this.persist(active, { intent: commentIntent });
+            }
+        }
+        if (active.record.intent?.kind === 'comment') {
+            if (active.record.intent.marker !== marker || active.record.intent.bodySha256 !== sha256(body)) {
+                return { result: await this.publicationDiverged(active, 'claim-comment-intent-diverged') };
+            }
+            observation = await this.readIssue(issueNumber);
+            let comments = observation ? commentsWithMarker(observation, marker) : [];
+            if (comments.some((comment) => comment.body !== body) || comments.length > 1) {
+                return { result: await this.publicationDiverged(active, 'claim-comment-diverged') };
+            }
+            if (comments.length === 0) {
                 try {
-                    await this.dependencies.issues.setLabels(issueNumber, expectedLabels);
+                    await this.dependencies.issues.postComment(issueNumber, body);
                 }
                 catch {
-                    return { result: await this.invokedFailure(active, 'claim-labels-delivery-unknown') };
+                    return { result: await this.invokedFailure(active, 'claim-comment-delivery-unknown') };
                 }
                 observation = await this.readIssue(issueNumber);
+                comments = observation ? commentsWithMarker(observation, marker) : [];
             }
-            if (!observation || !sameStrings(observation.labels, expectedLabels)) {
-                return { result: await this.publicationDiverged(active, 'claim-labels-observation-diverged') };
+            if (comments.length !== 1 || comments[0].body !== body
+                || !['OWNER', 'MEMBER', 'COLLABORATOR'].includes(comments[0].authorAssociation)) {
+                return { result: await this.publicationDiverged(active, 'claim-comment-observation-diverged') };
             }
             active = await this.confirmEffect(active);
         }
-        else if (!sameStrings(observation.labels, expectedLabels)) {
-            return { result: await this.publicationDiverged(active, 'claim-labels-missing-before-comment') };
+        observation = await this.readIssue(issueNumber);
+        if (!observation || observation.state !== 'OPEN' || !this.hasTrustedClaim(observation, active.record)) {
+            return { result: await this.publicationDiverged(active, 'claim-comment-observation-diverged') };
+        }
+        if (sameStrings(observation.labels, expectedLabels))
+            return { active };
+        const labels = new Set(observation.labels);
+        if (!labels.has(config.github.labels.auto.name)
+            || labels.has(config.github.labels.blocked.name)
+            || labels.has(config.github.labels.review.name)
+            || labels.has(config.github.labels.waitingHuman.name)) {
+            return { result: await this.publicationDiverged(active, 'claim-labels-diverged') };
         }
-        const body = claimComment(runId, issueNumber, branchName);
-        const marker = body.split('\n')[0];
         if (!active.record.intent) {
-            active = await this.persist(active, { intent: { kind: 'comment', issueNumber, marker, bodySha256: sha256(body) } });
+            active = await this.persist(active, { intent: { kind: 'claim-labels', issueNumber, expected: expectedLabels } });
         }
-        if (active.record.intent?.kind !== 'comment' || active.record.intent.marker !== marker || active.record.intent.bodySha256 !== sha256(body)) {
-            return { result: await this.publicationDiverged(active, 'claim-comment-intent-diverged') };
+        if (active.record.intent?.kind !== 'claim-labels' || !sameStrings(active.record.intent.expected, expectedLabels)) {
+            return { result: await this.publicationDiverged(active, 'claim-labels-intent-diverged') };
         }
-        observation = await this.readIssue(issueNumber);
-        let comments = observation ? commentsWithMarker(observation, marker) : [];
-        if (comments.some((comment) => comment.body !== body) || comments.length > 1) {
-            return { result: await this.publicationDiverged(active, 'claim-comment-diverged') };
+        try {
+            await this.dependencies.issues.setLabels(issueNumber, expectedLabels);
         }
-        if (comments.length === 0) {
-            try {
-                await this.dependencies.issues.postComment(issueNumber, body);
-            }
-            catch {
-                return { result: await this.invokedFailure(active, 'claim-comment-delivery-unknown') };
-            }
-            observation = await this.readIssue(issueNumber);
-            comments = observation ? commentsWithMarker(observation, marker) : [];
+        catch {
+            return { result: await this.invokedFailure(active, 'claim-labels-delivery-unknown') };
         }
-        if (comments.length !== 1 || comments[0].body !== body
-            || !['OWNER', 'MEMBER', 'COLLABORATOR'].includes(comments[0].authorAssociation)) {
-            return { result: await this.publicationDiverged(active, 'claim-comment-observation-diverged') };
+        observation = await this.readIssue(issueNumber);
+        if (!observation || !sameStrings(observation.labels, expectedLabels) || !this.hasTrustedClaim(observation, active.record)) {
+            return { result: await this.publicationDiverged(active, 'claim-labels-observation-diverged') };
         }
         active = await this.confirmEffect(active);
         return { active };
@@ -104,7 +136,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 +168,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 +202,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 +242,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 +268,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 +336,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 +382,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 +442,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 +491,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 +578,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 +627,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 +648,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') };
             }
         }
@@ -706,17 +738,6 @@ export class RunIssue {
                 return await this.preClaimInternal('config-changed-during-owner-acquire', input.issueNumber);
             }
             const config = confirmedConfig.config;
-            try {
-                await this.dependencies.validateContainment(config);
-            }
-            catch {
-                const evidence = await this.dependencies.writeEvidence({
-                    runId: `issue-${input.issueNumber}`,
-                    code: 'containment-certificate-invalid',
-                    summary: 'Containment certification is unavailable or stale.',
-                });
-                return { status: 'blocked', kind: 'safety', resumable: true, evidencePath: evidence.path };
-            }
             if (this.signal.aborted)
                 return await this.preClaimCancelled(input.issueNumber);
             let issue;
@@ -753,15 +774,33 @@ export class RunIssue {
                 if (active.record.intent?.kind === 'review-blocked-labels') {
                     return await this.blockReviewFeedback(active, active.record.intent.blockKind, active.record.intent.evidenceCode);
                 }
+                if (active.record.intent?.kind === 'blocked-labels') {
+                    return await this.publishBlockedTerminal(active, {
+                        status: 'blocked',
+                        kind: active.record.intent.blockKind,
+                        resumable: active.record.intent.resumable,
+                    }, active.record.intent.evidenceCode);
+                }
+                if (existing.terminalOutcome?.status === 'blocked'
+                    && issue?.state === 'OPEN'
+                    && blockedLabelProjection(issue.labels, config).status !== 'settled') {
+                    return await this.reconcilePersistedBlockedTerminal(active, issue, existing.terminalOutcome);
+                }
                 if (existing.terminalOutcome) {
-                    if (existing.terminalOutcome.status !== 'review-ready')
-                        return publicOutcome(existing.terminalOutcome);
-                    const continuation = await this.continueReviewReady(active, targetRoot, config);
-                    if ('result' in continuation)
-                        return continuation.result;
-                    active = continuation.active;
-                    issueSnapshot = structuredClone(active.record.issueSnapshot);
-                    frozenCriteria = structuredClone(active.record.frozenCriteria);
+                    if (existing.terminalOutcome.status !== 'review-ready') {
+                        const recovered = await this.recoverTerminalReviewReport(active, issue, config, frozenCriteria);
+                        if (!recovered)
+                            return publicOutcome(existing.terminalOutcome);
+                        active = recovered;
+                    }
+                    else {
+                        const continuation = await this.continueReviewReady(active, targetRoot, config);
+                        if ('result' in continuation)
+                            return continuation.result;
+                        active = continuation.active;
+                        issueSnapshot = structuredClone(active.record.issueSnapshot);
+                        frozenCriteria = structuredClone(active.record.frozenCriteria);
+                    }
                 }
                 if (active.record.reviewFeedback?.phase === 'frozen') {
                     const activation = await this.resumeActivatedReviewFeedback(active, targetRoot, config);
@@ -779,15 +818,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 +861,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 +899,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)
@@ -889,11 +935,13 @@ export class RunIssue {
                 worktreePath = resolve(targetRoot, config.runner.workspaceRoot, `issue-${input.issueNumber}`);
                 baseSha = await this.dependencies.git.getBaseSha({ targetRoot, baseBranch: config.github.baseBranch });
                 assertGitSha(baseSha, 'baseSha');
-                const runningLabels = sortedUnique([config.github.labels.auto.name, config.github.labels.running.name]);
+                const claimBody = claimComment(runId, input.issueNumber, branchName);
                 active = await this.createRun({
                     runId, issueNumber: input.issueNumber, canonicalRepository, baseSha, branchName, worktreePath,
                     issueSnapshot, frozenCriteria, config,
-                    intent: { kind: 'claim-labels', issueNumber: input.issueNumber, expected: runningLabels },
+                    intent: {
+                        kind: 'comment', issueNumber: input.issueNumber, marker: claimBody.split('\n')[0], bodySha256: sha256(claimBody),
+                    },
                 });
                 const claim = await this.reconcileClaim(active, config);
                 if ('result' in claim)
@@ -902,8 +950,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);
@@ -920,8 +968,15 @@ export class RunIssue {
             if (active.record.lifecycle === 'checking' && !active.record.directReview && active.record.routeReceipt?.route === 'direct') {
                 return await this.terminal(active, { status: 'internal-error', code: 'direct-review-state-missing' });
             }
+            if (active.record.lifecycle === 'implementing' && active.record.routeReceipt?.route === 'direct'
+                && !active.record.directReview) {
+                const baseline = await this.captureBaselineChecks(active, config);
+                if ('status' in baseline)
+                    return baseline;
+                active = baseline.active;
+            }
             attemptLoop: while (true) {
-                if (!await this.authorized(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)
@@ -1197,23 +1252,40 @@ 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));
+                if (reusableChecks.length !== active.record.checks.length) {
+                    active = await this.persist(active, {
+                        checks: reusableChecks,
+                        checkedChangeSha256: undefined,
+                        proofId: undefined,
+                        proofReceipt: undefined,
+                    });
+                }
                 for (const [id, command] of Object.entries(config.checks)) {
-                    if (active.record.checks.some((check) => check.id === id && check.status === 'passed'))
+                    if (active.record.checks.some((check) => check.id === id
+                        && check.command === command
+                        && (check.status === 'passed' || check.status === 'unchanged-failure')))
                         continue;
                     if (this.signal.aborted)
                         return await this.terminal(active, { status: 'cancelled' });
                     let check;
                     try {
-                        check = await this.dependencies.checks.run({ id, command, cwd: worktreePath, signal: this.signal });
+                        check = await this.dependencies.checks.run({ id, command, cwd: worktreePath, phase: 'changed', 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) };
+                    const outputSha256 = check.outputSha256;
+                    const baseline = active.record.baselineChecks?.find((candidate) => candidate.id === id && candidate.command === command);
+                    const status = check.status === 'failed' && baseline?.status === 'failed' && baseline.outputSha256 === outputSha256
+                        ? 'unchanged-failure'
+                        : check.status;
+                    const row = { id, command, status, outputSha256 };
                     active = await this.persist(active, { checks: [...active.record.checks, row] });
-                    if (check.status !== 'passed') {
+                    if (status === 'failed') {
                         if (this.repairBudgetExhausted(active, config.runner.maxCycles)) {
                             return active.record.reviewFeedback?.activeBatch
                                 ? await this.blockReviewFeedback(active, 'exhausted', 'review-feedback-check-repair-exhausted')
@@ -1265,6 +1337,9 @@ export class RunIssue {
                     || reviewedStageBinding.contentSha256 !== proofContentSha256) {
                     return await this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true }, 'checked-change-review-binding-drift');
                 }
+                if (!sameCheckPolicy(active.record.checks, config.checks)) {
+                    return await this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true }, 'configured-check-policy-drift');
+                }
                 const payload = {
                     version: 1,
                     canonicalRepository,
@@ -1278,7 +1353,10 @@ export class RunIssue {
                     untrackedContentSha256: freshness.untrackedContentSha256,
                     worktreeIdentity: freshness.worktreeIdentity,
                     changedFiles: proofChangedFiles,
-                    checks: active.record.checks.map((check) => ({ ...check, status: 'passed' })),
+                    checks: active.record.checks.map((check) => ({
+                        ...check,
+                        status: check.status === 'unchanged-failure' ? 'unchanged-failure' : 'passed',
+                    })),
                     checkPolicySha256: sha256(canonicalJson(config.checks)),
                     packageVersion: active.record.packageVersion,
                     proofSchemaVersion: 1,
@@ -1443,12 +1521,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 +1647,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 +1672,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) };
             }
         }
@@ -1774,7 +1871,7 @@ export class RunIssue {
             packageVersion: workflow.receipt.packageVersion,
             workflowGeneration: structuredClone(workflow.receipt),
             skillHashes: structuredClone(workflow.skillHashes),
-            checks: [], createdAt: now, updatedAt: now,
+            baselineChecks: [], checks: [], createdAt: now, updatedAt: now,
         };
         const saved = await this.dependencies.runRecords.compareAndSwap(state.generation, {
             schema: 'codex-orchestrator.agent-auto-state', version: 2, runs: [...state.runs, record],
@@ -1808,33 +1905,50 @@ 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))
+        if (!labels.has(config.github.labels.auto.name)
+            || labels.has(config.github.labels.blocked.name)
+            || labels.has(config.github.labels.review.name)
+            || labels.has(config.github.labels.waitingHuman.name))
             return false;
-        return this.hasTrustedClaim(issue, 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 +1962,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) {
@@ -1917,9 +2031,7 @@ export class RunIssue {
                 affectedDefectIds: [...directReview.review.affectedDefectIds],
                 fixedRepairFindings: directReview.repairFindings.filter((finding) => finding.status === 'fixed')
                     .map((finding) => ({ id: finding.id, affectedContracts: [...finding.affectedContracts] })),
-                mandatoryCoverage: directReview.stage === 'review-closure'
-                    ? [...directReview.review.coverage]
-                    : ['acceptance-criteria', 'correctness', 'test-quality'],
+                reviewFocus: ['acceptance-criteria', 'correctness', 'test-quality'],
                 workflowGeneration: structuredClone(active.record.workflowGeneration),
                 repairOnly: reportRepair !== undefined,
                 originalReportSha256: reportRepair?.originalReportSha256 ?? null,
@@ -1989,14 +2101,17 @@ export class RunIssue {
                 const current = active.record.directReview;
                 if (!current)
                     return this.terminal(active, { status: 'internal-error', code: 'direct-review-result-orphaned' });
-                if (current.review.reportRepairs >= 1 || reportRepair) {
-                    return this.terminal(active, { status: 'internal-error', code: 'direct-review-report-malformed' });
+                if (current.review.reportRepairs >= MAX_DIRECT_REVIEW_REPORT_REPAIRS) {
+                    return this.terminal(active, { status: 'internal-error', code: 'direct-review-report-malformed' }, 'direct-review-report-malformed');
                 }
                 const { invocation: _invocation, ...withoutInvocation } = structuredClone(current);
                 active = await this.persist(active, {
                     directReview: {
                         ...withoutInvocation,
-                        review: { ...withoutInvocation.review, reportRepairs: 1 },
+                        review: {
+                            ...withoutInvocation.review,
+                            reportRepairs: (withoutInvocation.review.reportRepairs + 1),
+                        },
                     },
                 });
                 reportRepair = {
@@ -2071,6 +2186,89 @@ export class RunIssue {
         }
         return this.persist(starting, { directReview: withoutInvocation });
     }
+    async captureBaselineChecks(starting, config) {
+        let active = starting;
+        if ((await this.dependencies.git.listChangedFiles(active.record.worktreePath)).length !== 0)
+            return { active };
+        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 });
+        }
+        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;
+            try {
+                check = await this.dependencies.checks.run({
+                    id,
+                    command,
+                    cwd: active.record.worktreePath,
+                    phase: 'baseline',
+                    signal: this.signal,
+                });
+            }
+            catch {
+                continue;
+            }
+            if ((await this.dependencies.git.listChangedFiles(active.record.worktreePath)).length !== 0) {
+                return this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true }, 'baseline-check-mutated-worktree');
+            }
+            active = await this.persist(active, {
+                baselineChecks: [
+                    ...(active.record.baselineChecks ?? []),
+                    { id, command, status: check.status, outputSha256: check.outputSha256 },
+                ],
+            });
+        }
+        return { active };
+    }
+    async recoverTerminalReviewReport(active, issue, config, frozenCriteria) {
+        const directReview = active.record.directReview;
+        const allowLegacyMalformed = directReview?.terminalCode === undefined
+            && active.record.outcomeEvidenceId === `evidence:${active.record.runId}:direct-review-report-malformed`;
+        if (!issue || !directReview || active.record.intent || active.record.process
+            || active.record.terminalOutcome?.status !== 'internal-error'
+            || directReview.status !== 'terminal' || directReview.terminalOutcome?.status !== 'internal-error'
+            || !canRecoverTerminalDirectReviewReport(directReview, { allowLegacyMalformed })
+            || !this.isAuthorizedIssue(issue, active.record, config))
+            return undefined;
+        let worktree;
+        try {
+            worktree = await this.dependencies.git.inspectWorktree({
+                worktreePath: active.record.worktreePath,
+                branchName: active.record.branchName,
+                baseSha: active.record.baseSha,
+            });
+        }
+        catch {
+            return undefined;
+        }
+        if (worktree !== 'matching'
+            || await this.dependencies.git.getHead(active.record.worktreePath) !== expectedImplementationHead(active.record))
+            return undefined;
+        const changedFiles = await this.dependencies.git.listChangedFiles(active.record.worktreePath);
+        if (changedFiles.length === 0 || !active.record.routeReceipt)
+            return undefined;
+        const targetFingerprint = directReviewTargetFingerprint({
+            snapshot: await this.dependencies.git.snapshot(active.record.worktreePath),
+            changedFiles,
+            routeDecisionSha256: active.record.routeReceipt.decisionSha256,
+            workflowGenerationHash: active.record.workflowGeneration.generationHash,
+            cycle: active.record.cycle,
+            frozenCriteria,
+        });
+        if (targetFingerprint !== directReview.targetFingerprint)
+            return undefined;
+        return this.persist(active, {
+            lifecycle: 'implementing',
+            directReview: recoverTerminalDirectReviewReport(directReview, { allowLegacyMalformed }),
+            terminalOutcome: undefined,
+            outcomeEvidenceId: undefined,
+        });
+    }
     async startNextCycle(active, findings, sources) {
         if (active.record.directReview?.status === 'clear') {
             const fallbackProvenance = active.record.lifecycle === 'proving' ? 'proof' : 'check';
@@ -2204,14 +2402,109 @@ 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) {
         if (active.record.reviewFeedback?.activeBatch && outcome.status !== 'review-ready') {
             return this.blockReviewFeedback(active, outcome.status === 'blocked' && outcome.kind === 'exhausted' ? 'exhausted' : 'safety', evidenceCode);
         }
+        if (outcome.status === 'blocked') {
+            return this.publishBlockedTerminal(active, outcome, evidenceCode);
+        }
+        return this.persistTerminal(active, outcome, evidenceCode, retainIntent);
+    }
+    async publishBlockedTerminal(starting, outcome, evidenceCode) {
+        let active = starting;
+        const autoBlocked = [active.config.github.labels.auto.name, active.config.github.labels.blocked.name].sort();
+        const blockedOnly = [active.config.github.labels.blocked.name];
+        let expected = autoBlocked;
+        const existing = active.record.intent;
+        if (!existing) {
+            active = await this.persist(active, { intent: {
+                    kind: 'blocked-labels',
+                    issueNumber: active.record.issueNumber,
+                    expected,
+                    blockKind: outcome.kind,
+                    resumable: outcome.resumable,
+                    evidenceCode,
+                } });
+        }
+        else if (existing.kind !== 'blocked-labels'
+            || existing.issueNumber !== active.record.issueNumber
+            || existing.blockKind !== outcome.kind
+            || existing.resumable !== outcome.resumable
+            || existing.evidenceCode !== evidenceCode) {
+            return this.invokedFailure(active, 'blocked-labels-intent-diverged');
+        }
+        else {
+            expected = existing.expected;
+            if (!sameStrings(expected, autoBlocked) && !sameStrings(expected, blockedOnly) && expected.length !== 0) {
+                return this.invokedFailure(active, 'blocked-labels-intent-diverged');
+            }
+        }
+        let issue = await this.readIssue(active.record.issueNumber);
+        if (!issue)
+            return this.invokedFailure(active, 'blocked-labels-issue-missing');
+        let projection = blockedLabelProjection(issue.labels, active.config);
+        if (issue.state === 'OPEN' && projection.status === 'transition') {
+            if (!this.dependencies.issues.transitionToBlocked) {
+                return this.invokedFailure(active, 'blocked-labels-transition-unavailable');
+            }
+            try {
+                await this.dependencies.issues.transitionToBlocked(active.record.issueNumber, blockedLabelPolicy(active.config));
+            }
+            catch {
+                return this.invokedFailure(active, 'blocked-labels-delivery-unknown');
+            }
+            issue = await this.readIssue(active.record.issueNumber);
+            projection = issue ? blockedLabelProjection(issue.labels, active.config) : { status: 'diverged' };
+        }
+        if (!issue)
+            return this.invokedFailure(active, 'blocked-labels-observation-missing');
+        if (issue.state === 'OPEN') {
+            if (projection.status !== 'settled') {
+                return this.invokedFailure(active, 'blocked-labels-observation-diverged');
+            }
+            if (!sameStrings(expected, projection.expected)) {
+                expected = projection.expected;
+                const intent = active.record.intent;
+                if (intent?.kind !== 'blocked-labels')
+                    return this.invokedFailure(active, 'blocked-labels-intent-diverged');
+                try {
+                    active = await this.persist(active, { intent: { ...intent, expected } });
+                }
+                catch {
+                    throw new PostEffectStateError(active);
+                }
+            }
+        }
+        try {
+            return await this.persistTerminal(active, outcome, evidenceCode, false);
+        }
+        catch {
+            throw new PostEffectStateError(active);
+        }
+    }
+    async reconcilePersistedBlockedTerminal(active, issue, outcome) {
+        if (!this.dependencies.issues.transitionToBlocked) {
+            return this.invokedFailure(active, 'blocked-labels-transition-unavailable');
+        }
+        try {
+            await this.dependencies.issues.transitionToBlocked(active.record.issueNumber, blockedLabelPolicy(active.config));
+        }
+        catch {
+            return this.invokedFailure(active, 'blocked-labels-delivery-unknown');
+        }
+        const observation = await this.readIssue(active.record.issueNumber);
+        if (!observation || observation.state !== 'OPEN'
+            || blockedLabelProjection(observation.labels, active.config).status !== 'settled') {
+            return this.invokedFailure(active, 'blocked-labels-observation-diverged');
+        }
+        return publicOutcome(outcome);
+    }
+    async persistTerminal(active, outcome, evidenceCode, retainIntent) {
         const evidence = await this.dependencies.writeEvidence({ runId: active.record.runId, code: evidenceCode, summary: outcome.status });
         const terminalOutcome = { ...outcome, evidencePath: evidence.path };
         const changes = {
@@ -2223,7 +2516,7 @@ export class RunIssue {
         if (outcome.status !== 'review-ready' && active.record.directReview && active.record.directReview.status !== 'terminal') {
             changes.directReview = projectTerminalDirectReview(active.record.directReview, outcome.status === 'blocked'
                 ? { status: 'blocked', kind: outcome.kind }
-                : { status: outcome.status });
+                : { status: outcome.status }, outcome.status === 'internal-error' ? outcome.code : undefined);
         }
         if (active.record.waitingHuman && (active.record.lifecycle === 'waiting-human' || active.record.waitingHuman.phase === 'resumed')) {
             if (active.record.waitingHuman.phase === 'resumed') {
@@ -2285,6 +2578,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');
@@ -2406,6 +2756,36 @@ function sameStrings(left, right) {
     const b = [...right].sort();
     return a.length === b.length && a.every((value, index) => value === b[index]);
 }
+function blockedLabelPolicy(config) {
+    return {
+        auto: config.github.labels.auto.name,
+        running: config.github.labels.running.name,
+        blocked: config.github.labels.blocked.name,
+        review: config.github.labels.review.name,
+        waitingHuman: config.github.labels.waitingHuman.name,
+    };
+}
+function blockedLabelProjection(labels, config) {
+    const policy = blockedLabelPolicy(config);
+    const present = new Set(labels);
+    if (present.has(policy.review) || present.has(policy.waitingHuman))
+        return { status: 'diverged' };
+    const auto = present.has(policy.auto);
+    const running = present.has(policy.running);
+    const blocked = present.has(policy.blocked);
+    if (running || (auto && !blocked))
+        return { status: 'transition' };
+    if (blocked)
+        return { status: 'settled', expected: auto ? [policy.auto, policy.blocked].sort() : [policy.blocked] };
+    return { status: 'settled', expected: [] };
+}
+function sameCheckPolicy(checks, policy) {
+    const expected = Object.entries(policy).sort(([left], [right]) => left.localeCompare(right));
+    const actual = checks.map((check) => [check.id, check.command])
+        .sort(([left], [right]) => left.localeCompare(right));
+    return actual.length === expected.length
+        && actual.every(([id, command], index) => id === expected[index]?.[0] && command === expected[index]?.[1]);
+}
 function sameFreshness(left, right) {
     return left.headSha === right.headSha
         && left.indexTreeSha === right.indexTreeSha
@@ -2422,6 +2802,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');