@kbediako/codex-orchestrator 0.2.0 → 0.2.1

package/dist/orchestrator/src/cli/providerLinearWorkerRunner.js

@@ -39,6 +39,7 @@ export const PROVIDER_LINEAR_WORKER_CHILD_LANES_FILENAME = 'provider-linear-work
 export const PROVIDER_LINEAR_RESIDENT_SESSION_SEED_ENV = 'CODEX_ORCHESTRATOR_PROVIDER_RESIDENT_SESSION_SEED';
 export const PROVIDER_LINEAR_CHILD_LANE_PIPELINE_ID = 'provider-linear-child-lane';
 export const PROVIDER_LINEAR_CHILD_LANE_RESERVED_SUMMARY = 'Child lane reserved before child run startup.';
+export const PROVIDER_LINEAR_CHILD_LANE_DIAGNOSTICS_FILENAME = 'provider-linear-child-lane-diagnostics.json';
 const PROVIDER_LINEAR_CHILD_LANE_PROOF_FILENAME = 'provider-linear-child-lane-proof.json';
 const PROVIDER_LINEAR_WORKER_SESSION_LOG_HYDRATION_FILENAME = 'provider-linear-worker-session-log-hydration.json';
 const PROVIDER_LINEAR_WORKER_PROOF_LOCK_FILENAME = `${PROVIDER_LINEAR_WORKER_PROOF_FILENAME}.lock`;
@@ -94,6 +95,9 @@ export const PROVIDER_SEMANTIC_STALL_RECHECK_DELAY_MS = 15 * 60 * 1000 + 1_000;
 const PROVIDER_WORKER_SESSION_LOG_POLL_INTERVAL_MS = 250;
 const PROVIDER_WORKER_SESSION_LOG_DISCOVERY_WINDOW_MS = 15 * 60 * 1000;
 const PROVIDER_WORKER_SESSION_LOG_HEADER_BYTES = 256 * 1024;
