sidekick-shared 0.27.5 → 0.28.0

package/dist/credentialIO.d.ts

@@ -7,30 +7,90 @@
  * Keychain is unavailable (locked, SSH) Claude Code falls back to the file on
  * macOS too, so reads consult the file after a Keychain miss.
  *
+ * Keychain writes mirror Claude Code 2.1.x exactly: the payload is hex-encoded
+ * (`-X`) and sent through `security -i` only while the command line fits the
+ * tool's line buffer; longer payloads go through argv. `security -i` silently
+ * truncates longer lines, which once stored half a credential (the `mcpOAuth`
+ * tokens make blobs of 4 KB and more) — a login Claude Code then reports as
+ * "Not logged in". Every write is read back and compared before it counts.
+ *
  * Both accounts.ts and credentials.ts consume this module so that all
  * credential access is platform-correct in one place.
  */
 export declare const KEYCHAIN_SERVICE = "Claude Code-credentials";
+/**
+ * Claude Code's ceiling for a `security -i` command line (the tool reads at
+ * most 4095 bytes per line). Longer commands go through argv instead.
+ */
+export declare const SECURITY_INTERACTIVE_LINE_LIMIT = 4032;
+/**
+ * Written as the item comment (`-j`) on every Keychain item Sidekick creates,
+ * so ownership is provable from the item itself even after its directory and
+ * the ledger that described it are gone.
+ */
+export declare const SIDEKICK_KEYCHAIN_COMMENT_PREFIX = "sidekick-agent-hub:";
+export type ClaudeCredentialStoreSource = 'keychain' | 'file';
+/**
+ * Outcome of reading one credential store. `error` (timeout, locked Keychain)
+ * is never treated like `absent`: guard decisions that may overwrite a store
+ * only proceed on a definite answer.
+ */
+export type ClaudeCredentialStoreRead = {
+    status: 'ok';
+    blob: Record<string, unknown>;
+    source: ClaudeCredentialStoreSource;
+} | {
+    status: 'absent';
+} | {
+    status: 'corrupt';
+    source: ClaudeCredentialStoreSource;
+    length: number;
+} | {
+    status: 'error';
+    reason: string;
+};
+/** A credential write that did not land, or could not be verified. */
+export declare class ClaudeCredentialWriteError extends Error {
+    constructor(message: string);
+}
+/**
+ * Read one Claude credential store with a definite outcome. On macOS the
+ * Keychain item is authoritative; the file is consulted only when the item is
+ * absent (Claude Code's own fallback), unless `keychainOnly` is set.
+ */
+export declare function readClaudeCredentialStore(configDir?: string, options?: {
+    keychainOnly?: boolean;
+}): ClaudeCredentialStoreRead;
 /**
  * Read the active Claude Code credentials as a parsed object.
  *
  * - macOS: reads from system Keychain via the `security` CLI, then the file
  * - Linux / WSL / Windows: reads `<home>/.credentials.json`
  *
- * Returns `null` when credentials are absent or unreadable.
+ * Returns `null` when credentials are absent or unreadable. Callers that must
+ * tell "absent" from "could not read" use {@link readClaudeCredentialStore}.
  */
 export declare function readActiveCredentials(configDir?: string): unknown;
 /**
- * Write credentials to the active Claude Code credential store.
+ * Write credentials to a profile home's Claude Code credential store.
  *
- * - macOS: writes to system Keychain via the `security` CLI
- * - Linux / WSL / Windows: atomic-writes `<home>/.credentials.json`
+ * - macOS: the suffixed Keychain item for `configDir`
+ * - Linux / WSL / Windows: atomic-writes `<configDir>/.credentials.json`
  *
- * Throws on failure.
+ * `configDir` is required: the live store is written only through the guarded
+ * installer in accounts.ts, which refuses downgrades and captures the outgoing
+ * login first. Throws {@link ClaudeCredentialWriteError} when the write did
+ * not land intact.
  */
 export declare function writeActiveCredentials(credentials: unknown, configDir?: string): void;
