sidekick-shared 0.28.3 → 0.29.1

package/dist/esm/aggregation/EventAggregator.js

@@ -18,6 +18,7 @@ import { HeatmapTracker } from './HeatmapTracker';
 import { PatternExtractor } from './PatternExtractor';
 import { categorizeError } from '../extractors/errorTaxonomy';
 import { estimateTextTokens } from '../tokenEstimation';
+import { isSubagentSpawnTool, isTaskNotificationSystemEvent, parseAsyncAgentLaunch, parseTaskNotification, taskNotificationFromEvent, taskNotificationOutcome, taskNotificationPromptFromAttachment, } from '../subagentSpawn';
 import { calculateNormalizedUsageCost, extractNormalizedUsage, normalizeProviderUsage, } from '../usageNormalization';
 // ── Defaults ──
 const DEFAULT_TIMELINE_CAP = 200;
@@ -30,6 +31,22 @@ const COMPACTION_DROP_THRESHOLD = 0.8; // >20% drop
 export const SNAPSHOT_SCHEMA_VERSION = 6;
 // ── Goal gate detection regex ──
 const GOAL_GATE_REGEX = /\b(CRITICAL|MUST|blocker|required|must.?complete|goal.?gate|essential|do.?not.?skip|blocking)\b/i;
+// ── Task notifications delivered as attachments ──
+/**
+ * The notification a `system` FollowEvent carries when it stands for a
+ * mid-turn task-notification attachment (its `raw` is the attachment line or
+ * the SessionEvent `extractSessionEvents` made from it).
+ */
+function taskNotificationFromAttachmentFollowEvent(event) {
+    const raw = event.raw;
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const prompt = taskNotificationPromptFromAttachment(raw);
+    if (prompt !== null)
+        return parseTaskNotification(prompt);
+    const asEvent = raw;
+    return isTaskNotificationSystemEvent(asEvent) ? taskNotificationFromEvent(asEvent) : null;
+}
 // ── Todo dependency parsing ──
 /**
  * Parses dependency references from a todo item's content text.
@@ -168,6 +185,17 @@ export class EventAggregator {
     // processEvent — main entry for SessionEvent
     // ═══════════════════════════════════════════════════════════════════════
     processEvent(event) {
+        // Opt-in mid-turn task notifications (`extractSessionEvents` with
+        // `includeTaskNotifications`) only finish background subagents and mark
+        // the timeline: they are not messages, prompts, context, or activity.
+        if (isTaskNotificationSystemEvent(event)) {
+            const notification = taskNotificationFromEvent(event);
+            if (notification) {
+                this.applyTaskNotification(notification, event.timestamp);
+                this.addTaskNotificationTimeline(event.timestamp, notification);
+            }
+            return;
+        }
         // 1. Increment counters, capture timestamps
         this.eventCount++;
         if (!this.sessionStartTime) {
@@ -233,6 +261,15 @@ export class EventAggregator {
     // processFollowEvent — adapter for CLI FollowEvent format
     // ═══════════════════════════════════════════════════════════════════════
     processFollowEvent(event) {
+        // A mid-turn task-notification attachment, like its SessionEvent form above.
+        if (event.type === 'system') {
+            const notification = taskNotificationFromAttachmentFollowEvent(event);
+            if (notification) {
+                this.applyTaskNotification(notification, event.timestamp);
+                this.addTaskNotificationTimeline(event.timestamp, notification);
+                return;
+            }
+        }
         // 1. Increment counters, capture timestamps
         this.eventCount++;
         if (!this.sessionStartTime) {
@@ -626,6 +663,14 @@ export class EventAggregator {
         this.pendingToolCalls.clear();
         this.pendingTaskCreates.clear();
         this.pendingSubagents.clear();
+        // A spawn still waiting for its tool_result is resolved by that result,
+        // which can land after the snapshot boundary. Background agents need no
+        // entry: their notifications are matched against every subagent.
+        this.subagents.forEach((agent, idx) => {
+            if (agent.status === 'running' && !agent.background && agent.id) {
+                this.pendingSubagents.set(agent.id, idx);
+            }
+        });
         this.pendingUserRequest = null;
         this.planExtractor.reset();
         return true;
@@ -1104,7 +1149,7 @@ export class EventAggregator {
                 else if (name === 'UpdatePlan') {
                     this.handleUpdatePlan(input, new Date(event.timestamp));
                 }
-                else if ((name === 'Agent' || name === 'Task') && toolUseId) {
+                else if (isSubagentSpawnTool(name) && toolUseId) {
                     this.handleAgentSpawn(toolUseId, input, new Date(event.timestamp));
                 }
             }
@@ -1114,7 +1159,7 @@ export class EventAggregator {
                     continue;
                 const isError = block.is_error ?? false;
                 this.resolveTaskCreate(toolUseId, block.content ?? block.output, event.timestamp, isError);
-                this.resolveAgentResult(toolUseId, isError, event.timestamp);
+                this.resolveAgentResult(toolUseId, isError, event.timestamp, block.content ?? block.output);
             }
         }
     }
@@ -1148,7 +1193,7 @@ export class EventAggregator {
             else if (event.toolName === 'UpdatePlan') {
                 this.handleUpdatePlan(input, new Date(event.timestamp));
             }
-            else if ((event.toolName === 'Agent' || event.toolName === 'Task') && toolUseId) {
+            else if (isSubagentSpawnTool(event.toolName) && toolUseId) {
                 this.handleAgentSpawn(toolUseId, input, new Date(event.timestamp));
             }
         }
@@ -1160,7 +1205,7 @@ export class EventAggregator {
                 return;
             const isError = raw.is_error ?? false;
             this.resolveTaskCreate(toolUseId, raw.content, event.timestamp, isError);
-            this.resolveAgentResult(toolUseId, isError, event.timestamp);
+            this.resolveAgentResult(toolUseId, isError, event.timestamp, raw.content);
         }
     }
     applyTaskUpdate(input) {
@@ -1465,11 +1510,14 @@ export class EventAggregator {
         };
         this.tasks.set(agentTaskId, task);
     }
-    resolveAgentResult(toolUseId, isError, timestamp) {
+    resolveAgentResult(toolUseId, isError, timestamp, content) {
         const agentTaskId = `agent-${toolUseId}`;
         const agentTask = this.tasks.get(agentTaskId);
         if (!agentTask)
             return;
+        // A background launch returns at once; its task notification finishes it.
+        if (!isError && parseAsyncAgentLaunch(content))
+            return;
         agentTask.status = isError ? 'deleted' : 'completed';
         agentTask.updatedAt = new Date(timestamp);
     }
@@ -1489,31 +1537,25 @@ export class EventAggregator {
     // Private: Subagent Tracking from SessionEvent
     // ═══════════════════════════════════════════════════════════════════════
     extractSubagentFromEvent(event) {
+        const notification = taskNotificationFromEvent(event);
+        if (notification)
+            this.applyTaskNotification(notification, event.timestamp);
         const content = event.message?.content;
         if (!Array.isArray(content))
             return;
         for (const block of content) {
-            if (block.type === 'tool_use' && block.name === 'Task') {
+            if (block.type === 'tool_use' && isSubagentSpawnTool(block.name)) {
                 const input = block.input;
                 const toolUseId = block.id;
                 if (!input || !toolUseId)
                     continue;
-                const info = {
-                    id: toolUseId,
-                    description: input.description || 'Unknown task',
-                    subagentType: input.subagent_type || input.subagentType || 'general',
-                    spawnTime: event.timestamp,
-                    status: 'running',
-                };
-                const idx = this.subagents.length;
-                this.subagents.push(info);
-                this.pendingSubagents.set(toolUseId, idx);
+                this.trackSubagentSpawn(toolUseId, input, event.timestamp);
             }
             else if (block.type === 'tool_result') {
                 const toolUseId = block.tool_use_id;
                 if (!toolUseId)
                     continue;
-                this.completeSubagent(toolUseId, event.timestamp);
+                this.resolveSubagentResult(toolUseId, block.content ?? block.output, block.is_error === true, event.timestamp);
             }
         }
     }
@@ -1522,23 +1564,10 @@ export class EventAggregator {
     // ═══════════════════════════════════════════════════════════════════════
     extractSubagentFromFollowEvent(event) {
         const raw = event.raw;
-        if (event.type === 'tool_use' && event.toolName === 'Task') {
+        if (event.type === 'tool_use' && isSubagentSpawnTool(event.toolName)) {
             if (!raw?.input)
                 return;
-            const input = raw.input;
-            const toolUseId = raw.id || '';
-            const info = {
-                id: toolUseId,
-                description: input.description || 'Unknown task',
-                subagentType: input.subagent_type || input.subagentType || 'general',
-                spawnTime: event.timestamp,
-                status: 'running',
-            };
-            const idx = this.subagents.length;
-            this.subagents.push(info);
-            if (toolUseId) {
-                this.pendingSubagents.set(toolUseId, idx);
-            }
+            this.trackSubagentSpawn(raw.id || '', raw.input, event.timestamp);
         }
         else if (event.type === 'tool_result') {
             if (!raw)
@@ -1546,23 +1575,133 @@ export class EventAggregator {
             const toolUseId = raw.tool_use_id;
             if (!toolUseId)
                 return;
-            this.completeSubagent(toolUseId, event.timestamp);
+            this.resolveSubagentResult(toolUseId, raw.content, raw.is_error === true, event.timestamp);
+        }
+        else if (event.type === 'user' && raw?.type === 'user') {
+            // Claude Code delivers most task notifications as their own user line.
+            const notification = taskNotificationFromEvent(raw);
+            if (notification)
+                this.applyTaskNotification(notification, event.timestamp);
+        }
+    }
+    trackSubagentSpawn(toolUseId, input, timestamp) {
+        const info = {
+            id: toolUseId,
+            description: input.description || 'Unknown task',
+            subagentType: input.subagent_type || input.subagentType || 'general',
+            spawnTime: timestamp,
+            status: 'running',
+        };
+        const idx = this.subagents.length;
+        this.subagents.push(info);
+        if (toolUseId) {
+            this.pendingSubagents.set(toolUseId, idx);
         }
     }
-    completeSubagent(toolUseId, timestamp) {
+    /**
+     * The spawning tool call's result. A foreground agent ends here; a
+     * background launch only reports the agent id, and the agent keeps running
+     * until its task notification arrives.
+     */
+    resolveSubagentResult(toolUseId, content, isError, timestamp) {
         const idx = this.pendingSubagents.get(toolUseId);
         if (idx === undefined)
             return;
-        this.pendingSubagents.delete(toolUseId);
+        const launch = isError ? null : parseAsyncAgentLaunch(content);
+        if (launch) {
+            this.markBackgroundLaunch(idx, launch);
+            return;
+        }
+        this.completeSubagent(toolUseId, timestamp, isError ? 'failed' : 'completed');
+    }
+    markBackgroundLaunch(idx, launch) {
         const agent = this.subagents[idx];
+        this.pendingSubagents.delete(agent.id);
+        agent.background = true;
+        if (launch.agentId)
+            agent.agentId = launch.agentId;
+    }
+    completeSubagent(toolUseId, timestamp, outcome = 'completed') {
+        const idx = this.pendingSubagents.get(toolUseId);
+        if (idx === undefined)
+            return;
+        this.finishSubagent(this.subagents[idx], timestamp, outcome);
+    }
+    finishSubagent(agent, timestamp, outcome) {
+        this.pendingSubagents.delete(agent.id);
         agent.status = 'completed';
         agent.completionTime = timestamp;
+        agent.outcome = outcome;
         const start = new Date(agent.spawnTime).getTime();
         const end = new Date(timestamp).getTime();
         if (!isNaN(start) && !isNaN(end) && end >= start) {
             agent.durationMs = end - start;
         }
     }
