sidekick-shared 0.28.3 → 0.29.1

package/dist/schemas/sessionEvent.d.ts

@@ -76,12 +76,12 @@ export declare const userSessionEventSchema: z.ZodObject<{
     promptSource: z.ZodOptional<z.ZodString>;
     cwd: z.ZodOptional<z.ZodString>;
     gitBranch: z.ZodOptional<z.ZodString>;
-    permissionMode: z.ZodOptional<z.ZodEnum<{
+    permissionMode: z.ZodCatch<z.ZodOptional<z.ZodEnum<{
         default: "default";
         acceptEdits: "acceptEdits";
         bypassPermissions: "bypassPermissions";
         plan: "plan";
-    }>>;
+    }>>>;
     rateLimits: z.ZodOptional<z.ZodObject<{
         primary: z.ZodOptional<z.ZodObject<{
             usedPercent: z.ZodNumber;
@@ -165,12 +165,12 @@ export declare const assistantSessionEventSchema: z.ZodObject<{
     promptSource: z.ZodOptional<z.ZodString>;
     cwd: z.ZodOptional<z.ZodString>;
     gitBranch: z.ZodOptional<z.ZodString>;
-    permissionMode: z.ZodOptional<z.ZodEnum<{
+    permissionMode: z.ZodCatch<z.ZodOptional<z.ZodEnum<{
         default: "default";
         acceptEdits: "acceptEdits";
         bypassPermissions: "bypassPermissions";
         plan: "plan";
-    }>>;
+    }>>>;
     rateLimits: z.ZodOptional<z.ZodObject<{
         primary: z.ZodOptional<z.ZodObject<{
             usedPercent: z.ZodNumber;
@@ -255,12 +255,12 @@ export declare const systemSessionEventSchema: z.ZodObject<{
     promptSource: z.ZodOptional<z.ZodString>;
     cwd: z.ZodOptional<z.ZodString>;
     gitBranch: z.ZodOptional<z.ZodString>;
-    permissionMode: z.ZodOptional<z.ZodEnum<{
+    permissionMode: z.ZodCatch<z.ZodOptional<z.ZodEnum<{
         default: "default";
         acceptEdits: "acceptEdits";
         bypassPermissions: "bypassPermissions";
         plan: "plan";
-    }>>;
+    }>>>;
     rateLimits: z.ZodOptional<z.ZodObject<{
         primary: z.ZodOptional<z.ZodObject<{
             usedPercent: z.ZodNumber;
@@ -348,12 +348,12 @@ export declare const toolUseSessionEventSchema: z.ZodObject<{
     promptSource: z.ZodOptional<z.ZodString>;
     cwd: z.ZodOptional<z.ZodString>;
     gitBranch: z.ZodOptional<z.ZodString>;
-    permissionMode: z.ZodOptional<z.ZodEnum<{
+    permissionMode: z.ZodCatch<z.ZodOptional<z.ZodEnum<{
         default: "default";
         acceptEdits: "acceptEdits";
         bypassPermissions: "bypassPermissions";
         plan: "plan";
-    }>>;
+    }>>>;
     rateLimits: z.ZodOptional<z.ZodObject<{
         primary: z.ZodOptional<z.ZodObject<{
             usedPercent: z.ZodNumber;
@@ -442,12 +442,12 @@ export declare const toolResultSessionEventSchema: z.ZodObject<{
     promptSource: z.ZodOptional<z.ZodString>;
     cwd: z.ZodOptional<z.ZodString>;
     gitBranch: z.ZodOptional<z.ZodString>;
-    permissionMode: z.ZodOptional<z.ZodEnum<{
+    permissionMode: z.ZodCatch<z.ZodOptional<z.ZodEnum<{
         default: "default";
         acceptEdits: "acceptEdits";
         bypassPermissions: "bypassPermissions";
         plan: "plan";
-    }>>;
+    }>>>;
     rateLimits: z.ZodOptional<z.ZodObject<{
         primary: z.ZodOptional<z.ZodObject<{
             usedPercent: z.ZodNumber;
@@ -520,6 +520,19 @@ export declare const toolResultSessionEventSchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export declare const sessionEventSchema: z.ZodType<SessionEvent>;
+/** Options for {@link extractSessionEvents}. */
+export interface ExtractSessionEventsOptions {
+    /**
+     * Also turn Claude Code's mid-turn task-notification attachments
+     * (`{ type: 'attachment', attachment: { type: 'queued_command',
+     * commandMode: 'task-notification', prompt } }`) into one `system` event
+     * with `origin: { kind: 'task-notification' }`, `message: { role: 'user',
+     * sourceLabel: 'task notification', content: <prompt> }`, and the line's
+     * timestamp. They report background agents finishing. Default `false`:
+     * attachment lines yield no events.
+     */
+    includeTaskNotifications?: boolean;
+}
 /**
  * Extracts canonical SessionEvents from a raw JSONL value.
  *
@@ -528,5 +541,9 @@ export declare const sessionEventSchema: z.ZodType<SessionEvent>;
  * `sessionEventSchema` alone rejects. This helper tries a direct parse,
  * then unwraps progress envelopes (recursively, in case of nesting).
  * Returns zero events for unrecognized input — never throws.
+ *
+ * The second argument is either the starting progress depth (the original
+ * signature) or an options object.
  */
 export declare function extractSessionEvents(raw: unknown, depth?: number): SessionEvent[];
+export declare function extractSessionEvents(raw: unknown, options?: ExtractSessionEventsOptions): SessionEvent[];

package/dist/schemas/sessionEvent.js

@@ -12,6 +12,7 @@ exports.sessionEventSchema = exports.toolResultSessionEventSchema = exports.tool
 exports.extractSessionEvents = extractSessionEvents;
 const zod_1 = require("zod");
 const usageNormalization_1 = require("./usageNormalization");
+const subagentSpawn_1 = require("../subagentSpawn");
 // ── MessageUsage ──
 exports.messageUsageSchema = zod_1.z.object({
     input_tokens: zod_1.z.number(),
@@ -56,7 +57,9 @@ const eventBaseShape = {
     promptSource: zod_1.z.string().optional(),
     cwd: zod_1.z.string().optional(),
     gitBranch: zod_1.z.string().optional(),
-    permissionMode: exports.permissionModeSchema.optional(),
+    // A mode this release doesn't know (Claude Code added `auto`) is dropped
+    // rather than rejecting the whole line with its prompt or tool results.
+    permissionMode: exports.permissionModeSchema.optional().catch(undefined),
     rateLimits: zod_1.z
         .object({
         primary: zod_1.z
@@ -173,22 +176,21 @@ exports.sessionEventSchema = zod_1.z.union([
 // ── Progress unwrapping ──
 /** Recursion bound for nested progress envelopes; real data nests 1 level. */
 const MAX_PROGRESS_DEPTH = 8;
-/**
- * Extracts canonical SessionEvents from a raw JSONL value.
- *
- * Claude Code wraps subagent/SDK events as
- * `{ type: 'progress', data: { message: <SessionEvent> } }`, which
- * `sessionEventSchema` alone rejects. This helper tries a direct parse,
- * then unwraps progress envelopes (recursively, in case of nesting).
- * Returns zero events for unrecognized input — never throws.
- */
-function extractSessionEvents(raw, depth = 0) {
-    return extractSessionEventsWithProvenance(raw, depth, {});
+function extractSessionEvents(raw, depthOrOptions = 0) {
+    if (typeof depthOrOptions === 'number') {
+        return extractSessionEventsWithProvenance(raw, depthOrOptions, {}, {});
+    }
+    return extractSessionEventsWithProvenance(raw, 0, {}, depthOrOptions ?? {});
 }
-function extractSessionEventsWithProvenance(raw, depth, inherited) {
+function extractSessionEventsWithProvenance(raw, depth, inherited, options) {
     const direct = exports.sessionEventSchema.safeParse(raw);
     if (direct.success)
         return [{ ...inherited, ...direct.data }];
+    if (options.includeTaskNotifications) {
+        const notification = taskNotificationAttachmentEvent(raw);
+        if (notification)
+            return [{ ...inherited, ...notification }];
+    }
     if (depth >= MAX_PROGRESS_DEPTH)
         return [];
     if (typeof raw === 'object' && raw !== null && raw.type === 'progress') {
@@ -197,12 +199,31 @@ function extractSessionEventsWithProvenance(raw, depth, inherited) {
         if (typeof data === 'object' && data !== null) {
             const message = data.message;
             if (typeof message === 'object' && message !== null) {
-                return extractSessionEventsWithProvenance(message, depth + 1, provenance);
+                return extractSessionEventsWithProvenance(message, depth + 1, provenance, options);
             }
         }
     }
     return [];
 }
+/** The `system` event for a task-notification attachment line, or `null`. */
+function taskNotificationAttachmentEvent(raw) {
+    const prompt = (0, subagentSpawn_1.taskNotificationPromptFromAttachment)(raw);
+    if (prompt === null)
+        return null;
+    const line = raw;
+    const candidate = {
+        type: 'system',
+        timestamp: line.timestamp,
+        origin: { kind: 'task-notification' },
+        message: { role: 'user', sourceLabel: 'task notification', content: prompt },
+    };
+    for (const key of ['entrypoint', 'isSidechain', 'cwd', 'gitBranch']) {
+        if (line[key] !== undefined)
+            candidate[key] = line[key];
+    }
+    const parsed = exports.systemSessionEventSchema.safeParse(candidate);
+    return parsed.success ? parsed.data : null;
+}
 function progressProvenance(raw) {
     const value = raw;
     const provenance = {};

package/dist/schemas/transcript.d.ts

@@ -12,6 +12,8 @@ export declare const canonicalTranscriptBlockSchema: z.ZodObject<{
     }>;
     text: z.ZodOptional<z.ZodString>;
     toolName: z.ZodOptional<z.ZodString>;
+    rawToolName: z.ZodOptional<z.ZodString>;
+    mcpServerName: z.ZodOptional<z.ZodString>;
     toolUseId: z.ZodOptional<z.ZodString>;
     input: z.ZodOptional<z.ZodUnknown>;
     output: z.ZodOptional<z.ZodUnknown>;

package/dist/schemas/transcript.js

@@ -20,6 +20,8 @@ exports.canonicalTranscriptBlockSchema = zod_1.z.object({
     type: zod_1.z.enum(['text', 'thinking', 'tool_use', 'tool_result', 'image', 'unknown']),
     text: zod_1.z.string().optional(),
     toolName: zod_1.z.string().optional(),
+    rawToolName: zod_1.z.string().optional(),
+    mcpServerName: zod_1.z.string().optional(),
     toolUseId: zod_1.z.string().optional(),
     input: zod_1.z.unknown().optional(),
     output: zod_1.z.unknown().optional(),
@@ -31,6 +33,8 @@ exports.canonicalTranscriptBlockSchema = zod_1.z.object({
 exports.canonicalToolCallSchema = zod_1.z.object({
     id: zod_1.z.string().optional(),
     name: zod_1.z.string(),
+    rawToolName: zod_1.z.string().optional(),
+    mcpServerName: zod_1.z.string().optional(),
     timestamp: zod_1.z.string(),
     input: zod_1.z.unknown().optional(),
     output: zod_1.z.unknown().optional(),

package/dist/sessionPromptHistory.d.ts

@@ -28,7 +28,13 @@ export interface SessionPromptHistoryBounds {
     maxSessionBytes?: number;
     /** Bytes read across all sessions in one call. Default 256 MiB. */
     maxTotalBytes?: number;
-    /** Largest single log record that is parsed. Default 16 MiB. */
+    /**
+     * Largest single log record that is parsed. Default 16 MiB
+     * (`PROMPT_HISTORY_ORDINAL_MAX_RECORD_BYTES`). A prompt inside a longer
+     * record is never seen, so later ordinals do not count it: ordinals match
+     * `collectPromptHistory()` (and usage events' `promptOrdinal`) only when
+     * both use the default.
+     */
     maxRecordBytes?: number;
     /** Wall-clock budget for the call. Default 60 000 ms. */
     deadlineMs?: number;

package/dist/sessionPromptHistory.js

@@ -56,7 +56,7 @@ const DEFAULT_SESSION_BOUNDS = {
     maxSessions: 1000,
     maxSessionBytes: 256 * 1024 * 1024,
     maxTotalBytes: 256 * 1024 * 1024,
-    maxRecordBytes: promptHistory_1.DEFAULT_BOUNDS.maxRecordBytes,
+    maxRecordBytes: promptHistory_1.PROMPT_HISTORY_ORDINAL_MAX_RECORD_BYTES,
     deadlineMs: 60_000,
 };
 const MAX_EXCLUSIONS = 1000;

package/dist/statusline/payload.d.ts

@@ -0,0 +1,10 @@
+/**
+ * `sidekick-shared/statusline/payload` — the pure Claude Code status-line
+ * stdin parser on its own, for hosts with a tight bundle budget that render
+ * their own line. Loads no account, credential, quota-snapshot, or network
+ * code (the full `sidekick-shared/statusline` entry does).
+ *
+ * @module statusline/payload
+ */
+export { parseClaudeStatuslinePayload, quotaFromStatuslinePayload, } from './claudeStatuslinePayload';
+export type { ClaudeStatuslinePayload, ClaudeStatuslineRateLimitWindow, QuotaFromStatuslineOptions, } from './claudeStatuslinePayload';

package/dist/statusline/payload.js

@@ -0,0 +1,14 @@
+"use strict";
+/**
+ * `sidekick-shared/statusline/payload` — the pure Claude Code status-line
+ * stdin parser on its own, for hosts with a tight bundle budget that render
+ * their own line. Loads no account, credential, quota-snapshot, or network
+ * code (the full `sidekick-shared/statusline` entry does).
+ *
+ * @module statusline/payload
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.quotaFromStatuslinePayload = exports.parseClaudeStatuslinePayload = void 0;
+var claudeStatuslinePayload_1 = require("./claudeStatuslinePayload");
+Object.defineProperty(exports, "parseClaudeStatuslinePayload", { enumerable: true, get: function () { return claudeStatuslinePayload_1.parseClaudeStatuslinePayload; } });
+Object.defineProperty(exports, "quotaFromStatuslinePayload", { enumerable: true, get: function () { return claudeStatuslinePayload_1.quotaFromStatuslinePayload; } });

package/dist/subagentSpawn.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Recognizes Claude Code subagent spawns and background-task notifications.
+ *
+ * Claude Code's subagent tool is `Agent`; `Task` is its earlier name (and the
+ * name OpenCode's `task` tool is normalized to). A background agent's spawning
+ * tool call gets its result right away ("Async agent launched successfully.")
+ * and its completion arrives later as a `<task-notification>` block, delivered
+ * either as a user line or as a mid-turn `queued_command` attachment.
+ *
+ * Pure: no filesystem access, so it is safe for browser bundles.
+ *
+ * @module subagentSpawn
+ */
+import type { SubagentOutcome } from './aggregation/types';
+import type { SessionEvent } from './types/sessionEvent';
+/** Tool names that spawn a subagent: `Agent` (current) and `Task` (earlier name). */
+export declare const SUBAGENT_SPAWN_TOOL_NAMES: readonly string[];
+/** Whether a tool name spawns a subagent (`Agent` or `Task`). */
+export declare function isSubagentSpawnTool(name: string | null | undefined): boolean;
+/** A spawning tool result that launched the agent in the background. */
+export interface AsyncAgentLaunch {
+    /** The agent id Claude Code reported (`agentId: <id>`), when present. */
+    agentId?: string;
+}
+/**
+ * Plain text of tool-result or message content: a string as-is, or the text
+ * blocks of a content array joined by newlines.
+ */
+export declare function contentText(content: unknown): string;
+/**
+ * Recognizes the immediate result of a background spawn
+ * (`Async agent launched successfully.` … `agentId: <id> …`). Accepts the
+ * result text or the raw tool-result content. Returns `null` for anything
+ * else, including a finished foreground agent's result.
+ */
+export declare function parseAsyncAgentLaunch(result: unknown): AsyncAgentLaunch | null;
+/** Fields of a `<task-notification>` block. */
+export interface TaskNotification {
+    /** `<task-id>`: the background agent's id (or a background shell task's id). */
+    taskId: string;
+    /** `<tool-use-id>`: the tool call that started the background work. */
+    toolUseId?: string;
+    /** `<status>` as written, e.g. `completed`, `failed`, `killed`, `stopped`. */
+    status?: string;
+    /** `<summary>`, e.g. `Agent "Explore auth" finished`. */
+    summary?: string;
+    /**
+     * The agent stopped while background work of its own is still running; it
+     * may resume, and the same task id notifies again.
+     */
+    interim: boolean;
+}
+/**
+ * Parses the first `<task-notification>` block in `text`. Whitespace and
+ * newlines between tags, missing fields, and unknown extra fields are
+ * tolerated; the block needs a `<task-id>`. Fields are read before the
+ * agent's own `<result>` output, which may quote anything.
+ */
+export declare function parseTaskNotification(text: unknown): TaskNotification | null;
+/**
+ * The `<task-notification>` prompt of a raw Claude Code attachment line
+ * (`{ type: 'attachment', attachment: { type: 'queued_command', commandMode:
+ * 'task-notification', prompt } }`), which is how a notification that lands
+ * mid-turn is recorded. `null` for any other value.
+ */
+export declare function taskNotificationPromptFromAttachment(raw: unknown): string | null;
+/**
+ * The synthetic `system` event `extractSessionEvents(raw, {
+ * includeTaskNotifications: true })` makes from a mid-turn task-notification
+ * attachment. It is bookkeeping, not a message or a prompt.
+ */
+export declare function isTaskNotificationSystemEvent(event: SessionEvent): boolean;
+/**
+ * The task notification an event carries: a user line with
+ * `origin.kind === 'task-notification'` or whose text starts with
+ * `<task-notification>`, or the opt-in synthetic system event. `null` otherwise.
+ */
+export declare function taskNotificationFromEvent(event: SessionEvent): TaskNotification | null;
+/** Maps a notification `<status>` to an outcome; unknown or missing statuses read as `completed`. */
+export declare function taskNotificationOutcome(status: string | undefined): SubagentOutcome;

package/dist/subagentSpawn.js

@@ -0,0 +1,174 @@
+"use strict";
+/**
+ * Recognizes Claude Code subagent spawns and background-task notifications.
+ *
+ * Claude Code's subagent tool is `Agent`; `Task` is its earlier name (and the
+ * name OpenCode's `task` tool is normalized to). A background agent's spawning
+ * tool call gets its result right away ("Async agent launched successfully.")
+ * and its completion arrives later as a `<task-notification>` block, delivered
+ * either as a user line or as a mid-turn `queued_command` attachment.
+ *
+ * Pure: no filesystem access, so it is safe for browser bundles.
+ *
+ * @module subagentSpawn
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUBAGENT_SPAWN_TOOL_NAMES = void 0;
+exports.isSubagentSpawnTool = isSubagentSpawnTool;
+exports.contentText = contentText;
+exports.parseAsyncAgentLaunch = parseAsyncAgentLaunch;
+exports.parseTaskNotification = parseTaskNotification;
+exports.taskNotificationPromptFromAttachment = taskNotificationPromptFromAttachment;
+exports.isTaskNotificationSystemEvent = isTaskNotificationSystemEvent;
+exports.taskNotificationFromEvent = taskNotificationFromEvent;
+exports.taskNotificationOutcome = taskNotificationOutcome;
+/** Tool names that spawn a subagent: `Agent` (current) and `Task` (earlier name). */
+exports.SUBAGENT_SPAWN_TOOL_NAMES = Object.freeze(['Agent', 'Task']);
+const SPAWN_TOOLS = new Set(exports.SUBAGENT_SPAWN_TOOL_NAMES);
+/** Whether a tool name spawns a subagent (`Agent` or `Task`). */
+function isSubagentSpawnTool(name) {
+    return typeof name === 'string' && SPAWN_TOOLS.has(name);
+}
+const ASYNC_LAUNCH_PREFIX = /^\s*Async agent launched successfully\b/;
+const AGENT_ID_LINE = /(?:^|\n)[ \t]*agentId:[ \t]*([A-Za-z0-9][\w.@-]*)/;
+/**
+ * Plain text of tool-result or message content: a string as-is, or the text
+ * blocks of a content array joined by newlines.
+ */
+function contentText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    const parts = [];
+    for (const block of content) {
+        if (!block || typeof block !== 'object')
+            continue;
+        const typed = block;
+        if (typed.type === 'text' && typeof typed.text === 'string')
+            parts.push(typed.text);
+    }
+    return parts.join('\n');
+}
+/**
+ * Recognizes the immediate result of a background spawn
+ * (`Async agent launched successfully.` … `agentId: <id> …`). Accepts the
+ * result text or the raw tool-result content. Returns `null` for anything
+ * else, including a finished foreground agent's result.
+ */
+function parseAsyncAgentLaunch(result) {
+    const text = contentText(result);
+    if (!ASYNC_LAUNCH_PREFIX.test(text))
+        return null;
+    const match = AGENT_ID_LINE.exec(text);
+    return match ? { agentId: match[1] } : {};
+}
+const NOTIFICATION_OPEN = '<task-notification>';
+const NOTIFICATION_CLOSE = '</task-notification>';
+const NOTIFICATION_PREFIX = /^\s*<task-notification>/;
+const TAG_PATTERNS = {
+    taskId: /<task-id>\s*([\s\S]*?)\s*<\/task-id>/,
+    toolUseId: /<tool-use-id>\s*([\s\S]*?)\s*<\/tool-use-id>/,
+    status: /<status>\s*([\s\S]*?)\s*<\/status>/,
+    summary: /<summary>\s*([\s\S]*?)\s*<\/summary>/,
+    note: /<note>\s*([\s\S]*?)\s*<\/note>/,
+};
+const INTERIM_TEXT = /waiting on its own background work|background work of its own still running/i;
+function tagValue(body, pattern) {
+    const value = pattern.exec(body)?.[1]?.trim();
+    return value ? value : undefined;
+}
+/**
+ * Parses the first `<task-notification>` block in `text`. Whitespace and
+ * newlines between tags, missing fields, and unknown extra fields are
+ * tolerated; the block needs a `<task-id>`. Fields are read before the
+ * agent's own `<result>` output, which may quote anything.
+ */
+function parseTaskNotification(text) {
+    if (typeof text !== 'string')
+        return null;
+    const start = text.indexOf(NOTIFICATION_OPEN);
+    if (start < 0)
+        return null;
+    let body = text.slice(start + NOTIFICATION_OPEN.length);
+    const resultAt = body.indexOf('<result>');
+    let header = resultAt >= 0 ? body.slice(0, resultAt) : body;
+    if (resultAt < 0) {
+        const end = body.indexOf(NOTIFICATION_CLOSE);
+        if (end >= 0)
+            header = body = body.slice(0, end);
+    }
+    if (!TAG_PATTERNS.taskId.test(header))
+        header = body;
+    const taskId = tagValue(header, TAG_PATTERNS.taskId);
+    if (!taskId)
+        return null;
+    const toolUseId = tagValue(header, TAG_PATTERNS.toolUseId);
+    const status = tagValue(header, TAG_PATTERNS.status);
+    const summary = tagValue(header, TAG_PATTERNS.summary);
+    const note = tagValue(header, TAG_PATTERNS.note);
+    return {
+        taskId,
+        ...(toolUseId ? { toolUseId } : {}),
+        ...(status ? { status } : {}),
+        ...(summary ? { summary } : {}),
+        interim: INTERIM_TEXT.test(summary ?? '') || INTERIM_TEXT.test(note ?? ''),
+    };
+}
+/**
+ * The `<task-notification>` prompt of a raw Claude Code attachment line
+ * (`{ type: 'attachment', attachment: { type: 'queued_command', commandMode:
+ * 'task-notification', prompt } }`), which is how a notification that lands
+ * mid-turn is recorded. `null` for any other value.
+ */
+function taskNotificationPromptFromAttachment(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const line = raw;
+    if (line.type !== 'attachment' || !line.attachment || typeof line.attachment !== 'object') {
+        return null;
+    }
+    const attachment = line.attachment;
+    return attachment.type === 'queued_command' &&
+        attachment.commandMode === 'task-notification' &&
+        typeof attachment.prompt === 'string'
+        ? attachment.prompt
+        : null;
+}
+/**
+ * The synthetic `system` event `extractSessionEvents(raw, {
+ * includeTaskNotifications: true })` makes from a mid-turn task-notification
+ * attachment. It is bookkeeping, not a message or a prompt.
+ */
+function isTaskNotificationSystemEvent(event) {
+    return event.type === 'system' && event.origin?.kind === 'task-notification';
+}
+/**
+ * The task notification an event carries: a user line with
+ * `origin.kind === 'task-notification'` or whose text starts with
+ * `<task-notification>`, or the opt-in synthetic system event. `null` otherwise.
+ */
+function taskNotificationFromEvent(event) {
+    if (event.type !== 'user' && event.type !== 'system')
+        return null;
+    const flagged = event.origin?.kind === 'task-notification';
+    if (event.type === 'system' && !flagged)
+        return null;
+    const text = contentText(event.message?.content);
+    if (!flagged && !NOTIFICATION_PREFIX.test(text))
+        return null;
+    return parseTaskNotification(text);
+}
+/** Maps a notification `<status>` to an outcome; unknown or missing statuses read as `completed`. */
+function taskNotificationOutcome(status) {
+    switch (status?.toLowerCase()) {
+        case 'failed':
+            return 'failed';
+        case 'killed':
+            return 'killed';
+        case 'stopped':
+            return 'stopped';
+        default:
+            return 'completed';
+    }
+}

package/dist/testing/credentialGuard.d.ts

@@ -15,6 +15,20 @@ export interface CredentialGuardOptions {
     blockedBinaries?: string[];
     /** Extra real paths to protect, besides the Claude, Codex, and Sidekick homes. */
     protectedPaths?: string[];
+    /**
+     * Home overrides to keep instead of unsetting, for a suite that points one
+     * at its own fixture before the guard installs. Accepts only the variables
+     * the guard unsets: `CLAUDE_CONFIG_DIR`, `CLAUDE_SECURESTORAGE_CONFIG_DIR`,
+     * `CODEX_HOME`, and `SIDEKICK_CONFIG_DIR`.
+     *
+     * Install throws, before changing anything, for any other name, or when a
+     * preserved value is, contains, or lies inside a real protected location:
+     * the real home's `.claude`, `.claude.json`, and `.codex`, the default
+     * Sidekick config dir, or a `protectedPaths` entry. Symlinks are resolved
+     * first. The guard cannot tell a real store kept elsewhere from a fixture,
+     * so preserve only paths the suite created. Blank values are kept unchecked.
+     */
+    preserveEnv?: readonly string[];
 }
 /**
  * Installs the guard once per process and returns it; later calls return the