+const PROVIDER_LINEAR_CHILD_LANE_POST_STARTUP_NO_OUTPUT_MIN_STALE_MS = 60 * 1000;
+const PROVIDER_LINEAR_CHILD_LANE_RUNNER_IDENTITY_START_BEFORE_TOLERANCE_MS = 5 * 60 * 1000;
+const PROVIDER_LINEAR_CHILD_LANE_RUNNER_PROCESS_LOOKUP_TIMEOUT_MS = 2000;
 export function buildEmptyProviderLinearWorkerTokenUsage() {
     return {
         input_tokens: null,
@@ -1391,7 +1395,7 @@ function applyProviderLinearWorkerJsonlRecord(state, parsed, activitySource, env
     }
     const observedTokens = extractProviderWorkerTokenUsage(parsed);
     if (observedTokens && hasProviderWorkerTokenUsage(observedTokens)) {
-        state.tokens = observedTokens;
+        state.tokens = mergeProviderWorkerObservedTokenUsage(state.tokens, observedTokens);
         changed = true;
     }
     const observedRateLimits = extractProviderWorkerRateLimits(parsed);
@@ -1416,13 +1420,6 @@ function applyProviderLinearWorkerJsonlRecord(state, parsed, activitySource, env
     }
     return changed;
 }
-function applyProviderLinearWorkerSessionJsonlLine(state, line, env = process.env) {
-    const parsed = parseProviderWorkerSessionJsonlLine(line);
-    if (!parsed) {
-        return false;
-    }
-    return applyProviderLinearWorkerSessionJsonlRecord(state, parsed, env);
-}
 function applyProviderLinearWorkerSessionJsonlRecord(state, parsed, env = process.env) {
     return applyProviderLinearWorkerJsonlRecord(state, parsed, 'session_log_hydration', env);
 }
@@ -1440,7 +1437,10 @@ function isProviderLinearWorkerBookkeepingRecord(parsed) {
     return parsed.type === 'session_meta' || parsed.type === 'turn_context' || parsed.type === 'thread.started';
 }
 function hasProviderWorkerTokenUsage(value) {
-    return value.input_tokens !== null || value.output_tokens !== null || value.total_tokens !== null;
+    return (value.input_tokens !== null ||
+        value.output_tokens !== null ||
+        value.total_tokens !== null ||
+        value.reasoning_output_tokens != null);
 }
 function maxProviderWorkerNullableNumber(left, right) {
     if (left === null) {
@@ -1452,11 +1452,28 @@ function maxProviderWorkerNullableNumber(left, right) {
     return Math.max(left, right);
 }
 function mergeProviderWorkerTokenUsageFloor(current, observed) {
-    return {
+    const merged = {
         input_tokens: maxProviderWorkerNullableNumber(current.input_tokens, observed.input_tokens),
         output_tokens: maxProviderWorkerNullableNumber(current.output_tokens, observed.output_tokens),
         total_tokens: maxProviderWorkerNullableNumber(current.total_tokens, observed.total_tokens)
     };
+    const reasoningOutputTokens = maxProviderWorkerNullableNumber(current.reasoning_output_tokens ?? null, observed.reasoning_output_tokens ?? null);
+    if (reasoningOutputTokens !== null) {
+        merged.reasoning_output_tokens = reasoningOutputTokens;
+    }
+    return merged;
+}
+function mergeProviderWorkerObservedTokenUsage(current, observed) {
+    const merged = {
+        input_tokens: observed.input_tokens ?? current.input_tokens,
+        output_tokens: observed.output_tokens ?? current.output_tokens,
+        total_tokens: observed.total_tokens ?? current.total_tokens
+    };
+    const reasoningOutputTokens = observed.reasoning_output_tokens ?? current.reasoning_output_tokens ?? null;
+    if (reasoningOutputTokens !== null) {
+        merged.reasoning_output_tokens = reasoningOutputTokens;
+    }
+    return merged;
 }
 function providerWorkerTokenUsageFallsBehindFloor(current, observed) {
     return (observed !== null &&
@@ -1666,15 +1683,30 @@ function normalizeProviderWorkerTokenUsage(input) {
         'totalTokens',
         'total'
     ]);
+    const reasoningOutputTokens = readTokenCount(input, [
+        'reasoning_output_tokens',
+        'reasoningOutputTokens',
+        'total_reasoning_output_tokens',
+        'totalReasoningOutputTokens',
+        'reasoning_tokens',
+        'reasoningTokens'
+    ]);
     const normalizedTotalTokens = totalTokens ?? (inputTokens !== null && outputTokens !== null ? inputTokens + outputTokens : null);
-    if (inputTokens === null && outputTokens === null && normalizedTotalTokens === null) {
+    if (inputTokens === null &&
+        outputTokens === null &&
+        normalizedTotalTokens === null &&
+        reasoningOutputTokens === null) {
         return null;
     }
-    return {
+    const usage = {
         input_tokens: inputTokens,
         output_tokens: outputTokens,
         total_tokens: normalizedTotalTokens
     };
+    if (reasoningOutputTokens !== null) {
+        usage.reasoning_output_tokens = reasoningOutputTokens;
+    }
+    return usage;
 }
 function readTokenCount(input, keys) {
     for (const key of keys) {
@@ -2698,6 +2730,9 @@ function formatProviderWorkerTokenUsageSummary(usage) {
     if (typeof usage.total_tokens === 'number' && Number.isFinite(usage.total_tokens)) {
         parts.push(`total ${Math.max(0, Math.trunc(usage.total_tokens))}`);
     }
+    if (typeof usage.reasoning_output_tokens === 'number' && Number.isFinite(usage.reasoning_output_tokens)) {
+        parts.push(`reasoning ${Math.max(0, Math.trunc(usage.reasoning_output_tokens))}`);
+    }
     return parts.length > 0 ? parts.join(' / ') : null;
 }
 function formatProviderWorkerRateLimitSummary(rateLimits) {
@@ -2964,6 +2999,7 @@ function resetProviderWorkerSessionLogTailState(state) {
     state.offsetBytes = 0;
     state.trailingText = '';
     state.bootstrapPending = true;
+    state.idRewindSignature = null;
 }
 function normalizeProviderWorkerSessionLogHydrationState(value) {
     if (!isRecord(value)) {
@@ -2981,36 +3017,46 @@ function normalizeProviderWorkerSessionLogHydrationState(value) {
         offset_bytes: offsetBytes,
         trailing_text: typeof value.trailing_text === 'string' ? value.trailing_text : '',
         bootstrap_pending: typeof value.bootstrap_pending === 'boolean' ? value.bootstrap_pending : true,
-        proof_signature: typeof value.proof_signature === 'string' ? value.proof_signature : ''
+        proof_signature: typeof value.proof_signature === 'string' ? value.proof_signature : '',
+        id_rewind_signature: typeof value.id_rewind_signature === 'string' ? value.id_rewind_signature : null
     };
 }
-function buildProviderWorkerSessionLogTailState(path, hydrationState) {
+function buildProviderWorkerSessionLogTailState(path, hydrationState, currentTurnStartedAt = null) {
+    const normalizedCurrentTurnStartedAt = normalizeOptionalString(currentTurnStartedAt);
     if (!hydrationState || hydrationState.path !== path) {
         return {
             path,
             offsetBytes: 0,
             trailingText: '',
-            bootstrapPending: true
+            bootstrapPending: true,
+            currentTurnStartedAt: normalizedCurrentTurnStartedAt,
+            idRewindSignature: null
         };
     }
     return {
         path,
         offsetBytes: hydrationState.offset_bytes,
         trailingText: hydrationState.trailing_text,
-        bootstrapPending: hydrationState.bootstrap_pending
+        bootstrapPending: hydrationState.bootstrap_pending,
+        currentTurnStartedAt: normalizedCurrentTurnStartedAt,
+        idRewindSignature: hydrationState.id_rewind_signature ?? null
     };
 }
 function snapshotProviderWorkerSessionLogTailState(state) {
     if (!state.path) {
         return null;
     }
-    return {
+    const snapshot = {
         path: state.path,
         offset_bytes: state.offsetBytes,
         trailing_text: state.trailingText,
         bootstrap_pending: state.bootstrapPending,
         proof_signature: ''
     };
+    if (state.idRewindSignature) {
+        snapshot.id_rewind_signature = state.idRewindSignature;
+    }
+    return snapshot;
 }
 function selectProviderLinearWorkerCurrentTurnActivity(proof) {
     const hydrated = proof.current_turn_activity ?? null;
@@ -3048,6 +3094,31 @@ function buildProviderWorkerSessionLogHydrationProofSignature(proof) {
         failure_diagnosis: proof.failure_diagnosis ?? null
     });
 }
+function providerLinearWorkerProofNeedsSessionLogIdHydration(proof) {
+    const selectedMode = proof.runtime?.selected_mode ?? proof.auth_provenance?.runtime_mode ?? null;
+    if (selectedMode !== 'appserver') {
+        return false;
+    }
+    if (!proof.thread_id || !proof.latest_turn_id || !proof.latest_session_id) {
+        return false;
+    }
+    return (proof.session_log_thread_id !== proof.thread_id ||
+        proof.session_log_turn_id !== proof.latest_turn_id ||
+        proof.session_log_session_id !== proof.latest_session_id);
+}
+function buildProviderWorkerSessionLogIdHydrationRewindSignature(proof) {
+    if (!providerLinearWorkerProofNeedsSessionLogIdHydration(proof)) {
+        return null;
+    }
+    return JSON.stringify({
+        thread_id: proof.thread_id ?? null,
+        latest_turn_id: proof.latest_turn_id ?? null,
+        latest_session_id: proof.latest_session_id ?? null,
+        session_log_thread_id: proof.session_log_thread_id ?? null,
+        session_log_turn_id: proof.session_log_turn_id ?? null,
+        session_log_session_id: proof.session_log_session_id ?? null
+    });
+}
 async function readProviderWorkerSessionLogDelta(state) {
     if (!state.path) {
         return '';
@@ -3060,6 +3131,7 @@ async function readProviderWorkerSessionLogDelta(state) {
         state.offsetBytes = 0;
         state.trailingText = '';
         state.bootstrapPending = true;
+        state.idRewindSignature = null;
     }
     const bytesToRead = fileStat.size - state.offsetBytes;
     if (bytesToRead <= 0) {
@@ -3089,11 +3161,54 @@ function parseProviderWorkerSessionJsonlLine(line) {
         return null;
     }
 }
+function extractProviderWorkerSessionLogObservedThreadId(parsed) {
+    const payload = isRecord(parsed.payload) ? parsed.payload : null;
+    if (parsed.type === 'session_meta' && payload) {
+        return normalizeOptionalString(payload.id);
+    }
+    if (parsed.type === 'thread.started') {
+        return normalizeOptionalString(parsed.thread_id);
+    }
+    return null;
+}
+function extractProviderWorkerSessionLogObservedTurnId(parsed) {
+    const payload = isRecord(parsed.payload) ? parsed.payload : null;
+    if (parsed.type === 'turn_context' && payload) {
+        return normalizeOptionalString(payload.turn_id);
+    }
+    return extractProviderWorkerActivityTurnId(parsed);
+}
+function observeProviderWorkerSessionLogLines(lines) {
+    let observed = false;
+    let observedThreadId = null;
+    let observedTurnId = null;
+    for (const line of lines) {
+        const parsed = parseProviderWorkerSessionJsonlLine(line);
+        if (!parsed) {
+            continue;
+        }
+        observed = true;
+        observedThreadId = extractProviderWorkerSessionLogObservedThreadId(parsed) ?? observedThreadId;
+        observedTurnId = extractProviderWorkerSessionLogObservedTurnId(parsed) ?? observedTurnId;
+    }
+    return {
+        observed,
+        observedThreadId,
+        observedTurnId
+    };
+}
+function observeProviderWorkerSessionLogAppliedLines(input) {
+    const observationLines = !input.bootstrapPending || input.linesToApply.length === input.lines.length
+        ? input.lines
+        : input.linesToApply;
+    return observeProviderWorkerSessionLogLines(observationLines);
+}
 function selectProviderWorkerSessionBootstrapLines(lines, options = { requireTurnContext: false }) {
     let latestSessionMetaIndex = -1;
     let latestTurnContextIndex = -1;
     let latestTurnId = null;
     let latestTurnCompleted = false;
+    let latestTurnCompletedIndex = -1;
     for (let index = 0; index < lines.length; index += 1) {
         const parsed = parseProviderWorkerSessionJsonlLine(lines[index] ?? '');
         if (!parsed) {
@@ -3106,12 +3221,14 @@ function selectProviderWorkerSessionBootstrapLines(lines, options = { requireTur
             latestTurnContextIndex = index;
             latestTurnId = normalizeOptionalString(parsed.payload.turn_id);
             latestTurnCompleted = false;
+            latestTurnCompletedIndex = -1;
         }
         if (parsed.type === 'event_msg' && isRecord(parsed.payload) && parsed.payload.type === 'task_complete') {
             const completedTurnId = normalizeOptionalString(parsed.payload.turn_id);
             if (latestTurnContextIndex >= 0 &&
                 (!latestTurnId || !completedTurnId || completedTurnId === latestTurnId)) {
                 latestTurnCompleted = true;
+                latestTurnCompletedIndex = index;
             }
         }
     }
@@ -3122,14 +3239,66 @@ function selectProviderWorkerSessionBootstrapLines(lines, options = { requireTur
         return lines;
     }
     if (latestTurnCompleted) {
-        return latestSessionMetaIndex >= 0 ? [lines[latestSessionMetaIndex] ?? ''] : [];
+        const currentTurnId = normalizeOptionalString(options.currentTurnId);
+        const allowCompletedBootstrapTurn = options.allowCompletedBootstrapTurn ?? true;
+        if (!allowCompletedBootstrapTurn && currentTurnId === null) {
+            return latestSessionMetaIndex >= 0 ? [lines[latestSessionMetaIndex] ?? ''] : [];
+        }
+        if (currentTurnId !== null && latestTurnId !== null && latestTurnId !== currentTurnId) {
+            return latestSessionMetaIndex >= 0 ? [lines[latestSessionMetaIndex] ?? ''] : [];
+        }
+        const currentTurnMatchesCompletedLog = currentTurnId !== null && latestTurnId === currentTurnId;
+        const completedLine = latestTurnCompletedIndex >= 0 ? lines[latestTurnCompletedIndex] ?? '' : '';
+        const completedLineHasTimestamp = providerWorkerSessionJsonlLineTimestamp(completedLine) !== null;
+        const completedFloorLine = completedLine && completedLineHasTimestamp
+            ? completedLine
+            : lines[latestTurnContextIndex] ?? '';
+        if (!currentTurnMatchesCompletedLog &&
+            !isProviderWorkerSessionBootstrapLineAtOrAfter(completedFloorLine, options.currentTurnStartedAt ?? null)) {
+            return latestSessionMetaIndex >= 0 ? [lines[latestSessionMetaIndex] ?? ''] : [];
+        }
+        const bootstrapLines = latestSessionMetaIndex >= 0 && latestSessionMetaIndex < latestTurnContextIndex
+            ? [lines[latestSessionMetaIndex] ?? '']
+            : [];
+        return [...bootstrapLines, ...lines.slice(latestTurnContextIndex)];
     }
     const bootstrapLines = latestSessionMetaIndex >= 0 && latestSessionMetaIndex < latestTurnContextIndex
         ? [lines[latestSessionMetaIndex] ?? '']
         : [];
     return [...bootstrapLines, ...lines.slice(latestTurnContextIndex)];
 }
-function applyProviderWorkerSessionLogDelta(parseState, tailState, chunk, env = process.env) {
+function providerWorkerSessionJsonlLineTimestamp(line) {
+    const parsed = parseProviderWorkerSessionJsonlLine(line);
+    if (!parsed) {
+        return null;
+    }
+    const lineTimestamp = normalizeOptionalString(parsed.timestamp);
+    if (lineTimestamp) {
+        return lineTimestamp;
+    }
+    const payload = isRecord(parsed.payload) ? parsed.payload : null;
+    return payload
+        ? normalizeOptionalString(payload.timestamp) ??
+            normalizeOptionalString(payload.created_at) ??
+            normalizeOptionalString(payload.at)
+        : null;
+}
+function isProviderWorkerSessionBootstrapLineAtOrAfter(line, floorTimestamp) {
+    const normalizedFloor = normalizeOptionalString(floorTimestamp);
+    if (!normalizedFloor) {
+        return false;
+    }
+    const lineTimestamp = providerWorkerSessionJsonlLineTimestamp(line);
+    return lineTimestamp !== null && compareIsoTimestamp(lineTimestamp, normalizedFloor) >= 0;
+}
+function shouldAllowCompletedProviderWorkerSessionBootstrapTurn(proof) {
+    if (proof.latest_turn_id !== null) {
+        return true;
+    }
+    const continuityState = proof.resident_session?.continuity_state ?? null;
+    return continuityState !== 'guarded_resume_pending' && continuityState !== 'guarded_resume_active';
+}
+function applyProviderWorkerSessionLogDelta(parseState, tailState, chunk, env = process.env, options = {}) {
     const combined = `${tailState.trailingText}${chunk}`;
     const lines = combined.split(/\r?\n/u);
     tailState.trailingText = lines.pop() ?? '';
@@ -3139,49 +3308,111 @@ function applyProviderWorkerSessionLogDelta(parseState, tailState, chunk, env =
     }
     const requireTurnContext = tailState.bootstrapPending && parseState.turnId === null;
     const linesToApply = tailState.bootstrapPending && lines.length > 0
-        ? selectProviderWorkerSessionBootstrapLines(lines, { requireTurnContext })
+        ? selectProviderWorkerSessionBootstrapLines(lines, {
+            requireTurnContext,
+            currentTurnStartedAt: tailState.currentTurnStartedAt,
+            currentTurnId: parseState.turnId,
+            allowCompletedBootstrapTurn: options.allowCompletedBootstrapTurn
+        })
         : lines;
+    const observation = observeProviderWorkerSessionLogAppliedLines({
+        lines,
+        linesToApply,
+        bootstrapPending: tailState.bootstrapPending
+    });
     let changed = false;
     for (const line of linesToApply) {
-        changed = applyProviderLinearWorkerSessionJsonlLine(parseState, line, env) || changed;
+        const parsed = parseProviderWorkerSessionJsonlLine(line);
+        if (!parsed) {
+            continue;
+        }
+        changed = applyProviderLinearWorkerSessionJsonlRecord(parseState, parsed, env) || changed;
     }
     if (tailState.bootstrapPending && lines.length > 0) {
         tailState.bootstrapPending = requireTurnContext && parseState.turnId === null;
     }
-    return changed;
+    return { changed, ...observation };
 }
-function flushProviderWorkerSessionLogTail(parseState, tailState, env = process.env) {
+function flushProviderWorkerSessionLogTail(parseState, tailState, env = process.env, options = {}) {
     const trailingLine = tailState.trailingText.trim();
     if (!trailingLine) {
         tailState.trailingText = '';
-        return false;
+        return { changed: false, observed: false, observedThreadId: null, observedTurnId: null };
     }
     if (!parseProviderWorkerSessionJsonlLine(trailingLine)) {
-        return false;
+        return { changed: false, observed: false, observedThreadId: null, observedTurnId: null };
     }
     tailState.trailingText = '';
     const shouldBootstrap = tailState.bootstrapPending;
     const requireTurnContext = shouldBootstrap && parseState.turnId === null;
     const trailingLines = shouldBootstrap
-        ? selectProviderWorkerSessionBootstrapLines([trailingLine], { requireTurnContext })
+        ? selectProviderWorkerSessionBootstrapLines([trailingLine], {
+            requireTurnContext,
+            currentTurnStartedAt: tailState.currentTurnStartedAt,
+            currentTurnId: parseState.turnId,
+            allowCompletedBootstrapTurn: options.allowCompletedBootstrapTurn
+        })
         : [trailingLine];
+    const observation = observeProviderWorkerSessionLogAppliedLines({
+        lines: [trailingLine],
+        linesToApply: trailingLines,
+        bootstrapPending: shouldBootstrap
+    });
     let changed = false;
     for (const line of trailingLines) {
-        changed = applyProviderLinearWorkerSessionJsonlLine(parseState, line, env) || changed;
+        const parsed = parseProviderWorkerSessionJsonlLine(line);
+        if (!parsed) {
+            continue;
+        }
+        changed = applyProviderLinearWorkerSessionJsonlRecord(parseState, parsed, env) || changed;
     }
     if (shouldBootstrap) {
         tailState.bootstrapPending = requireTurnContext && parseState.turnId === null;
     }
-    return changed;
+    return { changed, ...observation };
 }
 function normalizeProviderLinearWorkerProofForUpdatedAtComparison(proof) {
     return {
         ...proof,
+        current_turn_started_at: proof.current_turn_started_at ?? null,
+        session_log_thread_id: proof.session_log_thread_id ?? null,
+        session_log_turn_id: proof.session_log_turn_id ?? null,
+        session_log_session_id: proof.session_log_session_id ?? null,
+        resume_source_thread_id: proof.resume_source_thread_id ?? null,
+        current_turn_activity: proof.current_turn_activity ?? null,
+        runtime: proof.runtime ?? null,
+        appserver_supervision: proof.appserver_supervision
+            ? {
+                ...proof.appserver_supervision,
+                updated_at: null
+            }
+            : proof.appserver_supervision ?? null,
+        auth_provenance: proof.auth_provenance ?? null,
+        failure_diagnosis: proof.failure_diagnosis ?? null,
+        worker_host: proof.worker_host ?? null,
+        source_setup: proof.source_setup ?? null,
+        linear_budget: proof.linear_budget ?? null,
+        tracked_issue_error: proof.tracked_issue_error ?? null,
+        resident_session: proof.resident_session ?? null,
         parallelization: proof.parallelization ?? null,
         progress: null,
         updated_at: null
     };
 }
+function stableProviderLinearWorkerProofComparisonString(value) {
+    return JSON.stringify(sortProviderLinearWorkerProofComparisonValue(value));
+}
+function sortProviderLinearWorkerProofComparisonValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((entry) => sortProviderLinearWorkerProofComparisonValue(entry));
+    }
+    if (!isRecord(value)) {
+        return value;
+    }
+    return Object.fromEntries(Object.keys(value)
+        .sort()
+        .map((key) => [key, sortProviderLinearWorkerProofComparisonValue(value[key])]));
+}
 function selectProviderLinearWorkerProofTelemetryFields(proof) {
     return {
         attempt_started_at: proof.attempt_started_at ?? null,
@@ -3189,6 +3420,10 @@ function selectProviderLinearWorkerProofTelemetryFields(proof) {
         latest_turn_id: proof.latest_turn_id ?? null,
         latest_session_id: proof.latest_session_id ?? null,
         latest_session_id_source: proof.latest_session_id_source ?? null,
+        session_log_thread_id: proof.session_log_thread_id ?? null,
+        session_log_turn_id: proof.session_log_turn_id ?? null,
+        session_log_session_id: proof.session_log_session_id ?? null,
+        resume_source_thread_id: proof.resume_source_thread_id ?? null,
         turn_count: proof.turn_count,
         last_event: proof.last_event ?? null,
         last_message: proof.last_message ?? null,
@@ -3220,13 +3455,17 @@ function deriveProviderLinearWorkerParallelizationRecord(input) {
         child_lane_count: selectCurrentTurnChildLanes(input.childLanes, boundary).length
     };
 }
-function buildProviderLinearWorkerTurnBootstrapProof(proof, turnCount, updatedAt) {
+function buildProviderLinearWorkerTurnBootstrapProof(proof, turnCount, updatedAt, resumeSourceThreadId = null) {
     return {
         ...proof,
         current_turn_started_at: updatedAt,
         latest_turn_id: null,
         latest_session_id: null,
         latest_session_id_source: null,
+        session_log_thread_id: null,
+        session_log_turn_id: null,
+        session_log_session_id: null,
+        resume_source_thread_id: resumeSourceThreadId,
         last_event: null,
         last_message: null,
         last_event_at: null,
@@ -3334,8 +3573,60 @@ function shouldAdvanceProviderLinearWorkerProofUpdatedAt(currentProof, nextProof
         return (JSON.stringify(selectProviderLinearWorkerProofTelemetryFields(currentProof)) !==
             JSON.stringify(selectProviderLinearWorkerProofTelemetryFields(nextProof)));
     }
-    return (JSON.stringify(normalizeProviderLinearWorkerProofForUpdatedAtComparison(currentProof)) !==
-        JSON.stringify(normalizeProviderLinearWorkerProofForUpdatedAtComparison(nextProof)));
+    return (stableProviderLinearWorkerProofComparisonString(normalizeProviderLinearWorkerProofForUpdatedAtComparison(currentProof)) !==
+        stableProviderLinearWorkerProofComparisonString(normalizeProviderLinearWorkerProofForUpdatedAtComparison(nextProof)));
+}
+function selectProviderWorkerScopedSessionLogIds(input) {
+    const proofThreadId = input.proof.session_log_thread_id ?? null;
+    const proofTurnId = input.proof.session_log_turn_id ?? null;
+    const proofThreadMatchesLive = proofThreadId !== null &&
+        input.liveThreadId !== null &&
+        proofThreadId === input.liveThreadId;
+    const proofTurnMatchesLive = proofTurnId !== null && input.liveTurnId !== null && proofTurnId === input.liveTurnId;
+    const observedThreadMatchesLive = input.observedThreadId !== null &&
+        input.liveThreadId !== null &&
+        input.observedThreadId === input.liveThreadId;
+    const observedTurnMatchesLive = input.observedTurnId !== null &&
+        input.liveTurnId !== null &&
+        input.observedTurnId === input.liveTurnId;
+    let sessionLogThreadId;
+    let sessionLogTurnId;
+    if (input.sessionLogObserved) {
+        if (observedThreadMatchesLive) {
+            sessionLogThreadId = input.observedThreadId;
+            sessionLogTurnId = observedTurnMatchesLive ? input.observedTurnId : null;
+        }
+        else if (input.observedThreadId === null &&
+            observedTurnMatchesLive &&
+            input.liveThreadId !== null) {
+            sessionLogThreadId = input.liveThreadId;
+            sessionLogTurnId = input.observedTurnId;
+        }
+        else if (proofThreadMatchesLive) {
+            sessionLogThreadId = proofThreadId;
+            sessionLogTurnId = proofTurnMatchesLive ? proofTurnId : null;
+        }
+        else {
+            sessionLogThreadId = null;
+            sessionLogTurnId = null;
+        }
+    }
+    else if (proofThreadMatchesLive) {
+        sessionLogThreadId = proofThreadId;
+        sessionLogTurnId = proofTurnMatchesLive ? proofTurnId : null;
+    }
+    else {
+        sessionLogThreadId = input.proof.session_log_thread_id ?? null;
+        sessionLogTurnId = input.proof.session_log_turn_id ?? null;
+    }
+    return {
+        sessionLogThreadId,
+        sessionLogTurnId,
+        sessionLogSessionId: deriveLatestTurnSessionId({
+            threadId: sessionLogThreadId,
+            turnId: sessionLogTurnId
+        }).sessionId
+    };
 }
 async function hydrateProviderLinearWorkerProofFromSessionLog(proof, env, hydrationState = null) {
     const workspacePath = normalizeOptionalString(proof.workspace_path);
@@ -3395,7 +3686,7 @@ async function hydrateProviderLinearWorkerProofFromSessionLog(proof, env, hydrat
         parseState.currentTurnActivity = proofCurrentTurnActivity;
         parseState.failureDiagnosis = proof.failure_diagnosis ?? null;
     };
-    let tailState = buildProviderWorkerSessionLogTailState(sessionLogPath, hydrationState);
+    let tailState = buildProviderWorkerSessionLogTailState(sessionLogPath, hydrationState, proof.current_turn_started_at ?? null);
     let preserveProofTelemetryFloor = false;
     if (hydrationState && hydrationState.path === sessionLogPath) {
         const proofSignature = buildProviderWorkerSessionLogHydrationProofSignature(proof);
@@ -3409,7 +3700,9 @@ async function hydrateProviderLinearWorkerProofFromSessionLog(proof, env, hydrat
                     path: sessionLogPath,
                     offsetBytes: fileStat.size,
                     trailingText: tailState.trailingText,
-                    bootstrapPending: true
+                    bootstrapPending: true,
+                    currentTurnStartedAt: tailState.currentTurnStartedAt,
+                    idRewindSignature: tailState.idRewindSignature
                 };
             }
             else if (fileStat.size < tailState.offsetBytes) {
@@ -3417,7 +3710,9 @@ async function hydrateProviderLinearWorkerProofFromSessionLog(proof, env, hydrat
                     path: sessionLogPath,
                     offsetBytes: 0,
                     trailingText: '',
-                    bootstrapPending: true
+                    bootstrapPending: true,
+                    currentTurnStartedAt: tailState.currentTurnStartedAt,
+                    idRewindSignature: null
                 };
             }
             else {
@@ -3429,12 +3724,44 @@ async function hydrateProviderLinearWorkerProofFromSessionLog(proof, env, hydrat
             }
         }
     }
+    const idHydrationRewindSignature = buildProviderWorkerSessionLogIdHydrationRewindSignature(proof);
+    if (idHydrationRewindSignature === null) {
+        tailState = {
+            ...tailState,
+            idRewindSignature: null
+        };
+    }
+    else if (tailState.offsetBytes > 0 &&
+        tailState.idRewindSignature !== idHydrationRewindSignature) {
+        tailState = {
+            path: sessionLogPath,
+            offsetBytes: 0,
+            trailingText: '',
+            bootstrapPending: true,
+            currentTurnStartedAt: tailState.currentTurnStartedAt,
+            idRewindSignature: idHydrationRewindSignature
+        };
+    }
+    let sessionLogObserved = false;
+    let observedSessionLogThreadId = proof.session_log_thread_id ?? null;
+    let observedSessionLogTurnId = proof.session_log_turn_id ?? null;
+    const allowCompletedBootstrapTurn = shouldAllowCompletedProviderWorkerSessionBootstrapTurn(proof);
     try {
         const delta = await readProviderWorkerSessionLogDelta(tailState);
         if (delta) {
-            applyProviderWorkerSessionLogDelta(parseState, tailState, delta, env);
+            const deltaApply = applyProviderWorkerSessionLogDelta(parseState, tailState, delta, env, {
+                allowCompletedBootstrapTurn
+            });
+            sessionLogObserved = deltaApply.observed || sessionLogObserved;
+            observedSessionLogThreadId = deltaApply.observedThreadId ?? observedSessionLogThreadId;
+            observedSessionLogTurnId = deltaApply.observedTurnId ?? observedSessionLogTurnId;
         }
-        flushProviderWorkerSessionLogTail(parseState, tailState, env);
+        const tailApply = flushProviderWorkerSessionLogTail(parseState, tailState, env, {
+            allowCompletedBootstrapTurn
+        });
+        sessionLogObserved = tailApply.observed || sessionLogObserved;
+        observedSessionLogThreadId = tailApply.observedThreadId ?? observedSessionLogThreadId;
+        observedSessionLogTurnId = tailApply.observedTurnId ?? observedSessionLogTurnId;
     }
     catch {
         return {
@@ -3471,12 +3798,23 @@ async function hydrateProviderLinearWorkerProofFromSessionLog(proof, env, hydrat
         parseState.rateLimits !== null &&
         providerWorkerTokenUsageFallsBehindFloor(proofTokenFloor, parseState.tokens);
     const persistedTailState = snapshotProviderWorkerSessionLogTailState(tailState);
+    const scopedSessionLogIds = selectProviderWorkerScopedSessionLogIds({
+        sessionLogObserved,
+        observedThreadId: observedSessionLogThreadId,
+        observedTurnId: observedSessionLogTurnId,
+        proof,
+        liveThreadId,
+        liveTurnId
+    });
     const hydratedProof = {
         ...proof,
         thread_id: liveThreadId,
         latest_turn_id: liveTurnId,
         latest_session_id: session.sessionId,
         latest_session_id_source: session.source,
+        session_log_thread_id: scopedSessionLogIds.sessionLogThreadId,
+        session_log_turn_id: scopedSessionLogIds.sessionLogTurnId,
+        session_log_session_id: scopedSessionLogIds.sessionLogSessionId,
         last_event: parseState.lastEvent ?? null,
         last_message: parseState.finalMessage ?? null,
         last_event_at: parseState.lastEventAt ?? null,
@@ -3533,6 +3871,158 @@ export function deriveLatestTurnSessionId(input) {
         source: 'derived_from_thread_and_turn'
     };
 }
+function selectProviderLinearWorkerSessionLogProofForScope(input) {
+    const sessionLogThreadId = input.proof.session_log_thread_id ?? null;
+    const sessionLogTurnId = input.proof.session_log_turn_id ?? null;
+    const sessionLogSessionId = input.proof.session_log_session_id ?? null;
+    if (!input.scopeChanged) {
+        return { sessionLogThreadId, sessionLogTurnId, sessionLogSessionId };
+    }
+    if (sessionLogThreadId &&
+        sessionLogTurnId &&
+        sessionLogSessionId &&
+        sessionLogThreadId === input.threadId &&
+        sessionLogTurnId === input.turnId &&
+        sessionLogSessionId === input.sessionId) {
+        return { sessionLogThreadId, sessionLogTurnId, sessionLogSessionId };
+    }
+    return { sessionLogThreadId: null, sessionLogTurnId: null, sessionLogSessionId: null };
+}
+function buildProviderLinearWorkerRuntimeProof(selection) {
+    return {
+        requested_mode: selection.requested_mode,
+        selected_mode: selection.selected_mode,
+        provider: selection.provider,
+        runtime_session_id: selection.runtime_session_id,
+        fallback: selection.fallback
+    };
+}
+function normalizeProviderLinearWorkerRuntimeProof(proof) {
+    const existing = proof.runtime ?? null;
+    const authProvenance = proof.auth_provenance ?? null;
+    return {
+        requested_mode: existing?.requested_mode ?? authProvenance?.runtime_mode ?? null,
+        selected_mode: existing?.selected_mode ?? authProvenance?.runtime_mode ?? null,
+        provider: existing?.provider ?? authProvenance?.runtime_provider ?? null,
+        runtime_session_id: existing?.runtime_session_id ?? null,
+        fallback: existing?.fallback ?? null
+    };
+}
+function normalizeProviderLinearWorkerRuntimeProofIfRelevant(proof) {
+    const runtime = normalizeProviderLinearWorkerRuntimeProof(proof);
+    if (runtime.requested_mode ||
+        runtime.selected_mode ||
+        runtime.provider ||
+        runtime.runtime_session_id ||
+        runtime.fallback ||
+        proof.auth_provenance?.runtime_mode ||
+        proof.auth_provenance?.runtime_provider) {
+        return runtime;
+    }
+    return null;
+}
+function shouldEmitProviderLinearWorkerAppServerSupervisionProof(proof) {
+    const runtime = normalizeProviderLinearWorkerRuntimeProofIfRelevant(proof);
+    return (runtime?.requested_mode === 'appserver' ||
+        runtime?.selected_mode === 'appserver' ||
+        runtime?.fallback?.from_mode === 'appserver' ||
+        runtime?.fallback?.to_mode === 'appserver' ||
+        proof.auth_provenance?.runtime_mode === 'appserver');
+}
+function buildProviderLinearWorkerAppServerSupervisionProofIfRelevant(proof) {
+    return shouldEmitProviderLinearWorkerAppServerSupervisionProof(proof)
+        ? buildProviderLinearWorkerAppServerSupervisionProof(proof)
+        : null;
+}
+function buildProviderLinearWorkerAppServerSupervisionProof(proof) {
+    const selectedRuntime = normalizeProviderLinearWorkerRuntimeProof(proof);
+    const selectedMode = selectedRuntime.selected_mode ?? proof.auth_provenance?.runtime_mode ?? null;
+    const appserverSelected = selectedMode === 'appserver';
+    const appserverIntended = appserverSelected ||
+        selectedRuntime.requested_mode === 'appserver' ||
+        selectedRuntime.fallback?.from_mode === 'appserver' ||
+        proof.auth_provenance?.runtime_mode === 'appserver';
+    const stickyEnvironmentId = normalizeOptionalString(proof.auth_provenance?.cloud_env_id) ?? null;
+    const sessionLogThreadId = normalizeOptionalString(proof.session_log_thread_id) ?? null;
+    const sessionLogTurnId = normalizeOptionalString(proof.session_log_turn_id) ?? null;
+    const sessionLogSessionId = normalizeOptionalString(proof.session_log_session_id) ?? null;
+    const hasTurnPersistence = Boolean(proof.thread_id &&
+        proof.latest_turn_id &&
+        proof.latest_session_id &&
+        sessionLogThreadId === proof.thread_id &&
+        sessionLogTurnId === proof.latest_turn_id &&
+        sessionLogSessionId === proof.latest_session_id);
+    const residentResumeSourceThreadId = normalizeOptionalString(proof.resident_session?.source_thread_id) ?? null;
+    const recordedResumeSourceThreadId = normalizeOptionalString(proof.resume_source_thread_id) ?? null;
+    const inRunResumeRequested = appserverIntended && proof.turn_count > 1;
+    const supervisionCommand = residentResumeSourceThreadId || recordedResumeSourceThreadId || proof.turn_count > 1
+        ? 'codex_exec_resume'
+        : 'codex_exec';
+    const resumeSourceThreadId = residentResumeSourceThreadId ?? recordedResumeSourceThreadId;
+    const resumeRequested = Boolean(residentResumeSourceThreadId) || inRunResumeRequested;
+    const resumeThreadMatches = resumeRequested &&
+        proof.thread_id !== null &&
+        resumeSourceThreadId !== null &&
+        proof.thread_id === resumeSourceThreadId;
+    const resumeThreadMismatch = Boolean(resumeSourceThreadId) &&
+        proof.thread_id !== null &&
+        proof.thread_id !== resumeSourceThreadId;
+    const resumePersistedTurnObserved = resumeThreadMatches && hasTurnPersistence;
+    return {
+        selected_runtime: selectedRuntime,
+        supervision_command: supervisionCommand,
+        appserver_session_id: appserverSelected ? selectedRuntime.runtime_session_id : null,
+        thread_id: proof.thread_id,
+        latest_turn_id: proof.latest_turn_id,
+        latest_session_id: proof.latest_session_id,
+        session_log_thread_id: sessionLogThreadId,
+        session_log_turn_id: sessionLogTurnId,
+        session_log_session_id: sessionLogSessionId,
+        sticky_environment_id: stickyEnvironmentId,
+        sticky_environment_status: appserverIntended
+            ? stickyEnvironmentId
+                ? 'proven'
+                : 'blocked'
+            : 'not_applicable',
+        sticky_environment_blocker: appserverIntended && !stickyEnvironmentId
+            ? 'configured_environment_id_missing'
+            : null,
+        turn_persistence_status: appserverIntended
+            ? hasTurnPersistence
+                ? 'proven'
+                : 'blocked'
+            : 'not_applicable',
+        turn_persistence_source: appserverIntended && hasTurnPersistence ? 'session_log_hydration' : null,
+        turn_persistence_blocker: appserverIntended && !hasTurnPersistence
+            ? 'session_log_hydration_missing'
+            : null,
+        pagination_status: appserverIntended ? 'blocked' : 'not_applicable',
+        pagination_blocker: appserverIntended ? 'appserver_pagination_probe_not_implemented' : null,
+        resume_status: appserverIntended
+            ? resumeRequested
+                ? resumePersistedTurnObserved
+                    ? 'proven'
+                    : 'blocked'
+                : 'not_requested'
+            : 'not_applicable',
+        resume_source_thread_id: resumeSourceThreadId,
+        resume_observed_thread_id: resumeRequested ? proof.thread_id : null,
+        resume_blocker: appserverIntended && resumeRequested && resumeThreadMismatch
+            ? 'guarded_resume_thread_mismatch'
+            : appserverIntended && resumeRequested && !resumeSourceThreadId
+                ? 'resume_source_thread_id_missing'
+                : appserverIntended && resumeRequested && !proof.thread_id
+                    ? 'resume_thread_id_missing'
+                    : appserverIntended && resumeRequested && !resumePersistedTurnObserved
+                        ? 'resume_session_log_hydration_missing'
+                        : null,
+        fork_status: appserverIntended ? 'blocked' : 'not_applicable',
+        fork_blocker: appserverIntended ? 'appserver_fork_probe_not_implemented' : null,
+        jsonl_truth_retained: true,
+        session_log_truth_retained: appserverSelected,
+        updated_at: proof.updated_at ?? null
+    };
+}
 async function resolveProviderLinearWorkerRuntimeContext(env, repoRoot, runId) {
     const requestedMode = parseRuntimeMode(env.CODEX_ORCHESTRATOR_RUNTIME_MODE_ACTIVE ?? env.CODEX_ORCHESTRATOR_RUNTIME_MODE ?? null);
     return await createRuntimeCodexCommandContext({
@@ -3793,7 +4283,10 @@ async function readProviderLinearWorkerChildLanesWithPresence(runDir) {
         ledgerExists: true
     };
 }
-async function hydrateProviderLinearWorkerChildLanesFromActiveManifests(runDir, childLanes, priorProofChildLanes = null) {
+async function hydrateProviderLinearWorkerChildLanesFromActiveManifests(runDir, childLanes, priorProofChildLanes = null, options = {
+    now: () => new Date().toISOString(),
+    inspectProcess: inspectLocalProviderLinearChildLaneRunnerProcess
+}) {
     if (childLanes.length === 0) {
         return childLanes;
     }
@@ -3801,9 +4294,12 @@ async function hydrateProviderLinearWorkerChildLanesFromActiveManifests(runDir,
     if (!parent) {
         return childLanes;
     }
-    return await Promise.all(childLanes.map(async (childLane) => await hydrateProviderLinearWorkerChildLaneFromActiveManifest(parent, childLane, findMatchingPriorHydratedProviderLinearWorkerChildLane(childLane, priorProofChildLanes))));
+    return await Promise.all(childLanes.map(async (childLane) => await hydrateProviderLinearWorkerChildLaneFromActiveManifest(parent, childLane, findMatchingPriorHydratedProviderLinearWorkerChildLane(childLane, priorProofChildLanes), options)));
 }
-async function readHydratedProviderLinearWorkerChildLanesAndRepairLedger(runDir, priorProofChildLanes = null) {
+async function readHydratedProviderLinearWorkerChildLanesAndRepairLedger(runDir, priorProofChildLanes = null, options = {
+    now: () => new Date().toISOString(),
+    inspectProcess: inspectLocalProviderLinearChildLaneRunnerProcess
+}) {
     return await withProviderLinearWorkerChildLanesLock(runDir, async () => {
         const { records: existing, ledgerExists } = await readProviderLinearWorkerChildLanesWithPresence(runDir);
         if (!ledgerExists && existing.length === 0 && Array.isArray(priorProofChildLanes)) {
@@ -3815,7 +4311,7 @@ async function readHydratedProviderLinearWorkerChildLanesAndRepairLedger(runDir,
             }
             return recovered;
         }
-        const hydrated = await hydrateProviderLinearWorkerChildLanesFromActiveManifests(runDir, existing, priorProofChildLanes);
+        const hydrated = await hydrateProviderLinearWorkerChildLanesFromActiveManifests(runDir, existing, priorProofChildLanes, options);
         const ledgerRecords = hydrated.map((childLane, index) => preserveProviderLinearWorkerLaunchReservationLedgerIdentity(existing[index] ?? null, childLane));
         if (JSON.stringify(existing) !== JSON.stringify(ledgerRecords)) {
             await writeJsonAtomic(buildChildLanesPath(runDir), ledgerRecords);
@@ -3851,6 +4347,9 @@ function preserveProviderLinearWorkerLaunchReservationLedgerIdentity(existing, h
         existing.task_id !== hydrated.task_id) {
         return hydrated;
     }
+    if (hydrated.stale_invalidation_candidate) {
+        return hydrated;
+    }
     return existing;
 }
 async function readProviderLinearWorkerParentManifestHydrationMetadata(runDir) {
@@ -3875,7 +4374,10 @@ async function readProviderLinearWorkerParentManifestHydrationMetadata(runDir) {
         workspacePath: normalizeOptionalString(parsed.workspace_path) ?? normalizeOptionalString(parsed.workspacePath)
     };
 }
-async function hydrateProviderLinearWorkerChildLaneFromActiveManifest(parent, childLane, priorHydratedChildLane = null) {
+async function hydrateProviderLinearWorkerChildLaneFromActiveManifest(parent, childLane, priorHydratedChildLane = null, options = {
+    now: () => new Date().toISOString(),
+    inspectProcess: inspectLocalProviderLinearChildLaneRunnerProcess
+}) {
     if (isProviderLinearWorkerRetiredChildLanePlaceholder(childLane)) {
         return retireProviderLinearWorkerChildLanePlaceholder(childLane);
     }
@@ -3888,8 +4390,8 @@ async function hydrateProviderLinearWorkerChildLaneFromActiveManifest(parent, ch
     }
     const reservationPlaceholder = isProviderLinearWorkerChildLaneReservationPlaceholder(childLane);
     const candidate = reservationPlaceholder
-        ? await findMatchingProviderLinearWorkerChildLaneManifest(parent, childLane, childCliDir)
-        : await readProviderLinearWorkerChildLaneManifestCandidate(parent, childLane, childCliDir, resolveProviderLinearWorkerChildLanePath(childLane.manifest_path, childLane.workspace_path ?? parent.workspacePath) ?? join(childCliDir, childLane.run_id, 'manifest.json'));
+        ? await findMatchingProviderLinearWorkerChildLaneManifest(parent, childLane, childCliDir, options, priorHydratedChildLane)
+        : await readProviderLinearWorkerChildLaneManifestCandidate(parent, childLane, childCliDir, resolveProviderLinearWorkerChildLanePath(childLane.manifest_path, childLane.workspace_path ?? parent.workspacePath) ?? join(childCliDir, childLane.run_id, 'manifest.json'), options, priorHydratedChildLane);
     if (!candidate) {
         return childLane;
     }
@@ -3923,7 +4425,24 @@ async function hydrateProviderLinearWorkerChildLaneFromActiveManifest(parent, ch
         guardrail_command_count: candidate.guardrailCommandCount,
         lane_workspace_path: candidate.laneWorkspacePath ?? childLane.lane_workspace_path,
         patch_artifact_path: candidate.patchArtifactPath ?? childLane.patch_artifact_path,
-        patch_bytes: candidate.patchBytes ?? childLane.patch_bytes
+        patch_bytes: candidate.patchBytes ?? childLane.patch_bytes,
+        runtime_mode: candidate.runtimeMode,
+        runtime_provider: candidate.runtimeProvider,
+        heartbeat_at: candidate.heartbeatAt,
+        heartbeat_stale_after_seconds: candidate.heartbeatStaleAfterSeconds,
+        runner_pid: candidate.runnerPid,
+        runner_started_at: candidate.runnerStartedAt,
+        runner_alive: candidate.runnerAlive,
+        runner_identity_status: candidate.runnerIdentityStatus,
+        runner_identity_reason: candidate.runnerIdentityReason,
+        runner_observed_started_at: candidate.runnerObservedStartedAt,
+        runner_command_line_matches: candidate.runnerCommandLineMatches,
+        runtime_event: candidate.runtimeEvent,
+        runtime_event_at: candidate.runtimeEventAt,
+        appserver_startup_observed: candidate.appserverStartupObserved,
+        appserver_startup_observed_at: candidate.appserverStartupObservedAt,
+        stale_invalidation_candidate: candidate.staleInvalidationCandidate,
+        stale_invalidation_reason: candidate.staleInvalidationReason
     };
 }
 function isProviderLinearWorkerPendingChildLaneRecord(childLane) {
@@ -3938,6 +4457,8 @@ function isProviderLinearWorkerRetiredChildLanePlaceholder(childLane) {
     const summary = normalizeOptionalString(childLane.summary);
     return (childLane.status === 'launching' ||
         isActiveLookingProviderLinearWorkerChildLaneStatus(childLane.status) ||
+        childLane.status === 'stale_invalidation_candidate' ||
+        childLane.stale_invalidation_candidate === true ||
         Boolean(normalizeOptionalString(childLane.in_flight_action)) ||
         Boolean(runId?.startsWith('launching-')) ||
         isActiveLookingProviderLinearWorkerChildLaneSummary(summary));
@@ -4051,7 +4572,7 @@ function resolveProviderLinearWorkerChildLanePath(value, workspacePath) {
     const normalizedWorkspacePath = normalizeOptionalString(workspacePath);
     return normalizedWorkspacePath ? resolve(normalizedWorkspacePath, normalized) : resolve(normalized);
 }
-async function findMatchingProviderLinearWorkerChildLaneManifest(parent, childLane, childCliDir) {
+async function findMatchingProviderLinearWorkerChildLaneManifest(parent, childLane, childCliDir, options, priorHydratedChildLane = null) {
     let entries;
     try {
         entries = await readdir(childCliDir, { withFileTypes: true });
@@ -4061,7 +4582,7 @@ async function findMatchingProviderLinearWorkerChildLaneManifest(parent, childLa
     }
     const candidates = await Promise.all(entries
         .filter((entry) => entry.isDirectory())
-        .map(async (entry) => await readProviderLinearWorkerChildLaneManifestCandidate(parent, childLane, childCliDir, join(childCliDir, entry.name, 'manifest.json'))));
+        .map(async (entry) => await readProviderLinearWorkerChildLaneManifestCandidate(parent, childLane, childCliDir, join(childCliDir, entry.name, 'manifest.json'), options, priorHydratedChildLane)));
     return candidates
         .filter((candidate) => candidate !== null)
         .sort((left, right) => {
@@ -4069,7 +4590,7 @@ async function findMatchingProviderLinearWorkerChildLaneManifest(parent, childLa
         return timestampComparison !== 0 ? timestampComparison : right.runId.localeCompare(left.runId);
     })[0] ?? null;
 }
-async function readProviderLinearWorkerChildLaneManifestCandidate(parent, childLane, childCliDir, manifestPath) {
+async function readProviderLinearWorkerChildLaneManifestCandidate(parent, childLane, childCliDir, manifestPath, options, priorHydratedChildLane = null) {
     let parsed;
     try {
         parsed = JSON.parse(await readFile(manifestPath, 'utf8'));
@@ -4136,33 +4657,485 @@ async function readProviderLinearWorkerChildLaneManifestCandidate(parent, childL
         return null;
     }
     const proofMetadata = await readProviderLinearWorkerChildLaneProofHydrationMetadata(parent, childLane, runId, manifestArtifactRoot, workspacePath);
+    const runtimeDiagnostics = await readProviderLinearWorkerChildLaneRuntimeDiagnostics(parent, childLane, runId, manifestArtifactRoot);
+    const runtimeMode = normalizeOptionalString(runtimeDiagnostics?.provider_linear_child_lane_runtime_selected_mode) ??
+        normalizeOptionalString(runtimeDiagnostics?.runtime_mode) ??
+        normalizeOptionalString(parsed.runtime_mode);
+    const runtimeProvider = normalizeOptionalString(runtimeDiagnostics?.provider_linear_child_lane_runtime_provider) ??
+        normalizeOptionalString(runtimeDiagnostics?.runtime_provider) ??
+        normalizeOptionalString(parsed.runtime_provider);
+    const heartbeatAt = normalizeOptionalString(parsed.heartbeat_at);
+    const heartbeatStaleAfterSeconds = normalizeOptionalInteger(parsed.heartbeat_stale_after_seconds);
+    const rawRunnerPid = normalizeOptionalInteger(runtimeDiagnostics?.provider_linear_child_lane_runner_pid ?? parsed.provider_linear_child_lane_runner_pid);
+    const runnerPid = rawRunnerPid !== null && rawRunnerPid > 0 ? rawRunnerPid : null;
+    const runnerStartedAt = normalizeOptionalString(runtimeDiagnostics?.provider_linear_child_lane_runner_started_at ??
+        parsed.provider_linear_child_lane_runner_started_at);
+    const runnerIdentity = await inspectProviderLinearWorkerChildLaneRunnerIdentity({
+        runnerPid,
+        runnerStartedAt,
+        options
+    });
+    const runnerAlive = runnerIdentity.alive;
+    const runtimeEvent = normalizeOptionalString(runtimeDiagnostics?.provider_linear_child_lane_runtime_event ?? parsed.provider_linear_child_lane_runtime_event);
+    const runtimeEventAt = normalizeOptionalString(runtimeDiagnostics?.provider_linear_child_lane_runtime_event_at ?? parsed.provider_linear_child_lane_runtime_event_at);
+    const appserverStartupObserved = runtimeEvent === 'appserver_startup_observed' ||
+        runtimeDiagnostics?.provider_linear_child_lane_appserver_startup_observed === true ||
+        parsed.provider_linear_child_lane_appserver_startup_observed === true;
+    const appserverStartupObservedAt = normalizeOptionalString(runtimeDiagnostics?.provider_linear_child_lane_appserver_startup_observed_at ??
+        parsed.provider_linear_child_lane_appserver_startup_observed_at ??
+        (runtimeEvent === 'appserver_startup_observed' ? runtimeEventAt : null));
     const successfulStatus = isSuccessfulProviderLinearWorkerChildLaneStatus(status);
+    const patchArtifactPath = proofMetadata?.patchArtifactPath ?? null;
     const patchBytes = proofMetadata?.patchBytes ?? null;
-    const patchReady = Boolean(proofMetadata?.patchArtifactPath && patchBytes !== null && patchBytes > 0);
-    const hydratedStatus = successfulStatus && !patchReady ? 'in_progress' : status;
+    const proofOutputReady = Boolean(patchArtifactPath);
+    const patchReady = Boolean(patchArtifactPath && patchBytes !== null && patchBytes > 0);
+    const diagnosticStatus = successfulStatus && !proofOutputReady ? 'in_progress' : status;
+    const staleDiagnostic = resolveProviderLinearWorkerChildLanePostStartupNoOutputDiagnostic({
+        childLane,
+        status: diagnosticStatus,
+        runtimeMode,
+        heartbeatAt,
+        heartbeatStaleAfterSeconds,
+        runnerPid,
+        runnerStartedAt,
+        runnerAlive,
+        runnerIdentityStatus: runnerIdentity.status,
+        runnerIdentityReason: runnerIdentity.reason,
+        runtimeEvent,
+        runtimeEventAt,
+        appserverStartupObserved,
+        appserverStartupObservedAt,
+        proofOutputReady,
+        now: options.now
+    });
+    const hydratedStatus = staleDiagnostic
+        ? 'stale_invalidation_candidate'
+        : diagnosticStatus;
     const manifestTimestamp = latestProviderLinearWorkerChildLaneManifestTimestamp(parsed);
     const summaryRecordedAt = providerLinearWorkerChildLaneSummaryRecordedAt(parsed, proofMetadata?.updatedAt ?? null, startedAt);
+    const summary = staleDiagnostic?.summary ??
+        (successfulStatus && !patchReady
+            ? patchBytes === 0
+                ? 'Child lane completed without patch output; waiting for parent ledger decision.'
+                : 'Child lane completed; waiting for patch proof metadata.'
+            : stripNonApplicableGuardrailSummaryLines(parsed, normalizeOptionalString(parsed.summary)) ??
+                normalizeOptionalString(parsed.status_detail));
+    const priorStaleSummaryRecordedAt = staleDiagnostic &&
+        priorHydratedChildLane?.stale_invalidation_candidate === true &&
+        priorHydratedChildLane.stale_invalidation_reason === staleDiagnostic.reason
+        ? priorHydratedChildLane.summary_recorded_at
+        : null;
+    const currentStaleSummaryRecordedAt = staleDiagnostic &&
+        childLane.stale_invalidation_candidate === true &&
+        childLane.stale_invalidation_reason === staleDiagnostic.reason
+        ? childLane.summary_recorded_at
+        : null;
+    const staleSummaryRecordedAt = staleDiagnostic
+        ? currentStaleSummaryRecordedAt ?? priorStaleSummaryRecordedAt ?? staleDiagnostic.observedAt
+        : null;
     return {
         runId,
         status: hydratedStatus,
         manifestPath,
         artifactRoot: manifestArtifactRoot,
         logPath,
-        summary: successfulStatus && !patchReady
-            ? patchBytes === 0
-                ? 'Child lane completed without patch output; waiting for parent ledger decision.'
-                : 'Child lane completed; waiting for patch proof metadata.'
-            : stripNonApplicableGuardrailSummaryLines(parsed, normalizeOptionalString(parsed.summary)) ??
-                normalizeOptionalString(parsed.status_detail),
+        summary,
         startedAt,
         updatedAt: manifestTimestamp,
         laneWorkspacePath: proofMetadata?.laneWorkspacePath ?? null,
-        patchArtifactPath: proofMetadata?.patchArtifactPath ?? null,
+        patchArtifactPath,
         patchBytes: proofMetadata?.patchBytes ?? null,
         guardrailsRequired: resolveGuardrailsRequiredForManifest(parsed),
         guardrailsRequiredSource: resolveGuardrailsRequiredSourceForManifest(parsed),
         guardrailCommandCount: countGuardrailCommands(parsed),
-        summaryRecordedAt
+        summaryRecordedAt: staleSummaryRecordedAt ?? summaryRecordedAt,
+        runtimeMode,
+        runtimeProvider,
+        heartbeatAt,
+        heartbeatStaleAfterSeconds,
+        runnerPid,
+        runnerStartedAt,
+        runnerAlive,
+        runnerIdentityStatus: runnerIdentity.status,
+        runnerIdentityReason: runnerIdentity.reason,
+        runnerObservedStartedAt: runnerIdentity.observedStartedAt,
+        runnerCommandLineMatches: runnerIdentity.commandLineMatches,
+        runtimeEvent,
+        runtimeEventAt,
+        appserverStartupObserved,
+        appserverStartupObservedAt,
+        staleInvalidationCandidate: staleDiagnostic ? true : null,
+        staleInvalidationReason: staleDiagnostic?.reason ?? null
+    };
+}
+async function readProviderLinearWorkerChildLaneRuntimeDiagnostics(parent, childLane, runId, artifactRoot) {
+    let parsed;
+    try {
+        parsed = JSON.parse(await readFile(join(artifactRoot, PROVIDER_LINEAR_CHILD_LANE_DIAGNOSTICS_FILENAME), 'utf8'));
+    }
+    catch {
+        return null;
+    }
+    if (!isRecord(parsed)) {
+        return null;
+    }
+    if (normalizeOptionalString(parsed.parent_run_id) !== parent.runId ||
+        normalizeOptionalString(parsed.issue_id) !== childLane.issue_id ||
+        normalizeOptionalString(parsed.issue_identifier) !== childLane.issue_identifier ||
+        normalizeOptionalString(parsed.task_id) !== childLane.task_id ||
+        normalizeOptionalString(parsed.run_id) !== runId) {
+        return null;
+    }
+    if (parent.issueId && normalizeOptionalString(parsed.issue_id) !== parent.issueId) {
+        return null;
+    }
+    if (parent.issueIdentifier && normalizeOptionalString(parsed.issue_identifier) !== parent.issueIdentifier) {
+        return null;
+    }
+    const stream = normalizeOptionalString(parsed.stream);
+    if (stream && stream !== childLane.stream) {
+        return null;
+    }
+    return parsed;
+}
+async function inspectProviderLinearWorkerChildLaneRunnerIdentity(input) {
+    if (input.runnerPid === null) {
+        return {
+            alive: null,
+            status: 'not_recorded',
+            reason: 'runner_pid_not_recorded',
+            observedStartedAt: null,
+            commandLineMatches: null
+        };
+    }
+    const inspection = await readProviderLinearWorkerChildLaneRunnerProcessInspection(input.runnerPid, input.options);
+    return resolveProviderLinearWorkerChildLaneRunnerIdentity({
+        runnerStartedAt: input.runnerStartedAt,
+        inspection
+    });
+}
+async function readProviderLinearWorkerChildLaneRunnerProcessInspection(pid, options) {
+    if (options.inspectProcess) {
+        try {
+            return normalizeProviderLinearWorkerProcessInspection(await options.inspectProcess(pid));
+        }
+        catch (error) {
+            return {
+                alive: null,
+                startedAt: null,
+                commandLine: null,
+                error: providerLinearWorkerErrorMessage(error)
+            };
+        }
+    }
+    if (options.isProcessAlive) {
+        return {
+            alive: options.isProcessAlive(pid),
+            startedAt: null,
+            commandLine: null,
+            error: null
+        };
+    }
+    return await inspectLocalProviderLinearChildLaneRunnerProcess(pid);
+}
+function normalizeProviderLinearWorkerProcessInspection(value) {
+    if (!isRecord(value)) {
+        return {
+            alive: null,
+            startedAt: null,
+            commandLine: null,
+            error: 'process_identity_inspection_invalid'
+        };
+    }
+    return {
+        alive: typeof value.alive === 'boolean' ? value.alive : null,
+        startedAt: normalizeOptionalString(value.startedAt),
+        commandLine: normalizeOptionalString(value.commandLine),
+        error: normalizeOptionalString(value.error)
+    };
+}
+function resolveProviderLinearWorkerChildLaneRunnerIdentity(input) {
+    const commandLineMatches = resolveProviderLinearChildLaneRunnerCommandLineMatch(input.inspection.commandLine);
+    const recordedStartedMs = input.runnerStartedAt ? Date.parse(input.runnerStartedAt) : Number.NaN;
+    const recordedStartIdentityError = !input.runnerStartedAt
+        ? 'runner_started_at_missing'
+        : Number.isFinite(recordedStartedMs)
+            ? null
+            : 'runner_started_at_unparseable';
+    if (input.inspection.alive === false) {
+        if (recordedStartIdentityError) {
+            return {
+                alive: null,
+                status: 'ambiguous',
+                reason: recordedStartIdentityError,
+                observedStartedAt: input.inspection.startedAt,
+                commandLineMatches
+            };
+        }
+        return {
+            alive: false,
+            status: 'not_live',
+            reason: 'runner_pid_not_live',
+            observedStartedAt: input.inspection.startedAt,
+            commandLineMatches
+        };
+    }
+    if (input.inspection.alive !== true) {
+        const lookupFailureReason = input.inspection.error
+            ? `process_identity_lookup_failed:${truncateProviderLinearWorkerDiagnosticReason(input.inspection.error)}`
+            : 'process_identity_lookup_unknown';
+        return {
+            alive: null,
+            status: 'ambiguous',
+            reason: recordedStartIdentityError ?? lookupFailureReason,
+            observedStartedAt: input.inspection.startedAt,
+            commandLineMatches
+        };
+    }
+    if (commandLineMatches !== true) {
+        const reason = commandLineMatches === false
+            ? 'process_command_line_mismatch'
+            : input.inspection.error
+                ? `process_identity_lookup_failed:${truncateProviderLinearWorkerDiagnosticReason(input.inspection.error)}`
+                : 'process_command_line_unavailable';
+        return {
+            alive: null,
+            status: commandLineMatches === false ? 'pid_reuse_suspected' : 'ambiguous',
+            reason,
+            observedStartedAt: input.inspection.startedAt,
+            commandLineMatches
+        };
+    }
+    if (recordedStartIdentityError) {
+        return {
+            alive: null,
+            status: 'ambiguous',
+            reason: recordedStartIdentityError,
+            observedStartedAt: input.inspection.startedAt,
+            commandLineMatches
+        };
+    }
+    if (!input.inspection.startedAt) {
+        return {
+            alive: null,
+            status: 'ambiguous',
+            reason: input.inspection.error
+                ? `process_start_time_unavailable:${truncateProviderLinearWorkerDiagnosticReason(input.inspection.error)}`
+                : 'process_start_time_unavailable',
+            observedStartedAt: null,
+            commandLineMatches
+        };
+    }
+    const observedStartedMs = Date.parse(input.inspection.startedAt);
+    if (!Number.isFinite(observedStartedMs)) {
+        return {
+            alive: null,
+            status: 'ambiguous',
+            reason: 'process_start_time_unparseable',
+            observedStartedAt: input.inspection.startedAt,
+            commandLineMatches
+        };
+    }
+    if (observedStartedMs > recordedStartedMs) {
+        return {
+            alive: null,
+            status: 'pid_reuse_suspected',
+            reason: 'process_started_after_recorded_runner_start',
+            observedStartedAt: input.inspection.startedAt,
+            commandLineMatches
+        };
+    }
+    if (observedStartedMs < recordedStartedMs - PROVIDER_LINEAR_CHILD_LANE_RUNNER_IDENTITY_START_BEFORE_TOLERANCE_MS) {
+        return {
+            alive: null,
+            status: 'pid_reuse_suspected',
+            reason: 'process_start_time_mismatch',
+            observedStartedAt: input.inspection.startedAt,
+            commandLineMatches
+        };
+    }
+    return {
+        alive: true,
+        status: 'matched',
+        reason: 'process_identity_matched',
+        observedStartedAt: input.inspection.startedAt,
+        commandLineMatches
+    };
+}
+async function inspectLocalProviderLinearChildLaneRunnerProcess(pid) {
+    if (!isLocalProcessAlive(pid)) {
+        return {
+            alive: false,
+            startedAt: null,
+            commandLine: null,
+            error: null
+        };
+    }
+    const [startedAtResult, commandLineResult] = await Promise.all([
+        readLocalProcessPsOutput(pid, 'lstart='),
+        readLocalProcessCommandLine(pid)
+    ]);
+    if (startedAtResult.output === null && commandLineResult.output === null && !isLocalProcessAlive(pid)) {
+        return {
+            alive: false,
+            startedAt: null,
+            commandLine: null,
+            error: 'process_exited_before_identity_lookup'
+        };
+    }
+    const startedAt = startedAtResult.output ? parseLocalProcessStartedAt(startedAtResult.output) : null;
+    const startError = startedAtResult.output && !startedAt
+        ? `process_start_time_unparseable:${startedAtResult.output}`
+        : startedAtResult.error;
+    const error = [startError, commandLineResult.error]
+        .map((value) => normalizeOptionalString(value))
+        .filter((value) => Boolean(value))
+        .join('; ');
+    return {
+        alive: true,
+        startedAt,
+        commandLine: commandLineResult.output,
+        error: error || null
+    };
+}
+async function readLocalProcessCommandLine(pid) {
+    const commandResult = await readLocalProcessPsOutput(pid, 'command=');
+    if (commandResult.output !== null) {
+        return commandResult;
+    }
+    const argsResult = await readLocalProcessPsOutput(pid, 'args=');
+    if (argsResult.output !== null) {
+        return argsResult;
+    }
+    return {
+        output: null,
+        error: [commandResult.error, argsResult.error]
+            .map((value) => normalizeOptionalString(value))
+            .filter((value) => Boolean(value))
+            .join('; ') || null
+    };
+}
+async function readLocalProcessPsOutput(pid, outputColumn) {
+    return await new Promise((resolvePromise) => {
+        let stdout = '';
+        let stderr = '';
+        let completed = false;
+        let timedOut = false;
+        let timer = null;
+        const child = spawn('ps', ['-ww', '-p', String(pid), '-o', outputColumn], {
+            stdio: ['ignore', 'pipe', 'pipe']
+        });
+        const finish = (result) => {
+            if (completed) {
+                return;
+            }
+            completed = true;
+            if (timer) {
+                clearTimeout(timer);
+            }
+            resolvePromise(result);
+        };
+        timer = setTimeout(() => {
+            timedOut = true;
+            child.kill('SIGKILL');
+        }, PROVIDER_LINEAR_CHILD_LANE_RUNNER_PROCESS_LOOKUP_TIMEOUT_MS);
+        child.stdout?.on('data', (chunk) => {
+            stdout += String(chunk);
+        });
+        child.stderr?.on('data', (chunk) => {
+            stderr += String(chunk);
+        });
+        child.on('error', (error) => {
+            finish({
+                output: null,
+                error: providerLinearWorkerErrorMessage(error)
+            });
+        });
+        child.on('close', (code) => {
+            if (timedOut) {
+                finish({
+                    output: null,
+                    error: 'process_identity_lookup_timeout'
+                });
+                return;
+            }
+            const output = normalizeOptionalString(stdout);
+            if (code === 0 && output) {
+                finish({
+                    output,
+                    error: null
+                });
+                return;
+            }
+            finish({
+                output: null,
+                error: normalizeOptionalString(stderr) ?? `ps exited with code ${code ?? 'unknown'}`
+            });
+        });
+    });
+}
+function parseLocalProcessStartedAt(value) {
+    const normalized = normalizeOptionalString(value);
+    if (!normalized) {
+        return null;
+    }
+    const parsed = Date.parse(normalized);
+    return Number.isFinite(parsed) ? new Date(parsed).toISOString() : null;
+}
+function resolveProviderLinearChildLaneRunnerCommandLineMatch(commandLine) {
+    const normalized = normalizeOptionalString(commandLine);
+    if (!normalized) {
+        return null;
+    }
+    return normalized.includes('providerLinearChildLaneRunner');
+}
+function truncateProviderLinearWorkerDiagnosticReason(value) {
+    const normalized = normalizeOptionalString(value);
+    if (!normalized) {
+        return 'unknown';
+    }
+    return normalized.length > 160 ? `${normalized.slice(0, 157)}...` : normalized;
+}
+function providerLinearWorkerErrorMessage(error) {
+    return normalizeOptionalString(error?.message) ?? String(error);
+}
+function resolveProviderLinearWorkerChildLanePostStartupNoOutputDiagnostic(input) {
+    if (!isActiveLookingProviderLinearWorkerChildLaneStatus(input.status) ||
+        input.runtimeMode !== 'appserver' ||
+        input.appserverStartupObserved !== true ||
+        input.proofOutputReady) {
+        return null;
+    }
+    const heartbeatMs = input.heartbeatAt ? Date.parse(input.heartbeatAt) : Number.NaN;
+    const now = input.now();
+    const nowMs = Date.parse(now);
+    if (!Number.isFinite(heartbeatMs) || !Number.isFinite(nowMs)) {
+        return null;
+    }
+    const staleAfterMs = Math.max(PROVIDER_LINEAR_CHILD_LANE_POST_STARTUP_NO_OUTPUT_MIN_STALE_MS, (input.heartbeatStaleAfterSeconds ?? 0) * 1000);
+    if (nowMs - heartbeatMs <= staleAfterMs) {
+        return null;
+    }
+    if (input.runnerAlive !== false || input.runnerIdentityStatus !== 'not_live') {
+        return null;
+    }
+    const stream = input.childLane.stream || input.childLane.task_id || input.childLane.run_id;
+    const runnerState = input.runnerPid !== null
+        ? `providerLinearChildLaneRunner pid ${input.runnerPid} is not live` +
+            (input.runnerStartedAt ? ` for recorded start ${input.runnerStartedAt}` : '')
+        : 'providerLinearChildLaneRunner pid was not recorded';
+    const identityState = input.runnerIdentityReason
+        ? ` Runner identity proof: ${input.runnerIdentityReason}.`
+        : '';
+    const startupAt = input.appserverStartupObservedAt ?? input.runtimeEventAt ?? 'unknown time';
+    const reason = 'post_startup_no_output_heartbeat_stale_runner_dead';
+    return {
+        observedAt: now,
+        reason,
+        summary: `Child lane ${stream} is a stale invalidation candidate: appserver startup was observed at ${startupAt}, ` +
+            `manifest heartbeat stopped at ${input.heartbeatAt}, ${runnerState}, and no proof/patch output is present. ` +
+            identityState +
+            'Invalidate the lane and rerun parent-owned validation, or relaunch under CLI for scoped diagnosis.'
     };
 }
 async function readProviderLinearWorkerChildLaneProofHydrationMetadata(parent, childLane, runId, artifactRoot, workspacePath) {
@@ -4226,7 +5199,8 @@ function latestProviderLinearWorkerIsoTimestamp(...values) {
     return normalized[normalized.length - 1] ?? null;
 }
 function buildProviderLinearWorkerHydratedChildLaneSummary(childLane, candidate) {
-    if (candidate.summary?.startsWith('Child lane completed')) {
+    if (candidate.summary &&
+        (candidate.status === 'stale_invalidation_candidate' || candidate.summary.startsWith('Child lane completed'))) {
         return candidate.summary;
     }
     const label = childLane.stream || childLane.task_id || candidate.runId;
@@ -4454,6 +5428,25 @@ function normalizeProviderLinearWorkerChildLaneRecord(value) {
         lane_workspace_path: normalizeOptionalString(value.lane_workspace_path),
         patch_artifact_path: normalizeOptionalString(value.patch_artifact_path),
         patch_bytes: normalizeOptionalInteger(value.patch_bytes),
+        runtime_mode: normalizeOptionalString(value.runtime_mode),
+        runtime_provider: normalizeOptionalString(value.runtime_provider),
+        heartbeat_at: normalizeOptionalString(value.heartbeat_at),
+        heartbeat_stale_after_seconds: normalizeOptionalInteger(value.heartbeat_stale_after_seconds),
+        runner_pid: normalizeOptionalInteger(value.runner_pid),
+        runner_started_at: normalizeOptionalString(value.runner_started_at),
+        runner_alive: typeof value.runner_alive === 'boolean' ? value.runner_alive : null,
+        runner_identity_status: normalizeProviderLinearWorkerChildLaneRunnerIdentityStatus(value.runner_identity_status),
+        runner_identity_reason: normalizeOptionalString(value.runner_identity_reason),
+        runner_observed_started_at: normalizeOptionalString(value.runner_observed_started_at),
+        runner_command_line_matches: typeof value.runner_command_line_matches === 'boolean' ? value.runner_command_line_matches : null,
+        runtime_event: normalizeOptionalString(value.runtime_event),
+        runtime_event_at: normalizeOptionalString(value.runtime_event_at),
+        appserver_startup_observed: typeof value.appserver_startup_observed === 'boolean' ? value.appserver_startup_observed : null,
+        appserver_startup_observed_at: normalizeOptionalString(value.appserver_startup_observed_at),
+        stale_invalidation_candidate: typeof value.stale_invalidation_candidate === 'boolean'
+            ? value.stale_invalidation_candidate
+            : null,
+        stale_invalidation_reason: normalizeOptionalString(value.stale_invalidation_reason),
         decision,
         in_flight_action: inFlightAction,
         in_flight_started_at: normalizeOptionalString(value.in_flight_started_at),
@@ -4503,6 +5496,24 @@ function normalizeChildLaneInFlightAction(value) {
         ? value
         : null;
 }
+function normalizeProviderLinearWorkerChildLaneRunnerIdentityStatus(value) {
+    return value === 'not_recorded' ||
+        value === 'not_live' ||
+        value === 'matched' ||
+        value === 'ambiguous' ||
+        value === 'pid_reuse_suspected'
+        ? value
+        : null;
+}
+function isLocalProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error?.code === 'EPERM';
+    }
+}
 async function resolveProviderWorkerRunLocation(currentManifestPath) {
     try {
         const canonicalManifestPath = await realpath(currentManifestPath);
@@ -4926,6 +5937,7 @@ async function writeProofSnapshot(deps, runDir, auditPath, proof, env = process.
         const childLanes = await readHydratedProviderLinearWorkerChildLanesAndRepairLedger(runDir, proof.child_lanes);
         const proofWithHydratedSources = {
             ...proof,
+            runtime: normalizeProviderLinearWorkerRuntimeProofIfRelevant(proof),
             linear_audit: linearAudit,
             child_streams: childStreams,
             child_lanes: childLanes,
@@ -4940,6 +5952,7 @@ async function writeProofSnapshot(deps, runDir, auditPath, proof, env = process.
         };
         const hydratedProof = {
             ...proofWithHydratedSources,
+            appserver_supervision: buildProviderLinearWorkerAppServerSupervisionProofIfRelevant(proofWithHydratedSources),
             progress: deriveProviderLinearWorkerProgressSnapshot({
                 proof: proofWithHydratedSources,
                 now: deps.now
@@ -4967,9 +5980,14 @@ export async function refreshProviderLinearWorkerProofSnapshot(runDir, auditPath
         const linearBudget = await readSharedLinearBudgetStatus(env).catch(() => null);
         const linearAudit = auditPath ? await summarizeProviderLinearAuditPath(auditPath) : parsed.linear_audit ?? null;
         const childStreams = await readProviderLinearWorkerChildStreams(runDir);
-        const childLanes = await readHydratedProviderLinearWorkerChildLanesAndRepairLedger(runDir, parsed.child_lanes);
+        const childLanes = await readHydratedProviderLinearWorkerChildLanesAndRepairLedger(runDir, parsed.child_lanes, {
+            now,
+            isProcessAlive: options.isProcessAlive,
+            inspectProcess: options.inspectProcess
+        });
         const proofWithHydratedSources = {
             ...parsed,
+            runtime: normalizeProviderLinearWorkerRuntimeProofIfRelevant(parsed),
             linear_audit: linearAudit,
             child_streams: childStreams,
             child_lanes: childLanes,
@@ -4992,16 +6010,22 @@ export async function refreshProviderLinearWorkerProofSnapshot(runDir, auditPath
         const proofWithSessionTelemetry = proofWithSessionTelemetryResult.proof;
         const hydratedWithoutUpdatedAt = {
             ...proofWithSessionTelemetry,
+            appserver_supervision: buildProviderLinearWorkerAppServerSupervisionProofIfRelevant(proofWithSessionTelemetry),
             progress: deriveProviderLinearWorkerProgressSnapshot({
                 proof: proofWithSessionTelemetry,
                 now
             })
         };
-        const hydrated = {
+        const nextUpdatedAt = shouldAdvanceProviderLinearWorkerProofUpdatedAt(parsed, hydratedWithoutUpdatedAt, options.updatedAtComparisonScope ?? 'full')
+            ? now()
+            : parsed.updated_at ?? null;
+        const hydratedBase = {
             ...hydratedWithoutUpdatedAt,
-            updated_at: shouldAdvanceProviderLinearWorkerProofUpdatedAt(parsed, hydratedWithoutUpdatedAt, options.updatedAtComparisonScope ?? 'full')
-                ? now()
-                : parsed.updated_at ?? null
+            updated_at: nextUpdatedAt
+        };
+        const hydrated = {
+            ...hydratedBase,
+            appserver_supervision: buildProviderLinearWorkerAppServerSupervisionProofIfRelevant(hydratedBase)
         };
         await writeProof(proofPath, hydrated);
         await writeProviderWorkerSessionLogHydrationState(runDir, proofWithSessionTelemetryResult.hydrationState);
@@ -5088,6 +6112,10 @@ export async function runProviderLinearWorker(env = process.env, dependencyOverr
         latest_turn_id: null,
         latest_session_id: null,
         latest_session_id_source: null,
+        session_log_thread_id: null,
+        session_log_turn_id: null,
+        session_log_session_id: null,
+        resume_source_thread_id: residentSessionSeed?.source_thread_id ?? null,
         turn_count: 0,
         last_event: null,
         last_message: null,
@@ -5095,6 +6123,8 @@ export async function runProviderLinearWorker(env = process.env, dependencyOverr
         current_turn_activity: null,
         tokens: buildEmptyProviderLinearWorkerTokenUsage(),
         rate_limits: null,
+        runtime: buildProviderLinearWorkerRuntimeProof(runtimeContext.runtime),
+        appserver_supervision: null,
         auth_provenance: buildProviderWorkerRuntimeAuthProvenance({
             env: childEnv,
             runtime: runtimeContext.runtime,
@@ -5236,6 +6266,9 @@ export async function runProviderLinearWorker(env = process.env, dependencyOverr
             let liveStdoutBuffer = '';
             let liveProofSignature = null;
             const liveParseState = buildEmptyProviderLinearWorkerJsonlParseResult();
+            let liveSessionLogThreadId = null;
+            let liveSessionLogTurnId = null;
+            let liveSessionLogSessionId = null;
             const scheduleTrailingLiveRefresh = () => {
                 if (liveRefreshClosed || !liveRefreshPending || liveRefreshRequest !== null || liveRefreshTimer !== null) {
                     return;
@@ -5349,6 +6382,10 @@ export async function runProviderLinearWorker(env = process.env, dependencyOverr
                     latest_turn_id: liveTurnId,
                     latest_session_id: session.sessionId,
                     latest_session_id_source: session.source,
+                    session_log_thread_id: liveSessionLogThreadId ?? (liveScopeChanged ? null : finalProof.session_log_thread_id ?? null),
+                    session_log_turn_id: liveSessionLogTurnId ?? (liveScopeChanged ? null : finalProof.session_log_turn_id ?? null),
+                    session_log_session_id: liveSessionLogSessionId ?? (liveScopeChanged ? null : finalProof.session_log_session_id ?? null),
+                    resume_source_thread_id: finalProof.resume_source_thread_id ?? null,
                     turn_count: turnNumber,
                     last_event: liveParseState.lastEvent ?? (liveScopeChanged ? null : finalProof.last_event),
                     last_message: liveParseState.finalMessage ?? (liveScopeChanged ? null : finalProof.last_message),
@@ -5373,6 +6410,10 @@ export async function runProviderLinearWorker(env = process.env, dependencyOverr
                     latest_turn_id: nextProof.latest_turn_id,
                     latest_session_id: nextProof.latest_session_id,
                     latest_session_id_source: nextProof.latest_session_id_source,
+                    session_log_thread_id: nextProof.session_log_thread_id ?? null,
+                    session_log_turn_id: nextProof.session_log_turn_id ?? null,
+                    session_log_session_id: nextProof.session_log_session_id ?? null,
+                    resume_source_thread_id: nextProof.resume_source_thread_id ?? null,
                     turn_count: nextProof.turn_count,
                     last_event: nextProof.last_event,
                     last_message: nextProof.last_message,
@@ -5434,6 +6475,11 @@ export async function runProviderLinearWorker(env = process.env, dependencyOverr
             })) ??
                 deriveSharedRepoCheckoutPathFallback(context.repoRoot, context.taskId);
             const continueResidentSessionOnBoot = turnNumber === 1 && residentSessionSeed !== null;
+            const resumeSourceThreadIdForTurn = continueResidentSessionOnBoot
+                ? residentSessionSeed?.source_thread_id ?? null
+                : turnNumber > 1
+                    ? threadId ?? finalProof.thread_id ?? null
+                    : null;
             const prompt = buildProviderWorkerPrompt(issue, turnNumber, context.maxTurns, helperCommand, sharedRepoCheckoutPath, {
                 linearAudit: finalProof.linear_audit,
                 attemptStartedAt: finalProof.attempt_started_at ?? null,
@@ -5442,10 +6488,10 @@ export async function runProviderLinearWorker(env = process.env, dependencyOverr
                 continueResidentSessionOnBoot
             });
             const args = continueResidentSessionOnBoot
-                ? ['exec', 'resume', '--json', residentSessionSeed?.source_thread_id ?? '', prompt]
+                ? ['exec', 'resume', '--json', resumeSourceThreadIdForTurn ?? '', prompt]
                 : turnNumber === 1
                     ? ['exec', '--json', prompt]
-                    : ['exec', 'resume', '--json', threadId ?? '', prompt];
+                    : ['exec', 'resume', '--json', resumeSourceThreadIdForTurn ?? '', prompt];
             const resolved = resolveRuntimeCodexCommand(args, runtimeContext);
             let stopLiveSessionTailResolve = null;
             let liveSessionTailStopped = false;
@@ -5461,7 +6507,7 @@ export async function runProviderLinearWorker(env = process.env, dependencyOverr
             };
             const previousTurnProof = finalProof;
             const turnStartedAt = deps.now();
-            finalProof = await writeProofSnapshot(deps, context.runDir, auditPath, buildProviderLinearWorkerTurnBootstrapProof(finalProof, turnNumber, turnStartedAt), childEnv);
+            finalProof = await writeProofSnapshot(deps, context.runDir, auditPath, buildProviderLinearWorkerTurnBootstrapProof(finalProof, turnNumber, turnStartedAt, resumeSourceThreadIdForTurn), childEnv);
             const parallelizationDecisionCountBeforeTurn = readProviderLinearParallelizationSnapshots(finalProof.linear_audit, {
                 issueId: finalProof.issue_id
             }).length;
@@ -5471,9 +6517,14 @@ export async function runProviderLinearWorker(env = process.env, dependencyOverr
                     path: null,
                     offsetBytes: 0,
                     trailingText: '',
-                    bootstrapPending: true
+                    bootstrapPending: true,
+                    currentTurnStartedAt: turnStartedAt,
+                    idRewindSignature: null
                 }
                 : null;
+            const allowCompletedSessionBootstrapTurn = turnNumber === 1 &&
+                previousTurnProof.latest_turn_id === null &&
+                !continueResidentSessionOnBoot;
             const liveSessionTailPromise = liveSessionTailState === null
                 ? Promise.resolve()
                 : (async () => {
@@ -5499,7 +6550,22 @@ export async function runProviderLinearWorker(env = process.env, dependencyOverr
                         }
                         if (liveSessionTailState.path !== null) {
                             const delta = await readProviderWorkerSessionLogDelta(liveSessionTailState);
-                            if (delta && applyProviderWorkerSessionLogDelta(liveParseState, liveSessionTailState, delta, childEnv)) {
+                            const deltaApply = delta
+                                ? applyProviderWorkerSessionLogDelta(liveParseState, liveSessionTailState, delta, childEnv, { allowCompletedBootstrapTurn: allowCompletedSessionBootstrapTurn })
+                                : {
+                                    changed: false,
+                                    observed: false,
+                                    observedThreadId: null,
+                                    observedTurnId: null
+                                };
+                            if (deltaApply.observed) {
+                                liveSessionLogThreadId =
+                                    deltaApply.observedThreadId ?? liveSessionLogThreadId;
+                                liveSessionLogTurnId = deltaApply.observedTurnId ?? liveSessionLogTurnId;
+                                liveSessionLogSessionId = deriveLatestTurnSessionId({
+                                    threadId: liveSessionLogThreadId,
+                                    turnId: liveSessionLogTurnId
+                                }).sessionId;
                                 queueLiveProofWrite();
                             }
                         }
@@ -5511,7 +6577,21 @@ export async function runProviderLinearWorker(env = process.env, dependencyOverr
                             stopLiveSessionTailPromise
                         ]);
                     }
-                    if (liveSessionTailState.path !== null && flushProviderWorkerSessionLogTail(liveParseState, liveSessionTailState, childEnv)) {
+                    const tailApply = liveSessionTailState.path !== null
+                        ? flushProviderWorkerSessionLogTail(liveParseState, liveSessionTailState, childEnv, { allowCompletedBootstrapTurn: allowCompletedSessionBootstrapTurn })
+                        : {
+                            changed: false,
+                            observed: false,
+                            observedThreadId: null,
+                            observedTurnId: null
+                        };
+                    if (tailApply.observed) {
+                        liveSessionLogThreadId = tailApply.observedThreadId ?? liveSessionLogThreadId;
+                        liveSessionLogTurnId = tailApply.observedTurnId ?? liveSessionLogTurnId;
+                        liveSessionLogSessionId = deriveLatestTurnSessionId({
+                            threadId: liveSessionLogThreadId,
+                            turnId: liveSessionLogTurnId
+                        }).sessionId;
                         queueLiveProofWrite();
                     }
                 })().catch((error) => {
@@ -5541,6 +6621,9 @@ export async function runProviderLinearWorker(env = process.env, dependencyOverr
                         latest_turn_id: previousTurnProof.latest_turn_id,
                         latest_session_id: previousTurnProof.latest_session_id,
                         latest_session_id_source: previousTurnProof.latest_session_id_source,
+                        session_log_thread_id: previousTurnProof.session_log_thread_id,
+                        session_log_turn_id: previousTurnProof.session_log_turn_id,
+                        session_log_session_id: previousTurnProof.session_log_session_id,
                         last_event: previousTurnProof.last_event,
                         last_message: previousTurnProof.last_message,
                         last_event_at: previousTurnProof.last_event_at,
@@ -5600,6 +6683,13 @@ export async function runProviderLinearWorker(env = process.env, dependencyOverr
             const parsedTurnChanged = Boolean(turnId && turnId !== finalProof.latest_turn_id);
             const parsedScopeChanged = parsedThreadChanged || parsedTurnChanged;
             const session = deriveLatestTurnSessionId({ threadId, turnId });
+            const sessionLogProof = selectProviderLinearWorkerSessionLogProofForScope({
+                proof: finalProof,
+                threadId,
+                turnId,
+                sessionId: session.sessionId,
+                scopeChanged: parsedScopeChanged
+            });
             finalProof = {
                 issue_id: context.issueId,
                 issue_identifier: context.issueIdentifier,
@@ -5610,6 +6700,10 @@ export async function runProviderLinearWorker(env = process.env, dependencyOverr
                 latest_turn_id: turnId,
                 latest_session_id: session.sessionId,
                 latest_session_id_source: session.source,
+                session_log_thread_id: sessionLogProof.sessionLogThreadId,
+                session_log_turn_id: sessionLogProof.sessionLogTurnId,
+                session_log_session_id: sessionLogProof.sessionLogSessionId,
+                resume_source_thread_id: finalProof.resume_source_thread_id ?? null,
                 turn_count: turnNumber,
                 last_event: parsed.lastEvent ?? (parsedScopeChanged ? null : finalProof.last_event),
                 last_message: parsed.finalMessage ?? (parsedScopeChanged ? null : finalProof.last_message),
@@ -5617,6 +6711,8 @@ export async function runProviderLinearWorker(env = process.env, dependencyOverr
                 current_turn_activity: synchronizeProviderLinearWorkerCurrentTurnActivity(parsed.currentTurnActivity, threadId, turnId) ?? (parsedScopeChanged ? null : selectProviderLinearWorkerCurrentTurnActivity(finalProof)),
                 tokens: hasProviderWorkerTokenUsage(parsed.tokens) ? parsed.tokens : finalProof.tokens,
                 rate_limits: parsed.rateLimits ?? finalProof.rate_limits,
+                runtime: finalProof.runtime ?? buildProviderLinearWorkerRuntimeProof(runtimeContext.runtime),
+                appserver_supervision: finalProof.appserver_supervision ?? null,
                 auth_provenance: mergeProviderWorkerAuthProvenance(finalProof.auth_provenance ?? null, parsed.authProvenance),
                 failure_diagnosis: parsed.failureDiagnosis ??
                     stderrFailureDiagnosis ??