sidekick-shared 0.23.0 → 0.24.0

package/dist/multiProviderQuotaService.js

@@ -174,7 +174,7 @@ class MultiProviderQuotaService {
                 providerId: 'claude-code',
             });
             this.lastEmittedClaudeState = nextState;
-            if (nextState.available) {
+            if (nextState.available && nextState.stale !== true) {
                 this.lastSuccessfulClaudeState = nextState;
             }
             this.quotaByProvider = {
@@ -323,7 +323,18 @@ class MultiProviderQuotaService {
             }
         }
         this.cachedFallbackActive = hasVisibleCachedSuccess;
-        if (!hasVisibleCachedSuccess) {
+        if (hasVisibleCachedSuccess) {
+            this.emitClaudeState({
+                ...this.lastSuccessfulClaudeState,
+                error: state.error,
+                failureKind: state.failureKind,
+                httpStatus: state.httpStatus,
+                retryAfterMs: state.retryAfterMs,
+                source: 'cache',
+                stale: true,
+            });
+        }
+        else {
             this.emitClaudeState(state);
         }
     }

package/dist/node.d.ts

@@ -7,3 +7,7 @@
  */
 export { hydratePricingCatalog, normalizeLiteLlmCatalog, LITELLM_CATALOG_URL, } from './pricingCatalog';
 export type { HydrateOptions, HydrateResult } from './pricingCatalog';
+export { listRecentSessions, readSessionTranscript } from './sessionTranscripts';
+export type { ProviderSessionIndex, ListRecentSessionsOptions } from './sessionTranscripts';
+export { ObservedSessionCollector, observedSessionSourceFromProvider, fileFingerprint, } from './observedSessionCollector';
+export type { ObservedSessionReference, ObservedSessionCollectionSource, ObservedSessionDiagnosticKind, ObservedSessionDiagnostic, ObservedSessionCollection, ObservedSessionCollectorOptions, } from './observedSessionCollector';

package/dist/node.js

@@ -7,8 +7,15 @@
  * for browser bundles — use `sidekick-shared/browser` there.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LITELLM_CATALOG_URL = exports.normalizeLiteLlmCatalog = exports.hydratePricingCatalog = void 0;
+exports.fileFingerprint = exports.observedSessionSourceFromProvider = exports.ObservedSessionCollector = exports.readSessionTranscript = exports.listRecentSessions = exports.LITELLM_CATALOG_URL = exports.normalizeLiteLlmCatalog = exports.hydratePricingCatalog = void 0;
 var pricingCatalog_1 = require("./pricingCatalog");
 Object.defineProperty(exports, "hydratePricingCatalog", { enumerable: true, get: function () { return pricingCatalog_1.hydratePricingCatalog; } });
 Object.defineProperty(exports, "normalizeLiteLlmCatalog", { enumerable: true, get: function () { return pricingCatalog_1.normalizeLiteLlmCatalog; } });
 Object.defineProperty(exports, "LITELLM_CATALOG_URL", { enumerable: true, get: function () { return pricingCatalog_1.LITELLM_CATALOG_URL; } });
+var sessionTranscripts_1 = require("./sessionTranscripts");
+Object.defineProperty(exports, "listRecentSessions", { enumerable: true, get: function () { return sessionTranscripts_1.listRecentSessions; } });
+Object.defineProperty(exports, "readSessionTranscript", { enumerable: true, get: function () { return sessionTranscripts_1.readSessionTranscript; } });
+var observedSessionCollector_1 = require("./observedSessionCollector");
+Object.defineProperty(exports, "ObservedSessionCollector", { enumerable: true, get: function () { return observedSessionCollector_1.ObservedSessionCollector; } });
+Object.defineProperty(exports, "observedSessionSourceFromProvider", { enumerable: true, get: function () { return observedSessionCollector_1.observedSessionSourceFromProvider; } });
+Object.defineProperty(exports, "fileFingerprint", { enumerable: true, get: function () { return observedSessionCollector_1.fileFingerprint; } });

package/dist/observedSessionCollector.d.ts

@@ -0,0 +1,68 @@
+import type { ObservedAgentSessionV1 } from './types/observedSessionV1';
+import type { SessionProviderBase } from './providers/types';
+export interface ObservedSessionReference {
+    sessionId: string;
+    /** Opaque source locator used only by the source implementation. Never emitted in diagnostics. */
+    sourceKey?: string;
+    fingerprintHint?: string;
+}
+export interface ObservedSessionCollectionSource<T = unknown> {
+    providerId: string;
+    discover(): Promise<ObservedSessionReference[]> | ObservedSessionReference[];
+    read(reference: ObservedSessionReference): Promise<T> | T;
+    dispose?(): void;
+}
+export type ObservedSessionDiagnosticKind = 'provider-discovery-failed' | 'session-read-failed' | 'provider-recovered' | 'session-recovered';
+/** Content-safe diagnostics: identifiers and retry metadata only. */
+export interface ObservedSessionDiagnostic {
+    kind: ObservedSessionDiagnosticKind;
+    providerId: string;
+    sessionId?: string;
+    attempt?: number;
+    retryAt?: number;
+}
+export interface ObservedSessionCollection<T = unknown> {
+    providerId: string;
+    sessionId: string;
+    value: T;
+}
+export interface ObservedSessionCollectorOptions<T = unknown> {
+    sources: ObservedSessionCollectionSource<T>[];
+    initialBackoffMs?: number;
+    maxBackoffMs?: number;
+    clock?: {
+        now(): number;
+    };
+    fingerprint?: (source: ObservedSessionCollectionSource<T>, reference: ObservedSessionReference) => Promise<string | null> | string | null;
+    onObservation?: (observation: ObservedSessionCollection<T>) => void;
+    onDiagnostic?: (diagnostic: ObservedSessionDiagnostic) => void;
+}
+/**
+ * One-shot, host-scheduled observed-session collection with independent
+ * provider/session isolation and bounded retry state.
+ */
+export declare class ObservedSessionCollector<T = unknown> {
+    private readonly options;
+    private readonly failures;
+    private readonly initialBackoffMs;
+    private readonly maxBackoffMs;
+    private readonly clock;
+    constructor(options: ObservedSessionCollectorOptions<T>);
+    collect(): Promise<ObservedSessionCollection<T>[]>;
+    reset(): void;
+    dispose(): void;
+    private collectSource;
+    private collectSession;
+    private fingerprint;
+    private fail;
+    private recover;
+    private emitDiagnostic;
+    private key;
+}
+/**
+ * Adapt a provider using path-only discovery and independent adapter reads, so
+ * one malformed session cannot reject discovery of its healthy siblings.
+ */
+export declare function observedSessionSourceFromProvider(provider: SessionProviderBase, cwd: string): ObservedSessionCollectionSource<ObservedAgentSessionV1>;
+/** Size/mtime fingerprint suitable for retry bypass; returns null for synthetic DB locators. */
+export declare function fileFingerprint(sourcePath: string): string | null;

package/dist/observedSessionCollector.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObservedSessionCollector = void 0;
+exports.observedSessionSourceFromProvider = observedSessionSourceFromProvider;
+exports.fileFingerprint = fileFingerprint;
+const node_fs_1 = require("node:fs");
+const observedSessionV1_1 = require("./types/observedSessionV1");
+/**
+ * One-shot, host-scheduled observed-session collection with independent
+ * provider/session isolation and bounded retry state.
+ */
+class ObservedSessionCollector {
+    options;
+    failures = new Map();
+    initialBackoffMs;
+    maxBackoffMs;
+    clock;
+    constructor(options) {
+        this.options = options;
+        this.initialBackoffMs = Math.max(1, options.initialBackoffMs ?? 30_000);
+        this.maxBackoffMs = Math.max(this.initialBackoffMs, options.maxBackoffMs ?? 5 * 60_000);
+        this.clock = options.clock ?? { now: () => Date.now() };
+    }
+    async collect() {
+        const nested = await Promise.all(this.options.sources.map((source) => this.collectSource(source)));
+        return nested.flat();
+    }
+    reset() {
+        this.failures.clear();
+    }
+    dispose() {
+        for (const source of this.options.sources) {
+            try {
+                source.dispose?.();
+            }
+            catch {
+                // Disposal is best-effort and isolated per source.
+            }
+        }
+        this.reset();
+    }
+    async collectSource(source) {
+        const discoveryKey = `${source.providerId}\0$discovery`;
+        const discoveryFailure = this.failures.get(discoveryKey);
+        if (discoveryFailure && this.clock.now() < discoveryFailure.retryAt)
+            return [];
+        let references;
+        try {
+            references = await source.discover();
+            this.recover(discoveryKey, 'provider-recovered', source.providerId);
+        }
+        catch (error) {
+            this.fail(discoveryKey, 'provider-discovery-failed', source.providerId, undefined, null, error);
+            return [];
+        }
+        const activeKeys = new Set(references.map((ref) => this.key(source.providerId, ref.sessionId)));
+        for (const key of this.failures.keys()) {
+            if (key.startsWith(`${source.providerId}\0`) &&
+                !key.endsWith('$discovery') &&
+                !activeKeys.has(key)) {
+                this.failures.delete(key);
+            }
+        }
+        const rows = await Promise.all(references.map((reference) => this.collectSession(source, reference)));
+        return rows.filter((row) => row !== null);
+    }
+    async collectSession(source, reference) {
+        const key = this.key(source.providerId, reference.sessionId);
+        const fingerprint = await this.fingerprint(source, reference);
+        const prior = this.failures.get(key);
+        if (prior && prior.fingerprint === fingerprint && this.clock.now() < prior.retryAt)
+            return null;
+        let value;
+        try {
+            value = await source.read(reference);
+        }
+        catch (error) {
+            this.fail(key, 'session-read-failed', source.providerId, reference.sessionId, fingerprint, error);
+            return null;
+        }
+        this.recover(key, 'session-recovered', source.providerId, reference.sessionId);
+        const observation = { providerId: source.providerId, sessionId: reference.sessionId, value };
+        try {
+            this.options.onObservation?.(observation);
+        }
+        catch {
+            // Host callbacks cannot turn a healthy provider read into a collection failure.
+        }
+        return observation;
+    }
+    async fingerprint(source, reference) {
+        try {
+            return this.options.fingerprint
+                ? await this.options.fingerprint(source, reference)
+                : (reference.fingerprintHint ?? null);
+        }
+        catch {
+            return reference.fingerprintHint ?? null;
+        }
+    }
+    fail(key, kind, providerId, sessionId, fingerprint, error) {
+        const previous = this.failures.get(key);
+        const signature = failureSignature(error);
+        const fingerprintChanged = previous?.fingerprint !== fingerprint;
+        const attempt = previous && !fingerprintChanged ? previous.attempt + 1 : 1;
+        const delay = Math.min(this.maxBackoffMs, this.initialBackoffMs * 2 ** (attempt - 1));
+        const retryAt = this.clock.now() + delay;
+        const reportedSignature = previous?.reportedSignature ?? '';
+        this.failures.set(key, {
+            attempt,
+            retryAt,
+            fingerprint,
+            reportedSignature: signature,
+        });
+        if (signature !== reportedSignature || fingerprintChanged) {
+            this.emitDiagnostic({ kind, providerId, sessionId, attempt, retryAt });
+        }
+    }
+    recover(key, kind, providerId, sessionId) {
+        const prior = this.failures.get(key);
+        if (!prior)
+            return;
+        this.failures.delete(key);
+        this.emitDiagnostic({ kind, providerId, sessionId, attempt: prior.attempt });
+    }
+    emitDiagnostic(diagnostic) {
+        try {
+            this.options.onDiagnostic?.(diagnostic);
+        }
+        catch {
+            // Diagnostics are observational and never affect collection isolation.
+        }
+    }
+    key(providerId, sessionId) {
+        return `${providerId}\0${sessionId}`;
+    }
+}
+exports.ObservedSessionCollector = ObservedSessionCollector;
+/**
+ * Adapt a provider using path-only discovery and independent adapter reads, so
+ * one malformed session cannot reject discovery of its healthy siblings.
+ */
+function observedSessionSourceFromProvider(provider, cwd) {
+    const adapter = (0, observedSessionV1_1.createProviderSessionAdapterV1)(provider);
+    return {
+        providerId: provider.id,
+        discover() {
+            return provider.findAllSessions(cwd).map((sessionPath) => ({
+                sessionId: provider.getSessionId(sessionPath),
+                sourceKey: sessionPath,
+                fingerprintHint: provider.getSessionMetadata?.(sessionPath)?.mtime.getTime().toString() ??
+                    fileFingerprint(sessionPath) ??
+                    undefined,
+            }));
+        },
+        read(reference) {
+            if (!reference.sourceKey)
+                throw new Error('session source unavailable');
+            return adapter.read(reference.sourceKey, cwd);
+        },
+        dispose: () => adapter.dispose(),
+    };
+}
+/** Size/mtime fingerprint suitable for retry bypass; returns null for synthetic DB locators. */
+function fileFingerprint(sourcePath) {
+    try {
+        const stat = (0, node_fs_1.statSync)(sourcePath);
+        return `${stat.size}:${stat.mtimeMs}`;
+    }
+    catch {
+        return null;
+    }
+}
+function failureSignature(error) {
+    if (error instanceof Error)
+        return `${error.name}\0${error.message}`;
+    return typeof error === 'string' ? error : Object.prototype.toString.call(error);
+}

package/dist/parsers/codexParser.js

@@ -18,6 +18,7 @@ exports.normalizeCodexToolInput = normalizeCodexToolInput;
 exports.extractPatchFilePaths = extractPatchFilePaths;
 const codex_1 = require("../types/codex");
 const openCodeParser_1 = require("./openCodeParser");
+const usageNormalization_1 = require("../usageNormalization");
 function reportedCompaction(tokensBefore, tokensAfter) {
     if (typeof tokensBefore !== 'number' ||
         typeof tokensAfter !== 'number' ||
@@ -780,13 +781,28 @@ class CodexRolloutParser {
         const normalizedRateLimits = normalizeRateLimits(rateLimits);
         if (!usage && !normalizedRateLimits)
             return [];
-        const mappedUsage = usage
+        const normalizedUsage = usage
+            ? (0, usageNormalization_1.normalizeProviderUsage)({
+                semantics: 'openai',
+                provider: 'openai',
+                source: 'codex-token-count',
+                model: this.currentModel || undefined,
+                inputTokens: usage.input_tokens,
+                outputTokens: usage.output_tokens,
+                cacheReadTokens: usage.cached_input_tokens,
+                reasoningTokens: usage.reasoning_output_tokens,
+            })
+            : undefined;
+        const mappedUsage = normalizedUsage
             ? {
-                input_tokens: usage.input_tokens || 0,
-                output_tokens: usage.output_tokens || 0,
-                cache_read_input_tokens: usage.cached_input_tokens || 0,
-                cache_creation_input_tokens: 0,
-                reasoning_tokens: usage.reasoning_output_tokens || 0,
+                // Codex reports cached_input_tokens as a subset of input_tokens,
+                // while MessageUsage categories are disjoint. Normalize once here
+                // so aggregation and pricing do not count cached input twice.
+                input_tokens: normalizedUsage.uncachedInputTokens,
+                output_tokens: normalizedUsage.outputTokens,
+                cache_read_input_tokens: normalizedUsage.cacheReadTokens,
+                cache_creation_input_tokens: normalizedUsage.cacheWriteTokens,
+                reasoning_tokens: normalizedUsage.reasoningTokens,
             }
             : undefined;
         if (usage) {
@@ -801,9 +817,11 @@ class CodexRolloutParser {
                     sourceLabel: 'token count',
                     model: this.currentModel || undefined,
                     usage: mappedUsage,
+                    normalizedUsage,
                     content: [],
                 },
                 timestamp,
+                providerMetadata: { providerId: 'codex', source: 'codex-rollout' },
                 rateLimits: normalizedRateLimits,
             },
         ];

package/dist/parsers/openCodeParser.js

@@ -18,6 +18,7 @@ exports.normalizeToolInput = normalizeToolInput;
 exports.convertOpenCodeMessage = convertOpenCodeMessage;
 exports.parseDbMessageData = parseDbMessageData;
 exports.parseDbPartData = parseDbPartData;
+const usageNormalization_1 = require("../usageNormalization");
 /**
  * OpenCode → Claude Code tool name mapping.
  * OpenCode uses lowercase names; downstream code expects PascalCase.
@@ -322,7 +323,7 @@ function convertAssistantMessage(message, parts) {
         }
     }
     // Build usage data from message tokens
-    const reportedCost = message.cost && message.cost > 0
+    const reportedCost = typeof message.cost === 'number' && Number.isFinite(message.cost) && message.cost >= 0
         ? message.cost
         : stepFinishCost > 0
             ? stepFinishCost
@@ -335,6 +336,23 @@ function convertAssistantMessage(message, parts) {
         reported_cost: reportedCost,
         reasoning_tokens: message.tokens.reasoning || 0,
     };
+    const normalizedUsage = (0, usageNormalization_1.normalizeProviderUsage)({
+        semantics: message.providerID === 'openai'
+            ? 'openai'
+            : message.providerID === 'anthropic'
+                ? 'anthropic'
+                : 'sidekick',
+        provider: message.providerID ?? 'opencode',
+        source: 'opencode-message',
+        model: message.modelID,
+        inputTokens: message.tokens.input,
+        outputTokens: message.tokens.output,
+        cacheReadTokens: message.tokens.cacheRead,
+        cacheWriteTokens: message.tokens.cacheWrite,
+        reasoningTokens: message.tokens.reasoning,
+        reasoningIncludedInOutput: message.providerID === 'openai',
+        reportedCostUsd: reportedCost,
+    });
     const timestamp = toISOString(message.time.completed || message.time.created);
     const retryAttempts = parts
         .filter((part) => part.type === 'retry')
@@ -353,10 +371,13 @@ function convertAssistantMessage(message, parts) {
                 id: message.id,
                 model: message.modelID,
                 usage,
+                normalizedUsage,
                 content,
             },
             timestamp,
             providerMetadata: {
+                providerId: message.providerID ?? 'opencode',
+                source: 'opencode-message',
                 ...(retryAttempts.length > 0 ? { retryAttempts } : {}),
                 ...(finishReasons.length > 0 ? { finishReasons } : {}),
                 ...(message.error ? { providerError: message.error } : {}),

package/dist/parsers/sessionActivityDetector.js

@@ -126,6 +126,8 @@ function detectSessionActivity(sessionPath) {
         }
         if (!hasTerminal) {
             for (const pattern of ENDING_PATTERNS) {
+                if (pattern === '"type":"user"' && line.includes('"type":"tool_result"'))
+                    continue;
                 if (line.includes(pattern)) {
                     lastEndingIndex = i;
                     break;

package/dist/parsers/sessionPathResolver.js

@@ -81,10 +81,9 @@ const os = __importStar(require("os"));
 function encodeWorkspacePath(workspacePath) {
     // Normalize path separators to forward slash
     const normalized = workspacePath.replace(/\\/g, '/');
-    // Replace colons, slashes, and underscores with hyphens
-    // Windows: C:\Users\foo_bar -> C:/Users/foo_bar -> C--Users-foo-bar
-    // Unix: /home/user/foo_bar -> -home-user-foo-bar
-    return normalized.replace(/[:/_]/g, '-');
+    // Claude Code replaces every non-alphanumeric path character, including
+    // dots and spaces, with a hyphen.
+    return normalized.replace(/[^a-zA-Z0-9]/g, '-');
 }
 /**
  * Gets the session directory path for a workspace.
@@ -249,12 +248,7 @@ function discoverSessionDirectory(workspacePath) {
             });
             // Try to match by workspace path components
             // Normalize workspace path for comparison
-            const normalizedWorkspace = workspacePath
-                .replace(/\\/g, '/')
-                .replace(/:/g, '-')
-                .replace(/_/g, '-')
-                .replace(/\//g, '-')
-                .toLowerCase();
+            const normalizedWorkspace = encodeWorkspacePath(workspacePath).toLowerCase();
             for (const dir of existingDirs) {
                 // Check if the directory name matches (case-insensitive)
                 if (dir.toLowerCase() === normalizedWorkspace) {
@@ -262,7 +256,10 @@ function discoverSessionDirectory(workspacePath) {
                 }
             }
             // Fallback: match by final path component (project name)
-            const workspaceBasename = path.basename(workspacePath).replace(/_/g, '-').toLowerCase();
+            const workspaceBasename = path
+                .basename(workspacePath)
+                .replace(/[^a-zA-Z0-9]/g, '-')
+                .toLowerCase();
             for (const dir of existingDirs) {
                 const dirLower = dir.toLowerCase();
                 // Check if dir ends with the project name
@@ -406,12 +403,18 @@ function findAllSessions(workspacePath) {
             .filter((file) => file.endsWith('.jsonl'))
             .map((file) => {
             const fullPath = path.join(sessionDir, file);
-            const stats = fs.statSync(fullPath);
-            return {
-                path: fullPath,
-                mtime: stats.mtime.getTime(),
-            };
+            try {
+                const stats = fs.statSync(fullPath);
+                return {
+                    path: fullPath,
+                    mtime: stats.mtime.getTime(),
+                };
+            }
+            catch {
+                return null;
+            }
         })
+            .filter((file) => file !== null)
             .sort((a, b) => b.mtime - a.mtime)
             .map((file) => file.path);
         return files;

package/dist/parsers/subagentScanner.d.ts

@@ -26,7 +26,7 @@ import type { SubagentStats, TaskState } from '../types/sessionEvent';
  * }
  * ```
  */
-export declare function scanSubagentDir(sessionDir: string, sessionId: string, logger?: (msg: string) => void): SubagentStats[];
+export declare function scanSubagentDir(sessionDir: string, sessionId: string, logger?: (msg: string) => void, skipFiles?: ReadonlySet<string>): SubagentStats[];
 /**
  * Handles TaskUpdate tool input and updates task state.
  */

package/dist/parsers/subagentScanner.js

@@ -93,7 +93,7 @@ const reportedMissing = new Set();
  * }
  * ```
  */
-function scanSubagentDir(sessionDir, sessionId, logger) {
+function scanSubagentDir(sessionDir, sessionId, logger, skipFiles = new Set()) {
     const log = logger || (() => { });
     const subagentsDir = path.join(sessionDir, sessionId, 'subagents');
     const results = [];
@@ -110,6 +110,8 @@ function scanSubagentDir(sessionDir, sessionId, logger) {
         const files = fs.readdirSync(subagentsDir);
         log(`[SubagentScanner] Found ${files.length} files: ${files.join(', ')}`);
         for (const file of files) {
+            if (skipFiles.has(file))
+                continue;
             const match = file.match(AGENT_FILE_PATTERN);
             if (!match) {
                 continue;
@@ -169,10 +171,7 @@ function parseAgentFile(filePath, agentId, log) {
                 // Extract token usage from assistant messages
                 if (event.type === 'assistant' && event.message?.usage) {
                     const usage = event.message.usage;
-                    inputTokens +=
-                        (usage.input_tokens || 0) +
-                            (usage.cache_creation_input_tokens || 0) +
-                            (usage.cache_read_input_tokens || 0);
+                    inputTokens += usage.input_tokens || 0;
                     outputTokens += usage.output_tokens || 0;
                 }
                 // Extract agent type and description from Task tool invocation

package/dist/parsers/subagentTraceParser.js

@@ -141,7 +141,7 @@ function parseAgentTrace(filePath, agentId) {
                 }
                 // Format tool summary
                 let toolSummary;
-                if (sessionEvent.type === 'tool_use' && sessionEvent.tool) {
+                if (sessionEvent.tool) {
                     toolSummary = (0, toolSummary_1.formatToolSummary)(sessionEvent.tool.name, sessionEvent.tool.input);
                 }
                 events.push({
@@ -155,10 +155,7 @@ function parseAgentTrace(filePath, agentId) {
                 // Extract token usage
                 if (raw.type === 'assistant' && raw.message?.usage) {
                     const usage = raw.message.usage;
-                    inputTokens +=
-                        (usage.input_tokens || 0) +
-                            (usage.cache_creation_input_tokens || 0) +
-                            (usage.cache_read_input_tokens || 0);
+                    inputTokens += usage.input_tokens || 0;
                     outputTokens += usage.output_tokens || 0;
                 }
                 // Extract tool calls
@@ -251,7 +248,7 @@ function linkTraces(traces) {
                 for (const match of matches) {
                     const childId = match[1];
                     const child = traceById.get(childId);
-                    if (child && child !== trace) {
+                    if (child && child !== trace && !child.parentToolUseId) {
                         child.parentToolUseId = trace.agentId;
                         trace.children.push(child);
                     }
@@ -274,7 +271,7 @@ function linkTraces(traces) {
                 continue; // Already linked
             for (const traceEvent of potential.events) {
                 const evt = traceEvent.event;
-                if (evt.type === 'tool_use' && evt.tool?.name === 'Task') {
+                if (evt.type === 'assistant' && evt.tool?.name === 'Task') {
                     const taskTime = new Date(evt.timestamp).getTime();
                     // Within 2 seconds before child start
                     if (taskTime <= childStart && childStart - taskTime < 2000) {
@@ -337,13 +334,19 @@ function rawToSessionEvent(raw) {
             }
         }
     }
-    return {
-        type: mappedType,
-        message: message || { role: 'unknown' },
+    const common = {
         timestamp,
         isSidechain: raw.isSidechain,
         permissionMode: raw.permissionMode,
-        tool,
-        result,
     };
+    if (mappedType === 'user' || mappedType === 'assistant') {
+        return { ...common, type: mappedType, message: message || { role: 'unknown' }, tool };
+    }
+    if (mappedType === 'summary') {
+        return { ...common, type: 'summary', message: message || { role: 'summary' } };
+    }
+    if (mappedType === 'tool_use') {
+        return tool ? { ...common, type: 'tool_use', message, tool } : null;
+    }
+    return result ? { ...common, type: 'tool_result', message, result } : null;
 }

package/dist/providerStatus.js

@@ -24,7 +24,7 @@ function fallbackState() {
  */
 async function fetchStatusPage(baseUrl) {
     try {
-        const statusRes = await fetch(`${baseUrl}/api/v2/status.json`);
+        const statusRes = await fetchWithTimeout(`${baseUrl}/api/v2/status.json`);
         if (!statusRes.ok)
             return fallbackState();
         const statusData = await statusRes.json();
@@ -36,7 +36,7 @@ async function fetchStatusPage(baseUrl) {
             return { indicator, description, affectedComponents: [], activeIncident: null, updatedAt };
         }
         // Degraded — fetch summary for components + incidents
-        const summaryRes = await fetch(`${baseUrl}/api/v2/summary.json`);
+        const summaryRes = await fetchWithTimeout(`${baseUrl}/api/v2/summary.json`);
         if (!summaryRes.ok) {
             return { indicator, description, affectedComponents: [], activeIncident: null, updatedAt };
         }
@@ -61,6 +61,17 @@ async function fetchStatusPage(baseUrl) {
         return fallbackState();
     }
 }
+async function fetchWithTimeout(url) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 10_000);
+    timeout.unref();
+    try {
+        return await fetch(url, { signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
 /**
  * Fetch current Claude API status from status.claude.com.
  *