sidekick-shared 0.28.3 → 0.29.1

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

@@ -155,7 +155,8 @@ class ClaudeCodeReader {
         this.usageDeduper = usageDeduper ?? new claudeUsageDedupe_1.ClaudeUsageDeduper();
         this.parser = new jsonl_1.JsonlParser({
             onEvent: (raw) => {
-                for (const event of (0, sessionEvent_1.extractSessionEvents)(raw)) {
+                // Mid-turn task notifications finish background subagents.
+                for (const event of (0, sessionEvent_1.extractSessionEvents)(raw, { includeTaskNotifications: true })) {
                     this.events.push(this.usageDeduper.apply((0, claudeUsageDedupe_1.normalizeClaudeUsage)(event)));
                 }
             },
@@ -244,6 +245,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/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.
  *