sidekick-shared 0.22.0 → 0.23.1

package/dist/analytics/codeImpact.d.ts

@@ -0,0 +1,20 @@
+export interface ModelCostInput {
+    model: string;
+    cost: number;
+    priced?: boolean;
+}
+export interface CodeImpact {
+    changedLines: number;
+    additions: number;
+    deletions: number;
+    totalCost: number;
+    costPerChangedLine: number | null;
+    byModel: Array<{
+        model: string;
+        cost: number;
+        priced: boolean;
+        changedLines: number;
+        costPerChangedLine: number | null;
+    }>;
+}
+export declare function calculateCodeImpact(totalCost: number, additions: number, deletions: number, models?: ModelCostInput[]): CodeImpact;

package/dist/analytics/codeImpact.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateCodeImpact = calculateCodeImpact;
+function calculateCodeImpact(totalCost, additions, deletions, models = []) {
+    const safeAdditions = Math.max(0, additions);
+    const safeDeletions = Math.max(0, deletions);
+    const changedLines = safeAdditions + safeDeletions;
+    return {
+        changedLines,
+        additions: safeAdditions,
+        deletions: safeDeletions,
+        totalCost,
+        costPerChangedLine: changedLines > 0 ? totalCost / changedLines : null,
+        byModel: models.map((model) => ({
+            ...model,
+            priced: model.priced !== false,
+            changedLines,
+            costPerChangedLine: changedLines > 0 && model.priced !== false ? model.cost / changedLines : null,
+        })),
+    };
+}

package/dist/analytics/compactionLedger.d.ts

@@ -0,0 +1,11 @@
+import type { CompactionEvent } from '../types/sessionEvent';
+export interface CompactionLedger {
+    count: number;
+    tokensEvicted: number;
+    reestablishmentCostUsd: number | null;
+    source: 'reported' | 'heuristic' | 'mixed';
+    reportedCount: number;
+    heuristicCount: number;
+}
+export declare function calculateCompactionLedger(events: CompactionEvent[], model?: string | null): CompactionLedger;
+export declare function formatCompactionLedger(ledger: CompactionLedger): string;

package/dist/analytics/compactionLedger.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateCompactionLedger = calculateCompactionLedger;
+exports.formatCompactionLedger = formatCompactionLedger;
+const modelInfo_1 = require("../modelInfo");
+function calculateCompactionLedger(events, model) {
+    const tokensEvicted = events.reduce((sum, event) => sum + Math.max(0, event.tokensReclaimed), 0);
+    const reportedCount = events.filter((event) => event.source === 'reported').length;
+    const heuristicCount = events.length - reportedCount;
+    const pricing = model ? (0, modelInfo_1.getModelPricing)(model) : null;
+    return {
+        count: events.length,
+        tokensEvicted,
+        reestablishmentCostUsd: pricing
+            ? (0, modelInfo_1.calculateCostWithPricing)({ inputTokens: tokensEvicted, outputTokens: 0, cacheWriteTokens: 0, cacheReadTokens: 0 }, pricing)
+            : null,
+        source: reportedCount > 0 && heuristicCount > 0
+            ? 'mixed'
+            : reportedCount > 0
+                ? 'reported'
+                : 'heuristic',
+        reportedCount,
+        heuristicCount,
+    };
+}
+function formatCompactionLedger(ledger) {
+    const cost = ledger.reestablishmentCostUsd == null
+        ? 'cost unavailable'
+        : `~$${ledger.reestablishmentCostUsd.toFixed(2)} re-establishing context`;
+    return `${ledger.count} compaction${ledger.count === 1 ? '' : 's'} · ${ledger.tokensEvicted.toLocaleString()} tokens evicted · ${cost} · ${ledger.source}`;
+}

package/dist/analytics/qualityScore.d.ts

@@ -0,0 +1,26 @@
+import type { AggregatedMetrics } from '../aggregation/types';
+import type { SessionHistoryRecord } from '../types/historicalData';
+export type QualityFactorId = 'latency' | 'reliability' | 'context' | 'permission_safety' | 'outcomes';
+export interface QualityFactorContribution {
+    id: QualityFactorId;
+    label: string;
+    contribution: number;
+    maximum: number;
+    detail: string;
+}
+export interface SessionQualityScore {
+    /** Composite score. Beta until weights are calibrated against durable history. */
+    score: number;
+    beta: true;
+    factors: QualityFactorContribution[];
+}
+export interface QualityTrend {
+    currentWeekAverage: number | null;
+    previousWeekAverage: number | null;
+    delta: number | null;
+    direction: 'improving' | 'declining' | 'flat' | 'insufficient';
+    currentWeekSessions: number;
+    previousWeekSessions: number;
+}
+export declare function scoreSessionQuality(metrics: AggregatedMetrics): SessionQualityScore;
+export declare function calculateQualityTrend(records: SessionHistoryRecord[], now?: Date): QualityTrend;

