sidekick-shared 0.26.0 → 0.26.2

package/CHANGELOG.md

@@ -5,6 +5,29 @@ All notable changes to sidekick-shared will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.26.2] - 2026-09-06
+
+### Added
+
+- `DoctorOptions.provider` selects the session provider to diagnose; `HealthReport.sessionProvider` records it.
+- Optional watcher `onBatchComplete` callback for persisting state after all events in a read have been delivered.
+- `SessionSearchOptions.projectPath` and `signal` for provider-aware workspace filtering and cancellation; legacy `projectSlug` remains supported.
+
+### Fixed
+
+- JSONL watcher and provider reader checkpoints end at complete lines, retaining partial UTF-8 characters across reads and restarts. Codex restores parser context when seeking.
+- Watcher failures retain polling fallback; OpenCode watchers share the canonical data-directory resolver.
+- Session search enumerates through providers, includes database-only sessions, and deduplicates paths.
+- Doctor checks the selected session provider, treats unrelated integrations as informational, and reads account status without changing account selection.
+
+## [0.26.1] - 2026-09-05
+
+### Fixed
+
+- Static model metadata verified on 2026-09-05 adds exact Fable 5.1 pricing/context entries in dashed and dotted forms, with its $0.25/M cache-read rate, and GPT-6 Astra pricing with a 1.05M context window. GPT-5.6 Sol/Terra/Luna rates and the Sol alias are current; GPT-5.4 mini cache reads cost $0.075/M and mini/nano context windows are 400K. Sonnet 5's permanent $2/$10 rate is documented. Catalog overrides, observed limits, and historical models are preserved.
+- `resolveQuota({ preferFresh: false })` tries the API before local samples when API access is allowed. Failed live queries select the newer session or cached sample by capture time, prefer the cache on ties, and retain the API failure. Only a selected session sample is persisted.
+- Codex quota failures name Codex instead of Claude or Anthropic. Default cache preferences and API-disabled resolution are unchanged.
+
 ## [0.26.0] - 2026-09-05
 
 ### Added

package/README.md

@@ -9,7 +9,8 @@ Types, parsers, providers, readers, formatters, aggregation, search, reporting,
 
 ## Recent additions
 
-- **One token vocabulary and cost provenance (0.26.0)** — `summarizeTokens()` gives every surface the same `total` (input + output + cache writes + cache reads) and `context` (input + cache) figures; `AggregatedTokens.costUsd` carries `costProvenance` so reports can say whether a cost was provider-reported or estimated; `parseClaudeStatuslinePayload()` / `quotaFromStatuslinePayload()` turn Claude Code's status-line JSON into an official `statusline` quota source; `readQuotaSnapshot()` reports `ageMs` / `freshness` and keeps the sample's origin as `capturedSource`; `resolveQuota()` is the one quota resolution path (fresh persisted sample → session logs → provider API → older sample) shared by the CLI, the MCP server, and both dashboards; `readSessionFileStats()` / `computeSessionFileStats()` give every provider one `readSessionStats()` over the shared aggregator, with `availability`, `costProvenance`, and `toolFailures` on `SessionFileStats`; `collectUsageEvents()` reads priced usage events from session logs with a per-session cache, `computeBillingBlocks()` groups them into five-hour billing blocks, and `bucketUsage()` turns them into day, week, month, or session rows; `applySessionSummary()` and `importSessionHistory()` let any host fold finished sessions into `historical-data.json` the way the extension does; observed sessions are read once per discovery, re-read only when their fingerprint changes, and classified from events by `classifySessionActivity()`; `readSessionReportInputs()` derives report metrics and transcript from one read; `writeStateFile()` / `readStateFile()` (also on the `statusline` subpath) maintain the public, versioned `state.json` for external tools, validated by `sidekickStateFileSchema`; `getScheduledPeakHoursState()` and `evaluateQuotaThresholds()` are shared by the CLI and extension dashboards.
+- **0.26.2: reliable monitoring and search** — complete-line JSONL cursors preserve Unicode and Codex parser context; watcher `onBatchComplete` signals a delivered batch. `searchSessions()` adds workspace-path filtering and cancellation, and Doctor accepts an explicit session provider.
+- **One token vocabulary and cost provenance (0.26.0)** — `summarizeTokens()` gives every surface the same `total` (input + output + cache writes + cache reads) and `context` (input + cache) figures; `AggregatedTokens.costUsd` carries `costProvenance` so reports can say whether a cost was provider-reported or estimated; `parseClaudeStatuslinePayload()` / `quotaFromStatuslinePayload()` turn Claude Code's status-line JSON into an official `statusline` quota source; `readQuotaSnapshot()` reports `ageMs` / `freshness` and keeps the sample's origin as `capturedSource`; `resolveQuota()` shares quota resolution across CLI, MCP, and dashboard startup, with default local-sample preferences and an API-first option used by one-shot Codex queries; `readSessionFileStats()` / `computeSessionFileStats()` give every provider one `readSessionStats()` over the shared aggregator, with `availability`, `costProvenance`, and `toolFailures` on `SessionFileStats`; `collectUsageEvents()` reads priced usage events from session logs with a per-session cache, `computeBillingBlocks()` groups them into five-hour billing blocks, and `bucketUsage()` turns them into day, week, month, or session rows; `applySessionSummary()` and `importSessionHistory()` let any host fold finished sessions into `historical-data.json` the way the extension does; observed sessions are read once per discovery, re-read only when their fingerprint changes, and classified from events by `classifySessionActivity()`; `readSessionReportInputs()` derives report metrics and transcript from one read; `writeStateFile()` / `readStateFile()` (also on the `statusline` subpath) maintain the public, versioned `state.json` for external tools, validated by `sidekickStateFileSchema`; `getScheduledPeakHoursState()` and `evaluateQuotaThresholds()` are shared by the CLI and extension dashboards.
 - **Host-safe APIs (0.25.0)** — `listSessionPreviewsAsync()` / `readSessionPreviewAsync()` read previews with bounded concurrency and cooperative yielding; `ObservedSessionCollector.subscribe()` and `SessionMonitor.subscribe()` replace host polling loops with debounced change batches; `createSessionProviders({ onDiagnostic })` constructs every usable provider with structured diagnostics instead of throwing; `findSessionById()` resolves one session without scanning; `exportResolvedModelCatalog()` / `importResolvedModelCatalog()` and `registerModelAlias()` transfer context/pricing resolutions across realms; `onAccountsChanged()` reports login/logout/switch events; provider constructors perform no environment I/O, and quota pollers stay dormant without an account.
 - **Native session-file helpers** — `encodeClaudeWorkspacePath()` / `getClaudeSessionDirectory()` locate Claude Code's `~/.claude/projects/` directories with the real on-disk encoding, `findCodexRolloutFile()` resolves a Codex session id to its rollout path, `readCodexHistory()` tail-reads `~/.codex/history.jsonl`, `listSessionPreviews()` / `readSessionPreview()` build a cheap stat-first recent-sessions index across providers, and `parseMcpToolName()` splits `mcp__<server>__<tool>` identifiers (browser-safe).
 - **Non-blocking account APIs & locked sync writers** — every login/switch entry point gains an async variant (`switchAccountAsync()`, `getAccountLoginStatusAsync()`, `finalizeAccountLoginAsync()`, `prepareCodexAccountAsync()`, `finalizeCodexAccountAsync()`, `switchToCodexAccountAsync()`) that keeps `codex` CLI probes off the event loop, and synchronous callers get the same cross-process store lock via `atomicWriteFileSync()` / `updateJsonStoreAtomicSync()` / `withFileLockSync()`, with progress-based timeouts and abandoned-lock reclaim.
