sidekick-shared 0.24.5 → 0.26.0

package/dist/accountChangeSignal.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._onRawAccountsChanged = _onRawAccountsChanged;
+exports._emitAccountsChanged = _emitAccountsChanged;
+const listeners = new Set();
+function _onRawAccountsChanged(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+}
+function _emitAccountsChanged(reason) {
+    for (const listener of listeners) {
+        try {
+            listener(reason);
+        }
+        catch {
+            // Account notifications are observational and cannot break mutations.
+        }
+    }
+}

package/dist/accountChanges.d.ts

@@ -0,0 +1,21 @@
+import { type AccountChangeReason } from './accountChangeSignal';
+import { type ActiveAccountStatus } from './accountStatus';
+import type { Disposable } from './quotaPoller';
+export interface AccountsChangedEvent {
+    reason: AccountChangeReason;
+    status: ActiveAccountStatus;
+}
+export interface OnAccountsChangedOptions {
+    /** Emit the current status immediately after subscribing. */
+    emitCurrent?: boolean;
+    /** Catch-up poll for filesystems where watch delivery is unreliable. Default: 30s. */
+    pollIntervalMs?: number;
+}
+/**
+ * Observe login, logout, and active-account switches. Local Sidekick mutations
+ * signal immediately; filesystem watchers cover external CLIs; a low-frequency
+ * catch-up poll protects network mounts and watcher-hostile filesystems.
+ */
+export declare function onAccountsChanged(listener: (event: AccountsChangedEvent) => void, options?: OnAccountsChangedOptions): Disposable;
+/** Internal bridge for account mutations outside the registry module. */
+export declare function _notifyAccountsChanged(): void;

package/dist/accountChanges.js

