@navels/neal 0.1.0

package/dist/neal/status.js

@@ -0,0 +1,1260 @@
+import { open, readdir, readFile, stat } from 'node:fs/promises';
+import { basename, isAbsolute, join, relative, resolve } from 'node:path';
+import { getPlanAndExecuteQueueSummaryPath, inspectQueueChildResumeEvidence, loadPlanAndExecuteQueueState, readQueueChildLink, resolveQueueStoredPath, } from './plan-queue.js';
+import { buildBlockedGuidance, renderBlockedGuidanceSections, } from './blocked-guidance.js';
+import { formatMaybePublicPhase, formatPublicPhase } from './phase-display.js';
+import { decideResumeAction } from './resume-decision.js';
+import { getChangedFilesForRange, getCommitRange } from './git.js';
+import { inspectActiveRunLock } from './run-lock.js';
+import { listRuns } from './run-registry.js';
+import { formatPublicRunStatus, getRunDisplayStatus } from './run-status.js';
+import { getRunStatePath, loadState } from './state.js';
+import { getDerivedPlanView } from './state-views.js';
+import { getNealBuildMetadata } from './version.js';
+export { formatPublicPhase } from './phase-display.js';
+const EVENT_TAIL_BYTES = 256 * 1024;
+const STATUS_ERROR_MESSAGE_MAX_LENGTH = 1000;
+export const OK_MEANINGFUL_EVENT_MS = 2 * 60 * 1000;
+export const QUIET_WARNING_MS = 5 * 60 * 1000;
+const PROVIDER_ERROR_KINDS = new Set([
+    'timeout',
+    'no_progress_timeout',
+    'api_error',
+    'structured_output_missing',
+    'structured_output_invalid',
+    'permission_denied',
+    'session_unavailable',
+    'provider_failed',
+    'unknown',
+]);
+const MEANINGFUL_EVENT_TYPES = new Set([
+    'coder.thread_started',
+    'coder.turn_started',
+    'coder.item_started',
+    'coder.item_updated',
+    'coder.command_execution',
+    'coder.file_change',
+    'coder.turn_completed',
+    'advisor.assistant_text',
+    'advisor.task_started',
+    'advisor.task_progress',
+    'advisor.result',
+    'provider.session_started',
+    'provider.turn_started',
+    'provider.turn_completed',
+    'provider.tool_started',
+    'provider.tool_progress',
+    'provider.command_completed',
+    'provider.file_changed',
+    'provider.assistant_text',
+    'provider.assistant_thinking',
+    'provider.structured_output_received',
+    'provider.provider_error',
+    'provider.turn_liveness_timeout',
+    'provider.turn_liveness_retry',
+    'provider.turn_liveness_give_up',
+    'review.meaningful_progress.advance_parent',
+    'execute_finalization.advance_parent',
+    'phase.start',
+    'phase.complete',
+    'phase.retry',
+    'run.paused_after_scope',
+]);
+const STATUS_INTERNAL_EVENT_TYPES = new Set(['narrative.updated']);
+export async function buildStatusSnapshot(args) {
+    const statePath = isAbsolute(args.statePath) ? args.statePath : resolve(args.cwd, args.statePath);
+    const state = await loadState(statePath);
+    const eventsPath = join(state.runDir, 'events.ndjson');
+    const tail = await readEventTail(eventsPath);
+    const nowMs = (args.now ?? new Date()).getTime();
+    const eventSummary = summarizeEvents(tail.events);
+    const queue = await summarizeLinkedQueue(state.runDir, state.cwd);
+    const displayStatus = getRunDisplayStatus(state);
+    const latestRetrospectiveMarkdownPath = await findLatestRetrospectiveMarkdownPath(state.runDir);
+    const invalidDerivedPlanPayloadPath = await findCurrentInvalidSplitPlanPayloadArtifactPath(state);
+    const runId = basename(state.runDir);
+    const blockedGuidance = buildBlockedGuidance({
+        state,
+        runId,
+        waitingForOperatorGuidance: displayStatus.waitingForOperatorGuidance,
+    });
+    const blocker = summarizeBlocker(state, tail.events, invalidDerivedPlanPayloadPath, blockedGuidance);
+    const lock = await inspectActiveRunLock(state.cwd, runId);
+    const finalCompletionStaleness = classifyFinalCompletionStaleness({
+        state,
+        events: tail.events,
+        eventSummary,
+        nowMs,
+        lock,
+    });
+    const queueResumeEvidence = await inspectQueueChildResumeEvidence({ cwd: state.cwd, runDir: state.runDir });
+    const resumeDecision = decideResumeAction({
+        state,
+        selectedRunId: runId,
+        statePath,
+        lock,
+        queue: queueResumeEvidence,
+        retrospectivePath: latestRetrospectiveMarkdownPath,
+    });
+    const queueSummaryMarkdownPath = queue
+        ? getPlanAndExecuteQueueSummaryPath(state.cwd, queue.queueId)
+        : null;
+    const manualGate = summarizeManualGate(state, runId);
+    const health = classifyHealth(state, eventSummary, nowMs, finalCompletionStaleness);
+    const publicStatus = formatPublicStatusForDisplayStatus(displayStatus, health);
+    const publicPhase = formatPublicPhase(state.phase);
+    const nextAction = formatNextAction({
+        manualGate,
+        resumeDecision,
+        finalCompletionStaleness,
+        runId,
+        blockedGuidance,
+    });
+    const commits = summarizeCommits(state);
+    const squash = await summarizeSquashArtifact(state.runDir);
+    const providerError = summarizeProviderError(tail.events);
+    const build = await summarizeBuild(state);
+    const patch = await summarizePatch(state, displayStatus, squash);
+    return {
+        ok: true,
+        runId,
+        cwd: state.cwd,
+        statePath,
+        runDir: state.runDir,
+        planDoc: state.planDoc,
+        topLevelMode: state.topLevelMode,
+        executionShape: state.executionShape,
+        phase: state.phase,
+        publicPhase,
+        status: state.status,
+        effectiveStatus: displayStatus.effectiveStatus,
+        publicStatus,
+        nextAction,
+        waitingForOperatorGuidance: displayStatus.waitingForOperatorGuidance,
+        pendingOperatorGuidance: displayStatus.pendingOperatorGuidance,
+        blockedGuidance,
+        blocker,
+        manualGate,
+        resumeDecision,
+        currentScopeNumber: state.currentScopeNumber,
+        plannerSessionHandle: state.plannerSessionHandle,
+        coderSessionHandle: state.coderSessionHandle,
+        reviewerSessionHandle: state.reviewerSessionHandle,
+        coderRetryCount: state.coderRetryCount,
+        rounds: state.rounds.length,
+        createdCommits: state.createdCommits.length,
+        completedScopes: state.completedScopes.length,
+        lastEventAt: eventSummary.lastEvent?.ts ?? null,
+        lastMeaningfulEventAt: eventSummary.lastMeaningfulEvent?.ts ?? null,
+        lastCoderEventAt: eventSummary.lastCoderEvent?.ts ?? null,
+        lastReviewerEventAt: eventSummary.lastReviewerEvent?.ts ?? null,
+        lastMeaningfulEvent: eventSummary.lastMeaningfulEvent
+            ? {
+                type: eventSummary.lastMeaningfulEvent.type,
+                summary: summarizeEvent(eventSummary.lastMeaningfulEvent),
+            }
+            : null,
+        lock,
+        health,
+        findings: summarizeFindings(state),
+        commits,
+        squash,
+        providerError,
+        finalCompletionStaleness,
+        build,
+        patch,
+        derivedPlan: summarizeDerivedPlan(state),
+        ...(queue ? { queue } : {}),
+        events: {
+            path: tail.path,
+            exists: tail.exists,
+            parsedLines: tail.parsedLines,
+            malformedLines: tail.malformedLines,
+            truncated: tail.truncated,
+        },
+        artifacts: {
+            runStatePath: getRunStatePath(state.runDir),
+            eventsPath,
+            runNarrativeMarkdownPath: join(state.runDir, 'RUN_NARRATIVE.md'),
+            latestRetrospectiveMarkdownPath,
+            reviewMarkdownPath: state.reviewMarkdownPath,
+            progressJsonPath: state.progressJsonPath,
+            progressMarkdownPath: state.progressMarkdownPath,
+            recoveryMarkdownPath: state.recoveryMarkdownPath,
+            queueSummaryMarkdownPath,
+            archivedReviewPath: state.archivedReviewPath,
+            invalidDerivedPlanPayloadPath,
+        },
+    };
+}
+export async function buildStatusListSnapshot(args) {
+    const cwd = resolve(args.cwd);
+    const runs = await listRuns(cwd);
+    const snapshots = await Promise.all(runs.map((run) => buildStatusSnapshot({
+        cwd,
+        statePath: run.statePath,
+        now: args.now,
+    })));
+    return {
+        ok: true,
+        cwd,
+        runs: snapshots.map((snapshot, index) => {
+            const run = runs[index];
+            return {
+                runId: snapshot.runId,
+                runDir: snapshot.runDir,
+                statePath: snapshot.statePath,
+                planDoc: snapshot.planDoc,
+                topLevelMode: snapshot.topLevelMode,
+                executionShape: snapshot.executionShape,
+                status: snapshot.status,
+                effectiveStatus: snapshot.effectiveStatus,
+                publicStatus: snapshot.publicStatus,
+                phase: snapshot.phase,
+                publicPhase: snapshot.publicPhase,
+                currentScopeNumber: snapshot.currentScopeNumber,
+                waitingForOperatorGuidance: snapshot.waitingForOperatorGuidance,
+                pendingOperatorGuidance: snapshot.pendingOperatorGuidance,
+                manualGate: snapshot.manualGate,
+                commits: snapshot.commits,
+                squash: snapshot.squash,
+                providerError: snapshot.providerError,
+                finalCompletionStaleness: snapshot.finalCompletionStaleness,
+                build: snapshot.build,
+                patch: snapshot.patch,
+                lock: snapshot.lock,
+                createdAt: run.createdAt,
+                updatedAt: run.updatedAt,
+                nextAction: snapshot.nextAction,
+                artifacts: snapshot.artifacts,
+            };
+        }),
+    };
+}
+export function renderHumanStatusSnapshot(snapshot) {
+    const lines = [
+        '# Neal Status',
+        '',
+        `- Run: ${snapshot.runId}`,
+        `- Run directory: ${snapshot.runDir}`,
+        `- Plan: ${snapshot.planDoc}`,
+        `- Mode: ${snapshot.topLevelMode}`,
+        `- Status: ${snapshot.publicStatus}`,
+        `- Step: ${snapshot.publicPhase}`,
+    ];
+    if (shouldShowScope(snapshot)) {
+        lines.push(`- Current scope: ${snapshot.currentScopeNumber}`);
+    }
+    lines.push(`- Health: ${snapshot.health.classification} - ${snapshot.health.reason}`, `- Findings: ${snapshot.findings.openBlocking} open blocking, ${snapshot.findings.openNonBlocking} open non-blocking (${snapshot.findings.total} total)`, `- Operator guidance: waiting=${formatBoolean(snapshot.waitingForOperatorGuidance)}, pending=${formatBoolean(snapshot.pendingOperatorGuidance)}`);
+    if (snapshot.lastMeaningfulEvent) {
+        lines.push(`- Last progress: ${snapshot.lastMeaningfulEvent.type} - ${snapshot.lastMeaningfulEvent.summary}`);
+    }
+    else {
+        lines.push('- Last progress: none recorded');
+    }
+    if (snapshot.queue) {
+        lines.push(`- Queue: ${snapshot.queue.queueId} item ${snapshot.queue.itemIndex + 1}/${snapshot.queue.itemCount} ${snapshot.queue.stage}; queue ${snapshot.queue.queueStatus}, item ${snapshot.queue.itemStatus}`, `- Queue plan: ${snapshot.queue.requestedPlanPath}`);
+    }
+    if (snapshot.manualGate) {
+        lines.push('', '## Manual Gate', `- ID: ${snapshot.manualGate.id}`, `- Title: ${snapshot.manualGate.title}`, `- Reason: ${snapshot.manualGate.reason}`, `- Instructions: ${snapshot.manualGate.instructionsPath}`, `- Last checked: ${snapshot.manualGate.lastCheckedAt ?? 'never'}`, `- Resume command: ${snapshot.manualGate.resumeCommand}`);
+        if (snapshot.manualGate.lastFailure) {
+            lines.push(`- Last failure check: ${snapshot.manualGate.lastFailure.checkName}`, `- Last failure exit code: ${snapshot.manualGate.lastFailure.exitCode ?? 'none'}`, `- Last failure signal: ${snapshot.manualGate.lastFailure.signal ?? 'none'}`, `- Last failure stdout tail: ${snapshot.manualGate.lastFailure.stdoutTail || 'empty'}`, `- Last failure stderr tail: ${snapshot.manualGate.lastFailure.stderrTail || 'empty'}`);
+        }
+        else {
+            lines.push('- Last failure: none');
+        }
+    }
+    if (snapshot.derivedPlan) {
+        lines.push(`- Derived plan: ${snapshot.derivedPlan.path} (${snapshot.derivedPlan.status ?? 'unknown'})`);
+    }
+    if (snapshot.providerError) {
+        const provider = snapshot.providerError.provider ?? 'unclassified';
+        const kind = snapshot.providerError.kind ?? 'unclassified';
+        lines.push(`- Provider error: ${provider} ${kind} - ${snapshot.providerError.message}`);
+    }
+    lines.push(`- Active lock: ${formatLockSummary(snapshot.lock)}`, `- Squash: ${snapshot.squash.status}${snapshot.squash.replacementCommit ? ` replacement=${snapshot.squash.replacementCommit}` : ''}`, `- Patch policy: ${snapshot.patch.defaultSubmissionEligible ? 'eligible' : 'not eligible'} - ${snapshot.patch.reason}`);
+    if (snapshot.blocker.active && !snapshot.blockedGuidance) {
+        lines.push('', '## Blocker', `- Reason: ${snapshot.blocker.reason ?? 'unknown'}`, `- Source: ${snapshot.blocker.source ?? 'unknown'}`);
+        if (snapshot.blocker.artifactPaths.length > 0) {
+            lines.push('- Artifacts:');
+            for (const artifact of snapshot.blocker.artifactPaths) {
+                lines.push(`  - ${artifact.label}: ${artifact.path}`);
+            }
+        }
+    }
+    lines.push('', '## Artifacts', `- Run state: ${snapshot.artifacts.runStatePath}`, `- Events: ${snapshot.artifacts.eventsPath}`, `- Run narrative: ${snapshot.artifacts.runNarrativeMarkdownPath}`, `- Latest retrospective: ${snapshot.artifacts.latestRetrospectiveMarkdownPath ?? 'none found'}`, `- Progress: ${snapshot.artifacts.progressMarkdownPath}`, `- Progress JSON: ${snapshot.artifacts.progressJsonPath}`, `- Review: ${snapshot.artifacts.reviewMarkdownPath}`, `- Recovery: ${snapshot.artifacts.recoveryMarkdownPath}`);
+    if (snapshot.artifacts.invalidDerivedPlanPayloadPath) {
+        lines.push(`- Invalid split-plan payload: ${snapshot.artifacts.invalidDerivedPlanPayloadPath}`);
+    }
+    if (snapshot.artifacts.queueSummaryMarkdownPath) {
+        lines.push(`- Queue summary: ${snapshot.artifacts.queueSummaryMarkdownPath}`);
+    }
+    if (snapshot.artifacts.archivedReviewPath) {
+        lines.push(`- Archived review: ${snapshot.artifacts.archivedReviewPath}`);
+    }
+    if (snapshot.blockedGuidance) {
+        lines.push('', ...renderBlockedGuidanceSections(snapshot.blockedGuidance));
+    }
+    lines.push('', '## Next Action', `- ${snapshot.nextAction}`);
+    return lines.join('\n');
+}
+export function renderHumanStatusListSnapshot(snapshot) {
+    if (snapshot.runs.length === 0) {
+        return 'No Neal runs found.\n';
+    }
+    const rows = [
+        ['RUN ID', 'MODE', 'STATUS', 'STEP', 'PLAN', 'UPDATED', 'NEXT ACTION'],
+        ...snapshot.runs.map((run) => [
+            run.runId,
+            run.topLevelMode,
+            run.publicStatus,
+            run.publicPhase,
+            toDisplayPath(snapshot.cwd, run.planDoc),
+            run.updatedAt,
+            run.nextAction,
+        ]),
+    ];
+    const widths = rows[0].map((_cell, index) => Math.max(...rows.map((row) => row[index].length)));
+    return rows.map((row) => row.map((cell, index) => cell.padEnd(widths[index])).join('  ').trimEnd()).join('\n') + '\n';
+}
+function formatPublicStatusForDisplayStatus(displayStatus, health) {
+    const publicStatus = formatPublicRunStatus({
+        effectiveStatus: displayStatus.effectiveStatus,
+        waitingForOperatorGuidance: displayStatus.waitingForOperatorGuidance,
+        pendingOperatorGuidance: displayStatus.pendingOperatorGuidance,
+    });
+    if (displayStatus.effectiveStatus === 'paused' || health.classification === 'paused') {
+        return 'paused';
+    }
+    if (health.classification === 'stale') {
+        return 'stale';
+    }
+    return publicStatus;
+}
+function shouldShowScope(snapshot) {
+    return snapshot.topLevelMode === 'execute' && snapshot.phase !== 'done';
+}
+function formatBoolean(value) {
+    return value ? 'yes' : 'no';
+}
+function formatLockSummary(lock) {
+    switch (lock.kind) {
+        case 'none':
+            return 'none';
+        case 'live_same_run':
+            return `live for this run${typeof lock.pid === 'number' ? ` pid=${lock.pid}` : ''}`;
+        case 'stale_same_run':
+            return `stale for this run${typeof lock.pid === 'number' ? ` pid=${lock.pid}` : ''}`;
+        case 'live_different_run':
+            return `live for ${lock.runId}${typeof lock.pid === 'number' ? ` pid=${lock.pid}` : ''}`;
+        case 'stale_different_run':
+            return `stale for ${lock.runId}${typeof lock.pid === 'number' ? ` pid=${lock.pid}` : ''}`;
+        case 'cross_host':
+            return `cross-host for ${lock.runId} on ${lock.hostname ?? 'unknown host'}`;
+        case 'unreadable':
+            return `unreadable - ${lock.reason}`;
+    }
+}
+function formatNextAction(snapshot) {
+    if (snapshot.manualGate) {
+        return `Complete manual gate ${snapshot.manualGate.id}, then resume this run: ${snapshot.manualGate.resumeCommand}`;
+    }
+    if (snapshot.finalCompletionStaleness.stale && snapshot.resumeDecision.kind === 'continue') {
+        return `Final completion appears stale after reviewer output. Inspect artifacts and recover explicitly after confirming the branch state: neal status --run ${snapshot.runId}`;
+    }
+    if (snapshot.resumeDecision.kind === 'needs_message' && snapshot.blockedGuidance) {
+        const firstOption = snapshot.blockedGuidance.options[0]?.command;
+        if (firstOption) {
+            return `Needs operator guidance: ${formatSentence(snapshot.blockedGuidance.summary)} Use first resume option: ${firstOption}`;
+        }
+        return `Needs operator guidance: ${formatSentence(snapshot.blockedGuidance.summary)} Inspect guidance: neal status --run ${snapshot.runId}`;
+    }
+    return formatNextActionForDecision(snapshot.resumeDecision);
+}
+export function formatStatusNextActionForState(state) {
+    const runId = basename(state.runDir);
+    const resumeDecision = decideResumeAction({
+        state,
+        selectedRunId: runId,
+        statePath: getRunStatePath(state.runDir),
+    });
+    return formatNextAction({
+        manualGate: summarizeManualGate(state, runId),
+        resumeDecision,
+        finalCompletionStaleness: {
+            stale: false,
+            reason: null,
+            reviewerOutputObserved: false,
+            finalCompletionPhaseStartedAt: null,
+            lastFinalCompletionReviewerOutputAt: null,
+            finalCompletionPhaseTerminalEventObserved: false,
+        },
+        runId,
+        blockedGuidance: buildBlockedGuidance({ state, runId }),
+    });
+}
+function formatNextActionForDecision(decision) {
+    switch (decision.kind) {
+        case 'continue':
+            return `Resume this run: ${decision.resumeCommand}`;
+        case 'needs_message':
+            return `Needs operator guidance: ${formatSentence(decision.blocker)} Record guidance and resume: ${decision.messageCommand}`;
+        case 'pending_message':
+            return `Operator guidance is recorded. Resume this run: ${decision.resumeCommand}`;
+        case 'already_running':
+            return `${decision.reason} Inspect status: ${decision.statusCommand}`;
+        case 'done':
+            return decision.retrospectivePath
+                ? `No resume needed. Review latest retrospective: ${decision.retrospectivePath}`
+                : `No resume needed. Inspect status: ${decision.statusCommand}`;
+        case 'cannot_resume':
+            return `${decision.reason} Inspect status and artifacts: ${decision.statusCommand}`;
+    }
+}
+function formatSentence(value) {
+    const trimmed = value.trim();
+    if (/[.!?]$/.test(trimmed)) {
+        return trimmed;
+    }
+    return `${trimmed}.`;
+}
+function toDisplayPath(cwd, path) {
+    if (!isAbsolute(path)) {
+        return path;
+    }
+    const relativePath = relative(cwd, path);
+    return relativePath && !relativePath.startsWith('..') && !isAbsolute(relativePath) ? relativePath : path;
+}
+function summarizeManualGate(state, runId) {
+    const gate = state.phase === 'manual_gate' ? state.manualGate : null;
+    if (!gate) {
+        return null;
+    }
+    return {
+        id: gate.id,
+        title: gate.title,
+        reason: gate.reason,
+        instructionsPath: gate.instructionsPath,
+        lastCheckedAt: gate.lastCheckedAt,
+        lastFailure: gate.lastFailure,
+        resumeCommand: `neal resume --run ${runId}`,
+    };
+}
+async function findLatestRetrospectiveMarkdownPath(runDir) {
+    const defaultPath = join(runDir, 'RETROSPECTIVE.md');
+    try {
+        const defaultStat = await stat(defaultPath);
+        if (defaultStat.isFile()) {
+            return defaultPath;
+        }
+    }
+    catch (error) {
+        if (!isNotFoundError(error)) {
+            throw error;
+        }
+    }
+    let entries;
+    try {
+        entries = await readdir(runDir, { withFileTypes: true });
+    }
+    catch (error) {
+        if (isNotFoundError(error)) {
+            return null;
+        }
+        throw error;
+    }
+    const latestName = entries
+        .filter((entry) => entry.isFile() && /^RETROSPECTIVE-.+\.md$/.test(entry.name))
+        .map((entry) => entry.name)
+        .sort()
+        .at(-1);
+    return latestName ? join(runDir, latestName) : null;
+}
+export function summarizeDerivedPlan(state) {
+    const derivedPlan = getDerivedPlanView(state);
+    if (!derivedPlan) {
+        return null;
+    }
+    return {
+        path: derivedPlan.path,
+        parentScopeNumber: derivedPlan.parentScopeNumber,
+        status: derivedPlan.status,
+        scopeIndex: derivedPlan.scopeIndex,
+        reviewActive: derivedPlan.reviewActive,
+        acceptedAwaitingExecution: derivedPlan.acceptedAwaitingExecution,
+        executing: derivedPlan.executing,
+        abandoned: derivedPlan.abandoned,
+    };
+}
+async function findCurrentInvalidSplitPlanPayloadArtifactPath(state) {
+    const artifactPath = join(state.runDir, `SCOPE_${state.currentScopeNumber}_INVALID_DERIVED_PLAN.md`);
+    const fileStat = await stat(artifactPath).catch((error) => {
+        if (error.code === 'ENOENT') {
+            return null;
+        }
+        throw error;
+    });
+    return fileStat?.isFile() ? artifactPath : null;
+}
+function summarizeBlocker(state, events, invalidDerivedPlanPayloadPath, guidance = null) {
+    const blockedLike = state.status === 'blocked' ||
+        state.status === 'failed' ||
+        state.phase === 'blocked' ||
+        state.phase === 'interactive_blocked_recovery';
+    const artifactPaths = invalidDerivedPlanPayloadPath
+        ? [{ label: 'Invalid split-plan payload', path: invalidDerivedPlanPayloadPath }]
+        : [];
+    if (!blockedLike) {
+        return {
+            active: false,
+            reason: null,
+            source: null,
+            artifactPaths,
+        };
+    }
+    const candidates = [
+        {
+            reason: guidance?.category === 'scope_accounting_guardrail' ? guidance.summary : null,
+            source: 'blocked guidance',
+        },
+        {
+            reason: state.interactiveBlockedRecovery?.blockedReason ?? null,
+            source: 'RUN_STATE.json interactive recovery',
+        },
+        {
+            reason: currentOrLatestBlockedCompletedScopeBlocker(state),
+            source: 'RUN_STATE.json completed scopes',
+        },
+        {
+            reason: latestInvalidSplitPlanEventBlocker(events, invalidDerivedPlanPayloadPath),
+            source: 'events.ndjson invalid split-plan payload',
+        },
+    ];
+    const candidate = candidates.find((item) => item.reason);
+    return {
+        active: Boolean(candidate?.reason),
+        reason: candidate?.reason ?? null,
+        source: candidate?.source ?? null,
+        artifactPaths,
+    };
+}
+function nonEmptyString(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : null;
+}
+function currentOrLatestBlockedCompletedScopeBlocker(state) {
+    const blockedScopes = state.completedScopes.filter((scope) => scope.result === 'blocked' && scope.blocker);
+    const currentScope = blockedScopes.find((scope) => scope.number === String(state.currentScopeNumber));
+    return currentScope?.blocker ?? blockedScopes.at(-1)?.blocker ?? null;
+}
+function latestInvalidSplitPlanEventBlocker(events, invalidDerivedPlanPayloadPath) {
+    for (const event of [...events].reverse()) {
+        if (event.type !== 'split_plan.invalid_payload') {
+            continue;
+        }
+        const validationErrors = stringArrayValue(event.data.validationErrors);
+        const artifactPath = invalidDerivedPlanPayloadPath ?? stringValue(event.data.invalidPayloadPath);
+        const reason = validationErrors.length > 0
+            ? `Invalid split-plan payload: ${validationErrors.join('; ')}`
+            : 'Invalid split-plan payload was rejected by plan validation.';
+        return artifactPath ? `${reason} Invalid payload artifact: ${artifactPath}` : reason;
+    }
+    return null;
+}
+async function summarizeLinkedQueue(runDir, cwd) {
+    const link = await readQueueChildLink(runDir);
+    if (!link) {
+        return undefined;
+    }
+    const queueStatePath = resolveQueueStoredPath(cwd, link.queueStatePath);
+    const queueState = await loadPlanAndExecuteQueueState(queueStatePath, cwd);
+    if (queueState.queueId !== link.queueId) {
+        throw new Error(`Invalid queue child link: queue ${link.queueId} does not match state ${queueState.queueId}`);
+    }
+    const item = queueState.items[link.itemIndex];
+    if (!item) {
+        throw new Error(`Invalid queue child link: missing queue item ${link.itemIndex}`);
+    }
+    return {
+        queueId: queueState.queueId,
+        queueStatePath,
+        itemIndex: link.itemIndex,
+        itemCount: queueState.items.length,
+        stage: link.stage,
+        queueStatus: queueState.status,
+        itemStatus: item.status,
+        requestedPlanPath: item.requestedPlanPath,
+    };
+}
+async function readEventTail(path) {
+    let file;
+    try {
+        file = await open(path, 'r');
+    }
+    catch (error) {
+        if (isNotFoundError(error)) {
+            return {
+                path,
+                exists: false,
+                parsedLines: 0,
+                malformedLines: 0,
+                truncated: false,
+                events: [],
+            };
+        }
+        throw error;
+    }
+    try {
+        const stat = await file.stat();
+        const truncated = stat.size > EVENT_TAIL_BYTES;
+        const length = Math.min(stat.size, EVENT_TAIL_BYTES);
+        const start = stat.size - length;
+        const buffer = Buffer.alloc(length);
+        await file.read(buffer, 0, length, start);
+        let text = buffer.toString('utf8');
+        if (truncated) {
+            text = text.slice(Math.max(0, text.indexOf('\n') + 1));
+        }
+        return parseEventText(path, text, truncated);
+    }
+    finally {
+        await file.close();
+    }
+}
+function parseEventText(path, text, truncated) {
+    const lines = text.split('\n');
+    let malformedLines = 0;
+    let parsedLines = 0;
+    const events = [];
+    for (const [index, line] of lines.entries()) {
+        if (line.trim() === '') {
+            continue;
+        }
+        try {
+            const event = JSON.parse(line);
+            const parsed = parseRunEvent(event);
+            if (parsed) {
+                events.push(parsed);
+                parsedLines += 1;
+            }
+            else {
+                malformedLines += 1;
+            }
+        }
+        catch {
+            malformedLines += 1;
+            if (index === lines.length - 1) {
+                continue;
+            }
+        }
+    }
+    return {
+        path,
+        exists: true,
+        parsedLines,
+        malformedLines,
+        truncated,
+        events,
+    };
+}
+function parseRunEvent(event) {
+    if (typeof event.ts !== 'string' || typeof event.type !== 'string') {
+        return null;
+    }
+    const timeMs = Date.parse(event.ts);
+    if (!Number.isFinite(timeMs)) {
+        return null;
+    }
+    return {
+        ts: new Date(timeMs).toISOString(),
+        timeMs,
+        type: event.type,
+        data: event.data && typeof event.data === 'object' ? event.data : {},
+    };
+}
+function summarizeEvents(events) {
+    let lastEvent = null;
+    let lastMeaningfulEvent = null;
+    let lastCoderEvent = null;
+    let lastReviewerEvent = null;
+    let latestPhaseStart = null;
+    let latestTimeoutCleanupAfterPhaseStart = null;
+    for (const event of events) {
+        if (STATUS_INTERNAL_EVENT_TYPES.has(event.type)) {
+            continue;
+        }
+        if (!lastEvent || event.timeMs >= lastEvent.timeMs) {
+            lastEvent = event;
+        }
+        if (isMeaningfulEvent(event)) {
+            if (!lastMeaningfulEvent || event.timeMs >= lastMeaningfulEvent.timeMs) {
+                lastMeaningfulEvent = event;
+            }
+        }
+        if (isCoderEvent(event) && (!lastCoderEvent || event.timeMs >= lastCoderEvent.timeMs)) {
+            lastCoderEvent = event;
+        }
+        if (isReviewerEvent(event) && (!lastReviewerEvent || event.timeMs >= lastReviewerEvent.timeMs)) {
+            lastReviewerEvent = event;
+        }
+        if (event.type === 'phase.start' && (!latestPhaseStart || event.timeMs >= latestPhaseStart.timeMs)) {
+            latestPhaseStart = event;
+        }
+    }
+    if (latestPhaseStart) {
+        for (let index = events.length - 1; index >= 0; index -= 1) {
+            const event = events[index];
+            if (event.type === 'coder.timeout_cleanup' && event.timeMs >= latestPhaseStart.timeMs) {
+                latestTimeoutCleanupAfterPhaseStart = event;
+                break;
+            }
+        }
+    }
+    return {
+        lastEvent,
+        lastMeaningfulEvent,
+        lastCoderEvent,
+        lastReviewerEvent,
+        latestPhaseStart,
+        latestTimeoutCleanupAfterPhaseStart,
+    };
+}
+function isMeaningfulEvent(event) {
+    return MEANINGFUL_EVENT_TYPES.has(event.type) && event.type !== 'phase.heartbeat';
+}
+function isCoderEvent(event) {
+    return event.type.startsWith('coder.') || (event.type.startsWith('provider.') && event.data.role === 'coder');
+}
+function isReviewerEvent(event) {
+    return (event.type.startsWith('advisor.') ||
+        (event.type.startsWith('provider.') && event.data.role === 'structured-advisor'));
+}
+function classifyFinalCompletionStaleness(args) {
+    const evidence = summarizeFinalCompletionReviewEvidence(args.events);
+    const base = {
+        stale: false,
+        reason: null,
+        reviewerOutputObserved: evidence.reviewerOutputObserved,
+        finalCompletionPhaseStartedAt: evidence.finalCompletionPhaseStartedAt,
+        lastFinalCompletionReviewerOutputAt: evidence.lastFinalCompletionReviewerOutputAt,
+        finalCompletionPhaseTerminalEventObserved: evidence.finalCompletionPhaseTerminalEventObserved,
+    };
+    if (args.state.topLevelMode !== 'execute' ||
+        args.state.status !== 'running' ||
+        args.state.phase !== 'final_completion_review' ||
+        args.state.finalCommit === null ||
+        args.state.finalCompletionSummary === null ||
+        args.state.finalCompletionReviewVerdict !== null ||
+        args.state.finalCompletionResolvedAction !== null ||
+        !hasAcceptedTerminalCompletedScopeForCurrentPosition(args.state) ||
+        !evidence.reviewerOutputObserved ||
+        evidence.finalCompletionPhaseTerminalEventObserved ||
+        args.lock.kind === 'live_same_run') {
+        return base;
+    }
+    const quietMs = getQuietMs(args.eventSummary, args.nowMs);
+    if (quietMs === null || quietMs < QUIET_WARNING_MS) {
+        return base;
+    }
+    return {
+        ...base,
+        stale: true,
+        reason: 'final completion review has reviewer output but no terminal transition',
+    };
+}
+function summarizeFinalCompletionReviewEvidence(events) {
+    let latestPhaseStart = null;
+    for (const event of events) {
+        if (event.type === 'phase.start' &&
+            event.data.phase === 'final_completion_review' &&
+            (!latestPhaseStart || event.timeMs >= latestPhaseStart.timeMs)) {
+            latestPhaseStart = event;
+        }
+    }
+    let lastReviewerOutput = null;
+    let terminalEventObserved = false;
+    if (latestPhaseStart) {
+        for (const event of events) {
+            if (event.timeMs < latestPhaseStart.timeMs) {
+                continue;
+            }
+            if (isFinalCompletionReviewerOutputEvent(event)) {
+                if (!lastReviewerOutput || event.timeMs >= lastReviewerOutput.timeMs) {
+                    lastReviewerOutput = event;
+                }
+            }
+            if (isFinalCompletionPhaseTerminalEvent(event)) {
+                terminalEventObserved = true;
+            }
+        }
+    }
+    return {
+        reviewerOutputObserved: lastReviewerOutput !== null,
+        finalCompletionPhaseStartedAt: latestPhaseStart?.ts ?? null,
+        lastFinalCompletionReviewerOutputAt: lastReviewerOutput?.ts ?? null,
+        finalCompletionPhaseTerminalEventObserved: terminalEventObserved,
+    };
+}
+function isFinalCompletionReviewerOutputEvent(event) {
+    const label = stringValue(event.data.label);
+    return event.type === 'provider.structured_output_received' && Boolean(label?.startsWith('final-completion'));
+}
+function isFinalCompletionPhaseTerminalEvent(event) {
+    return ((event.type === 'phase.complete' || event.type === 'phase.error') &&
+        event.data.phase === 'final_completion_review');
+}
+function hasAcceptedTerminalCompletedScopeForCurrentPosition(state) {
+    const currentScopeNumber = String(state.currentScopeNumber);
+    return state.completedScopes.some((scope) => scope.number === currentScopeNumber &&
+        scope.result === 'accepted' &&
+        scope.marker === 'AUTONOMY_DONE' &&
+        scope.finalCommit === state.finalCommit);
+}
+function classifyHealth(state, events, nowMs, finalCompletionStaleness) {
+    const phaseStartMs = getPhaseStartMs(state, events);
+    const phaseElapsedMs = phaseStartMs === null ? null : Math.max(0, nowMs - phaseStartMs);
+    const quietMs = getQuietMs(events, nowMs);
+    const heartbeatOnly = isHeartbeatOnly(events);
+    const makeHealth = (classification, reason) => ({
+        classification,
+        phaseElapsedMs,
+        quietMs,
+        heartbeatOnly,
+        reason,
+    });
+    if (isBlockedState(state)) {
+        return makeHealth('blocked', 'state is blocked or failed');
+    }
+    if (events.lastMeaningfulEvent?.type === 'run.paused_after_scope') {
+        return makeHealth('paused', 'run paused after current scope');
+    }
+    if (state.status === 'paused') {
+        return makeHealth('paused', 'run is paused');
+    }
+    if (events.lastMeaningfulEvent?.type === 'phase.retry' || events.latestTimeoutCleanupAfterPhaseStart) {
+        return makeHealth('timed_out', 'retry or timeout cleanup observed');
+    }
+    if (state.status === 'done' || state.phase === 'done') {
+        return makeHealth('ok', 'run is done');
+    }
+    if (finalCompletionStaleness.stale) {
+        return makeHealth('stale', finalCompletionStaleness.reason ?? 'final completion review appears stale');
+    }
+    const meaningfulAgeMs = events.lastMeaningfulEvent ? nowMs - events.lastMeaningfulEvent.timeMs : null;
+    if (meaningfulAgeMs !== null && meaningfulAgeMs <= OK_MEANINGFUL_EVENT_MS) {
+        return makeHealth('ok', 'recent meaningful event');
+    }
+    const eventAgeMs = events.lastEvent ? nowMs - events.lastEvent.timeMs : null;
+    if (heartbeatOnly && eventAgeMs !== null && eventAgeMs <= OK_MEANINGFUL_EVENT_MS) {
+        return makeHealth('heartbeat_only', 'recent heartbeat without phase progress');
+    }
+    if (state.status === 'running' && quietMs !== null && quietMs >= QUIET_WARNING_MS) {
+        return makeHealth('quiet', 'no recent meaningful event');
+    }
+    return makeHealth('unknown', 'insufficient event evidence');
+}
+function getQuietMs(events, nowMs) {
+    const quietBasisMs = events.lastMeaningfulEvent?.timeMs ?? events.lastEvent?.timeMs ?? null;
+    return quietBasisMs === null ? null : Math.max(0, nowMs - quietBasisMs);
+}
+function isBlockedState(state) {
+    const { waitingForOperatorGuidance } = getRunDisplayStatus(state);
+    return state.status === 'blocked' || state.status === 'failed' || state.phase === 'blocked' || waitingForOperatorGuidance;
+}
+function getPhaseStartMs(state, events) {
+    if (events.latestPhaseStart) {
+        return events.latestPhaseStart.timeMs;
+    }
+    const updatedAtMs = Date.parse(state.updatedAt);
+    if (Number.isFinite(updatedAtMs)) {
+        return updatedAtMs;
+    }
+    const createdAtMs = Date.parse(state.createdAt);
+    return Number.isFinite(createdAtMs) ? createdAtMs : null;
+}
+function isHeartbeatOnly(events) {
+    if (events.lastEvent?.type !== 'phase.heartbeat') {
+        return false;
+    }
+    const phaseStartMs = events.latestPhaseStart?.timeMs ?? null;
+    if (phaseStartMs === null) {
+        return events.lastMeaningfulEvent === null;
+    }
+    return !events.lastMeaningfulEvent || events.lastMeaningfulEvent.timeMs <= phaseStartMs;
+}
+function summarizeEvent(event) {
+    const candidates = [
+        event.data.message,
+        typeof event.data.phase === 'string' ? formatMaybePublicPhase(event.data.phase) : null,
+        typeof event.data.nextPhase === 'string' ? formatMaybePublicPhase(event.data.nextPhase) : null,
+        event.data.command,
+        event.data.label,
+    ];
+    const summary = candidates.find((candidate) => typeof candidate === 'string' && candidate.length > 0);
+    return summary ?? event.type;
+}
+function summarizeFindings(state) {
+    return {
+        total: state.findings.length,
+        openBlocking: state.findings.filter((finding) => finding.status === 'open' && finding.severity === 'blocking').length,
+        openNonBlocking: state.findings.filter((finding) => finding.status === 'open' && finding.severity === 'non_blocking').length,
+        fixed: state.findings.filter((finding) => finding.status === 'fixed').length,
+        rejected: state.findings.filter((finding) => finding.status === 'rejected').length,
+        deferred: state.findings.filter((finding) => finding.status === 'deferred').length,
+    };
+}
+function summarizeCommits(state) {
+    return {
+        initialBaseCommit: state.initialBaseCommit,
+        baseCommit: state.baseCommit,
+        finalCommit: state.finalCommit,
+        createdCommitCount: state.createdCommits.length,
+        acceptedScopeFinalCommits: state.completedScopes
+            .filter((scope) => scope.result === 'accepted' && typeof scope.finalCommit === 'string' && scope.finalCommit.length > 0)
+            .map((scope) => scope.finalCommit),
+    };
+}
+async function summarizeSquashArtifact(runDir) {
+    const artifactPath = join(runDir, 'SQUASH_RESULT.json');
+    let artifactText;
+    try {
+        artifactText = await readFile(artifactPath, 'utf8');
+    }
+    catch (error) {
+        if (isNotFoundError(error)) {
+            return {
+                artifactPath,
+                status: 'missing',
+                replacementCommit: null,
+                finalHeadCommit: null,
+                originalBaseCommit: null,
+                originalFinalCommit: null,
+                unavailableReason: 'SQUASH_RESULT.json is not present for this run.',
+            };
+        }
+        const reason = error instanceof Error && error.message.trim()
+            ? `SQUASH_RESULT.json could not be read: ${truncateStatusMessage(error.message)}`
+            : 'SQUASH_RESULT.json could not be read.';
+        return malformedSquashSummary(artifactPath, reason);
+    }
+    try {
+        const artifact = parseSquashArtifact(JSON.parse(artifactText));
+        if (!artifact) {
+            return malformedSquashSummary(artifactPath, 'SQUASH_RESULT.json does not match the expected squash artifact shape.');
+        }
+        return {
+            artifactPath,
+            status: artifact.status,
+            replacementCommit: artifact.replacementCommit,
+            finalHeadCommit: artifact.finalHeadCommit,
+            originalBaseCommit: artifact.originalBaseCommit,
+            originalFinalCommit: artifact.originalFinalCommit,
+            unavailableReason: null,
+        };
+    }
+    catch (error) {
+        const reason = error instanceof Error && error.message.trim()
+            ? `SQUASH_RESULT.json could not be parsed: ${truncateStatusMessage(error.message)}`
+            : 'SQUASH_RESULT.json could not be parsed.';
+        return malformedSquashSummary(artifactPath, reason);
+    }
+}
+function malformedSquashSummary(artifactPath, unavailableReason) {
+    return {
+        artifactPath,
+        status: 'malformed',
+        replacementCommit: null,
+        finalHeadCommit: null,
+        originalBaseCommit: null,
+        originalFinalCommit: null,
+        unavailableReason,
+    };
+}
+function parseSquashArtifact(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return null;
+    }
+    const record = value;
+    if (record.version !== 1 || (record.status !== 'pending' && record.status !== 'complete')) {
+        return null;
+    }
+    const originalBaseCommit = stringValue(record.originalBaseCommit);
+    const originalFinalCommit = stringValue(record.originalFinalCommit);
+    if (!originalBaseCommit || !originalFinalCommit) {
+        return null;
+    }
+    const replacementCommit = nullableStringValue(record.replacementCommit);
+    const finalHeadCommit = nullableStringValue(record.finalHeadCommit);
+    if (record.status === 'complete' && (!replacementCommit || !finalHeadCommit)) {
+        return null;
+    }
+    if (record.status === 'pending' && (replacementCommit !== null || finalHeadCommit !== null)) {
+        return null;
+    }
+    return {
+        status: record.status,
+        replacementCommit,
+        finalHeadCommit,
+        originalBaseCommit,
+        originalFinalCommit,
+    };
+}
+function summarizeProviderError(events) {
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const event = events[index];
+        if (event.type !== 'provider.provider_error') {
+            continue;
+        }
+        return {
+            source: 'provider_event',
+            timestamp: event.ts,
+            provider: stringValue(event.data.provider),
+            role: providerRoleValue(event.data.role),
+            label: stringValue(event.data.label),
+            sessionHandle: nullableStringValue(event.data.sessionHandle),
+            kind: providerErrorKindValue(event.data.errorKind),
+            message: truncateStatusMessage(stringValue(event.data.message) ?? 'Provider failed.'),
+            retryable: typeof event.data.retryable === 'boolean' ? event.data.retryable : null,
+            diagnostic: providerErrorDiagnosticValue(event.data.providerData),
+        };
+    }
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const event = events[index];
+        if (event.type !== 'phase.error') {
+            continue;
+        }
+        return {
+            source: 'phase_error',
+            timestamp: event.ts,
+            provider: null,
+            role: null,
+            label: typeof event.data.phase === 'string' ? formatMaybePublicPhase(event.data.phase) : null,
+            sessionHandle: nullableStringValue(event.data.sessionHandle),
+            kind: null,
+            message: truncateStatusMessage(stringValue(event.data.message) ?? 'Run phase failed.'),
+            retryable: null,
+            diagnostic: null,
+        };
+    }
+    return null;
+}
+async function summarizeBuild(state) {
+    const metaBuild = await readMetaBuild(join(state.runDir, 'meta.json'));
+    if (metaBuild) {
+        return {
+            ...metaBuild,
+            source: 'meta',
+            agentConfig: state.agentConfig,
+        };
+    }
+    return {
+        ...await getNealBuildMetadata(),
+        source: 'live_fallback',
+        agentConfig: state.agentConfig,
+    };
+}
+async function readMetaBuild(path) {
+    try {
+        const parsed = JSON.parse(await readFile(path, 'utf8'));
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return null;
+        }
+        const build = parsed.build;
+        if (!build || typeof build !== 'object' || Array.isArray(build)) {
+            return null;
+        }
+        const record = build;
+        const packageVersion = stringValue(record.packageVersion);
+        const nodeVersion = stringValue(record.nodeVersion);
+        const sourceGitSha = nullableStringValue(record.sourceGitSha);
+        if (!packageVersion || !nodeVersion) {
+            return null;
+        }
+        return {
+            packageVersion,
+            nodeVersion,
+            sourceGitSha,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function summarizePatch(state, displayStatus, squash) {
+    const candidate = selectPatchCandidate(state, squash);
+    const range = candidate.baseCommit && candidate.headCommit ? `${candidate.baseCommit}..${candidate.headCommit}` : null;
+    const baseSummary = {
+        defaultSubmissionEligible: false,
+        source: candidate.source,
+        baseCommit: candidate.baseCommit,
+        headCommit: candidate.headCommit,
+        range,
+        commitCount: null,
+        changedFileCount: null,
+        changedFiles: [],
+        unavailableReason: null,
+    };
+    if (!candidate.baseCommit) {
+        return {
+            ...baseSummary,
+            reason: 'No patch base commit is available.',
+            unavailableReason: 'No patch base commit is available.',
+        };
+    }
+    if (!candidate.headCommit) {
+        return {
+            ...baseSummary,
+            reason: 'No patch head commit is available.',
+            unavailableReason: 'No patch head commit is available.',
+        };
+    }
+    let commits;
+    let changedFiles;
+    try {
+        [commits, changedFiles] = await Promise.all([
+            getCommitRange(state.cwd, candidate.baseCommit, candidate.headCommit),
+            getChangedFilesForRange(state.cwd, candidate.baseCommit, candidate.headCommit),
+        ]);
+    }
+    catch (error) {
+        const unavailableReason = error instanceof Error && error.message.trim()
+            ? truncateStatusMessage(error.message)
+            : 'Git could not read the patch range.';
+        return {
+            ...baseSummary,
+            reason: `Patch range is unavailable: ${unavailableReason}`,
+            unavailableReason,
+        };
+    }
+    const populatedSummary = {
+        ...baseSummary,
+        commitCount: commits.length,
+        changedFileCount: changedFiles.length,
+        changedFiles,
+    };
+    if (commits.length === 0 || changedFiles.length === 0) {
+        return {
+            ...populatedSummary,
+            reason: 'Completed run produced an empty patch range.',
+        };
+    }
+    if (squash.status === 'malformed') {
+        return {
+            ...populatedSummary,
+            reason: 'SQUASH_RESULT.json is malformed; default submission requires an auditable patch head.',
+            unavailableReason: squash.unavailableReason,
+        };
+    }
+    if (squash.status === 'pending') {
+        return {
+            ...populatedSummary,
+            reason: 'Squash artifact is pending; default submission requires finalized patch metadata.',
+        };
+    }
+    if (!isCleanCompletedExecuteRun(state, displayStatus)) {
+        return {
+            ...populatedSummary,
+            reason: `Run status is ${displayStatus.effectiveStatus}; default submission requires a completed execute run.`,
+        };
+    }
+    return {
+        ...populatedSummary,
+        defaultSubmissionEligible: true,
+        reason: 'Completed execute run has a non-empty patch range.',
+    };
+}
+function selectPatchCandidate(state, squash) {
+    if (squash.status === 'complete' && squash.originalBaseCommit && squash.replacementCommit) {
+        return {
+            source: 'squash_replacement',
+            baseCommit: squash.originalBaseCommit,
+            headCommit: squash.replacementCommit,
+        };
+    }
+    const baseCommit = state.initialBaseCommit ?? state.baseCommit;
+    if (baseCommit || state.finalCommit) {
+        return {
+            source: 'final_commit',
+            baseCommit,
+            headCommit: state.finalCommit,
+        };
+    }
+    return {
+        source: 'none',
+        baseCommit: null,
+        headCommit: null,
+    };
+}
+function isCleanCompletedExecuteRun(state, displayStatus) {
+    return (state.topLevelMode === 'execute' &&
+        state.phase === 'done' &&
+        state.status === 'done' &&
+        displayStatus.effectiveStatus === 'done' &&
+        !displayStatus.waitingForOperatorGuidance &&
+        !displayStatus.pendingOperatorGuidance);
+}
+function providerRoleValue(value) {
+    return value === 'coder' || value === 'structured-advisor' ? value : null;
+}
+function providerErrorKindValue(value) {
+    return typeof value === 'string' && PROVIDER_ERROR_KINDS.has(value)
+        ? value
+        : null;
+}
+const STATUS_PROVIDER_DIAGNOSTIC_MAX_STRING_LENGTH = 2_000;
+const STATUS_PROVIDER_DIAGNOSTIC_MAX_DEPTH = 4;
+function providerErrorDiagnosticValue(providerData) {
+    if (typeof providerData !== 'object' || providerData === null) {
+        return null;
+    }
+    const diagnostic = providerData.diagnostic;
+    const sanitized = sanitizeProviderDiagnostic(diagnostic);
+    return typeof sanitized === 'object' && sanitized !== null && !Array.isArray(sanitized)
+        ? sanitized
+        : null;
+}
+function sanitizeProviderDiagnostic(value, depth = 0) {
+    if (depth > STATUS_PROVIDER_DIAGNOSTIC_MAX_DEPTH) {
+        return '[truncated: max depth]';
+    }
+    if (value === null || typeof value === 'number' || typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        if (value.length <= STATUS_PROVIDER_DIAGNOSTIC_MAX_STRING_LENGTH) {
+            return value;
+        }
+        return `${value.slice(0, STATUS_PROVIDER_DIAGNOSTIC_MAX_STRING_LENGTH)}...[truncated ${value.length - STATUS_PROVIDER_DIAGNOSTIC_MAX_STRING_LENGTH} chars]`;
+    }
+    if (Array.isArray(value)) {
+        return value.slice(0, 20).map((item) => sanitizeProviderDiagnostic(item, depth + 1));
+    }
+    if (typeof value !== 'object') {
+        return null;
+    }
+    const output = {};
+    for (const [key, nestedValue] of Object.entries(value)) {
+        output[key] = sanitizeProviderDiagnostic(nestedValue, depth + 1);
+    }
+    return output;
+}
+function nullableStringValue(value) {
+    return value === null || value === undefined ? null : stringValue(value);
+}
+function truncateStatusMessage(value) {
+    if (value.length <= STATUS_ERROR_MESSAGE_MAX_LENGTH) {
+        return value;
+    }
+    return `${value.slice(0, STATUS_ERROR_MESSAGE_MAX_LENGTH - 3)}...`;
+}
+function stringValue(value) {
+    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : null;
+}
+function stringArrayValue(value) {
+    return Array.isArray(value)
+        ? value.filter((item) => typeof item === 'string' && item.trim().length > 0)
+        : [];
+}
+function isNotFoundError(error) {
+    return Boolean(error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT');
+}