@@ -104,7 +105,7 @@ returns the platform default that both overrides bypass.
 | **Credentials**                 | Claude Max OAuth credential reading from `~/.claude/.credentials.json`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
 | **Quota**                       | Claude Max subscription quota fetching (5-hour and 7-day windows), Codex rate-limit extraction from event streams (plus Codex reset credits via `fetchCodexResetCreditsFromApi()`, attached to quota state by `fetchCodexQuotaFromApi()`), and authoritative z.ai Coding Plan quota fetching via `resolveZaiQuota()` / `fetchZaiQuotaFromApi()` (reads z.ai's `api/monitor/usage/quota/limit` endpoint with cached-snapshot fallback). The observed-traffic z.ai estimator was removed from the package root exports in 0.23.0 and every remaining export of it is `@deprecated` — `resolveZaiQuota()` is the single supported z.ai quota API                                                                                                                                                                                                                                                                                                                                    |
 | **Provider Status**             | API health checking via status.claude.com and status.openai.com (indicator, components, incidents)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
-| **Doctor**                      | Typed cross-provider health diagnostics — `runDoctor()` checks project identity, sessions, accounts, providers, and dependencies into a `HealthReport`; `formatHealthReport()` renders it and `getSessionDiagnostics()` exposes the per-provider session probe                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| **Doctor**                      | Typed cross-provider health diagnostics — `runDoctor()` checks project identity, sessions, accounts, providers, and dependencies into a `HealthReport`; `formatHealthReport()` renders it and `getSessionDiagnostics()` retains the legacy Claude Code path probe; `runDoctor({ provider })` diagnoses the selected session provider                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
 | **Schemas**                     | Zod schemas for runtime validation of data crossing process/IPC boundaries — JSONL session events (`sessionEventSchema`, `messageUsageSchema`, `sessionMessageSchema`), assistant turns, observed-session V1 records, quota, account status, account management, quota history, and the public `state.json` contract (`sidekickStateFileSchema`) — plus `extractSessionEvents()` to unwrap `progress`-wrapped events. Account and quota APIs guarantee results valid against the same-release schemas. Also published fs-free via the [`sidekick-shared/schemas`](#supported-import-paths) subpath                                                                                                                                                                                                                                                                                                                                                                               |
 | **Extractors**                  | Pure functions for single-event processing: `extractTokenUsage()`, `extractToolCall()` (top-level `tool_use`), `extractToolCalls()` (assistant content blocks), plus Node-only session asset extraction (`gatherAssetsForCwd()`, `readClaudeAssets()`, `readCodexAssets()`) for URLs, file paths, commands, and plans                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
 | **Model Info & Pricing**        | Model family parsing (Anthropic / OpenAI / Google, including legacy `claude-3-opus-…` and `claude-3-5-sonnet-…` IDs), context-window lookup (including Fable 5 / Opus 4.8 / Opus 4.7 / Sonnet 4.7 1M and GPT-5.x variants), pricing tables with optional LiteLLM hydration, normalized non-double-counting cost (`calculateNormalizedUsageCost()`, fed by `normalizeProviderUsage()` / `extractNormalizedUsage()`), legacy cost helpers retained but deprecated (`calculateCost()`, `calculateCostWithProvenance()`), `mergeCostSources()`, display helpers (`shortModelName()`, `getModelDisplayInfo()`, `compareModelIds()`, `sortModelIds()`, `formatCost()`), and cross-realm catalog transfer — `exportResolvedModelCatalog()` / `importResolvedModelCatalog()` move resolved context windows and pricing (with provenance, prefix inheritance explicit) between Node and browser realms, and `registerModelAlias()` resolves short or host-specific names to canonical ids |
@@ -475,24 +476,25 @@ if (!peak.unavailable && peak.isPeak) {
 }
 ```
 
-### Resolve quota with one precedence
+### Resolve quota with shared source policies
 
 ```typescript
 import { resolveQuota } from 'sidekick-shared';
 
-// Fresh persisted sample (status line, session, or API; under five minutes) →
+// Default: fresh persisted sample (status line, session, or API; under five minutes) →
 // session logs (Codex rollouts) → provider API → older sample labelled by age.
 const quota = await resolveQuota({ providerId: 'claude-code' });
 console.log(quota.resolution); // 'snapshot-fresh' | 'session' | 'api' | 'snapshot-aging' | 'snapshot-stale' | 'unavailable'
 console.log(quota.source, quota.capturedSource, quota.freshness, quota.ageMs);
 
-// `--refresh` semantics: ask the API first.
+// Ask the API before any local sample: used by every one-shot Codex query
+// and by --refresh for other providers. API failures retain local fallbacks.
 await resolveQuota({ providerId: 'codex', workspacePath: process.cwd(), preferFresh: false });
 // Paint from local samples only (a poller will fetch live data next).
 await resolveQuota({ providerId: 'claude-code', allowApi: false });
 ```
 
-`resolveQuota()` is what `sidekick quota`, `quota --all`, the MCP `get_quota_status` tool, and both dashboards call, so every surface reports the same numbers and the same `resolution`. Every side effect is injectable (`readSnapshot`, `writeSnapshot`, `fetchImpl`, `getClaudeAccessToken`, the account resolvers) for tests.
+`resolveQuota()` is shared by `sidekick quota`, `quota --all`, the MCP `get_quota_status` tool, and dashboard startup. CLI and MCP Codex queries pass `preferFresh: false` to fetch live utilization and reset credits every time; dashboard schedules and default cache preferences are unchanged. After a failed live query, the newer session or persisted sample wins by `capturedAt`, with ties going to the persisted sample and missing timestamps treated as oldest. Only a selected session sample is persisted. Fallback results keep their source and age plus the API `failure` descriptor. `allowApi: false` always prevents network access, including when `preferFresh` is false. Every side effect is injectable (`readSnapshot`, `writeSnapshot`, `fetchImpl`, `getClaudeAccessToken`, the account resolvers) for tests.
 
 ### Fetch subscription quota
 
@@ -669,6 +671,26 @@ const tail = createJsonlTail({
 tail.start();
 ```
 
+`SessionWatcherCallbacks.onBatchComplete` is also available through `createWatcher()`. Save aggregation state only after a complete event batch and only when the state includes the full history (a completed replay or a compatible restored checkpoint). Live-only state is incomplete and must not replace a full-history checkpoint. JSONL positions end at complete lines; Codex readers reconstruct parser context when seeking. OpenCode's SQLite timestamp cursor does not persist row-version deduplication, so the dashboards replay OpenCode history instead of restoring a snapshot.
+
+### Search a workspace and diagnose its provider
+
+```typescript
+import { CodexProvider, searchSessions, runDoctor } from 'sidekick-shared';
+
+const provider = new CodexProvider();
+const controller = new AbortController();
+const matches = await searchSessions(provider, 'authentication', {
+  projectPath: '/path/to/project',
+  signal: controller.signal,
+  maxResults: 20,
+});
+const report = await runDoctor({ cwd: '/path/to/project', provider: 'codex' });
+console.log(matches, report.sessionProvider, report.checks);
+```
+
+`projectPath` resolves the workspace canonically and takes precedence over the legacy `projectSlug`. Cancellation is checked between session reads; it does not interrupt an in-progress synchronous provider read. `HealthReport.sessionProvider` is optional for compatibility. `getSessionDiagnostics()` remains a Claude Code path diagnostic; use `runDoctor()` for provider-aware checks.
+
 ### Poll quota with backoff
 
 ```typescript

package/dist/doctor.d.ts

@@ -1,6 +1,7 @@
 import { type ActiveAccountStatus } from './accountStatus';
 import { type ProjectIdentity } from './paths';
 import { type ProviderStatusState } from './providerStatus';
+import type { ProviderId } from './providers/types';
 import { type OpenCodeDbRuntimeStatus } from './providers/openCodeDatabase';
 export type HealthCheckStatus = 'ok' | 'warning' | 'error' | 'info';
 export interface HealthCheck {
@@ -38,10 +39,14 @@ export interface HealthReport {
         claude: ProviderStatusState;
         openai: ProviderStatusState;
     };
+    /** Legacy Claude Code path diagnostics, retained for compatibility. */
     sessions: SessionDiagnostics;
+    sessionProvider?: ProviderId;
 }
 export interface DoctorOptions {
     cwd?: string;
+    /** Session provider to diagnose; defaults to auto-detection. */
+    provider?: ProviderId | 'auto';
     deprecatedSettings?: DeprecatedSetting[];
     openCodeStatus?: OpenCodeDbRuntimeStatus;
     fetchStatuses?: () => Promise<{

package/dist/doctor.js

@@ -44,6 +44,8 @@ const paths_1 = require("./paths");
 const sessionPathResolver_1 = require("./parsers/sessionPathResolver");
 const providerStatus_1 = require("./providerStatus");
 const openCode_1 = require("./providers/openCode");
+const factory_1 = require("./providers/factory");
+const detect_1 = require("./providers/detect");
 const openCodeDatabase_1 = require("./providers/openCodeDatabase");
 /** Collects the Claude Code path-resolution detail used by both host surfaces. */
 function getSessionDiagnostics(workspacePath) {
@@ -100,15 +102,66 @@ function statusUnavailable() {
         updatedAt: new Date().toISOString(),
     };
 }
+async function checkSessionProvider(providerId, workspacePath) {
+    const { providers } = (0, factory_1.createSessionProviders)({ providerIds: [providerId] });
+    const provider = providers[0];
+    const title = `Session discovery (${provider?.displayName ?? providerId})`;
+    try {
+        if (!provider)
+            throw new Error(`${providerId} could not be initialized.`);
+        const sessions = provider.listSessionFilesAsync
+            ? await provider.listSessionFilesAsync(workspacePath)
+            : provider.findAllSessions(workspacePath);
+        if (sessions.length > 0) {
+            return {
+                id: 'session_discovery',
+                status: 'ok',
+                title,
+                message: `Found ${sessions.length} ${provider.displayName} session${sessions.length === 1 ? '' : 's'} for ${workspacePath}.`,
+            };
+        }
+        const operation = provider.getLastOperationStatus?.();
+        const runtime = provider.getRuntimeStatus?.();
+        const issue = operation && !operation.usable
+            ? operation.runtimeStatus
+            : runtime && !runtime.available
+                ? runtime
+                : undefined;
+        return {
+            id: 'session_discovery',
+            status: 'warning',
+            title,
+            message: issue?.message ?? `No ${provider.displayName} sessions found for ${workspacePath}.`,
+            repair: issue?.kind === 'sqlite_missing'
+                ? 'Install sqlite3 and ensure it is on PATH, then rerun sidekick doctor.'
+                : `Start ${provider.displayName} in this project, or inspect ${provider.getSessionDirectory(workspacePath)}.`,
+        };
+    }
+    catch (error) {
+        return {
+            id: 'session_discovery',
+            status: 'warning',
+            title,
+            message: error instanceof Error ? error.message : String(error),
+            repair: `Check ${providerId} session storage permissions and rerun sidekick doctor.`,
+        };
+    }
+    finally {
+        for (const candidate of providers)
+            candidate.dispose();
+    }
+}
 async function runDoctor(options = {}) {
     const project = (0, paths_1.resolveProjectIdentity)(options.cwd);
     const sessions = getSessionDiagnostics(project.cwd);
-    const accounts = (0, accountStatus_1.getActiveAccountStatus)();
+    const accounts = (0, accountStatus_1.getActiveAccountStatus)(undefined, { selfHeal: false });
+    const sessionProvider = options.provider && options.provider !== 'auto' ? options.provider : (0, detect_1.detectProvider)();
     let openCode = options.openCodeStatus;
     if (!openCode) {
         const database = new openCodeDatabase_1.OpenCodeDatabase((0, openCode_1.getOpenCodeDataDir)());
         database.open();
         openCode = database.getRuntimeStatus();
+        database.close();
     }
     const providerStatus = await (options.fetchStatuses ??
         (async () => {
@@ -130,20 +183,7 @@ async function runDoctor(options = {}) {
             title: 'Project identity',
             message: `Canonical slug: ${project.canonicalSlug}`,
         });
-    checks.push(sessions.discoveredSessionDir
-        ? {
-            id: 'session_discovery',
-            status: 'ok',
-            title: 'Session discovery',
-            message: `Found Claude Code sessions at ${sessions.discoveredSessionDir}.`,
-        }
-        : {
-            id: 'session_discovery',
-            status: 'warning',
-            title: 'Session discovery',
-            message: `No Claude Code session directory found for ${project.cwd}.`,
-            repair: `Start Claude Code in this project, or inspect ${sessions.expectedSessionDir}.`,
-        });
+    checks.push(await checkSessionProvider(sessionProvider, project.resolvedCwd));
     const openCodeCheck = openCode.available
         ? {
             id: 'opencode_sqlite',
@@ -167,16 +207,22 @@ async function runDoctor(options = {}) {
                     ? 'Install sqlite3 and ensure the sqlite3 executable is on PATH, then rerun sidekick doctor.'
                     : 'Make sqlite3 executable and verify the OpenCode database is readable.',
             };
+    if (sessionProvider !== 'opencode' && openCodeCheck.status === 'warning') {
+        openCodeCheck.status = 'info';
+        openCodeCheck.message += ' This does not affect the selected session provider.';
+    }
     checks.push(openCodeCheck);
     checks.push({
         id: 'accounts',
-        status: accounts.ok ? 'ok' : 'warning',
+        status: accounts.ok ? 'ok' : 'info',
         title: 'Accounts and credentials',
         message: accounts.ok
             ? `Detected ${[accounts.claude.present && 'Claude', accounts.codex.present && 'Codex'].filter(Boolean).join(' and ')} credentials.`
             : (accounts.error ?? 'No Claude or Codex credentials were detected.'),
         ...(!accounts.ok
-            ? { repair: 'Sign in with claude or codex, then rerun sidekick doctor.' }
+            ? {
+                repair: 'Sign in with claude or codex to refresh account quota. Existing sessions can be monitored without saved credentials.',
+            }
             : {}),
     });
     const unavailableProviders = Object.entries(providerStatus)
@@ -187,7 +233,11 @@ async function runDoctor(options = {}) {
         .map(([name]) => name);
     checks.push({
         id: 'provider_api',
-        status: degradedProviders.length > 0 ? 'warning' : unavailableProviders.length > 0 ? 'info' : 'ok',
+        status: degradedProviders.includes(sessionProvider === 'codex' ? 'openai' : sessionProvider === 'claude-code' ? 'claude' : '')
+            ? 'warning'
+            : degradedProviders.length > 0 || unavailableProviders.length > 0
+                ? 'info'
+                : 'ok',
         title: 'Provider API status',
         message: degradedProviders.length > 0
             ? `Provider incidents reported for: ${degradedProviders.join(', ')}.`
@@ -226,6 +276,7 @@ async function runDoctor(options = {}) {
         openCode,
         providerStatus,
         sessions,
+        sessionProvider,
     };
 }
 function formatHealthReport(report) {

package/dist/index.d.ts

@@ -97,7 +97,7 @@ export type { DebugLogEntry, DebugLogFile, DebugLogLevel } from './parsers/debug
 export { OpenCodeDatabase } from './providers/openCodeDatabase';
 export { CodexDatabase } from './providers/codexDatabase';
 export { searchSessions } from './search/sessionSearch';
-export type { SearchResult } from './search/sessionSearch';
+export type { SearchResult, SessionSearchOptions } from './search/sessionSearch';
 export { FilterEngine } from './search/advancedFilter';
 export type { FilterMode, FilterState, HighlightFormat as FilterHighlightFormat, } from './search/advancedFilter';
 export { composeContext } from './context/composer';

package/dist/modelContext.js

@@ -42,9 +42,11 @@ exports._getModelContextIds = _getModelContextIds;
 exports.resolveModelContextWindow = resolveModelContextWindow;
 exports.getModelContextWindowSize = getModelContextWindowSize;
 const modelAliases_1 = require("./modelAliases");
-/** Known model context window sizes (in tokens). */
+/** Known model context window sizes (in tokens); current models verified 2026-09-05. */
 const MODEL_CONTEXT_SIZES = {
-    // Claude — native 1M context (Fable 5, Opus 4.6+, Sonnet 4.6+)
+    // Claude — native 1M context (Fable 5+, Opus 4.6+, Sonnet 4.6+)
+    'claude-fable-5-1': 1_000_000,
+    'claude-fable-5.1': 1_000_000,
     'claude-fable-5': 1_000_000,
     'claude-opus-5': 1_000_000,
     'claude-opus-4-8': 1_000_000,
@@ -67,16 +69,19 @@ const MODEL_CONTEXT_SIZES = {
     'claude-3-haiku': 200_000,
     // OpenAI GPT-4.1 series (1M context)
     'gpt-4.1': 1_048_576,
-    // OpenAI GPT-5 series (keys sorted longest-first below; explicit entries
+    // OpenAI GPT-5/6 series (keys sorted longest-first below; explicit entries
     // for every variant so prefix matching can't misclassify a new one).
     // These are published model maxima. Codex reports a smaller *effective*
     // window per account tier via token_count; that value wins through the
     // observed-override layer.
+    'gpt-6-astra': 1_050_000,
     'gpt-5.6-sol': 1_050_000,
     'gpt-5.6-terra': 1_050_000,
     'gpt-5.6-luna': 1_050_000,
     'gpt-5.6': 1_050_000,
     'gpt-5.5': 1_050_000,
+    'gpt-5.4-mini': 400_000,
+    'gpt-5.4-nano': 400_000,
     'gpt-5.4': 1_050_000,
     'gpt-5.3-codex-spark': 128_000,
     'gpt-5.3-codex': 400_000,

package/dist/modelInfo.js

@@ -50,9 +50,10 @@ Object.defineProperty(exports, "MODEL_PROVIDER_IDS", { enumerable: true, get: fu
  * against `claude-sonnet-4.5`.
  *
  * Sources:
- *   - Anthropic: https://www.anthropic.com/pricing
- *   - OpenAI: https://openai.com/api/pricing/
- * Snapshot taken: 2026-06-09. Runtime LiteLLM hydration refreshes this.
+ *   - Anthropic: https://platform.claude.com/docs/en/about-claude/pricing
+ *   - OpenAI: https://developers.openai.com/api/docs/models
+ * Current Anthropic and GPT-5.6/6 rates verified: 2026-09-05.
+ * Runtime LiteLLM hydration refreshes this offline baseline.
  *
  * Anthropic keys appear in both dashed (`claude-opus-4-8`, the real model-ID
  * form) and dotted (`claude-opus-4.8`, the LiteLLM catalog form) spellings —
@@ -60,6 +61,19 @@ Object.defineProperty(exports, "MODEL_PROVIDER_IDS", { enumerable: true, get: fu
  */
 const PRICING_TABLE = {
     // ── Anthropic: Claude ──
+    // Fable 5.1 cache reads cost 0.025x input; Fable 5 retains its 0.1x rate.
+    'claude-fable-5-1': {
+        inputCostPerMillion: 10.0,
+        outputCostPerMillion: 50.0,
+        cacheWriteCostPerMillion: 12.5,
+        cacheReadCostPerMillion: 0.25,
+    },
+    'claude-fable-5.1': {
+        inputCostPerMillion: 10.0,
+        outputCostPerMillion: 50.0,
+        cacheWriteCostPerMillion: 12.5,
+        cacheReadCostPerMillion: 0.25,
+    },
     'claude-fable-5': {
         inputCostPerMillion: 10.0,
         outputCostPerMillion: 50.0,
@@ -84,11 +98,8 @@ const PRICING_TABLE = {
         cacheWriteCostPerMillion: 1.0,
         cacheReadCostPerMillion: 0.08,
     },
-    // Sonnet 5 carries the standard rate here. The introductory $2/$10 (through
-    // 2026-08-31) arrives via catalog hydration, which supersedes this baseline.
-    // Sonnet 5 is $2/$10, not the $3/$15 every earlier Sonnet charged, and it
-    // carries no >200K surcharge the way Sonnet 4.5 does. The catalog agrees
-    // across all eleven of its Sonnet 5 entries.
+    // Sonnet 5's $2/$10 introductory rate is now permanent. Standard pricing
+    // applies across its full 1M context window.
     'claude-sonnet-5': {
         inputCostPerMillion: 2.0,
         outputCostPerMillion: 10.0,
@@ -234,37 +245,44 @@ const PRICING_TABLE = {
         cacheWriteCostPerMillion: 0,
         cacheReadCostPerMillion: 0,
     },
-    // ── OpenAI: GPT-5 family ──
-    // Published rates, verified against the LiteLLM catalog. Runtime hydration
+    // ── OpenAI: GPT-5/6 families ──
+    // Published rates, cross-checked with the LiteLLM catalog. Runtime hydration
     // still supersedes these; they are the offline baseline.
     //
     // Every tier that ships at a rate of its own needs an entry of its own. Keys
     // are matched longest-first, so a `-mini`/`-nano`/`-pro` variant with no entry
     // silently inherits its base model's rate and reports a wrong number rather
     // than none — `gpt-5-nano` read 25x its true cost this way.
+    'gpt-6-astra': {
+        inputCostPerMillion: 10.0,
+        outputCostPerMillion: 50.0,
+        cacheWriteCostPerMillion: 12.5,
+        cacheReadCostPerMillion: 1.0,
+    },
     'gpt-5.6-sol': {
-        inputCostPerMillion: 5.0,
-        outputCostPerMillion: 30.0,
-        cacheWriteCostPerMillion: 6.25,
-        cacheReadCostPerMillion: 0.5,
+        inputCostPerMillion: 4.0,
+        outputCostPerMillion: 20.0,
+        cacheWriteCostPerMillion: 5.0,
+        cacheReadCostPerMillion: 0.4,
     },
     'gpt-5.6-terra': {
-        inputCostPerMillion: 2.5,
-        outputCostPerMillion: 15.0,
-        cacheWriteCostPerMillion: 3.13,
-        cacheReadCostPerMillion: 0.25,
+        inputCostPerMillion: 2.0,
+        outputCostPerMillion: 12.0,
+        cacheWriteCostPerMillion: 2.5,
+        cacheReadCostPerMillion: 0.2,
     },
     'gpt-5.6-luna': {
-        inputCostPerMillion: 1.0,
-        outputCostPerMillion: 6.0,
-        cacheWriteCostPerMillion: 1.25,
-        cacheReadCostPerMillion: 0.1,
+        inputCostPerMillion: 0.2,
+        outputCostPerMillion: 1.2,
+        cacheWriteCostPerMillion: 0.25,
+        cacheReadCostPerMillion: 0.02,
     },
+    // The GPT-5.6 alias routes to Sol.
     'gpt-5.6': {
-        inputCostPerMillion: 5.0,
-        outputCostPerMillion: 30.0,
-        cacheWriteCostPerMillion: 6.25,
-        cacheReadCostPerMillion: 0.5,
+        inputCostPerMillion: 4.0,
+        outputCostPerMillion: 20.0,
+        cacheWriteCostPerMillion: 5.0,
+        cacheReadCostPerMillion: 0.4,
     },
     'gpt-5.5-pro': {
         inputCostPerMillion: 30.0,
@@ -282,7 +300,7 @@ const PRICING_TABLE = {
         inputCostPerMillion: 0.75,
         outputCostPerMillion: 4.5,
         cacheWriteCostPerMillion: 0,
-        cacheReadCostPerMillion: 0.07,
+        cacheReadCostPerMillion: 0.075,
     },
     'gpt-5.4-nano': {
         inputCostPerMillion: 0.2,

package/dist/providers/claudeCode.js

@@ -136,6 +136,8 @@ class ClaudeCodeReader {
     sessionPath;
     parser;
     filePosition = 0;
+    /** Cursor after the last complete line, safe to persist across restarts. */
+    committedPosition = 0;
     events = [];
     _wasTruncated = false;
     decoder = new string_decoder_1.StringDecoder('utf8');
@@ -165,6 +167,7 @@ class ClaudeCodeReader {
             if (currentSize < this.filePosition) {
                 this._wasTruncated = true;
                 this.filePosition = 0;
+                this.committedPosition = 0;
                 this.parser.reset();
                 this.decoder = new string_decoder_1.StringDecoder('utf8');
             }
@@ -183,7 +186,11 @@ class ClaudeCodeReader {
             finally {
                 fs.closeSync(fd);
             }
-            const chunk = this.decoder.write(buffer.subarray(0, bytesRead));
+            const bytes = buffer.subarray(0, bytesRead);
+            const newline = bytes.lastIndexOf(0x0a);
+            if (newline >= 0)
+                this.committedPosition = this.filePosition + newline + 1;
+            const chunk = this.decoder.write(bytes);
             this.parser.processChunk(chunk);
             this.filePosition += bytesRead;
         }
@@ -198,6 +205,7 @@ class ClaudeCodeReader {
     }
     reset() {
         this.filePosition = 0;
+        this.committedPosition = 0;
         this.parser.reset();
         this.decoder = new string_decoder_1.StringDecoder('utf8');
         this._wasTruncated = false;
@@ -213,10 +221,11 @@ class ClaudeCodeReader {
         this.decoder = new string_decoder_1.StringDecoder('utf8');
     }
     getPosition() {
-        return this.filePosition;
+        return this.committedPosition;
     }
     seekTo(position) {
         this.filePosition = position;
+        this.committedPosition = position;
         this.parser.reset();
         this.decoder = new string_decoder_1.StringDecoder('utf8');
     }

package/dist/providers/codex.js

@@ -473,6 +473,8 @@ class CodexReader {
     onTokenUsage;
     parser;
     filePosition = 0;
+    /** Cursor after the last complete line, safe to persist across restarts. */
+    committedPosition = 0;
     lineBuffer = '';
     _wasTruncated = false;
     decoder = new string_decoder_1.StringDecoder('utf8');
@@ -487,18 +489,19 @@ class CodexReader {
     getSessionMeta() {
         return this.parser.getSessionMeta();
     }
-    readNew() {
+    readNew(endPosition) {
         this._wasTruncated = false;
         const events = [];
         try {
             if (!fs.existsSync(this.rolloutPath))
                 return [];
             const stats = fs.statSync(this.rolloutPath);
-            const currentSize = stats.size;
+            const currentSize = Math.min(stats.size, endPosition ?? stats.size);
             // Handle truncation
             if (currentSize < this.filePosition) {
                 this._wasTruncated = true;
                 this.filePosition = 0;
+                this.committedPosition = 0;
                 this.lineBuffer = '';
                 this.parser.reset();
                 this.decoder = new string_decoder_1.StringDecoder('utf8');
@@ -517,7 +520,11 @@ class CodexReader {
             finally {
                 fs.closeSync(fd);
             }
-            const chunk = this.decoder.write(buffer.subarray(0, bytesRead));
+            const bytes = buffer.subarray(0, bytesRead);
+            const newline = bytes.lastIndexOf(0x0a);
+            if (newline >= 0)
+                this.committedPosition = this.filePosition + newline + 1;
+            const chunk = this.decoder.write(bytes);
             this.filePosition += bytesRead;
             // Process lines
             const text = this.lineBuffer + chunk;
@@ -583,6 +590,7 @@ class CodexReader {
     }
     reset() {
         this.filePosition = 0;
+        this.committedPosition = 0;
         this.lineBuffer = '';
         this.parser.reset();
         this.decoder = new string_decoder_1.StringDecoder('utf8');
@@ -606,12 +614,14 @@ class CodexReader {
         this.decoder = new string_decoder_1.StringDecoder('utf8');
     }
     getPosition() {
-        return this.filePosition;
+        return this.committedPosition;
     }
     seekTo(position) {
-        this.filePosition = position;
-        this.lineBuffer = '';
-        this.decoder = new string_decoder_1.StringDecoder('utf8');
+        // Rebuild model, turn, and cumulative-token context before resuming.
+        // The prefix is parsed only; its events are already in the consumer snapshot.
+        this.reset();
+        if (position > 0)
+            this.readNew(position);
     }
     wasTruncated() {
         return this._wasTruncated;

package/dist/quotaPresentation.js

@@ -23,8 +23,20 @@ function formatRetryAfter(ms) {
 function describeQuotaFailure(quota) {
     if (!quota || quota.available || !quota.failureKind)
         return null;
+    const isCodex = quota.providerId === 'codex';
+    const apiName = isCodex ? 'Codex' : 'Anthropic';
     switch (quota.failureKind) {
         case 'auth':
+            if (isCodex) {
+                return {
+                    severity: 'error',
+                    title: quota.httpStatus ? 'Codex sign-in expired' : 'Codex sign-in required',
+                    message: quota.error ?? 'The current Codex login could not be used.',
+                    detail: 'Run `codex login` to sign in, then retry quota refresh.',
+                    alertKey: `auth:${quota.httpStatus ?? 'no-credentials'}`,
+                    isRetryable: false,
+                };
+            }
             if (quota.error === 'No OAuth token available') {
                 return {
                     severity: 'error',
@@ -47,7 +59,7 @@ function describeQuotaFailure(quota) {
             return {
                 severity: 'warning',
                 title: 'Quota API unreachable',
-                message: 'Could not reach Anthropic from the current environment.',
+                message: `Could not reach ${apiName} from the current environment.`,
                 detail: 'Check connectivity, proxy, or firewall settings, then retry.',
                 alertKey: 'network',
                 isRetryable: true,
@@ -59,7 +71,7 @@ function describeQuotaFailure(quota) {
                 message: quota.retryAfterMs != null
                     ? `Retry in ${formatRetryAfter(quota.retryAfterMs)}.`
                     : 'Retry shortly.',
-                detail: quota.httpStatus != null ? `Anthropic returned HTTP ${quota.httpStatus}.` : undefined,
+                detail: quota.httpStatus != null ? `${apiName} returned HTTP ${quota.httpStatus}.` : undefined,
                 alertKey: `rate_limit:${quota.httpStatus ?? 429}`,
                 isRetryable: true,
             };
@@ -68,8 +80,8 @@ function describeQuotaFailure(quota) {
                 severity: 'warning',
                 title: 'Quota API unavailable',
                 message: quota.httpStatus != null
-                    ? `Anthropic returned HTTP ${quota.httpStatus}. Try again shortly.`
-                    : 'Anthropic quota data is temporarily unavailable.',
+                    ? `${apiName} returned HTTP ${quota.httpStatus}. Try again shortly.`
+                    : `${apiName} quota data is temporarily unavailable.`,
                 alertKey: `server:${quota.httpStatus ?? 'unknown'}`,
                 isRetryable: true,
             };
@@ -78,7 +90,7 @@ function describeQuotaFailure(quota) {
                 severity: 'error',
                 title: 'Unexpected quota response',
                 message: quota.httpStatus != null
-                    ? `Anthropic returned HTTP ${quota.httpStatus}.`
+                    ? `${apiName} returned HTTP ${quota.httpStatus}.`
                     : (quota.error ?? 'Quota data could not be retrieved.'),
                 detail: 'This failure is not classified as retryable.',
                 alertKey: `unknown:${quota.httpStatus ?? 'none'}`,