@@ -0,0 +1,170 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onAccountsChanged = onAccountsChanged;
+exports._notifyAccountsChanged = _notifyAccountsChanged;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const accountChangeSignal_1 = require("./accountChangeSignal");
+const accountStatus_1 = require("./accountStatus");
+const accountRegistry_1 = require("./accountRegistry");
+const codexProfiles_1 = require("./codexProfiles");
+const listeners = new Set();
+let watchers = [];
+let pollTimer;
+let stopRawListener;
+let lastFingerprint;
+let debounceTimer;
+const DEFAULT_POLL_INTERVAL_MS = 30_000;
+let activePollIntervalMs = DEFAULT_POLL_INTERVAL_MS;
+/**
+ * Observe login, logout, and active-account switches. Local Sidekick mutations
+ * signal immediately; filesystem watchers cover external CLIs; a low-frequency
+ * catch-up poll protects network mounts and watcher-hostile filesystems.
+ */
+function onAccountsChanged(listener, options = {}) {
+    listeners.add(listener);
+    // The fastest interval any live subscriber asked for wins; a later, faster
+    // subscriber restarts the timer rather than being silently ignored.
+    const requestedPollMs = Math.max(1_000, options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS);
+    if (!stopRawListener) {
+        activePollIntervalMs = requestedPollMs;
+        ensureMonitoring();
+    }
+    else if (requestedPollMs < activePollIntervalMs) {
+        activePollIntervalMs = requestedPollMs;
+        restartPollTimer();
+    }
+    if (options.emitCurrent)
+        emitIfChanged('poll', true, listener);
+    return {
+        dispose: () => {
+            listeners.delete(listener);
+            if (listeners.size === 0)
+                stopMonitoring();
+        },
+    };
+}
+function ensureMonitoring() {
+    if (stopRawListener)
+        return;
+    lastFingerprint = fingerprint((0, accountStatus_1.getActiveAccountStatus)());
+    stopRawListener = (0, accountChangeSignal_1._onRawAccountsChanged)((reason) => scheduleCheck(reason));
+    for (const target of watchTargets()) {
+        try {
+            const watcher = fs.watch(target, { persistent: false }, () => {
+                scheduleCheck('filesystem');
+            });
+            watcher.on('error', () => {
+                watchers = watchers.filter((candidate) => candidate !== watcher);
+                try {
+                    watcher.close();
+                }
+                catch {
+                    // The catch-up poll remains active.
+                }
+            });
+            watchers.push(watcher);
+        }
+        catch {
+            // Missing/unwatchable directories are covered by the catch-up poll.
+        }
+    }
+    startPollTimer();
+}
+function startPollTimer() {
+    pollTimer = setInterval(() => emitIfChanged('poll'), activePollIntervalMs);
+    pollTimer.unref?.();
+}
+function restartPollTimer() {
+    if (pollTimer)
+        clearInterval(pollTimer);
+    startPollTimer();
+}
+function stopMonitoring() {
+    stopRawListener?.();
+    stopRawListener = undefined;
+    for (const watcher of watchers)
+        watcher.close();
+    watchers = [];
+    if (pollTimer)
+        clearInterval(pollTimer);
+    pollTimer = undefined;
+    if (debounceTimer)
+        clearTimeout(debounceTimer);
+    debounceTimer = undefined;
+    lastFingerprint = undefined;
+    activePollIntervalMs = DEFAULT_POLL_INTERVAL_MS;
+}
+function watchTargets() {
+    return Array.from(new Set([(0, accountRegistry_1.getAccountsDir)(), path.join(os.homedir(), '.claude'), (0, codexProfiles_1.getSystemCodexHome)()]));
+}
+function scheduleCheck(reason) {
+    if (debounceTimer)
+        clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(() => {
+        debounceTimer = undefined;
+        // Never force: watch targets include ~/.claude and the Codex home, whose
+        // history files churn on every prompt. Only a real status change may wake
+        // subscribers, or dormant quota pollers would poll on unrelated writes.
+        emitIfChanged(reason);
+    }, 25);
+    debounceTimer.unref?.();
+}
+function emitIfChanged(reason, force = false, singleListener) {
+    const status = (0, accountStatus_1.getActiveAccountStatus)();
+    const nextFingerprint = fingerprint(status);
+    if (!force && nextFingerprint === lastFingerprint)
+        return;
+    lastFingerprint = nextFingerprint;
+    const event = { reason, status };
+    const targets = singleListener ? [singleListener] : [...listeners];
+    for (const listener of targets) {
+        try {
+            listener(event);
+        }
+        catch {
+            // A host callback cannot stop monitoring.
+        }
+    }
+}
+function fingerprint(status) {
+    return JSON.stringify(status);
+}
+/** Internal bridge for account mutations outside the registry module. */
+function _notifyAccountsChanged() {
+    (0, accountChangeSignal_1._emitAccountsChanged)('local');
+}

package/dist/accountRegistry.d.ts

