sidekick-shared 0.29.1 → 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,5 +1,6 @@
 import { calculateNormalizedUsageCost, extractNormalizedUsage, } from './usageNormalization';
-import { isTaskNotificationSystemEvent } from './subagentSpawn';
+import { isTaskNotificationSystemEvent, isTaskStatusSystemEvent } from './subagentSpawn';
+import { isSubagentActivitySystemEvent } from './subagentActivity';
 const EMPTY_TOTALS = {
     uncachedInputTokens: 0,
     cacheReadTokens: 0,
@@ -27,7 +28,10 @@ export function projectSessionTranscript(events, options = {}) {
     let gitBranch;
     events.forEach((event, eventIndex) => {
         // A reader's synthetic notice that a background task finished, not a message.
-        if (isTaskNotificationSystemEvent(event))
+        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;

package/dist/esm/turns/assistantTurn.js

@@ -1,5 +1,5 @@
 import { formatToolSummary, truncate } from '../formatters/toolSummary';
-import { isSubagentSpawnTool } from '../subagentSpawn';
+import { SUBAGENT_SPAWN_TOOL_NAMES } from '../subagentSpawn';
 const DEFAULT_NARRATION_CHARS = 4000;
 const DEFAULT_REASONING_CHARS = 8000;
 const DEFAULT_PROCESS_STEPS = 60;
@@ -22,9 +22,12 @@ export function reasoningSummary(text) {
     }
     return { title: null, body: trimmed };
 }
-/** Whether a tool call spawns a subagent (`Agent`, or its earlier name `Task`). */
+/**
+ * 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 isSubagentSpawnTool(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/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,7 +8,8 @@
  * FollowEvent is a lossy summary for timeline display and CLI output.
  */
 import { formatToolSummary } from '../formatters/toolSummary';
-import { isTaskNotificationSystemEvent, taskNotificationFromEvent } from '../subagentSpawn';
+import { agentsStoppedNoticeFromEvent, describeAgentsStopped, describeTaskStatus, isAgentsKilledSystemEvent, isTaskNotificationSystemEvent, taskNotificationFromEvent, taskStatusFromEvent, } from '../subagentSpawn';
+import { describeSubagentActivity, subagentActivityFromEvent } from '../subagentActivity';
 /**
  * Converts a single SessionEvent to one or more FollowEvents.
  *
@@ -163,6 +164,35 @@ export function toFollowEvents(event, providerId) {
                 });
                 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/jsonlTail.js

@@ -4,6 +4,7 @@
  */
 import * as fs from 'fs';
 import { fileHeadOf, HEAD_BYTES, headMatches } from '../fileHead';
+import { FileContinuity, probeFileContinuity } from '../fileContinuity';
 import { JsonlParser } from '../parsers/jsonl';
 const DEFAULT_DEBOUNCE_MS = 100;
 const DEFAULT_CATCHUP_INTERVAL_MS = 30_000;
@@ -128,10 +129,8 @@ class JsonlTailReader {
     /** Inside a line over `maxLineBytes`: drop bytes until its newline. */
     skippingLine = false;
     currentLine = { offset: 0, length: 0 };
-    /** Identity and prefix of the file the offsets refer to, once read. */
-    identity = null;
-    head = null;
-    lastMtimeMs = -1;
+    /** Identity, mtime, and prefix of the file the offsets refer to, once read. */
+    continuity = new FileContinuity();
     maxReadBytes;
     maxLineBytes;
     rewritePolicy;
@@ -339,21 +338,10 @@ class JsonlTailReader {
     }
     /** Whether the continuity check needs bytes from the file. */
     probeNeeded(stat) {
-        return (this.identity === null ||
-            stat.dev !== this.identity.dev ||
-            stat.ino !== this.identity.ino ||
-            stat.size < this.readOffset ||
-            stat.mtimeMs !== this.lastMtimeMs ||
-            this.head === null ||
-            this.head.bytes < Math.min(HEAD_BYTES, stat.size));
+        return this.continuity.needsProbe(stat, this.readOffset);
     }
     probeSync(fd, stat) {
-        return {
-            prefix: readPrefix(fd, stat),
-            before: this.committedOffset > 0 && this.committedOffset <= stat.size
-                ? readAt(fd, this.committedOffset - 1, 1)
-                : null,
-        };
+        return probeFileContinuity(fd, stat, this.committedOffset);
     }
     async probeAsync(handle, stat) {
         const committedOffset = this.committedOffset;
@@ -370,31 +358,16 @@ class JsonlTailReader {
      * newline. `null` when it can continue.
      */
     resetReason(stat, probe) {
-        if (this.identity && (stat.dev !== this.identity.dev || stat.ino !== this.identity.ino)) {
-            return 'replaced';
-        }
-        if (stat.size < this.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;
+        return this.continuity.reasonFor(stat, this.readOffset, probe);
     }
     /** Records the identity and prefix of the file the offsets now refer to. */
     adoptFile(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);
-        }
+        this.continuity.record(stat, probe);
     }
     reset(reason, offset) {
         const previousOffset = this.committedOffset;
         this.position(offset);
-        this.head = null;
+        this.continuity.discardHead();
         if (reason === 'replaced' && this.active) {
             // fs.watch follows the old inode; watch the file now at the path.
             this.fsWatcher?.close();
@@ -469,7 +442,7 @@ class JsonlTailReader {
         this.position(Math.max(0, offset));
     }
     checkpoint() {
-        return checkpointOf(this.committedOffset, this.identity, this.head);
+        return checkpointOf(this.committedOffset, this.continuity.knownIdentity, this.continuity.knownHead);
     }
     resumeFrom(checkpoint) {
         this.generation += 1;
@@ -487,16 +460,12 @@ class JsonlTailReader {
                     ? lastCompleteLineOffset(fd, stat.size)
                     : 0;
             this.position(offset);
-            this.identity = { dev: stat.dev, ino: stat.ino };
-            this.lastMtimeMs = stat.mtimeMs;
-            this.head = fileHeadOf(prefix);
+            this.continuity.adoptPrefix(stat, prefix);
             return matches;
         }
         catch (error) {
             this.position(0);
-            this.identity = null;
-            this.head = null;
-            this.lastMtimeMs = -1;
+            this.continuity.forget();
             this.options.onError?.(toError(error));
             return false;
         }

package/dist/esm/watchers/jsonlWatcher.js

@@ -6,7 +6,7 @@ import { createJsonlTail } from './jsonlTail';
 import { codexTokenUsageFrom, normalizeCodexToolName, resolveCodexCallUsage, } from '../parsers/codexParser';
 import { formatToolSummary } from '../formatters/toolSummary';
 import { ClaudeUsageDeduper, normalizeClaudeUsage } from '../usage/claudeUsageDedupe';
-import { parseTaskNotification, taskNotificationPromptFromAttachment } from '../subagentSpawn';
+import { describeAgentsStopped, describeTaskStatus, isAgentsKilledSystemEvent, isFinalTaskStatus, parseAgentsStoppedNotice, parseTaskNotification, taskNotificationPromptFromAttachment, taskStatusFromAttachment, } from '../subagentSpawn';
 // ── Normalizers ──
 /**
  * Split lines of one Claude response repeat its usage; run the raw usage
@@ -136,15 +136,25 @@ function normalizeClaudeCodeEvent(raw, deduper, includeTaskNotifications) {
         }
         else if (includeTaskNotifications) {
             // A task notification that landed mid-turn is only an attachment line.
-            const notification = parseTaskNotification(taskNotificationPromptFromAttachment(raw));
+            const prompt = taskNotificationPromptFromAttachment(raw);
+            const notification = parseTaskNotification(prompt);
+            const stopped = notification ? null : parseAgentsStoppedNotice(prompt);
+            const taskStatus = taskStatusFromAttachment(raw);
+            let summary = null;
             if (notification) {
-                events.push({
-                    providerId: 'claude-code',
-                    type: 'system',
-                    timestamp: ts,
-                    summary: notification.summary ?? `Background task ${notification.status ?? 'finished'}`,
-                    raw,
-                });
+                summary = notification.summary ?? `Background task ${notification.status ?? 'finished'}`;
+            }
+            else if (stopped) {
+                summary = describeAgentsStopped(stopped);
+            }
+            else if (taskStatus && isFinalTaskStatus(taskStatus.status)) {
+                summary = describeTaskStatus(taskStatus);
+            }
+            else if (isAgentsKilledSystemEvent(raw)) {
+                summary = describeAgentsStopped(null);
+            }
+            if (summary !== null) {
+                events.push({ providerId: 'claude-code', type: 'system', timestamp: ts, summary, raw });
             }
         }
     }