+/**
+ * Write the live store with no guard. Internal: the only caller is
+ * `installIntoLiveClaudeStore` in accounts.ts (a test enforces this).
+ */
+export declare function writeLiveClaudeCredentialStoreUnguarded(credentials: unknown): void;
 /**
  * Remove the credential store of a config directory (an abandoned isolated
- * login, a removed profile). Best effort: never throws.
+ * login, a removed profile, the profile home of the account that became
+ * live). Never throws; returns true when the store is gone afterwards.
  */
-export declare function deleteStoredCredentials(configDir: string): void;
+export declare function deleteStoredCredentials(configDir: string): boolean;

package/dist/credentialIO.js

@@ -8,6 +8,13 @@
  * Keychain is unavailable (locked, SSH) Claude Code falls back to the file on
  * macOS too, so reads consult the file after a Keychain miss.
  *
+ * Keychain writes mirror Claude Code 2.1.x exactly: the payload is hex-encoded
+ * (`-X`) and sent through `security -i` only while the command line fits the
+ * tool's line buffer; longer payloads go through argv. `security -i` silently
+ * truncates longer lines, which once stored half a credential (the `mcpOAuth`
+ * tokens make blobs of 4 KB and more) — a login Claude Code then reports as
+ * "Not logged in". Every write is read back and compared before it counts.
+ *
  * Both accounts.ts and credentials.ts consume this module so that all
  * credential access is platform-correct in one place.
  */
@@ -45,17 +52,41 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.KEYCHAIN_SERVICE = void 0;
+exports.ClaudeCredentialWriteError = exports.SIDEKICK_KEYCHAIN_COMMENT_PREFIX = exports.SECURITY_INTERACTIVE_LINE_LIMIT = exports.KEYCHAIN_SERVICE = void 0;
+exports.readClaudeCredentialStore = readClaudeCredentialStore;
 exports.readActiveCredentials = readActiveCredentials;
 exports.writeActiveCredentials = writeActiveCredentials;
+exports.writeLiveClaudeCredentialStoreUnguarded = writeLiveClaudeCredentialStoreUnguarded;
 exports.deleteStoredCredentials = deleteStoredCredentials;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
 const claudeProfiles_1 = require("./claudeProfiles");
+const claudeCredentialLedger_1 = require("./claudeCredentialLedger");
 const atomic_1 = require("./writers/atomic");
 exports.KEYCHAIN_SERVICE = 'Claude Code-credentials';
 const SECURITY_TIMEOUT_MS = 4000;
+/** `security` exits with this status when no item matches. */
+const SECURITY_ITEM_NOT_FOUND = 44;
+/**
+ * Claude Code's ceiling for a `security -i` command line (the tool reads at
+ * most 4095 bytes per line). Longer commands go through argv instead.
+ */
+exports.SECURITY_INTERACTIVE_LINE_LIMIT = 4032;
+/**
+ * Written as the item comment (`-j`) on every Keychain item Sidekick creates,
+ * so ownership is provable from the item itself even after its directory and
+ * the ledger that described it are gone.
+ */
+exports.SIDEKICK_KEYCHAIN_COMMENT_PREFIX = 'sidekick-agent-hub:';
+/** A credential write that did not land, or could not be verified. */
+class ClaudeCredentialWriteError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ClaudeCredentialWriteError';
+    }
+}
+exports.ClaudeCredentialWriteError = ClaudeCredentialWriteError;
 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
