sidekick-shared 0.23.0 → 0.23.1

package/README.md

@@ -110,13 +110,23 @@ await hydratePricingCatalog({ cacheDir: '~/.config/sidekick' });
 ### Detect the active session provider
 
 ```typescript
-import { detectProvider } from 'sidekick-shared';
-
-const provider = await detectProvider('/path/to/project');
-if (provider) {
-  console.log(`Active provider: ${provider.id}`);
-  const sessions = await provider.listSessions();
-}
+import {
+  detectProvider,
+  ClaudeCodeProvider,
+  OpenCodeProvider,
+  CodexProvider,
+} from 'sidekick-shared';
+
+const providerId = detectProvider(); // 'claude-code' | 'opencode' | 'codex'
+const provider =
+  providerId === 'opencode'
+    ? new OpenCodeProvider()
+    : providerId === 'codex'
+      ? new CodexProvider()
+      : new ClaudeCodeProvider();
+
+console.log(`Active provider: ${provider.displayName}`);
+const sessions = provider.findAllSessions('/path/to/project');
 ```
 
 ### Read persisted tasks
@@ -237,17 +247,15 @@ The extractor is safe for CLI and VS Code extension-host code, but not for brows
 Build a provider-neutral snapshot of what an assistant has "seen" in a session — layered evidence sources, context pressure, and observed capabilities. Read it through any session provider, or build it directly from a canonical `SessionEvent[]`.
 
 ```typescript
-import { detectProvider, readSessionContextSnapshot } from 'sidekick-shared';
+import { ClaudeCodeProvider, readSessionContextSnapshot } from 'sidekick-shared';
 
-const provider = await detectProvider('/path/to/project');
-if (provider) {
-  const snapshot = readSessionContextSnapshot(provider, '/path/to/session.jsonl');
+const provider = new ClaudeCodeProvider();
+const snapshot = readSessionContextSnapshot(provider, '/path/to/session.jsonl');
 
-  console.log(snapshot.pressure); // 'low' | 'medium' | 'high'
-  console.log(snapshot.contextTokens, '/', snapshot.contextWindow);
-  console.log(snapshot.capabilities.tools, snapshot.capabilities.mcpServers);
-  console.log(snapshot.sources.length, 'evidence sources');
-}
+console.log(snapshot.pressure); // 'low' | 'medium' | 'high'
+console.log(snapshot.contextTokens, '/', snapshot.contextWindow);
+console.log(snapshot.capabilities.tools, snapshot.capabilities.mcpServers);
+console.log(snapshot.sources.length, 'evidence sources');
 ```
 
 Use `createSessionContextProjector()` for incremental updates as new events stream in, or `calculateSessionContextPressure(contextTokens, contextWindow)` for the pressure band alone.
@@ -403,10 +411,6 @@ const totalSource = mergeCostSources(a.source, b.source); // 'unpriced' wins (le
 console.log(formatCost(total), totalSource);
 ```
 
-### Deferred Contextful adoption note
-
-`sidekick-shared@0.18.x` already exposes the quota primitives Contextful needs: `MultiProviderQuotaService`, `ProviderQuotaMap`, `ProviderQuotaState`, and `CodexQuotaWatcher`. Contextful should keep its local integration unchanged until a newer `sidekick-shared` release is published to npm, then migrate thin wrappers to these public APIs plus `formatTokenCount()`, `formatDurationMs()`, and `createJsonlTail()`.
-
 ## Building
 
 ```bash

package/dist/accountManager.js

@@ -281,6 +281,7 @@ async function spawnAccountLogin(provider, label, opts = {}) {
     }
     let childExited = false;
     let childExitCode = null;
+    const childState = {};
     const timeoutMs = opts.timeoutMs ?? 180_000;
     const deadline = Date.now() + timeoutMs;
     let child;
@@ -297,6 +298,10 @@ async function spawnAccountLogin(provider, label, opts = {}) {
         childExited = true;
         childExitCode = code;
     });
