sidekick-shared 0.28.2 → 0.29.0

package/dist/promptHistory.js

@@ -15,6 +15,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
@@ -54,8 +58,9 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.__promptHistoryTesting = exports.DEFAULT_BOUNDS = void 0;
+exports.__promptHistoryTesting = exports.DEFAULT_BOUNDS = exports.PROMPT_HISTORY_ORDINAL_MAX_RECORD_BYTES = void 0;
 exports.collectPromptHistory = collectPromptHistory;
+exports.readPromptOrdinalMarks = readPromptOrdinalMarks;
 exports.emptyStats = emptyStats;
 exports.isPromptHistorySessionSettled = isPromptHistorySessionSettled;
 exports.parsePromptHistoryCursor = parsePromptHistoryCursor;
@@ -72,12 +77,19 @@ const codexRollouts_1 = require("./providers/codexRollouts");
 const directoryListingCache_1 = require("./providers/directoryListingCache");
 const workspaceRoots_1 = require("./workspaceRoots");
 const fileHead_1 = require("./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.
+ */
+exports.PROMPT_HISTORY_ORDINAL_MAX_RECORD_BYTES = 16 * 1024 * 1024;
 /** @internal */
 exports.DEFAULT_BOUNDS = {
     maxSessions: 1000,
     maxFileBytes: 16 * 1024 * 1024,
     maxTotalBytes: 256 * 1024 * 1024,
-    maxRecordBytes: 16 * 1024 * 1024,
+    maxRecordBytes: exports.PROMPT_HISTORY_ORDINAL_MAX_RECORD_BYTES,
     maxEntries: 10_000,
     deadlineMs: 30_000,
 };
@@ -152,6 +164,7 @@ async function collectPromptHistory(options) {
             if (exclusions.length < MAX_EXCLUSIONS)
                 exclusions.push(exclusion);
         },
+        includeText: options.includeText !== false,
     };
     let totalBytes = 0;
     let scannedAny = false;