package/dist/analytics/qualityScore.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scoreSessionQuality = scoreSessionQuality;
+exports.calculateQualityTrend = calculateQualityTrend;
+function awarded(maximum, ratio) {
+    return Math.round(maximum * Math.max(0, Math.min(1, ratio)) * 10) / 10;
+}
+function scoreSessionQuality(metrics) {
+    const latencyMs = metrics.latencyStats?.avgFirstTokenLatencyMs ?? 0;
+    const latencyRatio = latencyMs > 0 ? 1 - Math.min(1, latencyMs / 15_000) : 1;
+    const completedCalls = metrics.toolStats.reduce((sum, tool) => sum + tool.completedCount, 0);
+    const errorRate = completedCalls > 0 ? metrics.errorRollup.totalFailures / completedCalls : 0;
+    const contextTokens = Math.max(1, metrics.tokens.inputTokens + metrics.tokens.cacheReadTokens + metrics.tokens.cacheWriteTokens);
+    const evicted = metrics.compactionEvents.reduce((sum, event) => sum + event.tokensReclaimed, 0);
+    const contextRatio = 1 - Math.min(1, evicted / contextTokens);
+    const start = metrics.sessionStartTime ? Date.parse(metrics.sessionStartTime) : NaN;
+    const end = metrics.lastEventTime ? Date.parse(metrics.lastEventTime) : NaN;
+    let bypassMs = 0;
+    for (let index = 0; index < metrics.permissionModeHistory.length; index++) {
+        const change = metrics.permissionModeHistory[index];
+        if (change.mode !== 'bypassPermissions')
+            continue;
+        const from = Date.parse(change.timestamp);
+        const to = Date.parse(metrics.permissionModeHistory[index + 1]?.timestamp ?? metrics.lastEventTime ?? '');
+        if (Number.isFinite(from) && Number.isFinite(to))
+            bypassMs += Math.max(0, to - from);
+    }
+    const sessionMs = Number.isFinite(start) && Number.isFinite(end) ? Math.max(1, end - start) : 1;
+    const bypassRatio = Math.min(1, bypassMs / sessionMs);
+    const tasks = Array.from(metrics.taskState.tasks.values()).filter((task) => task.status !== 'deleted');
+    const completedTasks = tasks.filter((task) => task.status === 'completed').length;
+    const goalGates = tasks.filter((task) => task.isGoalGate);
+    const completedGates = goalGates.filter((task) => task.status === 'completed').length;
+    const taskRatio = tasks.length > 0 ? completedTasks / tasks.length : 1;
+    const goalRatio = goalGates.length > 0 ? completedGates / goalGates.length : taskRatio;
+    const outcomeRatio = taskRatio * 0.6 + goalRatio * 0.4;
+    const factors = [
+        {
+            id: 'latency',
+            label: 'Response latency',
+            contribution: awarded(15, latencyRatio),
+            maximum: 15,
+            detail: latencyMs > 0 ? `${Math.round(latencyMs)}ms average first token` : 'No latency penalty',
+        },
+        {
+            id: 'reliability',
+            label: 'Tool reliability',
+            contribution: awarded(30, 1 - Math.min(1, errorRate * 2)),
+            maximum: 30,
+            detail: `${metrics.errorRollup.totalFailures}/${completedCalls} completed tool calls failed`,
+        },
+        {
+            id: 'context',
+            label: 'Context stability',
+            contribution: awarded(15, contextRatio),
+            maximum: 15,
+            detail: `${metrics.compactionCount} compactions, ${evicted} tokens evicted`,
+        },
+        {
+            id: 'permission_safety',
+            label: 'Permission safety',
+            contribution: awarded(10, 1 - bypassRatio),
+            maximum: 10,
+            detail: `${Math.round(bypassRatio * 100)}% of observed time bypassing permissions`,
+        },
+        {
+            id: 'outcomes',
+            label: 'Task outcomes',
+            contribution: awarded(30, outcomeRatio),
+            maximum: 30,
+            detail: `${completedTasks}/${tasks.length} tasks and ${completedGates}/${goalGates.length} goal gates completed`,
+        },
+    ];
+    return {
+        score: Math.round(factors.reduce((sum, factor) => sum + factor.contribution, 0)),
+        beta: true,
+        factors,
+    };
+}
+function calculateQualityTrend(records, now = new Date()) {
+    const end = now.getTime();
+    const week = 7 * 24 * 60 * 60 * 1000;
+    const eligible = records.filter((record) => record.qualityScore > 0 && Number.isFinite(Date.parse(record.endTime)));
+    const current = eligible.filter((record) => {
+        const at = Date.parse(record.endTime);
+        return at >= end - week && at <= end;
+    });
+    const previous = eligible.filter((record) => {
+        const at = Date.parse(record.endTime);
+        return at >= end - 2 * week && at < end - week;
+    });
+    const average = (items) => items.length > 0
+        ? Math.round((items.reduce((sum, item) => sum + item.qualityScore, 0) / items.length) * 10) /
+            10
+        : null;
+    const currentWeekAverage = average(current);
+    const previousWeekAverage = average(previous);
+    const delta = currentWeekAverage != null && previousWeekAverage != null
+        ? Math.round((currentWeekAverage - previousWeekAverage) * 10) / 10
+        : null;
+    return {
+        currentWeekAverage,
+        previousWeekAverage,
+        delta,
+        direction: delta == null
+            ? 'insufficient'
+            : delta > 0.5
+                ? 'improving'
+                : delta < -0.5
+                    ? 'declining'
+                    : 'flat',
+        currentWeekSessions: current.length,
+        previousWeekSessions: previous.length,
+    };
+}

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

