sidekick-shared 0.29.0 → 0.29.1

package/dist/esm/parsers/codexParser.js

@@ -171,6 +171,61 @@ export function extractPatchFilePaths(input) {
 }
 /** Default cap on each piece of per-call correlation state the parser keeps. */
 export const DEFAULT_MAX_TRACKED_TOOL_CALLS = 4096;
+/** Entries per table {@link CodexRolloutParser.exportResumeState} keeps by default. */
+const DEFAULT_RESUME_STATE_LIMIT = 256;
+function isPlainObject(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function cloneJson(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function isOptionalString(value) {
+    return value === undefined || typeof value === 'string';
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === 'string');
+}
+function isTokenCount(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0;
+}
+/** A valid `CodexTokenUsage` (copied), `null` for `null`, or `undefined` when invalid. Internal. */
+export function codexTokenUsageFrom(value) {
+    if (value === null)
+        return null;
+    if (!isPlainObject(value))
+        return undefined;
+    if (!isTokenCount(value.input_tokens) || !isTokenCount(value.output_tokens))
+        return undefined;
+    const usage = {
+        input_tokens: value.input_tokens,
+        output_tokens: value.output_tokens,
+    };
+    for (const field of ['cached_input_tokens', 'reasoning_output_tokens', 'total_tokens']) {
+        const count = value[field];
+        if (count === undefined)
+            continue;
+        if (!isTokenCount(count))
+            return undefined;
+        usage[field] = count;
+    }
+    return usage;
+}
+/** Last `limit` items of an insertion-ordered collection, oldest first. */
+function newest(items, size, limit) {
+    const count = limit >= 0 ? Math.min(size, Math.floor(limit)) : 0;
+    const kept = [];
+    let skip = size - count;
+    for (const item of items) {
+        if (kept.length >= count)
+            break;
+        if (skip > 0) {
+            skip -= 1;
+            continue;
+        }
+        kept.push(item);
+    }
+    return kept;
+}
 /** Fixed per-entry cost added to each pending call's byte estimate. */
 const PENDING_ENTRY_OVERHEAD_BYTES = 64;
 /** Prefix of the bookkeeping keys the parser stashes inside tool inputs. */
@@ -282,6 +337,118 @@ export class CodexRolloutParser {
     getLastRateLimits() {
         return this.lastRateLimits;
     }
+    /**
+     * The state later lines depend on — session metadata, current model,
+     * previous cumulative token total, context window, rate limits, plan mode,
+     * and the tool-call correlation tables (newest `limit` entries each) — as
+     * JSON-serializable data. Eviction counters are not included.
+     */
+    exportResumeState(limit = DEFAULT_RESUME_STATE_LIMIT) {
+        return cloneJson({
+            version: 1,
+            sessionMeta: this.sessionMeta,
+            currentModel: this.currentModel,
+            prevTotalUsage: this.prevTotalUsage,
+            lastTokenUsage: this.lastTokenUsage,
+            modelContextWindow: this.modelContextWindow,
+            lastRateLimits: this.lastRateLimits,
+            hasAggregateRateLimits: this.hasAggregateRateLimits,
+            inPlanMode: this.inPlanMode,
+            emittedToolUseIds: newest(this.emittedToolUseIds, this.emittedToolUseIds.size, limit),
+            patchExpandedToolUseIds: newest(this.patchExpandedToolUseIds, this.patchExpandedToolUseIds.size, limit),
+            pendingExecCommands: newest(this.pendingExecCommands.values(), this.pendingExecCommands.size, limit),
+            pendingMcpToolCalls: newest(this.pendingMcpToolCalls.values(), this.pendingMcpToolCalls.size, limit),
+        });
+    }
+    /**
+     * Replaces this parser's state with one from {@link exportResumeState}, as
+     * if it had parsed the rollout up to where that state was taken. Returns
+     * false, changing nothing, when `state` is not a valid version-1 state.
+     * This parser's own `maxTrackedToolCalls`, `maxPendingBytes`, and
+     * `metadataOnly` options apply to the imported tables.
+     */
+    importResumeState(state) {
+        if (!isPlainObject(state) || state.version !== 1)
+            return false;
+        const s = state;
+        const prevTotalUsage = codexTokenUsageFrom(s.prevTotalUsage);
+        const lastTokenUsage = codexTokenUsageFrom(s.lastTokenUsage);
+        if (prevTotalUsage === undefined || lastTokenUsage === undefined)
+            return false;
+        if (s.sessionMeta !== null && !isPlainObject(s.sessionMeta))
+            return false;
+        if (s.lastRateLimits !== null && !isPlainObject(s.lastRateLimits))
+            return false;
+        if (s.currentModel !== null && typeof s.currentModel !== 'string')
+            return false;
+        const contextWindow = s.modelContextWindow;
+        if (contextWindow !== null &&
+            !(typeof contextWindow === 'number' && Number.isFinite(contextWindow) && contextWindow > 0)) {
+            return false;
+        }
+        if (typeof s.hasAggregateRateLimits !== 'boolean' || typeof s.inPlanMode !== 'boolean') {
+            return false;
+        }
+        if (!isStringArray(s.emittedToolUseIds))
+            return false;
+        const patches = s.patchExpandedToolUseIds;
+        if (!Array.isArray(patches) ||
+            !patches.every((entry) => Array.isArray(entry) &&
+                entry.length === 2 &&
+                typeof entry[0] === 'string' &&
+                isStringArray(entry[1]))) {
+            return false;
+        }
+        const execs = s.pendingExecCommands;
+        if (!Array.isArray(execs) ||
+            !execs.every((entry) => isPlainObject(entry) &&
+                typeof entry.call_id === 'string' &&
+                isStringArray(entry.command) &&
+                isOptionalString(entry.workdir) &&
+                typeof entry.timestamp === 'string')) {
+            return false;
+        }
+        const mcps = s.pendingMcpToolCalls;
+        if (!Array.isArray(mcps) ||
+            !mcps.every((entry) => isPlainObject(entry) &&
+                typeof entry.call_id === 'string' &&
+                typeof entry.tool_name === 'string' &&
+                isOptionalString(entry.server_name) &&
+                (entry.arguments === undefined || isPlainObject(entry.arguments)) &&
+                typeof entry.timestamp === 'string')) {
+            return false;
+        }
+        const copy = cloneJson({
+            sessionMeta: s.sessionMeta,
+            lastRateLimits: s.lastRateLimits,
+            patches: patches,
+            execs: execs,
+            mcps: mcps,
+        });
+        this.reset();
+        this.sessionMeta = copy.sessionMeta;
+        this.currentModel = s.currentModel;
+        this.prevTotalUsage = prevTotalUsage;
+        this.lastTokenUsage = lastTokenUsage;
+        this.modelContextWindow = contextWindow;
+        this.lastRateLimits = copy.lastRateLimits;
+        this.hasAggregateRateLimits = s.hasAggregateRateLimits;
+        this.inPlanMode = s.inPlanMode;
+        for (const id of s.emittedToolUseIds) {
+            rememberBounded(this.emittedToolUseIds, id, this.maxTrackedToolCalls);
+        }
+        for (const [callId, toolUseIds] of copy.patches)
+            this.putPendingPatch(callId, toolUseIds);
+        for (const pending of copy.execs) {
+            this.putPendingExec(this.metadataOnly
+                ? { call_id: pending.call_id, command: [], timestamp: pending.timestamp }
+                : pending);
+        }
+        for (const pending of copy.mcps) {
+            this.putPendingMcp(this.metadataOnly ? { ...pending, arguments: undefined } : pending);
+        }
+        return true;
+    }
     /**
      * Converts a single rollout line to zero or more session events.
      */
@@ -353,6 +520,16 @@ export class CodexRolloutParser {
             this.evictedByBytes += 1;
         }
     }
+    putPendingExec(pending) {
+        this.putPending(this.pendingExecCommands, pending.call_id, pending, () => stringBytes(pending.call_id, pending.workdir, pending.timestamp, ...(Array.isArray(pending.command) ? pending.command : [])));
+    }
+    putPendingMcp(pending) {
+        this.putPending(this.pendingMcpToolCalls, pending.call_id, pending, () => stringBytes(pending.call_id, pending.server_name, pending.tool_name, pending.timestamp) +
+            approxJsonBytes(pending.arguments));
+    }
+    putPendingPatch(callId, toolUseIds) {
+        this.putPending(this.patchExpandedToolUseIds, callId, toolUseIds, () => stringBytes(callId, ...toolUseIds));
+    }
     /** Removes and returns a pending call. */
     takePending(table, callId) {
         const value = table.get(callId);
@@ -582,7 +759,7 @@ export class CodexRolloutParser {
             if (filePaths.length === 0)
                 return [];
             const toolUseIds = filePaths.map((fp) => `${item.call_id}-${fp}`);
-            this.putPending(this.patchExpandedToolUseIds, item.call_id, toolUseIds, () => stringBytes(item.call_id, ...toolUseIds));
+            this.putPendingPatch(item.call_id, toolUseIds);
             for (const id of toolUseIds) {
                 rememberBounded(this.emittedToolUseIds, id, this.maxTrackedToolCalls);
             }
@@ -732,7 +909,7 @@ export class CodexRolloutParser {
                 const pending = this.metadataOnly
                     ? { call_id: e.call_id, command: [], timestamp }
                     : { call_id: e.call_id, command: e.command, workdir: e.workdir, timestamp };
-                this.putPending(this.pendingExecCommands, e.call_id, pending, () => stringBytes(pending.call_id, pending.workdir, pending.timestamp, ...(Array.isArray(pending.command) ? pending.command : [])));
+                this.putPendingExec(pending);
                 return [];
             }
             case 'exec_command_end': {
@@ -795,8 +972,7 @@ export class CodexRolloutParser {
                     arguments: this.metadataOnly ? undefined : e.arguments,
                     timestamp,
                 };
-                this.putPending(this.pendingMcpToolCalls, e.call_id, pending, () => stringBytes(pending.call_id, pending.server_name, pending.tool_name, timestamp) +
-                    approxJsonBytes(pending.arguments));
+                this.putPendingMcp(pending);
                 return [];
             }
             case 'mcp_tool_call_end': {

package/dist/esm/parsers/openCodeParser.js

@@ -11,6 +11,7 @@
  * @module parsers/openCodeParser
  */
 import { normalizeProviderUsage } from '../usageNormalization';
+import { ownValue } from '../ownKey';
 /**
  * OpenCode → Claude Code tool name mapping.
  * OpenCode uses lowercase names; downstream code expects PascalCase.
@@ -46,7 +47,7 @@ export function normalizeToolName(name) {
     if (!name)
         return name;
     // Check mapping (case-insensitive lookup via lowercase key)
-    const mapped = TOOL_NAME_MAP[name.toLowerCase()];
+    const mapped = ownValue(TOOL_NAME_MAP, name.toLowerCase());
     if (mapped)
         return mapped;
     // Already PascalCase (starts with uppercase)? Pass through.

package/dist/esm/parsers/subagentScanner.js

@@ -12,28 +12,49 @@ import * as path from 'path';
 import { ClaudeUsageDeduper, dedupedRawClaudeUsage } from '../usage/claudeUsageDedupe';
 import { addUsageToSubagent } from '../usage/subagentUsage';
 import { cachedSubagentStats } from './subagentStatsCache';
+import { isSubagentSpawnTool } from '../subagentSpawn';
 /**
  * Pattern for matching subagent JSONL files.
  * Files are named like: agent-<hash>.jsonl
  */
 const AGENT_FILE_PATTERN = /^agent-(.+)\.jsonl$/;
+function metaString(value) {
+    return typeof value === 'string' && value ? value : undefined;
+}
 /**
  * Reads `agent-<id>.meta.json` (written by Claude Code next to the transcript)
- * for the spawn's agent type and description. Missing or malformed files
- * yield an empty object.
+ * for the spawn's agent type, description, spawning tool_use id, parent agent,
+ * and completion flags. Missing or malformed files yield an empty object;
+ * wrongly typed fields are left out.
  */
 export function readAgentMeta(agentFilePath) {
     try {
         const metaPath = agentFilePath.replace(/\.jsonl$/, '.meta.json');
         const parsed = JSON.parse(fs.readFileSync(metaPath, 'utf-8'));
-        return {
-            ...(typeof parsed.agentType === 'string' && parsed.agentType
-                ? { agentType: parsed.agentType }
-                : {}),
-            ...(typeof parsed.description === 'string' && parsed.description
-                ? { description: parsed.description }
-                : {}),
-        };
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+            return {};
+        const record = parsed;
+        const meta = {};
+        const agentType = metaString(record.agentType);
+        if (agentType)
+            meta.agentType = agentType;
+        const description = metaString(record.description);
+        if (description)
+            meta.description = description;
+        const toolUseId = metaString(record.toolUseId);
+        if (toolUseId)
+            meta.toolUseId = toolUseId;
+        const parentAgentId = metaString(record.parentAgentId);
+        if (parentAgentId)
+            meta.parentAgentId = parentAgentId;
+        const requestShape = metaString(record.requestShape);
+        if (requestShape)
+            meta.requestShape = requestShape;
+        if (typeof record.finished === 'boolean')
+            meta.finished = record.finished;
+        if (typeof record.stoppedByUser === 'boolean')
+            meta.stoppedByUser = record.stoppedByUser;
+        return meta;
     }
     catch {
         return {};
@@ -208,8 +229,8 @@ function parseAgentFile(filePath, agentId, log) {
                                 }
                             }
                             toolCalls.push(toolCall);
-                            // If this is a Task tool call (spawning another subagent), extract info
-                            if (toolUse.name === 'Task' && toolUse.input) {
+                            // If this is an Agent/Task call (spawning another subagent), extract info
+                            if (isSubagentSpawnTool(toolUse.name) && toolUse.input) {
                                 if (toolUse.input.subagent_type && !agentType) {
                                     agentType = String(toolUse.input.subagent_type);
                                 }

package/dist/esm/parsers/subagentTraceParser.js

@@ -5,10 +5,13 @@
  * (not just stats) for drill-down trace visualization. Applies noise classification
  * and tool summary formatting from the formatters module.
  *
- * Three-phase parent-child linking:
- * 1. Result-based: match toolUseResult.agentId → parent tool_use_id
- * 2. Team summary: parse <teammate-message> XML blocks
- * 3. Positional fallback: timestamp ordering + proximity
+ * Parent-child linking, exact links first:
+ * 1. Meta `parentAgentId` (Claude Code writes it for nested spawns)
+ * 2. The child's spawning tool_use id (meta `toolUseId`) found in another
+ *    trace's `Agent` / `Task` calls
+ * Only traces without that spawn metadata (older Claude Code) fall back to:
+ * 3. Team summary: parse <teammate-message> XML blocks
+ * 4. Positional fallback: timestamp ordering + proximity
  *
  * @module parsers/subagentTraceParser
  */
@@ -19,6 +22,8 @@ import { isHardNoise, classifyMessage, getSoftNoiseReason } from '../formatters/
 import { ClaudeUsageDeduper, dedupedRawClaudeUsage } from '../usage/claudeUsageDedupe';
 import { addUsageToSubagent } from '../usage/subagentUsage';
 import { readAgentMeta } from './subagentScanner';
+import { isSubagentSpawnTool } from '../subagentSpawn';
+import { ownValue } from '../ownKey';
 // ── Constants ──
 const AGENT_FILE_PATTERN = /^agent-(.+)\.jsonl$/;
 // ── Public API ──
@@ -50,10 +55,8 @@ export function scanSubagentTraces(sessionDir, sessionId) {
             if (trace)
                 traces.push(trace);
         }
-        // Link parent-child relationships
-        linkTraces(traces);
-        // Return only top-level traces (those without parents)
-        return traces.filter((t) => !t.parentToolUseId);
+        // Link parent-child relationships; returns the traces with no parent agent.
+        return linkTraces(traces);
     }
     catch {
         return [];
@@ -133,8 +136,8 @@ function parseAgentTrace(filePath, agentId) {
                                 input: block.input || {},
                                 timestamp,
                             });
-                            // Extract agent info from Task tool
-                            if (block.name === 'Task' && block.input) {
+                            // Extract agent info from an Agent/Task spawn
+                            if (isSubagentSpawnTool(block.name) && block.input) {
                                 if (block.input.subagent_type && !agentType) {
                                     agentType = String(block.input.subagent_type);
                                 }
@@ -171,6 +174,14 @@ function parseAgentTrace(filePath, agentId) {
             agentId,
             agentType,
             description,
+            filePath,
+            ...(meta.toolUseId
+                ? { spawnToolUseId: meta.toolUseId, parentToolUseId: meta.toolUseId }
+                : {}),
+            ...(meta.parentAgentId ? { parentAgentId: meta.parentAgentId } : {}),
+            ...(meta.requestShape ? { background: meta.requestShape === 'background' } : {}),
+            ...(meta.finished !== undefined ? { finished: meta.finished } : {}),
+            ...(meta.stoppedByUser !== undefined ? { stoppedByUser: meta.stoppedByUser } : {}),
             events,
             children: [],
             stats: {
@@ -195,23 +206,61 @@ function parseAgentTrace(filePath, agentId) {
     }
 }
 // ── Parent-Child Linking ──
+/**
+ * Nests child traces under their parents and returns the traces with no
+ * parent agent. Exact metadata links come first; the heuristics only place
+ * traces Claude Code recorded no spawn metadata for.
+ */
 function linkTraces(traces) {
     const traceById = new Map();
     for (const trace of traces) {
         traceById.set(trace.agentId, trace);
     }
-    // Phase 1: Result-based linking
-    // Look for tool_result events that contain agentId references
+    const parentOf = new Map();
+    const attach = (parent, child) => {
+        if (parent === child || parentOf.has(child))
+            return false;
+        // Never nest an agent under its own descendant (malformed metadata).
+        for (let up = parent; up; up = parentOf.get(up)) {
+            if (up === child)
+                return false;
+        }
+        parentOf.set(child, parent);
+        parent.children.push(child);
+        return true;
+    };
+    // Phase 1: the meta file names the parent agent
+    for (const child of traces) {
+        const parent = child.parentAgentId ? traceById.get(child.parentAgentId) : undefined;
+        if (parent)
+            attach(parent, child);
+    }
+    // Phase 2: the child's spawning call is in another trace
+    const spawnOwner = new Map();
     for (const trace of traces) {
-        for (const traceEvent of trace.events) {
-            const evt = traceEvent.event;
-            if (evt.type === 'tool_use' && evt.tool?.name === 'Task') {
-                // The tool_use_id from this call should appear as a result in the parent
-                // but we can link via timestamp proximity to child traces
-            }
+        for (const id of spawnToolUseIdsOf(trace)) {
+            if (!spawnOwner.has(id))
+                spawnOwner.set(id, trace);
         }
     }
-    // Phase 2: Team summary linking
+    for (const child of traces) {
+        if (parentOf.has(child) || !child.spawnToolUseId)
+            continue;
+        const parent = spawnOwner.get(child.spawnToolUseId);
+        if (parent && attach(parent, child))
+            child.parentAgentId ??= parent.agentId;
+    }
+    // Heuristic links set parentAgentId and, as before, parentToolUseId to the
+    // parent's agent id.
+    const unresolved = (trace) => !parentOf.has(trace) && !trace.spawnToolUseId && !trace.parentAgentId;
+    const linkHeuristically = (parent, child) => {
+        if (!attach(parent, child))
+            return false;
+        child.parentAgentId = parent.agentId;
+        child.parentToolUseId = parent.agentId;
+        return true;
+    };
+    // Phase 3: Team summary linking
     for (const trace of traces) {
         for (const traceEvent of trace.events) {
             const content = traceEvent.event.message?.content;
@@ -219,45 +268,56 @@ function linkTraces(traces) {
                 // Parse teammate agent IDs from XML blocks
                 const matches = content.matchAll(/agent[_-]id['":\s]+([a-f0-9]+)/gi);
                 for (const match of matches) {
-                    const childId = match[1];
-                    const child = traceById.get(childId);
-                    if (child && child !== trace && !child.parentToolUseId) {
-                        child.parentToolUseId = trace.agentId;
-                        trace.children.push(child);
-                    }
+                    const child = traceById.get(match[1]);
+                    if (child && unresolved(child))
+                        linkHeuristically(trace, child);
                 }
             }
         }
     }
-    // Phase 3: Positional fallback — timestamp proximity
+    // Phase 4: Positional fallback — timestamp proximity
     // Traces without parents that fall within another trace's time window
-    const parentless = traces.filter((t) => !t.parentToolUseId);
-    for (const child of parentless) {
+    for (const child of traces.filter(unresolved)) {
         if (!child.stats.startTime)
             continue;
         const childStart = child.stats.startTime.getTime();
-        // Find a trace that was active (Task tool call) right before this child started
+        // Find a top-level trace that spawned an agent right before this child started
         for (const potential of traces) {
-            if (potential === child)
+            if (potential === child || parentOf.has(potential))
                 continue;
-            if (potential.parentToolUseId)
-                continue; // Already linked
             for (const traceEvent of potential.events) {
                 const evt = traceEvent.event;
-                if (evt.type === 'assistant' && evt.tool?.name === 'Task') {
+                if (evt.type === 'assistant' && isSubagentSpawnTool(evt.tool?.name)) {
                     const taskTime = new Date(evt.timestamp).getTime();
                     // Within 2 seconds before child start
                     if (taskTime <= childStart && childStart - taskTime < 2000) {
-                        child.parentToolUseId = potential.agentId;
-                        potential.children.push(child);
+                        linkHeuristically(potential, child);
                         break;
                     }
                 }
             }
-            if (child.parentToolUseId)
+            if (parentOf.has(child))
                 break;
         }
     }
+    return traces.filter((trace) => !parentOf.has(trace));
+}
+/** Ids of the `Agent` / `Task` calls a trace made. */
+function spawnToolUseIdsOf(trace) {
+    const ids = [];
+    for (const traceEvent of trace.events) {
+        const content = traceEvent.event.message?.content;
+        if (!Array.isArray(content))
+            continue;
+        for (const block of content) {
+            if (block?.type === 'tool_use' &&
+                typeof block.id === 'string' &&
+                isSubagentSpawnTool(block.name)) {
+                ids.push(block.id);
+            }
+        }
+    }
+    return ids;
 }
 // ── Helpers ──
 function rawToSessionEvent(raw) {
@@ -272,7 +332,7 @@ function rawToSessionEvent(raw) {
         tool_result: 'tool_result',
         summary: 'summary',
     };
-    const mappedType = typeMap[type];
+    const mappedType = ownValue(typeMap, type);
     if (!mappedType)
         return null;
     const message = raw.message;

package/dist/esm/pricingCatalog.js

@@ -20,6 +20,7 @@ import { promises as fs } from 'node:fs';
 import * as path from 'node:path';
 import { _setCatalogContextWindows } from './modelContext';
 import { _setPricingOverrides, getPricingCatalogInfo } from './modelInfo';
+import { setOwnValue } from './ownKey';
 import { getConfigDir } from './paths';
 import { atomicWriteJson } from './writers/atomic';
 // ── Constants ──
@@ -117,7 +118,7 @@ export function normalizeLiteLlmCatalog(raw) {
             continue;
         // Catalog keys use both `provider/model` and bare `model` forms. Record both
         // the raw key and the bare-model form so lookups work regardless of caller.
-        out[key] = pricing;
+        setOwnValue(out, key, pricing);
         const bare = stripProviderPrefix(key);
         if (bare && bare !== key && !out[bare]) {
             out[bare] = pricing;
@@ -154,7 +155,7 @@ export function normalizeLiteLlmContextWindows(raw) {
         const window = entry.max_input_tokens;
         if (typeof window !== 'number' || !Number.isFinite(window) || window <= 0)
             continue;
-        out[key] = window;
+        setOwnValue(out, key, window);
         const bare = stripProviderPrefix(key);
         if (bare && bare !== key) {
             const seen = aliasWindows.get(bare) ?? new Set();

package/dist/esm/providers/claudeCode.js

@@ -13,7 +13,7 @@ import { StringDecoder } from 'string_decoder';
 import { readSessionContextSnapshot } from '../context/sessionContext';
 import { readSessionFileStats } from '../sessionStats';
 import { JsonlParser } from '../parsers/jsonl';
-import { ClaudeUsageDeduper, normalizeClaudeUsage } from '../usage/claudeUsageDedupe';
+import { ClaudeUsageDeduper, normalizeClaudeUsage, } from '../usage/claudeUsageDedupe';
 import { ProviderDiagnosticTracker } from './diagnostics';
 import { DirectoryListingCache, splitWatchedPath } from './directoryListingCache';
 import { encodeWorkspacePath as encodeWsPath, getSessionDirectory as getSessionDir, discoverSessionDirectory as discoverSessionDir, findActiveSession as findActiveSessionPath, findAllSessions as findAllSessionPaths, findSessionsInDirectory as findSessionsInDir, decodeEncodedPath, getAllProjectFolders as getAllProjectFoldersRaw, findSessionFilesWithStats, } from '../parsers/sessionPathResolver';
@@ -119,7 +119,8 @@ class ClaudeCodeReader {
         this.usageDeduper = usageDeduper ?? new ClaudeUsageDeduper();
         this.parser = new JsonlParser({
             onEvent: (raw) => {
-                for (const event of extractSessionEvents(raw)) {
+                // Mid-turn task notifications finish background subagents.
+                for (const event of extractSessionEvents(raw, { includeTaskNotifications: true })) {
                     this.events.push(this.usageDeduper.apply(normalizeClaudeUsage(event)));
                 }
             },
@@ -208,6 +209,13 @@ class ClaudeCodeReader {
     wasTruncated() {
         return this._wasTruncated;
     }
+    /** The usage deduper's recent message ids, so a resumed reader does not recount a split response. */
+    getResumeState() {
+        return this.usageDeduper.exportState();
+    }
+    restoreResumeState(state) {
+        return this.usageDeduper.importState(state);
+    }
 }
 /**
  * Session provider for Claude Code CLI.