@@ -1,4 +1,6 @@
-export type AccountProviderId = 'claude-code' | 'codex';
+import type { AccountProviderId } from './providerIds';
+export { ACCOUNT_PROVIDER_IDS } from './providerIds';
+export type { AccountProviderId } from './providerIds';
 export interface AccountIdentityMetadata {
     email?: string;
     workspaceId?: string;
@@ -39,11 +41,32 @@ export interface ResolvedActiveAccount {
     source: 'live' | 'registry' | 'none';
 }
 export declare function getAccountsDir(): string;
+interface RegistryWriteOptions {
+    /**
+     * Skip the local change notification. Only for writes that change no
+     * observable account state, such as re-pointing the active pointer at the
+     * profile that already matches the live login (self-heal): a read path
+     * must not wake every subscriber.
+     */
+    silent?: boolean;
+}
+/**
+ * Run `operation` while holding the registry lock. For callers that need a
+ * read-modify-write across several steps (the legacy Claude facade's
+ * add/remove); inside it use the `*Unlocked` writers, never the locking ones:
+ * the lock is not re-entrant.
+ */
+export declare function withSavedAccountRegistryLock<T>(operation: () => T): T;
 export declare function readSavedAccountRegistry(): SavedAccountRegistry | null;
 export declare function writeSavedAccountRegistry(registry: SavedAccountRegistry): void;
 export declare function listSavedAccountProfiles(providerId?: AccountProviderId): SavedAccountProfile[];
 export declare function getActiveSavedAccount(providerId: AccountProviderId): SavedAccountProfile | null;
 export declare function upsertSavedAccountProfile(profile: SavedAccountProfile): SavedAccountRegistry;
-export declare function setActiveSavedAccount(providerId: AccountProviderId, accountId: string | null): SavedAccountRegistry;
+export declare function setActiveSavedAccount(providerId: AccountProviderId, accountId: string | null, options?: RegistryWriteOptions): SavedAccountRegistry;
 export declare function replaceSavedAccountProfiles(providerId: AccountProviderId, accounts: SavedAccountProfile[], activeId: string | null): SavedAccountRegistry;
+/**
+ * Same as {@link replaceSavedAccountProfiles} without taking the registry
+ * lock: for callers already inside {@link withSavedAccountRegistryLock}.
+ */
+export declare function replaceSavedAccountProfilesUnlocked(providerId: AccountProviderId, accounts: SavedAccountProfile[], activeId: string | null): SavedAccountRegistry;
 export declare function removeSavedAccountProfile(providerId: AccountProviderId, accountId: string): SavedAccountProfile | null;

package/dist/accountRegistry.js

@@ -33,7 +33,9 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ACCOUNT_PROVIDER_IDS = void 0;
 exports.getAccountsDir = getAccountsDir;
+exports.withSavedAccountRegistryLock = withSavedAccountRegistryLock;
 exports.readSavedAccountRegistry = readSavedAccountRegistry;
 exports.writeSavedAccountRegistry = writeSavedAccountRegistry;
 exports.listSavedAccountProfiles = listSavedAccountProfiles;
@@ -41,11 +43,15 @@ exports.getActiveSavedAccount = getActiveSavedAccount;
 exports.upsertSavedAccountProfile = upsertSavedAccountProfile;
 exports.setActiveSavedAccount = setActiveSavedAccount;
 exports.replaceSavedAccountProfiles = replaceSavedAccountProfiles;
+exports.replaceSavedAccountProfilesUnlocked = replaceSavedAccountProfilesUnlocked;
 exports.removeSavedAccountProfile = removeSavedAccountProfile;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const paths_1 = require("./paths");
 const atomic_1 = require("./writers/atomic");
+const accountChangeSignal_1 = require("./accountChangeSignal");
+var providerIds_1 = require("./providerIds");
+Object.defineProperty(exports, "ACCOUNT_PROVIDER_IDS", { enumerable: true, get: function () { return providerIds_1.ACCOUNT_PROVIDER_IDS; } });
 function getAccountsDir() {
     return path.join((0, paths_1.getConfigDir)(), 'accounts');
 }
@@ -58,8 +64,20 @@ function getRegistryLockPath() {
 function ensureAccountsDir() {
     fs.mkdirSync(getAccountsDir(), { recursive: true, mode: 0o700 });
 }
-function writeRegistryUnlocked(registry) {
+function writeRegistryUnlocked(registry, options = {}) {
     (0, atomic_1.atomicWriteJsonSync)(getRegistryPath(), normalizeRegistry(registry));
+    if (!options.silent)
+        (0, accountChangeSignal_1._emitAccountsChanged)('local');
+}
+/**
+ * Run `operation` while holding the registry lock. For callers that need a
+ * read-modify-write across several steps (the legacy Claude facade's
+ * add/remove); inside it use the `*Unlocked` writers, never the locking ones:
+ * the lock is not re-entrant.
+ */
+function withSavedAccountRegistryLock(operation) {
+    ensureAccountsDir();
+    return (0, atomic_1.withFileLockSync)(getRegistryLockPath(), operation);
 }
 /**
  * Serializes registry read-modify-write cycles across processes. Without the
@@ -68,13 +86,13 @@ function writeRegistryUnlocked(registry) {
  * mutation. Lock ordering: callers that also hold a provider auth-swap lock
  * take that lock first and this one inside it, never the reverse.
  */
-function mutateSavedAccountRegistry(mutator) {
-    ensureAccountsDir();
-    return (0, atomic_1.withFileLockSync)(getRegistryLockPath(), () => {
-        const next = mutator(readSavedAccountRegistry() ?? createEmptyRegistry());
-        writeRegistryUnlocked(next);
-        return next;
-    });
+function mutateSavedAccountRegistry(mutator, options = {}) {
+    return withSavedAccountRegistryLock(() => mutateSavedAccountRegistryUnlocked(mutator, options));
+}
+function mutateSavedAccountRegistryUnlocked(mutator, options = {}) {
+    const next = mutator(readSavedAccountRegistry() ?? createEmptyRegistry());
+    writeRegistryUnlocked(next, options);
+    return next;
 }
 function createEmptyRegistry() {
     return {
@@ -182,20 +200,30 @@ function upsertSavedAccountProfile(profile) {
         return registry;
     });
 }
-function setActiveSavedAccount(providerId, accountId) {
+function setActiveSavedAccount(providerId, accountId, options = {}) {
     return mutateSavedAccountRegistry((registry) => {
         registry.activeByProvider[providerId] = accountId;
         return registry;
-    });
+    }, options);
 }
-function replaceSavedAccountProfiles(providerId, accounts, activeId) {
-    return mutateSavedAccountRegistry((registry) => {
+function replaceProfiles(providerId, accounts, activeId) {
+    return (registry) => {
         registry.accounts = registry.accounts
             .filter((account) => account.providerId !== providerId)
             .concat(accounts);
         registry.activeByProvider[providerId] = activeId;
         return registry;
-    });
+    };
+}
+function replaceSavedAccountProfiles(providerId, accounts, activeId) {
+    return mutateSavedAccountRegistry(replaceProfiles(providerId, accounts, activeId));
+}
+/**
+ * Same as {@link replaceSavedAccountProfiles} without taking the registry
+ * lock: for callers already inside {@link withSavedAccountRegistryLock}.
+ */
+function replaceSavedAccountProfilesUnlocked(providerId, accounts, activeId) {
+    return mutateSavedAccountRegistryUnlocked(replaceProfiles(providerId, accounts, activeId));
 }
 function removeSavedAccountProfile(providerId, accountId) {
     ensureAccountsDir();

package/dist/accountStatus.d.ts

@@ -10,10 +10,18 @@ export interface ActiveAccountStatus {
     codex: ActiveProviderAccountStatus;
     error?: string;
 }
+export interface ActiveAccountStatusOptions {
+    /**
+     * Re-point a stale saved-account pointer at the live identity when they
+     * disagree (default true). Hot paths such as the status line pass `false`
+     * so they never write; an ordinary command repairs the pointer later.
+     */
+    selfHeal?: boolean;
+}
 /**
  * Reads active Claude Code and Codex account status in one filesystem pass.
  *
  * If reading either provider throws, the result still has provider-shaped
  * fields so startup flows can render a consistent "not configured" state.
  */
-export declare function getActiveAccountStatus(error?: string): ActiveAccountStatus;
+export declare function getActiveAccountStatus(error?: string, options?: ActiveAccountStatusOptions): ActiveAccountStatus;

package/dist/accountStatus.js

@@ -12,10 +12,10 @@ function errorMessage(error) {
  * If reading either provider throws, the result still has provider-shaped
  * fields so startup flows can render a consistent "not configured" state.
  */
-function getActiveAccountStatus(error) {
+function getActiveAccountStatus(error, options = {}) {
     try {
-        const claudeAccount = (0, accounts_1.resolveActiveClaudeAccount)();
-        const codexAccount = (0, codexProfiles_1.resolveActiveCodexAccount)();
+        const claudeAccount = (0, accounts_1.resolveActiveClaudeAccount)(options);
+        const codexAccount = (0, codexProfiles_1.resolveActiveCodexAccount)(options);
         const claude = claudeAccount.source !== 'none'
             ? {
                 present: true,

package/dist/accounts.d.ts

@@ -50,5 +50,7 @@ export declare function getActiveAccount(): AccountEntry | null;
  * 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.
  */
-export declare function resolveActiveClaudeAccount(): ResolvedActiveAccount;
+export declare function resolveActiveClaudeAccount(options?: {
+    selfHeal?: boolean;
+}): ResolvedActiveAccount;
 export declare function isMultiAccountEnabled(): boolean;

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;