@kbediako/codex-orchestrator 0.1.37 → 0.2.0

package/dist/orchestrator/src/cli/control/selectedRunProjection.js

@@ -0,0 +1,1838 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { dirname, isAbsolute, join, relative, resolve } from 'node:path';
+import { stripNonApplicableGuardrailSummaryLines } from '../run/manifest.js';
+import { LINEAR_ADVISORY_STATE_FILE } from './controlPersistenceFiles.js';
+import { resolveLegacyWorkspacePathFromRunDir, resolveManifestWorkspacePath, resolveProviderWorkspacePath } from '../run/workspacePath.js';
+import { PROVIDER_LINEAR_CHILD_LANE_PIPELINE_ID, PROVIDER_LINEAR_CHILD_LANE_RESERVED_SUMMARY, PROVIDER_LINEAR_WORKER_CHILD_LANES_FILENAME, PROVIDER_LINEAR_WORKER_PROOF_FILENAME, refreshProviderLinearWorkerProofSnapshot } from '../providerLinearWorkerRunner.js';
+import { buildTrackedLinearPayload } from './observabilityReadModel.js';
+import { buildProviderFallbackTaskId, buildProviderIssueKey, hasQueuedProviderIntakeRetry, readProviderIntakeClaim, selectProviderIntakeClaim } from './providerIntakeState.js';
+import { classifyProviderLinearWorkflowState } from './providerLinearWorkflowStates.js';
+import { buildProviderIssueDebugSnapshot } from './providerIssueObservability.js';
+import { writeJsonAtomic } from '../utils/fs.js';
+import { buildProviderLinearWorkerTerminalSummary, deriveDeterministicProviderMutationSuppressions, formatDeterministicProviderMutationDegradationSummary, isAuxiliaryProviderProofHarnessManifest, isProviderLinearWorkerProofFreshForStage, resolveProviderLinearWorkerAttemptStartedAt, resolveProviderLinearWorkerTerminalReason, resolveProviderLinearWorkerTerminalStatus, shouldUseProviderLinearWorkerTerminalProofForSelectedRun } from './providerLinearWorkerTruth.js';
+const PROVIDER_LINEAR_WORKER_PIPELINE_TITLE = 'Provider Linear Worker';
+const PROVIDER_LINEAR_WORKER_PIPELINE_ID = 'provider-linear-worker';
+const PROVIDER_LINEAR_WORKER_RECONCILIATION_FILENAME = 'provider-linear-worker-reconciliation.json';
+const SYNTHETIC_LINEAR_TASK_ID_PATTERN = /^linear-[a-z0-9]+(?:-[a-z0-9]+)*$/i;
+const PROVIDER_LINEAR_CHILD_PIPELINE_IDS = new Set([
+    'docs-review',
+    'implementation-gate',
+    'docs-relevance-advisory',
+    'provider-linear-child-lane'
+]);
+function selectFreshLinearAdvisoryTrackedIssue(advisoryState) {
+    if (!advisoryState || advisoryState.stale_source) {
+        return null;
+    }
+    return advisoryState.tracked_issue ?? null;
+}
+export function createSelectedRunProjectionReader(context) {
+    let selectedSnapshotPromise = null;
+    let selectedContextPromise = null;
+    let compatibilityContextPromise = null;
+    const readSelectedRunManifestSnapshot = async () => {
+        selectedSnapshotPromise ??= readSelectedRunManifestSnapshotInternal(context);
+        return selectedSnapshotPromise;
+    };
+    const buildSelectedRunContext = async (snapshot = null) => {
+        if (snapshot) {
+            return buildSelectedRunContextFromSnapshot(context, snapshot);
+        }
+        selectedContextPromise ??= (async () => {
+            const selectedSnapshot = await readSelectedRunManifestSnapshot();
+            return buildSelectedRunContextFromSnapshot(context, selectedSnapshot);
+        })();
+        return selectedContextPromise;
+    };
+    const buildCompatibilitySourceContext = async (snapshot = null) => {
+        if (snapshot) {
+            return buildCompatibilitySourceContextFromSnapshot(context, snapshot);
+        }
+        compatibilityContextPromise ??= (async () => {
+            const selectedSnapshot = await readSelectedRunManifestSnapshot();
+            return buildCompatibilitySourceContextFromSnapshot(context, selectedSnapshot);
+        })();
+        return compatibilityContextPromise;
+    };
+    return {
+        readSelectedRunManifestSnapshot,
+        buildSelectedRunContext,
+        buildCompatibilitySourceContext
+    };
+}
+export async function discoverCompatibilityCollectionContexts(context) {
+    const runsRoot = resolveRunsRootFromRunDir(context.paths.runDir);
+    const currentTaskId = resolveTaskIdFromManifestPath(context.paths.manifestPath);
+    const currentRunId = resolveRunIdFromManifestPath(context.paths.manifestPath);
+    if (!runsRoot) {
+        return { running: [], retrying: [], all: [] };
+    }
+    const controlWorkspacePath = await resolveControlWorkspacePath(context);
+    const selectedSnapshot = await readSelectedRunManifestSnapshotInternal(context);
+    const selectedContext = await buildUnreconciledCompatibilitySourceContextFromSnapshot(context, selectedSnapshot);
+    const discovered = await readDiscoveredTaskCompatibilityContexts(context, runsRoot, currentTaskId, currentRunId, controlWorkspacePath);
+    const reconciled = await reconcileProviderLinearWorkerDiscoveredContexts(discovered, context.providerIntakeState ?? null, selectedContext ? [selectedContext] : []);
+    const running = [];
+    const retrying = [];
+    const all = [];
+    for (const entry of reconciled) {
+        const discoveredContext = entry.context;
+        all.push(discoveredContext);
+        if (discoveredContext.rawStatus === 'in_progress') {
+            running.push(discoveredContext);
+            continue;
+        }
+        if ((context.providerIntakeState?.claims.length ?? 0) === 0 && entry.retryFallbackEligible) {
+            retrying.push(discoveredContext);
+        }
+    }
+    return { running, retrying, all };
+}
+async function readDiscoveredTaskCompatibilityContexts(context, runsRoot, currentTaskId, currentRunId, controlWorkspacePath) {
+    const discovered = [];
+    const taskEntries = await readDirectoryNames(runsRoot);
+    for (const taskEntry of taskEntries.sort((left, right) => left.localeCompare(right)).reverse()) {
+        if (taskEntry === 'local-mcp') {
+            continue;
+        }
+        const discoveredContexts = await readTaskCompatibilityContexts(join(runsRoot, taskEntry, 'cli'), {
+            excludeRunId: taskEntry === currentTaskId ? currentRunId : null,
+            providerIntakeState: context.providerIntakeState,
+            controlWorkspacePath
+        });
+        discovered.push(...discoveredContexts);
+    }
+    return discovered;
+}
+export async function discoverAuthoritativeRetryCollectionContexts(context) {
+    if (!context.providerIntakeState) {
+        return [];
+    }
+    const retrying = [];
+    for (const claim of context.providerIntakeState.claims) {
+        if (!hasQueuedProviderIntakeRetry(claim)) {
+            continue;
+        }
+        retrying.push(await buildProviderRetryContextFromClaim(context, claim));
+    }
+    return retrying.sort((left, right) => Date.parse(right.updatedAt ?? '') - Date.parse(left.updatedAt ?? ''));
+}
+async function buildSelectedRunContextFromSnapshot(context, snapshot) {
+    return await reconcileSelectedProviderLinearWorkerContext(context, await buildUnreconciledCompatibilitySourceContextFromSnapshot(context, snapshot));
+}
+async function buildCompatibilitySourceContextFromSnapshot(context, snapshot) {
+    return await reconcileSelectedProviderLinearWorkerContext(context, await buildUnreconciledCompatibilitySourceContextFromSnapshot(context, snapshot));
+}
+async function buildUnreconciledCompatibilitySourceContextFromSnapshot(context, snapshot) {
+    const [parts, controlWorkspacePath] = await Promise.all([
+        resolveProjectionContextParts(context, snapshot),
+        resolveControlWorkspacePath(context)
+    ]);
+    const providerClaim = findMatchingProviderIntakeClaim(context.providerIntakeState, snapshot, parts.providerLinearWorkerProof);
+    return buildProjectionContextFromParts(snapshot, parts, resolveRunsRootFromRunDir(context.paths.runDir), controlWorkspacePath, providerClaim, context.providerIntakeState ?? null);
+}
+async function reconcileSelectedProviderLinearWorkerContext(context, selected) {
+    if (!selected || !context.providerIntakeState) {
+        return selected;
+    }
+    if (!isProviderLinearWorkerReconciliationSource(selected) ||
+        !isActiveLookingProviderLinearWorkerManifestStatus(selected.rawStatus)) {
+        return selected;
+    }
+    const selectedRunDir = selected.runDir ?? (selected.manifestPath ? dirname(selected.manifestPath) : context.paths.runDir);
+    const selectedManifestPath = selected.manifestPath ?? context.paths.manifestPath;
+    const runsRoot = resolveRunsRootFromRunDir(selectedRunDir);
+    const currentTaskId = resolveTaskIdFromManifestPath(selectedManifestPath) ?? selected.taskId;
+    const currentRunId = resolveRunIdFromManifestPath(selectedManifestPath) ?? selected.runId;
+    if (!runsRoot) {
+        return selected;
+    }
+    const controlWorkspacePath = await resolveControlWorkspacePath(context);
+    const discovered = await readDiscoveredTaskCompatibilityContexts(context, runsRoot, currentTaskId, currentRunId, controlWorkspacePath);
+    const [reconciled] = await reconcileProviderLinearWorkerDiscoveredContexts([{ context: selected, retryFallbackEligible: false }], context.providerIntakeState, discovered.map((entry) => entry.context));
+    return (reconciled?.context ?? selected);
+}
+function buildProjectionContextFromParts(snapshot, parts, controlRunsRoot, controlWorkspacePath, providerClaim = null, providerIntakeState = null) {
+    if (!snapshot) {
+        return null;
+    }
+    const { manifestRecord, taskId, runId } = snapshot;
+    const issueProvider = snapshot.issueProvider ?? providerClaim?.provider ?? null;
+    const allowTrackedIssueFallbackIdentityRebinding = hasProviderLinearClaimBindingProvenance(snapshot, parts.providerLinearWorkerProof);
+    const { issueIdentifier, issueId, lookupAliases } = resolveProjectionIssueIdentity(snapshot, parts.trackedIssue, providerClaim, allowTrackedIssueFallbackIdentityRebinding);
+    const matchedTrackedIssue = resolveProjectionTrackedIssue(parts.trackedIssue, {
+        issueIdentifier,
+        issueId,
+        taskId,
+        runId
+    });
+    const control = parts.control;
+    const manifestRawStatus = readStringValue(manifestRecord, 'status') ?? 'unknown';
+    const startedAt = readStringValue(manifestRecord, 'started_at', 'startedAt') ?? null;
+    const providerProofRecord = (parts.providerLinearWorkerProof ?? null);
+    const proofIsFreshForStage = isProviderLinearWorkerProofFreshForStage(providerProofRecord, startedAt);
+    const useTerminalProof = shouldUseProviderLinearWorkerTerminalProofForSelectedRun(manifestRecord, providerProofRecord);
+    const useScopedTerminalProof = useTerminalProof && proofIsFreshForStage;
+    const proofTerminalStatus = useScopedTerminalProof
+        ? resolveProviderLinearWorkerTerminalStatus(providerProofRecord)
+        : null;
+    const rawStatus = proofTerminalStatus ?? manifestRawStatus;
+    const manifestUpdatedAt = readStringValue(manifestRecord, 'updated_at', 'updatedAt') ?? null;
+    const proofUpdatedAt = useScopedTerminalProof
+        ? readStringValue(providerProofRecord ?? {}, 'updated_at')
+        : null;
+    const updatedAt = proofUpdatedAt && (!manifestUpdatedAt || compareIsoTimestamp(proofUpdatedAt, manifestUpdatedAt) >= 0)
+        ? proofUpdatedAt
+        : manifestUpdatedAt;
+    const manifestCompletedAt = readStringValue(manifestRecord, 'completed_at', 'completedAt');
+    const completedAt = manifestCompletedAt ?? (isTerminalRunStatus(rawStatus) ? proofUpdatedAt ?? updatedAt : null);
+    const manifestSummary = stripNonApplicableGuardrailSummaryLines(manifestRecord, readStringValue(manifestRecord, 'summary'));
+    const proofAttemptStartedAt = useScopedTerminalProof
+        ? resolveProviderLinearWorkerAttemptStartedAt(providerProofRecord)
+        : null;
+    const proofSummary = useScopedTerminalProof && proofTerminalStatus
+        ? buildProviderLinearWorkerTerminalSummary({
+            status: proofTerminalStatus,
+            endReason: resolveProviderLinearWorkerTerminalReason(providerProofRecord),
+            degradationSummary: proofAttemptStartedAt === null
+                ? null
+                : formatDeterministicProviderMutationDegradationSummary(deriveDeterministicProviderMutationSuppressions(parts.providerLinearWorkerProof?.linear_audit ?? null, {
+                    recordedAtNotBefore: proofAttemptStartedAt,
+                    issueId: parts.providerLinearWorkerProof?.issue_id ?? null
+                }))
+        })
+        : null;
+    const providerDebugSnapshot = buildProviderIssueDebugSnapshot({
+        tracked_issue: matchedTrackedIssue,
+        claim: providerClaim,
+        proof: proofIsFreshForStage ? parts.providerLinearWorkerProof : null,
+        rehydrated_at: providerIntakeState?.rehydrated_at ?? null
+    });
+    const terminalMergeCloseoutProgress = resolveTerminalMergeCloseoutProgress({
+        rawStatus,
+        providerDebugSnapshot,
+        trackedIssue: matchedTrackedIssue
+    });
+    const summary = resolveSelectedRunDisplaySummary({
+        manifestRecord,
+        rawStatus,
+        summary: proofSummary ?? manifestSummary,
+        terminalMergeCloseoutProgress
+    });
+    const workspacePath = resolveSelectedRunWorkspacePath({
+        manifestRecord,
+        manifestPath: snapshot.manifestPath,
+        controlRunsRoot,
+        controlWorkspacePath
+    });
+    const questionSummary = buildSelectedRunQuestionSummary(parts.questions);
+    const latestAction = control.latest_action?.action ?? null;
+    const compatibilityState = resolveCompatibilityState(shouldPreferTrackedIssueCompatibilityState(matchedTrackedIssue, providerClaim)
+        ? matchedTrackedIssue
+        : null, providerClaim);
+    const { displayStatus, statusReason } = resolveSelectedRunDisplayStatus({
+        rawStatus,
+        latestAction,
+        questionSummary,
+        compatibilityState,
+        terminalMergeCloseoutProgress
+    });
+    const tracked = buildTrackedLinearPayload(matchedTrackedIssue);
+    const latestEvent = buildSelectedRunLatestEvent({
+        controlAction: control.latest_action ?? null,
+        updatedAt,
+        summary,
+        fallbackEvent: rawStatus,
+        providerDebugSnapshot,
+        terminalMergeCloseoutProgress
+    });
+    const lastError = terminalMergeCloseoutProgress?.status === 'failed'
+        ? terminalMergeCloseoutProgress.stall_reason ??
+            summary ??
+            'merge_closeout_failed'
+        : rawStatus === 'failed'
+            ? summary ?? control.latest_action?.reason ?? 'run_failed'
+            : latestAction === 'fail'
+                ? control.latest_action?.reason ?? manifestSummary ?? 'run_failed'
+                : null;
+    return {
+        issueProvider,
+        issueIdentifier,
+        issueId,
+        taskId,
+        runId,
+        lookupAliases,
+        rawStatus,
+        displayStatus,
+        statusReason,
+        startedAt,
+        updatedAt,
+        completedAt,
+        summary,
+        lastError,
+        latestAction,
+        latestEvent,
+        workspacePath,
+        pipelineId: readStringValue(manifestRecord, 'pipeline_id', 'pipelineId') ?? null,
+        pipelineTitle: readStringValue(manifestRecord, 'pipeline_title', 'pipelineTitle') ?? null,
+        stages: readManifestStageSummaries(manifestRecord),
+        approvalsTotal: readManifestApprovalsTotal(manifestRecord),
+        manifestPath: snapshot.manifestPath,
+        runDir: snapshot.runDir,
+        questionSummary,
+        tracked,
+        compatibilityState: compatibilityState?.state ?? null,
+        providerLinearWorkerProof: parts.providerLinearWorkerProof,
+        providerDebugSnapshot,
+        providerRetryState: buildProviderRetryState(providerClaim)
+    };
+}
+function resolveProjectionIssueIdentity(snapshot, trackedIssue, providerClaim, allowTrackedIssueFallbackIdentityRebinding) {
+    const manifestIssueIdentifier = isProjectionFallbackIdentityValue(snapshot.issueIdentifier, snapshot)
+        ? null
+        : snapshot.issueIdentifier;
+    const manifestIssueId = isProjectionFallbackIdentityValue(snapshot.issueId, snapshot)
+        ? null
+        : snapshot.issueId;
+    const issueIdentifier = manifestIssueIdentifier ??
+        providerClaim?.issue_identifier ??
+        (allowTrackedIssueFallbackIdentityRebinding ? trackedIssue?.identifier : null) ??
+        snapshot.issueIdentifier;
+    const trackedIssueId = allowTrackedIssueFallbackIdentityRebinding &&
+        trackedIssue?.identifier === issueIdentifier
+        ? trackedIssue.id
+        : null;
+    const issueId = manifestIssueId ??
+        providerClaim?.issue_id ??
+        trackedIssueId ??
+        snapshot.issueId;
+    return {
+        issueIdentifier,
+        issueId,
+        lookupAliases: Array.from(new Set(snapshot.lookupAliases.concat(buildProjectionLookupAliases({
+            issueIdentifier,
+            issueId,
+            taskId: snapshot.taskId,
+            runId: snapshot.runId
+        }))))
+    };
+}
+function resolveProjectionTrackedIssue(trackedIssue, identity) {
+    if (!trackedIssue) {
+        return null;
+    }
+    if (!hasAuthoritativeProjectionIssueIdentity(identity)) {
+        return trackedIssue;
+    }
+    if (identity.issueId && trackedIssue.id === identity.issueId) {
+        return trackedIssue;
+    }
+    if (trackedIssue.identifier === identity.issueIdentifier) {
+        return trackedIssue;
+    }
+    return null;
+}
+function isProjectionFallbackIdentityValue(value, input) {
+    if (!value) {
+        return false;
+    }
+    return (isProjectionFallbackIdentityAlias(value, input.taskId) ||
+        isProjectionFallbackIdentityAlias(value, input.runId));
+}
+function isProjectionFallbackIdentityAlias(value, candidate) {
+    if (!candidate) {
+        return false;
+    }
+    if (value === candidate) {
+        return true;
+    }
+    return SYNTHETIC_LINEAR_TASK_ID_PATTERN.test(value) && candidate.startsWith(`${value}-`);
+}
+function resolveSelectedRunWorkspacePath(input) {
+    const explicitWorkspacePath = resolveManifestWorkspacePath(input.manifestRecord);
+    if (explicitWorkspacePath) {
+        return explicitWorkspacePath;
+    }
+    if (!input.controlRunsRoot ||
+        !isCliRunManifestPathWithinRunsRoot(input.manifestPath, input.controlRunsRoot)) {
+        return null;
+    }
+    return input.controlWorkspacePath;
+}
+function resolveCompatibilityState(trackedIssue, providerClaim) {
+    const state = trackedIssue?.state ?? providerClaim?.issue_state ?? null;
+    const stateType = trackedIssue?.state_type ?? providerClaim?.issue_state_type ?? null;
+    if (!state && !stateType) {
+        return null;
+    }
+    return {
+        state,
+        stateType
+    };
+}
+function shouldPreferTrackedIssueCompatibilityState(trackedIssue, providerClaim) {
+    if (!trackedIssue) {
+        return false;
+    }
+    if (providerClaim?.reason !== 'provider_issue_rehydrated_active_run') {
+        return true;
+    }
+    const trackedUpdatedAt = trackedIssue.updated_at ?? null;
+    const claimUpdatedAt = providerClaim.issue_updated_at ?? null;
+    if (!claimUpdatedAt) {
+        return true;
+    }
+    if (!trackedUpdatedAt) {
+        return false;
+    }
+    return compareIsoTimestamp(trackedUpdatedAt, claimUpdatedAt) > 0;
+}
+function isCliRunManifestPathWithinRunsRoot(manifestPath, runsRoot) {
+    const relativePath = relative(runsRoot, manifestPath);
+    if (relativePath === '' || isAbsolute(relativePath)) {
+        return false;
+    }
+    const normalizedRelativePath = relativePath.replace(/\\/g, '/');
+    if (normalizedRelativePath.startsWith('../')) {
+        return false;
+    }
+    const segments = normalizedRelativePath.split('/');
+    return (segments.length === 4 &&
+        segments[0].length > 0 &&
+        segments[1] === 'cli' &&
+        segments[2].length > 0 &&
+        segments[3] === 'manifest.json');
+}
+async function readSelectedRunManifestSnapshotInternal(context) {
+    const preferredSnapshot = await resolveProviderSelectedManifestSnapshot(context);
+    if (preferredSnapshot) {
+        return preferredSnapshot;
+    }
+    const manifest = await readJsonFile(context.paths.manifestPath);
+    if (!manifest) {
+        return null;
+    }
+    const control = context.controlStore.snapshot();
+    return buildSelectedRunManifestSnapshot(manifest, context.paths.manifestPath, control.run_id ?? null);
+}
+async function readManifestSnapshotForPath(manifestPath, fallbackRunId = null) {
+    const manifest = await readJsonFile(manifestPath);
+    if (!manifest) {
+        return null;
+    }
+    return buildSelectedRunManifestSnapshot(manifest, manifestPath, readStringValue(manifest, 'run_id') ?? fallbackRunId);
+}
+function buildSelectedRunQuestionSummary(records) {
+    const queued = records.filter((record) => record.status === 'queued');
+    let latestQuestion = null;
+    for (const record of queued) {
+        if (!latestQuestion) {
+            latestQuestion = record;
+            continue;
+        }
+        if (Date.parse(record.queued_at) >= Date.parse(latestQuestion.queued_at)) {
+            latestQuestion = record;
+        }
+    }
+    return {
+        queuedCount: queued.length,
+        latestQuestion: latestQuestion
+            ? {
+                questionId: latestQuestion.question_id,
+                prompt: latestQuestion.prompt,
+                urgency: latestQuestion.urgency,
+                queuedAt: latestQuestion.queued_at
+            }
+            : null
+    };
+}
+function resolveSelectedRunDisplayStatus(input) {
+    if (input.terminalMergeCloseoutProgress) {
+        return {
+            displayStatus: input.terminalMergeCloseoutProgress.phase === 'pending_shared_root_reconciliation'
+                ? 'pending_shared_root_reconciliation'
+                : 'failed',
+            statusReason: input.terminalMergeCloseoutProgress.stall_reason ?? null
+        };
+    }
+    if (input.rawStatus === 'in_progress' && input.latestAction === 'pause') {
+        return {
+            displayStatus: 'paused',
+            statusReason: input.questionSummary.queuedCount > 0 ? 'queued_questions' : 'control_pause'
+        };
+    }
+    if (input.rawStatus === 'in_progress' && input.questionSummary.queuedCount > 0) {
+        return { displayStatus: 'awaiting_input', statusReason: 'queued_questions' };
+    }
+    if (input.rawStatus === 'in_progress') {
+        const operatorVisibleState = resolveOperatorVisibleRunningState(input.compatibilityState);
+        if (operatorVisibleState) {
+            return { displayStatus: operatorVisibleState, statusReason: null };
+        }
+    }
+    return { displayStatus: input.rawStatus, statusReason: null };
+}
+function resolveOperatorVisibleRunningState(compatibilityState) {
+    const normalizedState = compatibilityState?.state?.trim() ?? null;
+    const normalizedStateType = compatibilityState?.stateType?.trim().toLowerCase() ?? null;
+    if (!normalizedState) {
+        return null;
+    }
+    const workflowState = classifyProviderLinearWorkflowState({
+        state: normalizedState,
+        state_type: normalizedStateType
+    });
+    if (workflowState.isTodo ||
+        workflowState.isTerminal ||
+        normalizedStateType === 'triage' ||
+        normalizedStateType === 'backlog' ||
+        normalizedStateType === 'unstarted') {
+        return null;
+    }
+    const stateKey = normalizedState.toLowerCase().replace(/[^a-z0-9]+/g, '');
+    if (stateKey === 'running' || stateKey === 'started') {
+        return normalizedState;
+    }
+    return normalizedState;
+}
+function buildSelectedRunLatestEvent(input) {
+    if (!input.controlAction &&
+        input.terminalMergeCloseoutProgress &&
+        input.providerDebugSnapshot?.progress) {
+        return {
+            at: input.providerDebugSnapshot.progress.summary_recorded_at ??
+                input.providerDebugSnapshot.progress.last_semantic_progress_at ??
+                input.providerDebugSnapshot.last_semantic_progress_at ??
+                input.updatedAt,
+            event: input.terminalMergeCloseoutProgress.phase,
+            message: input.terminalMergeCloseoutProgress.summary ?? input.summary,
+            source: input.terminalMergeCloseoutProgress.event_source ?? 'merge_closeout',
+            messageRecordedAt: input.terminalMergeCloseoutProgress.message_recorded_at ??
+                input.terminalMergeCloseoutProgress.summary_recorded_at ??
+                null,
+            sourceUpdatedAt: input.terminalMergeCloseoutProgress.source_updated_at ??
+                input.terminalMergeCloseoutProgress.last_semantic_progress_at ??
+                input.providerDebugSnapshot.last_semantic_progress_at ??
+                input.updatedAt,
+            candidates: input.terminalMergeCloseoutProgress.event_candidates ?? [],
+            requestedBy: null,
+            reason: input.terminalMergeCloseoutProgress.stall_reason ?? null
+        };
+    }
+    if (!input.controlAction &&
+        input.providerDebugSnapshot?.progress &&
+        hasAuthoritativeProviderDebugEvidence(input.providerDebugSnapshot) &&
+        shouldPreferProviderDebugProgressEvent(input.fallbackEvent)) {
+        return {
+            at: input.providerDebugSnapshot.progress.summary_recorded_at ??
+                input.providerDebugSnapshot.progress.message_recorded_at ??
+                input.providerDebugSnapshot.progress.source_updated_at ??
+                input.providerDebugSnapshot.progress.last_semantic_progress_at ??
+                input.providerDebugSnapshot.last_semantic_progress_at ??
+                input.updatedAt,
+            event: input.providerDebugSnapshot.progress.selected_event ??
+                input.providerDebugSnapshot.progress.phase,
+            message: input.providerDebugSnapshot.progress.summary ?? input.summary,
+            source: input.providerDebugSnapshot.progress.event_source ?? 'provider_debug_progress',
+            messageRecordedAt: input.providerDebugSnapshot.progress.message_recorded_at ??
+                input.providerDebugSnapshot.progress.summary_recorded_at ??
+                null,
+            sourceUpdatedAt: input.providerDebugSnapshot.progress.source_updated_at ??
+                input.providerDebugSnapshot.progress.last_semantic_progress_at ??
+                input.providerDebugSnapshot.last_semantic_progress_at ??
+                input.updatedAt,
+            candidates: input.providerDebugSnapshot.progress.event_candidates ?? [],
+            requestedBy: null,
+            reason: input.providerDebugSnapshot.progress.stall_reason ?? null
+        };
+    }
+    if (!input.controlAction && !input.updatedAt && !input.summary) {
+        return null;
+    }
+    return {
+        at: input.controlAction?.requested_at ?? input.updatedAt,
+        event: input.controlAction?.action ?? input.fallbackEvent,
+        message: input.summary,
+        source: input.controlAction ? 'control_action' : 'run_summary',
+        messageRecordedAt: null,
+        sourceUpdatedAt: input.controlAction?.requested_at ?? input.updatedAt,
+        candidates: [],
+        requestedBy: input.controlAction?.requested_by ?? null,
+        reason: input.controlAction?.reason ?? null
+    };
+}
+function hasAuthoritativeProviderDebugEvidence(providerDebugSnapshot) {
+    const claimIsStale = providerDebugSnapshot.claim?.freshness === 'stale';
+    if (claimIsStale && providerDebugSnapshot.progress?.kind === 'merge_closeout') {
+        return false;
+    }
+    const hasFreshClaim = providerDebugSnapshot.claim !== null && !claimIsStale;
+    const hasFreshPullRequest = providerDebugSnapshot.pull_request !== null && !claimIsStale;
+    return Boolean(hasFreshClaim ||
+        providerDebugSnapshot.worker ||
+        hasFreshPullRequest ||
+        providerDebugSnapshot.last_audit_operation);
+}
+function shouldPreferProviderDebugProgressEvent(fallbackEvent) {
+    return (fallbackEvent === 'in_progress' ||
+        fallbackEvent === 'running' ||
+        fallbackEvent === 'started' ||
+        fallbackEvent === 'resuming');
+}
+function resolveSelectedRunDisplaySummary(input) {
+    if (input.terminalMergeCloseoutProgress?.summary) {
+        return input.terminalMergeCloseoutProgress.summary;
+    }
+    const acceptedProviderRetryResumeAt = readLatestAcceptedProviderRetryResumeAt(input.manifestRecord);
+    const hasFailedCommandsForAuthoritativeAttempt = acceptedProviderRetryResumeAt === null
+        ? manifestHasFailedCommands(input.manifestRecord)
+        : manifestHasFailedCommandsSince(input.manifestRecord, acceptedProviderRetryResumeAt);
+    if (input.rawStatus === 'succeeded' &&
+        input.summary &&
+        hasStaleFailureSummary(input.summary, input.manifestRecord) &&
+        !hasFailedCommandsForAuthoritativeAttempt) {
+        const filteredSummary = filterStaleFailureSummary(input.summary, input.manifestRecord);
+        return filteredSummary ?? 'Completed successfully';
+    }
+    if (input.rawStatus === 'in_progress' &&
+        input.summary &&
+        hasStaleFailureSummary(input.summary, input.manifestRecord) &&
+        acceptedProviderRetryResumeAt !== null &&
+        !manifestHasFailedCommandsSince(input.manifestRecord, acceptedProviderRetryResumeAt)) {
+        const filteredSummary = filterStaleFailureSummary(input.summary, input.manifestRecord);
+        return filteredSummary ?? 'Retry accepted; run resumed after a failed attempt.';
+    }
+    return input.summary;
+}
+function resolveTerminalMergeCloseoutProgress(input) {
+    const progress = input.providerDebugSnapshot?.progress ?? null;
+    if (input.rawStatus !== 'succeeded' ||
+        !progress ||
+        progress.kind !== 'merge_closeout' ||
+        !input.providerDebugSnapshot) {
+        return null;
+    }
+    const isTerminalMergeCloseoutProgress = progress.phase === 'pending_shared_root_reconciliation' ||
+        progress.status === 'failed';
+    if (!isTerminalMergeCloseoutProgress) {
+        return null;
+    }
+    if (hasAuthoritativeProviderDebugEvidence(input.providerDebugSnapshot)) {
+        return progress;
+    }
+    if (input.providerDebugSnapshot.claim?.freshness !== 'stale') {
+        return null;
+    }
+    if (input.trackedIssue && classifyProviderLinearWorkflowState(input.trackedIssue).isTerminal) {
+        return null;
+    }
+    return progress;
+}
+function isTerminalRunStatus(status) {
+    return status === 'succeeded' || status === 'failed' || status === 'cancelled' || status === 'canceled';
+}
+function hasStaleFailureSummary(summary, manifestRecord) {
+    return summary.split('\n').some((line) => isStaleFailureSummaryLine(line, manifestRecord));
+}
+function filterStaleFailureSummary(summary, manifestRecord) {
+    const retainedLines = summary
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0 && !isStaleFailureSummaryLine(line, manifestRecord));
+    if (retainedLines.length === 0) {
+        return null;
+    }
+    return retainedLines.join('\n');
+}
+function isStaleFailureSummaryLine(line, manifestRecord) {
+    const trimmed = line.trim();
+    if (/^Stage '.*' failed with exit code \d+\.$/u.test(trimmed) ||
+        /^Sub-pipeline '.*' failed\.$/u.test(trimmed) ||
+        /^Execution error: .+/u.test(trimmed)) {
+        return true;
+    }
+    if (!/^Sub-pipeline error: .+/u.test(trimmed)) {
+        return false;
+    }
+    return !hasMatchingSkippedSubpipelineErrorSummary(manifestRecord, trimmed);
+}
+function manifestHasFailedCommands(manifestRecord) {
+    const commands = manifestRecord.commands;
+    if (!Array.isArray(commands)) {
+        return false;
+    }
+    return commands.some((command) => {
+        if (!command || typeof command !== 'object') {
+            return false;
+        }
+        return readStringValue(command, 'status') === 'failed';
+    });
+}
+function manifestHasFailedCommandsSince(manifestRecord, sinceAtMs) {
+    const commands = manifestRecord.commands;
+    if (!Array.isArray(commands)) {
+        return false;
+    }
+    return commands.some((command) => {
+        if (!isRecord(command) || readStringValue(command, 'status') !== 'failed') {
+            return false;
+        }
+        const commandFailureAtMs = readLatestCommandFailureTimestampMs(command);
+        if (commandFailureAtMs === null) {
+            return true;
+        }
+        return commandFailureAtMs >= sinceAtMs;
+    });
+}
+function readLatestAcceptedProviderRetryResumeAt(manifestRecord) {
+    const resumeEvents = manifestRecord.resume_events;
+    if (!Array.isArray(resumeEvents)) {
+        return null;
+    }
+    let latestAcceptedAt = null;
+    for (const event of resumeEvents) {
+        if (!isRecord(event) ||
+            readStringValue(event, 'reason') !== 'provider-retry' ||
+            readStringValue(event, 'outcome') !== 'accepted') {
+            continue;
+        }
+        const acceptedAt = Date.parse(readStringValue(event, 'timestamp') ?? '');
+        if (!Number.isFinite(acceptedAt)) {
+            continue;
+        }
+        latestAcceptedAt = latestAcceptedAt === null ? acceptedAt : Math.max(latestAcceptedAt, acceptedAt);
+    }
+    return latestAcceptedAt;
+}
+function readLatestCommandFailureTimestampMs(command) {
+    return readLatestCommandTimestampMs(command);
+}
+function hasMatchingSkippedSubpipelineErrorSummary(manifestRecord, summaryLine) {
+    const commands = manifestRecord.commands;
+    if (!Array.isArray(commands)) {
+        return false;
+    }
+    return commands.some((command) => {
+        if (!isRecord(command) || readStringValue(command, 'status') !== 'skipped') {
+            return false;
+        }
+        if ((readStringValue(command, 'summary') ?? '').trim() !== summaryLine) {
+            return false;
+        }
+        return true;
+    });
+}
+function readLatestCommandTimestampMs(command) {
+    for (const key of ['completed_at', 'completedAt', 'updated_at', 'updatedAt', 'started_at', 'startedAt']) {
+        const value = readStringValue(command, key);
+        const parsed = Date.parse(value ?? '');
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return null;
+}
+function readManifestStageSummaries(manifestRecord) {
+    const commands = manifestRecord.commands;
+    if (!Array.isArray(commands)) {
+        return [];
+    }
+    return commands.flatMap((command) => {
+        if (!isRecord(command)) {
+            return [];
+        }
+        const id = readStringValue(command, 'id');
+        if (!id) {
+            return [];
+        }
+        return [
+            {
+                id,
+                title: readStringValue(command, 'title') ?? id,
+                status: readStringValue(command, 'status') ?? null
+            }
+        ];
+    });
+}
+function readManifestApprovalsTotal(manifestRecord) {
+    return Array.isArray(manifestRecord.approvals) ? manifestRecord.approvals.length : 0;
+}
+async function resolveControlWorkspacePath(context) {
+    const controlManifest = await readJsonFile(context.paths.manifestPath);
+    const explicitWorkspacePath = controlManifest ? resolveManifestWorkspacePath(controlManifest) : null;
+    if (explicitWorkspacePath) {
+        return explicitWorkspacePath;
+    }
+    return resolveSafeLegacyWorkspacePathFromRunDir(context.paths.runDir);
+}
+function resolveSafeLegacyWorkspacePathFromRunDir(runDir) {
+    const legacyWorkspacePath = resolveLegacyWorkspacePathFromRunDir(runDir);
+    const runsRoot = resolveRunsRootFromRunDir(runDir);
+    if (!runsRoot) {
+        return null;
+    }
+    return normalizePathForComparison(runsRoot) === normalizePathForComparison(join(legacyWorkspacePath, '.runs'))
+        ? legacyWorkspacePath
+        : null;
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function resolveRunsRootFromRunDir(runDir) {
+    const candidate = resolve(runDir, '..', '..', '..');
+    return candidate || null;
+}
+function resolveTaskIdFromManifestPath(manifestPath) {
+    const segments = normalizePathForComparison(manifestPath).split('/').filter((segment) => segment.length > 0);
+    const manifestIndex = segments[segments.length - 1] === 'manifest.json' ? segments.length - 1 : segments.length;
+    if (manifestIndex < 3) {
+        return null;
+    }
+    if (segments[manifestIndex - 2] !== 'cli') {
+        return null;
+    }
+    return segments[manifestIndex - 3] ?? null;
+}
+function resolveRunIdFromManifestPath(manifestPath) {
+    const normalizedPath = manifestPath.replace(/\\/g, '/');
+    const match = normalizedPath.match(/\/cli\/([^/]+)\/manifest\.json$/);
+    return match?.[1] ?? null;
+}
+function normalizePathForComparison(pathname) {
+    return resolve(pathname).replace(/\\/g, '/');
+}
+async function resolveProjectionContextParts(context, snapshot) {
+    if (!snapshot || snapshot.runDir === context.paths.runDir) {
+        return {
+            control: context.controlStore.snapshot(),
+            questions: context.questionQueue.list(),
+            runDir: context.paths.runDir,
+            trackedIssue: selectFreshLinearAdvisoryTrackedIssue(context.linearAdvisoryState),
+            providerLinearWorkerProof: await readProviderLinearWorkerProofForProjection(context.paths.runDir)
+        };
+    }
+    const control = normalizeControlState(await readJsonFile(join(snapshot.runDir, 'control.json')), snapshot.runId);
+    const questionSnapshot = await readJsonFile(join(snapshot.runDir, 'questions.json'));
+    const advisoryState = await readJsonFile(join(snapshot.runDir, LINEAR_ADVISORY_STATE_FILE));
+    return {
+        control,
+        questions: Array.isArray(questionSnapshot?.questions) ? questionSnapshot.questions : [],
+        runDir: snapshot.runDir,
+        trackedIssue: selectFreshLinearAdvisoryTrackedIssue(advisoryState),
+        providerLinearWorkerProof: await readProviderLinearWorkerProofForProjection(snapshot.runDir)
+    };
+}
+function buildSelectedRunManifestSnapshot(manifestRecord, manifestPath, fallbackRunId) {
+    const issueProvider = readStringValue(manifestRecord, 'issue_provider', 'issueProvider') ?? null;
+    const taskId = readStringValue(manifestRecord, 'task_id', 'taskId') ?? resolveTaskIdFromManifestPath(manifestPath);
+    const runId = readStringValue(manifestRecord, 'run_id', 'runId') ??
+        fallbackRunId ??
+        resolveRunIdFromManifestPath(manifestPath);
+    const issueIdentifier = readStringValue(manifestRecord, 'issue_identifier', 'issueIdentifier') ?? taskId ?? runId;
+    const issueId = readStringValue(manifestRecord, 'issue_id', 'issueId') ?? taskId ?? runId;
+    if (!issueIdentifier) {
+        return null;
+    }
+    return {
+        manifestRecord,
+        manifestPath,
+        runDir: dirname(manifestPath),
+        issueProvider,
+        issueIdentifier,
+        issueId,
+        taskId,
+        runId,
+        lookupAliases: buildProjectionLookupAliases({
+            issueIdentifier,
+            issueId,
+            taskId,
+            runId
+        })
+    };
+}
+function normalizeControlState(snapshot, runId) {
+    return {
+        run_id: snapshot?.run_id ?? runId ?? 'unknown-run',
+        control_seq: typeof snapshot?.control_seq === 'number' ? snapshot.control_seq : 0,
+        latest_action: snapshot?.latest_action ?? null,
+        feature_toggles: snapshot?.feature_toggles ?? null,
+        transport_mutation: snapshot?.transport_mutation ?? null
+    };
+}
+async function readTaskCompatibilityContexts(cliRoot, options = {}) {
+    const discovered = [];
+    const runEntries = await readDirectoryNames(cliRoot);
+    for (const runEntry of runEntries.sort((left, right) => left.localeCompare(right)).reverse()) {
+        if (options.excludeRunId && runEntry === options.excludeRunId) {
+            continue;
+        }
+        const runDir = join(cliRoot, runEntry);
+        const manifestPath = join(runDir, 'manifest.json');
+        const manifest = await readJsonFile(manifestPath);
+        if (!manifest) {
+            continue;
+        }
+        const snapshot = buildSelectedRunManifestSnapshot(manifest, manifestPath, runEntry);
+        if (!snapshot) {
+            continue;
+        }
+        if (isAuxiliaryProviderProofHarnessManifest(manifest)) {
+            continue;
+        }
+        const control = normalizeControlState(await readJsonFile(join(runDir, 'control.json')), snapshot.runId);
+        const questionSnapshot = await readJsonFile(join(runDir, 'questions.json'));
+        const advisoryState = await readJsonFile(join(runDir, LINEAR_ADVISORY_STATE_FILE));
+        const providerLinearWorkerProof = await readProviderLinearWorkerProofForProjection(runDir);
+        const context = buildProjectionContextFromParts(snapshot, {
+            control,
+            questions: Array.isArray(questionSnapshot?.questions) ? questionSnapshot.questions : [],
+            runDir,
+            trackedIssue: selectFreshLinearAdvisoryTrackedIssue(advisoryState),
+            providerLinearWorkerProof
+        }, resolveRunsRootFromRunDir(runDir), options.controlWorkspacePath ?? resolveSafeLegacyWorkspacePathFromRunDir(runDir), findMatchingProviderIntakeClaim(options.providerIntakeState, snapshot, providerLinearWorkerProof), options.providerIntakeState ?? null);
+        if (context) {
+            discovered.push({
+                context,
+                retryFallbackEligible: isManifestRetryFallbackCandidate(manifest)
+            });
+        }
+    }
+    return discovered;
+}
+async function reconcileProviderLinearWorkerDiscoveredContexts(discovered, providerIntakeState, additionalContexts = []) {
+    if (!providerIntakeState) {
+        return discovered;
+    }
+    const discoveredContexts = discovered.map((candidate) => candidate.context);
+    const allContexts = additionalContexts.concat(discoveredContexts);
+    return await Promise.all(discovered.map(async (entry) => {
+        const reconciliation = resolveProviderLinearWorkerRunArtifactReconciliation(entry.context, allContexts, providerIntakeState);
+        if (!reconciliation) {
+            return entry;
+        }
+        await writeProviderLinearWorkerRunArtifactReconciliation(entry.context.runDir, reconciliation).catch(() => undefined);
+        return {
+            ...entry,
+            context: applyProviderLinearWorkerRunArtifactReconciliation(entry.context, reconciliation)
+        };
+    }));
+}
+function resolveProviderLinearWorkerRunArtifactReconciliation(context, allContexts, providerIntakeState) {
+    if (!isProviderLinearWorkerReconciliationSource(context) ||
+        !isActiveLookingProviderLinearWorkerManifestStatus(context.rawStatus)) {
+        return null;
+    }
+    const claim = findProviderLinearWorkerClaimForContext(providerIntakeState, context);
+    if (claim && isActiveProviderLinearWorkerClaimState(claim.state)) {
+        return null;
+    }
+    const replacementRun = findNewerTerminalProviderLinearWorkerContext(allContexts, context);
+    const supersedingRunBoundClaim = !claim
+        ? findNewerRunBoundProviderLinearWorkerClaimForContext(providerIntakeState, context)
+        : null;
+    const claimReconciliationReason = claim
+        ? resolveProviderLinearWorkerClaimReconciliationReason(claim)
+        : null;
+    const absentClaimReconciliationReason = !claim
+        ? resolveAbsentProviderLinearWorkerClaimReconciliationReason(providerIntakeState, context, replacementRun, supersedingRunBoundClaim)
+        : null;
+    const reason = claimReconciliationReason ?? absentClaimReconciliationReason;
+    if (!reason) {
+        return null;
+    }
+    const claimForRecord = claim ?? supersedingRunBoundClaim;
+    const evidenceUpdatedAt = selectProviderLinearWorkerReconciliationEvidenceUpdatedAt(reason, claimForRecord, replacementRun, providerIntakeState);
+    if (!isProviderLinearWorkerReconciliationEvidenceNewerThanContext(evidenceUpdatedAt, context, Boolean(replacementRun) || reason === 'provider_claim_active_newer_run')) {
+        return null;
+    }
+    const reconciledStatus = replacementRun?.rawStatus ??
+        (claim?.state === 'completed' ? 'succeeded' : 'cancelled');
+    const recordedAt = evidenceUpdatedAt ?? context.updatedAt ?? context.startedAt ?? new Date(0).toISOString();
+    const supersedingRunBoundClaimSummaryPrefix = supersedingRunBoundClaim && isActiveProviderLinearWorkerClaimState(supersedingRunBoundClaim.state)
+        ? 'newer active claim run'
+        : 'newer run-bound claim run';
+    const summary = replacementRun
+        ? `Provider worker artifact reconciled as ${reconciledStatus}: newer terminal run ${replacementRun.runId ?? 'unknown'} supersedes retained ${context.rawStatus} manifest.`
+        : supersedingRunBoundClaim
+            ? `Provider worker artifact reconciled as ${reconciledStatus}: ${supersedingRunBoundClaimSummaryPrefix} ${supersedingRunBoundClaim.run_id ?? 'unknown'} supersedes retained ${context.rawStatus} manifest.`
+            : reason === 'provider_issue_removed'
+                ? `Provider worker artifact reconciled as ${reconciledStatus}: provider intake removed this issue with no active claim.`
+                : `Provider worker artifact reconciled as ${reconciledStatus}: provider claim is ${claimForRecord?.state ?? 'absent'} (${claimForRecord?.reason ?? reason}).`;
+    return {
+        schema_version: 1,
+        kind: 'provider-linear-worker-run-artifact-reconciliation',
+        status: 'reconciled',
+        reconciled_status: reconciledStatus,
+        reason,
+        summary,
+        recorded_at: recordedAt,
+        manifest: {
+            path: context.manifestPath ?? null,
+            run_id: context.runId,
+            task_id: context.taskId,
+            status: context.rawStatus,
+            updated_at: context.updatedAt
+        },
+        provider_claim: claimForRecord
+            ? {
+                state: claimForRecord.state,
+                reason: claimForRecord.reason,
+                issue_state: claimForRecord.issue_state,
+                issue_state_type: claimForRecord.issue_state_type,
+                updated_at: claimForRecord.updated_at,
+                run_id: claimForRecord.run_id,
+                run_manifest_path: claimForRecord.run_manifest_path
+            }
+            : null,
+        replacement_run: replacementRun
+            ? {
+                run_id: replacementRun.runId,
+                status: replacementRun.rawStatus,
+                manifest_path: replacementRun.manifestPath ?? null,
+                updated_at: replacementRun.updatedAt
+            }
+            : null
+    };
+}
+function applyProviderLinearWorkerRunArtifactReconciliation(context, reconciliation) {
+    return {
+        ...context,
+        rawStatus: reconciliation.reconciled_status,
+        displayStatus: reconciliation.reconciled_status,
+        statusReason: reconciliation.reason,
+        completedAt: context.completedAt ?? reconciliation.recorded_at,
+        summary: reconciliation.summary,
+        lastError: reconciliation.reconciled_status === 'failed'
+            ? context.lastError ?? reconciliation.summary
+            : context.lastError,
+        latestEvent: {
+            ...(context.latestEvent ?? {
+                requestedBy: null,
+                reason: null
+            }),
+            at: reconciliation.recorded_at,
+            event: reconciliation.reconciled_status,
+            message: reconciliation.summary,
+            reason: reconciliation.reason
+        }
+    };
+}
+async function writeProviderLinearWorkerRunArtifactReconciliation(runDir, reconciliation) {
+    if (!runDir) {
+        return;
+    }
+    const targetPath = join(runDir, PROVIDER_LINEAR_WORKER_RECONCILIATION_FILENAME);
+    const existing = await readJsonFile(targetPath);
+    if (JSON.stringify(existing) === JSON.stringify(reconciliation)) {
+        return;
+    }
+    await writeJsonAtomic(targetPath, reconciliation);
+}
+function isActiveLookingProviderLinearWorkerManifestStatus(status) {
+    return status === 'in_progress' || status === 'launching';
+}
+function isProviderLinearWorkerReconciliationSource(context) {
+    if (context.issueProvider !== null && context.issueProvider !== 'linear') {
+        return false;
+    }
+    return (context.pipelineId === PROVIDER_LINEAR_WORKER_PIPELINE_ID ||
+        context.pipelineTitle === PROVIDER_LINEAR_WORKER_PIPELINE_TITLE ||
+        context.providerLinearWorkerProof != null);
+}
+function findProviderLinearWorkerClaimForContext(providerIntakeState, context) {
+    const candidates = providerIntakeState.claims.filter((claim) => providerLinearWorkerClaimMatchesContext(claim, context));
+    return candidates.sort((left, right) => compareProviderLinearWorkerClaimForContext(left, right, context))[0] ?? null;
+}
+function compareProviderLinearWorkerClaimForContext(left, right, context) {
+    const leftRunIdentityMatch = providerLinearWorkerClaimRunIdentityMatchesContext(left, context);
+    const rightRunIdentityMatch = providerLinearWorkerClaimRunIdentityMatchesContext(right, context);
+    if (leftRunIdentityMatch !== rightRunIdentityMatch) {
+        return leftRunIdentityMatch ? -1 : 1;
+    }
+    return compareIsoTimestamp(right.updated_at, left.updated_at);
+}
+function providerLinearWorkerClaimMatchesContext(claim, context) {
+    if (claim.provider !== 'linear') {
+        return false;
+    }
+    if (providerLinearWorkerClaimRunIdentityMatchesContext(claim, context)) {
+        return true;
+    }
+    if (isProviderLinearWorkerRunBoundClaimAuthoritative(claim) &&
+        providerLinearWorkerClaimHasRunIdentity(claim)) {
+        return false;
+    }
+    return providerLinearWorkerClaimIssueIdentityMatchesContext(claim, context);
+}
+function isActiveProviderLinearWorkerClaimState(state) {
+    return (state === 'accepted' ||
+        state === 'starting' ||
+        state === 'running' ||
+        state === 'resuming' ||
+        state === 'resumable' ||
+        state === 'handoff_failed');
+}
+function resolveProviderLinearWorkerClaimReconciliationReason(claim) {
+    if (claim.state === 'completed') {
+        return 'provider_claim_completed';
+    }
+    if (claim.state === 'released') {
+        const reason = claim.reason ?? '';
+        if (isLiveRehydrateProviderLinearWorkerReleasedClaim(claim)) {
+            return null;
+        }
+        if (reason.includes('not_active') ||
+            reason.includes('not_mutable') ||
+            reason.includes('assignee_changed') ||
+            reason.includes('todo_blocked_by_non_terminal') ||
+            isTerminalProviderLinearIssueState(claim.issue_state, claim.issue_state_type)) {
+            return 'provider_claim_released';
+        }
+    }
+    if (claim.state === 'stale' || claim.state === 'duplicate' || claim.state === 'ignored') {
+        return `provider_claim_${claim.state}`;
+    }
+    return null;
+}
+function isLiveRehydrateProviderLinearWorkerReleasedClaim(claim) {
+    if (!isProviderLinearWorkerReleasedLiveRehydrateReason(claim.reason)) {
+        return false;
+    }
+    const workflowState = classifyProviderLinearWorkflowState({
+        state: claim.issue_state,
+        state_type: claim.issue_state_type
+    });
+    return workflowState.isActive && !workflowState.isTodo;
+}
+function isProviderLinearWorkerReleasedLiveRehydrateReason(reason) {
+    return (reason === 'provider_issue_released:not_active' ||
+        isProviderLinearWorkerReleasedPendingReopenReason(reason));
+}
+function isProviderLinearWorkerReleasedPendingReopenReason(reason) {
+    return (typeof reason === 'string' &&
+        reason.startsWith('provider_issue_released_pending_reopen:'));
+}
+function resolveAbsentProviderLinearWorkerClaimReconciliationReason(providerIntakeState, context, replacementRun, supersedingActiveClaim) {
+    if (replacementRun) {
+        return 'provider_claim_absent_newer_terminal_run';
+    }
+    if (supersedingActiveClaim) {
+        return 'provider_claim_active_newer_run';
+    }
+    if (providerLinearWorkerRemovedIntakeReasonMatchesContext(providerIntakeState, context)) {
+        return 'provider_issue_removed';
+    }
+    return null;
+}
+function providerLinearWorkerRemovedIntakeReasonMatchesContext(providerIntakeState, context) {
+    if (providerIntakeState.latest_reason !== 'provider_issue_removed') {
+        return false;
+    }
+    const providerIssueKeys = buildProviderLinearWorkerContextProviderIssueKeys(context);
+    return Boolean(providerIntakeState.latest_provider_key &&
+        providerIssueKeys.includes(providerIntakeState.latest_provider_key));
+}
+function buildProviderLinearWorkerContextProviderIssueKeys(context) {
+    const identities = [context.issueId, context.issueIdentifier].filter((value) => Boolean(value && !isProjectionFallbackIdentityValue(value, context)));
+    return Array.from(new Set(identities.map((identity) => buildProviderIssueKey('linear', identity))));
+}
+function selectProviderLinearWorkerReconciliationEvidenceUpdatedAt(reason, claim, replacementRun, providerIntakeState) {
+    const replacementRunEvidenceAt = replacementRun
+        ? selectProviderLinearWorkerReconciliationRunEvidenceTimestamp(replacementRun)
+        : null;
+    const claimRunEvidenceAt = claim
+        ? selectProviderLinearWorkerClaimRunEvidenceTimestamp(claim)
+        : null;
+    if (reason === 'provider_claim_absent_newer_terminal_run') {
+        return replacementRunEvidenceAt;
+    }
+    if (reason === 'provider_issue_removed') {
+        return providerIntakeState.updated_at;
+    }
+    return selectLatestIsoTimestamp(claim?.updated_at ?? null, claimRunEvidenceAt, replacementRunEvidenceAt);
+}
+function selectProviderLinearWorkerReconciliationRunEvidenceTimestamp(context) {
+    return selectLatestIsoTimestamp(context.updatedAt, selectProviderLinearWorkerContextChronologyTimestamp(context));
+}
+function isProviderLinearWorkerReconciliationEvidenceNewerThanContext(evidenceUpdatedAt, context, useRunChronologyBoundary = false) {
+    if (!evidenceUpdatedAt) {
+        return false;
+    }
+    const contextEvidenceBoundary = useRunChronologyBoundary
+        ? selectProviderLinearWorkerContextChronologyTimestamp(context) ?? context.updatedAt
+        : selectLatestIsoTimestamp(context.updatedAt, context.startedAt);
+    return !contextEvidenceBoundary || compareIsoTimestamp(evidenceUpdatedAt, contextEvidenceBoundary) > 0;
+}
+function isTerminalProviderLinearIssueState(issueState, issueStateType) {
+    return classifyProviderLinearWorkflowState({
+        state: issueState,
+        state_type: issueStateType
+    }).isTerminal;
+}
+function findNewerTerminalProviderLinearWorkerContext(contexts, context) {
+    return contexts
+        .filter((candidate) => candidate !== context &&
+        isProviderLinearWorkerReconciliationSource(candidate) &&
+        isTerminalRunStatus(candidate.rawStatus) &&
+        providerLinearWorkerContextsShareIssueIdentity(candidate, context) &&
+        isProviderLinearWorkerContextChronologicallyNewer(candidate, context))
+        .sort(compareProviderLinearWorkerContextChronologyDesc)[0] ?? null;
+}
+function compareProviderLinearWorkerContextChronologyDesc(left, right) {
+    const chronologyComparison = compareIsoTimestamp(selectProviderLinearWorkerContextChronologyTimestamp(right), selectProviderLinearWorkerContextChronologyTimestamp(left));
+    return chronologyComparison !== 0
+        ? chronologyComparison
+        : compareIsoTimestamp(right.updatedAt, left.updatedAt);
+}
+function isProviderLinearWorkerContextChronologicallyNewer(candidate, context) {
+    const candidateStartedAt = selectProviderLinearWorkerContextChronologyTimestamp(candidate);
+    const contextStartedAt = selectProviderLinearWorkerContextChronologyTimestamp(context);
+    if (!candidateStartedAt) {
+        return false;
+    }
+    if (!contextStartedAt) {
+        const contextUpdatedAt = selectLatestIsoTimestamp(context.updatedAt, context.startedAt);
+        return !contextUpdatedAt || compareIsoTimestamp(candidateStartedAt, contextUpdatedAt) > 0;
+    }
+    return compareIsoTimestamp(candidateStartedAt, contextStartedAt) > 0;
+}
+function selectProviderLinearWorkerContextChronologyTimestamp(context) {
+    return selectLatestIsoTimestamp(context.startedAt, parseProviderLinearWorkerRunIdTimestamp(context.runId), parseProviderLinearWorkerRunPathTimestamp(context.manifestPath ?? context.runDir ?? null));
+}
+function parseProviderLinearWorkerRunPathTimestamp(pathValue) {
+    if (!pathValue) {
+        return null;
+    }
+    const normalized = pathValue.replace(/\\/g, '/');
+    const segments = normalized.split('/').filter(Boolean);
+    const manifestIndex = segments.lastIndexOf('manifest.json');
+    if (manifestIndex > 0) {
+        return parseProviderLinearWorkerRunIdTimestamp(segments[manifestIndex - 1]);
+    }
+    return parseProviderLinearWorkerRunIdTimestamp(segments[segments.length - 1]);
+}
+function parseProviderLinearWorkerRunIdTimestamp(runId) {
+    if (!runId) {
+        return null;
+    }
+    const match = runId.match(/\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-\d{3}Z/);
+    if (!match) {
+        return null;
+    }
+    const iso = match[0].replace(/^(\d{4}-\d{2}-\d{2})T(\d{2})-(\d{2})-(\d{2})-(\d{3})Z$/, '$1T$2:$3:$4.$5Z');
+    return Number.isFinite(Date.parse(iso)) ? iso : null;
+}
+function findNewerRunBoundProviderLinearWorkerClaimForContext(providerIntakeState, context) {
+    return providerIntakeState.claims
+        .filter((claim) => claim.provider === 'linear' &&
+        isProviderLinearWorkerRunBoundClaimAuthoritative(claim) &&
+        providerLinearWorkerClaimHasRunIdentity(claim) &&
+        !providerLinearWorkerClaimRunIdentityMatchesContext(claim, context) &&
+        providerLinearWorkerClaimIssueIdentityMatchesContext(claim, context) &&
+        isProviderLinearWorkerRunBoundClaimNewerThanContext(claim, context))
+        .sort(compareProviderLinearWorkerRunBoundClaimDesc)[0] ?? null;
+}
+function isProviderLinearWorkerRunBoundClaimNewerThanContext(claim, context) {
+    const claimRunEvidenceAt = selectProviderLinearWorkerClaimRunEvidenceTimestamp(claim);
+    const contextRunEvidenceAt = selectProviderLinearWorkerContextChronologyTimestamp(context);
+    if (claimRunEvidenceAt && contextRunEvidenceAt) {
+        return compareIsoTimestamp(claimRunEvidenceAt, contextRunEvidenceAt) > 0;
+    }
+    if (claimRunEvidenceAt && !contextRunEvidenceAt) {
+        return true;
+    }
+    return compareIsoTimestamp(claim.updated_at, context.updatedAt) > 0;
+}
+function compareProviderLinearWorkerRunBoundClaimDesc(left, right) {
+    const chronologyComparison = compareIsoTimestamp(selectProviderLinearWorkerClaimRunEvidenceTimestamp(right), selectProviderLinearWorkerClaimRunEvidenceTimestamp(left));
+    return chronologyComparison !== 0
+        ? chronologyComparison
+        : compareIsoTimestamp(right.updated_at, left.updated_at);
+}
+function selectProviderLinearWorkerClaimRunEvidenceTimestamp(claim) {
+    return selectLatestIsoTimestamp(parseProviderLinearWorkerRunIdTimestamp(claim.run_id), parseProviderLinearWorkerRunPathTimestamp(claim.run_manifest_path));
+}
+function isProviderLinearWorkerRunBoundClaimAuthoritative(claim) {
+    return (isActiveProviderLinearWorkerClaimState(claim.state) ||
+        (claim.state === 'released' && isLiveRehydrateProviderLinearWorkerReleasedClaim(claim)));
+}
+function providerLinearWorkerClaimHasRunIdentity(claim) {
+    return Boolean(claim.run_id || claim.run_manifest_path);
+}
+function providerLinearWorkerClaimRunIdentityMatchesContext(claim, context) {
+    const manifestPath = context.manifestPath ?? null;
+    return Boolean((claim.run_id && claim.run_id === context.runId) ||
+        (claim.run_manifest_path && manifestPath && claim.run_manifest_path === manifestPath));
+}
+function providerLinearWorkerClaimIssueIdentityMatchesContext(claim, context) {
+    return Boolean((claim.issue_id && claim.issue_id === context.issueId) ||
+        (claim.issue_identifier && claim.issue_identifier === context.issueIdentifier) ||
+        (claim.task_id && claim.task_id === context.taskId));
+}
+function providerLinearWorkerContextsShareIssueIdentity(left, right) {
+    return Boolean((left.issueId && right.issueId && left.issueId === right.issueId) ||
+        (left.issueIdentifier && right.issueIdentifier && left.issueIdentifier === right.issueIdentifier) ||
+        (left.taskId && right.taskId && left.taskId === right.taskId));
+}
+function selectLatestIsoTimestamp(...values) {
+    return values
+        .filter((value) => Boolean(value))
+        .sort((left, right) => compareIsoTimestamp(right, left))[0] ?? null;
+}
+async function readDirectoryNames(path) {
+    try {
+        const entries = await readdir(path, { withFileTypes: true });
+        return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+    }
+    catch {
+        return [];
+    }
+}
+async function readJsonFile(path) {
+    try {
+        const raw = await readFile(path, 'utf8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+async function readProviderLinearWorkerProofForProjection(runDir) {
+    const proof = await readJsonFile(join(runDir, PROVIDER_LINEAR_WORKER_PROOF_FILENAME));
+    const refreshPlan = await resolveProviderLinearWorkerProjectionProofRefreshPlan(runDir, proof);
+    if (!refreshPlan) {
+        return proof;
+    }
+    return ((await refreshProviderLinearWorkerProofSnapshot(runDir, null, undefined, undefined, process.env, {
+        updatedAtComparisonScope: refreshPlan.updatedAtComparisonScope,
+        skipSessionLogHydration: refreshPlan.skipSessionLogHydration
+    }).catch(() => proof)) ?? proof);
+}
+async function resolveProviderLinearWorkerProjectionProofRefreshPlan(runDir, proof) {
+    if (!proof) {
+        return null;
+    }
+    const hasRetiredResidue = hasProviderLinearWorkerProjectionRetiredChildLaneResidue(proof) ||
+        (await hasProviderLinearWorkerProjectionRetiredChildLaneResidueInLedger(runDir));
+    const telemetryGap = hasProviderLinearWorkerProjectionTelemetryGap(proof);
+    const canSkipSessionLogHydration = canSkipProviderLinearWorkerProjectionSessionLogHydration(proof, telemetryGap);
+    if (!isProviderLinearWorkerProjectionRefreshEligible(proof)) {
+        return hasRetiredResidue
+            ? {
+                updatedAtComparisonScope: 'full',
+                skipSessionLogHydration: canSkipSessionLogHydration
+            }
+            : null;
+    }
+    if (hasRetiredResidue) {
+        return {
+            updatedAtComparisonScope: 'full',
+            skipSessionLogHydration: canSkipSessionLogHydration
+        };
+    }
+    if (hasProviderLinearWorkerProjectionReservationPlaceholder(proof)) {
+        return {
+            updatedAtComparisonScope: 'full',
+            skipSessionLogHydration: canSkipSessionLogHydration
+        };
+    }
+    if (hasProviderLinearWorkerProjectionActivePendingChildLane(proof)) {
+        return {
+            updatedAtComparisonScope: 'full',
+            skipSessionLogHydration: canSkipSessionLogHydration
+        };
+    }
+    if (await hasProviderLinearWorkerProjectionActivePendingChildLaneInLedger(runDir)) {
+        return {
+            updatedAtComparisonScope: 'full',
+            skipSessionLogHydration: canSkipSessionLogHydration
+        };
+    }
+    return telemetryGap
+        ? {
+            updatedAtComparisonScope: 'telemetry',
+            skipSessionLogHydration: false
+        }
+        : null;
+}
+function isProviderLinearWorkerProjectionRefreshEligible(proof) {
+    return (proof.owner_status === 'in_progress' &&
+        (proof.owner_phase === 'turn_running' || proof.owner_phase === 'turn_completed'));
+}
+function hasProviderLinearWorkerProjectionReservationPlaceholder(proof) {
+    return hasProviderLinearWorkerProjectionReservationPlaceholderInRecords(proof.child_lanes);
+}
+function hasProviderLinearWorkerProjectionActivePendingChildLane(proof) {
+    return hasProviderLinearWorkerProjectionActivePendingChildLaneInRecords(proof.child_lanes);
+}
+function hasProviderLinearWorkerProjectionRetiredChildLaneResidue(proof) {
+    return hasProviderLinearWorkerProjectionRetiredChildLaneResidueInRecords(proof.child_lanes);
+}
+function hasProviderLinearWorkerProjectionTelemetryGap(proof) {
+    const tokens = proof.tokens ?? null;
+    const hasTokens = tokens?.input_tokens != null || tokens?.output_tokens != null || tokens?.total_tokens != null;
+    return (!proof.latest_turn_id ||
+        !proof.latest_session_id ||
+        !hasTokens ||
+        proof.rate_limits == null);
+}
+function canSkipProviderLinearWorkerProjectionSessionLogHydration(proof, telemetryGap) {
+    if (proof.owner_phase !== 'turn_completed') {
+        return false;
+    }
+    const currentTurnActivity = proof.current_turn_activity ?? null;
+    return !(telemetryGap ||
+        !proof.last_event_at ||
+        (!proof.last_event && !proof.last_message) ||
+        currentTurnActivity == null ||
+        currentTurnActivity.recorded_at == null ||
+        currentTurnActivity.turn_id !== proof.latest_turn_id ||
+        currentTurnActivity.session_id !== proof.latest_session_id ||
+        proof.auth_provenance == null);
+}
+async function hasProviderLinearWorkerProjectionActivePendingChildLaneInLedger(runDir) {
+    const records = await readJsonFile(join(runDir, PROVIDER_LINEAR_WORKER_CHILD_LANES_FILENAME));
+    return hasProviderLinearWorkerProjectionActivePendingChildLaneInRecords(records);
+}
+async function hasProviderLinearWorkerProjectionRetiredChildLaneResidueInLedger(runDir) {
+    const records = await readJsonFile(join(runDir, PROVIDER_LINEAR_WORKER_CHILD_LANES_FILENAME));
+    return hasProviderLinearWorkerProjectionRetiredChildLaneResidueInRecords(records);
+}
+function hasProviderLinearWorkerProjectionReservationPlaceholderInRecords(records) {
+    if (!Array.isArray(records)) {
+        return false;
+    }
+    return records.some((childLane) => {
+        if (!isRecord(childLane)) {
+            return false;
+        }
+        const runId = readStringValue(childLane, 'run_id');
+        const summary = readStringValue(childLane, 'summary');
+        const status = readStringValue(childLane, 'status');
+        const pipelineId = readStringValue(childLane, 'pipeline_id');
+        const decision = readStringValue(childLane, 'decision');
+        return (pipelineId === PROVIDER_LINEAR_CHILD_LANE_PIPELINE_ID &&
+            decision === 'pending' &&
+            (status === 'launching' ||
+                Boolean(runId?.startsWith('launching-')) ||
+                summary === PROVIDER_LINEAR_CHILD_LANE_RESERVED_SUMMARY));
+    });
+}
+function hasProviderLinearWorkerProjectionActivePendingChildLaneInRecords(records) {
+    if (!Array.isArray(records)) {
+        return false;
+    }
+    return records.some((childLane) => {
+        if (!isRecord(childLane)) {
+            return false;
+        }
+        const status = readStringValue(childLane, 'status');
+        return (readStringValue(childLane, 'pipeline_id') === PROVIDER_LINEAR_CHILD_LANE_PIPELINE_ID &&
+            readStringValue(childLane, 'decision') === 'pending' &&
+            !isProviderLinearWorkerProjectionTerminalChildLaneStatus(status ?? null));
+    });
+}
+function hasProviderLinearWorkerProjectionRetiredChildLaneResidueInRecords(records) {
+    if (!Array.isArray(records)) {
+        return false;
+    }
+    return records.some((childLane) => {
+        if (!isRecord(childLane)) {
+            return false;
+        }
+        const status = readStringValue(childLane, 'status');
+        const summary = readStringValue(childLane, 'summary');
+        const decision = readStringValue(childLane, 'decision');
+        const inFlightAction = readStringValue(childLane, 'in_flight_action');
+        const hasActiveLookingStatus = status === 'launching' ||
+            status === 'in_progress' ||
+            status === 'running' ||
+            status === 'queued';
+        return (readStringValue(childLane, 'pipeline_id') === PROVIDER_LINEAR_CHILD_LANE_PIPELINE_ID &&
+            (decision === 'invalidated' || decision === 'rejected') &&
+            (hasActiveLookingStatus ||
+                Boolean(inFlightAction) ||
+                isProviderLinearWorkerProjectionActiveLookingChildLaneSummary(summary)));
+    });
+}
+function isProviderLinearWorkerProjectionActiveLookingChildLaneSummary(summary) {
+    if (!summary) {
+        return false;
+    }
+    const normalized = summary.toLowerCase();
+    return (summary === PROVIDER_LINEAR_CHILD_LANE_RESERVED_SUMMARY ||
+        normalized.includes(' is running') ||
+        normalized.includes(' is queued') ||
+        normalized.includes(' status is in_progress') ||
+        normalized.includes(' status is running') ||
+        normalized.includes(' status is queued') ||
+        normalized.includes(' status is launching') ||
+        normalized.includes('reserved before child run startup'));
+}
+function isProviderLinearWorkerProjectionTerminalChildLaneStatus(status) {
+    return (status === 'succeeded' ||
+        status === 'failed' ||
+        status === 'completed' ||
+        status === 'canceled' ||
+        status === 'cancelled' ||
+        status === 'invalidated' ||
+        status === 'rejected');
+}
+function isManifestRetryFallbackCandidate(manifestRecord) {
+    if (readStringValue(manifestRecord, 'issue_provider', 'issueProvider') !== 'linear') {
+        return false;
+    }
+    const status = readStringValue(manifestRecord, 'status');
+    return status === 'failed' || status === 'cancelled' || status === 'canceled';
+}
+function findMatchingProviderIntakeClaim(state, snapshot, providerLinearWorkerProof = null) {
+    if (!state || !snapshot) {
+        return null;
+    }
+    const claimMatchSource = buildSelectedRunProviderClaimMatchSource(snapshot, providerLinearWorkerProof);
+    const issueScopedClaim = findIssueScopedProviderIntakeClaim(state, claimMatchSource);
+    if (issueScopedClaim) {
+        return providerIntakeClaimCanFallbackByIssue(issueScopedClaim, claimMatchSource) ? issueScopedClaim : null;
+    }
+    const matchedClaims = state.claims
+        .filter((claim) => providerIntakeClaimMatchesSelectedRun(claim, claimMatchSource))
+        .sort((left, right) => compareProviderIntakeClaimSpecificity(right, left, claimMatchSource));
+    return matchedClaims[0] ?? null;
+}
+function findIssueScopedProviderIntakeClaim(state, snapshot) {
+    if (snapshot.issueId) {
+        const byIssueId = readProviderIntakeClaim(state, buildProviderIssueKey('linear', snapshot.issueId));
+        if (byIssueId) {
+            return byIssueId;
+        }
+    }
+    return state.claims.find((claim) => claim.issue_identifier === snapshot.issueIdentifier) ?? null;
+}
+function providerIntakeClaimMatchesSelectedRun(claim, snapshot) {
+    if (claim.run_manifest_path && claim.run_manifest_path === snapshot.manifestPath) {
+        return true;
+    }
+    if (!providerIntakeClaimMatchesIssueIdentity(claim, snapshot)) {
+        return providerIntakeClaimMatchesSyntheticFallbackTaskBinding(claim, snapshot);
+    }
+    if (claim.run_id && snapshot.runId) {
+        if (claim.task_id && snapshot.taskId && claim.task_id !== snapshot.taskId) {
+            return false;
+        }
+        return claim.run_id === snapshot.runId;
+    }
+    if (claim.task_id && snapshot.taskId) {
+        return claim.task_id === snapshot.taskId;
+    }
+    return false;
+}
+function compareProviderIntakeClaimSpecificity(left, right, snapshot) {
+    const leftPriority = scoreProviderIntakeClaimSpecificity(left, snapshot);
+    const rightPriority = scoreProviderIntakeClaimSpecificity(right, snapshot);
+    if (leftPriority !== rightPriority) {
+        return leftPriority - rightPriority;
+    }
+    const leftTaskLength = left.task_id?.length ?? 0;
+    const rightTaskLength = right.task_id?.length ?? 0;
+    if (leftTaskLength !== rightTaskLength) {
+        return leftTaskLength - rightTaskLength;
+    }
+    return (left.issue_identifier ?? '').localeCompare(right.issue_identifier ?? '');
+}
+function scoreProviderIntakeClaimSpecificity(claim, snapshot) {
+    if (claim.run_manifest_path && claim.run_manifest_path === snapshot.manifestPath) {
+        return 4;
+    }
+    if (claim.run_id && snapshot.runId && claim.run_id === snapshot.runId) {
+        return 3;
+    }
+    if (claim.task_id && snapshot.taskId && claim.task_id === snapshot.taskId) {
+        return 2;
+    }
+    if (providerIntakeClaimMatchesSyntheticFallbackTaskBinding(claim, snapshot)) {
+        return 1;
+    }
+    return 0;
+}
+function providerIntakeClaimCanFallbackByIssue(claim, snapshot) {
+    return (providerIntakeClaimMatchesSelectedRun(claim, snapshot) ||
+        (!claim.run_manifest_path && !claim.run_id && !claim.task_id));
+}
+function providerIntakeClaimMatchesIssueIdentity(claim, snapshot) {
+    return ((claim.issue_id != null && snapshot.issueId != null && claim.issue_id === snapshot.issueId) ||
+        claim.issue_identifier === snapshot.issueIdentifier);
+}
+function providerIntakeClaimMatchesSyntheticFallbackTaskBinding(claim, snapshot) {
+    if (!claim.task_id || !snapshot.taskId) {
+        return false;
+    }
+    if (!hasProviderLinearClaimBindingProvenance(snapshot, snapshot.providerLinearWorkerProof)) {
+        return false;
+    }
+    if (claim.task_id !== buildProviderFallbackTaskId({ id: claim.issue_id })) {
+        return false;
+    }
+    if (snapshot.taskId === claim.task_id) {
+        return !hasAuthoritativeProjectionIssueIdentity(snapshot);
+    }
+    const pipelineId = readStringValue(snapshot.manifestRecord, 'pipeline_id', 'pipelineId') ?? null;
+    return (matchesSyntheticProviderChildTaskId(claim.task_id, snapshot.taskId, pipelineId) &&
+        !hasAuthoritativeProjectionIssueIdentity(snapshot));
+}
+function isProviderLinearChildPipelineId(pipelineId) {
+    return pipelineId !== null && PROVIDER_LINEAR_CHILD_PIPELINE_IDS.has(pipelineId);
+}
+function matchesSyntheticProviderChildTaskId(claimTaskId, snapshotTaskId, pipelineId) {
+    if (!isProviderLinearChildPipelineId(pipelineId)) {
+        return false;
+    }
+    if (pipelineId === 'provider-linear-child-lane') {
+        return snapshotTaskId.startsWith(`${claimTaskId}-`);
+    }
+    return snapshotTaskId === `${claimTaskId}-${pipelineId}`;
+}
+function hasProviderLinearClaimBindingProvenance(snapshot, providerLinearWorkerProof) {
+    if (snapshot.issueProvider !== null && snapshot.issueProvider !== 'linear') {
+        return false;
+    }
+    const pipelineId = readStringValue(snapshot.manifestRecord, 'pipeline_id', 'pipelineId') ?? null;
+    const pipelineTitle = readStringValue(snapshot.manifestRecord, 'pipeline_title', 'pipelineTitle') ?? null;
+    return (pipelineId === PROVIDER_LINEAR_WORKER_PIPELINE_ID ||
+        pipelineTitle === PROVIDER_LINEAR_WORKER_PIPELINE_TITLE ||
+        providerLinearWorkerProof != null ||
+        (snapshot.issueProvider === 'linear' && isProviderLinearChildPipelineId(pipelineId)));
+}
+function buildSelectedRunProviderClaimMatchSource(snapshot, providerLinearWorkerProof) {
+    return {
+        issueId: snapshot.issueId,
+        issueIdentifier: snapshot.issueIdentifier,
+        issueProvider: snapshot.issueProvider,
+        manifestPath: snapshot.manifestPath,
+        manifestRecord: snapshot.manifestRecord,
+        runId: snapshot.runId,
+        taskId: snapshot.taskId,
+        providerLinearWorkerProof
+    };
+}
+function hasAuthoritativeProjectionIssueIdentity(snapshot) {
+    if (snapshot.issueIdentifier && !isProjectionFallbackIdentityValue(snapshot.issueIdentifier, snapshot)) {
+        return true;
+    }
+    if (snapshot.issueId && !isProjectionFallbackIdentityValue(snapshot.issueId, snapshot)) {
+        return true;
+    }
+    return false;
+}
+function buildProviderRetryState(claim) {
+    if (!claim) {
+        return null;
+    }
+    const active = claim.retry_queued === true;
+    const attempt = claim.retry_attempt ?? null;
+    const dueAt = claim.retry_due_at ?? null;
+    const error = claim.retry_error ?? null;
+    if (!active && attempt === null && dueAt === null && error === null) {
+        return null;
+    }
+    return {
+        active,
+        attempt,
+        due_at: dueAt,
+        error
+    };
+}
+async function buildProviderRetryContextFromClaim(context, claim) {
+    const retryLatestEvent = claim.reason !== null
+        ? {
+            at: claim.updated_at,
+            event: claim.state,
+            message: claim.reason,
+            requestedBy: null,
+            reason: claim.reason
+        }
+        : null;
+    const snapshot = claim.run_manifest_path
+        ? await readManifestSnapshotForPath(claim.run_manifest_path, claim.run_id ?? null)
+        : null;
+    const controlWorkspacePath = await resolveControlWorkspacePath(context);
+    if (!snapshot) {
+        return {
+            issueProvider: claim.provider,
+            issueIdentifier: claim.issue_identifier,
+            issueId: claim.issue_id,
+            taskId: claim.task_id,
+            runId: claim.run_id,
+            lookupAliases: buildProjectionLookupAliases({
+                issueIdentifier: claim.issue_identifier,
+                issueId: claim.issue_id,
+                taskId: claim.task_id,
+                runId: claim.run_id
+            }),
+            rawStatus: claim.state,
+            displayStatus: 'retrying',
+            statusReason: claim.reason,
+            startedAt: claim.accepted_at,
+            updatedAt: claim.updated_at,
+            completedAt: null,
+            summary: claim.reason,
+            lastError: claim.retry_error ?? null,
+            latestAction: null,
+            latestEvent: retryLatestEvent,
+            workspacePath: resolveRetryWorkspacePath(claim, controlWorkspacePath),
+            pipelineTitle: null,
+            stages: [],
+            approvalsTotal: 0,
+            manifestPath: claim.run_manifest_path,
+            runDir: claim.run_manifest_path ? dirname(claim.run_manifest_path) : null,
+            questionSummary: {
+                queuedCount: 0,
+                latestQuestion: null
+            },
+            tracked: null,
+            compatibilityState: claim.issue_state,
+            providerLinearWorkerProof: null,
+            providerDebugSnapshot: buildProviderIssueDebugSnapshot({
+                claim,
+                rehydrated_at: context.providerIntakeState?.rehydrated_at ?? null
+            }),
+            providerRetryState: buildProviderRetryState(claim)
+        };
+    }
+    const parts = await resolveProjectionContextParts(context, snapshot);
+    const base = buildProjectionContextFromParts(snapshot, parts, resolveRunsRootFromRunDir(context.paths.runDir), controlWorkspacePath, claim, context.providerIntakeState ?? null) ??
+        null;
+    if (!base) {
+        return {
+            issueProvider: claim.provider,
+            issueIdentifier: claim.issue_identifier,
+            issueId: claim.issue_id,
+            taskId: claim.task_id,
+            runId: claim.run_id,
+            lookupAliases: buildProjectionLookupAliases({
+                issueIdentifier: claim.issue_identifier,
+                issueId: claim.issue_id,
+                taskId: claim.task_id,
+                runId: claim.run_id
+            }),
+            rawStatus: claim.state,
+            displayStatus: 'retrying',
+            statusReason: claim.reason,
+            startedAt: claim.accepted_at,
+            updatedAt: claim.updated_at,
+            completedAt: null,
+            summary: claim.reason,
+            lastError: claim.retry_error ?? null,
+            latestAction: null,
+            latestEvent: null,
+            workspacePath: resolveRetryWorkspacePath(claim, controlWorkspacePath),
+            pipelineTitle: null,
+            stages: [],
+            approvalsTotal: 0,
+            manifestPath: claim.run_manifest_path,
+            runDir: claim.run_manifest_path ? dirname(claim.run_manifest_path) : null,
+            questionSummary: {
+                queuedCount: 0,
+                latestQuestion: null
+            },
+            tracked: null,
+            compatibilityState: claim.issue_state,
+            providerLinearWorkerProof: null,
+            providerRetryState: buildProviderRetryState(claim)
+        };
+    }
+    return {
+        ...base,
+        lookupAliases: Array.from(new Set(base.lookupAliases.concat(buildProjectionLookupAliases({
+            issueIdentifier: claim.issue_identifier,
+            issueId: claim.issue_id,
+            taskId: claim.task_id,
+            runId: claim.run_id
+        })))),
+        rawStatus: claim.state,
+        displayStatus: 'retrying',
+        statusReason: claim.reason,
+        updatedAt: claim.updated_at,
+        summary: claim.reason ?? base.summary,
+        lastError: claim.retry_error ?? base.lastError,
+        latestEvent: retryLatestEvent ?? base.latestEvent,
+        workspacePath: resolveRetryWorkspacePath(claim, controlWorkspacePath, base),
+        compatibilityState: claim.issue_state ?? base.compatibilityState ?? null,
+        providerRetryState: buildProviderRetryState(claim)
+    };
+}
+function resolveRetryWorkspacePath(claim, controlWorkspacePath, source) {
+    const proofWorkspacePath = source?.providerLinearWorkerProof?.workspace_path ?? null;
+    if (proofWorkspacePath) {
+        return proofWorkspacePath;
+    }
+    if (source?.workspacePath &&
+        (!controlWorkspacePath || source.workspacePath !== controlWorkspacePath)) {
+        return source.workspacePath;
+    }
+    if (!controlWorkspacePath || !claim.task_id) {
+        return null;
+    }
+    try {
+        return resolveProviderWorkspacePath(controlWorkspacePath, claim.task_id);
+    }
+    catch {
+        return null;
+    }
+}
+function readStringValue(record, ...keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === 'string') {
+            const trimmed = value.trim();
+            if (trimmed.length > 0) {
+                return trimmed;
+            }
+        }
+    }
+    return undefined;
+}
+function compareIsoTimestamp(left, right) {
+    const leftValue = Date.parse(left ?? '');
+    const rightValue = Date.parse(right ?? '');
+    if (!Number.isFinite(leftValue) && !Number.isFinite(rightValue)) {
+        return 0;
+    }
+    if (!Number.isFinite(leftValue)) {
+        return -1;
+    }
+    if (!Number.isFinite(rightValue)) {
+        return 1;
+    }
+    return leftValue - rightValue;
+}
+function buildProjectionLookupAliases(input) {
+    const aliases = new Set();
+    for (const candidate of [input.issueIdentifier, input.issueId, input.taskId, input.runId]) {
+        if (candidate) {
+            aliases.add(candidate);
+        }
+    }
+    return Array.from(aliases);
+}
+async function resolveProviderSelectedManifestSnapshot(context) {
+    const claim = selectProviderIntakeClaim(context.providerIntakeState);
+    if (!claim?.run_manifest_path) {
+        return null;
+    }
+    const preferredSnapshot = await readManifestSnapshotForPath(claim.run_manifest_path);
+    if (!preferredSnapshot) {
+        return null;
+    }
+    const currentTaskId = resolveTaskIdFromManifestPath(context.paths.manifestPath);
+    const currentRunId = resolveRunIdFromManifestPath(context.paths.manifestPath);
+    if (currentTaskId === 'local-mcp' && currentRunId === 'control-host') {
+        return preferredSnapshot;
+    }
+    const providerControlHostTaskId = readStringValue(preferredSnapshot.manifestRecord, 'provider_control_host_task_id');
+    const providerControlHostRunId = readStringValue(preferredSnapshot.manifestRecord, 'provider_control_host_run_id');
+    if (providerControlHostTaskId !== currentTaskId ||
+        providerControlHostRunId !== currentRunId) {
+        return null;
+    }
+    return preferredSnapshot;
+}