+    /**
+     * Applies a background task's notification to the subagent it reports on,
+     * matched by the spawning tool_use id (or by agent id when the notification
+     * has none). The latest notification wins: an interim one ("waiting on its
+     * own background work") keeps or puts the agent back to running, a final one
+     * completes it. Notifications for background shell tasks match nothing.
+     */
+    applyTaskNotification(notification, timestamp) {
+        const agent = this.findNotifiedSubagent(notification);
+        const toolUseId = agent?.id || notification.toolUseId;
+        const outcome = taskNotificationOutcome(notification.status);
+        if (agent) {
+            agent.background = true;
+            if (!agent.agentId)
+                agent.agentId = notification.taskId;
+            if (notification.interim) {
+                this.pendingSubagents.delete(agent.id);
+                agent.status = 'running';
+                delete agent.completionTime;
+                delete agent.durationMs;
+                delete agent.outcome;
+            }
+            else {
+                this.finishSubagent(agent, timestamp, outcome);
+            }
+        }
+        const agentTask = toolUseId ? this.tasks.get(`agent-${toolUseId}`) : undefined;
+        if (agentTask?.isSubagent) {
+            agentTask.status = notification.interim
+                ? 'in_progress'
+                : outcome === 'failed'
+                    ? 'deleted'
+                    : 'completed';
+            agentTask.updatedAt = new Date(timestamp);
+        }
+    }
+    findNotifiedSubagent(notification) {
+        const { toolUseId, taskId } = notification;
+        for (let i = this.subagents.length - 1; i >= 0; i--) {
+            if (toolUseId && this.subagents[i].id === toolUseId)
+                return this.subagents[i];
+        }
+        for (let i = this.subagents.length - 1; i >= 0; i--) {
+            if (this.subagents[i].agentId === taskId)
+                return this.subagents[i];
+        }
+        return undefined;
+    }
+    addTaskNotificationTimeline(timestamp, notification) {
+        let description = notification.summary ?? `Background task ${notification.status ?? 'finished'}`;
+        if (description.length > 200)
+            description = description.substring(0, 197) + '...';
+        this.timeline.push({
+            type: 'tool_result',
+            timestamp,
+            description,
+            noiseLevel: 'system',
+            messageClassification: 'system',
+            ...(notification.toolUseId ? { metadata: { toolUseId: notification.toolUseId } } : {}),
+        });
+        if (this.timeline.length > this.timelineCap) {
+            this.timeline.shift();
+        }
+    }
     // ═══════════════════════════════════════════════════════════════════════
     // Private: Plan Extraction from SessionEvent
     // ═══════════════════════════════════════════════════════════════════════