@@ -382,6 +382,7 @@ function resolveActiveCodexAccount() {
             email: identity.email ?? match?.email ?? match?.metadata?.email,
             label: match?.label,
             providerAccountId: match?.providerAccountId ?? identity.workspaceId,
+            registryAccountId: match?.id,
             source: 'live',
         };
     }
@@ -392,6 +393,7 @@ function resolveActiveCodexAccount() {
             email: active.email ?? active.metadata?.email,
             label: active.label,
             providerAccountId: active.providerAccountId,
+            registryAccountId: active.id,
             source: 'registry',
         };
     }

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/composer.d.ts

@@ -5,7 +5,8 @@ import type { PersistedTask } from '../types/taskPersistence';
 import type { DecisionEntry } from '../types/decisionLog';
 import type { KnowledgeNote } from '../types/knowledgeNote';
 import type { TokenTotals } from '../types/historicalData';
-import type { SessionProvider, SessionFileStats, ProviderId } from '../providers/types';
+import type { SessionProviderBase, SessionFileStats, ProviderId } from '../providers/types';
+import type { ProjectIdentity } from '../paths';
 export type Fidelity = 'full' | 'compact' | 'brief';
 export interface ContextResult {
     provider: ProviderId;
@@ -28,4 +29,4 @@ export interface ContextResult {
     } | null;
     sessionSummaries: SessionFileStats[];
 }
-export declare function composeContext(slug: string, fidelity: Fidelity, provider: SessionProvider, workspacePath?: string): Promise<ContextResult>;
+export declare function composeContext(project: string | ProjectIdentity, fidelity: Fidelity, provider: SessionProviderBase, workspacePath?: string): Promise<ContextResult>;

package/dist/context/composer.js

@@ -9,14 +9,14 @@ const decisions_1 = require("../readers/decisions");
 const notes_1 = require("../readers/notes");
 const history_1 = require("../readers/history");
 const handoff_1 = require("../readers/handoff");
-async function composeContext(slug, fidelity, provider, workspacePath) {
+async function composeContext(project, fidelity, provider, workspacePath) {
     // Fetch all data in parallel
     const [allTasks, allDecisions, allNotes, history, handoff] = await Promise.all([
-        (0, tasks_1.readTasks)(slug),
-        (0, decisions_1.readDecisions)(slug),
-        (0, notes_1.readNotes)(slug),
+        (0, tasks_1.readTasks)(project),
+        (0, decisions_1.readDecisions)(project),
+        (0, notes_1.readNotes)(project),
         (0, history_1.readHistory)(),
-        (0, handoff_1.readLatestHandoff)(slug),
+        (0, handoff_1.readLatestHandoff)(project),
     ]);
     // Get session summaries
     const sessionFiles = workspacePath ? provider.findAllSessions(workspacePath) : [];

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;
     }