sidekick-shared 0.29.0 → 0.30.0

package/dist/parsers/codexParser.d.ts

@@ -13,6 +13,21 @@
  */
 import type { SessionEvent } from '../types/sessionEvent';
 import type { CodexRolloutLine, CodexSessionMeta, CodexTokenUsage, CodexRateLimits } from '../types/codex';
+/** Pending exec command awaiting its end event. */
+interface PendingExecCommand {
+    call_id: string;
+    command: string[];
+    workdir?: string;
+    timestamp: string;
+}
+/** Pending MCP tool call awaiting its end event. */
+interface PendingMcpToolCall {
+    call_id: string;
+    server_name?: string;
+    tool_name: string;
+    arguments?: Record<string, unknown>;
+    timestamp: string;
+}
 /**
  * Resolve the usage of the single call a Codex `token_count` event reports.
  *
@@ -73,6 +88,15 @@ export interface CodexRolloutParserOptions {
      * unchanged. For cheap passes over large rollouts; default false.
      */
     metadataOnly?: boolean;
+    /**
+     * Emit the multi-agent lifecycle as `system` events with `origin: { kind:
+     * 'subagent-activity' }` (read them with `subagentActivityFromEvent()`):
+     * `SubAgentActivity` items (`started`, `completed`, `interacted`,
+     * `interrupted`) and each `FINAL_ANSWER` agent message. Transcripts,
+     * context attribution, and the aggregator's message counts skip them.
+     * Default false: those records produce no events.
+     */
+    includeSubagentActivity?: boolean;
 }
 /** Pending tool-call state counters from {@link CodexRolloutParser.getPendingStats}. */
 export interface CodexPendingStats {
@@ -85,6 +109,47 @@ export interface CodexPendingStats {
     /** Pending calls forgotten because `maxPendingBytes` was exceeded. */
     evictedByBytes: number;
 }
+/**
+ * JSON-serializable continuation state of a {@link CodexRolloutParser}, from
+ * `exportResumeState()`, for `importResumeState()` in a parser that resumes
+ * at the same rollout position (for example from a persisted session
+ * snapshot). Every table lists its entries oldest first.
+ */
+export interface CodexRolloutResumeState {
+    version: 1;
+    sessionMeta: CodexSessionMeta | null;
+    /** Model from the latest `turn_context`, attributed to later events. */
+    currentModel: string | null;
+    /** Cumulative total of the previous token_count event, to skip its duplicates. */
+    prevTotalUsage: CodexTokenUsage | null;
+    lastTokenUsage: CodexTokenUsage | null;
+    modelContextWindow: number | null;
+    lastRateLimits: CodexRateLimits | null;
+    hasAggregateRateLimits: boolean;
+    inPlanMode: boolean;
+    /** Call ids whose tool use was already emitted, so their end event does not emit another. */
+    emittedToolUseIds: string[];
+    /** `apply_patch` calls awaiting output: call id and its per-file tool-use ids. */
+    patchExpandedToolUseIds: Array<[string, string[]]>;
+    /** `exec_command_begin` events awaiting their end. */
+    pendingExecCommands: PendingExecCommand[];
+    /** `mcp_tool_call_begin` events awaiting their end. */
+    pendingMcpToolCalls: PendingMcpToolCall[];
+    /**
+     * Multi-agent tool calls by call id with their raw tool names, so a later
+     * `SubAgentActivity` record names its tool. Optional: absent in states
+     * from earlier versions (and when `includeSubagentActivity` is off).
+     */
+    collaborationCalls?: Array<[string, string]>;
+    /**
+     * Forked subagent rollouts: the ordinal below which records are the
+     * embedded parent history (see `getInheritedHistoryEnd()`). Optional:
+     * absent (nothing skipped) in states from earlier versions.
+     */
+    inheritedHistoryEnd?: number | null;
+}
+/** A valid `CodexTokenUsage` (copied), `null` for `null`, or `undefined` when invalid. Internal. */
+export declare function codexTokenUsageFrom(value: unknown): CodexTokenUsage | null | undefined;
 /**
  * Stateful parser for Codex JSONL rollout lines.
  *
@@ -112,6 +177,15 @@ export declare class CodexRolloutParser {
     /** Byte budget for pending calls; `null` = unlimited (no accounting). */
     private readonly maxPendingBytes;
     private readonly metadataOnly;
+    private readonly 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.
+     */
+    private historyStartOrdinal;
+    /** Multi-agent tool calls (call id → raw name), only with `includeSubagentActivity`. */
+    private collaborationCalls;
     /** Pending calls in insertion order, for the byte budget. */
     private pendingLedger;
     private pendingBytes;
@@ -130,6 +204,29 @@ export declare class CodexRolloutParser {
     getModelContextWindow(): number | null;
     /** Get the last observed rate limits from token_count events. */
     getLastRateLimits(): CodexRateLimits | null;
+    /**
+     * 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(): number | null;
+    /**
+     * 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?: number): CodexRolloutResumeState;
+    /**
+     * 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: unknown): boolean;
     /**
      * Converts a single rollout line to zero or more session events.
      */
@@ -142,6 +239,9 @@ export declare class CodexRolloutParser {
      * first.
      */
     private putPending;
+    private putPendingExec;
+    private putPendingMcp;
+    private putPendingPatch;
     /** Removes and returns a pending call. */
     private takePending;
     private forgetPendingBytes;
@@ -152,6 +252,12 @@ export declare class CodexRolloutParser {
     private toolOutput;
     private handleSessionMeta;
     private handleResponseItem;
+    private rememberCollaborationCall;
+    private subagentActivityEvent;
+    /** A child's `FINAL_ANSWER` message to its parent (opt-in). */
+    private handleAgentMessage;
+    /** A `SubAgentActivity` turn item (opt-in). */
+    private handleItemCompleted;
     private handleMessage;
     private handleReasoning;
     private handleFunctionCall;
@@ -164,3 +270,4 @@ export declare class CodexRolloutParser {
     private handleEventMsg;
     private handleTokenCount;
 }
+export {};

package/dist/parsers/codexParser.js

@@ -18,9 +18,11 @@ exports.resolveCodexCallUsage = resolveCodexCallUsage;
 exports.normalizeCodexToolName = normalizeCodexToolName;
 exports.normalizeCodexToolInput = normalizeCodexToolInput;
 exports.extractPatchFilePaths = extractPatchFilePaths;
+exports.codexTokenUsageFrom = codexTokenUsageFrom;
 const codex_1 = require("../types/codex");
 const openCodeParser_1 = require("./openCodeParser");
 const usageNormalization_1 = require("../usageNormalization");
+const subagentActivity_1 = require("../subagentActivity");
 function reportedCompaction(tokensBefore, tokensAfter) {
     if (typeof tokensBefore !== 'number' ||
         typeof tokensAfter !== 'number' ||
@@ -178,6 +180,84 @@ function extractPatchFilePaths(input) {
 }
 /** Default cap on each piece of per-call correlation state the parser keeps. */
 exports.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);
+}
+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. */
+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. */
@@ -242,6 +322,15 @@ 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;
@@ -257,6 +346,7 @@ 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() {
@@ -289,13 +379,172 @@ 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,
+     * 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),
+            ...(this.historyStartOrdinal !== null
+                ? { inheritedHistoryEnd: this.historyStartOrdinal }
+                : {}),
+            ...(this.collaborationCalls.size > 0
+                ? {
+                    collaborationCalls: newest(this.collaborationCalls, this.collaborationCalls.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 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,
+            patches: patches,
+            execs: execs,
+            mcps: mcps,
+        });
+        this.reset();
+        this.sessionMeta = copy.sessionMeta;
+        this.historyStartOrdinal = typeof inheritedEnd === 'number' ? inheritedEnd : null;
+        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);
+        }
+        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':
@@ -311,6 +560,8 @@ 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();
@@ -360,6 +611,16 @@ 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);
@@ -390,7 +651,25 @@ 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 [
@@ -430,10 +709,91 @@ 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: subagentActivity_1.SUBAGENT_ACTIVITY_ORIGIN_KIND },
+            message: {
+                role: 'system',
+                id: `subagent-activity:${id}`,
+                sourceLabel: 'subagent activity',
+                content: [{ type: subagentActivity_1.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 = (0, subagentActivity_1.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)
@@ -515,6 +875,11 @@ 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',
@@ -589,7 +954,7 @@ 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);
             }
@@ -739,7 +1104,7 @@ 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': {
@@ -802,8 +1167,7 @@ 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': {
@@ -972,6 +1336,8 @@ class CodexRolloutParser {
                         timestamp,
                     },
                 ];
+            case 'item_completed':
+                return this.handleItemCompleted(timestamp, event);
             case 'turn_aborted':
             case 'agent_reasoning':
             case 'agent_message':

package/dist/parsers/openCodeParser.js

@@ -22,6 +22,7 @@ exports.convertOpenCodeMessage = convertOpenCodeMessage;
 exports.parseDbMessageData = parseDbMessageData;
 exports.parseDbPartData = parseDbPartData;
 const usageNormalization_1 = require("../usageNormalization");
+const ownKey_1 = require("../ownKey");
 /**
  * OpenCode → Claude Code tool name mapping.
  * OpenCode uses lowercase names; downstream code expects PascalCase.
@@ -57,7 +58,7 @@ function normalizeToolName(name) {
     if (!name)
         return name;
     // Check mapping (case-insensitive lookup via lowercase key)
-    const mapped = TOOL_NAME_MAP[name.toLowerCase()];
+    const mapped = (0, ownKey_1.ownValue)(TOOL_NAME_MAP, name.toLowerCase());
     if (mapped)
         return mapped;
     // Already PascalCase (starts with uppercase)? Pass through.

package/dist/parsers/subagentEndState.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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
+ */
+export declare class SubagentEndTracker {
+    private readonly unanswered;
+    private lastWasCleanAssistant;
+    /** Feeds one parsed JSONL line, in file order. */
+    observe(raw: unknown): void;
+    /** Whether the lines so far end cleanly. */
+    endedCleanly(): boolean;
+}