sidekick-shared 0.29.1 → 0.30.0

package/dist/esm/fileContinuity.js

@@ -0,0 +1,149 @@
+/**
+ * Continuity of a file read incrementally by byte offset: whether the file
+ * now at a path is still the content earlier reads consumed, or was
+ * truncated, rewritten, or replaced since.
+ *
+ * {@link FileContinuity} holds the rules `createJsonlTail` applies, so every
+ * incremental reader detects the same cases the same way:
+ *
+ * - `replaced`: another file (by device and inode, read from the open
+ *   descriptor, so a rename between a stat and an open cannot mix two files)
+ *   now has the path.
+ * - `truncated`: the file is shorter than the read position.
+ * - `rewritten`: the mtime changed and either the first {@link HEAD_BYTES}
+ *   bytes differ from those recorded, or the byte before the committed
+ *   (resume-safe) offset is no longer a newline.
+ *
+ * Replacement and truncation are checked on every read; the content probe
+ * only when the mtime changed or the recorded head is still short.
+ *
+ * Known limits: a rewrite that leaves the mtime unchanged (coarse mtime
+ * resolution, or an mtime restored on purpose) or that changes only bytes
+ * past the first 4 KiB while the resume point still follows a newline goes
+ * unnoticed; on filesystems without stable inode numbers (some SMB mounts,
+ * Windows) an unchanged file can read as replaced, which costs a replay.
+ *
+ * @module fileContinuity
+ */
+import * as fs from 'fs';
+import { fileHeadOf, HEAD_BYTES, headMatches } from './fileHead';
+/**
+ * What one reader knows about the file its offsets refer to: identity,
+ * mtime, and a digest of the first bytes, recorded by {@link adopt} after
+ * each read.
+ *
+ * Synchronous readers call {@link check} on the open descriptor, restart
+ * from offset 0 when it returns a reason, then call {@link adopt}. A reader
+ * that repositions without reading (a seek to a stored offset, a reset)
+ * calls {@link forget}, so its next read adopts the file instead of
+ * comparing it with the old one. The lower-level methods ({@link needsProbe},
+ * {@link reasonFor}, {@link record}) serve asynchronous readers that probe
+ * on their own.
+ */
+export class FileContinuity {
+    identity = null;
+    head = null;
+    lastMtimeMs = -1;
+    /** What the last {@link check} probed and decided, for {@link adopt}. */
+    checked = null;
+    /** Device and inode of the adopted file; `null` before the first read and after {@link forget}. */
+    get knownIdentity() {
+        return this.identity;
+    }
+    /** Length and digest of the adopted file's first bytes, once probed. */
+    get knownHead() {
+        return this.head;
+    }
+    /** Whether {@link reasonFor} needs bytes from the file to decide. */
+    needsProbe(stat, readOffset) {
+        return (this.identity === null ||
+            stat.dev !== this.identity.dev ||
+            stat.ino !== this.identity.ino ||
+            stat.size < readOffset ||
+            stat.mtimeMs !== this.lastMtimeMs ||
+            this.head === null ||
+            this.head.bytes < Math.min(HEAD_BYTES, stat.size));
+    }
+    /**
+     * Why the reader must start over: the path now names another file, the
+     * file shrank below `readOffset`, its first bytes changed, or the resume
+     * point no longer follows a newline. `null` when it can continue.
+     */
+    reasonFor(stat, readOffset, probe) {
+        if (this.identity && (stat.dev !== this.identity.dev || stat.ino !== this.identity.ino)) {
+            return 'replaced';
+        }
+        if (stat.size < readOffset)
+            return 'truncated';
+        if (this.identity && stat.mtimeMs !== this.lastMtimeMs && probe) {
+            if (this.head && !headMatches(this.head, probe.prefix))
+                return 'rewritten';
+            if (probe.before && probe.before[0] !== 0x0a)
+                return 'rewritten';
+        }
+        return null;
+    }
+    /** Records the identity, mtime, and (from `probe`) first bytes of the file the offsets now refer to. */
+    record(stat, probe) {
+        this.identity = { dev: stat.dev, ino: stat.ino };
+        this.lastMtimeMs = stat.mtimeMs;
+        if (probe && (!this.head || this.head.bytes < Math.min(HEAD_BYTES, stat.size))) {
+            this.head = fileHeadOf(probe.prefix);
+        }
+    }
+    /** Drops the recorded first bytes (the reader restarted); the next {@link record} with a probe sets them again. */
+    discardHead() {
+        this.head = null;
+    }
+    /** Records the file as known from `prefix`, its first `min(HEAD_BYTES, size)` bytes. */
+    adoptPrefix(stat, prefix) {
+        this.identity = { dev: stat.dev, ino: stat.ino };
+        this.lastMtimeMs = stat.mtimeMs;
+        this.head = fileHeadOf(prefix);
+    }
+    /** Forgets the file, so the next {@link check} adopts whatever file has the path. */
+    forget() {
+        this.identity = null;
+        this.head = null;
+        this.lastMtimeMs = -1;
+        this.checked = null;
+    }
+    /**
+     * Applies the rules to the file open on `fd` (`stat` from `fstat` on that
+     * descriptor), reading the bytes they need. `readOffset` is how far the
+     * reader has read; `committedOffset` (default `readOffset`) is its
+     * resume-safe position just after a newline. Returns why the reader must
+     * restart from offset 0, or `null`. Call {@link adopt} with the same
+     * `stat` once the reader has acted on the answer.
+     */
+    check(fd, stat, readOffset, committedOffset = readOffset) {
+        const probe = this.needsProbe(stat, readOffset)
+            ? probeFileContinuity(fd, stat, committedOffset)
+            : null;
+        const reason = this.reasonFor(stat, readOffset, probe);
+        this.checked = { probe, reset: reason !== null };
+        return reason;
+    }
+    /** Records the file just checked as the one the reader's offsets now refer to. */
+    adopt(stat) {
+        const checked = this.checked;
+        this.checked = null;
+        if (checked?.reset)
+            this.head = null;
+        this.record(stat, checked?.probe ?? null);
+    }
+}
+/** Reads the bytes {@link FileContinuity.reasonFor} compares, from the file open on `fd`. */
+export function probeFileContinuity(fd, stat, committedOffset) {
+    return {
+        prefix: readAt(fd, 0, Math.min(HEAD_BYTES, stat.size)),
+        before: committedOffset > 0 && committedOffset <= stat.size
+            ? readAt(fd, committedOffset - 1, 1)
+            : null,
+    };
+}
+function readAt(fd, position, length) {
+    const buffer = Buffer.alloc(length);
+    const count = length > 0 ? fs.readSync(fd, buffer, 0, length, position) : 0;
+    return buffer.subarray(0, count);
+}