package/dist/esm/aggregation/snapshot.js

@@ -2,14 +2,18 @@
  * Session snapshot sidecar — persists aggregator state + reader position
  * so that re-attaching to a session skips full replay.
  *
- * Snapshots are stored in ~/.config/sidekick/snapshots/{sessionId}.json.
- * They are invalidated when the source file changes beyond the snapshot position.
+ * Snapshots are stored in `<config dir>/snapshots/{sessionId}.json` (see
+ * `getConfigDir()`). They are invalidated when the source file shrank below
+ * the snapshot position or, for file-backed sessions that recorded a
+ * {@link SessionSnapshot.sourceCheckpoint}, when the file is no longer the
+ * same append-only file.
  *
  * @module aggregation/snapshot
  */
 import * as fs from 'fs';
 import * as path from 'path';
 import { getConfigDir } from '../paths';
+import { verifyJsonlCheckpoint } from '../watchers/jsonlTail';
 import { atomicWriteJsonSync } from '../writers/atomic';
 import { SNAPSHOT_SCHEMA_VERSION } from './EventAggregator';
 /** Current schema version — bump when format changes. */
@@ -101,8 +105,8 @@ export function pruneSnapshots(keep = MAX_SNAPSHOT_FILES) {
  * - Schema version doesn't match
  * - JSON parse fails
  *
- * The caller is responsible for staleness checks (comparing sourceSize
- * and readerPosition against the actual file).
+ * The caller is responsible for staleness checks against the actual file:
+ * `isSnapshotValid(snapshot, currentSize, sourcePath)`.
  */
 export function loadSnapshot(sessionId) {
     try {
@@ -142,13 +146,21 @@ export function deleteSnapshot(sessionId) {
 /**
  * Validates whether a snapshot is still usable for a given source file.
  *
- * For JSONL providers: checks that the file hasn't been truncated
- * (current size >= snapshot position) and that the size matches or has grown.
- *
  * For DB-backed providers: sourceSize is 0, so we always consider valid
  * (the DB reader's timestamp-based cursor handles staleness naturally).
+ *
+ * For JSONL providers: the file must not have shrunk below the snapshot
+ * position. With `sourcePath` the check is also content-aware: the snapshot
+ * must carry a {@link SessionSnapshot.sourceCheckpoint} for exactly
+ * `readerPosition`, and that checkpoint must still match the file at
+ * `sourcePath` (same device and inode, same first bytes, position just after
+ * a newline), so a file replaced by another one or rewritten to the same or
+ * a larger size is not resumed mid-content. A snapshot without a checkpoint
+ * (written before 0.29.1) is invalid when `sourcePath` is given, which costs
+ * one full replay. Without `sourcePath` only the size check applies, as it
+ * did before.
  */
-export function isSnapshotValid(snapshot, currentSourceSize) {
+export function isSnapshotValid(snapshot, currentSourceSize, sourcePath) {
     // DB-backed providers store sourceSize=0 — always valid (cursor is a timestamp)
     if (snapshot.sourceSize === 0) {
         return true;
@@ -157,5 +169,15 @@ export function isSnapshotValid(snapshot, currentSourceSize) {
     if (currentSourceSize < snapshot.readerPosition) {
         return false;
     }
-    return true;
+    if (typeof sourcePath !== 'string') {
+        return true;
+    }
+    // Snapshot content comes from disk: guard the shape before trusting it.
+    const checkpoint = snapshot.sourceCheckpoint;
+    if (!checkpoint ||
+        typeof checkpoint !== 'object' ||
+        checkpoint.offset !== snapshot.readerPosition) {
+        return false;
+    }
+    return verifyJsonlCheckpoint(sourcePath, checkpoint);
 }

package/dist/esm/authStatus.js

@@ -0,0 +1,87 @@
+/**
+ * Pure parsers for the provider CLIs' read-only sign-in status commands,
+ * `claude auth status --json` and `codex login status`. They do no I/O. The
+ * caller runs the command with its own environment, home, and timeout, and
+ * passes the output here.
+ *
+ * A status command reports which credential the CLI would use. It does not
+ * prove that a request will authenticate: an expired or revoked token can
+ * still read as logged in.
+ *
+ * @module authStatus
+ */
+/** Larger outputs are not a status report; reading stops there. */
+const MAX_STATUS_OUTPUT = 256 * 1024;
+const MAX_DETAIL = 200;
+function stringField(record, key) {
+    const value = record[key];
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed && trimmed.length <= 512 ? trimmed : undefined;
+}
+function parseJsonObject(output) {
+    const trimmed = output.trim();
+    const candidates = [trimmed];
+    // Tolerate warning lines printed ahead of the JSON document, which must
+    // then start a line and run to the end of the output.
+    const start = trimmed.search(/\n[ \t]*\{/);
+    if (start >= 0)
+        candidates.push(trimmed.slice(start).trim());
+    for (const candidate of candidates) {
+        if (!candidate.startsWith('{') || !candidate.endsWith('}'))
+            continue;
+        try {
+            const parsed = JSON.parse(candidate);
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed))
+                return parsed;
+        }
+        catch {
+            /* Try the next candidate. */
+        }
+    }
+    return undefined;
+}
+/**
+ * Parse the stdout of `claude auth status --json`. Claude Code exits 1 while
+ * printing valid signed-out JSON, so parse stdout whatever the exit status
+ * was. Only a JSON `"loggedIn": true` counts as logged in.
+ */
+export function parseClaudeAuthStatus(stdout) {
+    const raw = typeof stdout === 'string' && stdout.length <= MAX_STATUS_OUTPUT
+        ? parseJsonObject(stdout)
+        : undefined;
+    if (!raw)
+        return { loggedIn: false };
+    const method = stringField(raw, 'authMethod');
+    const email = stringField(raw, 'email');
+    const subscriptionType = stringField(raw, 'subscriptionType');
+    return {
+        loggedIn: raw.loggedIn === true,
+        ...(method ? { method } : {}),
+        ...(email ? { email } : {}),
+        ...(subscriptionType ? { subscriptionType } : {}),
+        raw,
+    };
+}
+/**
+ * Parse the output of `codex login status`. Codex prints its status line to
+ * stderr (`Logged in using ChatGPT`, `Logged in using an API key - sk-…`,
+ * `Not logged in`), so pass both streams. The exit status is not consulted:
+ * callers that require exit 0 check it themselves.
+ */
+export function parseCodexLoginStatus(stdout, stderr) {
+    const combined = `${typeof stdout === 'string' ? stdout : ''}\n${typeof stderr === 'string' ? stderr : ''}`.trim();
+    const firstLine = combined.split(/\r?\n/, 1)[0]?.trim() ?? '';
+    const detail = (/^(Logged in using .*?API key)\s+-\s.*$/i.exec(firstLine)?.[1] ?? firstLine)
+        .slice(0, MAX_DETAIL)
+        .trim();
+    const withDetail = detail ? { detail } : {};
+    if (!/^Logged in/i.test(combined))
+        return { loggedIn: false, ...withDetail };
+    if (/API key/i.test(combined))
+        return { loggedIn: true, method: 'api-key', ...withDetail };
+    if (/ChatGPT/i.test(combined))
+        return { loggedIn: true, method: 'chatgpt', ...withDetail };
+    return { loggedIn: true, ...withDetail };
+}

package/dist/esm/browser.js

@@ -17,17 +17,20 @@ export { addLocalDays, formatDurationMs, formatLocalDateKey, formatTokenCount, p
 export { parseMcpToolName } from './parsers/mcpToolName';
 export { buildSessionContextSnapshot, calculateSessionContextPressure, createSessionContextProjector, } from './context/sessionContext';
 export { ACCOUNT_PROVIDER_IDS, MODEL_PROVIDER_IDS, QUOTA_PROVIDER_IDS, RUNTIME_QUOTA_PROVIDER_IDS, SESSION_PROVIDER_IDS, } from './providerIds';
+export { SUBAGENT_SPAWN_TOOL_NAMES, isSubagentSpawnTool, isTaskNotificationSystemEvent, parseTaskNotification, taskNotificationFromEvent, } from './subagentSpawn';
 export { assistantTurnEventsFromSessionEvents, extractTurnSubagents, isAssistantTurnSubagentTool, reasoningSummary, segmentAssistantTurn, } from './turns/assistantTurn';
-export { parseModelId, getModelPricing, resolveModelPricing, getModelInfo, calculateCost, calculateCostWithPricing, calculateCostWithProvenance, mergeCostSources, shortModelName, getModelDisplayInfo, compareModelIds, sortModelIds, formatCost, } from './modelInfo';
+export { parseModelId, getModelPricing, resolveModelPricing, getModelInfo, calculateCost, calculateCostWithPricing, calculateCostWithProvenance, mergeCostSources, shortModelName, getModelDisplayInfo, compareModelIds, sortModelIds, formatCost, canonicalModelId, isMovingModelAlias, registerModelPricing, clearRegisteredModelPricing, getPricingCatalogInfo, costSourceFromPricingProvenance, mergeCostComponents, } from './modelInfo';
 export { exportResolvedModelCatalog, importResolvedModelCatalog, registerModelAlias, resolveModelAlias, RESOLVED_MODEL_CATALOG_SCHEMA_VERSION, } from './modelCatalog';
 export { BILLING_BLOCK_DURATION_MS, computeBillingBlocks, findActiveBillingBlock, } from './usage/billingBlocks';
 export { bucketUsage, summarizeUsageRows, usageBucketKey, weekKey } from './usage/usageReports';
 export { applySessionSummary, isFileImported, markFileImported, removeSessionSummary, sessionSummaryFromStats, } from './historicalStore';
 export { FAILING_TOOL_TREND_ARROWS, failingToolTrend, mergeFailingToolWindows, } from './failingTools';
-export { diagnoseProviderFailure, PROVIDER_AUTHENTICATION_SOURCES, PROVIDER_AUTHENTICATION_STATES, PROVIDER_CREDENTIAL_KINDS, PROVIDER_FAILURE_CODES, PROVIDER_FAILURE_EVIDENCE_SOURCES, PROVIDER_RECOVERY_ACTIONS, } from './providerFailure';
+export { diagnoseProviderFailure, PROVIDER_AUTHENTICATION_SOURCES, PROVIDER_AUTHENTICATION_STATES, PROVIDER_CREDENTIAL_KINDS, PROVIDER_FAILURE_CODES, PROVIDER_FAILURE_EVIDENCE_SOURCES, PROVIDER_RECOVERY_ACTIONS, CODEX_ERROR_INFO_KINDS, decodeCodexErrorInfo, } from './providerFailure';
+export { parseClaudeAuthStatus, parseCodexLoginStatus } from './authStatus';
 export { isAggregateCodexLimit } from './types/codex';
 // Codex rollout parsing (pure: no filesystem access)
 export { CodexRolloutParser, DEFAULT_MAX_TRACKED_TOOL_CALLS, extractPatchFilePaths, normalizeCodexToolName, normalizeCodexToolInput, resolveCodexCallUsage, } from './parsers/codexParser';
+export { codexRolloutOrigin, codexSpawnParentFromSource } from './parsers/codexRolloutOrigin';
 export { HUMAN_CLAUDE_ENTRYPOINTS, HUMAN_CODEX_SOURCES, humanPromptText, isHumanPrompt, } from './humanPrompt';
 export { renderHandoffUrlTemplate } from './handoffUrl';
 // Tool categories across providers

package/dist/esm/codex.js

@@ -0,0 +1,18 @@
+/**
+ * `sidekick-shared/codex` — a small Node-only entry for Codex homes, the
+ * child-process environment, `auth.json` helpers, credential-store mode,
+ * rollout lookup, and the atomic JSON writers those helpers rely on.
+ *
+ * Loads a handful of modules and no Zod, so a host that only launches or
+ * locates Codex does not pay for the full `sidekick-shared/node` surface.
+ * Everything here is also exported from the package root and from
+ * `sidekick-shared/node`.
+ *
+ * @module codex
+ */
+export { getSystemCodexHome, resolveSidekickCodexHome, getCodexExecutionEnv, getCodexMonitoringHomes, getCodexSessionsDirs, getCodexCredentialStoreMode, forceFileCredentialStore, CODEX_SESSIONS_SUBDIR, CODEX_ARCHIVED_SESSIONS_SUBDIR, } from './codexPaths';
+export { parseAuthJson as parseCodexAuthJson, readAuthIdentityFromRaw as readCodexAuthIdentity, readLastRefresh as readCodexLastRefresh, readAccessTokenExpiry as readCodexAccessTokenExpiry, identitiesMatch as codexIdentitiesMatch, codexRefreshFingerprint, compareCodexAuthFreshness, } from './codexAuth';
+export { findCodexRolloutFile } from './providers/codexRollouts';
+export { atomicWriteJson, atomicWriteJsonSync } from './writers/atomic';
+export { parseClaudeAuthStatus, parseCodexLoginStatus } from './authStatus';
+export { codexRolloutOrigin, codexSpawnParentFromSource } from './parsers/codexRolloutOrigin';

package/dist/esm/codexProfiles.js

@@ -7,6 +7,7 @@ import { getAccountsDir, getActiveSavedAccount, listSavedAccountProfiles, remove
 // re-serializing would drop fields added by newer codex versions, and the
 // rotated refresh token inside is only valid in its freshest form.
 import { atomicWriteFileSync as atomicWriteFile, atomicWriteJsonSync as atomicWriteJson, withFileLockSync, } from './writers/atomic';
+import { parseCodexLoginStatus } from './authStatus';
 import { identitiesMatch, codexRefreshFingerprint, compareCodexAuthFreshness, readAuthIdentityFromRaw, readLastRefresh, STALE_AUTH_THRESHOLD_MS, } from './codexAuth';
 import { ensureCodexProfileDirs, forceFileCredentialStore, getCodexCredentialStoreMode, getCodexProfileDir, getCodexProfileHome, getCodexProfileStatePath, getCodexBackupPath, getCodexLoginDir, getCodexLoginsDir, getCodexLoginHome, getCodexLoginStatePath, getCodexProfilesDir, getSystemCodexHome, readFileOrNull, resolveSidekickCodexHome, } from './codexPaths';
 import { getAccountHealth, readHealthSidecar, writeCodexHealthSidecar, } from './accountHealth';
@@ -206,18 +207,14 @@ function readMetadataFromLegacyCredentials(codexHome) {
     return {};
 }
 const PROBE_TIMEOUT_MS = 4000;
+/** `codex login status` counts only on exit 0; the text is read by {@link parseCodexLoginStatus}. */
 export function parseCodexLoginStatusOutput(status, stdout) {
-    const trimmed = stdout.trim();
-    if (status === 0 && /^Logged in/i.test(trimmed)) {
-        if (/API key/i.test(trimmed)) {
-            return { loggedIn: true, authMode: 'api-key' };
-        }
-        if (/ChatGPT/i.test(trimmed)) {
-            return { loggedIn: true, authMode: 'chatgpt' };
-        }
-        return { loggedIn: true };
-    }
-    return { loggedIn: false };
+    if (status !== 0)
+        return { loggedIn: false };
+    const parsed = parseCodexLoginStatus(stdout);
+    if (!parsed.loggedIn)
+        return { loggedIn: false };
+    return parsed.method ? { loggedIn: true, authMode: parsed.method } : { loggedIn: true };
 }
 /**
  * Blocks the caller's event loop for up to {@link PROBE_TIMEOUT_MS}. Async code

package/dist/esm/context/sessionContext.js

@@ -8,6 +8,7 @@ import { EventAggregator } from '../aggregation/EventAggregator';
 import { getModelContextWindowSize } from '../modelContext';
 import { parseMcpToolName } from '../parsers/mcpToolName';
 import { estimateTextTokens } from '../tokenEstimation';
+import { isTaskNotificationSystemEvent } from '../subagentSpawn';
 const DEFAULT_CONTEXT_SOURCE_LIMIT = 200;
 const DEFAULT_SNIPPET_MAX_CHARS = 240;
 const DEFAULT_BODY_MAX_CHARS = 5000;
@@ -205,6 +206,9 @@ function extractSourcesFromEvent(event, state) {
     }
 }
 function extractSystemSource(event, state) {
+    // Background-task notices only update subagent lifecycles (like the aggregator).
+    if (isTaskNotificationSystemEvent(event))
+        return;
     const message = event.message;
     const text = extractText(message?.content);
     const label = message?.sourceLabel ?? message?.role ?? 'system';

package/dist/esm/formatters/toolSummary.js

@@ -7,6 +7,7 @@
  *
  * @module formatters/toolSummary
  */
+import { ownValue } from '../ownKey';
 // ── Helpers ──
 function truncate(text, maxLen) {
     const clean = text.replace(/\s+/g, ' ').trim();
@@ -171,6 +172,8 @@ const TOOL_FORMATTERS = {
     Bash: formatBash,
     Grep: formatGrep,
     Glob: formatGlob,
+    // Claude Code's subagent tool; `Task` is its earlier name.
+    Agent: formatTask,
     Task: formatTask,
     WebFetch: formatWebFetch,
     WebSearch: formatWebSearch,
@@ -214,7 +217,7 @@ function genericFallback(input) {
 export function formatToolSummary(toolName, input) {
     // Strip MCP prefixes: "mcp__server__tool" → use "tool" for matching
     const baseName = toolName.includes('__') ? (toolName.split('__').pop() ?? toolName) : toolName;
-    const formatter = TOOL_FORMATTERS[toolName] ?? TOOL_FORMATTERS[baseName];
+    const formatter = ownValue(TOOL_FORMATTERS, toolName) ?? ownValue(TOOL_FORMATTERS, baseName);
     if (formatter) {
         const result = formatter(input);
         if (result)

package/dist/esm/formatting.js

@@ -2,10 +2,19 @@
  * Pure display formatting helpers shared by CLI, extension host, webviews,
  * and downstream apps.
  *
- * This module intentionally has no Node-only imports.
+ * This module intentionally has no Node-only imports, and no runtime imports
+ * at all: bundles that only format values must not retain the pricing tables
+ * in `modelInfo.ts`. Type-only imports are fine.
  *
  * @module formatting
  */
+export function formatCost(cost, options) {
+    const source = options?.source;
+    if (cost === null || cost === undefined || source === 'unpriced')
+        return '—';
+    const formatted = cost < 0.01 ? `$${cost.toFixed(4)}` : `$${cost.toFixed(2)}`;
+    return source === 'estimated' ? `${formatted} (est.)` : formatted;
+}
 /** Format a token count with compact `k` / `M` suffixes. */
 export function formatTokenCount(value, options = {}) {
     if (!Number.isFinite(value))