sidekick-shared 0.29.0 → 0.30.0

package/dist/esm/testing/codexSubagentFixtures.js

@@ -0,0 +1,336 @@
+/**
+ * Redacted rollouts in the shape Codex 0.166 writes for multi-agent sessions:
+ * a parent that spawns a child (`spawn_agent` → `SubAgentActivity` started →
+ * `{"task_name": …}` output → MESSAGE / FINAL_ANSWER agent messages →
+ * `completed`), a failed spawn, `followup_task` / `send_message` /
+ * `interrupt_agent` interactions, and a forked child whose rollout embeds the
+ * parent's history (and session_meta) before its
+ * `subagent_history_start_ordinal`, which itself spawns a grandchild.
+ * Payload text is placeholder; ids are synthetic.
+ *
+ * Test-only helpers.
+ *
+ * @module testing/codexSubagentFixtures
+ */
+export const PARENT_ID = '01a18f87-0000-7000-8000-000000000001';
+export const CHILD_ID = '01a18f9d-0000-7000-8000-000000000002';
+export const GRANDCHILD_ID = '01a18fa0-0000-7000-8000-000000000003';
+export const CALL_SPAWN = 'call_spawn_builder';
+export const CALL_SPAWN_FAILED = 'call_spawn_failed';
+export const CALL_FOLLOWUP = 'call_followup_builder';
+export const CALL_SEND = 'call_send_builder';
+export const CALL_INTERRUPT = 'call_interrupt_builder';
+export const CALL_SPAWN_GRANDCHILD = 'call_spawn_deep_dive';
+export const CHILD_TURN_ID = '01a18f9d-0000-7000-8000-0000000000t1';
+export const CHILD_PATH = '/root/review_builder';
+export const GRANDCHILD_PATH = '/root/review_builder/deep_dive';
+/** `2026-10-31T01:<minute>:<second>.000Z`. */
+export function at(minute, second = 0) {
+    return `2026-10-31T01:${String(minute).padStart(2, '0')}:${String(second).padStart(2, '0')}.000Z`;
+}
+function numbered(rows) {
+    return rows.map((row, ordinal) => ({ timestamp: row.timestamp, ordinal, ...row }));
+}
+function tokenCount(timestamp, total, last) {
+    return {
+        timestamp,
+        type: 'event_msg',
+        payload: {
+            type: 'token_count',
+            info: {
+                total_token_usage: { input_tokens: total, output_tokens: 0, total_tokens: total },
+                last_token_usage: { input_tokens: last, output_tokens: 0, total_tokens: last },
+            },
+        },
+    };
+}
+function functionCall(timestamp, callId, name, args, namespace = 'collaboration') {
+    return {
+        timestamp,
+        type: 'response_item',
+        payload: {
+            type: 'function_call',
+            status: 'completed',
+            id: `fc_${callId}`,
+            name,
+            ...(namespace ? { namespace } : {}),
+            arguments: JSON.stringify(args),
+            call_id: callId,
+        },
+    };
+}
+function output(timestamp, callId, text) {
+    return {
+        timestamp,
+        type: 'response_item',
+        payload: { type: 'function_call_output', call_id: callId, output: text },
+    };
+}
+function activity(timestamp, threadId, item) {
+    return {
+        timestamp,
+        type: 'event_msg',
+        payload: {
+            type: 'item_completed',
+            thread_id: threadId,
+            turn_id: `${threadId}-turn`,
+            item: { type: 'SubAgentActivity', model: null, reasoning_effort: null, ...item },
+        },
+    };
+}
+function agentMessage(timestamp, id, author, recipient, messageType, payload) {
+    return {
+        timestamp,
+        type: 'response_item',
+        payload: {
+            type: 'agent_message',
+            id,
+            author,
+            recipient,
+            content: [
+                {
+                    type: 'input_text',
+                    text: `Message Type: ${messageType}\nTask name: ${recipient}\nSender: ${author}\nPayload:\n${payload}`,
+                },
+                ...(payload ? [] : [{ type: 'encrypted_content', encrypted_content: 'gAAAA-redacted' }]),
+            ],
+        },
+    };
+}
+function exec(timestamp, callId) {
+    return functionCall(timestamp, callId, 'exec_command', { cmd: 'rg TODO' }, undefined);
+}
+/** The parent session's rollout (ordinals 0…). */
+export function parentRollout(options) {
+    const rows = [
+        {
+            timestamp: at(15),
+            type: 'session_meta',
+            payload: {
+                id: PARENT_ID,
+                session_id: PARENT_ID,
+                timestamp: at(15),
+                cwd: options.cwd,
+                originator: 'codex-tui',
+                cli_version: '0.166.0',
+                source: 'vscode',
+                thread_source: 'user',
+                history_mode: 'paginated',
+                base_instructions: { text: 'Parent base instructions.' },
+            },
+        },
+        {
+            timestamp: at(15, 1),
+            type: 'turn_context',
+            payload: { model: 'gpt-test', cwd: options.cwd },
+        },
+        {
+            timestamp: at(15, 2),
+            type: 'response_item',
+            payload: {
+                type: 'message',
+                role: 'user',
+                content: [{ type: 'input_text', text: 'Review the builder.' }],
+            },
+        },
+        tokenCount(at(15, 3), 1000, 1000),
+        functionCall(at(40, 33), CALL_SPAWN, 'spawn_agent', {
+            task_name: 'review_builder',
+            message: 'gAAAA-redacted',
+        }),
+        options.withoutActivity
+            ? null
+            : activity(at(40, 33), PARENT_ID, {
+                id: CALL_SPAWN,
+                kind: 'started',
+                model: 'gpt-test',
+                reasoning_effort: 'high',
+                agent_thread_id: CHILD_ID,
+                agent_path: CHILD_PATH,
+            }),
+        output(at(40, 34), CALL_SPAWN, JSON.stringify({ task_name: CHILD_PATH })),
+        functionCall(at(40, 35), CALL_SPAWN_FAILED, 'spawn_agent', {
+            task_name: 'review_extra',
+            message: 'gAAAA-redacted',
+        }),
+        output(at(40, 35), CALL_SPAWN_FAILED, 'collab spawn failed: agent thread limit reached'),
+        {
+            timestamp: at(41, 8),
+            type: 'inter_agent_communication_metadata',
+            payload: { trigger_turn: false },
+        },
+        agentMessage(at(41, 8), 'amsg_progress', CHILD_PATH, '/root', 'MESSAGE', ''),
+        options.withoutActivity || options.withoutCompleted
+            ? null
+            : activity(at(42, 21), PARENT_ID, {
+                id: `subagent-completed-${CHILD_TURN_ID}`,
+                kind: 'completed',
+                agent_thread_id: CHILD_ID,
+                agent_path: CHILD_PATH,
+            }),
+        agentMessage(at(42, 25), 'amsg_final', CHILD_PATH, '/root', 'FINAL_ANSWER', 'Found two issues.'),
+        functionCall(at(45, 37), CALL_FOLLOWUP, 'followup_task', {
+            target: 'review_builder',
+            message: 'gAAAA-redacted',
+        }),
+        options.withoutActivity
+            ? null
+            : activity(at(45, 37), PARENT_ID, {
+                id: CALL_FOLLOWUP,
+                kind: 'interacted',
+                agent_thread_id: CHILD_ID,
+                agent_path: CHILD_PATH,
+            }),
+        output(at(45, 38), CALL_FOLLOWUP, ''),
+        functionCall(at(45, 40), CALL_SEND, 'send_message', {
+            target: 'review_builder',
+            message: 'gAAAA-redacted',
+        }),
+        options.withoutActivity
+            ? null
+            : activity(at(45, 40), PARENT_ID, {
+                id: CALL_SEND,
+                kind: 'interacted',
+                agent_thread_id: CHILD_ID,
+                agent_path: CHILD_PATH,
+            }),
+        functionCall(at(46, 0), CALL_INTERRUPT, 'interrupt_agent', { target: 'review_builder' }),
+        options.withoutActivity
+            ? null
+            : activity(at(46, 0), PARENT_ID, {
+                id: CALL_INTERRUPT,
+                kind: 'interrupted',
+                agent_thread_id: CHILD_ID,
+                agent_path: CHILD_PATH,
+            }),
+        tokenCount(at(46, 5), 2000, 1000),
+    ];
+    return numbered(rows.filter((row) => row !== null));
+}
+/** Records the child inherits from the parent (re-stamped at fork time, as Codex does). */
+const INHERITED_RECORDS = 5;
+/** The forked child's rollout: its meta, the parent's history, then its own records. */
+export function childRollout(options) {
+    const start = 1 + INHERITED_RECORDS;
+    return numbered([
+        {
+            timestamp: at(40, 33),
+            type: 'session_meta',
+            payload: {
+                id: CHILD_ID,
+                session_id: PARENT_ID,
+                forked_from_id: PARENT_ID,
+                parent_thread_id: PARENT_ID,
+                timestamp: at(40, 33),
+                cwd: options.cwd,
+                originator: 'codex-tui',
+                cli_version: '0.166.0',
+                source: {
+                    subagent: {
+                        thread_spawn: {
+                            parent_thread_id: PARENT_ID,
+                            depth: 1,
+                            agent_path: CHILD_PATH,
+                            agent_nickname: 'Banach',
+                            agent_role: null,
+                        },
+                    },
+                },
+                thread_source: 'subagent',
+                agent_nickname: 'Banach',
+                agent_path: CHILD_PATH,
+                history_mode: 'paginated',
+                subagent_history_start_ordinal: start,
+                multi_agent_version: 'v2',
+            },
+        },
+        // The parent's history, embedded by the fork.
+        {
+            timestamp: at(40, 33),
+            type: 'session_meta',
+            payload: {
+                id: PARENT_ID,
+                timestamp: at(15),
+                cwd: '/somewhere/else',
+                source: 'vscode',
+                base_instructions: { text: 'Parent base instructions.' },
+            },
+        },
+        { timestamp: at(40, 33), type: 'turn_context', payload: { model: 'gpt-parent' } },
+        exec(at(40, 33), 'call_parent_exec'),
+        tokenCount(at(40, 33), 5000, 5000),
+        {
+            timestamp: at(40, 33),
+            type: 'response_item',
+            payload: {
+                type: 'message',
+                role: 'developer',
+                content: [{ type: 'input_text', text: 'You are now a newly spawned child agent.' }],
+            },
+        },
+        // The child's own records.
+        {
+            timestamp: at(40, 34),
+            type: 'event_msg',
+            payload: { type: 'task_started', turn_id: CHILD_TURN_ID },
+        },
+        { timestamp: at(40, 34), type: 'turn_context', payload: { model: 'gpt-test' } },
+        exec(at(40, 35), 'call_child_exec'),
+        output(at(40, 36), 'call_child_exec', 'Process exited with code 0'),
+        tokenCount(at(40, 37), 300, 300),
+        functionCall(at(40, 38), CALL_SPAWN_GRANDCHILD, 'spawn_agent', {
+            task_name: 'deep_dive',
+            message: 'gAAAA-redacted',
+        }),
+        activity(at(40, 38), CHILD_ID, {
+            id: CALL_SPAWN_GRANDCHILD,
+            kind: 'started',
+            agent_thread_id: GRANDCHILD_ID,
+            agent_path: GRANDCHILD_PATH,
+        }),
+        output(at(40, 39), CALL_SPAWN_GRANDCHILD, JSON.stringify({ task_name: GRANDCHILD_PATH })),
+        tokenCount(at(42, 20), 500, 200),
+    ]);
+}
+/** The grandchild's rollout (depth 2): a fork of the child. */
+export function grandchildRollout(options) {
+    return numbered([
+        {
+            timestamp: at(40, 38),
+            type: 'session_meta',
+            payload: {
+                id: GRANDCHILD_ID,
+                session_id: PARENT_ID,
+                forked_from_id: CHILD_ID,
+                parent_thread_id: CHILD_ID,
+                timestamp: at(40, 38),
+                cwd: options.cwd,
+                cli_version: '0.166.0',
+                source: {
+                    subagent: {
+                        thread_spawn: {
+                            parent_thread_id: CHILD_ID,
+                            depth: 2,
+                            agent_path: GRANDCHILD_PATH,
+                            agent_nickname: 'Noether',
+                            agent_role: 'explorer',
+                        },
+                    },
+                },
+                thread_source: 'subagent',
+                agent_nickname: 'Noether',
+                agent_path: GRANDCHILD_PATH,
+                agent_role: 'explorer',
+                subagent_history_start_ordinal: 3,
+            },
+        },
+        { timestamp: at(40, 38), type: 'session_meta', payload: { id: CHILD_ID, cwd: options.cwd } },
+        exec(at(40, 38), 'call_child_exec'),
+        exec(at(40, 40), 'call_grandchild_exec'),
+        tokenCount(at(40, 41), 50, 50),
+    ]);
+}
+/** Rows as JSONL text. */
+export function toJsonl(rows) {
+    return rows.map((row) => JSON.stringify(row)).join('\n') + '\n';
+}