package/dist/esm/index.js

@@ -51,6 +51,7 @@ export { ClaudeCodeProvider } from './providers/claudeCode';
 export { OpenCodeProvider, getOpenCodeDataDir } from './providers/openCode';
 export { CodexProvider, findCodexRolloutFile } from './providers/codex';
 export { walkRolloutFiles, walkRolloutFilesAsync } from './providers/rolloutWalker';
+export { COMPRESSED_ROLLOUT_SUFFIX, isCompressedRolloutPath, isZstdDecompressionAvailable, readRolloutBuffer, readRolloutText, resolveRolloutPath, } from './providers/compressedRollouts';
 // Parsers — JSONL
 export { JsonlParser, TRUNCATION_PATTERNS } from './parsers/jsonl';
 // Parsers — OpenCode
@@ -58,6 +59,7 @@ export { normalizeToolName, normalizeToolInput, detectPlanModeFromText, convertO
 // Parsers — Codex
 export { CodexRolloutParser, DEFAULT_MAX_TRACKED_TOOL_CALLS, extractPatchFilePaths, normalizeCodexToolName, normalizeCodexToolInput, resolveCodexCallUsage, } from './parsers/codexParser';
 export { codexRolloutOrigin, codexSpawnParentFromSource } from './parsers/codexRolloutOrigin';
+export { SUBAGENT_ACTIVITY_BLOCK_TYPE, SUBAGENT_ACTIVITY_ORIGIN_KIND, describeSubagentActivity, isSubagentActivitySystemEvent, parseCodexAgentMessageText, subagentActivityFromEvent, } from './subagentActivity';
 // Parsers — Subagent scanning
 export { scanSubagentDir, extractTaskInfo, readAgentMeta } from './parsers/subagentScanner';
 // Usage — split-line dedupe, subagent tokens, session totals
@@ -80,7 +82,7 @@ export { listSessionPreviews, listSessionPreviewsAsync, readSessionPreview, read
 export { parseDebugLog, filterByLevel, collapseDuplicates, discoverDebugLogs, } from './parsers/debugLogParser';
 // Database wrappers
 export { OpenCodeDatabase } from './providers/openCodeDatabase';
-export { CodexDatabase } from './providers/codexDatabase';
+export { CodexDatabase, isCodexSubagentThread } from './providers/codexDatabase';
 // Search
 export { searchSessions } from './search/sessionSearch';
 export { FilterEngine } from './search/advancedFilter';
@@ -88,7 +90,8 @@ export { FilterEngine } from './search/advancedFilter';
 export { composeContext } from './context/composer';
 export { buildSessionContextSnapshot, calculateSessionContextPressure, createSessionContextProjector, readSessionContextSnapshot, } from './context/sessionContext';
 // Subagent spawns (`Agent` / `Task`) and background-task notifications
-export { SUBAGENT_SPAWN_TOOL_NAMES, isSubagentSpawnTool, isTaskNotificationSystemEvent, parseTaskNotification, taskNotificationFromEvent, } from './subagentSpawn';
+export { SUBAGENT_SPAWN_TOOL_NAMES, agentsStoppedNoticeFromEvent, isAgentsKilledSystemEvent, isCodexSubagentSpawnTool, isSubagentSpawnTool, isTaskNotificationSystemEvent, isTaskStatusSystemEvent, parseAgentsStoppedNotice, parseCodexSpawnLaunch, parseTaskNotification, taskNotificationFromEvent, taskStatusFromAttachment, taskStatusFromEvent, } from './subagentSpawn';
+export { SUBAGENT_PARENT_IDLE_ENDED_MS, SUBAGENT_UNREPORTED_QUIET_MS, resolveSubagentDisplayState, subagentDisplayLabel, } from './subagentDisplayState';
 // Assistant turn projection
 export { assistantTurnEventsFromSessionEvents, extractTurnSubagents, isAssistantTurnSubagentTool, reasoningSummary, segmentAssistantTurn, } from './turns/assistantTurn';
 // Plan Extraction

package/dist/esm/node.js

@@ -24,6 +24,7 @@ export { ACTIVE_SESSION_MTIME_THRESHOLD_MS, importSessionHistory, } from './usag
 export { bucketUsage, summarizeUsageRows, usageBucketKey, weekKey } from './usage/usageReports';
 export { findCodexRolloutFile } from './providers/codex';
 export { walkRolloutFiles, walkRolloutFilesAsync } from './providers/rolloutWalker';
+export { COMPRESSED_ROLLOUT_SUFFIX, isCompressedRolloutPath, isZstdDecompressionAvailable, readRolloutBuffer, readRolloutText, resolveRolloutPath, } from './providers/compressedRollouts';
 export { readCodexHistory } from './parsers/codexHistory';
 export { listSessionPreviews, listSessionPreviewsAsync, readSessionPreview, readSessionPreviewAsync, } from './sessionPreviews';
 export { ObservedSessionCollector, observedSessionSourceFromProvider, fileFingerprint, fileFingerprintParts, } from './observedSessionCollector';
@@ -41,6 +42,7 @@ export { parseAuthJson as parseCodexAuthJson, readAuthIdentityFromRaw as readCod
 export { atomicWriteJson, atomicWriteJsonSync } from './writers/atomic';
 export { parseClaudeAuthStatus, parseCodexLoginStatus } from './authStatus';
 export { codexRolloutOrigin, codexSpawnParentFromSource } from './parsers/codexRolloutOrigin';
+export { SUBAGENT_ACTIVITY_BLOCK_TYPE, SUBAGENT_ACTIVITY_ORIGIN_KIND, describeSubagentActivity, isSubagentActivitySystemEvent, parseCodexAgentMessageText, subagentActivityFromEvent, } from './subagentActivity';
 export { getPricingCatalogInfo, registerModelPricing, clearRegisteredModelPricing, } from './modelInfo';
 export { fetchProviderServiceStatus } from './providerServiceStatus';
 // Tool categories across providers

package/dist/esm/parsers/codexParser.js

@@ -14,6 +14,7 @@
 import { isAggregateCodexLimit } from '../types/codex';
 import { normalizeToolName } from './openCodeParser';
 import { normalizeProviderUsage } from '../usageNormalization';
+import { SUBAGENT_ACTIVITY_BLOCK_TYPE, SUBAGENT_ACTIVITY_ORIGIN_KIND, parseCodexAgentMessageText, } from '../subagentActivity';
 function reportedCompaction(tokensBefore, tokensAfter) {
     if (typeof tokensBefore !== 'number' ||
         typeof tokensAfter !== 'number' ||
@@ -173,6 +174,29 @@ export function extractPatchFilePaths(input) {
 export const DEFAULT_MAX_TRACKED_TOOL_CALLS = 4096;
 /** Entries per table {@link CodexRolloutParser.exportResumeState} keeps by default. */
 const DEFAULT_RESUME_STATE_LIMIT = 256;
+/** Raw names of Codex's multi-agent tools (namespace `collaboration`). */
+const COLLABORATION_TOOL_NAMES = new Set([
+    'spawn_agent',
+    'followup_task',
+    'send_message',
+    'interrupt_agent',
+    'wait_agent',
+    'list_agents',
+]);
+const SUBAGENT_ACTIVITY_KINDS = new Set([
+    'started',
+    'completed',
+    'interacted',
+    'interrupted',
+]);
+function nonEmptyString(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+/** `subagent_history_start_ordinal` of a session_meta payload, when valid. */
+function historyStartOrdinalOf(meta) {
+    const value = meta?.subagent_history_start_ordinal;
+    return typeof value === 'number' && Number.isInteger(value) && value > 0 ? value : null;
+}
 function isPlainObject(value) {
     return !!value && typeof value === 'object' && !Array.isArray(value);
 }
@@ -290,6 +314,15 @@ export class CodexRolloutParser {
     /** Byte budget for pending calls; `null` = unlimited (no accounting). */
     maxPendingBytes;
     metadataOnly;
+    includeSubagentActivity;
+    /**
+     * Set once a forked child's rollout embeds an ancestor's session_meta: its
+     * own `subagent_history_start_ordinal`, below which records are the
+     * parent's history and are skipped. `null` while nothing is skipped.
+     */
+    historyStartOrdinal = null;
+    /** Multi-agent tool calls (call id → raw name), only with `includeSubagentActivity`. */
+    collaborationCalls = new Map();
     /** Pending calls in insertion order, for the byte budget. */
     pendingLedger = new Map();
     pendingBytes = 0;
@@ -305,6 +338,7 @@ export class CodexRolloutParser {
                 ? Math.floor(maxBytes)
                 : null;
         this.metadataOnly = options.metadataOnly === true;
+        this.includeSubagentActivity = options.includeSubagentActivity === true;
     }
     /** Counters for the pending tool-call state and what the caps evicted. */
     getPendingStats() {
@@ -337,6 +371,16 @@ export class CodexRolloutParser {
     getLastRateLimits() {
         return this.lastRateLimits;
     }
+    /**
+     * In a forked subagent's rollout, the ordinal of its first own record:
+     * records with a lower `ordinal` are the parent history the fork embeds
+     * and produce no events. Known once the rollout's second line (an embedded
+     * ancestor `session_meta`) was parsed; `null` otherwise, and for every
+     * rollout that is not such a fork.
+     */
+    getInheritedHistoryEnd() {
+        return this.historyStartOrdinal;
+    }
     /**
      * The state later lines depend on — session metadata, current model,
      * previous cumulative token total, context window, rate limits, plan mode,
@@ -358,6 +402,14 @@ export class CodexRolloutParser {
             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),
+            ...(this.historyStartOrdinal !== null
+                ? { inheritedHistoryEnd: this.historyStartOrdinal }
+                : {}),
+            ...(this.collaborationCalls.size > 0
+                ? {
+                    collaborationCalls: newest(this.collaborationCalls, this.collaborationCalls.size, limit),
+                }
+                : {}),
         });
     }
     /**
@@ -418,6 +470,21 @@ export class CodexRolloutParser {
                 typeof entry.timestamp === 'string')) {
             return false;
         }
+        const inheritedEnd = s.inheritedHistoryEnd;
+        if (inheritedEnd !== undefined &&
+            inheritedEnd !== null &&
+            !(typeof inheritedEnd === 'number' && Number.isInteger(inheritedEnd) && inheritedEnd > 0)) {
+            return false;
+        }
+        const collaborationCalls = s.collaborationCalls;
+        if (collaborationCalls !== undefined &&
+            !(Array.isArray(collaborationCalls) &&
+                collaborationCalls.every((entry) => Array.isArray(entry) &&
+                    entry.length === 2 &&
+                    typeof entry[0] === 'string' &&
+                    typeof entry[1] === 'string'))) {
+            return false;
+        }
         const copy = cloneJson({
             sessionMeta: s.sessionMeta,
             lastRateLimits: s.lastRateLimits,
@@ -427,6 +494,7 @@ export class CodexRolloutParser {
         });
         this.reset();
         this.sessionMeta = copy.sessionMeta;
+        this.historyStartOrdinal = typeof inheritedEnd === 'number' ? inheritedEnd : null;
         this.currentModel = s.currentModel;
         this.prevTotalUsage = prevTotalUsage;
         this.lastTokenUsage = lastTokenUsage;
@@ -447,15 +515,28 @@ export class CodexRolloutParser {
         for (const pending of copy.mcps) {
             this.putPendingMcp(this.metadataOnly ? { ...pending, arguments: undefined } : pending);
         }
+        if (this.includeSubagentActivity && Array.isArray(collaborationCalls)) {
+            for (const [callId, name] of collaborationCalls) {
+                this.rememberCollaborationCall(callId, name);
+            }
+        }
         return true;
     }
     /**
      * Converts a single rollout line to zero or more session events.
      */
     convertLine(line) {
+        if (line.type === 'session_meta') {
+            return this.handleSessionMeta(line.timestamp, line.payload, line.ordinal);
+        }
+        // A forked subagent rollout embeds the parent's history before its own
+        // records; that history is the parent's, not the child's.
+        if (this.historyStartOrdinal !== null &&
+            typeof line.ordinal === 'number' &&
+            line.ordinal < this.historyStartOrdinal) {
+            return [];
+        }
         switch (line.type) {
-            case 'session_meta':
-                return this.handleSessionMeta(line.timestamp, line.payload);
             case 'response_item':
                 return this.handleResponseItem(line.timestamp, line.payload);
             case 'compacted':
@@ -471,6 +552,8 @@ export class CodexRolloutParser {
     /** Reset all parser state. */
     reset() {
         this.sessionMeta = null;
+        this.historyStartOrdinal = null;
+        this.collaborationCalls.clear();
         this.currentModel = null;
         this.pendingExecCommands.clear();
         this.pendingMcpToolCalls.clear();
@@ -560,7 +643,25 @@ export class CodexRolloutParser {
         return this.metadataOnly ? '' : content;
     }
     // --- Handlers ---
-    handleSessionMeta(timestamp, payload) {
+    handleSessionMeta(timestamp, payload, ordinal) {
+        if (this.sessionMeta) {
+            // Only the rollout's own (first) session_meta counts. A forked child
+            // embeds its parent's right after its own, followed by the parent's
+            // history up to the child's `subagent_history_start_ordinal`; from
+            // here on, records below that ordinal are skipped. (Children whose
+            // rollout has no embedded meta keep every record: in some, Codex
+            // recorded a start ordinal past their own records.)
+            const start = historyStartOrdinalOf(this.sessionMeta);
+            if (this.historyStartOrdinal === null &&
+                start !== null &&
+                typeof ordinal === 'number' &&
+                ordinal < start) {
+                this.historyStartOrdinal = start;
+            }
+            return [];
+        }
+        if (!payload || typeof payload !== 'object')
+            return [];
         this.sessionMeta = payload;
         const text = payload.base_instructions?.text?.trim();
         return [
@@ -600,10 +701,91 @@ export class CodexRolloutParser {
                 return this.handleCustomToolCall(timestamp, payload);
             case 'custom_tool_call_output':
                 return this.handleCustomToolCallOutput(timestamp, payload);
+            case 'agent_message':
+                return this.handleAgentMessage(timestamp, payload);
             default:
                 return [];
         }
     }
+    // --- Subagent activity ---
+    rememberCollaborationCall(callId, name) {
+        this.collaborationCalls.delete(callId);
+        this.collaborationCalls.set(callId, name);
+        while (this.collaborationCalls.size > this.maxTrackedToolCalls) {
+            this.collaborationCalls.delete(this.collaborationCalls.keys().next().value);
+        }
+    }
+    subagentActivityEvent(timestamp, id, activity) {
+        return {
+            type: 'system',
+            timestamp,
+            origin: { kind: SUBAGENT_ACTIVITY_ORIGIN_KIND },
+            message: {
+                role: 'system',
+                id: `subagent-activity:${id}`,
+                sourceLabel: 'subagent activity',
+                content: [{ type: SUBAGENT_ACTIVITY_BLOCK_TYPE, ...activity }],
+            },
+            providerMetadata: { providerId: 'codex', source: 'codex-rollout' },
+        };
+    }
+    /** A child's `FINAL_ANSWER` message to its parent (opt-in). */
+    handleAgentMessage(timestamp, item) {
+        if (!this.includeSubagentActivity || !Array.isArray(item.content))
+            return [];
+        const first = item.content.find((part) => !!part && typeof part === 'object' && typeof part.text === 'string');
+        const parsed = parseCodexAgentMessageText(first?.text);
+        if (!parsed || parsed.messageType !== 'FINAL_ANSWER')
+            return [];
+        const agentPath = nonEmptyString(item.author) ?? parsed.sender;
+        const recipient = nonEmptyString(item.recipient) ?? parsed.taskName;
+        const text = this.metadataOnly ? undefined : nonEmptyString(parsed.payload.trim());
+        const activity = {
+            kind: 'final-answer',
+            ...(agentPath ? { agentPath } : {}),
+            ...(recipient ? { recipient } : {}),
+            ...(text ? { text } : {}),
+        };
+        return [
+            this.subagentActivityEvent(timestamp, nonEmptyString(item.id) ?? `final-answer-${timestamp}-${agentPath ?? ''}`, activity),
+        ];
+    }
+    /** A `SubAgentActivity` turn item (opt-in). */
+    handleItemCompleted(timestamp, event) {
+        if (!this.includeSubagentActivity)
+            return [];
+        const item = event.item;
+        if (!item || item.type !== 'SubAgentActivity')
+            return [];
+        const kind = typeof item.kind === 'string' ? item.kind : '';
+        if (!SUBAGENT_ACTIVITY_KINDS.has(kind))
+            return [];
+        const itemId = nonEmptyString(item.id);
+        const completedTurn = kind === 'completed' && itemId?.startsWith('subagent-completed-')
+            ? nonEmptyString(itemId.slice('subagent-completed-'.length))
+            : undefined;
+        const callId = kind === 'completed' ? undefined : itemId;
+        const tool = callId ? this.collaborationCalls.get(callId) : undefined;
+        const fields = {
+            callId,
+            tool,
+            turnId: completedTurn,
+            agentThreadId: nonEmptyString(item.agent_thread_id),
+            agentPath: nonEmptyString(item.agent_path),
+            model: nonEmptyString(item.model),
+            reasoningEffort: nonEmptyString(item.reasoning_effort),
+            parentThreadId: nonEmptyString(event.thread_id),
+            parentTurnId: nonEmptyString(event.turn_id),
+        };
+        const activity = { kind: kind };
+        for (const [key, value] of Object.entries(fields)) {
+            if (value !== undefined)
+                activity[key] = value;
+        }
+        return [
+            this.subagentActivityEvent(timestamp, itemId ?? `${kind}-${timestamp}-${activity.agentThreadId ?? ''}`, activity),
+        ];
+    }
     handleMessage(timestamp, item) {
         const text = extractTextFromContent(item.content);
         if (!text)
@@ -685,6 +867,11 @@ export class CodexRolloutParser {
         const canonicalName = normalizeCodexToolName(item.name);
         const normalizedInput = normalizeCodexToolInput(canonicalName, item.name, parsedArgs);
         rememberBounded(this.emittedToolUseIds, item.call_id, this.maxTrackedToolCalls);
+        if (this.includeSubagentActivity &&
+            typeof item.call_id === 'string' &&
+            (item.namespace === 'collaboration' || COLLABORATION_TOOL_NAMES.has(item.name))) {
+            this.rememberCollaborationCall(item.call_id, item.name);
+        }
         return [
             {
                 type: 'assistant',
@@ -1141,6 +1328,8 @@ export class CodexRolloutParser {
                         timestamp,
                     },
                 ];
+            case 'item_completed':
+                return this.handleItemCompleted(timestamp, event);
             case 'turn_aborted':
             case 'agent_reasoning':
             case 'agent_message':

package/dist/esm/parsers/subagentEndState.js

@@ -0,0 +1,61 @@
+/**
+ * Whether a Claude Code subagent transcript ended cleanly, read line by line.
+ *
+ * Clean means: the last user or assistant line is an assistant line that
+ * stopped with `end_turn` or `stop_sequence`, and every `tool_use` in the
+ * transcript has its `tool_result`. A user line after that (a resumed agent's
+ * new prompt) makes it unfinished again.
+ *
+ * Pure. Internal to the subagent parsers.
+ *
+ * @module parsers/subagentEndState
+ */
+const ENDED_STOP_REASONS = new Set(['end_turn', 'stop_sequence']);
+/** Bounds the unanswered-call set for pathological transcripts. */
+const MAX_PENDING_TOOL_USES = 4096;
+export class SubagentEndTracker {
+    unanswered = new Set();
+    lastWasCleanAssistant = false;
+    /** Feeds one parsed JSONL line, in file order. */
+    observe(raw) {
+        if (!raw || typeof raw !== 'object')
+            return;
+        const line = raw;
+        if (line.type !== 'assistant' && line.type !== 'user')
+            return;
+        const message = line.message && typeof line.message === 'object'
+            ? line.message
+            : undefined;
+        const content = Array.isArray(message?.content) ? message.content : [];
+        if (line.type === 'user') {
+            for (const block of content) {
+                if (!block || typeof block !== 'object')
+                    continue;
+                const typed = block;
+                if (typed.type === 'tool_result' && typeof typed.tool_use_id === 'string') {
+                    this.unanswered.delete(typed.tool_use_id);
+                }
+            }
+            this.lastWasCleanAssistant = false;
+            return;
+        }
+        let callsTool = false;
+        for (const block of content) {
+            if (!block || typeof block !== 'object')
+                continue;
+            const typed = block;
+            if (typed.type !== 'tool_use')
+                continue;
+            callsTool = true;
+            if (typeof typed.id === 'string' && this.unanswered.size < MAX_PENDING_TOOL_USES) {
+                this.unanswered.add(typed.id);
+            }
+        }
+        const stop = typeof message?.stop_reason === 'string' ? message.stop_reason : '';
+        this.lastWasCleanAssistant = !callsTool && ENDED_STOP_REASONS.has(stop);
+    }
+    /** Whether the lines so far end cleanly. */
+    endedCleanly() {
+        return this.lastWasCleanAssistant && this.unanswered.size === 0;
+    }
+}

package/dist/esm/parsers/subagentScanner.js

@@ -13,6 +13,7 @@ import { ClaudeUsageDeduper, dedupedRawClaudeUsage } from '../usage/claudeUsageD
 import { addUsageToSubagent } from '../usage/subagentUsage';
 import { cachedSubagentStats } from './subagentStatsCache';
 import { isSubagentSpawnTool } from '../subagentSpawn';
+import { SubagentEndTracker } from './subagentEndState';
 /**
  * Pattern for matching subagent JSONL files.
  * Files are named like: agent-<hash>.jsonl
@@ -160,6 +161,7 @@ function parseAgentFile(filePath, agentId, log) {
         let description;
         const tokens = { agentId, toolCalls: [], inputTokens: 0, outputTokens: 0 };
         const usageDeduper = new ClaudeUsageDeduper();
+        const endTracker = new SubagentEndTracker();
         let startTime;
         let endTime;
         // Task tracking state
@@ -176,6 +178,7 @@ function parseAgentFile(filePath, agentId, log) {
                 if (!startTime)
                     startTime = eventTimestamp;
                 endTime = eventTimestamp;
+                endTracker.observe(event);
                 // Extract token usage from assistant messages. Split lines of one
                 // response repeat its usage, so count each response once.
                 const usage = dedupedRawClaudeUsage(event, usageDeduper);
@@ -298,6 +301,7 @@ function parseAgentFile(filePath, agentId, log) {
                 startTime,
                 endTime,
                 durationMs,
+                endedCleanly: endTracker.endedCleanly(),
             };
         }
         return null;

package/dist/esm/parsers/subagentTraceParser.js

@@ -22,6 +22,7 @@ import { isHardNoise, classifyMessage, getSoftNoiseReason } from '../formatters/
 import { ClaudeUsageDeduper, dedupedRawClaudeUsage } from '../usage/claudeUsageDedupe';
 import { addUsageToSubagent } from '../usage/subagentUsage';
 import { readAgentMeta } from './subagentScanner';
+import { SubagentEndTracker } from './subagentEndState';
 import { isSubagentSpawnTool } from '../subagentSpawn';
 import { ownValue } from '../ownKey';
 // ── Constants ──
@@ -73,6 +74,7 @@ function parseAgentTrace(filePath, agentId) {
         let description;
         const tokens = { agentId, toolCalls: [], inputTokens: 0, outputTokens: 0 };
         const usageDeduper = new ClaudeUsageDeduper();
+        const endTracker = new SubagentEndTracker();
         let startTime;
         let endTime;
         for (const line of lines) {
@@ -82,6 +84,7 @@ function parseAgentTrace(filePath, agentId) {
                 if (!startTime)
                     startTime = timestamp;
                 endTime = timestamp;
+                endTracker.observe(raw);
                 // Build SessionEvent from raw JSONL
                 const sessionEvent = rawToSessionEvent(raw);
                 if (!sessionEvent)
@@ -182,6 +185,8 @@ function parseAgentTrace(filePath, agentId) {
             ...(meta.requestShape ? { background: meta.requestShape === 'background' } : {}),
             ...(meta.finished !== undefined ? { finished: meta.finished } : {}),
             ...(meta.stoppedByUser !== undefined ? { stoppedByUser: meta.stoppedByUser } : {}),
+            ...(endTime ? { lastActivityAt: endTime } : {}),
+            endedCleanly: endTracker.endedCleanly(),
             events,
             children: [],
             stats: {
@@ -198,6 +203,7 @@ function parseAgentTrace(filePath, agentId) {
                 startTime,
                 endTime,
                 durationMs,
+                endedCleanly: endTracker.endedCleanly(),
             },
         };
     }