sidekick-shared 0.28.3 → 0.29.1

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/claudeCode.js

@@ -13,7 +13,7 @@ import { StringDecoder } from 'string_decoder';
 import { readSessionContextSnapshot } from '../context/sessionContext';
 import { readSessionFileStats } from '../sessionStats';
 import { JsonlParser } from '../parsers/jsonl';
-import { ClaudeUsageDeduper, normalizeClaudeUsage } from '../usage/claudeUsageDedupe';
+import { ClaudeUsageDeduper, normalizeClaudeUsage, } from '../usage/claudeUsageDedupe';
 import { ProviderDiagnosticTracker } from './diagnostics';
 import { DirectoryListingCache, splitWatchedPath } from './directoryListingCache';
 import { encodeWorkspacePath as encodeWsPath, getSessionDirectory as getSessionDir, discoverSessionDirectory as discoverSessionDir, findActiveSession as findActiveSessionPath, findAllSessions as findAllSessionPaths, findSessionsInDirectory as findSessionsInDir, decodeEncodedPath, getAllProjectFolders as getAllProjectFoldersRaw, findSessionFilesWithStats, } from '../parsers/sessionPathResolver';
@@ -119,7 +119,8 @@ class ClaudeCodeReader {
         this.usageDeduper = usageDeduper ?? new ClaudeUsageDeduper();
         this.parser = new JsonlParser({
             onEvent: (raw) => {
-                for (const event of extractSessionEvents(raw)) {
+                // Mid-turn task notifications finish background subagents.
+                for (const event of extractSessionEvents(raw, { includeTaskNotifications: true })) {
                     this.events.push(this.usageDeduper.apply(normalizeClaudeUsage(event)));
                 }
             },
@@ -208,6 +209,13 @@ class ClaudeCodeReader {
     wasTruncated() {
         return this._wasTruncated;
     }
+    /** The usage deduper's recent message ids, so a resumed reader does not recount a split response. */
+    getResumeState() {
+        return this.usageDeduper.exportState();
+    }
+    restoreResumeState(state) {
+        return this.usageDeduper.importState(state);
+    }
 }
 /**
  * Session provider for Claude Code CLI.

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 });
@@ -292,6 +270,12 @@ class CodexReader {
     lineBuffer = '';
     _wasTruncated = false;
     decoder = new StringDecoder('utf8');
+    /**
+     * Position from `seekTo()` whose prefix still has to be parsed for model,
+     * turn, and cumulative-token context; `restoreResumeState()` supplies that
+     * context instead and clears it.
+     */
+    pendingSeek = null;
     constructor(rolloutPath, onContextWindowLimit, onRateLimits, onTokenUsage) {
         this.rolloutPath = rolloutPath;
         this.onContextWindowLimit = onContextWindowLimit;
@@ -301,9 +285,11 @@ class CodexReader {
     }
     /** Get the parser's session metadata. */
     getSessionMeta() {
+        this.settleSeek();
         return this.parser.getSessionMeta();
     }
     readNew(endPosition) {
+        this.settleSeek();
         this._wasTruncated = false;
         const events = [];
         try {
@@ -357,47 +343,51 @@ class CodexReader {
                     // Skip malformed JSON lines
                 }
             }
-            // Propagate model_context_window from token_count events to the provider.
-            // The model comes along so the value can be persisted per model — the
-            // window Codex reports is tier-specific, not the published maximum.
-            const mcw = this.parser.getModelContextWindow();
-            if (mcw && this.onContextWindowLimit) {
-                this.onContextWindowLimit(mcw, this.parser.getCurrentModel() ?? undefined);
-            }
-            // Propagate rate_limits from token_count events to the provider
-            const rateLimits = this.parser.getLastRateLimits();
-            if (rateLimits && this.onRateLimits) {
-                this.onRateLimits(rateLimits);
-            }
-            // Propagate last token usage snapshot to the provider
-            const lastUsage = this.parser.getLastTokenUsage();
-            if (lastUsage && this.onTokenUsage) {
-                const normalized = normalizeProviderUsage({
-                    semantics: 'openai',
-                    provider: 'openai',
-                    source: 'codex-reader-snapshot',
-                    model: this.parser.getCurrentModel() || undefined,
-                    inputTokens: lastUsage.input_tokens,
-                    outputTokens: lastUsage.output_tokens,
-                    cacheReadTokens: lastUsage.cached_input_tokens,
-                    reasoningTokens: lastUsage.reasoning_output_tokens,
-                });
-                this.onTokenUsage({
-                    inputTokens: normalized.uncachedInputTokens,
-                    outputTokens: normalized.outputTokens,
-                    cacheWriteTokens: normalized.cacheWriteTokens,
-                    cacheReadTokens: normalized.cacheReadTokens,
-                    reasoningTokens: normalized.reasoningTokens,
-                    model: this.parser.getCurrentModel() || 'unknown',
-                    timestamp: new Date(),
-                });
-            }
+            this.propagateParserState();
         }
         catch {
             // Skip read errors
         }
         return events;
     }
+    /** Hands the parser's context window, rate limits, and last usage to the provider. */
+    propagateParserState() {
+        // Propagate model_context_window from token_count events to the provider.
+        // The model comes along so the value can be persisted per model — the
+        // window Codex reports is tier-specific, not the published maximum.
+        const mcw = this.parser.getModelContextWindow();
+        if (mcw && this.onContextWindowLimit) {
+            this.onContextWindowLimit(mcw, this.parser.getCurrentModel() ?? undefined);
+        }
+        // Propagate rate_limits from token_count events to the provider
+        const rateLimits = this.parser.getLastRateLimits();
+        if (rateLimits && this.onRateLimits) {
+            this.onRateLimits(rateLimits);
+        }
+        // Propagate last token usage snapshot to the provider
+        const lastUsage = this.parser.getLastTokenUsage();
+        if (lastUsage && this.onTokenUsage) {
+            const normalized = normalizeProviderUsage({
+                semantics: 'openai',
+                provider: 'openai',
+                source: 'codex-reader-snapshot',
+                model: this.parser.getCurrentModel() || undefined,
+                inputTokens: lastUsage.input_tokens,
+                outputTokens: lastUsage.output_tokens,
+                cacheReadTokens: lastUsage.cached_input_tokens,
+                reasoningTokens: lastUsage.reasoning_output_tokens,
+            });
+            this.onTokenUsage({
+                inputTokens: normalized.uncachedInputTokens,
+                outputTokens: normalized.outputTokens,
+                cacheWriteTokens: normalized.cacheWriteTokens,
+                cacheReadTokens: normalized.cacheReadTokens,
+                reasoningTokens: normalized.reasoningTokens,
+                model: this.parser.getCurrentModel() || 'unknown',
+                timestamp: new Date(),
+            });
+        }
+    }
     readAll() {
         this.reset();
         return this.readNew();
@@ -409,11 +399,13 @@ class CodexReader {
         this.parser.reset();
         this.decoder = new StringDecoder('utf8');
         this._wasTruncated = false;
+        this.pendingSeek = null;
     }
     exists() {
         return fs.existsSync(this.rolloutPath);
     }
     flush() {
+        this.settleSeek();
         this.lineBuffer += this.decoder.end();
         // Process any remaining data in the line buffer
         if (this.lineBuffer.trim()) {
@@ -431,15 +423,45 @@ class CodexReader {
         return this.committedPosition;
     }
     seekTo(position) {
-        // Rebuild model, turn, and cumulative-token context before resuming.
-        // The prefix is parsed only; its events are already in the consumer snapshot.
         this.reset();
+        this.filePosition = position;
+        this.committedPosition = position;
+        // The prefix's context is rebuilt on the next read, unless
+        // restoreResumeState() supplies it first.
         if (position > 0)
-            this.readNew(position);
+            this.pendingSeek = position;
     }
     wasTruncated() {
         return this._wasTruncated;
     }
+    /** The parser's continuation state (see `CodexRolloutParser.exportResumeState`). */
+    getResumeState() {
+        this.settleSeek();
+        return this.parser.exportResumeState();
+    }
+    /**
+     * Restores parser state from `getResumeState()`; after `seekTo()` this
+     * replaces re-parsing the rollout up to that position.
+     */
+    restoreResumeState(state) {
+        if (!this.parser.importResumeState(state))
+            return false;
+        this.pendingSeek = null;
+        this.propagateParserState();
+        return true;
+    }
+    /**
+     * Rebuilds model, turn, and cumulative-token context for a pending
+     * `seekTo()` position. The prefix is parsed only; its events are already
+     * in the consumer snapshot.
+     */
+    settleSeek() {
+        const position = this.pendingSeek;
+        if (position === null)
+            return;
+        this.reset();
+        this.readNew(position);
+    }
 }
 // ---------------------------------------------------------------------------
 // CodexProvider — full SessionProviderBase implementation

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 {