sidekick-shared 0.25.0 → 0.26.1

package/dist/accounts.js

@@ -201,7 +201,14 @@ function readAccountRegistry() {
     };
 }
 function writeAccountRegistry(registry) {
-    const mappedClaudeProfiles = registry.accounts.map((account) => ({
+    (0, accountRegistry_1.replaceSavedAccountProfiles)('claude-code', mapClaudeProfiles(registry), registry.activeAccountUuid);
+}
+/** For callers already holding the registry lock (see withSavedAccountRegistryLock). */
+function writeAccountRegistryUnlocked(registry) {
+    (0, accountRegistry_1.replaceSavedAccountProfilesUnlocked)('claude-code', mapClaudeProfiles(registry), registry.activeAccountUuid);
+}
+function mapClaudeProfiles(registry) {
+    return registry.accounts.map((account) => ({
         id: account.uuid,
         providerId: 'claude-code',
         providerAccountId: account.uuid,
@@ -212,7 +219,6 @@ function writeAccountRegistry(registry) {
             email: account.email,
         },
     }));
-    (0, accountRegistry_1.replaceSavedAccountProfiles)('claude-code', mappedClaudeProfiles, registry.activeAccountUuid);
 }
 // ── Read active Claude account ───────────────────────────────────────────
 function readActiveClaudeAccount() {
@@ -254,17 +260,34 @@ function addCurrentAccount(label) {
         return { success: false, error: 'Could not read Claude config file.' };
     }
     ensureDirs();
-    // 4. Load or create registry
-    const registry = readAccountRegistry() ?? {
-        version: 1,
-        activeAccountUuid: null,
-        accounts: [],
-    };
-    // 5. Check if account already exists — update credentials + label
-    const existing = registry.accounts.find((a) => a.uuid === active.uuid);
-    if (existing) {
-        if (label !== undefined)
-            existing.label = label;
+    // 4–7 are one read-modify-write of the registry: hold the registry lock
+    // across them so a concurrent add from another process is not dropped
+    // when this write replaces the whole Claude profile set.
+    return (0, accountRegistry_1.withSavedAccountRegistryLock)(() => {
+        // 4. Load or create registry
+        const registry = readAccountRegistry() ?? {
+            version: 1,
+            activeAccountUuid: null,
+            accounts: [],
+        };
+        // 5. Check if account already exists — update credentials + label
+        const existing = registry.accounts.find((a) => a.uuid === active.uuid);
+        if (existing) {
+            if (label !== undefined)
+                existing.label = label;
+            (0, atomic_1.atomicWriteJsonSync)(path.join(getCredentialsDir(), `${active.uuid}.credentials.json`), credBlob);
+            (0, atomic_1.atomicWriteJsonSync)(path.join(getConfigsDir(), `${active.uuid}.config.json`), configBlob);
+            try {
+                writeClaudeProfileMirror(active.uuid, credBlob, configBlob);
+            }
+            catch {
+                /* flat backups remain available */
+            }
+            registry.activeAccountUuid = active.uuid;
+            writeAccountRegistryUnlocked(registry);
+            return { success: true };
+        }
+        // 6. New account — back up credentials
         (0, atomic_1.atomicWriteJsonSync)(path.join(getCredentialsDir(), `${active.uuid}.credentials.json`), credBlob);
         (0, atomic_1.atomicWriteJsonSync)(path.join(getConfigsDir(), `${active.uuid}.config.json`), configBlob);
         try {
@@ -273,29 +296,17 @@ function addCurrentAccount(label) {
         catch {
             /* flat backups remain available */
         }
+        // 7. Add entry
+        registry.accounts.push({
+            uuid: active.uuid,
+            email: active.email,
+            label,
+            addedAt: new Date().toISOString(),
+        });
         registry.activeAccountUuid = active.uuid;
-        writeAccountRegistry(registry);
+        writeAccountRegistryUnlocked(registry);
         return { success: true };
-    }
-    // 6. New account — back up credentials
-    (0, atomic_1.atomicWriteJsonSync)(path.join(getCredentialsDir(), `${active.uuid}.credentials.json`), credBlob);
-    (0, atomic_1.atomicWriteJsonSync)(path.join(getConfigsDir(), `${active.uuid}.config.json`), configBlob);
-    try {
-        writeClaudeProfileMirror(active.uuid, credBlob, configBlob);
-    }
-    catch {
-        /* flat backups remain available */
-    }
-    // 7. Add entry
-    registry.accounts.push({
-        uuid: active.uuid,
-        email: active.email,
-        label,
-        addedAt: new Date().toISOString(),
     });
-    registry.activeAccountUuid = active.uuid;
-    writeAccountRegistry(registry);
-    return { success: true };
 }
 // ── Switch to account ────────────────────────────────────────────────────
 /**
@@ -486,34 +497,37 @@ function reconcileClaudeAuthState() {
 }
 // ── Remove account ───────────────────────────────────────────────────────
 function removeAccount(uuid) {
-    const registry = readAccountRegistry();
-    if (!registry) {
-        return { success: false, error: 'No account registry found.' };
-    }
-    const idx = registry.accounts.findIndex((a) => a.uuid === uuid);
-    if (idx === -1) {
-        return { success: false, error: `Account ${uuid} not found.` };
-    }
-    // Remove backed-up files
-    try {
-        fs.unlinkSync(path.join(getCredentialsDir(), `${uuid}.credentials.json`));
-    }
-    catch {
-        /* ok */
-    }
-    try {
-        fs.unlinkSync(path.join(getConfigsDir(), `${uuid}.config.json`));
-    }
-    catch {
-        /* ok */
-    }
-    // Remove from registry
-    registry.accounts.splice(idx, 1);
-    if (registry.activeAccountUuid === uuid) {
-        registry.activeAccountUuid = registry.accounts[0]?.uuid ?? null;
-    }
-    writeAccountRegistry(registry);
-    return { success: true };
+    // One read-modify-write under the registry lock (see addCurrentAccount).
+    return (0, accountRegistry_1.withSavedAccountRegistryLock)(() => {
+        const registry = readAccountRegistry();
+        if (!registry) {
+            return { success: false, error: 'No account registry found.' };
+        }
+        const idx = registry.accounts.findIndex((a) => a.uuid === uuid);
+        if (idx === -1) {
+            return { success: false, error: `Account ${uuid} not found.` };
+        }
+        // Remove backed-up files
+        try {
+            fs.unlinkSync(path.join(getCredentialsDir(), `${uuid}.credentials.json`));
+        }
+        catch {
+            /* ok */
+        }
+        try {
+            fs.unlinkSync(path.join(getConfigsDir(), `${uuid}.config.json`));
+        }
+        catch {
+            /* ok */
+        }
+        // Remove from registry
+        registry.accounts.splice(idx, 1);
+        if (registry.activeAccountUuid === uuid) {
+            registry.activeAccountUuid = registry.accounts[0]?.uuid ?? null;
+        }
+        writeAccountRegistryUnlocked(registry);
+        return { success: true };
+    });
 }
 // ── Query helpers ────────────────────────────────────────────────────────
 function listAccounts() {
@@ -546,7 +560,8 @@ function getActiveAccount() {
  * re-pointed so registry-keyed data tracks reality too. Never creates or deletes
  * profiles; an unknown live account is shown as-is with no label and no write.
  */
-function resolveActiveClaudeAccount() {
+function resolveActiveClaudeAccount(options = {}) {
+    const selfHeal = options.selfHeal ?? true;
     const live = readActiveClaudeAccount();
     if (live) {
         const profiles = (0, accountRegistry_1.listSavedAccountProfiles)('claude-code');
@@ -554,12 +569,17 @@ function resolveActiveClaudeAccount() {
             profiles.find((p) => (p.email ?? p.metadata?.email) === live.email);
         if (match) {
             const active = (0, accountRegistry_1.getActiveSavedAccount)('claude-code');
-            if (!active || active.id !== match.id) {
+            // Hot paths (the status line runs on every prompt) pass selfHeal: false
+            // so a persistently failing registry write never becomes a write per
+            // prompt; the next ordinary command repairs the pointer instead.
+            if (selfHeal && (!active || active.id !== match.id)) {
                 // Self-heal is best-effort: a registry write failure (read-only/full
                 // disk) must never break display or extension activation. We still
                 // return the correct live identity below.
+                // Silent: this is a read path repairing a pointer to the profile that
+                // already matches the live login, so subscribers have nothing new to see.
                 try {
-                    (0, accountRegistry_1.setActiveSavedAccount)('claude-code', match.id);
+                    (0, accountRegistry_1.setActiveSavedAccount)('claude-code', match.id, { silent: true });
                 }
                 catch {
                     /* keep going with the live identity */

package/dist/aggregation/EventAggregator.d.ts

@@ -14,7 +14,7 @@ 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 = 4;
+export declare const SNAPSHOT_SCHEMA_VERSION = 5;
 /**
  * JSON-serializable snapshot of EventAggregator state.
  * Used by session snapshot sidecar files for fast resume.
@@ -28,7 +28,14 @@ export interface SerializedAggregatorState {
         cacheRead: number;
         reasoning: number;
         total: number;
+        /** @deprecated Mirrors `costUsd`; kept so older readers of the field keep working. */
         reportedCost: number;
+        costUsd: number;
+        reportedCostUsd: number;
+        estimatedCostUsd: number;
+        reportedCalls: number;
+        estimatedCalls: number;
+        unpricedCalls: number;
     };
     modelUsage: Array<[
         string,
@@ -100,7 +107,13 @@ export declare class EventAggregator {
     private cacheReadTokens;
     private reasoningTokens;
     private totalTokens;
-    private reportedCost;
+    /** Running cost in USD (reported + estimated). */
+    private costUsd;
+    private reportedCostUsd;
+    private estimatedCostUsd;
+    private reportedCalls;
+    private estimatedCalls;
+    private unpricedCalls;
     private modelUsage;
     private currentContextSize;
     private previousContextSize;

package/dist/aggregation/EventAggregator.js

@@ -16,6 +16,7 @@ const planExtractor_1 = require("../parsers/planExtractor");
 const eventBridge_1 = require("../watchers/eventBridge");
 const toolSummary_1 = require("../formatters/toolSummary");
 const noiseClassifier_1 = require("../formatters/noiseClassifier");
+const costProvenance_1 = require("./costProvenance");
 const FrequencyTracker_1 = require("./FrequencyTracker");
 const HeatmapTracker_1 = require("./HeatmapTracker");
 const PatternExtractor_1 = require("./PatternExtractor");
@@ -30,7 +31,7 @@ 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. */
-exports.SNAPSHOT_SCHEMA_VERSION = 4;
+exports.SNAPSHOT_SCHEMA_VERSION = 5;
 // ── 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 ──
@@ -78,7 +79,13 @@ class EventAggregator {
     cacheReadTokens = 0;
     reasoningTokens = 0;
     totalTokens = 0;
-    reportedCost = 0;
+    /** Running cost in USD (reported + estimated). */
+    costUsd = 0;
+    reportedCostUsd = 0;
+    estimatedCostUsd = 0;
+    reportedCalls = 0;
+    estimatedCalls = 0;
+    unpricedCalls = 0;
     // Per-model usage
     modelUsage = new Map();
     // Context size tracking
@@ -262,8 +269,10 @@ class EventAggregator {
             this.attributePlanUsage(normalized.totalTokens, cost);
         }
         else if (typeof event.cost === 'number' && Number.isFinite(event.cost) && event.cost >= 0) {
-            // Compatibility for cost-only follow events.
-            this.reportedCost += event.cost;
+            // Compatibility for cost-only follow events (provider-reported by definition).
+            this.costUsd += event.cost;
+            this.reportedCostUsd += event.cost;
+            this.reportedCalls += 1;
         }
         // 4. Tool tracking from FollowEvent
         if (event.type === 'tool_use' && event.toolName) {
@@ -309,7 +318,16 @@ class EventAggregator {
             cacheReadTokens: this.cacheReadTokens,
             reasoningTokens: this.reasoningTokens,
             totalTokens: this.totalTokens,
-            reportedCost: this.reportedCost,
+            costUsd: this.costUsd,
+            reportedCostUsd: this.reportedCostUsd,
+            estimatedCostUsd: this.estimatedCostUsd,
+            unpricedCalls: this.unpricedCalls,
+            costProvenance: (0, costProvenance_1.classifyCostProvenance)({
+                reportedCalls: this.reportedCalls,
+                estimatedCalls: this.estimatedCalls,
+                unpricedCalls: this.unpricedCalls,
+            }),
+            reportedCost: this.costUsd,
         };
     }
     getModelStats() {
@@ -427,7 +445,12 @@ class EventAggregator {
         this.cacheReadTokens = 0;
         this.reasoningTokens = 0;
         this.totalTokens = 0;
-        this.reportedCost = 0;
+        this.costUsd = 0;
+        this.reportedCostUsd = 0;
+        this.estimatedCostUsd = 0;
+        this.reportedCalls = 0;
+        this.estimatedCalls = 0;
+        this.unpricedCalls = 0;
         this.modelUsage.clear();
         this.currentContextSize = 0;
         this.previousContextSize = 0;
@@ -503,7 +526,13 @@ class EventAggregator {
                 cacheRead: this.cacheReadTokens,
                 reasoning: this.reasoningTokens,
                 total: this.totalTokens,
-                reportedCost: this.reportedCost,
+                reportedCost: this.costUsd,
+                costUsd: this.costUsd,
+                reportedCostUsd: this.reportedCostUsd,
+                estimatedCostUsd: this.estimatedCostUsd,
+                reportedCalls: this.reportedCalls,
+                estimatedCalls: this.estimatedCalls,
+                unpricedCalls: this.unpricedCalls,
             },
             modelUsage: Array.from(this.modelUsage.entries()),
             contextSize: this.currentContextSize,
@@ -550,7 +579,12 @@ class EventAggregator {
         this.cacheReadTokens = state.tokens.cacheRead;
         this.reasoningTokens = state.tokens.reasoning;
         this.totalTokens = state.tokens.total;
-        this.reportedCost = state.tokens.reportedCost;
+        this.costUsd = state.tokens.costUsd;
+        this.reportedCostUsd = state.tokens.reportedCostUsd;
+        this.estimatedCostUsd = state.tokens.estimatedCostUsd;
+        this.reportedCalls = state.tokens.reportedCalls;
+        this.estimatedCalls = state.tokens.estimatedCalls;
+        this.unpricedCalls = state.tokens.unpricedCalls;
         this.modelUsage = new Map(state.modelUsage);
         this.currentContextSize = state.contextSize;
         this.previousContextSize = state.previousContextSize;
@@ -619,7 +653,18 @@ class EventAggregator {
         this.cacheReadTokens += cacheRead;
         this.reasoningTokens += reasoningTok;
         this.totalTokens += usage.totalTokens;
-        this.reportedCost += cost;
+        this.costUsd += cost;
+        if (pricedUsage.source === 'provider-reported') {
+            this.reportedCostUsd += cost;
+            this.reportedCalls += 1;
+        }
+        else if (pricedUsage.source === 'unpriced') {
+            this.unpricedCalls += 1;
+        }
+        else {
+            this.estimatedCostUsd += cost;
+            this.estimatedCalls += 1;
+        }
         // Burn rate sample accumulation
         this.tokensSinceLastSample += usage.totalTokens;
         // Context size computation

package/dist/aggregation/costProvenance.d.ts

@@ -0,0 +1,14 @@
+import type { AggregatedCostProvenance, AggregatedTokens } from './types';
+/** The fields `describeCostProvenance` reads; any `AggregatedTokens` qualifies. */
+export type AggregatedCostProvenanceInput = Pick<AggregatedTokens, 'costProvenance' | 'unpricedCalls'>;
+/**
+ * Human-readable qualifier for an aggregate cost, for report footers and
+ * table cells. Empty when there is nothing to qualify.
+ */
+export declare function describeCostProvenance(tokens: AggregatedCostProvenanceInput): string;
+/** Classify a cost breakdown by how many events fell into each bucket. */
+export declare function classifyCostProvenance(counts: {
+    reportedCalls: number;
+    estimatedCalls: number;
+    unpricedCalls: number;
+}): AggregatedCostProvenance;

package/dist/aggregation/costProvenance.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeCostProvenance = describeCostProvenance;
+exports.classifyCostProvenance = classifyCostProvenance;
+const PROVENANCE_LABELS = {
+    reported: 'provider-reported',
+    estimated: 'estimated from catalog pricing',
+    mixed: 'partly provider-reported, partly estimated',
+    unpriced: 'unpriced',
+    none: '',
+};
+/**
+ * Human-readable qualifier for an aggregate cost, for report footers and
+ * table cells. Empty when there is nothing to qualify.
+ */
+function describeCostProvenance(tokens) {
+    const base = PROVENANCE_LABELS[tokens.costProvenance] ?? '';
+    const unpriced = tokens.unpricedCalls > 0
+        ? `${tokens.unpricedCalls} unpriced call${tokens.unpricedCalls === 1 ? '' : 's'}`
+        : '';
+    if (base && unpriced)
+        return `${base} · ${unpriced}`;
+    return base || unpriced;
+}
+/** Classify a cost breakdown by how many events fell into each bucket. */
+function classifyCostProvenance(counts) {
+    const { reportedCalls, estimatedCalls, unpricedCalls } = counts;
+    if (reportedCalls > 0 && estimatedCalls > 0)
+        return 'mixed';
+    if (reportedCalls > 0)
+        return 'reported';
+    if (estimatedCalls > 0)
+        return 'estimated';
+    return unpricedCalls > 0 ? 'unpriced' : 'none';
+}

package/dist/aggregation/snapshot.d.ts

@@ -8,6 +8,8 @@
  * @module aggregation/snapshot
  */
 import { type SerializedAggregatorState } from './EventAggregator';
+/** Newest snapshots kept on disk; older ones are pruned opportunistically. */
+export declare const MAX_SNAPSHOT_FILES = 200;
 /** Snapshot sidecar file content. */
 export interface SessionSnapshot {
     /** Schema version for forward-compatibility checks. */
@@ -32,10 +34,19 @@ export declare function getSnapshotPath(sessionId: string): string;
 /**
  * Saves a session snapshot to disk.
  *
- * Creates the snapshots directory if it doesn't exist.
- * Writes atomically via rename to avoid partial reads.
+ * Creates the snapshots directory if it doesn't exist. Uses the shared
+ * fsynced atomic writer with a per-process temp name, so the CLI dashboard and
+ * the extension host snapshotting the same session cannot collide on a shared
+ * `.tmp` file. Every {@link PRUNE_EVERY_N_SAVES} saves the directory is
+ * trimmed to the newest {@link MAX_SNAPSHOT_FILES}; snapshots are caches, so
+ * dropping an old one only costs a replay.
  */
 export declare function saveSnapshot(snapshot: SessionSnapshot): void;
+/**
+ * Deletes all but the newest `keep` snapshot files (by modification time).
+ * Returns how many files were removed. Best-effort; never throws.
+ */
+export declare function pruneSnapshots(keep?: number): number;
 /**
  * Loads a session snapshot from disk if it exists and is valid.
  *

package/dist/aggregation/snapshot.js

@@ -42,17 +42,25 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_SNAPSHOT_FILES = void 0;
 exports.getSnapshotPath = getSnapshotPath;
 exports.saveSnapshot = saveSnapshot;
+exports.pruneSnapshots = pruneSnapshots;
 exports.loadSnapshot = loadSnapshot;
 exports.deleteSnapshot = deleteSnapshot;
 exports.isSnapshotValid = isSnapshotValid;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const paths_1 = require("../paths");
+const atomic_1 = require("../writers/atomic");
 const EventAggregator_1 = require("./EventAggregator");
 /** Current schema version — bump when format changes. */
 const SNAPSHOT_VERSION = EventAggregator_1.SNAPSHOT_SCHEMA_VERSION;
+/** Newest snapshots kept on disk; older ones are pruned opportunistically. */
+exports.MAX_SNAPSHOT_FILES = 200;
+/** Prune runs once per this many saves, so steady-state writes stay one file each. */
+const PRUNE_EVERY_N_SAVES = 25;
+let savesSincePrune = 0;
 /** Returns the directory for snapshot files. */
 function getSnapshotsDir() {
     return path.join((0, paths_1.getConfigDir)(), 'snapshots');
@@ -66,8 +74,12 @@ function getSnapshotPath(sessionId) {
 /**
  * Saves a session snapshot to disk.
  *
- * Creates the snapshots directory if it doesn't exist.
- * Writes atomically via rename to avoid partial reads.
+ * Creates the snapshots directory if it doesn't exist. Uses the shared
+ * fsynced atomic writer with a per-process temp name, so the CLI dashboard and
+ * the extension host snapshotting the same session cannot collide on a shared
+ * `.tmp` file. Every {@link PRUNE_EVERY_N_SAVES} saves the directory is
+ * trimmed to the newest {@link MAX_SNAPSHOT_FILES}; snapshots are caches, so
+ * dropping an old one only costs a replay.
  */
 function saveSnapshot(snapshot) {
     try {
@@ -75,15 +87,54 @@ function saveSnapshot(snapshot) {
         if (!fs.existsSync(dir)) {
             fs.mkdirSync(dir, { recursive: true });
         }
-        const filePath = getSnapshotPath(snapshot.sessionId);
-        const tmpPath = filePath + '.tmp';
-        fs.writeFileSync(tmpPath, JSON.stringify(snapshot), 'utf-8');
-        fs.renameSync(tmpPath, filePath);
+        (0, atomic_1.atomicWriteJsonSync)(getSnapshotPath(snapshot.sessionId), snapshot);
+        savesSincePrune += 1;
+        if (savesSincePrune >= PRUNE_EVERY_N_SAVES) {
+            savesSincePrune = 0;
+            pruneSnapshots(exports.MAX_SNAPSHOT_FILES);
+        }
     }
     catch {
         // Non-critical — snapshot failure should never break session monitoring
     }
 }
+/**
+ * Deletes all but the newest `keep` snapshot files (by modification time).
+ * Returns how many files were removed. Best-effort; never throws.
+ */
+function pruneSnapshots(keep = exports.MAX_SNAPSHOT_FILES) {
+    try {
+        const dir = getSnapshotsDir();
+        const entries = fs
+            .readdirSync(dir)
+            .filter((name) => name.endsWith('.json'))
+            .map((name) => {
+            const filePath = path.join(dir, name);
+            try {
+                return { filePath, mtimeMs: fs.statSync(filePath).mtimeMs };
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((entry) => entry !== null)
+            .sort((a, b) => b.mtimeMs - a.mtimeMs);
+        let removed = 0;
+        for (const entry of entries.slice(Math.max(0, keep))) {
+            try {
+                fs.unlinkSync(entry.filePath);
+                removed += 1;
+            }
+            catch {
+                // Already gone or locked; skip.
+            }
+        }
+        return removed;
+    }
+    catch {
+        return 0;
+    }
+}
 /**
  * Loads a session snapshot from disk if it exists and is valid.
  *

package/dist/aggregation/types.d.ts

@@ -50,7 +50,17 @@ export interface EventAggregatorOptions {
     /** Read a plan file from disk (fallback when Edit tool is used instead of Write). */
     readPlanFile?: (path: string) => string | null;
 }
-/** Token accumulation totals (aggregation-specific, includes reportedCost). */
+/**
+ * How an aggregate cost figure was produced.
+ *
+ * - `reported`  — every priced event carried a provider-reported cost.
+ * - `estimated` — every priced event was priced from the model catalog.
+ * - `mixed`     — some events reported, some estimated.
+ * - `unpriced`  — no event could be priced at all.
+ * - `none`      — no usage events yet.
+ */
+export type AggregatedCostProvenance = 'reported' | 'estimated' | 'mixed' | 'unpriced' | 'none';
+/** Token accumulation totals (aggregation-specific, includes cost). */
 export interface AggregatedTokens {
     inputTokens: number;
     outputTokens: number;
@@ -59,6 +69,25 @@ export interface AggregatedTokens {
     reasoningTokens: number;
     /** Overall total after applying provider reasoning-in-output semantics. */
     totalTokens: number;
+    /**
+     * Cost in USD for the priced portion of the session. Read `costProvenance`
+     * before labelling it: only `'reported'` came from the provider; anything
+     * else includes Sidekick's own catalog estimate.
+     */
+    costUsd: number;
+    /** Portion of `costUsd` the provider reported itself. */
+    reportedCostUsd: number;
+    /** Portion of `costUsd` Sidekick estimated from catalog pricing. */
+    estimatedCostUsd: number;
+    /** Usage events that had neither a reported cost nor a catalog price. */
+    unpricedCalls: number;
+    /** Classification of `costUsd`. */
+    costProvenance: AggregatedCostProvenance;
+    /**
+     * @deprecated Same value as `costUsd`. Despite the name it has always mixed
+     * catalog estimates with provider-reported figures; use `costUsd` together
+     * with `costProvenance`.
+     */
     reportedCost: number;
 }
 /** Per-model usage breakdown. */

package/dist/analytics/compactionLedger.js

@@ -2,18 +2,28 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.calculateCompactionLedger = calculateCompactionLedger;
 exports.formatCompactionLedger = formatCompactionLedger;
-const modelInfo_1 = require("../modelInfo");
+const usageNormalization_1 = require("../usageNormalization");
 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;
+    // Re-establishing evicted context means sending it again as uncached input.
+    // Price it through the same normalized path every other cost figure uses so
+    // the ledger can never disagree with the session total on the same tokens.
+    const reestablishment = model
+        ? (0, usageNormalization_1.calculateNormalizedUsageCost)({
+            usage: (0, usageNormalization_1.normalizeProviderUsage)({
+                semantics: 'sidekick',
+                inputTokens: tokensEvicted,
+                reasoningIncludedInOutput: true,
+            }),
+            modelId: model,
+        })
+        : null;
     return {
         count: events.length,
         tokensEvicted,
-        reestablishmentCostUsd: pricing
-            ? (0, modelInfo_1.calculateCostWithPricing)({ inputTokens: tokensEvicted, outputTokens: 0, cacheWriteTokens: 0, cacheReadTokens: 0 }, pricing)
-            : null,
+        reestablishmentCostUsd: reestablishment?.costUsd ?? null,
         source: reportedCount > 0 && heuristicCount > 0
             ? 'mixed'
             : reportedCount > 0

package/dist/analytics/qualityScore.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.scoreSessionQuality = scoreSessionQuality;
 exports.calculateQualityTrend = calculateQualityTrend;
+const tokenSummary_1 = require("../tokenSummary");
 function awarded(maximum, ratio) {
     return Math.round(maximum * Math.max(0, Math.min(1, ratio)) * 10) / 10;
 }
@@ -10,7 +11,7 @@ function scoreSessionQuality(metrics) {
     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 contextTokens = Math.max(1, (0, tokenSummary_1.summarizeTokens)(metrics.tokens).context);
     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;