@@ -65,27 +96,69 @@ function quoteSecurityInteractiveArg(value) {
 function getCredentialsFilePath(configDir) {
     return path.join(configDir ?? (0, claudeProfiles_1.getLiveClaudeHome)(), '.credentials.json');
 }
-function readCredentialsFile(configDir) {
+function parseStoredText(raw, source) {
+    const text = raw.trim();
+    if (!text)
+        return { status: 'corrupt', source, length: 0 };
+    // `security -w` prints hex when the stored bytes are not plain text.
+    const decoded = source === 'keychain' && !text.startsWith('{') && /^(?:[0-9a-f]{2})+$/i.test(text)
+        ? Buffer.from(text, 'hex').toString('utf8')
+        : text;
     try {
-        return JSON.parse(fs.readFileSync(getCredentialsFilePath(configDir), 'utf8'));
+        const parsed = JSON.parse(decoded);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            return { status: 'ok', blob: parsed, source };
+        }
     }
     catch {
-        return null;
+        /* fall through */
     }
+    return { status: 'corrupt', source, length: decoded.length };
 }
-function readKeychainItem(service) {
+function readCredentialsFileStore(configDir) {
+    let raw;
     try {
-        const raw = (0, child_process_1.execFileSync)('security', ['find-generic-password', '-s', service, '-w'], {
+        raw = fs.readFileSync(getCredentialsFilePath(configDir), 'utf8');
+    }
+    catch (error) {
+        return error.code === 'ENOENT'
+            ? { status: 'absent' }
+            : { status: 'error', reason: String(error.message ?? error) };
+    }
+    return parseStoredText(raw, 'file');
+}
+function securityErrorStatus(error) {
+    const status = error.status;
+    return typeof status === 'number' ? status : null;
+}
+function readKeychainStore(service) {
+    try {
+        const raw = (0, child_process_1.execFileSync)('security', ['find-generic-password', '-a', (0, claudeProfiles_1.claudeKeychainAccountName)(), '-s', service, '-w'], {
             encoding: 'utf8',
             stdio: ['pipe', 'pipe', 'pipe'],
             timeout: SECURITY_TIMEOUT_MS,
             killSignal: 'SIGKILL',
         });
-        return JSON.parse(raw.trim());
+        return parseStoredText(String(raw), 'keychain');
     }
-    catch {
-        return null;
+    catch (error) {
+        if (securityErrorStatus(error) === SECURITY_ITEM_NOT_FOUND)
+            return { status: 'absent' };
+        return { status: 'error', reason: String(error?.message ?? error) };
+    }
+}
+/**
+ * Read one Claude credential store with a definite outcome. On macOS the
+ * Keychain item is authoritative; the file is consulted only when the item is
+ * absent (Claude Code's own fallback), unless `keychainOnly` is set.
+ */
+function readClaudeCredentialStore(configDir, options = {}) {
+    if (process.platform === 'darwin') {
+        const keychain = readKeychainStore((0, claudeProfiles_1.claudeKeychainService)(configDir));
+        if (keychain.status !== 'absent' || options.keychainOnly)
+            return keychain;
     }
+    return readCredentialsFileStore(configDir);
 }
 /**
  * Read the active Claude Code credentials as a parsed object.
@@ -93,69 +166,160 @@ function readKeychainItem(service) {
  * - macOS: reads from system Keychain via the `security` CLI, then the file
  * - Linux / WSL / Windows: reads `<home>/.credentials.json`
  *
- * Returns `null` when credentials are absent or unreadable.
+ * Returns `null` when credentials are absent or unreadable. Callers that must
+ * tell "absent" from "could not read" use {@link readClaudeCredentialStore}.
  */
 function readActiveCredentials(configDir) {
     if (process.platform === 'darwin') {
-        return readKeychainItem((0, claudeProfiles_1.claudeKeychainService)(configDir)) ?? readCredentialsFile(configDir);
+        const keychain = readKeychainStore((0, claudeProfiles_1.claudeKeychainService)(configDir));
+        if (keychain.status === 'ok')
+            return keychain.blob;
     }
-    return readCredentialsFile(configDir);
+    const file = readCredentialsFileStore(configDir);
+    return file.status === 'ok' ? file.blob : null;
+}
+function runKeychainWrite(service, hex, comment) {
+    const account = (0, claudeProfiles_1.claudeKeychainAccountName)();
+    const args = ['add-generic-password', '-U', '-a', account, '-s', service];
+    const interactive = [
+        'add-generic-password',
+        '-U',
+        '-a',
+        quoteSecurityInteractiveArg(account),
+        '-s',
+        quoteSecurityInteractiveArg(service),
+    ];
+    if (comment) {
+        args.push('-j', comment);
+        interactive.push('-j', quoteSecurityInteractiveArg(comment));
+    }
+    args.push('-X', hex);
+    interactive.push('-X', quoteSecurityInteractiveArg(hex));
+    const line = `${interactive.join(' ')}\n`;
+    if (Buffer.byteLength(line, 'utf8') <= exports.SECURITY_INTERACTIVE_LINE_LIMIT) {
+        (0, child_process_1.execFileSync)('security', ['-i'], {
+            input: line,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            timeout: SECURITY_TIMEOUT_MS,
+            killSignal: 'SIGKILL',
+        });
+        return;
+    }
+    // The same trade-off Claude Code makes for large payloads: the hex is on the
+    // command line (visible to `ps`) for the duration of this call.
+    (0, child_process_1.execFileSync)('security', args, {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        timeout: SECURITY_TIMEOUT_MS,
+        killSignal: 'SIGKILL',
+    });
 }
 /**
- * Write credentials to the active Claude Code credential store.
- *
- * - macOS: writes to system Keychain via the `security` CLI
- * - Linux / WSL / Windows: atomic-writes `<home>/.credentials.json`
- *
- * Throws on failure.
+ * Write a credential blob to a store and verify it by reading it back.
+ * `configDir` undefined targets the live home; only the guarded live installer
+ * in accounts.ts may do that (see {@link writeLiveClaudeCredentialStoreUnguarded}).
  */
-function writeActiveCredentials(credentials, configDir) {
+function writeClaudeCredentialStore(credentials, configDir) {
     const json = JSON.stringify(credentials);
-    JSON.parse(json); // validate round-trip
+    let expected;
+    try {
+        expected = JSON.stringify(JSON.parse(json));
+    }
+    catch {
+        throw new ClaudeCredentialWriteError('Refusing to store a credential that is not JSON.');
+    }
     if (process.platform === 'darwin') {
         const service = (0, claudeProfiles_1.claudeKeychainService)(configDir);
-        const command = [
-            'add-generic-password',
-            '-U',
+        const comment = configDir
+            ? `${exports.SIDEKICK_KEYCHAIN_COMMENT_PREFIX}${path.resolve(configDir)}`
+            : null;
+        try {
+            runKeychainWrite(service, Buffer.from(json, 'utf8').toString('hex'), comment);
+        }
+        catch (error) {
+            throw new ClaudeCredentialWriteError(`Keychain write failed: ${error?.message ?? error}`);
+        }
+        const readBack = readKeychainStore(service);
+        if (readBack.status === 'error') {
+            throw new ClaudeCredentialWriteError('The Keychain write could not be verified (read-back failed); treating it as not written.');
+        }
+        if (readBack.status !== 'ok' || JSON.stringify(readBack.blob) !== expected) {
+            throw new ClaudeCredentialWriteError('The Keychain item did not hold the credential after writing it.');
+        }
+        return;
+    }
+    // Linux / WSL / Windows — file-based (tmp + fsync + rename, retried on Windows)
+    (0, atomic_1.atomicWriteFileSync)(getCredentialsFilePath(configDir), json, 0o600);
+    const readBack = readCredentialsFileStore(configDir);
+    if (readBack.status !== 'ok' || JSON.stringify(readBack.blob) !== expected) {
+        throw new ClaudeCredentialWriteError('The credentials file did not hold the credential after writing it.');
+    }
+}
+/**
+ * Write credentials to a profile home's Claude Code credential store.
+ *
+ * - macOS: the suffixed Keychain item for `configDir`
+ * - Linux / WSL / Windows: atomic-writes `<configDir>/.credentials.json`
+ *
+ * `configDir` is required: the live store is written only through the guarded
+ * installer in accounts.ts, which refuses downgrades and captures the outgoing
+ * login first. Throws {@link ClaudeCredentialWriteError} when the write did
+ * not land intact.
+ */
+function writeActiveCredentials(credentials, configDir) {
+    if (!configDir) {
+        throw new ClaudeCredentialWriteError('writeActiveCredentials() needs a config directory; the live Claude login is only written through a guarded account switch.');
+    }
+    (0, claudeCredentialLedger_1.recordClaudeCredentialHome)(configDir, 'profile');
+    writeClaudeCredentialStore(credentials, configDir);
+}
+/**
+ * Write the live store with no guard. Internal: the only caller is
+ * `installIntoLiveClaudeStore` in accounts.ts (a test enforces this).
+ */
+function writeLiveClaudeCredentialStoreUnguarded(credentials) {
+    writeClaudeCredentialStore(credentials, undefined);
+}
+function deleteKeychainItem(service, withAccount) {
+    try {
+        (0, child_process_1.execFileSync)('security', [
+            'delete-generic-password',
+            ...(withAccount ? ['-a', (0, claudeProfiles_1.claudeKeychainAccountName)()] : []),
             '-s',
-            quoteSecurityInteractiveArg(service),
-            '-a',
-            quoteSecurityInteractiveArg((0, claudeProfiles_1.claudeKeychainAccountName)()),
-            '-w',
-            quoteSecurityInteractiveArg(json),
-        ].join(' ');
-        (0, child_process_1.execFileSync)('security', ['-i'], {
-            input: command + '\n',
-            stdio: ['pipe', 'pipe', 'pipe'],
+            service,
+        ], {
+            stdio: ['ignore', 'ignore', 'ignore'],
             timeout: SECURITY_TIMEOUT_MS,
             killSignal: 'SIGKILL',
         });
-        return;
+        return 'deleted';
+    }
+    catch (error) {
+        return securityErrorStatus(error) === SECURITY_ITEM_NOT_FOUND ? 'absent' : 'error';
     }
-    // Linux / WSL / Windows — file-based (tmp + fsync + rename, retried on Windows)
-    (0, atomic_1.atomicWriteFileSync)(getCredentialsFilePath(configDir), json, 0o600);
 }
 /**
  * Remove the credential store of a config directory (an abandoned isolated
- * login, a removed profile). Best effort: never throws.
+ * login, a removed profile, the profile home of the account that became
+ * live). Never throws; returns true when the store is gone afterwards.
  */
 function deleteStoredCredentials(configDir) {
+    let gone = true;
     if (process.platform === 'darwin') {
-        try {
-            (0, child_process_1.execFileSync)('security', ['delete-generic-password', '-s', (0, claudeProfiles_1.claudeKeychainService)(configDir)], {
-                stdio: ['ignore', 'ignore', 'ignore'],
-                timeout: SECURITY_TIMEOUT_MS,
-                killSignal: 'SIGKILL',
-            });
-        }
-        catch {
-            /* no item, or keychain unavailable */
-        }
+        const service = (0, claudeProfiles_1.claudeKeychainService)(configDir);
+        let outcome = deleteKeychainItem(service, true);
+        // Items written before the account name was pinned may carry another one.
+        if (outcome === 'absent')
+            outcome = deleteKeychainItem(service, false);
+        if (outcome === 'error')
+            gone = false;
     }
     try {
         fs.rmSync(getCredentialsFilePath(configDir), { force: true });
     }
     catch {
-        /* best effort */
+        gone = false;
     }
+    if (gone)
+        (0, claudeCredentialLedger_1.forgetClaudeCredentialHome)(configDir);
+    return gone;
 }

package/dist/doctor.js

@@ -37,7 +37,6 @@ exports.getSessionDiagnostics = getSessionDiagnostics;
 exports.runDoctor = runDoctor;
 exports.formatHealthReport = formatHealthReport;
 const fs = __importStar(require("fs"));
-const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const accountStatus_1 = require("./accountStatus");
 const paths_1 = require("./paths");
@@ -48,11 +47,12 @@ const openCode_1 = require("./providers/openCode");
 const factory_1 = require("./providers/factory");
 const detect_1 = require("./providers/detect");
 const openCodeDatabase_1 = require("./providers/openCodeDatabase");
+const claudePaths_1 = require("./claudePaths");
 /** Collects the Claude Code path-resolution detail used by both host surfaces. */
 function getSessionDiagnostics(workspacePath) {
     const encodedPath = (0, sessionPathResolver_1.encodeWorkspacePath)(workspacePath);
     const expectedSessionDir = (0, sessionPathResolver_1.getSessionDirectory)(workspacePath);
-    const projectsDir = path.join(os.homedir(), '.claude', 'projects');
+    const projectsDir = (0, claudePaths_1.getClaudeProjectsDir)();
     let existingProjectDirs = [];
     let expectedDirExists = false;
     try {

package/dist/ensureDefaultAccounts.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureDefaultAccounts = ensureDefaultAccounts;
 const accounts_1 = require("./accounts");
-const codexProfiles_1 = require("./codexProfiles");
 const accountSync_1 = require("./accountSync");
 function logFailure(options, message, error) {
     try {
@@ -35,13 +34,7 @@ async function ensureDefaultAccounts(options) {
         logFailure(options, 'Claude auth reconciliation failed.', error);
     }
     try {
-        await (0, codexProfiles_1.reconcileCodexAuthStateAsync)();
-    }
-    catch (error) {
-        logFailure(options, 'Codex auth reconciliation failed.', error);
-    }
-    try {
-        (0, accountSync_1.cleanupAbandonedLogins)();
+        await (0, accountSync_1.cleanupAbandonedLoginsAsync)();
     }
     catch (error) {
         logFailure(options, 'Abandoned login cleanup failed.', error);

package/dist/esm/accountChangeSignal.js

@@ -0,0 +1,15 @@
+const listeners = new Set();
+export function _onRawAccountsChanged(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+}
+export function _emitAccountsChanged(reason) {
+    for (const listener of listeners) {
+        try {
+            listener(reason);
+        }
+        catch {
+            // Account notifications are observational and cannot break mutations.
+        }
+    }
+}

package/dist/esm/accountChanges.js

@@ -0,0 +1,152 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { _emitAccountsChanged, _onRawAccountsChanged, } from './accountChangeSignal';
+import { getActiveAccountStatus } from './accountStatus';
+import { getAccountsDir } from './accountRegistry';
+import { syncLiveAccountStateSync } from './accountSync';
+import { getLiveClaudeHome } from './claudeProfiles';
+import { getSystemCodexHome } from './codexPaths';
+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.
+ */
+export 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(getActiveAccountStatus());
+    stopRawListener = _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([
+        getAccountsDir(),
+        getLiveClaudeHome(),
+        path.join(os.homedir(), '.claude'),
+        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) {
+    // External CLIs write the live homes directly: fold their logins into the
+    // saved profiles before reporting status, so a native `claude /login` is
+    // registered and its rotated tokens are backed up without a host round-trip.
+    // `local` signals come from our own registry writes and need no sync.
+    if (reason === 'filesystem' || reason === 'poll') {
+        try {
+            syncLiveAccountStateSync({ reason: reason === 'poll' ? 'poll' : 'watch' });
+        }
+        catch {
+            // Sync problems surface through the health model, never through the watcher.
+        }
+    }
+    const status = 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. */
+export function _notifyAccountsChanged() {
+    _emitAccountsChanged('local');
+}