package/dist/esm/toolCallOrigins.js

@@ -21,6 +21,8 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import * as readline from 'readline';
+import { Readable } from 'stream';
+import { isCompressedRolloutPath, readRolloutBufferAsync, readRolloutHeadAsync, } from './providers/compressedRollouts';
 import { listCandidates, readPromptOrdinalMarks, resolveRoots, } from './promptHistory';
 import { codexRolloutOrigin } from './parsers/codexRolloutOrigin';
 import { realpathOrNull } from './workspaceRoots';
@@ -42,7 +44,9 @@ export async function findToolCallOrigins(options) {
         return found;
     const providers = options.providers ?? ['claude-code', 'codex'];
     const sinceMs = options.since ? options.since.getTime() : null;
-    const candidates = await listCandidates(providers, listingRoots, sinceMs);
+    const candidates = await listCandidates(providers, listingRoots, sinceMs, {
+        includeCompressedRollouts: options.includeCompressedRollouts,
+    });
     const byProviderSession = new Map();
     for (const candidate of candidates) {
         byProviderSession.set(`${candidate.provider}:${candidate.sessionId}`, candidate);
@@ -152,21 +156,15 @@ function claudeSubagentTranscripts(sessionFile, sessionId) {
     }));
 }
 async function readFirstRecord(filePath) {
-    let handle;
     try {
-        handle = await fs.promises.open(filePath, 'r');
-        const buffer = Buffer.alloc(256 * 1024);
-        const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
-        const text = buffer.subarray(0, bytesRead).toString('utf8');
+        // A compressed rollout's head is decompressed.
+        const text = (await readRolloutHeadAsync(filePath, 256 * 1024)).toString('utf8');
         const newline = text.indexOf('\n');
         return JSON.parse(newline === -1 ? text : text.slice(0, newline));
     }
     catch {
         return undefined;
     }
-    finally {
-        await handle?.close();
-    }
 }
 /** Fail-closed scope check on a recorded working directory. */
 function inScope(cwd, roots, realpaths) {
@@ -187,7 +185,16 @@ async function scanForIds(filePath, provider, wanted, roots, realpaths, signal)
     const hits = [];
     let stream;
     try {
-        stream = fs.createReadStream(filePath, { encoding: 'utf8' });
+        if (isCompressedRolloutPath(filePath)) {
+            // Compressed rollouts are complete; search their decompressed content.
+            const content = await readRolloutBufferAsync(filePath);
+            if (!content)
+                return hits;
+            stream = Readable.from([content.toString('utf8')]);
+        }
+        else {
+            stream = fs.createReadStream(filePath, { encoding: 'utf8' });
+        }
     }
     catch {
         return hits;

package/dist/esm/toolCategory.js

@@ -16,7 +16,11 @@ export const TOOL_CATEGORIES = [
     'mcp',
     'other',
 ];
-/** Lower-cased tool names of every provider, by category. */
+/**
+ * Lower-cased tool names of every provider, by category. Codex's bare `wait`
+ * is a code-mode cell wait, not a subagent wait (that is `wait_agent`), so it
+ * is `other`.
+ */
 const CATEGORY_BY_NAME = new Map([
     [
         'shell',
@@ -50,7 +54,7 @@ const CATEGORY_BY_NAME = new Map([
             'send_message',
             'followup_task',
             'list_agents',
-            'wait',
+            'interrupt_agent',
         ],
     ],
     [

package/dist/esm/transcript.js

@@ -1,4 +1,6 @@
 import { calculateNormalizedUsageCost, extractNormalizedUsage, } from './usageNormalization';
+import { isTaskNotificationSystemEvent, isTaskStatusSystemEvent } from './subagentSpawn';
+import { isSubagentActivitySystemEvent } from './subagentActivity';
 const EMPTY_TOTALS = {
     uncachedInputTokens: 0,
     cacheReadTokens: 0,
@@ -25,6 +27,12 @@ export function projectSessionTranscript(events, options = {}) {
     let cwd;
     let gitBranch;
     events.forEach((event, eventIndex) => {
+        // A reader's synthetic notice that a background task finished, not a message.
+        if (isTaskNotificationSystemEvent(event) || isTaskStatusSystemEvent(event))
+            return;
+        // Likewise a subagent lifecycle record (opt-in Codex parser event).
+        if (isSubagentActivitySystemEvent(event))
+            return;
         if (nonEmpty(event.cwd))
             cwd = event.cwd;
         if (nonEmpty(event.gitBranch))

package/dist/esm/turns/assistantTurn.js

@@ -1,10 +1,10 @@
 import { formatToolSummary, truncate } from '../formatters/toolSummary';
+import { SUBAGENT_SPAWN_TOOL_NAMES } from '../subagentSpawn';
 const DEFAULT_NARRATION_CHARS = 4000;
 const DEFAULT_REASONING_CHARS = 8000;
 const DEFAULT_PROCESS_STEPS = 60;
 const DEFAULT_REASONING_BLOCKS = 24;
 const DEFAULT_TOOL_INPUT_CHARS = 200;
-const SUBAGENT_TOOL_NAMES = new Set(['Task']);
 const LABEL_MAX = 80;
 const TITLE_RE = /^\s*\*\*([^*\n]+)\*\*[ \t]*(?:\n+([\s\S]*))?$/;
 const TITLE_MAX = 100;
@@ -22,8 +22,12 @@ export function reasoningSummary(text) {
     }
     return { title: null, body: trimmed };
 }
+/**
+ * Whether a tool call spawns a subagent (`Agent`, or its earlier name `Task`).
+ * Codex `spawn_agent` is not included here (its turns project as before).
+ */
 export function isAssistantTurnSubagentTool(toolName) {
-    return toolName != null && SUBAGENT_TOOL_NAMES.has(toolName);
+    return typeof toolName === 'string' && SUBAGENT_SPAWN_TOOL_NAMES.includes(toolName);
 }
 export function segmentAssistantTurn(events, options = {}) {
     const maxNarrationChars = options.maxNarrationChars ?? DEFAULT_NARRATION_CHARS;

package/dist/esm/usage/claudeUsageDedupe.js

@@ -59,6 +59,25 @@ export function normalizeClaudeUsage(event) {
         },
     };
 }
+const BUCKET_KEYS = ['input', 'cacheRead', 'cacheWrite', 'output', 'reasoning'];
+/** Entries {@link ClaudeUsageDeduper.exportState} keeps by default. */
+const DEFAULT_EXPORT_LIMIT = 256;
+function isCount(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0;
+}
+function bucketsFrom(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const record = value;
+    const buckets = {};
+    for (const key of BUCKET_KEYS) {
+        const count = record[key];
+        if (!isCount(count))
+            return null;
+        buckets[key] = count;
+    }
+    return buckets;
+}
 function bucketsOf(usage) {
     return {
         input: usage.uncachedInputTokens,
@@ -163,6 +182,55 @@ export class ClaudeUsageDeduper {
     reset() {
         this.seen.clear();
     }
+    /**
+     * The most recent `limit` message ids and the tokens counted for each,
+     * oldest first. Split lines of one response are adjacent, so a reader
+     * resumed at the position this was taken at needs only the last few.
+     */
+    exportState(limit = DEFAULT_EXPORT_LIMIT) {
+        const count = limit >= 0 ? Math.min(this.seen.size, Math.floor(limit)) : 0;
+        const entries = [];
+        if (count > 0) {
+            let skip = this.seen.size - count;
+            for (const [id, buckets] of this.seen) {
+                if (skip > 0) {
+                    skip -= 1;
+                    continue;
+                }
+                entries.push([id, { ...buckets }]);
+            }
+        }
+        return { version: 1, entries };
+    }
+    /**
+     * Replaces this deduper's state with one from {@link exportState}. Returns
+     * false, changing nothing, when `state` is not a valid version-1 state
+     * (wrong shape, empty ids, or counts that are not finite non-negative
+     * numbers). Entries beyond this deduper's capacity drop oldest first.
+     */
+    importState(state) {
+        if (!state || typeof state !== 'object')
+            return false;
+        const { version, entries } = state;
+        if (version !== 1 || !Array.isArray(entries))
+            return false;
+        const parsed = [];
+        for (const entry of entries) {
+            if (!Array.isArray(entry) || entry.length !== 2)
+                return false;
+            const [id, value] = entry;
+            if (typeof id !== 'string' || id.length === 0)
+                return false;
+            const buckets = bucketsFrom(value);
+            if (!buckets)
+                return false;
+            parsed.push([id, buckets]);
+        }
+        this.seen.clear();
+        for (const [id, buckets] of parsed)
+            this.remember(id, buckets);
+        return true;
+    }
     remember(id, buckets) {
         this.seen.delete(id);
         this.seen.set(id, buckets);

package/dist/esm/usage/usageEvents.js

@@ -15,7 +15,10 @@
  * tagged with the subagent, and their sizes and mtimes join the fingerprint.
  * (Codex spawned subagents and forks are top-level rollouts, already listed
  * as sessions of their own; their events are tagged with the parent read
- * from the rollout's first line.)
+ * from the rollout's first line; the parent history a forked child embeds
+ * is not counted (it carries no token usage). Compressed rollouts
+ * (`….jsonl.zst`) are read when a Codex provider was created with
+ * `includeCompressedRollouts`.)
  *
  * Each event also carries the ordinal of the human prompt it answered, from
  * the same scanner as `collectPromptHistory()`, so usage joins prompt history

package/dist/esm/watchers/eventBridge.js

@@ -8,6 +8,8 @@
  * FollowEvent is a lossy summary for timeline display and CLI output.
  */
 import { formatToolSummary } from '../formatters/toolSummary';
+import { agentsStoppedNoticeFromEvent, describeAgentsStopped, describeTaskStatus, isAgentsKilledSystemEvent, isTaskNotificationSystemEvent, taskNotificationFromEvent, taskStatusFromEvent, } from '../subagentSpawn';
+import { describeSubagentActivity, subagentActivityFromEvent } from '../subagentActivity';
 /**
  * Converts a single SessionEvent to one or more FollowEvents.
  *
@@ -148,6 +150,49 @@ export function toFollowEvents(event, providerId) {
             break;
         }
         case 'system': {
+            // A background task's notice (opt-in reader event): its summary, not the raw block.
+            const notification = isTaskNotificationSystemEvent(event)
+                ? taskNotificationFromEvent(event)
+                : null;
+            if (notification) {
+                events.push({
+                    providerId,
+                    type: 'system',
+                    timestamp: ts,
+                    summary: notification.summary ?? `Background task ${notification.status ?? 'finished'}`,
+                    raw: event,
+                });
+                break;
+            }
+            // The user stopping background agents, or a background agent's final status.
+            const stopped = agentsStoppedNoticeFromEvent(event);
+            const taskStatus = stopped ? null : taskStatusFromEvent(event);
+            if (stopped || taskStatus || isAgentsKilledSystemEvent(event)) {
+                events.push({
+                    providerId,
+                    type: 'system',
+                    timestamp: ts,
+                    summary: stopped
+                        ? describeAgentsStopped(stopped)
+                        : taskStatus
+                            ? describeTaskStatus(taskStatus)
+                            : describeAgentsStopped(null),
+                    raw: event,
+                });
+                break;
+            }
+            // A subagent lifecycle record (opt-in Codex parser event): a content-free summary.
+            const activity = subagentActivityFromEvent(event);
+            if (activity) {
+                events.push({
+                    providerId,
+                    type: 'system',
+                    timestamp: ts,
+                    summary: describeSubagentActivity(activity),
+                    raw: event,
+                });
+                break;
+            }
             const text = extractTextContent(event.message?.content);
             const label = event.message?.sourceLabel || event.message?.role || 'system';
             const summary = text ||

package/dist/esm/watchers/factory.js

@@ -41,13 +41,15 @@ export function resolveSessionPath(provider, workspacePath, sessionId) {
 export function createWatcher(options) {
     const { provider, workspacePath, sessionId, callbacks } = options;
     const sessionPath = resolveSessionPath(provider, workspacePath, sessionId);
-    const watcher = createWatcherForProvider(provider, sessionPath, callbacks);
+    const watcher = createWatcherForProvider(provider, sessionPath, callbacks, {
+        includeTaskNotifications: options.includeTaskNotifications === true,
+    });
     return { watcher, sessionPath };
 }
-function createWatcherForProvider(provider, sessionPath, callbacks) {
+function createWatcherForProvider(provider, sessionPath, callbacks, jsonlOptions) {
     switch (provider.id) {
         case 'claude-code':
-            return new JsonlSessionWatcher(provider.id, sessionPath, callbacks);
+            return new JsonlSessionWatcher(provider.id, sessionPath, callbacks, jsonlOptions);
         case 'codex':
             return new ProviderReaderSessionWatcher(provider, sessionPath, callbacks);
         case 'opencode': {