+    child.on('error', (error) => {
+        childExited = true;
+        childState.spawnError = error;
+    });
     while (true) {
         if (opts.signal?.aborted) {
             child.kill();
@@ -308,6 +313,11 @@ async function spawnAccountLogin(provider, label, opts = {}) {
             return finalizeAccountLogin(provider, begin.loginId, { activate: opts.activate ?? true });
         }
         if (childExited) {
+            if (childState.spawnError) {
+                const error = `Could not spawn account login: ${childState.spawnError.message}`;
+                emitStatus(opts, { state: 'failed', error });
+                return { success: false, error };
+            }
             const finalStatus = emitStatus(opts, getAccountLoginStatus(provider, begin.loginId));
             if (finalStatus.state === 'authenticated') {
                 return finalizeAccountLogin(provider, begin.loginId, { activate: opts.activate ?? true });

package/dist/aggregation/EventAggregator.d.ts

@@ -13,6 +13,8 @@ import type { EventAggregatorOptions, AggregatedTokens, ModelUsageStats, BurnRat
 import type { SerializedFrequencyState } from './FrequencyTracker';
 import type { SerializedHeatmapState } from './HeatmapTracker';
 import type { SerializedPatternState } from './PatternExtractor';
+/** Schema version for serialized snapshots. */
+export declare const SNAPSHOT_SCHEMA_VERSION = 3;
 /**
  * JSON-serializable snapshot of EventAggregator state.
  * Used by session snapshot sidecar files for fast resume.
@@ -127,6 +129,7 @@ export declare class EventAggregator {
     private currentPermissionMode;
     private permissionModeHistory;
     private contextTimeline;
+    private readonly contextTimelineCap;
     private contextTurnIndex;
     private timeline;
     private pendingUserRequest;
@@ -166,7 +169,7 @@ export declare class EventAggregator {
     /** Serializes all mutable state to a JSON-safe object for snapshot persistence. */
     serialize(): SerializedAggregatorState;
     /** Restores mutable state from a serialized snapshot. Clears transient state (pending calls). */
-    restore(state: SerializedAggregatorState): void;
+    restore(state: SerializedAggregatorState): boolean;
     private accumulateUsage;
     private updateBurnRate;
     private processLatency;

package/dist/aggregation/EventAggregator.js

@@ -9,7 +9,7 @@
  * @module aggregation/EventAggregator
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventAggregator = void 0;
+exports.EventAggregator = exports.SNAPSHOT_SCHEMA_VERSION = void 0;
 exports.parseTodoDependencies = parseTodoDependencies;
 const jsonl_1 = require("../parsers/jsonl");
 const planExtractor_1 = require("../parsers/planExtractor");
@@ -24,11 +24,12 @@ const errorTaxonomy_1 = require("../extractors/errorTaxonomy");
 // ── Defaults ──
 const DEFAULT_TIMELINE_CAP = 200;
 const DEFAULT_LATENCY_CAP = 100;
+const DEFAULT_CONTEXT_TIMELINE_CAP = 2_000;
 const DEFAULT_BURN_WINDOW_MS = 5 * 60_000;
 const DEFAULT_BURN_SAMPLE_MS = 10_000;
 const COMPACTION_DROP_THRESHOLD = 0.8; // >20% drop
 /** Schema version for serialized snapshots. */
-const SNAPSHOT_SCHEMA_VERSION = 3;
+exports.SNAPSHOT_SCHEMA_VERSION = 3;
 // ── Goal gate detection regex ──
 const GOAL_GATE_REGEX = /\b(CRITICAL|MUST|blocker|required|must.?complete|goal.?gate|essential|do.?not.?skip|blocking)\b/i;
 // ── Todo dependency parsing ──
@@ -127,6 +128,7 @@ class EventAggregator {
     permissionModeHistory = [];
     // Context timeline
     contextTimeline = [];
+    contextTimelineCap;
     contextTurnIndex = 0;
     // Timeline
     timeline = [];
@@ -150,6 +152,7 @@ class EventAggregator {
         this.latencyCap = options?.latencyCap ?? DEFAULT_LATENCY_CAP;
         this.burnWindowMs = options?.burnWindowMs ?? DEFAULT_BURN_WINDOW_MS;
         this.burnSampleMs = options?.burnSampleMs ?? DEFAULT_BURN_SAMPLE_MS;
+        this.contextTimelineCap = options?.contextTimelineCap ?? DEFAULT_CONTEXT_TIMELINE_CAP;
         this.computeContextSize = options?.computeContextSize ?? null;
         this.providerId = options?.providerId ?? null;
         this._providerId = this.providerId;
@@ -167,6 +170,10 @@ class EventAggregator {
         this.lastEventTime = event.timestamp;
         // Guard: some event types (e.g. 'summary') have no message field in the raw JSONL
         if (!event.message) {
+            if (event.type === 'summary') {
+                this.recordExplicitCompaction(event.timestamp, event.compaction);
+                this.addTimelineFromSessionEvent(event);
+            }
             return;
         }
         // 2. Track model
@@ -300,7 +307,7 @@ class EventAggregator {
                     priced: true,
                 };
                 acc.calls++;
-                acc.tokens += inputTok + outputTok;
+                acc.tokens += inputTok + outputTok + cacheWrite + cacheRead;
                 acc.inputTokens += inputTok;
                 acc.outputTokens += outputTok;
                 acc.cacheWriteTokens += cacheWrite;
@@ -346,7 +353,7 @@ class EventAggregator {
         // 12. Gonzo/Lazyjournal analytics
         this.feedAnalytics(event.timestamp, event.summary, event.toolName);
         // Message count (skip system events)
-        if (event.type !== 'system') {
+        if (event.type === 'user' || event.type === 'assistant') {
             this.messageCount++;
         }
     }
@@ -543,7 +550,7 @@ class EventAggregator {
     /** Serializes all mutable state to a JSON-safe object for snapshot persistence. */
     serialize() {
         return {
-            version: SNAPSHOT_SCHEMA_VERSION,
+            version: exports.SNAPSHOT_SCHEMA_VERSION,
             tokens: {
                 input: this.inputTokens,
                 output: this.outputTokens,
@@ -587,8 +594,8 @@ class EventAggregator {
     }
     /** Restores mutable state from a serialized snapshot. Clears transient state (pending calls). */
     restore(state) {
-        if (state.version !== SNAPSHOT_SCHEMA_VERSION) {
-            return; // Incompatible snapshot — caller should fall back to full replay
+        if (state.version !== exports.SNAPSHOT_SCHEMA_VERSION) {
+            return false;
         }
         this.inputTokens = state.tokens.input;
         this.outputTokens = state.tokens.output;
@@ -617,7 +624,9 @@ class EventAggregator {
         this.permissionModeHistory = state.permissionModeHistory
             ? [...state.permissionModeHistory]
             : [];
-        this.contextTimeline = state.contextTimeline ? [...state.contextTimeline] : [];
+        this.contextTimeline = state.contextTimeline
+            ? state.contextTimeline.slice(-this.contextTimelineCap)
+            : [];
         this.contextTurnIndex = state.contextTurnIndex ?? 0;
         this.timeline = [...state.timeline];
         this.messageCount = state.messageCount;
@@ -640,6 +649,7 @@ class EventAggregator {
         this.pendingSubagents.clear();
         this.pendingUserRequest = null;
         this.planExtractor.reset();
+        return true;
     }
     // ═══════════════════════════════════════════════════════════════════════
     // Private: Token & Context
@@ -716,6 +726,9 @@ class EventAggregator {
             inputTokens: contextSize,
             turnIndex: this.contextTurnIndex++,
         });
+        if (this.contextTimeline.length > this.contextTimelineCap) {
+            this.contextTimeline.splice(0, this.contextTimeline.length - this.contextTimelineCap);
+        }
         // Per-model usage. Accumulate reasoning tokens and an inverted-sticky
         // `priced` flag so one unpriced event taints the aggregate (UI renders "—").
         const perModelKey = model ?? this.currentModel ?? 'unknown';
@@ -731,7 +744,7 @@ class EventAggregator {
             priced: true,
         };
         acc.calls++;
-        acc.tokens += inputTok + outputTok;
+        acc.tokens += inputTok + outputTok + cacheWrite + cacheRead;
         acc.inputTokens += inputTok;
         acc.outputTokens += outputTok;
         acc.cacheWriteTokens += cacheWrite;

package/dist/aggregation/snapshot.d.ts

@@ -7,7 +7,7 @@
  *
  * @module aggregation/snapshot
  */
-import type { SerializedAggregatorState } from './EventAggregator';
+import { type SerializedAggregatorState } from './EventAggregator';
 /** Snapshot sidecar file content. */
 export interface SessionSnapshot {
     /** Schema version for forward-compatibility checks. */

package/dist/aggregation/snapshot.js

@@ -50,8 +50,9 @@ exports.isSnapshotValid = isSnapshotValid;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const paths_1 = require("../paths");
+const EventAggregator_1 = require("./EventAggregator");
 /** Current schema version — bump when format changes. */
-const SNAPSHOT_VERSION = 3;
+const SNAPSHOT_VERSION = EventAggregator_1.SNAPSHOT_SCHEMA_VERSION;
 /** Returns the directory for snapshot files. */
 function getSnapshotsDir() {
     return path.join((0, paths_1.getConfigDir)(), 'snapshots');

package/dist/aggregation/types.d.ts

@@ -31,6 +31,8 @@ export interface EventAggregatorOptions {
     timelineCap?: number;
     /** Maximum latency records to retain (default 100). */
     latencyCap?: number;
+    /** Maximum context-size points to retain (default 2000). */
+    contextTimelineCap?: number;
     /** Burn rate sliding window in ms (default 5 * 60_000). */
     burnWindowMs?: number;
     /** Burn rate sample interval in ms (default 10_000). */

package/dist/autoSwitch.d.ts

@@ -42,7 +42,7 @@ export interface AutoSwitchControllerOptions {
     cooldownMs?: number;
     now?: () => number;
 }
-export declare function decideAutoSwitch(_provider: AccountProviderId, active: AutoSwitchActiveAccount, candidates: AutoSwitchCandidate[], config?: AutoSwitchConfig): AutoSwitchDecision | null;
+export declare function decideAutoSwitch(_provider: AccountProviderId, active: AutoSwitchActiveAccount, candidates: AutoSwitchCandidate[], config?: AutoSwitchConfig, nowMs?: number): AutoSwitchDecision | null;
 export declare class AutoSwitchController implements Disposable {
     private readonly quotaService;
     private readonly getClaudeAccounts;

package/dist/autoSwitch.js

@@ -11,6 +11,7 @@ exports.DEFAULT_AUTO_SWITCH_CONFIG = {
     thresholdPct: 90,
 };
 const MATERIAL_REMAINING_IMPROVEMENT_PCT = 5;
+const MAX_STALE_SNAPSHOT_AGE_MS = 5 * 60 * 60 * 1000;
 function mergedConfig(config) {
     return {
         ...exports.DEFAULT_AUTO_SWITCH_CONFIG,
@@ -27,7 +28,17 @@ function quotaRemaining(quota) {
         return 0;
     return Math.max(0, 100 - quotaUtilization(quota));
 }
-function decideAutoSwitch(_provider, active, candidates, config) {
+function isUsableCandidateQuota(quota, nowMs) {
+    if (!quota?.available)
+        return false;
+    if (quota.stale !== true)
+        return true;
+    const capturedAt = Date.parse(quota.capturedAt ?? '');
+    if (!Number.isFinite(capturedAt) || capturedAt > nowMs)
+        return false;
+    return nowMs - capturedAt <= MAX_STALE_SNAPSHOT_AGE_MS;
+}
+function decideAutoSwitch(_provider, active, candidates, config, nowMs = Date.now()) {
     const cfg = mergedConfig(config);
     if (!cfg.enabled)
         return null;
@@ -40,7 +51,7 @@ function decideAutoSwitch(_provider, active, candidates, config) {
     const best = candidates
         .filter((candidate) => candidate.accountId !== active.accountId &&
         candidate.switchable !== false &&
-        candidate.quota?.available)
+        isUsableCandidateQuota(candidate.quota, nowMs))
         .sort((a, b) => quotaRemaining(b.quota) - quotaRemaining(a.quota))[0];
     if (!best)
         return null;
@@ -129,7 +140,7 @@ class AutoSwitchController {
                 quota: accountId === activeAccountId ? activeQuota : this.readSnapshot(providerId, accountId),
             };
         });
-        const decision = decideAutoSwitch(providerId, { accountId: activeAccountId, quota: activeQuota }, candidates, this.config);
+        const decision = decideAutoSwitch(providerId, { accountId: activeAccountId, quota: activeQuota }, candidates, this.config, this.now());
         if (!decision)
             return;
         if (this.switchedDuringCrossing.has(providerId))

package/dist/codexQuota.d.ts

@@ -32,6 +32,8 @@ export interface CodexQuotaApiOptions {
     usageUrl?: string;
     resetCreditsUrl?: string;
     capturedAt?: string;
+    signal?: AbortSignal;
+    timeoutMs?: number;
 }
 export declare function quotaFromCodexRateLimits(rateLimits: CodexRateLimits | null | undefined, source?: 'api' | 'session' | 'cache', capturedAt?: string): QuotaState | null;
 export declare function readLatestCodexQuotaFromRollouts(sessionPaths: string[], options?: {

package/dist/codexQuota.js

@@ -414,10 +414,19 @@ async function fetchCodexQuotaFromApi(options = {}) {
             sevenDayLabel: 'Secondary',
         };
     }
+    const controller = new AbortController();
+    const onAbort = () => controller.abort();
+    if (options.signal?.aborted)
+        controller.abort();
+    else
+        options.signal?.addEventListener('abort', onAbort, { once: true });
+    const timeout = setTimeout(() => controller.abort(), options.timeoutMs ?? 10_000);
+    timeout.unref();
     try {
         const fetchImpl = options.fetchImpl ?? fetch;
         const response = await fetchImpl(options.usageUrl ?? CHATGPT_USAGE_URL, {
             method: 'GET',
+            signal: controller.signal,
             headers: {
                 Authorization: `Bearer ${accessToken}`,
                 Accept: 'application/json',
@@ -468,6 +477,7 @@ async function fetchCodexQuotaFromApi(options = {}) {
             accessToken,
             accountId: auth?.accountId,
             capturedAt,
+            signal: controller.signal,
         });
         if (resetCredits) {
             quota.resetCredits = resetCredits;
@@ -488,6 +498,10 @@ async function fetchCodexQuotaFromApi(options = {}) {
             sevenDayLabel: 'Secondary',
         };
     }
+    finally {
+        clearTimeout(timeout);
+        options.signal?.removeEventListener('abort', onAbort);
+    }
 }
 async function fetchCodexResetCreditsFromApi(options = {}) {
     const capturedAt = options.capturedAt ?? new Date().toISOString();
@@ -497,6 +511,14 @@ async function fetchCodexResetCreditsFromApi(options = {}) {
     const accessToken = auth?.accessToken;
     if (!accessToken)
         return undefined;
+    const controller = new AbortController();
+    const onAbort = () => controller.abort();
+    if (options.signal?.aborted)
+        controller.abort();
+    else
+        options.signal?.addEventListener('abort', onAbort, { once: true });
+    const timeout = setTimeout(() => controller.abort(), options.timeoutMs ?? 10_000);
+    timeout.unref();
     try {
         const fetchImpl = options.fetchImpl ?? fetch;
         const headers = {
@@ -511,6 +533,7 @@ async function fetchCodexResetCreditsFromApi(options = {}) {
         const response = await fetchImpl(options.resetCreditsUrl ?? CHATGPT_RESET_CREDITS_URL, {
             method: 'GET',
             headers,
+            signal: controller.signal,
         });
         if (!response.ok)
             return undefined;
@@ -519,6 +542,10 @@ async function fetchCodexResetCreditsFromApi(options = {}) {
     catch {
         return undefined;
     }
+    finally {
+        clearTimeout(timeout);
+        options.signal?.removeEventListener('abort', onAbort);
+    }
 }
 function readCodexAuth(codexHome) {
     try {

package/dist/codexQuotaWatcher.d.ts

@@ -15,6 +15,9 @@ export interface CodexQuotaWatcherOptions {
     discoveryPollIntervalMs?: number;
     maxTailBytes?: number;
     maxSessionFiles?: number;
+    /** Minimum interval between expensive rollout-tail fallback scans. */
+    localScanCacheMs?: number;
+    now?: () => number;
     providerFactory?: () => CodexProvider;
     getActiveAccount?: CodexAccountReader;
     readSnapshot?: SnapshotReader;
@@ -39,6 +42,8 @@ export declare class CodexQuotaWatcher implements Disposable {
     private readonly watchFile;
     private readonly maxTailBytes;
     private readonly maxSessionFiles;
+    private readonly localScanCacheMs;
+    private readonly now;
     private readonly workspaceId;
     private readonly appendHistorySample;
     private readonly listeners;
@@ -48,6 +53,8 @@ export declare class CodexQuotaWatcher implements Disposable {
     private fileWatcher;
     private sessionPath;
     private lastEmissionKey;
+    private lastLocalScanAt;
+    private lastLocalScanState;
     private running;
     constructor(workspacePath: string, options?: CodexQuotaWatcherOptions);
     start(): void;

package/dist/codexQuotaWatcher.js

@@ -41,6 +41,7 @@ const quotaSnapshots_1 = require("./quotaSnapshots");
 const quotaHistory_1 = require("./quotaHistory");
 const codex_1 = require("./providers/codex");
 const DEFAULT_DISCOVERY_POLL_INTERVAL_MS = 30_000;
+const DEFAULT_LOCAL_SCAN_CACHE_MS = 5 * 60_000;
 function accountEmail(account) {
     return account?.email ?? account?.metadata?.email;
 }
@@ -81,6 +82,8 @@ class CodexQuotaWatcher {
     watchFile;
     maxTailBytes;
     maxSessionFiles;
+    localScanCacheMs;
+    now;
     workspaceId;
     appendHistorySample;
     listeners = [];
@@ -90,6 +93,8 @@ class CodexQuotaWatcher {
     fileWatcher = null;
     sessionPath = null;
     lastEmissionKey = null;
+    lastLocalScanAt = Number.NEGATIVE_INFINITY;
+    lastLocalScanState = null;
     running = false;
     constructor(workspacePath, options = {}) {
         this.workspacePath = workspacePath;
@@ -110,6 +115,8 @@ class CodexQuotaWatcher {
         this.watchFile = options.watchFile ?? fs.watch;
         this.maxTailBytes = options.maxTailBytes;
         this.maxSessionFiles = options.maxSessionFiles;
+        this.localScanCacheMs = options.localScanCacheMs ?? DEFAULT_LOCAL_SCAN_CACHE_MS;
+        this.now = options.now ?? Date.now;
         this.workspaceId = options.workspaceId;
         this.appendHistorySample = options.appendHistorySample ?? quotaHistory_1.appendQuotaHistorySample;
     }
@@ -255,28 +262,39 @@ class CodexQuotaWatcher {
     }
     emitCachedOrUnavailable() {
         const account = this.getActiveAccount();
-        let localProvider = null;
-        try {
-            localProvider = this.providerFactory();
-            const local = (0, codexQuota_1.resolveCodexQuotaFromLocalSources)({
-                workspacePath: this.workspacePath,
-                activeAccount: account,
-                readSnapshot: this.readSnapshot,
-                writeSnapshot: this.writeSnapshot,
-                provider: localProvider,
-                maxTailBytes: this.maxTailBytes,
-                maxSessionFiles: this.maxSessionFiles,
-            });
-            if (local) {
-                this.emitState(local);
+        const scanNow = this.now();
+        if (scanNow - this.lastLocalScanAt < this.localScanCacheMs) {
+            if (this.lastLocalScanState) {
+                this.emitState(this.lastLocalScanState);
                 return;
             }
         }
-        catch {
-            // Fall through to account-scoped cache or unavailable state.
-        }
-        finally {
-            localProvider?.dispose();
+        else {
+            let localProvider = null;
+            this.lastLocalScanAt = scanNow;
+            this.lastLocalScanState = null;
+            try {
+                localProvider = this.providerFactory();
+                this.lastLocalScanState = (0, codexQuota_1.resolveCodexQuotaFromLocalSources)({
+                    workspacePath: this.workspacePath,
+                    activeAccount: account,
+                    readSnapshot: this.readSnapshot,
+                    writeSnapshot: this.writeSnapshot,
+                    provider: localProvider,
+                    maxTailBytes: this.maxTailBytes,
+                    maxSessionFiles: this.maxSessionFiles,
+                });
+                if (this.lastLocalScanState) {
+                    this.emitState(this.lastLocalScanState);
+                    return;
+                }
+            }
+            catch {
+                // Fall through to account-scoped cache or unavailable state.
+            }
+            finally {
+                localProvider?.dispose();
+            }
         }
         const cached = account ? this.readSnapshot('codex', account.id) : null;
         if (cached) {

package/dist/context/sessionContext.js

@@ -57,6 +57,10 @@ function buildSessionContextSnapshot(events, options = {}) {
         if (event.rateLimits)
             lastRateLimits = event.rateLimits;
     }
+    return assembleSessionContextSnapshot(aggregator, sourceState, lastPermissionMode, lastRateLimits, options);
+}
+function assembleSessionContextSnapshot(aggregator, sourceState, lastPermissionMode, lastRateLimits, options) {
+    const providerId = options.providerId;
     const metrics = aggregator.getMetrics();
     const model = options.model ?? metrics.currentModel ?? metrics.modelStats[0]?.model;
     const contextWindow = options.contextWindow ??
@@ -100,24 +104,46 @@ function buildSessionContextSnapshot(events, options = {}) {
     };
 }
 function createSessionContextProjector(options = {}) {
-    let events = [];
+    let aggregator = createProjectorAggregator(options);
+    let sourceState = createSourceExtractionState(options);
+    let lastPermissionMode;
+    let lastRateLimits;
+    const process = (event) => {
+        aggregator.processEvent(event);
+        extractSourcesFromEvent(event, sourceState);
+        if (event.permissionMode)
+            lastPermissionMode = event.permissionMode;
+        if (event.rateLimits)
+            lastRateLimits = event.rateLimits;
+    };
+    const snapshot = () => assembleSessionContextSnapshot(aggregator, sourceState, lastPermissionMode, lastRateLimits, options);
     return {
         processEvent(event) {
-            events.push(event);
-            return buildSessionContextSnapshot(events, options);
+            process(event);
+            return snapshot();
         },
         processEvents(newEvents) {
-            events.push(...newEvents);
-            return buildSessionContextSnapshot(events, options);
+            for (const event of newEvents)
+                process(event);
+            return snapshot();
         },
         getSnapshot() {
-            return buildSessionContextSnapshot(events, options);
+            return snapshot();
         },
         reset() {
-            events = [];
+            aggregator = createProjectorAggregator(options);
+            sourceState = createSourceExtractionState(options);
+            lastPermissionMode = undefined;
+            lastRateLimits = undefined;
         },
     };
 }
+function createProjectorAggregator(options) {
+    return new EventAggregator_1.EventAggregator({
+        providerId: options.providerId,
+        computeContextSize: options.computeContextSize,
+    });
+}
 function readSessionContextSnapshot(provider, sessionPath, options = {}) {
     const reader = provider.createReader(sessionPath);
     const events = reader.readAll();
@@ -177,7 +203,7 @@ function extractSourcesFromEvent(event, state) {
                 layer: 'summary',
                 sourceType: 'summary',
                 title: 'Context summary',
-                text: extractText(event.message.content) || 'Context compacted',
+                text: extractText(event.message?.content) || 'Context compacted',
             });
             break;
     }
@@ -394,7 +420,7 @@ function limitSources(sources, limit) {
 }
 function latestModel(events) {
     for (let i = events.length - 1; i >= 0; i--) {
-        const model = events[i].message.model;
+        const model = events[i].message?.model;
         if (model)
             return model;
     }

package/dist/credentialIO.js

@@ -52,6 +52,12 @@ const os = __importStar(require("os"));
 const child_process_1 = require("child_process");
 const claudeProfiles_1 = require("./claudeProfiles");
 exports.KEYCHAIN_SERVICE = 'Claude Code-credentials';
+function quoteSecurityInteractiveArg(value) {
+    // `security -i` is not a POSIX shell: adjacent quoted segments do NOT
+    // concatenate (so the shell-style '\'' splice splits the token), and
+    // backslash escapes the next character even inside single quotes.
+    return `'${value.replace(/\\/g, '\\\\').replace(/'/g, `\\'`)}'`;
+}
 function getCredentialsFilePath(configDir) {
     return path.join(configDir ?? path.join(os.homedir(), '.claude'), '.credentials.json');
 }
@@ -93,16 +99,24 @@ function writeActiveCredentials(credentials, configDir) {
     const json = JSON.stringify(credentials);
     JSON.parse(json); // validate round-trip
     if (process.platform === 'darwin') {
-        (0, child_process_1.execFileSync)('security', [
+        const service = (0, claudeProfiles_1.claudeKeychainService)(configDir);
+        const account = process.env.USER || 'user';
+        const command = [
             'add-generic-password',
             '-U',
             '-s',
-            (0, claudeProfiles_1.claudeKeychainService)(configDir),
+            quoteSecurityInteractiveArg(service),
             '-a',
-            process.env.USER || 'user',
+            quoteSecurityInteractiveArg(account),
             '-w',
-            json,
-        ], { stdio: ['pipe', 'pipe', 'pipe'], timeout: 4000, killSignal: 'SIGKILL' });
+            quoteSecurityInteractiveArg(json),
+        ].join(' ');
+        (0, child_process_1.execFileSync)('security', ['-i'], {
+            input: command + '\n',
+            stdio: ['pipe', 'pipe', 'pipe'],
+            timeout: 4000,
+            killSignal: 'SIGKILL',
+        });
         return;
     }
     // Linux / WSL / Windows — file-based