@@ -265,6 +278,46 @@ 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
+ */
+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: exports.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 */
 function emptyStats() {
     return {
@@ -943,7 +996,7 @@ class LineScanner {
         return {
             entry: {
                 ...entry,
-                text,
+                ...this.textFields(text),
                 cwd: scoped,
                 ...(place.gitBranch ? { gitBranch: place.gitBranch } : {}),
                 ...(entry.usage ? { usage: { ...entry.usage } } : {}),
@@ -962,11 +1015,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;
         }
@@ -984,7 +1047,7 @@ class LineScanner {
             sessionId: this.candidate.sessionId,
             ordinal,
             timestamp,
-            text,
+            ...this.textFields(text),
             cwd: scoped,
             ...(gitBranch ? { gitBranch } : {}),
             metadataStatus: 'pending',

package/dist/providerFailure.d.ts

@@ -29,10 +29,26 @@ export type ProviderRetryAfter = {
     at: string;
 };
 export declare const PROVIDER_FAILURE_EVIDENCE_SOURCES: readonly ["structured-error", "http-status", "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 declare const CODEX_ERROR_INFO_KINDS: readonly ["contextWindowExceeded", "sessionBudgetExceeded", "usageLimitExceeded", "rateLimitExceeded", "serverOverloaded", "cyberPolicy", "httpConnectionFailed", "responseStreamConnectionFailed", "internalServerError", "unauthorized", "badRequest", "threadRollbackFailed", "sandboxError", "responseStreamDisconnected", "responseTooManyFailedAttempts", "activeTurnNotSteerable", "other"];
+export type CodexErrorInfoKind = (typeof CODEX_ERROR_INFO_KINDS)[number];
+/** A decoded `codexErrorInfo`: its closed variant and any upstream HTTP status. */
+export interface CodexErrorInfoSummary {
+    kind: CodexErrorInfoKind;
+    /** Present when a transport variant carried a valid `httpStatusCode`. */
+    httpStatusCode?: number;
+}
 export interface ProviderFailureEvidence {
     source: (typeof PROVIDER_FAILURE_EVIDENCE_SOURCES)[number];
     rule: ProviderFailureCode;
     checkedAt?: string;
+    /** Present only when a Codex `codexErrorInfo` decided the rule. */
+    codexErrorInfo?: CodexErrorInfoKind;
 }
 /** Safe diagnostic projection. No raw error text, request data, or credentials. */
 export interface ProviderFailureDiagnosis {
@@ -40,13 +56,41 @@ export interface ProviderFailureDiagnosis {
     credentialKind: ProviderCredentialKind;
     diagnosis: ProviderFailureCode;
     recovery: ProviderRecoveryAction;
+    /**
+     * Whether sending the same request again, unchanged and after any
+     * `retryAfter`, can reasonably succeed. True for a rate limit that will
+     * lift, overload, an unavailable service (5xx), a timeout, or a failed
+     * connection. False for authentication, missing runtime or configuration,
+     * execution policy, an invalid provider session, context overflow, a usage
+     * quota exhausted with no known reset, and unknown failures. Conservative:
+     * a hint for retry policy, not a promise. The caller still decides whether
+     * a repeat is safe (idempotency, output already delivered).
+     *
+     * Always set by `diagnoseProviderFailure()` since 0.29.0; optional in the
+     * type so diagnoses stored or built by older producers stay valid.
+     */
+    retryable?: boolean;
     evidence: ProviderFailureEvidence[];
     authentication?: ProviderAuthenticationEvidence;
     httpStatus?: number;
     retryAfter?: ProviderRetryAfter;
 }
+/**
+ * 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 declare function decodeCodexErrorInfo(value: unknown): CodexErrorInfoSummary | undefined;
 /**
  * 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 declare function diagnoseProviderFailure(input: ProviderFailureInput): ProviderFailureDiagnosis;

package/dist/providerFailure.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PROVIDER_FAILURE_EVIDENCE_SOURCES = exports.PROVIDER_RECOVERY_ACTIONS = exports.PROVIDER_FAILURE_CODES = exports.PROVIDER_AUTHENTICATION_SOURCES = exports.PROVIDER_AUTHENTICATION_STATES = exports.PROVIDER_CREDENTIAL_KINDS = void 0;
+exports.CODEX_ERROR_INFO_KINDS = exports.PROVIDER_FAILURE_EVIDENCE_SOURCES = exports.PROVIDER_RECOVERY_ACTIONS = exports.PROVIDER_FAILURE_CODES = exports.PROVIDER_AUTHENTICATION_SOURCES = exports.PROVIDER_AUTHENTICATION_STATES = exports.PROVIDER_CREDENTIAL_KINDS = void 0;
+exports.decodeCodexErrorInfo = decodeCodexErrorInfo;
 exports.diagnoseProviderFailure = diagnoseProviderFailure;
 exports.PROVIDER_CREDENTIAL_KINDS = ['oauth', 'api-key', 'unknown'];
 exports.PROVIDER_AUTHENTICATION_STATES = [
@@ -46,6 +47,31 @@ exports.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.
+ */
+exports.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;
@@ -81,6 +107,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(exports.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`.
+ */
+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'
@@ -171,6 +231,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';
@@ -236,6 +334,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`.
  */
 function diagnoseProviderFailure(input) {
     const codes = [];
@@ -253,11 +358,15 @@ 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')
@@ -310,9 +419,20 @@ 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);
@@ -348,6 +468,7 @@ function diagnoseProviderFailure(input) {
         credentialKind: input.credentialKind,
         diagnosis,
         recovery: recovery(diagnosis, input.credentialKind),
+        retryable: isRetryable(diagnosis, codexErrorInfo === 'usageLimitExceeded', retry),
         evidence: diagnosis === 'unknown'
             ? []
             : [
@@ -357,6 +478,7 @@ function diagnoseProviderFailure(input) {
                     ...(source === 'authentication-check'
                         ? { checkedAt: authentication.checkedAt }
                         : {}),
+                    ...(codexErrorInfo ? { codexErrorInfo } : {}),
                 },
             ],
         ...(authentication ? { authentication } : {}),

package/dist/providers/codex.d.ts

@@ -9,31 +9,12 @@
  * Ported from sidekick-vscode/src/services/providers/CodexSessionProvider.ts
  */
 import type { ReadSessionContextSnapshotOptions, SessionContextSnapshot } from '../context/sessionContext';
+import { findCodexRolloutFile } from './codexRollouts';
 import type { ListSessionFilesOptions, SessionProviderBase, SessionReader, ProjectFolderInfo, SearchHit, SessionFileInfo, SessionFileStats, ProviderId, ProviderOperationStatus, ProviderRuntimeStatus, SessionProviderOptions, WatchedSessionFile } from './types';
 import type { SubagentStats, TokenUsage } from '../types/sessionEvent';
 import type { CodexRateLimits } from '../types/codex';
-export interface FindCodexRolloutFileOptions {
-    /**
-     * Codex home whose `sessions/` subtree to search. Defaults to every
-     * monitored home: `$CODEX_HOME` if set, else `~/.codex`, plus managed
-     * profile homes that recorded sessions.
-     */
-    codexHome?: string;
-}
-/**
- * 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 declare function findCodexRolloutFile(sessionId: string, options?: FindCodexRolloutFileOptions): string | null;
+export { findCodexRolloutFile };
+export type { FindCodexRolloutFileOptions } from './codexRollouts';
 /**
  * Session provider for Codex CLI.
  *

package/dist/providers/codex.js

@@ -43,8 +43,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CodexProvider = void 0;
-exports.findCodexRolloutFile = findCodexRolloutFile;
+exports.CodexProvider = exports.findCodexRolloutFile = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const string_decoder_1 = require("string_decoder");
@@ -56,6 +55,7 @@ const subagentStatsCache_1 = require("../parsers/subagentStatsCache");
 const rolloutWalker_1 = require("./rolloutWalker");
 const codexPaths_1 = require("../codexPaths");
 const codexRollouts_1 = require("./codexRollouts");
+Object.defineProperty(exports, "findCodexRolloutFile", { enumerable: true, get: function () { return codexRollouts_1.findCodexRolloutFile; } });
 const directoryListingCache_1 = require("./directoryListingCache");
 const diagnostics_1 = require("./diagnostics");
 const modelContext_1 = require("../modelContext");
@@ -84,29 +84,6 @@ function hasRolloutFile(dir) {
 function findRolloutFilesInConfiguredHomes(options = {}) {
     return (0, rolloutWalker_1.walkRolloutFiles)((0, codexRollouts_1.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).
- */
-function findCodexRolloutFile(sessionId, options = {}) {
-    const normalizedId = sessionId.trim().toLowerCase();
-    if (!normalizedId)
-        return null;
-    const sessionsDirs = options.codexHome
-        ? (0, codexPaths_1.getCodexSessionsDirs)([options.codexHome])
-        : (0, codexRollouts_1.getSessionsDirs)();
-    // Name-only filter, one walk across the homes, newest modification first.
-    return (0, rolloutWalker_1.walkRolloutFiles)(sessionsDirs, { sessionId: normalizedId })[0]?.path ?? null;
-}
 /** Pick the best sessions directory for UI/search entrypoints. */
 function getSessionsDir() {
     const dirs = (0, codexPaths_1.getCodexSessionsDirs)(undefined, { includeArchived: false });
@@ -634,7 +611,7 @@ class CodexProvider {
     }
     findSessionById(_workspacePath, sessionId) {
         try {
-            const found = findCodexRolloutFile(sessionId);
+            const found = (0, codexRollouts_1.findCodexRolloutFile)(sessionId);
             this.recordDatabaseFallback('findSessionById', true);
             return found;
         }

package/dist/providers/codexDatabase.d.ts

@@ -4,8 +4,9 @@
  */
 import type { CodexDbThread } from '../types/codex';
 import type { ProviderRuntimeStatus } from './types';
-/** Parent thread id recorded in a Codex `threads.source` JSON value, if any. */
-export declare function spawnParentFromSource(source: unknown): string | undefined;
+import { codexSpawnParentFromSource as spawnParentFromSource } from '../parsers/codexRolloutOrigin';
+/** Parent thread id of a spawned subagent's `source`; one rule shared with rollout parsing. */
+export { spawnParentFromSource };
 export declare class CodexDatabase {
     private readonly dbPath;
     private sqlite3Available;

package/dist/providers/codexDatabase.js

@@ -37,35 +37,17 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CodexDatabase = void 0;
-exports.spawnParentFromSource = spawnParentFromSource;
+exports.CodexDatabase = exports.spawnParentFromSource = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
+const codexRolloutOrigin_1 = require("../parsers/codexRolloutOrigin");
+Object.defineProperty(exports, "spawnParentFromSource", { enumerable: true, get: function () { return codexRolloutOrigin_1.codexSpawnParentFromSource; } });
 /**
  * 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. */
-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;
-}
 class CodexDatabase {
     dbPath;
     sqlite3Available = null;
@@ -246,7 +228,7 @@ class CodexDatabase {
         if (!this.getThreadColumns().has('source'))
             return [];
         const rows = this.query('SELECT * FROM threads WHERE source LIKE ? ORDER BY created_at ASC', [`%${parentId}%`]);
-        return rows.filter((row) => spawnParentFromSource(row.source) === parentId);
+        return rows.filter((row) => (0, codexRolloutOrigin_1.codexSpawnParentFromSource)(row.source) === parentId);
     }
     /** Get the database file's mtime (ms epoch). Returns 0 if unavailable. */
     getDbMtime() {

package/dist/providers/codexRollouts.d.ts

@@ -42,3 +42,25 @@ export declare function normalizePath(input: string): string;
  * sits inside it.
  */
 export declare function listCodexSessionFilesAsync(workspacePath?: string, options?: ListSessionFilesOptions, cache?: DirectoryListingCache): Promise<SessionFileInfo[]>;
+export interface FindCodexRolloutFileOptions {
+    /**
+     * Codex home whose `sessions/` subtree to search. Defaults to every
+     * monitored home: `$CODEX_HOME` if set, else `~/.codex`, plus managed
+     * profile homes that recorded sessions.
+     */
+    codexHome?: string;
+}
+/**
+ * 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 declare function findCodexRolloutFile(sessionId: string, options?: FindCodexRolloutFileOptions): string | null;

package/dist/providers/codexRollouts.js

@@ -50,6 +50,7 @@ exports.initializeCounters = initializeCounters;
 exports.cwdMatches = cwdMatches;
 exports.normalizePath = normalizePath;
 exports.listCodexSessionFilesAsync = listCodexSessionFilesAsync;
+exports.findCodexRolloutFile = findCodexRolloutFile;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const codexPaths_1 = require("../codexPaths");
@@ -259,3 +260,26 @@ async function listCodexSessionFilesAsync(workspacePath, options = {}, cache = n
     }
     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).
+ */
+function findCodexRolloutFile(sessionId, options = {}) {
+    const normalizedId = sessionId.trim().toLowerCase();
+    if (!normalizedId)
+        return null;
+    const sessionsDirs = options.codexHome
+        ? (0, codexPaths_1.getCodexSessionsDirs)([options.codexHome])
+        : getSessionsDirs();
+    // Name-only filter, one walk across the homes, newest modification first.
+    return (0, rolloutWalker_1.walkRolloutFiles)(sessionsDirs, { sessionId: normalizedId })[0]?.path ?? null;
+}

package/dist/providers/openCode.js

@@ -60,7 +60,6 @@ const sessionContext_1 = require("../context/sessionContext");
 const sessionStats_1 = require("../sessionStats");
 const openCodeParser_1 = require("../parsers/openCodeParser");
 const openCodeDatabase_1 = require("./openCodeDatabase");
-const usageNormalization_1 = require("../usageNormalization");
 const subagentUsage_1 = require("../usage/subagentUsage");
 const zaiQuota_1 = require("../zaiQuota");
 const diagnostics_1 = require("./diagnostics");
@@ -1493,21 +1492,14 @@ class OpenCodeProvider {
                             if (tokens) {
                                 // Same semantics as the main-session parser (openCodeParser).
                                 const cache = tokens.cache;
-                                const providerID = msgData.providerID;
-                                (0, subagentUsage_1.addUsageToSubagent)(tokenTotals, (0, usageNormalization_1.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',
-                                }));
+                                (0, subagentUsage_1.addUsageToSubagent)(tokenTotals, (0, openCodeParser_1.normalizeOpenCodeUsage)({
+                                    input: tokens.input,
+                                    output: tokens.output,
+                                    cacheRead: cache?.read,
+                                    cacheWrite: cache?.write,
+                                    reasoning: tokens.reasoning,
+                                    total: tokens.total,
+                                }, msgData.providerID));
                             }
                         }
                         catch {