sidekick-shared 0.28.3 → 0.29.0

package/dist/esm/pricingCatalog.js

@@ -19,7 +19,7 @@
 import { promises as fs } from 'node:fs';
 import * as path from 'node:path';
 import { _setCatalogContextWindows } from './modelContext';
-import { _setPricingOverrides } from './modelInfo';
+import { _setPricingOverrides, getPricingCatalogInfo } from './modelInfo';
 import { getConfigDir } from './paths';
 import { atomicWriteJson } from './writers/atomic';
 // ── Constants ──
@@ -36,6 +36,10 @@ const DEFAULT_TIMEOUT_MS = 3_000;
  *   2. Otherwise attempt a network fetch; on success, persist + apply.
  *   3. On any failure, load a stale cache if present; else leave overrides empty.
  *
+ * `getPricingCatalogInfo().source` afterwards reads `litellm` for a fresh fetch
+ * or a cache within `ttlMs`, and `stale-cache` for a cache older than `ttlMs`
+ * — whether the refresh failed or `offline` skipped it.
+ *
  * Always resolves — never throws. Offline-safe.
  */
 export async function hydratePricingCatalog(options = {}) {
@@ -44,8 +48,9 @@ export async function hydratePricingCatalog(options = {}) {
     const now = Date.now();
     // 1. Fresh cache? (Offline callers take any cache, however old.)
     const cached = await readCache(cachePath);
-    if (cached && (offline || now - Date.parse(cached.fetchedAt) < ttlMs)) {
-        return applyCacheFile(cached, 'cache');
+    const cacheFresh = cached !== null && now - Date.parse(cached.fetchedAt) < ttlMs;
+    if (cached && (offline || cacheFresh)) {
+        return applyCacheFile(cached, 'cache', cacheFresh ? 'litellm' : 'stale-cache');
     }
     // 2. Try network.
     if (fetchImpl && !offline) {
@@ -58,12 +63,12 @@ export async function hydratePricingCatalog(options = {}) {
                 contextWindows: normalizeLiteLlmContextWindows(fetched),
             };
             await writeCache(cachePath, payload, logger);
-            return applyCacheFile(payload, 'network');
+            return applyCacheFile(payload, 'network', 'litellm');
         }
     }
     // 3. Fall back to stale cache if present.
     if (cached) {
-        return applyCacheFile(cached, 'cache');
+        return applyCacheFile(cached, 'cache', 'stale-cache');
     }
     // 4. Nothing we can do — stay on static tables.
     return {
@@ -71,6 +76,7 @@ export async function hydratePricingCatalog(options = {}) {
         entries: 0,
         contextWindowEntries: 0,
         fetchedAt: new Date(now).toISOString(),
+        digest: getPricingCatalogInfo().digest,
     };
 }
 /**
@@ -78,9 +84,9 @@ export async function hydratePricingCatalog(options = {}) {
  * `contextWindows` is absent on caches written before context hydration; those
  * contribute no overrides rather than clearing whatever is already loaded.
  */
-function applyCacheFile(cache, source) {
+function applyCacheFile(cache, source, basis) {
     const contextWindows = cache.contextWindows ?? {};
-    _setPricingOverrides(cache.overrides);
+    _setPricingOverrides(cache.overrides, { source: basis, fetchedAt: cache.fetchedAt });
     if (Object.keys(contextWindows).length > 0) {
         _setCatalogContextWindows(contextWindows);
     }
@@ -89,6 +95,7 @@ function applyCacheFile(cache, source) {
         entries: Object.keys(cache.overrides).length,
         contextWindowEntries: Object.keys(contextWindows).length,
         fetchedAt: cache.fetchedAt,
+        digest: getPricingCatalogInfo().digest,
     };
 }
 /**

package/dist/esm/promptHistory.js

@@ -14,6 +14,10 @@
  * record over `maxRecordBytes` is skipped without being buffered and reported
  * in `exclusions`, the only way a record is permanently left out.
  *
+ * `includeText: false` returns the same entries, ordinals, timestamps,
+ * metadata, exclusions, and cursor without prompt text, for consumers that
+ * only count or attribute prompts. Cursors are interchangeable between modes.
+ *
  * A prompt can be written before its answer. The cursor then keeps the byte
  * offset of that prompt's line and its answer-tracking state (never text), and
  * the prompt is returned again under the same identity once its first
@@ -28,12 +32,19 @@ import { listCodexSessionFilesAsync } from './providers/codexRollouts';
 import { DirectoryListingCache } from './providers/directoryListingCache';
 import { realpathOrNull, resolveWorkspaceRoots } from './workspaceRoots';
 import { fileHeadOf, HEAD_BYTES, headMatches } from './fileHead';
+/**
+ * The default `maxRecordBytes` (16 MiB). Prompt ordinals are only comparable
+ * between readers that skip the same records, so every reader that publishes
+ * or joins on ordinals (prompt history, session prompt history, usage events'
+ * `promptOrdinal`) uses this bound.
+ */
+export const PROMPT_HISTORY_ORDINAL_MAX_RECORD_BYTES = 16 * 1024 * 1024;
 /** @internal */
 export const DEFAULT_BOUNDS = {
     maxSessions: 1000,
     maxFileBytes: 16 * 1024 * 1024,
     maxTotalBytes: 256 * 1024 * 1024,
-    maxRecordBytes: 16 * 1024 * 1024,
+    maxRecordBytes: PROMPT_HISTORY_ORDINAL_MAX_RECORD_BYTES,
     maxEntries: 10_000,
     deadlineMs: 30_000,
 };
@@ -108,6 +119,7 @@ export async function collectPromptHistory(options) {
             if (exclusions.length < MAX_EXCLUSIONS)
                 exclusions.push(exclusion);
         },
+        includeText: options.includeText !== false,
     };
     let totalBytes = 0;
     let scannedAny = false;
@@ -221,6 +233,46 @@ export async function collectPromptHistory(options) {
     }
     return finish();
 }
+/**
+ * Every human prompt of one session file with its ordinal and timestamp, read
+ * whole in one pass with the default record bound, so the ordinals are the
+ * ones `collectPromptHistory()` returns with default bounds. No scope check
+ * and no text: prompts are counted wherever their cwd points. Prompts whose
+ * line has no usable timestamp still take an ordinal but are left out. A
+ * non-interactive Codex session (subagent, fork, unknown source) has none.
+ * In file order. Rejects when the file cannot be opened or changes while its
+ * head is read.
+ * @internal
+ */
+export async function readPromptOrdinalMarks(provider, sessionId, filePath) {
+    const marks = [];
+    const stat = await fs.promises.stat(filePath);
+    const unbounded = Number.MAX_SAFE_INTEGER;
+    const context = {
+        roots: [],
+        sinceMs: null,
+        stats: emptyStats(),
+        realpaths: new Map(),
+        bounds: {
+            maxSessions: unbounded,
+            maxFileBytes: unbounded,
+            maxTotalBytes: unbounded,
+            maxRecordBytes: PROMPT_HISTORY_ORDINAL_MAX_RECORD_BYTES,
+            maxEntries: unbounded,
+            deadlineMs: unbounded,
+        },
+        shouldStop: () => null,
+        entriesSoFar: () => 0,
+        exclude: () => undefined,
+        includeText: false,
+        onPrompt: ({ ordinal, timestamp }) => {
+            if (timestamp !== undefined)
+                marks.push({ ordinal, timestampMs: Date.parse(timestamp) });
+        },
+    };
+    await scanFile({ provider, sessionId, filePath, key: `${provider}:${sessionId}:${hashPath(filePath)}` }, stat, undefined, { bytes: unbounded, bound: 'maxFileBytes', forceProgress: true }, context);
+    return marks;
+}
 /** @internal */
 export function emptyStats() {
     return {
@@ -899,7 +951,7 @@ class LineScanner {
         return {
             entry: {
                 ...entry,
-                text,
+                ...this.textFields(text),
                 cwd: scoped,
                 ...(place.gitBranch ? { gitBranch: place.gitBranch } : {}),
                 ...(entry.usage ? { usage: { ...entry.usage } } : {}),
@@ -918,11 +970,21 @@ class LineScanner {
             this.closedCarried = open;
         this.open = null;
     }
+    /** Entry text fields: the text, or an empty string flagged as omitted. */
+    textFields(text) {
+        return this.context.includeText === false ? { text: '', textOmitted: true } : { text };
+    }
     /** Assign an ordinal to a human prompt and emit it when in scope. */
     recordPrompt(text, timestamp, cwd, gitBranch, lineOffset, lineBytes, stateBefore) {
         const ordinal = this.nextOrdinal++;
         this.closeOpen();
-        if (typeof timestamp !== 'string' || Number.isNaN(Date.parse(timestamp))) {
+        const usable = typeof timestamp === 'string' && !Number.isNaN(Date.parse(timestamp));
+        this.context.onPrompt?.({
+            ordinal,
+            timestamp: usable ? timestamp : undefined,
+            lineOffset,
+        });
+        if (!usable) {
             this.context.stats.promptsMissingTimestamp++;
             return;
         }
@@ -940,7 +1002,7 @@ class LineScanner {
             sessionId: this.candidate.sessionId,
             ordinal,
             timestamp,
-            text,
+            ...this.textFields(text),
             cwd: scoped,
             ...(gitBranch ? { gitBranch } : {}),
             metadataStatus: 'pending',

package/dist/esm/providerFailure.js

@@ -42,6 +42,31 @@ export const PROVIDER_FAILURE_EVIDENCE_SOURCES = [
     'message',
     'authentication-check',
 ];
+/**
+ * The variants Codex reports in `codexErrorInfo` on `error` and failed-turn
+ * payloads (app-server camelCase spelling; the snake_case spelling Codex
+ * writes to rollout files is accepted too). `rateLimitExceeded` is an older
+ * spelling some Codex builds emitted.
+ */
+export const CODEX_ERROR_INFO_KINDS = [
+    'contextWindowExceeded',
+    'sessionBudgetExceeded',
+    'usageLimitExceeded',
+    'rateLimitExceeded',
+    'serverOverloaded',
+    'cyberPolicy',
+    'httpConnectionFailed',
+    'responseStreamConnectionFailed',
+    'internalServerError',
+    'unauthorized',
+    'badRequest',
+    'threadRollbackFailed',
+    'sandboxError',
+    'responseStreamDisconnected',
+    'responseTooManyFailedAttempts',
+    'activeTurnNotSteerable',
+    'other',
+];
 function read(value, key) {
     try {
         return value && typeof value === 'object' ? value[key] : undefined;
@@ -77,6 +102,40 @@ function retryAfter(value) {
     const at = timestamp(value);
     return at ? { kind: 'date', at } : undefined;
 }
+function compactKey(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]/g, '');
+}
+const CODEX_ERROR_INFO_BY_KEY = new Map(CODEX_ERROR_INFO_KINDS.map((kind) => [compactKey(kind), kind]));
+/**
+ * Decode one Codex `codexErrorInfo` value: a string variant
+ * (`"serverOverloaded"`, `"usage_limit_exceeded"`) or an object variant
+ * (`{ "httpConnectionFailed": { "httpStatusCode": 503 } }`, snake_case keys
+ * accepted). Returns `undefined` for anything else, including `null`.
+ */
+export function decodeCodexErrorInfo(value) {
+    if (typeof value === 'string') {
+        const kind = value.length <= 64 ? CODEX_ERROR_INFO_BY_KEY.get(compactKey(value)) : undefined;
+        return kind ? { kind } : undefined;
+    }
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    let keys;
+    try {
+        keys = Object.keys(value);
+    }
+    catch {
+        return undefined;
+    }
+    for (const key of keys.slice(0, 8)) {
+        const kind = key.length <= 64 ? CODEX_ERROR_INFO_BY_KEY.get(compactKey(key)) : undefined;
+        if (!kind)
+            continue;
+        const payload = read(value, key);
+        const status = statusNumber(read(payload, 'httpStatusCode') ?? read(payload, 'http_status_code'));
+        return status === undefined ? { kind } : { kind, httpStatusCode: status };
+    }
+    return undefined;
+}
 function rejected(kind) {
     return kind === 'oauth'
         ? 'oauth_reauthentication_required'
@@ -167,6 +226,44 @@ function classifyStatus(status, kind) {
         return 'service_unavailable';
     return undefined;
 }
+/** Variants with no matching failure code (bad request, policy, budget, other) stay unclassified. */
+function classifyCodexErrorInfo(info, kind) {
+    switch (info.kind) {
+        case 'usageLimitExceeded':
+        case 'rateLimitExceeded':
+            return 'rate_limited';
+        case 'serverOverloaded':
+            return 'overloaded';
+        case 'internalServerError':
+            return 'service_unavailable';
+        case 'unauthorized':
+            return rejected(kind);
+        case 'contextWindowExceeded':
+            return 'context_overflow';
+        case 'httpConnectionFailed':
+        case 'responseStreamConnectionFailed':
+        case 'responseStreamDisconnected':
+        case 'responseTooManyFailedAttempts':
+            return info.httpStatusCode === undefined
+                ? 'connection_failed'
+                : classifyStatus(info.httpStatusCode, kind);
+        default:
+            return undefined;
+    }
+}
+function isRetryable(code, quotaExhausted, retry) {
+    switch (code) {
+        case 'rate_limited':
+            return !quotaExhausted || retry !== undefined;
+        case 'overloaded':
+        case 'service_unavailable':
+        case 'timeout':
+        case 'connection_failed':
+            return true;
+        default:
+            return false;
+    }
+}
 function classifyMessage(message, kind) {
     if (/\b(execution policy|sandbox policy|approval)\b.{0,60}\b(denied|blocked|rejected|not allowed)\b|\bdenied by policy\b/i.test(message))
         return 'execution_policy_denied';
@@ -232,6 +329,13 @@ function recovery(code, kind) {
 /**
  * Classify a caller-designated terminal failure without I/O or recovery actions.
  * Public status and runtime readiness do not establish request authentication.
+ *
+ * A Codex `codexErrorInfo` (or `codex_error_info`) on the error or on any
+ * nested `error` / `cause` / `response` / `data` / `body` / `errors` entry is
+ * structured evidence. It ranks ahead of the same object's `code` / `type` /
+ * `name`, objects are read outer first, and every structured code ranks ahead
+ * of HTTP status and message text. Its transport variants also supply
+ * `httpStatus`.
  */
 export function diagnoseProviderFailure(input) {
     const codes = [];
@@ -249,11 +353,15 @@ export function diagnoseProviderFailure(input) {
         if (!value || typeof value !== 'object' || visited.has(value))
             continue;
         visited.add(value);
+        const codex = decodeCodexErrorInfo(read(value, 'codexErrorInfo') ?? read(value, 'codex_error_info'));
+        if (codex)
+            codes.push(codex);
         for (const key of ['code', 'type', 'name'])
             codes.push(text(read(value, key)));
         messages.push(text(read(value, 'message')));
         for (const key of ['status', 'statusCode', 'httpStatus', 'status_code'])
             httpStatus ??= statusNumber(read(value, key));
+        httpStatus ??= codex?.httpStatusCode;
         const headers = read(value, 'headers');
         const header = typeof Headers !== 'undefined' && headers instanceof Headers
             ? headers.get('retry-after')
@@ -306,9 +414,20 @@ export function diagnoseProviderFailure(input) {
             source: auth.source,
         };
     }
-    let diagnosis = codes
-        .map((code) => classifyCode(code, input.credentialKind))
-        .find((code) => code !== undefined);
+    let diagnosis;
+    let codexErrorInfo;
+    for (const code of codes) {
+        if (typeof code === 'string') {
+            diagnosis = classifyCode(code, input.credentialKind);
+        }
+        else {
+            diagnosis = classifyCodexErrorInfo(code, input.credentialKind);
+            if (diagnosis)
+                codexErrorInfo = code.kind;
+        }
+        if (diagnosis)
+            break;
+    }
     let source = 'structured-error';
     if (!diagnosis && httpStatus !== undefined) {
         diagnosis = classifyStatus(httpStatus, input.credentialKind);
@@ -344,6 +463,7 @@ export function diagnoseProviderFailure(input) {
         credentialKind: input.credentialKind,
         diagnosis,
         recovery: recovery(diagnosis, input.credentialKind),
+        retryable: isRetryable(diagnosis, codexErrorInfo === 'usageLimitExceeded', retry),
         evidence: diagnosis === 'unknown'
             ? []
             : [
@@ -353,6 +473,7 @@ export function diagnoseProviderFailure(input) {
                     ...(source === 'authentication-check'
                         ? { checkedAt: authentication.checkedAt }
                         : {}),
+                    ...(codexErrorInfo ? { codexErrorInfo } : {}),
                 },
             ],
         ...(authentication ? { authentication } : {}),

package/dist/esm/providers/codex.js

@@ -18,7 +18,7 @@ import { CodexDatabase, spawnParentFromSource } from './codexDatabase';
 import { cachedSubagentStats } from '../parsers/subagentStatsCache';
 import { DEFAULT_ROLLOUT_WALK_MAX_DEPTH, extractRolloutSessionId as extractSessionId, isRolloutFile, walkRolloutFiles, } from './rolloutWalker';
 import { getCodexSessionsDirs } from '../codexPaths';
-import { cwdMatches, getSessionsDirs, listCodexSessionFilesAsync, normalizePath, readFirstLines, readSessionCwd, readSessionCwdAsync, readSessionMeta, } from './codexRollouts';
+import { cwdMatches, findCodexRolloutFile, getSessionsDirs, listCodexSessionFilesAsync, normalizePath, readFirstLines, readSessionCwd, readSessionCwdAsync, readSessionMeta, } from './codexRollouts';
 import { DirectoryListingCache, splitWatchedPath } from './directoryListingCache';
 import { ProviderDiagnosticTracker, diagnosticFromRuntimeStatus } from './diagnostics';
 import { getModelContextWindowSize } from '../modelContext';
@@ -47,29 +47,7 @@ function hasRolloutFile(dir) {
 function findRolloutFilesInConfiguredHomes(options = {}) {
     return walkRolloutFiles(getSessionsDirs(), options);
 }
-/**
- * Locates the rollout file for a Codex session id by walking
- * `<home>/sessions/YYYY/MM/DD/rollout-<timestamp>-<id>.jsonl`, then
- * `<home>/archived_sessions/`, where Codex moves the rollouts of archived
- * threads.
- *
- * Filename-only match, case-insensitive on the id — no file contents are read
- * and files are only stat'ed once their name matches, so the walk stays cheap
- * even over a large history. When the same id exists in more than one home,
- * the most recently modified copy wins. Returns `null` for an unknown, empty,
- * or whitespace id. Consumers who want the database's answer instead can query
- * the already-public `CodexDatabase` (requires the external `sqlite3` binary).
- */
-export function findCodexRolloutFile(sessionId, options = {}) {
-    const normalizedId = sessionId.trim().toLowerCase();
-    if (!normalizedId)
-        return null;
-    const sessionsDirs = options.codexHome
-        ? getCodexSessionsDirs([options.codexHome])
-        : getSessionsDirs();
-    // Name-only filter, one walk across the homes, newest modification first.
-    return walkRolloutFiles(sessionsDirs, { sessionId: normalizedId })[0]?.path ?? null;
-}
+export { findCodexRolloutFile };
 /** Pick the best sessions directory for UI/search entrypoints. */
 function getSessionsDir() {
     const dirs = getCodexSessionsDirs(undefined, { includeArchived: false });

package/dist/esm/providers/codexDatabase.js

@@ -5,30 +5,14 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { execFile, execFileSync } from 'child_process';
+import { codexSpawnParentFromSource as spawnParentFromSource } from '../parsers/codexRolloutOrigin';
 /**
  * Ids per inlined `IN (…)` query. Values are passed inside a single argv
  * element to sqlite3, so an unbounded list would hit E2BIG on large stores.
  */
 const SQL_ID_CHUNK_SIZE = 400;
-/** Parent thread id recorded in a Codex `threads.source` JSON value, if any. */
-export function spawnParentFromSource(source) {
-    let parsed = source;
-    if (typeof source === 'string') {
-        if (!source.startsWith('{'))
-            return undefined;
-        try {
-            parsed = JSON.parse(source);
-        }
-        catch {
-            return undefined;
-        }
-    }
-    if (!parsed || typeof parsed !== 'object')
-        return undefined;
-    const parent = parsed
-        .subagent?.thread_spawn?.parent_thread_id;
-    return typeof parent === 'string' ? parent : undefined;
-}
+/** Parent thread id of a spawned subagent's `source`; one rule shared with rollout parsing. */
+export { spawnParentFromSource };
 export class CodexDatabase {
     dbPath;
     sqlite3Available = null;

package/dist/esm/providers/codexRollouts.js

@@ -8,7 +8,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { getCodexSessionsDirs } from '../codexPaths';
 import { DirectoryListingCache } from './directoryListingCache';
-import { walkRolloutFilesAsync } from './rolloutWalker';
+import { walkRolloutFiles, walkRolloutFilesAsync } from './rolloutWalker';
 /** Every directory across the monitored homes that may hold rollouts, archived ones included. */
 export function getSessionsDirs() {
     return getCodexSessionsDirs();
@@ -213,3 +213,26 @@ export async function listCodexSessionFilesAsync(workspacePath, options = {}, ca
     }
     return results;
 }
+/**
+ * Locates the rollout file for a Codex session id by walking
+ * `<home>/sessions/YYYY/MM/DD/rollout-<timestamp>-<id>.jsonl`, then
+ * `<home>/archived_sessions/`, where Codex moves the rollouts of archived
+ * threads.
+ *
+ * Filename-only match, case-insensitive on the id — no file contents are read
+ * and files are only stat'ed once their name matches, so the walk stays cheap
+ * even over a large history. When the same id exists in more than one home,
+ * the most recently modified copy wins. Returns `null` for an unknown, empty,
+ * or whitespace id. Consumers who want the database's answer instead can query
+ * the already-public `CodexDatabase` (requires the external `sqlite3` binary).
+ */
+export function findCodexRolloutFile(sessionId, options = {}) {
+    const normalizedId = sessionId.trim().toLowerCase();
+    if (!normalizedId)
+        return null;
+    const sessionsDirs = options.codexHome
+        ? getCodexSessionsDirs([options.codexHome])
+        : getSessionsDirs();
+    // Name-only filter, one walk across the homes, newest modification first.
+    return walkRolloutFiles(sessionsDirs, { sessionId: normalizedId })[0]?.path ?? null;
+}

package/dist/esm/providers/openCode.js

@@ -21,9 +21,8 @@ import * as path from 'path';
 import { execSync } from 'child_process';
 import { readSessionContextSnapshot } from '../context/sessionContext';
 import { readSessionFileStats } from '../sessionStats';
-import { convertOpenCodeMessage, parseDbMessageData, parseDbPartData, normalizeToolName, normalizeToolInput, } from '../parsers/openCodeParser';
+import { convertOpenCodeMessage, parseDbMessageData, parseDbPartData, normalizeOpenCodeUsage, normalizeToolName, normalizeToolInput, } from '../parsers/openCodeParser';
 import { OpenCodeDatabase } from './openCodeDatabase';
-import { normalizeProviderUsage } from '../usageNormalization';
 import { addUsageToSubagent } from '../usage/subagentUsage';
 import { accumulateZaiUsage, inferZaiQuotaState, parseZaiQuotaError, ZAI_PROVIDER_IDS, } from '../zaiQuota';
 import { ProviderDiagnosticTracker, diagnosticFromRuntimeStatus } from './diagnostics';
@@ -1456,21 +1455,14 @@ export class OpenCodeProvider {
                             if (tokens) {
                                 // Same semantics as the main-session parser (openCodeParser).
                                 const cache = tokens.cache;
-                                const providerID = msgData.providerID;
-                                addUsageToSubagent(tokenTotals, normalizeProviderUsage({
-                                    semantics: providerID === 'openai'
-                                        ? 'openai'
-                                        : providerID === 'anthropic'
-                                            ? 'anthropic'
-                                            : 'sidekick',
-                                    provider: providerID ?? 'opencode',
-                                    inputTokens: tokens.input,
-                                    outputTokens: tokens.output,
-                                    cacheReadTokens: cache?.read,
-                                    cacheWriteTokens: cache?.write,
-                                    reasoningTokens: tokens.reasoning,
-                                    reasoningIncludedInOutput: providerID === 'openai',
-                                }));
+                                addUsageToSubagent(tokenTotals, normalizeOpenCodeUsage({
+                                    input: tokens.input,
+                                    output: tokens.output,
+                                    cacheRead: cache?.read,
+                                    cacheWrite: cache?.write,
+                                    reasoning: tokens.reasoning,
+                                    total: tokens.total,
+                                }, msgData.providerID));
                             }
                         }
                         catch {

package/dist/esm/report/htmlReportGenerator.js

@@ -596,14 +596,51 @@ function renderContentBlock(block, includeThinking, includeToolDetail) {
             return '';
     }
 }
-function renderToolUse(block, includeDetail) {
+/** Prefix of the bookkeeping keys session parsers stash inside tool inputs. */
+const SIDEKICK_INPUT_KEY_PREFIX = '_sidekick';
+/**
+ * The tool's display identity and user-facing input. Entries built outside
+ * the canonical projection may still carry the parsers' `_sidekick*` keys in
+ * `toolInput`; those are hidden here and read as the raw identity.
+ */
+function toolDisplay(block) {
     const name = block.toolName || 'unknown';
+    const raw = block.toolInput;
+    let input = raw;
+    let rawToolName = block.rawToolName;
+    let mcpServerName = block.mcpServerName;
+    if (raw && Object.keys(raw).some((key) => key.startsWith(SIDEKICK_INPUT_KEY_PREFIX))) {
+        const clean = {};
+        for (const [key, value] of Object.entries(raw)) {
+            if (!key.startsWith(SIDEKICK_INPUT_KEY_PREFIX))
+                clean[key] = value;
+        }
+        input = clean;
+        if (!rawToolName && typeof raw._sidekickRawToolName === 'string') {
+            rawToolName = raw._sidekickRawToolName;
+        }
+        if (!mcpServerName && typeof raw._sidekickMcpServerName === 'string') {
+            mcpServerName = raw._sidekickMcpServerName;
+        }
+    }
+    const parts = [];
+    if (rawToolName && rawToolName.trim() && rawToolName !== name)
+        parts.push(rawToolName);
+    if (mcpServerName && mcpServerName.trim())
+        parts.push(`MCP: ${mcpServerName}`);
+    const hint = parts.length
+        ? ` <span class="tool-raw-name" style="color:var(--text-muted);font-size:11px">${escapeHtml(parts.join(' · '))}</span>`
+        : '';
+    return { name, hint, input };
+}
+function renderToolUse(block, includeDetail) {
+    const { name, hint, input } = toolDisplay(block);
     if (!includeDetail) {
-        return `<div class="tool-block" data-block-type="tool"><div style="padding:8px 12px;background:rgba(245,166,35,0.08);color:var(--accent-orange);font-family:monospace;font-size:13px;">${escapeHtml(name)}</div></div>`;
+        return `<div class="tool-block" data-block-type="tool"><div style="padding:8px 12px;background:rgba(245,166,35,0.08);color:var(--accent-orange);font-family:monospace;font-size:13px;">${escapeHtml(name)}${hint}</div></div>`;
     }
     let inputHtml = '';
-    if (block.toolInput && Object.keys(block.toolInput).length > 0) {
-        const inputJson = JSON.stringify(block.toolInput, null, 2);
+    if (input && Object.keys(input).length > 0) {
+        const inputJson = JSON.stringify(input, null, 2);
         const highlighted = highlightCodeBlock(inputJson, 'json');
         inputHtml = `<div class="tool-io">
     <div class="tool-label">Input</div>
@@ -611,7 +648,7 @@ function renderToolUse(block, includeDetail) {
   </div>`;
     }
     return `<details class="tool-block" data-block-type="tool">
-  <summary>${escapeHtml(name)}${block.toolUseId ? ` <span style="color:var(--text-muted);font-size:11px">${escapeHtml(block.toolUseId)}</span>` : ''}</summary>
+  <summary>${escapeHtml(name)}${hint}${block.toolUseId ? ` <span style="color:var(--text-muted);font-size:11px">${escapeHtml(block.toolUseId)}</span>` : ''}</summary>
   <div class="tool-content">
     ${inputHtml}
   </div>

package/dist/esm/report/transcriptParser.js

@@ -42,17 +42,19 @@ function toReportBlock(block) {
             return block.text ? [{ type: 'text', text: block.text }] : [];
         case 'thinking':
             return block.text ? [{ type: 'thinking', text: block.text }] : [];
-        case 'tool_use':
-            return [
-                {
-                    type: 'tool_use',
-                    toolName: block.toolName ?? 'unknown',
-                    toolInput: block.input && typeof block.input === 'object'
-                        ? block.input
-                        : {},
-                    toolUseId: block.toolUseId,
-                },
-            ];
+        case 'tool_use': {
+            const toolBlock = {
+                type: 'tool_use',
+                toolName: block.toolName ?? 'unknown',
+                toolInput: block.input && typeof block.input === 'object'
+                    ? block.input
+                    : {},
+                toolUseId: block.toolUseId,
+                ...(block.rawToolName ? { rawToolName: block.rawToolName } : {}),
+                ...(block.mcpServerName ? { mcpServerName: block.mcpServerName } : {}),
+            };
+            return [toolBlock];
+        }
         case 'tool_result':
             return [
                 {

package/dist/esm/schemas/providerFailure.js

@@ -9,7 +9,7 @@
  */
 import { z } from 'zod';
 import { ACCOUNT_PROVIDER_IDS } from '../providerIds';
-import { PROVIDER_AUTHENTICATION_SOURCES, PROVIDER_AUTHENTICATION_STATES, PROVIDER_CREDENTIAL_KINDS, PROVIDER_FAILURE_CODES, PROVIDER_FAILURE_EVIDENCE_SOURCES, PROVIDER_RECOVERY_ACTIONS, } from '../providerFailure';
+import { CODEX_ERROR_INFO_KINDS, PROVIDER_AUTHENTICATION_SOURCES, PROVIDER_AUTHENTICATION_STATES, PROVIDER_CREDENTIAL_KINDS, PROVIDER_FAILURE_CODES, PROVIDER_FAILURE_EVIDENCE_SOURCES, PROVIDER_RECOVERY_ACTIONS, } from '../providerFailure';
 export const providerAuthenticationEvidenceSchema = z.object({
     credentialKind: z.enum(PROVIDER_CREDENTIAL_KINDS),
     state: z.enum(PROVIDER_AUTHENTICATION_STATES),
@@ -20,6 +20,7 @@ export const providerFailureEvidenceSchema = z.object({
     source: z.enum(PROVIDER_FAILURE_EVIDENCE_SOURCES),
     rule: z.enum(PROVIDER_FAILURE_CODES),
     checkedAt: z.string().optional(),
+    codexErrorInfo: z.enum(CODEX_ERROR_INFO_KINDS).optional(),
 });
 export const providerRetryAfterSchema = z.discriminatedUnion('kind', [
     z.object({ kind: z.literal('delay'), delayMs: z.number() }),
@@ -30,6 +31,7 @@ export const providerFailureDiagnosisSchema = z.object({
     credentialKind: z.enum(PROVIDER_CREDENTIAL_KINDS),
     diagnosis: z.enum(PROVIDER_FAILURE_CODES),
     recovery: z.enum(PROVIDER_RECOVERY_ACTIONS),
+    retryable: z.boolean().optional(),
     evidence: z.array(providerFailureEvidenceSchema),
     authentication: providerAuthenticationEvidenceSchema.optional(),
     httpStatus: z.number().optional(),