@agent-finops/core 0.8.0 → 0.9.0

package/dist/localAgentLogs.js

@@ -1,11 +1,13 @@
-import { createReadStream } from "node:fs";
+import { constants, createReadStream } from "node:fs";
 import { lstat, open, readdir, readFile, stat } from "node:fs/promises";
 import { basename, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { homedir } from "node:os";
 import { createInterface } from "node:readline";
+import { createHash } from "node:crypto";
 import { canPriceTokenUsageAtScope, estimateTokenCostUsd, estimateTokenCostsUsd, promptTierThreshold, usesPromptTieredPricing } from "./modelPricing.js";
 import { redactSecrets } from "./discovery.js";
-import { localAgentFormatDescriptors, localAgentFormatLabel, matchesLocalAgentDetectionFile, matchesLocalAgentFormatFile, validateLocalAgentFormatDescriptors } from "./localAgentFormats/registry.js";
+import { createCodexInvocationCollector, isCodexInvocationCollectorSnapshot } from "./toolInvocations.js";
+import { localAgentFormatDescriptor, localAgentFormatDescriptors, localAgentFormatLabel, matchesLocalAgentDetectionFile, matchesLocalAgentFormatFile, validateLocalAgentFormatDescriptors } from "./localAgentFormats/registry.js";
 import { parseGeminiSession } from "./localAgentFormats/gemini.js";
 /**
  * Resolve the repository root most recently observed in transcript metadata.
@@ -20,6 +22,56 @@ export function latestObservedWorkingDirectory(calls) {
         .sort((left, right) => right.timestamp.localeCompare(left.timestamp))[0]
         ?.workingDirectory;
 }
+export const localAgentFinancialParserVersion = 1;
+/**
+ * Qualitative parser contract version. Bumped to 2 with the checkpointed
+ * streaming path (A4b): entries and checkpoints written by the pre-streaming
+ * parser are never reinterpreted — a version mismatch is a miss (entries) or
+ * a discard (checkpoints), and the store schema pins this exact literal so
+ * both sides fail closed together. Bumped to 4 when Claude Code subagent
+ * transcripts gained their own session identity (`subagentId`) and
+ * cross-file completion evidence (`subagentCompletions`, from both Task tool
+ * results and background task-notifications): entries persisted by the
+ * collapsing parser must re-parse rather than silently keep merging subagent
+ * runs into their parent session.
+ */
+export const localAgentQualitativeParserVersion = 4;
+/**
+ * Conservative launch defaults for action-capable qualitative evidence.
+ * Callers must still inspect `qualitativeCoverage` before deriving a finding:
+ * the limits protect responsiveness; they do not turn a partial scan into a
+ * representative sample.
+ */
+export const SAFE_QUALITATIVE_SCAN_POLICY = Object.freeze({
+    maxFileBytes: 64 * 1024 * 1024,
+    maxSourceBytes: 256 * 1024 * 1024
+});
+/**
+ * True only when every requested source was scanned under an explicit bounded
+ * policy without omitting an eligible file. Legacy unbounded results return
+ * false so an action caller cannot accidentally treat unknown coverage as a
+ * complete launch-safe scan.
+ */
+export function hasCompleteQualitativeCoverage(result, agents = ["claude-code", "codex"]) {
+    return agents.every((agent) => (result.sourceScans.find((scan) => scan.agent === agent)?.qualitativeCoverage === "complete"));
+}
+/**
+ * Whether a bounded result contains exact calls from at least one completely
+ * parsed selected file for every requested source. This is deliberately
+ * weaker than global coverage: it can support a clearly scoped experiment,
+ * never a claim about the source's overall/main driver.
+ */
+export function hasExactSelectedQualitativeEvidence(result, agents) {
+    const requested = agents ?? [...new Set(result.calls
+            .filter((call) => localAgentFormatDescriptor(call.agent)?.capabilities.actionPlanning)
+            .map((call) => call.agent))];
+    return requested.length > 0 && requested.every((agent) => {
+        const scan = result.sourceScans.find((entry) => entry.agent === agent);
+        return scan?.qualitativeSelectedEvidence === "complete_files_only" &&
+            (scan.qualitativeFilesReadCompletely ?? 0) > 0 &&
+            result.calls.some((call) => call.agent === agent);
+    });
+}
 /**
  * Codex rollout/compaction files can repeat the same session's cumulative
  * token counter. Keep only the latest snapshot per session so financial value,
@@ -80,7 +132,7 @@ function stableTurnEvidenceFingerprint(call) {
         timestamp: call.timestamp,
         model: call.model,
         project: call.project ?? null,
-        workingDirectory: call.workingDirectory ?? null,
+        workingDirectoryRef: stableWorkingDirectoryRef(call),
         usageSupport: call.usageSupport ?? null,
         reportedTotalTokens: call.reportedTotalTokens ?? null,
         usage: {
@@ -95,6 +147,27 @@ function stableTurnEvidenceFingerprint(call) {
         geminiTokenEvidence: call.geminiTokenEvidence ?? null
     });
 }
+function stableWorkingDirectoryRef(call) {
+    const supplied = call.workingDirectoryRef;
+    const derived = call.workingDirectory
+        ? derivedWorkingDirectoryRef(call.workingDirectory)
+        : undefined;
+    if (supplied && derived && supplied !== derived)
+        return "conflicting-working-directory";
+    return supplied ?? derived ?? null;
+}
+/**
+ * The one NUL-separated avref derivation for working directories. Every
+ * consumer — stable call refs, the financial probe re-attach, and header-pass
+ * attribution — must produce byte-identical refs for the same directory.
+ */
+function derivedWorkingDirectoryRef(workingDirectory) {
+    return `avref_${createHash("sha256")
+        .update("project-working-directory")
+        .update("\u0000")
+        .update(workingDirectory)
+        .digest("hex")}`;
+}
 function isStableTurnConflict(call) {
     return call.model === "conflicting-local-evidence" &&
         call.usageSupport === "unsupported_token_shape";
@@ -160,9 +233,37 @@ function parseClaudeFinancialUsage(value, onDiagnostic) {
         cacheWrite1hTokens: write1hField.value ?? 0
     };
     if (componentsSupported) {
+        const cacheWriteEvidence = writeTotalField.value !== undefined ||
+            (write5mField.value !== undefined && write1hField.value !== undefined)
+            ? "observed"
+            : write5mField.value !== undefined || write1hField.value !== undefined
+                ? "partial"
+                : "not_separately_reported";
+        const cacheReadEvidence = cacheReadField.value === undefined
+            ? "not_separately_reported"
+            : "observed";
+        const componentTotalComplete = cacheReadEvidence === "observed" &&
+            cacheWriteEvidence === "observed";
         return {
             usage,
-            latestTurnUsage: toTurnUsage(usage, "assistant_message_usage")
+            latestTurnUsage: toTurnUsage(usage, "assistant_message_usage"),
+            ...(reportedTotalField.value !== undefined
+                ? { reportedTotalTokens: reportedTotalField.value }
+                : {}),
+            tokenComponentEvidence: {
+                inputTokens: "observed",
+                outputTokens: "observed",
+                cacheReadTokens: cacheReadEvidence,
+                cacheWriteTokens: cacheWriteEvidence,
+                thoughtTokens: "not_separately_reported",
+                toolTokens: "not_separately_reported",
+                calculatedTotalTokens: componentTotalComplete
+                    ? "calculated_complete"
+                    : "calculated_partial",
+                reportedTotalTokens: reportedTotalField.value === undefined
+                    ? "not_reported"
+                    : "provider_reported"
+            }
         };
     }
     onDiagnostic?.({ code: "unsupported_token_shape", count: 1 });
@@ -232,7 +333,28 @@ function parseCodexCumulativeUsage(current, baseline) {
             cacheReadTokens: cached
         },
         supported: currentSupported && baselineSupported && monotonic,
-        ...(reportedTotalTokens !== undefined ? { reportedTotalTokens } : {})
+        ...(reportedTotalTokens !== undefined ? { reportedTotalTokens } : {}),
+        ...(currentSupported && baselineSupported && monotonic
+            ? {
+                tokenComponentEvidence: {
+                    inputTokens: "observed",
+                    outputTokens: "observed",
+                    cacheReadTokens: currentCachedField.value === undefined
+                        ? "not_separately_reported"
+                        : "observed",
+                    cacheWriteTokens: "not_separately_reported",
+                    thoughtTokens: "not_separately_reported",
+                    toolTokens: "not_separately_reported",
+                    // Codex input_tokens already contains cached input; subtracting
+                    // the optional cache split and adding it back preserves the full
+                    // observed input+output total even when the split is unavailable.
+                    calculatedTotalTokens: "calculated_complete",
+                    reportedTotalTokens: reportedTotalTokens === undefined
+                        ? "not_reported"
+                        : "provider_reported"
+                }
+            }
+            : {})
     };
 }
 function parseCodexTurnUsage(value) {
@@ -272,8 +394,18 @@ export function parseClaudeCodeTranscript(content, filePath = "", sinceMs, onDia
     let lastPrompt;
     let latestActivityKey;
     let isSubagent = filePath.split(sep).includes("subagents");
+    // Claude Code writes the parent's sessionId on every subagent line, so the
+    // line-level `agentId` (mirrored in the `subagents/agent-<id>.jsonl` file
+    // name) is the only truthful per-run identity for a subagent transcript.
+    const fileSubagentId = subagentTranscriptFileId(filePath);
+    const observedEntryAgentIds = new Set();
+    const subagentCompletionsBySession = new Map();
     let parentSessionId;
     let malformedLines = 0;
+    let entryOrdinal = 0;
+    let latestUnscopedWorkOrdinal = -1;
+    const latestWorkOrdinalBySession = new Map();
+    const completionBySession = new Map();
     for (const line of content.split("\n")) {
         if (!line.trim())
             continue;
@@ -287,6 +419,27 @@ export function parseClaudeCodeTranscript(content, filePath = "", sinceMs, onDia
         }
         if (!isRecord(entry))
             continue;
+        entryOrdinal += 1;
+        const entrySessionId = stringOf(entry.sessionId);
+        if (entry.type === "user" || entry.type === "assistant") {
+            if (entrySessionId)
+                latestWorkOrdinalBySession.set(entrySessionId, entryOrdinal);
+            else
+                latestUnscopedWorkOrdinal = entryOrdinal;
+        }
+        const durationMs = numberOf(entry.durationMs);
+        if (entry.type === "system" && entry.subtype === "turn_duration" &&
+            entrySessionId && Number.isSafeInteger(durationMs) && durationMs >= 0) {
+            const observedAt = toIso(stringOf(entry.timestamp));
+            if (observedAt) {
+                completionBySession.set(entrySessionId, {
+                    status: "completed",
+                    evidence: "claude_turn_duration",
+                    observedAt,
+                    ordinal: entryOrdinal
+                });
+            }
+        }
         if (entry.type === "ai-title") {
             title = stringOf(entry.aiTitle) ?? title;
         }
@@ -295,7 +448,43 @@ export function parseClaudeCodeTranscript(content, filePath = "", sinceMs, onDia
         }
         if (entry.isSidechain === true)
             isSubagent = true;
+        const entryAgentId = stringOf(entry.agentId);
+        if (entryAgentId) {
+            // Line-level agentId only appears on sidechain lines; it is subagent
+            // evidence even when the sidechain flag or path marker is missing.
+            isSubagent = true;
+            observedEntryAgentIds.add(entryAgentId);
+        }
         parentSessionId = stringOf(entry.parentSessionId) ?? parentSessionId;
+        // The host records each finished subagent run in the owning transcript:
+        // synchronous runs as a Task tool result, background runs as a
+        // task-notification queue operation. Subagent files carry no completion
+        // marker of their own, so these are the explicit completion evidence for
+        // those runs. Only an explicit "completed" status counts; failed, killed,
+        // or merely launched runs never read as comparable completed tasks.
+        if (entrySessionId) {
+            const toolUseResult = isRecord(entry.toolUseResult) ? entry.toolUseResult : undefined;
+            let completedSubagentId = toolUseResult && toolUseResult.status === "completed"
+                ? stringOf(toolUseResult.agentId)
+                : undefined;
+            if (!completedSubagentId && entry.type === "queue-operation") {
+                const notification = parseTaskNotification(stringOf(entry.content));
+                if (notification?.status === "completed")
+                    completedSubagentId = notification.taskId;
+            }
+            const completionObservedAt = completedSubagentId
+                ? toIso(stringOf(entry.timestamp))
+                : undefined;
+            if (completedSubagentId && completionObservedAt) {
+                const bySubagent = subagentCompletionsBySession.get(entrySessionId) ??
+                    new Map();
+                const prior = bySubagent.get(completedSubagentId);
+                if (!prior || Date.parse(completionObservedAt) > Date.parse(prior)) {
+                    bySubagent.set(completedSubagentId, completionObservedAt);
+                }
+                subagentCompletionsBySession.set(entrySessionId, bySubagent);
+            }
+        }
         const message = isRecord(entry.message) ? entry.message : undefined;
         if (entry.type === "user" && message) {
             for (const prompt of textValues(message.content)) {
@@ -312,10 +501,11 @@ export function parseClaudeCodeTranscript(content, filePath = "", sinceMs, onDia
         if (stringOf(message.model) === "<synthetic>")
             continue;
         // Streaming/retries can write the same API response on multiple lines.
-        const dedupeKey = `${stringOf(message.id) ?? ""}:${stringOf(entry.requestId) ?? ""}`;
-        if (dedupeKey !== ":" && seen.has(dedupeKey))
+        const nativeResponse = claudeNativeResponseIdentity(message, entry);
+        if (nativeResponse && seen.has(nativeResponse.localDedupeKey))
             continue;
-        seen.add(dedupeKey);
+        if (nativeResponse)
+            seen.add(nativeResponse.localDedupeKey);
         const timestamp = toIso(stringOf(entry.timestamp)) ?? new Date(0).toISOString();
         if (typeof sinceMs === "number" && Date.parse(timestamp) < sinceMs) {
             // These prompts led to a call outside the selected evidence window. Do
@@ -329,11 +519,14 @@ export function parseClaudeCodeTranscript(content, filePath = "", sinceMs, onDia
         const sessionId = stringOf(entry.sessionId);
         const call = {
             agent: "claude-code",
+            ...(nativeResponse ? { callId: nativeResponse.callId } : {}),
             model: stringOf(message.model) ?? "claude-code",
             timestamp,
             project,
             workingDirectory,
             sessionId,
+            ...(entryAgentId ? { subagentId: entryAgentId } : {}),
+            ...(stringOf(entry.version) ? { sourceVersion: stringOf(entry.version) } : {}),
             ...(parsedUsage.latestTurnUsage
                 ? { latestTurnUsage: parsedUsage.latestTurnUsage }
                 : {}),
@@ -342,6 +535,9 @@ export function parseClaudeCodeTranscript(content, filePath = "", sinceMs, onDia
             ...(parsedUsage.reportedTotalTokens !== undefined
                 ? { reportedTotalTokens: parsedUsage.reportedTotalTokens }
                 : {}),
+            ...(parsedUsage.tokenComponentEvidence
+                ? { tokenComponentEvidence: parsedUsage.tokenComponentEvidence }
+                : {}),
             usage: parsedUsage.usage
         };
         calls.push(call);
@@ -362,6 +558,31 @@ export function parseClaudeCodeTranscript(content, filePath = "", sinceMs, onDia
         activityEvidence.set(activityKey, evidence);
         latestActivityKey = activityKey;
     }
+    // One subagent transcript is one run: calls whose lines omitted agentId
+    // still belong to the file's single run identity (content agentId when one
+    // was observed, else the `subagents/` file name). Never invented for
+    // parent transcripts.
+    const defaultSubagentId = observedEntryAgentIds.size === 1
+        ? [...observedEntryAgentIds][0]
+        : fileSubagentId;
+    if (isSubagent && defaultSubagentId) {
+        for (const call of calls)
+            call.subagentId ??= defaultSubagentId;
+    }
+    for (const [completionSessionId, bySubagent] of subagentCompletionsBySession) {
+        let target;
+        for (let index = calls.length - 1; index >= 0; index -= 1) {
+            if (calls[index].sessionId === completionSessionId) {
+                target = calls[index];
+                break;
+            }
+        }
+        if (!target)
+            continue;
+        target.subagentCompletions = [...bySubagent.entries()]
+            .sort((left, right) => left[0].localeCompare(right[0]))
+            .map(([subagentId, observedAt]) => ({ subagentId, observedAt }));
+    }
     const fallbackPrompt = lastPrompt && isHumanPrompt(lastPrompt) ? lastPrompt : undefined;
     const activities = new Map();
     for (const [activityKey, evidence] of activityEvidence) {
@@ -385,141 +606,179 @@ export function parseClaudeCodeTranscript(content, filePath = "", sinceMs, onDia
     }
     for (const call of calls) {
         call.activity = activities.get(localActivityScopeKey(call.sessionId, call.workingDirectory, call.project));
+        const completion = call.sessionId
+            ? completionBySession.get(call.sessionId)
+            : undefined;
+        const latestWorkOrdinal = call.sessionId
+            ? latestWorkOrdinalBySession.get(call.sessionId) ?? -1
+            : -1;
+        if (completion && completion.ordinal >= latestWorkOrdinal &&
+            completion.ordinal >= latestUnscopedWorkOrdinal &&
+            Date.parse(completion.observedAt) >= Date.parse(call.timestamp)) {
+            const { ordinal: _ordinal, ...evidence } = completion;
+            call.completion = evidence;
+        }
     }
     if (malformedLines > 0) {
         onDiagnostic?.({ code: "malformed_jsonl", count: malformedLines });
     }
     return calls;
 }
-/** Parse one Codex rollout file (JSONL event stream). Exported for tests. */
-export function parseCodexRollout(content, onEntry, onDiagnostic) {
-    let model;
-    let rootCwd;
-    const toolWorkdirs = new Map();
-    let sessionId;
-    let rootSessionMetaSeen = false;
-    let startedAt;
-    let rootStartedAtMs;
-    let rootTaskStarted = false;
-    let inheritedUsageBaseline;
-    let lastActivityAt;
-    let lastTotal;
-    let lastTurn;
-    let lastRateLimits;
-    const prompts = [];
-    const fileCounts = new Map();
-    let toolCallCount = 0;
-    let isSubagent = false;
-    let parentSessionId;
-    let malformedLines = 0;
-    for (const line of content.split("\n")) {
-        if (!line.trim())
-            continue;
-        let entry;
-        try {
-            entry = JSON.parse(line);
+function createCodexRolloutParserState() {
+    return {
+        toolWorkdirs: new Map(),
+        rootSessionMetaSeen: false,
+        rootTaskStarted: false,
+        prompts: [],
+        restoredPromptOverflow: 0,
+        fileCounts: new Map(),
+        toolCallCount: 0,
+        isSubagent: false,
+        malformedLines: 0
+    };
+}
+/** One line of the shared Codex rollout reducer (blank/malformed included). */
+function consumeCodexRolloutLine(state, line, onEntry) {
+    if (!line.trim())
+        return;
+    let entry;
+    try {
+        entry = JSON.parse(line);
+    }
+    catch {
+        state.malformedLines += 1;
+        return;
+    }
+    if (!isRecord(entry))
+        return;
+    onEntry?.(entry);
+    const payload = isRecord(entry.payload) ? entry.payload : undefined;
+    if (entry.type === "session_meta" && payload && !state.rootSessionMetaSeen) {
+        // A forked/subagent rollout can embed the parent transcript, including
+        // many later session_meta records. The first metadata record belongs to
+        // this rollout file; later records are nested/history evidence and must
+        // never replace the financial session identity or root cwd.
+        state.rootSessionMetaSeen = true;
+        state.sessionId = stringOf(payload.id);
+        state.sourceVersion = stringOf(payload.cli_version);
+        state.rootCwd = stringOf(payload.cwd);
+        state.startedAt = toIso(stringOf(payload.timestamp) ?? stringOf(entry.timestamp));
+        state.rootStartedAtMs = timestampMilliseconds(payload.timestamp ?? entry.timestamp);
+        state.isSubagent = stringOf(payload.thread_source) === "subagent" ||
+            isRecord(payload.source) && "subagent" in payload.source;
+        state.parentSessionId = stringOf(payload.parent_thread_id);
+    }
+    if (entry.type === "turn_context" && payload) {
+        state.model = stringOf(payload.model) ?? state.model;
+        // The restored checkpoint already carries the session cwd decision when
+        // one was observed; the turn_context fallback applies only when neither
+        // a raw nor a restored session cwd exists (same ??= semantics).
+        if (state.rootCwd === undefined && !state.restoredRootCwd?.present) {
+            state.rootCwd = stringOf(payload.cwd);
         }
-        catch {
-            malformedLines += 1;
-            continue;
+    }
+    if (state.isSubagent &&
+        !state.rootTaskStarted &&
+        payload?.type === "task_started" &&
+        isRootSpecificTaskStart(payload.started_at, state.rootStartedAtMs)) {
+        // Forked Codex rollouts copy the parent's complete event history after
+        // the child's root session_meta. The cumulative counter immediately
+        // before the child's first task is the inherited baseline, not child
+        // usage. Reset qualitative evidence at the same boundary so parent
+        // prompts/files cannot become the child's focus. Restored checkpoint
+        // evidence predating the boundary is parent history too and resets with
+        // it (the raw session cwd deliberately survives, exactly as rootCwd).
+        state.inheritedUsageBaseline = state.lastTotal;
+        state.lastTotal = undefined;
+        state.rootTaskStarted = true;
+        state.prompts.length = 0;
+        state.restoredPromptOverflow = 0;
+        state.fileCounts.clear();
+        state.toolWorkdirs.clear();
+        state.restoredWorkdirs = undefined;
+        state.toolCallCount = 0;
+        state.model = undefined;
+        state.lastTurn = undefined;
+        state.lastRateLimits = undefined;
+        state.lastActivityAt = toIso(stringOf(entry.timestamp)) ?? state.startedAt;
+    }
+    if (payload?.type === "task_started" && (!state.isSubagent || state.rootTaskStarted)) {
+        state.pendingTaskTurnId = stringOf(payload.turn_id);
+        state.completedTask = undefined;
+    }
+    if (entry.type === "event_msg" && payload?.type === "task_complete") {
+        const completedTurnId = stringOf(payload.turn_id);
+        const observedAt = toIso(stringOf(entry.timestamp));
+        if (state.pendingTaskTurnId && completedTurnId === state.pendingTaskTurnId && observedAt) {
+            state.completedTask = {
+                status: "completed",
+                evidence: "codex_task_complete",
+                observedAt
+            };
+            state.pendingTaskTurnId = undefined;
         }
-        if (!isRecord(entry))
-            continue;
-        onEntry?.(entry);
-        const payload = isRecord(entry.payload) ? entry.payload : undefined;
-        if (entry.type === "session_meta" && payload && !rootSessionMetaSeen) {
-            // A forked/subagent rollout can embed the parent transcript, including
-            // many later session_meta records. The first metadata record belongs to
-            // this rollout file; later records are nested/history evidence and must
-            // never replace the financial session identity or root cwd.
-            rootSessionMetaSeen = true;
-            sessionId = stringOf(payload.id);
-            rootCwd = stringOf(payload.cwd);
-            startedAt = toIso(stringOf(payload.timestamp) ?? stringOf(entry.timestamp));
-            rootStartedAtMs = timestampMilliseconds(payload.timestamp ?? entry.timestamp);
-            isSubagent = stringOf(payload.thread_source) === "subagent" || isRecord(payload.source) && "subagent" in payload.source;
-            parentSessionId = stringOf(payload.parent_thread_id);
-        }
-        if (entry.type === "turn_context" && payload) {
-            model = stringOf(payload.model) ?? model;
-            rootCwd ??= stringOf(payload.cwd);
-        }
-        if (isSubagent &&
-            !rootTaskStarted &&
-            payload?.type === "task_started" &&
-            isRootSpecificTaskStart(payload.started_at, rootStartedAtMs)) {
-            // Forked Codex rollouts copy the parent's complete event history after
-            // the child's root session_meta. The cumulative counter immediately
-            // before the child's first task is the inherited baseline, not child
-            // usage. Reset qualitative evidence at the same boundary so parent
-            // prompts/files cannot become the child's focus.
-            inheritedUsageBaseline = lastTotal;
-            lastTotal = undefined;
-            rootTaskStarted = true;
-            prompts.length = 0;
-            fileCounts.clear();
-            toolWorkdirs.clear();
-            toolCallCount = 0;
-            model = undefined;
-            lastTurn = undefined;
-            lastRateLimits = undefined;
-            lastActivityAt = toIso(stringOf(entry.timestamp)) ?? startedAt;
-        }
-        if (payload?.type === "function_call" || payload?.type === "custom_tool_call") {
-            toolCallCount += 1;
-            const args = jsonRecord(stringOf(payload.arguments));
-            const workdir = stringOf(args?.workdir) ?? stringOf(args?.cwd);
-            if (workdir && isAbsolute(workdir)) {
-                const normalized = resolve(workdir);
-                toolWorkdirs.set(normalized, (toolWorkdirs.get(normalized) ?? 0) + 1);
-            }
-            // Current Codex Desktop records the orchestration wrapper as a custom
-            // `exec` call whose input is JavaScript containing nested tool calls.
-            // Extract only quoted absolute workdir/cwd values; never evaluate it.
-            if (payload.type === "custom_tool_call" && stringOf(payload.name) === "exec") {
-                collectEmbeddedToolWorkdirs(stringOf(payload.input), toolWorkdirs);
-            }
-            collectToolFiles(args, fileCounts);
-            collectPatchFiles(stringOf(args?.patch) ?? stringOf(args?.input) ?? stringOf(payload.input), fileCounts);
+        else {
+            state.completedTask = undefined;
+            state.pendingTaskTurnId = undefined;
         }
-        if (payload?.type === "message" && payload.role === "user") {
-            for (const prompt of textValues(payload.content)) {
-                if (isHumanPrompt(prompt))
-                    prompts.push(prompt);
-            }
+    }
+    if (payload?.type === "function_call" || payload?.type === "custom_tool_call") {
+        state.toolCallCount += 1;
+        const args = jsonRecord(stringOf(payload.arguments));
+        const workdir = stringOf(args?.workdir) ?? stringOf(args?.cwd);
+        if (workdir && isAbsolute(workdir)) {
+            const normalized = resolve(workdir);
+            state.toolWorkdirs.set(normalized, (state.toolWorkdirs.get(normalized) ?? 0) + 1);
         }
-        if (entry.type === "event_msg" && payload?.type === "token_count") {
-            const eventTimestamp = toIso(stringOf(entry.timestamp)) ?? lastActivityAt ?? startedAt;
-            const info = isRecord(payload.info) ? payload.info : undefined;
-            const total = info && isRecord(info.total_token_usage) ? info.total_token_usage : undefined;
-            const turn = info && isRecord(info.last_token_usage) ? info.last_token_usage : undefined;
-            if (total) {
-                lastTotal = total;
-                lastActivityAt = eventTimestamp;
-            }
-            if (turn) {
-                lastTurn = turn;
-                lastActivityAt = eventTimestamp;
-            }
-            const rateLimits = parseCodexRateLimits(payload.rate_limits, eventTimestamp);
-            if (rateLimits) {
-                lastRateLimits = rateLimits;
-            }
+        // Current Codex Desktop records the orchestration wrapper as a custom
+        // `exec` call whose input is JavaScript containing nested tool calls.
+        // Extract only quoted absolute workdir/cwd values; never evaluate it.
+        if (payload.type === "custom_tool_call" && stringOf(payload.name) === "exec") {
+            collectEmbeddedToolWorkdirs(stringOf(payload.input), state.toolWorkdirs);
         }
+        collectToolFiles(args, state.fileCounts);
+        collectPatchFiles(stringOf(args?.patch) ?? stringOf(args?.input) ?? stringOf(payload.input), state.fileCounts);
     }
+    if (payload?.type === "message" && payload.role === "user") {
+        for (const prompt of textValues(payload.content)) {
+            if (isHumanPrompt(prompt))
+                state.prompts.push(prompt);
+        }
+    }
+    if (entry.type === "event_msg" && payload?.type === "token_count") {
+        const eventTimestamp = toIso(stringOf(entry.timestamp)) ?? state.lastActivityAt ?? state.startedAt;
+        const info = isRecord(payload.info) ? payload.info : undefined;
+        const total = info && isRecord(info.total_token_usage) ? info.total_token_usage : undefined;
+        const turn = info && isRecord(info.last_token_usage) ? info.last_token_usage : undefined;
+        if (total) {
+            state.lastTotal = total;
+            state.lastActivityAt = eventTimestamp;
+        }
+        if (turn) {
+            state.lastTurn = turn;
+            state.lastActivityAt = eventTimestamp;
+        }
+        const rateLimits = parseCodexRateLimits(payload.rate_limits, eventTimestamp);
+        if (rateLimits) {
+            state.lastRateLimits = rateLimits;
+        }
+    }
+}
+/** Terminal step of the shared Codex rollout reducer. */
+function finishCodexRolloutParse(state, onDiagnostic) {
     // A fork without a recognized root-task boundary is ambiguous: older Codex
     // formats may contain only inherited parent history. Omitting that child is
     // safer than charging the parent cumulative counter again. Likewise, a
     // recognized boundary with no later total_token_usage is not a financial
     // call yet.
-    if (malformedLines > 0) {
-        onDiagnostic?.({ code: "malformed_jsonl", count: malformedLines });
+    if (state.malformedLines > 0) {
+        onDiagnostic?.({ code: "malformed_jsonl", count: state.malformedLines });
     }
-    if (!lastTotal || isSubagent && !rootTaskStarted)
+    if (!state.lastTotal || state.isSubagent && !state.rootTaskStarted)
         return [];
-    const parsedUsage = parseCodexCumulativeUsage(lastTotal, inheritedUsageBaseline);
-    const parsedTurn = lastTurn
-        ? parseCodexTurnUsage(lastTurn)
+    const parsedUsage = parseCodexCumulativeUsage(state.lastTotal, state.inheritedUsageBaseline);
+    const parsedTurn = state.lastTurn
+        ? parseCodexTurnUsage(state.lastTurn)
         : { supported: true };
     const usageSupport = parsedUsage.supported && parsedTurn.supported
         ? "complete"
@@ -527,25 +786,48 @@ export function parseCodexRollout(content, onEntry, onDiagnostic) {
     if (usageSupport === "unsupported_token_shape") {
         onDiagnostic?.({ code: "unsupported_token_shape", count: 1 });
     }
-    const workingDirectory = absoluteWorkingDirectory(dominantCodexCwd(rootCwd, toolWorkdirs));
-    const project = projectFromCwd(workingDirectory);
+    const hasRestoredEvidence = state.restoredRootCwd !== undefined ||
+        (state.restoredWorkdirs !== undefined && state.restoredWorkdirs.length > 0);
+    let workingDirectory;
+    let workingDirectoryRef;
+    let project;
+    if (!hasRestoredEvidence) {
+        workingDirectory = absoluteWorkingDirectory(dominantCodexCwd(state.rootCwd, state.toolWorkdirs));
+        project = projectFromCwd(workingDirectory);
+    }
+    else {
+        const dominant = resolveStreamedDominantCwd(state);
+        workingDirectory = dominant.workingDirectory;
+        workingDirectoryRef = dominant.workingDirectoryRef;
+        project = dominant.project;
+    }
     const activity = buildLocalAgentActivity({
-        prompts,
-        files: fileCounts,
-        toolCallCount,
+        prompts: state.prompts,
+        files: state.fileCounts,
+        toolCallCount: state.toolCallCount,
         project,
-        isSubagent,
-        parentSessionId
+        isSubagent: state.isSubagent,
+        parentSessionId: state.parentSessionId,
+        ...(state.restoredPromptOverflow > 0
+            ? { priorPromptCount: state.restoredPromptOverflow }
+            : {})
     });
     return [{
             agent: "codex",
-            model: model ?? "codex",
-            timestamp: lastActivityAt ?? startedAt ?? new Date(0).toISOString(),
-            startedAt,
+            model: state.model ?? "codex",
+            timestamp: state.lastActivityAt ?? state.startedAt ?? new Date(0).toISOString(),
+            startedAt: state.startedAt,
             project,
             workingDirectory,
-            sessionId,
-            rateLimits: lastRateLimits,
+            ...(workingDirectoryRef ? { workingDirectoryRef } : {}),
+            sessionId: state.sessionId,
+            ...(state.sourceVersion ? { sourceVersion: state.sourceVersion } : {}),
+            ...(state.completedTask && !state.pendingTaskTurnId &&
+                Date.parse(state.completedTask.observedAt) >=
+                    Date.parse(state.lastActivityAt ?? state.startedAt ?? "")
+                ? { completion: state.completedTask }
+                : {}),
+            rateLimits: state.lastRateLimits,
             activity,
             ...(usageSupport === "complete" && parsedTurn.usage
                 ? { latestTurnUsage: parsedTurn.usage }
@@ -555,9 +837,140 @@ export function parseCodexRollout(content, onEntry, onDiagnostic) {
             ...(parsedUsage.reportedTotalTokens !== undefined
                 ? { reportedTotalTokens: parsedUsage.reportedTotalTokens }
                 : {}),
+            ...(usageSupport === "complete" && parsedUsage.tokenComponentEvidence
+                ? { tokenComponentEvidence: parsedUsage.tokenComponentEvidence }
+                : {}),
             usage: parsedUsage.usage
         }];
 }
+/**
+ * `dominantCodexCwd` over evidence that partially crossed a checkpoint
+ * boundary as hashes. Scores and depths reproduce the raw computation
+ * exactly (ancestor refs encode the descendant relation over resolved
+ * paths); only the terminal tie-break degrades from full-path localeCompare
+ * to basename-then-ref order when a restored entry is involved — the
+ * documented QA 27/28 divergence. A winner restored from hashes yields a
+ * ref-only working directory, matching warm cache-hit call shape.
+ */
+function resolveStreamedDominantCwd(state) {
+    if (state.rootCwd !== undefined) {
+        const sessionProject = projectFromCwd(state.rootCwd);
+        if (sessionProject && sessionProject !== "(home)") {
+            const workingDirectory = absoluteWorkingDirectory(state.rootCwd);
+            return { workingDirectory, project: projectFromCwd(workingDirectory) };
+        }
+    }
+    else if (state.restoredRootCwd?.present && state.restoredRootCwd.shortCircuits) {
+        return {
+            ...(state.restoredRootCwd.resolvedRef
+                ? { workingDirectoryRef: state.restoredRootCwd.resolvedRef }
+                : {}),
+            ...(state.restoredRootCwd.resolvedProject
+                ? { project: state.restoredRootCwd.resolvedProject }
+                : {})
+        };
+    }
+    const merged = mergeCodexWorkdirTallies(state);
+    if (merged.length === 0) {
+        if (state.rootCwd !== undefined) {
+            const workingDirectory = absoluteWorkingDirectory(state.rootCwd);
+            return { workingDirectory, project: projectFromCwd(workingDirectory) };
+        }
+        if (state.restoredRootCwd?.present) {
+            return {
+                ...(state.restoredRootCwd.resolvedRef
+                    ? { workingDirectoryRef: state.restoredRootCwd.resolvedRef }
+                    : {}),
+                ...(state.restoredRootCwd.resolvedProject
+                    ? { project: state.restoredRootCwd.resolvedProject }
+                    : {})
+            };
+        }
+        return {};
+    }
+    const scored = merged.map((candidate) => ({
+        candidate,
+        score: merged.reduce((total, entry) => (entry.ref === candidate.ref || entry.ancestorRefs.includes(candidate.ref)
+            ? total + entry.count
+            : total), 0)
+    }));
+    scored.sort((left, right) => (right.score - left.score ||
+        left.candidate.depth - right.candidate.depth ||
+        (left.candidate.rawPath !== undefined && right.candidate.rawPath !== undefined
+            ? left.candidate.rawPath.localeCompare(right.candidate.rawPath)
+            : left.candidate.base.localeCompare(right.candidate.base) ||
+                left.candidate.ref.localeCompare(right.candidate.ref))));
+    const winner = scored[0].candidate;
+    if (winner.rawPath !== undefined) {
+        return { workingDirectory: winner.rawPath, project: projectFromCwd(winner.rawPath) };
+    }
+    return {
+        workingDirectoryRef: winner.ref,
+        ...(winner.base.length > 0 ? { project: winner.base } : {})
+    };
+}
+/** Merge restored hashed workdir tallies with this slice's raw observations. */
+function mergeCodexWorkdirTallies(state) {
+    const home = resolve(homedir());
+    const byRef = new Map();
+    for (const restored of state.restoredWorkdirs ?? []) {
+        if (restored.isHome)
+            continue;
+        const existing = byRef.get(restored.ref);
+        if (existing)
+            existing.count += restored.count;
+        else
+            byRef.set(restored.ref, { ...restored, ancestorRefs: [...restored.ancestorRefs] });
+    }
+    for (const [rawPath, count] of state.toolWorkdirs) {
+        if (resolve(rawPath) === home)
+            continue;
+        const tally = hashedWorkdirTally(rawPath, count, home);
+        const existing = byRef.get(tally.ref);
+        if (existing) {
+            existing.count += count;
+            existing.rawPath = rawPath;
+        }
+        else {
+            byRef.set(tally.ref, { ...tally, rawPath });
+        }
+    }
+    return [...byRef.values()];
+}
+/** Hashed tally row for one observed (already resolved) tool workdir. */
+function hashedWorkdirTally(path, count, home) {
+    return {
+        ref: derivedWorkingDirectoryRef(path),
+        ancestorRefs: properAncestorPaths(path).map(derivedWorkingDirectoryRef),
+        depth: path.split(sep).length,
+        base: basename(path),
+        isHome: resolve(path) === home,
+        count
+    };
+}
+/**
+ * Proper ancestors of a normalized absolute path, excluding the filesystem
+ * root: `dominantCodexCwd`'s descendant test (`startsWith(candidate + sep)`)
+ * never matches the bare root, so the root must not appear as an ancestor.
+ */
+function properAncestorPaths(path) {
+    const ancestors = [];
+    const segments = path.split(sep).filter(Boolean);
+    let current = "";
+    for (let index = 0; index < segments.length - 1; index += 1) {
+        current += `${sep}${segments[index]}`;
+        ancestors.push(current);
+    }
+    return ancestors;
+}
+/** Parse one Codex rollout file (JSONL event stream). Exported for tests. */
+export function parseCodexRollout(content, onEntry, onDiagnostic) {
+    const state = createCodexRolloutParserState();
+    for (const line of content.split("\n")) {
+        consumeCodexRolloutLine(state, line, onEntry);
+    }
+    return finishCodexRolloutParse(state, onDiagnostic);
+}
 function collectEmbeddedToolWorkdirs(input, toolWorkdirs) {
     if (!input)
         return;
@@ -626,6 +1039,18 @@ function parseCodexRateLimitWindow(value) {
 export async function loadLocalAgentUsage(options = {}) {
     return loadLocalAgentUsageWithFormats(await localAgentFormatRuntimes(), options);
 }
+/**
+ * Read only formats whose registry contract supports action planning.
+ *
+ * The launch action loop currently has truthful session/completion semantics
+ * for Claude Code and Codex. Keeping this entrypoint registry-driven avoids an
+ * unnecessary Gemini history walk and prevents presence-only/experimental
+ * formats from silently entering a matched token experiment.
+ */
+export async function loadLocalAgentActionEvidence(options = {}) {
+    const runtimes = await localAgentFormatRuntimes();
+    return loadLocalAgentUsageWithFormats(runtimes.filter((runtime) => runtime.descriptor.capabilities.actionPlanning), options);
+}
 /**
  * Registry-driven ingestion engine. Exported from this module for registry
  * contract tests and format modules, but intentionally omitted from the
@@ -633,6 +1058,9 @@ export async function loadLocalAgentUsage(options = {}) {
  */
 export async function loadLocalAgentUsageWithFormats(registry, options = {}) {
     validateLocalAgentFormatDescriptors(registry.map((entry) => entry.descriptor));
+    const qualitativePolicy = options.qualitativeScan
+        ? validateQualitativeScanPolicy(options.qualitativeScan)
+        : undefined;
     const home = homedir();
     const calls = [];
     const codexInvocationFiles = options.collectCodexInvocationEvidence
@@ -643,37 +1071,149 @@ export async function loadLocalAgentUsageWithFormats(registry, options = {}) {
     const sinceMs = typeof since === "number" && Number.isFinite(since) ? since : undefined;
     const diagnostics = [];
     const sourceScans = [];
+    // One bounded header-pass budget per run. A malformed coverage ref is
+    // dropped rather than compared: proven files then keep blocking (fail
+    // closed) instead of reading as foreign to a garbage project.
+    const headerPass = options.ownershipIndex
+        ? {
+            ownershipIndex: options.ownershipIndex,
+            ...(options.coverageProjectRef &&
+                /^avref_[a-f0-9]{64}$/.test(options.coverageProjectRef)
+                ? { coverageProjectRef: options.coverageProjectRef }
+                : {}),
+            probesRemaining: codexHeaderProbesPerScan
+        }
+        : undefined;
     for (const runtime of registry) {
         const { descriptor } = runtime;
         const scan = emptySourceScan(descriptor.id);
+        if (qualitativePolicy)
+            initializeQualitativeCoverage(scan);
         sourceScans.push(scan);
         const root = localAgentFormatRoot(descriptor, options, home);
-        for (const file of await listFormatCandidateFiles(root, descriptor, scan, diagnostics)) {
+        const discoveredFiles = await listFormatCandidateFiles(root, descriptor, scan, diagnostics);
+        const files = qualitativePolicy
+            ? await selectBoundedQualitativeFiles(discoveredFiles, descriptor, sinceMs, qualitativePolicy, 
+            // Must match the loop's per-file derivation exactly (key alignment).
+            Boolean(options.collectCodexInvocationEvidence) && descriptor.id === "codex" &&
+                descriptor.capabilities.invocationEvidence, scan, diagnostics, options.qualitativeIndex, headerPass, options.streamCheckpoints)
+            : discoveredFiles.map((filePath) => ({ filePath }));
+        for (const selected of files) {
+            const file = selected.filePath;
             if (!matchesLocalAgentFormatFile(descriptor, file))
                 continue;
-            let content;
-            try {
-                content = await readFile(file, "utf8");
+            const collectInvocationEvidence = Boolean(codexInvocationFiles) &&
+                descriptor.id === "codex" && descriptor.capabilities.invocationEvidence;
+            let indexed;
+            if (qualitativePolicy && selected.streamedValue) {
+                // A checkpointed stream completed this run; its index entry is
+                // already persisted. Consume the value like a fresh complete read.
+                indexed = selected.streamedValue;
+                scan.qualitativeFilesReadCompletely =
+                    (scan.qualitativeFilesReadCompletely ?? 0) + 1;
             }
-            catch (error) {
-                recordUnreadableFile(descriptor.id, scan, diagnostics, error);
-                continue;
+            else if (qualitativePolicy && options.qualitativeIndex && selected.indexKey) {
+                try {
+                    const candidate = await options.qualitativeIndex.read(selected.indexKey);
+                    if (candidate && await qualitativeIndexKeyStillCurrent(file, selected.indexKey)) {
+                        if (isQualitativeIndexValue(candidate, descriptor, collectInvocationEvidence)) {
+                            indexed = candidate;
+                            scan.qualitativeIndexHits = (scan.qualitativeIndexHits ?? 0) + 1;
+                            scan.qualitativeBytesReused =
+                                (scan.qualitativeBytesReused ?? 0) + (selected.fileSize ?? 0);
+                            scan.qualitativeFilesReadCompletely =
+                                (scan.qualitativeFilesReadCompletely ?? 0) + 1;
+                        }
+                        else {
+                            scan.qualitativeIndexErrors = (scan.qualitativeIndexErrors ?? 0) + 1;
+                        }
+                    }
+                    // A candidate whose file identity moved on mid-scan is a benign
+                    // change, not an index failure; the fresh-read path fails it closed.
+                }
+                catch {
+                    if (!selected.probeErrored) {
+                        scan.qualitativeIndexErrors = (scan.qualitativeIndexErrors ?? 0) + 1;
+                    }
+                }
             }
-            if (!content)
+            // A file admitted only because a validated selection-time hit exempted
+            // it from the byte budget must never fall through to an unbudgeted
+            // fresh read when the loop probe misses (concurrent GC, transient FS
+            // error). Fail closed: record the skip, coverage stays "indexing", and
+            // the next scan re-probes.
+            if (!indexed && selected.budgetExempt) {
+                recordQualitativeBudgetSkip(scan);
                 continue;
+            }
+            let parsed;
+            if (indexed) {
+                parsed = indexed;
+            }
+            else {
+                let content;
+                try {
+                    if (qualitativePolicy) {
+                        const bounded = await readBoundedUtf8File(file, selected.maxReadBytes, selected.indexKey.fileIdentity);
+                        content = bounded.content;
+                        scan.qualitativeBytesRead = (scan.qualitativeBytesRead ?? 0) + bounded.bytesRead;
+                        scan.qualitativeFilesReadCompletely =
+                            (scan.qualitativeFilesReadCompletely ?? 0) + 1;
+                    }
+                    else {
+                        content = await readFile(file, "utf8");
+                    }
+                }
+                catch (error) {
+                    if (qualitativePolicy && error instanceof QualitativeReadLimitError) {
+                        recordQualitativeBudgetSkip(scan);
+                        continue;
+                    }
+                    recordUnreadableFile(descriptor.id, scan, diagnostics, error);
+                    if (qualitativePolicy)
+                        scan.qualitativeCoverage = "partial";
+                    continue;
+                }
+                if (!content)
+                    continue;
+                const fileDiagnostics = [];
+                const fresh = runtime.parseFull({
+                    content,
+                    filePath: file,
+                    sinceMs,
+                    collectInvocationEvidence,
+                    onDiagnostic: (diagnostic) => fileDiagnostics.push(diagnostic)
+                });
+                parsed = {
+                    calls: fresh.calls,
+                    ...(fresh.invocationFile ? { invocationFile: fresh.invocationFile } : {}),
+                    ...(fresh.invocationWindowProof
+                        ? { invocationWindowProof: fresh.invocationWindowProof }
+                        : {}),
+                    diagnostics: fileDiagnostics
+                };
+                // Never persist a registry ownership violation, even through a
+                // caller-supplied adapter. Preserve the legacy fail-fast contract.
+                assertFormatCallOwnership(descriptor, parsed.calls);
+                assertInvocationOwnership(descriptor, parsed.invocationFile, collectInvocationEvidence);
+                if (qualitativePolicy && options.qualitativeIndex && selected.indexKey) {
+                    try {
+                        await options.qualitativeIndex.write(selected.indexKey, parsed);
+                    }
+                    catch {
+                        // One broken store document should read as one failure: the
+                        // selection probe already counted it when it errored there.
+                        if (!selected.probeErrored) {
+                            scan.qualitativeIndexErrors = (scan.qualitativeIndexErrors ?? 0) + 1;
+                        }
+                    }
+                }
+            }
             filesParsed += 1;
             scan.filesParsed += 1;
-            const collectInvocationEvidence = Boolean(codexInvocationFiles) &&
-                descriptor.id === "codex" && descriptor.capabilities.invocationEvidence;
-            const parsed = runtime.parseFull({
-                content,
-                filePath: file,
-                sinceMs,
-                collectInvocationEvidence,
-                onDiagnostic: (diagnostic) => {
-                    recordParseDiagnostic(descriptor.id, scan, diagnostics, diagnostic);
-                }
-            });
+            for (const diagnostic of parsed.diagnostics) {
+                recordParseDiagnostic(descriptor.id, scan, diagnostics, diagnostic);
+            }
             assertFormatCallOwnership(descriptor, parsed.calls);
             assertInvocationOwnership(descriptor, parsed.invocationFile, collectInvocationEvidence);
             calls.push(...parsed.calls);
@@ -681,6 +1221,8 @@ export async function loadLocalAgentUsageWithFormats(registry, options = {}) {
                 codexInvocationFiles.push(parsed.invocationFile);
             }
         }
+        if (qualitativePolicy)
+            finishQualitativeCoverage(scan, diagnostics);
     }
     const normalizedCalls = dedupeCumulativeSessionCalls(calls, (agent) => {
         const scan = sourceScans.find((entry) => entry.agent === agent);
@@ -729,9 +1271,71 @@ export async function loadLocalAgentFinancialUsageWithFormats(registry, options
         const scan = financialSourceScan(descriptor);
         const calls = [];
         const root = localAgentFormatRoot(descriptor, options, home);
-        for (const file of await listFormatCandidateFiles(root, descriptor, scan, diagnostics)) {
-            if (!matchesLocalAgentFormatFile(descriptor, file))
-                continue;
+        const candidateFiles = (await listFormatCandidateFiles(root, descriptor, scan, diagnostics))
+            .filter((file) => matchesLocalAgentFormatFile(descriptor, file));
+        // Per-file financial cache (req 5's financial half). The newest file per
+        // source always parses fresh: the active session's evidence — including
+        // its raw working directory for downstream context inference — must never
+        // come from a privacy-reduced cache entry.
+        const financialKeys = new Map();
+        let newestFile;
+        if (options.financialIndex) {
+            let newestRecency = Number.NEGATIVE_INFINITY;
+            for (const file of candidateFiles) {
+                const metadata = await lstat(file).catch(() => undefined);
+                if (!metadata || !metadata.isFile() || metadata.isSymbolicLink())
+                    continue;
+                financialKeys.set(file, {
+                    schemaVersion: 2,
+                    section: "financial",
+                    agent: descriptor.id,
+                    pathHash: createHash("sha256").update(resolve(file)).digest("hex"),
+                    fileIdentity: qualitativeFileIdentity(metadata),
+                    financialParserVersion: localAgentFinancialParserVersion
+                });
+                const recency = Math.max(metadata.mtimeMs, metadata.ctimeMs, metadata.birthtimeMs);
+                if (recency > newestRecency) {
+                    newestRecency = recency;
+                    newestFile = file;
+                }
+            }
+        }
+        for (const file of candidateFiles) {
+            const financialKey = financialKeys.get(file);
+            // Any newest file may reuse its cache when its identity is
+            // byte-unchanged — cached evidence is then exact. Codex additionally
+            // recovers its root working directory from the bounded session_meta
+            // first line; Claude reuse serves refs only and context inference
+            // falls back to the requested project path. An actively growing
+            // session changes identity and always parses fresh.
+            if (options.financialIndex && financialKey) {
+                try {
+                    const cached = await options.financialIndex.read(financialKey);
+                    if (cached && file === newestFile &&
+                        !await financialIdentityStillCurrent(file, financialKey)) {
+                        throw new Error("stale newest identity");
+                    }
+                    if (cached) {
+                        if (file === newestFile && descriptor.id === "codex") {
+                            await attachProbedRootCwd(file, cached.calls, financialKey.fileIdentity);
+                        }
+                        const cachedCalls = cached.calls;
+                        assertFormatCallOwnership(descriptor, cachedCalls);
+                        scan.filesParsed += 1;
+                        for (const diagnostic of cached.diagnostics) {
+                            recordParseDiagnostic(descriptor.id, scan, diagnostics, diagnostic);
+                        }
+                        calls.push(...cachedCalls);
+                        continue;
+                    }
+                }
+                catch {
+                    // A failing cache never blocks the authoritative fresh parse.
+                }
+            }
+            const diagnosticsBefore = diagnostics.length;
+            const unreadableBefore = scan.unreadableFiles;
+            const filesParsedBefore = scan.filesParsed;
             const parsedCalls = await runtime.parseFinancialFile({
                 filePath: file,
                 sinceMs,
@@ -741,6 +1345,23 @@ export async function loadLocalAgentFinancialUsageWithFormats(registry, options
             assertFormatCallOwnership(descriptor, parsedCalls);
             assertFinancialSourceOwnership(descriptor, scan, diagnostics);
             calls.push(...parsedCalls);
+            // Cache only clean, content-bearing parses under the identity captured
+            // BEFORE the read: a file that changed mid-parse fails the next
+            // identity check instead of serving mixed evidence.
+            if (options.financialIndex && financialKey &&
+                scan.filesParsed === filesParsedBefore + 1 &&
+                scan.unreadableFiles === unreadableBefore) {
+                const parseDiagnostics = diagnostics.slice(diagnosticsBefore)
+                    .filter((entry) => (entry.code === "malformed_jsonl" ||
+                    entry.code === "malformed_session_file" ||
+                    entry.code === "unsupported_token_shape"))
+                    .map((entry) => ({ code: entry.code,
+                    count: entry.count }));
+                await options.financialIndex.write(financialKey, {
+                    calls: parsedCalls,
+                    diagnostics: parseDiagnostics
+                }).catch(() => undefined);
+            }
         }
         return { calls, scan, diagnostics };
     }));
@@ -768,6 +1389,139 @@ export async function loadLocalAgentFinancialUsageWithFormats(registry, options
         diagnostics: scanned.flatMap((entry) => entry.diagnostics)
     };
 }
+/** Whether a financial cache key still matches the file's on-disk identity. */
+async function financialIdentityStillCurrent(filePath, key) {
+    const metadata = await lstat(filePath).catch(() => undefined);
+    if (!metadata || !metadata.isFile() || metadata.isSymbolicLink())
+        return false;
+    return qualitativeFileIdentity(metadata) === key.fileIdentity;
+}
+/**
+ * Recover the newest Codex rollout's root working directory from its bounded
+ * session_meta first line and re-attach it to cached calls whose privacy-
+ * reduced ref matches. Reads at most 256 KiB; never guesses on mismatch.
+ */
+async function attachProbedRootCwd(filePath, calls, expectedIdentity) {
+    const header = await probeCodexRolloutHeader(filePath, expectedIdentity);
+    const cwd = header?.cwd;
+    if (!cwd)
+        return;
+    const ref = derivedWorkingDirectoryRef(cwd);
+    for (const call of calls) {
+        if (call.workingDirectoryRef === ref && !call.workingDirectory) {
+            call.workingDirectory = cwd;
+        }
+    }
+}
+const codexHeaderProbeBytes = 256 * 1024;
+/**
+ * Bounded Codex rollout header probe (design section c). Opens the exact
+ * inode (O_NOFOLLOW), binds both boundary stats to `expectedIdentity` when
+ * one is supplied, reads at most the first 256 KiB, and abstractly parses
+ * only the first complete line as a root `session_meta` record. Every
+ * failure — oversized first line, non-session_meta first line, malformed
+ * JSON, identity drift mid-probe — returns undefined: unknown, never an
+ * error and never a guess. The raw cwd never escapes its callers beyond
+ * deriving an avref or re-attaching evidence that already carried the
+ * byte-identical ref.
+ */
+async function probeCodexRolloutHeader(filePath, expectedIdentity) {
+    let firstLine;
+    try {
+        const handle = await open(filePath, constants.O_RDONLY | constants.O_NOFOLLOW);
+        try {
+            const before = await handle.stat();
+            if (!before.isFile() ||
+                expectedIdentity !== undefined &&
+                    qualitativeFileIdentity(before) !== expectedIdentity) {
+                return undefined;
+            }
+            const probe = Buffer.allocUnsafe(codexHeaderProbeBytes);
+            let bytesRead = 0;
+            let sawEof = false;
+            while (bytesRead < probe.length) {
+                const read = await handle.read(probe, bytesRead, probe.length - bytesRead, bytesRead);
+                if (read.bytesRead === 0) {
+                    sawEof = true;
+                    break;
+                }
+                bytesRead += read.bytesRead;
+                if (probe.subarray(0, bytesRead).includes(0x0a))
+                    break;
+            }
+            const window = probe.subarray(0, bytesRead);
+            const newlineAt = window.indexOf(0x0a);
+            if (newlineAt > 0) {
+                firstLine = Buffer.from(window.subarray(0, newlineAt));
+            }
+            else if (newlineAt === -1 && sawEof && bytesRead > 0) {
+                // EOF inside the window: the whole file is one complete first line.
+                firstLine = Buffer.from(window);
+            }
+            const after = await handle.stat();
+            if (!after.isFile() ||
+                expectedIdentity !== undefined &&
+                    qualitativeFileIdentity(after) !== expectedIdentity) {
+                return undefined;
+            }
+        }
+        finally {
+            await handle.close().catch(() => undefined);
+        }
+    }
+    catch {
+        return undefined;
+    }
+    if (!firstLine)
+        return undefined;
+    let record;
+    try {
+        record = JSON.parse(firstLine.toString("utf8"));
+    }
+    catch {
+        return undefined;
+    }
+    if (!isRecord(record) || record.type !== "session_meta" || !isRecord(record.payload)) {
+        return undefined;
+    }
+    const payload = record.payload;
+    const cwd = stringOf(payload.cwd);
+    const parentSessionId = stringOf(payload.parent_thread_id);
+    const forkedFromId = stringOf(payload.forked_from_id);
+    return {
+        ...(cwd && isAbsolute(cwd) ? { cwd } : {}),
+        isSubagent: stringOf(payload.thread_source) === "subagent" ||
+            isRecord(payload.source) && "subagent" in payload.source,
+        ...(parentSessionId ? { parentSessionId } : {}),
+        ...(forkedFromId ? { forkedFromId } : {})
+    };
+}
+/**
+ * MINOR-5 attribution parity: "proven" requires exactly the condition under
+ * which `dominantCodexCwd` short-circuits to the session cwd — an absolute
+ * path whose `projectFromCwd` label is a real project (not "(home)"; cwd "/"
+ * has an empty basename and falls through to body evidence, QA case 36). A
+ * full parse of such a rollout is guaranteed to emit this same directory as
+ * its only call's working directory, so the derived ref matches byte-for-
+ * byte. Everything else — home, "/", relative, absent, unparseable — stays
+ * unknown and keeps blocking; unknown is never treated as foreign.
+ */
+function codexHeaderAttribution(header) {
+    const marker = header ? { isSubagent: header.isSubagent } : {};
+    const cwd = header?.cwd;
+    if (!cwd || !isAbsolute(cwd))
+        return { status: "unknown", ...marker };
+    const project = projectFromCwd(cwd);
+    if (!project || project === "(home)")
+        return { status: "unknown", ...marker };
+    // Refs derive from the resolved directory: `absoluteWorkingDirectory`
+    // resolves the short-circuited session cwd before the call is emitted.
+    return {
+        status: "proven",
+        projectRef: derivedWorkingDirectoryRef(resolve(cwd)),
+        ...marker
+    };
+}
 /** @internal Runtime hook owned by the Claude Code registry entry. */
 export async function readClaudeCodeFinancialFileForRegistry(context) {
     const { filePath, sinceMs, scan, diagnostics } = context;
@@ -780,7 +1534,11 @@ export async function readClaudeCodeFinancialFileForRegistry(context) {
     let streamed;
     try {
         streamed = await streamJsonlRecords(filePath, (entry) => {
-            const call = parseClaudeFinancialEntry(entry, filePath, sinceMs, seen, (diagnostic) => fileDiagnostics.push(diagnostic));
+            const call = parseClaudeFinancialEntry(entry, filePath, 
+            // Window-blind on purpose: cached values must contain the complete
+            // file so a narrow-window run can never truncate a wider one. The
+            // loader's final timestamp filter performs all narrowing.
+            undefined, seen, (diagnostic) => fileDiagnostics.push(diagnostic));
             if (call)
                 calls.push(call);
         });
@@ -920,6 +1678,975 @@ function assertInvocationOwnership(descriptor, invocationFile, collectionAllowed
         throw new Error(`Local-agent format ${descriptor.id} emitted invocation evidence for a different source.`);
     }
 }
+class QualitativeReadLimitError extends Error {
+    constructor() {
+        super("Qualitative transcript changed beyond the configured byte limit while being read.");
+        this.name = "QualitativeReadLimitError";
+    }
+}
+function validateQualitativeScanPolicy(policy) {
+    for (const [name, value] of Object.entries(policy)) {
+        if (!Number.isSafeInteger(value) || value <= 0) {
+            throw new RangeError(`${name} must be a positive safe integer byte limit.`);
+        }
+    }
+    return policy;
+}
+function initializeQualitativeCoverage(scan) {
+    scan.filesSkippedBeforeWindow = 0;
+    scan.qualitativeCoverage = "complete";
+    scan.qualitativeFilesEligible = 0;
+    scan.qualitativeFilesSkippedForBudget = 0;
+    scan.qualitativeFilesSelected = 0;
+    scan.qualitativeFilesReadCompletely = 0;
+    scan.qualitativeBytesEligible = 0;
+    scan.qualitativeBytesSelected = 0;
+    scan.qualitativeBytesRead = 0;
+    scan.qualitativeBytesReused = 0;
+    scan.qualitativeIndexHits = 0;
+    scan.qualitativeIndexErrors = 0;
+    scan.qualitativeFilesIndexed = 0;
+    scan.qualitativeFilesForeignProven = 0;
+    scan.qualitativeFilesOwnershipUnknown = 0;
+    scan.qualitativeSelectedEvidence = "complete_files_only";
+}
+/**
+ * Select complete files, never byte ranges. A partial session can make a
+ * cumulative counter look like a turn or make inherited Codex history look
+ * like child usage, so a file that does not fit is omitted as a whole.
+ */
+async function selectBoundedQualitativeFiles(discoveredFiles, descriptor, sinceMs, policy, collectInvocationEvidence, scan, diagnostics, qualitativeIndex, headerPass, streamCheckpoints) {
+    const eligible = [];
+    for (const filePath of discoveredFiles) {
+        if (!matchesLocalAgentFormatFile(descriptor, filePath))
+            continue;
+        let metadata;
+        try {
+            metadata = await lstat(filePath);
+        }
+        catch (error) {
+            recordUnreadableFile(descriptor.id, scan, diagnostics, error);
+            scan.qualitativeCoverage = "partial";
+            continue;
+        }
+        // Discovery accepts regular files only. Re-check immediately before the
+        // read so a path replacement cannot redirect a local scan through a link.
+        if (!metadata.isFile() || metadata.isSymbolicLink() ||
+            !Number.isSafeInteger(metadata.size) || metadata.size < 0) {
+            recordUnreadableFile(descriptor.id, scan, diagnostics, newErrorWithCode("EINVAL"));
+            scan.qualitativeCoverage = "partial";
+            continue;
+        }
+        // Match the financial reader's conservative proof: ctime catches a path
+        // whose mtime was restored after replacement, and birthtime catches a
+        // recent copy that preserved an older mtime.
+        const newestFileEvidence = Math.max(metadata.mtimeMs, metadata.ctimeMs, metadata.birthtimeMs);
+        if (typeof sinceMs === "number" && Number.isFinite(newestFileEvidence) &&
+            newestFileEvidence < sinceMs) {
+            scan.filesSkippedBeforeWindow = (scan.filesSkippedBeforeWindow ?? 0) + 1;
+            continue;
+        }
+        scan.qualitativeFilesEligible = (scan.qualitativeFilesEligible ?? 0) + 1;
+        scan.qualitativeBytesEligible = (scan.qualitativeBytesEligible ?? 0) + metadata.size;
+        eligible.push({
+            filePath,
+            size: metadata.size,
+            recencyMs: newestFileEvidence,
+            dev: metadata.dev,
+            ino: metadata.ino,
+            mtimeMs: metadata.mtimeMs,
+            ctimeMs: metadata.ctimeMs,
+            birthtimeMs: metadata.birthtimeMs
+        });
+    }
+    // Recent evidence is the most useful bounded prefix. Path order breaks
+    // equal-mtime ties so repeated scans of an unchanged tree are deterministic.
+    eligible.sort((left, right) => (right.recencyMs - left.recencyMs || left.filePath.localeCompare(right.filePath)));
+    const selected = [];
+    const streamCandidates = [];
+    let remaining = policy.maxSourceBytes;
+    for (const file of eligible) {
+        let probeErrored = false;
+        // Probe the private index before any budget decision (req 5): a file with
+        // validated cached evidence is admitted regardless of size and consumes
+        // no byte budget. The probe is trusted for budget exemption only after
+        // the same identity re-check the parse loop performs.
+        if (qualitativeIndex) {
+            const candidateKey = qualitativeIndexKey(descriptor.id, file.filePath, file, sinceMs, collectInvocationEvidence);
+            let cachedHit = false;
+            try {
+                const candidate = await qualitativeIndex.read(candidateKey);
+                cachedHit = Boolean(candidate &&
+                    await qualitativeIndexKeyStillCurrent(file.filePath, candidateKey) &&
+                    isQualitativeIndexValue(candidate, descriptor, collectInvocationEvidence));
+            }
+            catch {
+                probeErrored = true;
+                scan.qualitativeIndexErrors = (scan.qualitativeIndexErrors ?? 0) + 1;
+            }
+            if (cachedHit) {
+                selected.push({
+                    filePath: file.filePath,
+                    maxReadBytes: file.size,
+                    fileSize: file.size,
+                    indexKey: candidateKey,
+                    budgetExempt: true,
+                    probeErrored
+                });
+                scan.qualitativeFilesSelected = (scan.qualitativeFilesSelected ?? 0) + 1;
+                continue;
+            }
+        }
+        // Oversized Codex rollouts route to the bounded streaming pass instead
+        // of a permanent skip whenever both index sections are available; they
+        // never consume the whole-file byte budget (req 5).
+        if (streamCheckpoints && qualitativeIndex && descriptor.id === "codex" &&
+            file.size > policy.maxFileBytes) {
+            streamCandidates.push(file);
+            continue;
+        }
+        if (file.size > policy.maxFileBytes || file.size > remaining) {
+            recordQualitativeBudgetSkip(scan);
+            // A budget-skipped Codex file still gets a bounded header pass so a
+            // proven-foreign attribution can honestly narrow the requested
+            // project's blocking set without ever reading the body. Claude files
+            // get no header shortcut (their cwd can change mid-file).
+            if (headerPass && descriptor.id === "codex") {
+                await recordBudgetSkippedCodexHeader(file, headerPass, scan);
+            }
+            continue;
+        }
+        selected.push({
+            filePath: file.filePath,
+            // Bind the read to the selected metadata snapshot. Growth is treated as
+            // incomplete coverage rather than silently consuming another file's
+            // reserved source budget.
+            maxReadBytes: file.size,
+            fileSize: file.size,
+            indexKey: qualitativeIndexKey(descriptor.id, file.filePath, file, sinceMs, collectInvocationEvidence),
+            probeErrored: probeErrored || undefined
+        });
+        scan.qualitativeFilesSelected = (scan.qualitativeFilesSelected ?? 0) + 1;
+        scan.qualitativeBytesSelected = (scan.qualitativeBytesSelected ?? 0) + file.size;
+        remaining -= file.size;
+    }
+    if (streamCandidates.length > 0 && streamCheckpoints && qualitativeIndex) {
+        const streamed = await runCodexStreamingPass(streamCandidates, {
+            descriptor,
+            qualitativeIndex,
+            streamCheckpoints,
+            ...(headerPass ? { ownershipIndex: headerPass.ownershipIndex } : {}),
+            collectInvocationEvidence,
+            sinceMs,
+            scan,
+            remainingBytes: policy.maxStreamedBytesPerRun ?? defaultStreamedBytesPerRun
+        });
+        for (const file of streamCandidates) {
+            const value = streamed.get(file.filePath);
+            if (value) {
+                selected.push({
+                    filePath: file.filePath,
+                    fileSize: file.size,
+                    streamedValue: value
+                });
+                scan.qualitativeFilesSelected = (scan.qualitativeFilesSelected ?? 0) + 1;
+                continue;
+            }
+            // Unconverged this run: same honest accounting as a budget skip (the
+            // body was not fully parsed), plus explicit stream-progress counters
+            // and the A4a header-pass ownership classification.
+            recordQualitativeBudgetSkip(scan);
+            scan.qualitativeFilesStreaming = (scan.qualitativeFilesStreaming ?? 0) + 1;
+            if (headerPass) {
+                await recordBudgetSkippedCodexHeader(file, headerPass, scan);
+            }
+        }
+    }
+    return selected;
+}
+/**
+ * Fresh bounded header reads allowed per scan. Files beyond the cap simply
+ * stay ownership-unknown ("indexing") this run — never claimed either way —
+ * and are reached on a later run once earlier probes persist their results.
+ */
+export const codexHeaderProbesPerScan = 64;
+/**
+ * Classify one budget-skipped Codex file from its persisted or freshly probed
+ * header attribution. Only a "proven" attribution to a project OTHER than the
+ * requested coverage ref counts as foreign; proven-owned and unknown files
+ * keep blocking. Store failures count as index errors, which already force
+ * the fail-closed "indexing" state.
+ */
+async function recordBudgetSkippedCodexHeader(file, headerPass, scan) {
+    const pathHash = createHash("sha256").update(resolve(file.filePath)).digest("hex");
+    const fileIdentity = qualitativeFileIdentity(file);
+    let attribution;
+    try {
+        const stored = await headerPass.ownershipIndex.readOwnership("codex", pathHash);
+        if (stored && stored.fileIdentity === fileIdentity) {
+            attribution = stored.headerAttribution;
+        }
+    }
+    catch {
+        scan.qualitativeIndexErrors = (scan.qualitativeIndexErrors ?? 0) + 1;
+        return;
+    }
+    if (!attribution) {
+        // Honest carry-over: past the cap the file simply stays unknown this run.
+        if (headerPass.probesRemaining <= 0)
+            return;
+        headerPass.probesRemaining -= 1;
+        attribution = codexHeaderAttribution(await probeCodexRolloutHeader(file.filePath, fileIdentity));
+        try {
+            await headerPass.ownershipIndex.writeOwnership("codex", pathHash, {
+                // Body-derived ownership is still unknown: only the header was read.
+                status: "unknown",
+                fileIdentity,
+                projectRefs: [],
+                headerAttribution: attribution
+            });
+        }
+        catch {
+            scan.qualitativeIndexErrors = (scan.qualitativeIndexErrors ?? 0) + 1;
+            return;
+        }
+    }
+    if (attribution.status === "proven" && attribution.projectRef &&
+        headerPass.coverageProjectRef &&
+        attribution.projectRef !== headerPass.coverageProjectRef) {
+        scan.qualitativeFilesForeignProven = (scan.qualitativeFilesForeignProven ?? 0) + 1;
+    }
+}
+const codexStreamChunkBytes = 8 * 1_024 * 1_024;
+/** A single JSONL line above this bound is skipped as malformed (design e). */
+const codexStreamMaxLineBytes = 32 * 1_024 * 1_024;
+const codexStreamPrefixProbeBytes = 64 * 1_024;
+/**
+ * Default per-run byte allowance for the streaming pass. Sized from measured
+ * end-to-end throughput (~99 MB/s on the reference machine, QA probe8): 512
+ * MiB keeps one slice at roughly 4-5 seconds of wall clock inside the cold
+ * budget. Callers with different budgets tune `maxStreamedBytesPerRun`.
+ */
+export const defaultStreamedBytesPerRun = 512 * 1_024 * 1_024;
+/** Bounded per-run header probes used only to order the streaming schedule. */
+const codexStreamSchedulingProbesPerScan = 256;
+/** Documented retention caps for the privacy-reduced checkpoint state. */
+const checkpointRecentPromptLimit = 12;
+const checkpointPromptCharLimit = 4_096;
+const checkpointFileCountLimit = 256;
+const checkpointWorkdirLimit = 128;
+/**
+ * Reduce live reducer state to its persistable form: prompts pass through
+ * `sanitizeLocalActivityText` and keep only the last 12 survivors (earlier
+ * survivors persist as a count); file basename tallies and hashed workdir
+ * tallies are capped deterministically; the raw session cwd collapses to its
+ * short-circuit decision plus resolved ref/project. Raw absolute paths and
+ * raw prompt text never reach disk.
+ */
+function serializeCodexReducerState(state) {
+    // Path spans are stripped BEFORE sanitization so persisted survivors carry
+    // the same privacy guarantee as entries: raw absolute paths (including
+    // home-anchored ones) never reach disk. Topic derivation is unaffected
+    // (topicTokens strips the same spans); the residual divergence is that
+    // inferAction can no longer see action words embedded inside path segments
+    // of checkpoint-crossing prompts, and path-only prompts stop counting —
+    // pinned by the streaming privacy fixture.
+    const survivors = state.prompts
+        .map((prompt) => sanitizeLocalActivityText(stripAbsolutePathSpans(prompt)))
+        .filter(isHumanPrompt)
+        .map((prompt) => prompt.length > checkpointPromptCharLimit
+        ? prompt.slice(0, checkpointPromptCharLimit)
+        : prompt);
+    const recentPrompts = survivors.slice(-checkpointRecentPromptLimit);
+    const promptOverflow = state.restoredPromptOverflow +
+        Math.max(0, survivors.length - checkpointRecentPromptLimit);
+    let rootCwd;
+    if (state.rootCwd !== undefined) {
+        const sessionProject = projectFromCwd(state.rootCwd);
+        const resolved = absoluteWorkingDirectory(state.rootCwd);
+        rootCwd = {
+            present: true,
+            shortCircuits: Boolean(sessionProject && sessionProject !== "(home)"),
+            ...(resolved !== undefined
+                ? {
+                    resolvedRef: derivedWorkingDirectoryRef(resolved),
+                    ...(projectFromCwd(resolved) !== undefined
+                        ? { resolvedProject: projectFromCwd(resolved) }
+                        : {})
+                }
+                : {})
+        };
+    }
+    else if (state.restoredRootCwd) {
+        rootCwd = state.restoredRootCwd;
+    }
+    else {
+        rootCwd = { present: false, shortCircuits: false };
+    }
+    const workdirs = mergeCodexWorkdirTallies(state)
+        .map(({ rawPath: _rawPath, ...tally }) => tally)
+        .sort((left, right) => right.count - left.count || left.ref.localeCompare(right.ref))
+        .slice(0, checkpointWorkdirLimit);
+    const fileCounts = [...state.fileCounts.entries()]
+        .sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]))
+        .slice(0, checkpointFileCountLimit);
+    return {
+        ...(state.model !== undefined ? { model: state.model } : {}),
+        ...(state.sessionId !== undefined ? { sessionId: state.sessionId } : {}),
+        ...(state.sourceVersion !== undefined ? { sourceVersion: state.sourceVersion } : {}),
+        rootSessionMetaSeen: state.rootSessionMetaSeen,
+        ...(state.startedAt !== undefined ? { startedAt: state.startedAt } : {}),
+        ...(state.rootStartedAtMs !== undefined ? { rootStartedAtMs: state.rootStartedAtMs } : {}),
+        rootTaskStarted: state.rootTaskStarted,
+        isSubagent: state.isSubagent,
+        ...(state.parentSessionId !== undefined ? { parentSessionId: state.parentSessionId } : {}),
+        ...(state.pendingTaskTurnId !== undefined ? { pendingTaskTurnId: state.pendingTaskTurnId } : {}),
+        ...(state.completedTask !== undefined ? { completedTask: state.completedTask } : {}),
+        malformedLines: state.malformedLines,
+        ...(state.lastActivityAt !== undefined ? { lastActivityAt: state.lastActivityAt } : {}),
+        ...(state.lastTotal !== undefined ? { lastTotal: state.lastTotal } : {}),
+        ...(state.lastTurn !== undefined ? { lastTurn: state.lastTurn } : {}),
+        ...(state.inheritedUsageBaseline !== undefined
+            ? { inheritedUsageBaseline: state.inheritedUsageBaseline }
+            : {}),
+        ...(state.lastRateLimits !== undefined ? { lastRateLimits: state.lastRateLimits } : {}),
+        rootCwd,
+        workdirs,
+        promptOverflow,
+        recentPrompts,
+        fileCounts,
+        toolCallCount: state.toolCallCount
+    };
+}
+/** Fail-closed structural check for a restored reducer state. */
+function isPersistedCodexReducerState(value) {
+    if (!isRecord(value))
+        return false;
+    const optionalString = (input) => input === undefined || typeof input === "string";
+    const optionalRecord = (input) => input === undefined || isRecord(input) && !Array.isArray(input);
+    const optionalFinite = (input) => input === undefined || typeof input === "number" && Number.isFinite(input);
+    const nonnegativeInt = (input) => Number.isSafeInteger(input) && Number(input) >= 0;
+    const rootCwd = value.rootCwd;
+    const validRootCwd = isRecord(rootCwd) &&
+        typeof rootCwd.present === "boolean" &&
+        typeof rootCwd.shortCircuits === "boolean" &&
+        optionalString(rootCwd.resolvedRef) &&
+        optionalString(rootCwd.resolvedProject);
+    const validWorkdirs = Array.isArray(value.workdirs) && value.workdirs.every((entry) => (isRecord(entry) &&
+        typeof entry.ref === "string" &&
+        Array.isArray(entry.ancestorRefs) &&
+        entry.ancestorRefs.every((ref) => typeof ref === "string") &&
+        nonnegativeInt(entry.depth) &&
+        typeof entry.base === "string" &&
+        typeof entry.isHome === "boolean" &&
+        nonnegativeInt(entry.count)));
+    const validCompletion = value.completedTask === undefined || (isRecord(value.completedTask) &&
+        value.completedTask.status === "completed" &&
+        value.completedTask.evidence === "codex_task_complete" &&
+        typeof value.completedTask.observedAt === "string");
+    const validRateLimits = value.lastRateLimits === undefined || (isRecord(value.lastRateLimits) &&
+        typeof value.lastRateLimits.observedAt === "string" &&
+        Array.isArray(value.lastRateLimits.windows));
+    return typeof value.rootSessionMetaSeen === "boolean" &&
+        typeof value.rootTaskStarted === "boolean" &&
+        typeof value.isSubagent === "boolean" &&
+        optionalString(value.model) &&
+        optionalString(value.sessionId) &&
+        optionalString(value.sourceVersion) &&
+        optionalString(value.startedAt) &&
+        optionalFinite(value.rootStartedAtMs) &&
+        optionalString(value.parentSessionId) &&
+        optionalString(value.pendingTaskTurnId) &&
+        validCompletion &&
+        nonnegativeInt(value.malformedLines) &&
+        optionalString(value.lastActivityAt) &&
+        optionalRecord(value.lastTotal) &&
+        optionalRecord(value.lastTurn) &&
+        optionalRecord(value.inheritedUsageBaseline) &&
+        validRateLimits &&
+        validRootCwd &&
+        validWorkdirs &&
+        nonnegativeInt(value.promptOverflow) &&
+        Array.isArray(value.recentPrompts) &&
+        value.recentPrompts.every((prompt) => typeof prompt === "string") &&
+        Array.isArray(value.fileCounts) &&
+        value.fileCounts.every((pair) => (Array.isArray(pair) && pair.length === 2 &&
+            typeof pair[0] === "string" && nonnegativeInt(pair[1]))) &&
+        nonnegativeInt(value.toolCallCount);
+}
+function restoreCodexReducerState(persisted) {
+    const state = createCodexRolloutParserState();
+    state.model = persisted.model;
+    state.sessionId = persisted.sessionId;
+    state.sourceVersion = persisted.sourceVersion;
+    state.rootSessionMetaSeen = persisted.rootSessionMetaSeen;
+    state.startedAt = persisted.startedAt;
+    state.rootStartedAtMs = persisted.rootStartedAtMs;
+    state.rootTaskStarted = persisted.rootTaskStarted;
+    state.isSubagent = persisted.isSubagent;
+    state.parentSessionId = persisted.parentSessionId;
+    state.pendingTaskTurnId = persisted.pendingTaskTurnId;
+    state.completedTask = persisted.completedTask;
+    state.malformedLines = persisted.malformedLines;
+    state.lastActivityAt = persisted.lastActivityAt;
+    state.lastTotal = persisted.lastTotal;
+    state.lastTurn = persisted.lastTurn;
+    state.inheritedUsageBaseline = persisted.inheritedUsageBaseline;
+    state.lastRateLimits = persisted.lastRateLimits;
+    state.restoredRootCwd = persisted.rootCwd;
+    state.restoredWorkdirs = persisted.workdirs;
+    state.prompts = [...persisted.recentPrompts];
+    state.restoredPromptOverflow = persisted.promptOverflow;
+    state.fileCounts = new Map(persisted.fileCounts);
+    state.toolCallCount = persisted.toolCallCount;
+    return state;
+}
+/**
+ * One run's bounded streaming pass over oversized Codex rollouts. Candidates
+ * are ordered mainline-first (checkpoint or bounded header probe supplies the
+ * subagent marker) so the 326-subagent reverse-scan pathology can never
+ * starve mainline files, then newest-first within each class. Returns the
+ * evidence of every file whose stream completed this run; everything else
+ * advanced by at least its checkpoint and stays honestly unconverged.
+ */
+async function runCodexStreamingPass(files, context) {
+    const scan = context.scan;
+    const candidates = [];
+    let schedulingProbes = codexStreamSchedulingProbesPerScan;
+    for (const file of files) {
+        const pathHash = createHash("sha256").update(resolve(file.filePath)).digest("hex");
+        let checkpoint;
+        try {
+            checkpoint = await context.streamCheckpoints.readStreamCheckpoint("codex", pathHash);
+        }
+        catch {
+            scan.qualitativeIndexErrors = (scan.qualitativeIndexErrors ?? 0) + 1;
+        }
+        let isSubagent;
+        if (checkpoint && isPersistedCodexReducerState(checkpoint.reducerState) &&
+            checkpoint.reducerState.rootSessionMetaSeen) {
+            isSubagent = checkpoint.reducerState.isSubagent;
+        }
+        else {
+            if (context.ownershipIndex) {
+                try {
+                    const stored = await context.ownershipIndex.readOwnership("codex", pathHash);
+                    if (stored && stored.fileIdentity === qualitativeFileIdentity(file)) {
+                        isSubagent = stored.headerAttribution?.isSubagent;
+                    }
+                }
+                catch {
+                    // Scheduling is a hint; the ledger's own ownership reads count
+                    // store failures and force the fail-closed coverage state.
+                }
+            }
+            if (isSubagent === undefined && schedulingProbes > 0) {
+                schedulingProbes -= 1;
+                const header = await probeCodexRolloutHeader(file.filePath, qualitativeFileIdentity(file));
+                isSubagent = header?.isSubagent;
+            }
+        }
+        candidates.push({
+            file,
+            pathHash,
+            ...(checkpoint ? { checkpoint } : {}),
+            ...(isSubagent !== undefined ? { isSubagent } : {})
+        });
+    }
+    const classOf = (candidate) => candidate.isSubagent === false ? 0 : candidate.isSubagent === undefined ? 1 : 2;
+    candidates.sort((left, right) => (classOf(left) - classOf(right) ||
+        right.file.recencyMs - left.file.recencyMs ||
+        left.file.filePath.localeCompare(right.file.filePath)));
+    const completed = new Map();
+    const budget = { remainingBytes: context.remainingBytes };
+    for (const candidate of candidates) {
+        // The policy validator guarantees a positive allowance, so the first
+        // scheduled candidate always streams; later candidates run only while
+        // allowance remains (mainline-first order makes this starvation-safe).
+        if (budget.remainingBytes <= 0)
+            break;
+        const value = await streamCodexRolloutSlice(candidate, context, budget);
+        if (value)
+            completed.set(candidate.file.filePath, value);
+    }
+    return completed;
+}
+/**
+ * Advance one oversized rollout by a bounded slice; complete it when EOF is
+ * reached with a stable identity. Every failure path degrades to "no claim
+ * this run": a broken resume proof restarts from byte zero, a mid-stream
+ * append keeps the checkpoint and withholds the entry (design edge 4), and
+ * store errors surface as index errors that force the fail-closed
+ * "indexing" coverage state.
+ */
+async function streamCodexRolloutSlice(candidate, context, budget) {
+    const scan = context.scan;
+    const selectionIdentity = qualitativeFileIdentity(candidate.file);
+    const runSinceIso = typeof context.sinceMs === "number"
+        ? new Date(context.sinceMs).toISOString()
+        : null;
+    let handle;
+    try {
+        handle = await open(candidate.file.filePath, constants.O_RDONLY | constants.O_NOFOLLOW);
+        const before = await handle.stat();
+        if (!before.isFile() ||
+            before.dev !== candidate.file.dev ||
+            before.ino !== candidate.file.ino ||
+            before.birthtimeMs !== candidate.file.birthtimeMs) {
+            return undefined;
+        }
+        // Resume proof: pinned identity, monotonic size, matching prefix bytes,
+        // matching contract, and structurally valid restored state. Anything
+        // less discards the checkpoint and restarts from byte zero.
+        let state = createCodexRolloutParserState();
+        let collector = context.collectInvocationEvidence
+            ? createCodexInvocationCollector(context.sinceMs)
+            : undefined;
+        let offset = 0;
+        let entrySinceIso = context.collectInvocationEvidence ? runSinceIso : null;
+        const checkpoint = candidate.checkpoint;
+        if (checkpoint) {
+            let resumable = checkpoint.parserVersion === localAgentQualitativeParserVersion &&
+                checkpoint.collectInvocationEvidence === context.collectInvocationEvidence &&
+                checkpoint.pin.dev === candidate.file.dev &&
+                checkpoint.pin.ino === candidate.file.ino &&
+                checkpoint.pin.birthtimeMs === candidate.file.birthtimeMs &&
+                checkpoint.offset <= candidate.file.size &&
+                checkpoint.prefixProbe.bytes === Math.min(codexStreamPrefixProbeBytes, checkpoint.offset) &&
+                isPersistedCodexReducerState(checkpoint.reducerState) &&
+                (!context.collectInvocationEvidence ||
+                    isCodexInvocationCollectorSnapshot(checkpoint.collectorState));
+            if (resumable && checkpoint.offset > 0) {
+                const probeBytes = Math.min(codexStreamPrefixProbeBytes, checkpoint.offset);
+                const probe = Buffer.allocUnsafe(probeBytes);
+                let probeRead = 0;
+                while (probeRead < probeBytes) {
+                    const read = await handle.read(probe, probeRead, probeBytes - probeRead, checkpoint.offset - probeBytes + probeRead);
+                    if (read.bytesRead === 0)
+                        break;
+                    probeRead += read.bytesRead;
+                }
+                resumable = probeRead === probeBytes &&
+                    createHash("sha256").update(probe).digest("hex") === checkpoint.prefixProbe.sha256;
+            }
+            if (resumable) {
+                state = restoreCodexReducerState(checkpoint.reducerState);
+                if (context.collectInvocationEvidence) {
+                    const pinnedSinceMs = checkpoint.sinceIso === null
+                        ? undefined
+                        : Date.parse(checkpoint.sinceIso);
+                    collector = createCodexInvocationCollector(pinnedSinceMs, checkpoint.collectorState);
+                    entrySinceIso = checkpoint.sinceIso;
+                }
+                offset = checkpoint.offset;
+            }
+            else {
+                await context.streamCheckpoints.deleteStreamCheckpoint("codex", candidate.pathHash)
+                    .catch(() => undefined);
+            }
+        }
+        // Bounded chunked line consumption from the resume offset.
+        const collectorConsume = collector?.consume;
+        let consumed = offset;
+        let position = offset;
+        let carry = Buffer.alloc(0);
+        let skippingOversizedLine = false;
+        let linesConsumed = 0;
+        let sawEof = false;
+        while (true) {
+            // A candidate that was scheduled always consumes at least one complete
+            // line (or reaches EOF/an oversized-line skip) before yielding to the
+            // byte allowance — this is what guarantees convergence across runs.
+            if (budget.remainingBytes <= 0 && linesConsumed > 0)
+                break;
+            const readLength = budget.remainingBytes > 0
+                ? Math.min(codexStreamChunkBytes, budget.remainingBytes)
+                : codexStreamChunkBytes;
+            const chunk = Buffer.allocUnsafe(readLength);
+            const read = await handle.read(chunk, 0, readLength, position);
+            if (read.bytesRead === 0) {
+                sawEof = true;
+                break;
+            }
+            budget.remainingBytes -= read.bytesRead;
+            scan.qualitativeBytesStreamed = (scan.qualitativeBytesStreamed ?? 0) + read.bytesRead;
+            const dataStart = position - carry.length;
+            position += read.bytesRead;
+            const data = carry.length > 0
+                ? Buffer.concat([carry, chunk.subarray(0, read.bytesRead)])
+                : chunk.subarray(0, read.bytesRead);
+            let lineStart = 0;
+            while (true) {
+                const newlineAt = data.indexOf(0x0a, lineStart);
+                if (newlineAt === -1)
+                    break;
+                if (skippingOversizedLine) {
+                    // The oversized line just terminated; count it once, exactly when
+                    // its bytes are durably consumed past the checkpoint offset.
+                    skippingOversizedLine = false;
+                    state.malformedLines += 1;
+                }
+                else if (newlineAt - lineStart > codexStreamMaxLineBytes) {
+                    // Exact bound: chunk alignment can let a just-over-cap line
+                    // accumulate fully before its newline arrives; it is still skipped
+                    // as malformed, matching the documented >32 MiB rule.
+                    state.malformedLines += 1;
+                }
+                else {
+                    consumeCodexRolloutLine(state, data.subarray(lineStart, newlineAt).toString("utf8"), collectorConsume);
+                }
+                lineStart = newlineAt + 1;
+                linesConsumed += 1;
+                consumed = dataStart + lineStart;
+            }
+            if (skippingOversizedLine) {
+                carry = Buffer.alloc(0);
+            }
+            else {
+                carry = Buffer.from(data.subarray(lineStart));
+                if (carry.length > codexStreamMaxLineBytes) {
+                    skippingOversizedLine = true;
+                    carry = Buffer.alloc(0);
+                }
+            }
+        }
+        // A crashed or kill-9'd session leaves a final line with no trailing
+        // newline, and that file never changes again. When the post-slice
+        // identity still equals the selection identity, the tail is provably not
+        // an in-flight append: consume it as the final complete line, exactly as
+        // the whole-file parser's split("\\n") treats the same bytes. A torn tail
+        // degrades to the malformed_jsonl diagnostic both paths share.
+        if (sawEof && !skippingOversizedLine && carry.length > 0) {
+            const settled = await handle.stat();
+            if (settled.isFile() && settled.size === consumed + carry.length &&
+                qualitativeFileIdentity(settled) === selectionIdentity) {
+                if (carry.length > codexStreamMaxLineBytes) {
+                    state.malformedLines += 1;
+                }
+                else {
+                    consumeCodexRolloutLine(state, carry.toString("utf8"), collectorConsume);
+                }
+                consumed += carry.length;
+                carry = Buffer.alloc(0);
+            }
+        }
+        if (sawEof && !skippingOversizedLine && carry.length === 0 && consumed > 0) {
+            const after = await handle.stat();
+            if (after.isFile() && after.size === consumed &&
+                qualitativeFileIdentity(after) === selectionIdentity) {
+                return await completeStreamedRollout(candidate, context, state, collector, consumed, entrySinceIso, runSinceIso);
+            }
+            // The rollout changed while streaming (an active append): keep the
+            // checkpoint at the last complete line and withhold the entry.
+        }
+        if (consumed > offset || (consumed > 0 && !candidate.checkpoint)) {
+            await writeStreamCheckpointAt(candidate, context, handle, state, collector, consumed, entrySinceIso);
+        }
+        return undefined;
+    }
+    catch {
+        // Unreadable mid-stream: no claim this run; selection re-treats the file
+        // as skipped and the ledger keeps it blocking.
+        return undefined;
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+}
+async function writeStreamCheckpointAt(candidate, context, handle, state, collector, consumed, entrySinceIso) {
+    const scan = context.scan;
+    const probeBytes = Math.min(codexStreamPrefixProbeBytes, consumed);
+    const probe = Buffer.allocUnsafe(probeBytes);
+    let probeRead = 0;
+    while (probeRead < probeBytes) {
+        const read = await handle.read(probe, probeRead, probeBytes - probeRead, consumed - probeBytes + probeRead);
+        if (read.bytesRead === 0)
+            break;
+        probeRead += read.bytesRead;
+    }
+    if (probeRead !== probeBytes) {
+        scan.qualitativeIndexErrors = (scan.qualitativeIndexErrors ?? 0) + 1;
+        return;
+    }
+    try {
+        await context.streamCheckpoints.writeStreamCheckpoint("codex", candidate.pathHash, {
+            pin: {
+                dev: candidate.file.dev,
+                ino: candidate.file.ino,
+                birthtimeMs: candidate.file.birthtimeMs
+            },
+            parserVersion: localAgentQualitativeParserVersion,
+            collectInvocationEvidence: context.collectInvocationEvidence,
+            sinceIso: entrySinceIso,
+            offset: consumed,
+            prefixProbe: {
+                bytes: probeBytes,
+                sha256: createHash("sha256").update(probe).digest("hex")
+            },
+            reducerState: serializeCodexReducerState(state),
+            ...(collector ? { collectorState: collector.snapshot() } : {})
+        });
+    }
+    catch {
+        scan.qualitativeIndexErrors = (scan.qualitativeIndexErrors ?? 0) + 1;
+    }
+}
+async function completeStreamedRollout(candidate, context, state, collector, consumed, entrySinceIso, runSinceIso) {
+    const scan = context.scan;
+    const fileDiagnostics = [];
+    const calls = finishCodexRolloutParse(state, (diagnostic) => fileDiagnostics.push(diagnostic));
+    const invocationFile = collector?.finish();
+    const invocationWindowProof = collector?.windowProof();
+    const stored = {
+        calls,
+        ...(invocationFile ? { invocationFile } : {}),
+        ...(collector ? { invocationWindowProof } : {}),
+        diagnostics: fileDiagnostics
+    };
+    assertFormatCallOwnership(context.descriptor, stored.calls);
+    assertInvocationOwnership(context.descriptor, stored.invocationFile, context.collectInvocationEvidence);
+    const entryKey = {
+        schemaVersion: 1,
+        parserVersion: localAgentQualitativeParserVersion,
+        agent: "codex",
+        pathHash: candidate.pathHash,
+        fileIdentity: qualitativeFileIdentity(candidate.file),
+        sinceIso: entrySinceIso,
+        collectInvocationEvidence: context.collectInvocationEvidence
+    };
+    let entryPersisted = false;
+    try {
+        await context.qualitativeIndex.write(entryKey, stored);
+        entryPersisted = true;
+    }
+    catch {
+        scan.qualitativeIndexErrors = (scan.qualitativeIndexErrors ?? 0) + 1;
+    }
+    if (entryPersisted) {
+        // Only a durably indexed file may drop its resumable state.
+        await context.streamCheckpoints.deleteStreamCheckpoint("codex", candidate.pathHash)
+            .catch(() => undefined);
+    }
+    void consumed;
+    // The stored entry carries the pinned collector window. This run may have
+    // requested a newer window; aggregated invocation evidence is used in-run
+    // only when it narrows exactly, otherwise this run honestly reports
+    // partial coverage while the calls (window-blind, filtered by timestamp
+    // downstream) remain exact.
+    if (stored.invocationFile && entrySinceIso !== runSinceIso &&
+        !streamedInvocationNarrowsExactly(entrySinceIso, runSinceIso, stored)) {
+        scan.qualitativeCoverage = "partial";
+        const { invocationFile: _omitted, invocationWindowProof: _proof, ...rest } = stored;
+        return { ...rest };
+    }
+    return stored;
+}
+/**
+ * In-run mirror of the store's `invocationWindowCanBeNarrowedExactly` for a
+ * freshly completed stream whose collector window predates this run's
+ * request (the loader cannot import the store module).
+ */
+function streamedInvocationNarrowsExactly(pinnedSinceIso, runSinceIso, value) {
+    if (pinnedSinceIso === runSinceIso)
+        return true;
+    if (runSinceIso === null)
+        return false;
+    if (pinnedSinceIso !== null && Date.parse(pinnedSinceIso) > Date.parse(runSinceIso)) {
+        return false;
+    }
+    const invocation = value.invocationFile;
+    if (!invocation)
+        return false;
+    const proof = value.invocationWindowProof;
+    if (!proof || !proof.allCountedEventsTimestamped)
+        return false;
+    const hasCountedEvidence = invocation.assistantTurns > 0 ||
+        invocation.contextSignal.compactionEvents > 0 ||
+        invocation.invocations.length > 0 ||
+        invocation.invokedMcpTools.length > 0 ||
+        invocation.invokedSkills.length > 0 ||
+        invocation.invokedSubagents.length > 0 ||
+        invocation.invokedCommands.length > 0 ||
+        invocation.contextSignal.fileReads.length > 0 ||
+        invocation.contextSignal.repeatedFileReads.length > 0;
+    if (!hasCountedEvidence)
+        return proof.earliestCountedAt === undefined;
+    if (proof.earliestCountedAt === undefined)
+        return false;
+    return Date.parse(proof.earliestCountedAt) >= Date.parse(runSinceIso);
+}
+function qualitativeIndexKey(agent, filePath, metadata, sinceMs, collectInvocationEvidence) {
+    return {
+        schemaVersion: 1,
+        parserVersion: localAgentQualitativeParserVersion,
+        agent,
+        pathHash: createHash("sha256").update(resolve(filePath)).digest("hex"),
+        fileIdentity: qualitativeFileIdentity(metadata),
+        sinceIso: typeof sinceMs === "number" ? new Date(sinceMs).toISOString() : null,
+        collectInvocationEvidence
+    };
+}
+function qualitativeFileIdentity(metadata) {
+    return [
+        metadata.dev,
+        metadata.ino,
+        metadata.size,
+        metadata.mtimeMs,
+        metadata.ctimeMs,
+        metadata.birthtimeMs
+    ].join(":");
+}
+async function qualitativeIndexKeyStillCurrent(filePath, key) {
+    try {
+        const current = await lstat(filePath);
+        return current.isFile() && !current.isSymbolicLink() &&
+            qualitativeFileIdentity(current) === key.fileIdentity;
+    }
+    catch {
+        return false;
+    }
+}
+function isQualitativeIndexValue(value, descriptor, collectInvocationEvidence) {
+    if (!isRecord(value) || !Array.isArray(value.calls) ||
+        !Array.isArray(value.diagnostics)) {
+        return false;
+    }
+    const calls = value.calls;
+    if (!calls.every((call) => isIndexedLocalAgentCall(call, descriptor.id))) {
+        return false;
+    }
+    const diagnostics = value.diagnostics;
+    if (!diagnostics.every((entry) => (isRecord(entry) &&
+        (entry.code === "malformed_jsonl" ||
+            entry.code === "malformed_session_file" ||
+            entry.code === "unsupported_token_shape") &&
+        Number.isSafeInteger(entry.count) && Number(entry.count) > 0))) {
+        return false;
+    }
+    const invocationFile = value.invocationFile;
+    try {
+        assertInvocationOwnership(descriptor, invocationFile, collectInvocationEvidence);
+    }
+    catch {
+        return false;
+    }
+    return true;
+}
+function isIndexedLocalAgentCall(value, agent) {
+    if (!isRecord(value) || value.agent !== agent ||
+        typeof value.model !== "string" || value.model.length === 0 ||
+        typeof value.timestamp !== "string" || !Number.isFinite(Date.parse(value.timestamp))) {
+        return false;
+    }
+    const usage = value.usage;
+    if (!isRecord(usage))
+        return false;
+    const tokenFields = [
+        "inputTokens",
+        "outputTokens",
+        "cacheReadTokens",
+        "cacheWrite5mTokens",
+        "cacheWrite1hTokens",
+        "thoughtTokens",
+        "toolTokens"
+    ];
+    return tokenFields.every((field) => {
+        const tokenValue = usage[field];
+        if (field === "inputTokens" || field === "outputTokens") {
+            return Number.isSafeInteger(tokenValue) && Number(tokenValue) >= 0;
+        }
+        return tokenValue === undefined ||
+            Number.isSafeInteger(tokenValue) && Number(tokenValue) >= 0;
+    });
+}
+async function readBoundedUtf8File(filePath, maxBytes, expectedIdentity) {
+    // Open the selected inode itself without following a last-moment link. The
+    // metadata snapshot used for selection is then checked on the descriptor,
+    // not on the path, both before and after reading. This prevents a path swap
+    // from turning an out-of-root or actively rewritten file into "complete"
+    // qualitative evidence.
+    const handle = await open(filePath, constants.O_RDONLY | constants.O_NOFOLLOW);
+    const chunks = [];
+    let bytesRead = 0;
+    try {
+        const before = await handle.stat();
+        if (!before.isFile() || qualitativeFileIdentity(before) !== expectedIdentity) {
+            throw newErrorWithCode("ESTALE");
+        }
+        const chunk = Buffer.allocUnsafe(Math.min(64 * 1024, maxBytes + 1));
+        while (true) {
+            const remainingWithSentinel = maxBytes - bytesRead + 1;
+            const length = Math.min(chunk.length, remainingWithSentinel);
+            const read = await handle.read(chunk, 0, length, null);
+            if (read.bytesRead === 0)
+                break;
+            bytesRead += read.bytesRead;
+            if (bytesRead > maxBytes) {
+                throw new QualitativeReadLimitError();
+            }
+            chunks.push(Buffer.from(chunk.subarray(0, read.bytesRead)));
+        }
+        const after = await handle.stat();
+        if (!after.isFile() || qualitativeFileIdentity(after) !== expectedIdentity) {
+            throw newErrorWithCode("ESTALE");
+        }
+    }
+    finally {
+        await handle.close();
+    }
+    return {
+        content: Buffer.concat(chunks, bytesRead).toString("utf8"),
+        bytesRead
+    };
+}
+function recordQualitativeBudgetSkip(scan) {
+    scan.qualitativeCoverage = "partial";
+    scan.qualitativeFilesSkippedForBudget =
+        (scan.qualitativeFilesSkippedForBudget ?? 0) + 1;
+}
+function finishQualitativeCoverage(scan, diagnostics) {
+    if (scan.directoryStatus === "unreadable" || scan.unreadableFiles > 0) {
+        scan.qualitativeCoverage = "partial";
+    }
+    // Per-project ledger (BLOCKER-1 semantics, fail closed). An unparsed
+    // eligible file blocks unless the bounded header pass proved it belongs to
+    // a project other than the requested one; a file proven to belong to the
+    // requested project itself keeps blocking until indexed (design section d:
+    // it is the oversized relevant transcript, never an exclusion).
+    const eligible = scan.qualitativeFilesEligible ?? 0;
+    const indexed = Math.min(eligible, scan.qualitativeFilesReadCompletely ?? 0);
+    scan.qualitativeFilesIndexed = indexed;
+    const foreignProven = scan.qualitativeFilesForeignProven ?? 0;
+    scan.qualitativeFilesOwnershipUnknown = Math.max(0, eligible - indexed - foreignProven);
+    // A missing directory is an absent agent, not a failure; only unreadable
+    // state, unreadable files, or index errors force the fail-closed state.
+    const scanFailure = scan.directoryStatus === "unreadable" || scan.unreadableFiles > 0 ||
+        (scan.qualitativeIndexErrors ?? 0) > 0;
+    scan.qualitativeProjectCoverage =
+        !scanFailure && scan.qualitativeFilesOwnershipUnknown === 0
+            ? "complete"
+            : "indexing";
+    const indexErrors = scan.qualitativeIndexErrors ?? 0;
+    if (indexErrors > 0) {
+        diagnostics.push({
+            agent: scan.agent,
+            code: "qualitative_index_error",
+            severity: "warning",
+            message: `${agentLabel(scan.agent)} private index had ${indexErrors} read/write failure(s); project coverage is rebuilding. If this persists after several runs, a newer aibill version may own the index.`,
+            count: indexErrors
+        });
+    }
+    const skipped = scan.qualitativeFilesSkippedForBudget ?? 0;
+    if (skipped > 0) {
+        diagnostics.push({
+            agent: scan.agent,
+            code: "qualitative_scan_incomplete",
+            severity: "warning",
+            message: `${agentLabel(scan.agent)} qualitative coverage is partial: ${skipped} eligible transcript file(s) exceeded the configured scan limits. No omitted file contributed an action finding.`,
+            count: skipped
+        });
+    }
+}
 function financialSourceScan(descriptor) {
     const scan = {
         ...emptySourceScan(descriptor.id),
@@ -1317,6 +3044,30 @@ function newErrorWithCode(code) {
     error.code = code;
     return error;
 }
+function claudeNativeResponseIdentity(message, entry) {
+    const rawMessageId = stringOf(message.id);
+    const rawRequestId = stringOf(entry.requestId);
+    // Never weaken a two-part native identity by silently dropping one
+    // attacker-sized component; without the exact bounded pair there is no
+    // cross-file deduplication proof.
+    if ((rawMessageId && rawMessageId.length > 4_096) ||
+        (rawRequestId && rawRequestId.length > 4_096)) {
+        return undefined;
+    }
+    const messageId = rawMessageId || undefined;
+    const requestId = rawRequestId || undefined;
+    if (!messageId && !requestId)
+        return undefined;
+    const localDedupeKey = JSON.stringify([messageId ?? null, requestId ?? null]);
+    return {
+        localDedupeKey,
+        callId: `callref_${createHash("sha256")
+            .update("claude-native-response-v1")
+            .update("\u0000")
+            .update(localDedupeKey)
+            .digest("hex")}`
+    };
+}
 function parseClaudeFinancialEntry(entry, filePath, sinceMs, seen, onDiagnostic) {
     if (entry.type !== "assistant")
         return undefined;
@@ -1324,10 +3075,11 @@ function parseClaudeFinancialEntry(entry, filePath, sinceMs, seen, onDiagnostic)
     const usage = message && isRecord(message.usage) ? message.usage : undefined;
     if (!message || !usage || stringOf(message.model) === "<synthetic>")
         return undefined;
-    const dedupeKey = `${stringOf(message.id) ?? ""}:${stringOf(entry.requestId) ?? ""}`;
-    if (dedupeKey !== ":" && seen.has(dedupeKey))
+    const nativeResponse = claudeNativeResponseIdentity(message, entry);
+    if (nativeResponse && seen.has(nativeResponse.localDedupeKey))
         return undefined;
-    seen.add(dedupeKey);
+    if (nativeResponse)
+        seen.add(nativeResponse.localDedupeKey);
     const timestamp = toIso(stringOf(entry.timestamp)) ?? new Date(0).toISOString();
     if (typeof sinceMs === "number" && Date.parse(timestamp) < sinceMs)
         return undefined;
@@ -1335,11 +3087,13 @@ function parseClaudeFinancialEntry(entry, filePath, sinceMs, seen, onDiagnostic)
     const workingDirectory = absoluteWorkingDirectory(stringOf(entry.cwd));
     return {
         agent: "claude-code",
+        ...(nativeResponse ? { callId: nativeResponse.callId } : {}),
         model: stringOf(message.model) ?? "claude-code",
         timestamp,
         project: projectFromCwd(workingDirectory) ?? projectFromTranscriptPath(filePath),
         workingDirectory,
         sessionId: stringOf(entry.sessionId),
+        ...(stringOf(entry.version) ? { sourceVersion: stringOf(entry.version) } : {}),
         ...(parsedUsage.latestTurnUsage
             ? { latestTurnUsage: parsedUsage.latestTurnUsage }
             : {}),
@@ -1348,6 +3102,9 @@ function parseClaudeFinancialEntry(entry, filePath, sinceMs, seen, onDiagnostic)
         ...(parsedUsage.reportedTotalTokens !== undefined
             ? { reportedTotalTokens: parsedUsage.reportedTotalTokens }
             : {}),
+        ...(parsedUsage.tokenComponentEvidence
+            ? { tokenComponentEvidence: parsedUsage.tokenComponentEvidence }
+            : {}),
         usage: parsedUsage.usage
     };
 }
@@ -1363,6 +3120,7 @@ function consumeCodexFinancialEntry(state, entry) {
     if (entry.type === "session_meta" && payload && !state.rootSessionMetaSeen) {
         state.rootSessionMetaSeen = true;
         state.sessionId = stringOf(payload.id);
+        state.sourceVersion = stringOf(payload.cli_version);
         state.rootCwd = stringOf(payload.cwd);
         state.startedAt = toIso(stringOf(payload.timestamp) ?? stringOf(entry.timestamp));
         state.rootStartedAtMs = timestampMilliseconds(payload.timestamp ?? entry.timestamp);
@@ -1431,6 +3189,7 @@ function finishCodexFinancialStream(state, onDiagnostic) {
         project: projectFromCwd(workingDirectory),
         workingDirectory,
         sessionId: state.sessionId,
+        ...(state.sourceVersion ? { sourceVersion: state.sourceVersion } : {}),
         rateLimits: state.lastRateLimits,
         ...(usageSupport === "complete" && parsedTurn.usage
             ? { latestTurnUsage: parsedTurn.usage }
@@ -1440,6 +3199,9 @@ function finishCodexFinancialStream(state, onDiagnostic) {
         ...(parsedUsage.reportedTotalTokens !== undefined
             ? { reportedTotalTokens: parsedUsage.reportedTotalTokens }
             : {}),
+        ...(usageSupport === "complete" && parsedUsage.tokenComponentEvidence
+            ? { tokenComponentEvidence: parsedUsage.tokenComponentEvidence }
+            : {}),
         usage: parsedUsage.usage
     };
 }
@@ -1745,6 +3507,35 @@ function projectFromTranscriptPath(filePath) {
     const tail = parent.split("-").filter(Boolean).pop();
     return tail && tail.length > 0 ? tail : undefined;
 }
+/**
+ * Parse the host-framed task-notification a background subagent's completion
+ * writes into the owning transcript. Only the leading host template tags are
+ * read (first match): the trailing `<result>` section is model output and is
+ * never trusted or retained. The same task-id may notify more than once for
+ * a resumed run; callers keep the latest record and the session-vitals join
+ * still requires the record to postdate the run's last observed activity.
+ */
+function parseTaskNotification(content) {
+    if (!content || !content.startsWith("<task-notification>"))
+        return undefined;
+    const taskId = /<task-id>([A-Za-z0-9._-]{1,128})<\/task-id>/.exec(content)?.[1];
+    const status = /<status>([a-z_-]{1,64})<\/status>/.exec(content)?.[1];
+    return taskId && status ? { taskId, status } : undefined;
+}
+/**
+ * Fallback subagent-run identity from the `subagents/agent-<id>.jsonl` file
+ * name, for subagent transcripts whose lines omit `agentId`. Never derived
+ * for files outside a `subagents` directory, and never a path (one validated
+ * basename segment only).
+ */
+function subagentTranscriptFileId(filePath) {
+    const segments = filePath.split(sep);
+    if (!segments.includes("subagents"))
+        return undefined;
+    const base = segments.at(-1) ?? "";
+    const name = base.endsWith(".jsonl") ? base.slice(0, -".jsonl".length) : base;
+    return /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(name) ? name : undefined;
+}
 function localActivityScopeKey(sessionId, workingDirectory, project) {
     // The absolute cwd stays inside this ephemeral parser key and is never
     // persisted or rendered. It prevents one transcript that changes projects
@@ -1821,11 +3612,11 @@ function buildLocalAgentActivity(input) {
         kind,
         action,
         source,
-        promptCount: prompts.length,
+        promptCount: prompts.length + (input.priorPromptCount ?? 0),
         toolCallCount: input.toolCallCount,
         files,
         isSubagent: input.isSubagent,
-        parentSessionId: input.parentSessionId
+        ...(input.parentSessionId ? { parentSessionId: input.parentSessionId } : {})
     };
 }
 function focusTopic(prompts) {
@@ -1978,11 +3769,19 @@ function promptTokens(value) {
         .map((token) => token.replace(/^[.-]+|[.-]+$/g, ""))
         .filter((token) => token.length >= 2 && token !== "cz" && !/^\d+$/.test(token));
 }
+/**
+ * Strip absolute-path spans (including file:// forms) from free text. Shared
+ * by topic derivation and by checkpoint prompt persistence: persisted prompt
+ * survivors must never carry a raw local path (req 1).
+ */
+function stripAbsolutePathSpans(value) {
+    return value.replace(/(^|[\s("'=:])(?:file:\/\/)?\/[^\s)"']+/g, "$1");
+}
 function topicTokens(value) {
     // Absolute paths often appear in attached-image metadata and tool-oriented
     // prompts. They are machine context, not the user's work topic, and can
     // otherwise outrank meaningful words when only one recent prompt exists.
-    const withoutAbsolutePaths = value.replace(/(^|[\s("'=:])(?:file:\/\/)?\/[^\s)"']+/g, "$1")
+    const withoutAbsolutePaths = stripAbsolutePathSpans(value)
         .replace(/\b[^\s/\\]+\.(?:png|jpe?g|gif|webp|heic|svg|pdf|mov|mp4)\b/gi, " ")
         .replace(/\b(?:attached|attachment|clipboard|image|images|photo|picture|screenshot|screenshots)\b/gi, " ");
     return promptTokens(sanitizeLocalActivityText(withoutAbsolutePaths));