@cortexkit/anthropic-auth-core 1.15.1 → 1.16.0

package/dist/accounts.d.ts

@@ -70,7 +70,7 @@ export type OAuthQuotaSnapshot = Partial<Record<QuotaWindowName, AccountQuotaWin
     scoped?: AccountScopedQuotaWindow[];
     checkedAt?: number;
 };
-export type RoutingMode = 'main-first' | 'fallback-first';
+export type RoutingMode = 'main-first' | 'fallback-first' | 'sticky-balanced';
 export type KillswitchThresholds = Partial<Record<QuotaWindowName | '5h' | '1w' | 'scoped', number>>;
 export type KillswitchConfig = {
     enabled?: boolean;
@@ -134,6 +134,7 @@ export type AccountStorage = {
     };
     cacheKeep?: {
         enabled?: boolean;
+        always?: boolean;
         startHour?: number;
         endHour?: number;
         subagents?: boolean;
@@ -189,7 +190,13 @@ export declare function getAccountStoragePath(): string;
 export declare function getAccountStatePath(configPath?: string): string;
 export declare function createEmptyStorage(): AccountStorage;
 export declare function loadAccounts(path?: string): Promise<AccountStorage | null>;
-export declare function saveAccounts(storage: AccountStorage, path?: string): Promise<void>;
+export interface SaveAccountsOptions {
+    /** Account ids intentionally removed by this mutation. */
+    removedAccountIds?: readonly string[];
+    /** Preserve disk order when a stale snapshot is missing newer accounts. */
+    preserveExistingAccountOrder?: boolean;
+}
+export declare function saveAccounts(storage: AccountStorage, path?: string, options?: SaveAccountsOptions): Promise<void>;
 export declare function saveAccountState(storage: AccountStorage, path?: string, scope?: AccountStateSaveScope): Promise<void>;
 export declare function acquireRefreshFileLock(options: {
     name: string;
@@ -211,10 +218,15 @@ export declare function setDumpPersistentEnabled(enabled: boolean, path?: string
 export declare function isFastModePersistentlyEnabled(storage: AccountStorage | null): boolean;
 export declare function setFastModePersistentEnabled(enabled: boolean, path?: string): Promise<AccountStorage>;
 export declare function setCacheKeepPersistentWindow(startHour: number, endHour: number, path?: string): Promise<AccountStorage>;
+export declare function setCacheKeepPersistentAlways(path?: string): Promise<AccountStorage>;
 export declare function setCacheKeepPersistentEnabled(enabled: boolean, path?: string): Promise<AccountStorage>;
 export declare function isCacheKeepSubagentsEnabled(storage: AccountStorage | null): boolean;
 export declare function setCacheKeepSubagentsEnabled(enabled: boolean, path?: string): Promise<AccountStorage>;
 export declare function shouldFallbackStatus(status: number, storage: AccountStorage | null): boolean;
+export declare function getQuotaMinimumRemainingThresholds(storage: AccountStorage | null): {
+    five_hour: number;
+    seven_day: number;
+};
 export declare function getRefreshIntervalMs(storage: AccountStorage | null): number;
 export declare function hashRefreshToken(refreshToken: string): string;
 export declare function buildRefreshOperationError(input: {

package/dist/accounts.js

@@ -517,19 +517,81 @@ async function writeJsonAtomic(path, value) {
         throw error;
     }
 }
-export function saveAccounts(storage, path = getAccountStoragePath()) {
-    const resolvedPath = path;
-    return enqueueSave(() => saveAccountsLocked(storage, resolvedPath));
-}
-async function saveAccountsLocked(storage, path) {
-    const existing = await loadExistingTopLevelFields(path);
-    const nextConfig = { ...existing, ...configFromStorage(storage) };
-    await writeJsonAtomic(path, nextConfig);
-    await saveAccountStateUnlocked(storage, path, {
-        mainQuota: true,
-        mainRefresh: true,
-        accounts: true,
+function sameAccountIdentity(left, right) {
+    return (left.id === right.id ||
+        Boolean(left.label && right.label && left.label === right.label));
+}
+function mergeAccountsForSave(existing, incoming, options) {
+    const removedIds = new Set(options.removedAccountIds ?? []);
+    const current = existing.filter((account) => !removedIds.has(account.id));
+    const next = incoming.filter((account) => !removedIds.has(account.id));
+    const missing = current.filter((account) => !next.some((candidate) => sameAccountIdentity(candidate, account)));
+    if (!missing.length)
+        return [...next];
+    if (options.preserveExistingAccountOrder === false) {
+        return [...next, ...missing];
+    }
+    const usedIncoming = new Set();
+    const merged = current.map((account) => {
+        const index = next.findIndex((candidate, candidateIndex) => !usedIncoming.has(candidateIndex) &&
+            sameAccountIdentity(candidate, account));
+        const candidate = next[index];
+        if (!candidate)
+            return account;
+        usedIncoming.add(index);
+        return candidate;
     });
+    for (let index = 0; index < next.length; index++) {
+        const candidate = next[index];
+        if (!usedIncoming.has(index) && candidate)
+            merged.push(candidate);
+    }
+    return merged;
+}
+const ACCOUNT_CONFIG_LOCK_TTL_MS = 10_000;
+const ACCOUNT_CONFIG_LOCK_WAIT_MS = 12_000;
+async function acquireAccountConfigWriteLock(path) {
+    await mkdir(dirname(path), { recursive: true });
+    const deadline = Date.now() + ACCOUNT_CONFIG_LOCK_WAIT_MS;
+    while (true) {
+        const lock = await acquireRefreshFileLock({
+            name: 'config-write',
+            ttlMs: ACCOUNT_CONFIG_LOCK_TTL_MS,
+            path,
+            renew: true,
+        });
+        if (lock)
+            return lock;
+        if (Date.now() >= deadline) {
+            throw new Error('Timed out waiting for the account configuration write lock');
+        }
+        await new Promise((resolve) => setTimeout(resolve, 25));
+    }
+}
+export function saveAccounts(storage, path = getAccountStoragePath(), options = {}) {
+    const resolvedPath = path;
+    return enqueueSave(() => saveAccountsLocked(storage, resolvedPath, options));
+}
+async function saveAccountsLocked(storage, path, options) {
+    const lock = await acquireAccountConfigWriteLock(path);
+    try {
+        const current = await loadAccounts(path);
+        const nextStorage = {
+            ...storage,
+            accounts: mergeAccountsForSave(current?.accounts ?? [], storage.accounts, options),
+        };
+        const existing = await loadExistingTopLevelFields(path);
+        const nextConfig = { ...existing, ...configFromStorage(nextStorage) };
+        await writeJsonAtomic(path, nextConfig);
+        await saveAccountStateUnlocked(nextStorage, path, {
+            mainQuota: true,
+            mainRefresh: true,
+            accounts: true,
+        });
+    }
+    finally {
+        await lock.release();
+    }
 }
 function applyMainQuotaStatePatch(state, storage) {
     state.main = state.main ?? {};
@@ -877,13 +939,27 @@ export async function setFastModePersistentEnabled(enabled, path = getAccountSto
 export async function setCacheKeepPersistentWindow(startHour, endHour, path = getAccountStoragePath()) {
     const storage = (await loadAccounts(path)) ?? createEmptyStorage();
     storage.cacheKeep = {
+        ...(storage.cacheKeep ?? {}),
         enabled: true,
+        always: false,
         startHour,
         endHour,
     };
     await saveAccounts(storage, path);
     return storage;
 }
+export async function setCacheKeepPersistentAlways(path = getAccountStoragePath()) {
+    const storage = (await loadAccounts(path)) ?? createEmptyStorage();
+    storage.cacheKeep = {
+        ...(storage.cacheKeep ?? {}),
+        enabled: true,
+        always: true,
+    };
+    delete storage.cacheKeep.startHour;
+    delete storage.cacheKeep.endHour;
+    await saveAccounts(storage, path);
+    return storage;
+}
 export async function setCacheKeepPersistentEnabled(enabled, path = getAccountStoragePath()) {
     const storage = (await loadAccounts(path)) ?? createEmptyStorage();
     storage.cacheKeep = {
@@ -911,7 +987,7 @@ function getFallbackStatuses(storage) {
 export function shouldFallbackStatus(status, storage) {
     return getFallbackStatuses(storage).includes(status);
 }
-function normalizeThresholds(storage) {
+export function getQuotaMinimumRemainingThresholds(storage) {
     const configured = storage?.quota?.minimumRemaining || {};
     return {
         five_hour: configured.five_hour ??
@@ -1141,7 +1217,7 @@ export function quotaSnapshotPassesModelScope(quota, model) {
 export function quotaSnapshotPassesPolicy(quota, storage) {
     if (!quotaEnabled(storage))
         return true;
-    const thresholds = normalizeThresholds(storage);
+    const thresholds = getQuotaMinimumRemainingThresholds(storage);
     for (const key of ['five_hour', 'seven_day']) {
         const window = quota?.[key];
         if (!window)
@@ -1293,8 +1369,9 @@ export async function removeAccountPersistent(id, path = getAccountStoragePath()
     if (!storage)
         return false;
     const existed = removeAccount(storage, id);
-    if (existed)
-        await saveAccounts(storage, path);
+    if (existed) {
+        await saveAccounts(storage, path, { removedAccountIds: [id] });
+    }
     return existed;
 }
 export async function reorderAccountsPersistent(orderedIds, path = getAccountStoragePath()) {
@@ -1302,7 +1379,7 @@ export async function reorderAccountsPersistent(orderedIds, path = getAccountSto
     if (!storage)
         return;
     reorderAccounts(storage, orderedIds);
-    await saveAccounts(storage, path);
+    await saveAccounts(storage, path, { preserveExistingAccountOrder: false });
 }
 export async function setAccountEnabledPersistent(id, enabled, path = getAccountStoragePath()) {
     const storage = await loadAccounts(path);
@@ -1321,7 +1398,7 @@ export async function addAccountPersistent(account, path = getAccountStoragePath
 export function getQuotaNextRefreshAt(quota, storage, now) {
     if (!quotaEnabled(storage))
         return now + getQuotaCheckIntervalMs(storage);
-    const thresholds = normalizeThresholds(storage);
+    const thresholds = getQuotaMinimumRemainingThresholds(storage);
     const blockedResetTimes = [];
     for (const key of ['five_hour', 'seven_day']) {
         const window = quota?.[key];
@@ -1353,8 +1430,11 @@ function quotaSnapshotIsFresh(quota, storage, now) {
         return Boolean(window && now - window.checkedAt < maxAge);
     });
 }
-function quotaIsStale(account, storage, now) {
-    return !quotaSnapshotIsFresh(account.quota, storage, now);
+function quotaIsStale(account, storage, now, modelId) {
+    if (!quotaSnapshotIsFresh(account.quota, storage, now))
+        return true;
+    const scoped = getScopedQuotaWindowForModel(account.quota, modelId);
+    return Boolean(scoped && now - scoped.checkedAt >= getQuotaCheckIntervalMs(storage));
 }
 function cachedQuotaWindowStillRelevant(window, now) {
     if (!window)
@@ -1656,8 +1736,8 @@ export class FallbackAccountManager {
                 }
                 this.seedFallbackQuota(next, storage);
                 const stale = this.quotaManager
-                    ? this.quotaManager.isFallbackStale(next.id, next.access)
-                    : quotaIsStale(next, storage, this.now());
+                    ? this.quotaManager.isFallbackStale(next.id, next.access, options.modelId)
+                    : quotaIsStale(next, storage, this.now(), options.modelId);
                 // Skip the request-time refresh when this account's quota API is
                 // backed off (recent 429/5xx). Hitting it again would extend the
                 // backoff; evaluate policy on the cached/seeded quota instead. Mirrors

package/dist/cachekeep-registry.d.ts

@@ -0,0 +1,21 @@
+export declare const CACHE_KEEP_REGISTRY_LEASE_MS: number;
+export type CacheKeepTrackedSession = {
+    id: string;
+    cacheExpiresAt: number;
+    nextPrewarmAt: number;
+};
+export declare function getDefaultCacheKeepRegistryDirectory(scope: 'opencode' | 'pi'): string;
+export declare class CacheKeepSessionRegistry {
+    private readonly options;
+    private readonly filePath;
+    private writeChain;
+    constructor(options: {
+        directory: string;
+        now?: () => number;
+        leaseMs?: number;
+        instanceId?: string;
+    });
+    publish(sessions: readonly CacheKeepTrackedSession[]): Promise<void>;
+    list(localSessions?: readonly CacheKeepTrackedSession[]): Promise<CacheKeepTrackedSession[]>;
+    dispose(): Promise<void>;
+}

package/dist/cachekeep-registry.js

@@ -0,0 +1,124 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, readdir, readFile, rename, rm, writeFile, } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+export const CACHE_KEEP_REGISTRY_LEASE_MS = 3 * 60_000;
+function normalizeSession(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return;
+    const record = value;
+    if (typeof record.id !== 'string' ||
+        record.id.length === 0 ||
+        typeof record.cacheExpiresAt !== 'number' ||
+        !Number.isFinite(record.cacheExpiresAt) ||
+        typeof record.nextPrewarmAt !== 'number' ||
+        !Number.isFinite(record.nextPrewarmAt)) {
+        return;
+    }
+    return {
+        id: record.id,
+        cacheExpiresAt: record.cacheExpiresAt,
+        nextPrewarmAt: record.nextPrewarmAt,
+    };
+}
+function normalizeRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return;
+    const record = value;
+    if (record.version !== 1 ||
+        typeof record.updatedAt !== 'number' ||
+        !Number.isFinite(record.updatedAt) ||
+        !Array.isArray(record.sessions)) {
+        return;
+    }
+    return {
+        version: 1,
+        updatedAt: record.updatedAt,
+        sessions: record.sessions.flatMap((session) => {
+            const normalized = normalizeSession(session);
+            return normalized ? [normalized] : [];
+        }),
+    };
+}
+export function getDefaultCacheKeepRegistryDirectory(scope) {
+    return join(tmpdir(), 'opencode-anthropic-auth', 'cachekeep-sessions', scope);
+}
+export class CacheKeepSessionRegistry {
+    options;
+    filePath;
+    writeChain = Promise.resolve();
+    constructor(options) {
+        this.options = options;
+        const instanceId = options.instanceId ?? `${process.pid}-${randomUUID()}`;
+        this.filePath = join(options.directory, `${instanceId}.json`);
+    }
+    publish(sessions) {
+        const snapshot = sessions.map((session) => ({ ...session }));
+        this.writeChain = this.writeChain
+            .catch(() => { })
+            .then(async () => {
+            if (snapshot.length === 0) {
+                await rm(this.filePath, { force: true });
+                return;
+            }
+            await mkdir(this.options.directory, { recursive: true, mode: 0o700 });
+            const tempPath = `${this.filePath}.${randomUUID()}.tmp`;
+            const record = {
+                version: 1,
+                updatedAt: this.options.now?.() ?? Date.now(),
+                sessions: snapshot,
+            };
+            await writeFile(tempPath, `${JSON.stringify(record)}\n`, {
+                mode: 0o600,
+            });
+            await rename(tempPath, this.filePath);
+        });
+        return this.writeChain;
+    }
+    async list(localSessions = []) {
+        await this.writeChain.catch(() => { });
+        const now = this.options.now?.() ?? Date.now();
+        const leaseMs = this.options.leaseMs ?? CACHE_KEEP_REGISTRY_LEASE_MS;
+        let names;
+        try {
+            names = (await readdir(this.options.directory)).filter((name) => name.endsWith('.json'));
+        }
+        catch {
+            names = [];
+        }
+        const records = await Promise.all(names.map(async (name) => {
+            try {
+                const raw = await readFile(join(this.options.directory, name), 'utf8');
+                return normalizeRecord(JSON.parse(raw));
+            }
+            catch {
+                return undefined;
+            }
+        }));
+        const sessions = new Map();
+        for (const record of records) {
+            if (!record ||
+                now - record.updatedAt > leaseMs ||
+                record.updatedAt > now) {
+                continue;
+            }
+            for (const session of record.sessions) {
+                const existing = sessions.get(session.id);
+                if (!existing || session.cacheExpiresAt > existing.cacheExpiresAt) {
+                    sessions.set(session.id, session);
+                }
+            }
+        }
+        for (const session of localSessions) {
+            const existing = sessions.get(session.id);
+            if (!existing || session.cacheExpiresAt > existing.cacheExpiresAt) {
+                sessions.set(session.id, { ...session });
+            }
+        }
+        return [...sessions.values()].sort((left, right) => left.id.localeCompare(right.id));
+    }
+    async dispose() {
+        await this.writeChain.catch(() => { });
+        await rm(this.filePath, { force: true });
+    }
+}

package/dist/cachekeep.d.ts

@@ -1,4 +1,5 @@
 import type { AccountStorage } from './accounts.ts';
+import type { CacheKeepTrackedSession } from './cachekeep-registry.ts';
 export declare const CLAUDE_CACHE_KEEP_COMMAND_NAME = "claude-cachekeep";
 export declare const CACHE_KEEP_TTL_MS: number;
 export declare const CACHE_KEEP_PREWARM_LEAD_MS: number;
@@ -16,6 +17,8 @@ export type CacheKeepCommandAction = {
     type: 'status';
 } | {
     type: 'disable';
+} | {
+    type: 'always';
 } | {
     type: 'window';
     startHour: number;
@@ -28,23 +31,29 @@ export type CacheKeepCommandAction = {
 };
 export type CacheKeepStatus = {
     enabled: boolean;
+    always?: boolean;
     window?: CacheKeepWindow;
     trackedSessions?: number;
+    trackedSessionDetails?: CacheKeepTrackedSession[];
     nextPrewarmAt?: number;
     hybridActive?: boolean;
 };
 export declare function parseCacheKeepCommandAction(input: string): CacheKeepCommandAction;
 export declare function getCacheKeepWindow(storage: AccountStorage | null): CacheKeepWindow | undefined;
+export declare function isCacheKeepAlways(storage: AccountStorage | null): boolean;
 export declare function isCacheKeepPersistentlyEnabled(storage: AccountStorage | null): boolean;
 export declare function isCacheKeepHybridActive(storage: AccountStorage | null): boolean;
 export declare function isWithinCacheKeepWindow(window: CacheKeepWindow | undefined, now?: Date): boolean;
+export declare function isCacheKeepActiveNow(storage: AccountStorage | null, now?: Date): boolean;
 export declare function localDayKey(now?: Date): string;
 export declare function buildCacheKeepStatusSummary(status: CacheKeepStatus): string;
 export declare function executeCacheKeepCommand(input: {
     argumentsText: string;
     enabled?: boolean;
+    always?: boolean;
     window?: CacheKeepWindow;
     trackedSessions?: number;
+    trackedSessionDetails?: CacheKeepTrackedSession[];
     nextPrewarmAt?: number;
     hybridActive?: boolean;
 }): string;
@@ -86,14 +95,20 @@ export declare class CacheKeepManager {
         now?: () => number;
         prewarmTimeoutMs?: number;
         prepareHeaders?: (headers: Headers, target: CacheKeepTarget) => Promise<Headers> | Headers;
+        onTrackedSessionsChanged?: (sessions: readonly CacheKeepTrackedSession[]) => Promise<void> | void;
     });
     start(): void;
     stop(): void;
-    stats(window?: CacheKeepWindow, now?: number): {
+    stats(window?: CacheKeepWindow, now?: number, always?: boolean): {
         trackedSessions: number;
         nextPrewarmAt: number | undefined;
     };
+    trackedSessions(): CacheKeepTrackedSession[];
+    trackedOAuthRoute(sessionId: string): {
+        oauthAccountId?: string;
+    } | undefined;
     trackedCount(): number;
+    private publishTrackedSessions;
     private totalBodyBytes;
     private evictOldestTarget;
     private pruneTargets;

package/dist/cachekeep.js

@@ -14,7 +14,7 @@ const STATUS_TITLE = '## Claude Cache Keep Status';
 const ENABLED_TITLE = '## Claude Cache Keep Enabled';
 const DISABLED_TITLE = '## Claude Cache Keep Disabled';
 const USAGE_TITLE = '## Claude Cache Keep Usage';
-const USAGE = 'Usage: `/claude-cachekeep`, `/claude-cachekeep off`, or `/claude-cachekeep HH-HH`.';
+const USAGE = 'Usage: `/claude-cachekeep`, `/claude-cachekeep always`, `/claude-cachekeep off`, or `/claude-cachekeep HH-HH`.';
 function padHour(hour) {
     return String(hour).padStart(2, '0');
 }
@@ -24,6 +24,8 @@ export function parseCacheKeepCommandAction(input) {
         return { type: 'status' };
     if (trimmed === 'off')
         return { type: 'disable' };
+    if (trimmed === 'always')
+        return { type: 'always' };
     if (trimmed === 'subagents on')
         return { type: 'subagents', enabled: true };
     if (trimmed === 'subagents off')
@@ -58,8 +60,12 @@ export function getCacheKeepWindow(storage) {
     }
     return { startHour, endHour };
 }
+export function isCacheKeepAlways(storage) {
+    return (storage?.cacheKeep?.enabled === true && storage.cacheKeep.always === true);
+}
 export function isCacheKeepPersistentlyEnabled(storage) {
-    return storage?.cacheKeep?.enabled === true && !!getCacheKeepWindow(storage);
+    return (storage?.cacheKeep?.enabled === true &&
+        (isCacheKeepAlways(storage) || !!getCacheKeepWindow(storage)));
 }
 export function isCacheKeepHybridActive(storage) {
     return (isCacheKeepPersistentlyEnabled(storage) &&
@@ -75,6 +81,12 @@ export function isWithinCacheKeepWindow(window, now = new Date()) {
     }
     return hour >= window.startHour || hour < window.endHour;
 }
+export function isCacheKeepActiveNow(storage, now = new Date()) {
+    if (storage?.cacheKeep?.enabled !== true)
+        return false;
+    return (isCacheKeepAlways(storage) ||
+        isWithinCacheKeepWindow(getCacheKeepWindow(storage), now));
+}
 export function localDayKey(now = new Date()) {
     return `${now.getFullYear()}-${padHour(now.getMonth() + 1)}-${padHour(now.getDate())}`;
 }
@@ -88,13 +100,18 @@ function localWindowKey(window, now = new Date()) {
     }
     return localDayKey(now);
 }
+function cacheKeepPeriodKey(storage, window, now = new Date()) {
+    return isCacheKeepAlways(storage) ? 'always' : localWindowKey(window, now);
+}
 export function buildCacheKeepStatusSummary(status) {
-    const window = status.window
-        ? `${padHour(status.window.startHour)}-${padHour(status.window.endHour)}`
-        : 'not configured';
+    const schedule = status.always
+        ? 'always (while this process is running)'
+        : status.window
+            ? `${padHour(status.window.startHour)}-${padHour(status.window.endHour)}`
+            : 'not configured';
     const lines = [
         `Cache keep: ${status.enabled ? 'enabled' : 'disabled'}`,
-        `Window: ${window}`,
+        `Schedule: ${schedule}`,
         'Mode requirement: `/claude-cache mode hybrid` must be active.',
     ];
     if (typeof status.hybridActive === 'boolean') {
@@ -103,6 +120,12 @@ export function buildCacheKeepStatusSummary(status) {
     if (typeof status.trackedSessions === 'number') {
         lines.push(`Tracked sessions: ${status.trackedSessions}`);
     }
+    if (status.trackedSessionDetails?.length) {
+        lines.push('Sessions:');
+        for (const session of status.trackedSessionDetails) {
+            lines.push(`- ${session.id}`);
+        }
+    }
     if (status.nextPrewarmAt) {
         lines.push(`Next prewarm: ${new Date(status.nextPrewarmAt).toLocaleString()}`);
     }
@@ -112,8 +135,10 @@ export function executeCacheKeepCommand(input) {
     const action = parseCacheKeepCommandAction(input.argumentsText);
     const status = {
         enabled: input.enabled ?? false,
+        always: input.always,
         window: input.window,
         trackedSessions: input.trackedSessions,
+        trackedSessionDetails: input.trackedSessionDetails,
         nextPrewarmAt: input.nextPrewarmAt,
         hybridActive: input.hybridActive,
     };
@@ -127,6 +152,18 @@ export function executeCacheKeepCommand(input) {
             buildCacheKeepStatusSummary({ ...status, enabled: false }),
         ].join('\n');
     }
+    if (action.type === 'always') {
+        return [
+            ENABLED_TITLE,
+            '',
+            buildCacheKeepStatusSummary({
+                ...status,
+                enabled: true,
+                always: true,
+                window: undefined,
+            }),
+        ].join('\n');
+    }
     if (action.type === 'window') {
         return [
             ENABLED_TITLE,
@@ -134,6 +171,7 @@ export function executeCacheKeepCommand(input) {
             buildCacheKeepStatusSummary({
                 ...status,
                 enabled: true,
+                always: false,
                 window: { startHour: action.startHour, endHour: action.endHour },
             }),
         ].join('\n');
@@ -218,17 +256,47 @@ export class CacheKeepManager {
         clearInterval(this.timer);
         this.timer = null;
     }
-    stats(window, now = this.options.now?.() ?? Date.now()) {
-        const today = localWindowKey(window, new Date(now));
+    stats(window, now = this.options.now?.() ?? Date.now(), always = false) {
+        const today = always ? 'always' : localWindowKey(window, new Date(now));
         const targets = [...this.targets.values()].filter((target) => target.dayKey === today);
         const nextPrewarmAt = targets.length
             ? Math.min(...targets.map((target) => target.cacheExpiresAt - CACHE_KEEP_PREWARM_LEAD_MS))
             : undefined;
         return { trackedSessions: targets.length, nextPrewarmAt };
     }
+    trackedSessions() {
+        return [...this.targets.values()]
+            .map((target) => ({
+            id: target.id,
+            cacheExpiresAt: target.cacheExpiresAt,
+            nextPrewarmAt: target.cacheExpiresAt - CACHE_KEEP_PREWARM_LEAD_MS,
+        }))
+            .sort((left, right) => left.id.localeCompare(right.id));
+    }
+    trackedOAuthRoute(sessionId) {
+        const target = this.targets.get(sessionId);
+        return target ? { oauthAccountId: target.oauthAccountId } : undefined;
+    }
     trackedCount() {
         return this.targets.size;
     }
+    publishTrackedSessions() {
+        const callback = this.options.onTrackedSessionsChanged;
+        if (!callback)
+            return;
+        try {
+            void Promise.resolve(callback(this.trackedSessions())).catch((error) => {
+                logger.warn('cachekeep', 'failed to publish tracked sessions', {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            });
+        }
+        catch (error) {
+            logger.warn('cachekeep', 'failed to publish tracked sessions', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
     totalBodyBytes() {
         return [...this.targets.values()].reduce((sum, target) => sum + target.bodyText.length, 0);
     }
@@ -270,10 +338,10 @@ export class CacheKeepManager {
         }
         const now = this.options.now?.() ?? Date.now();
         const window = getCacheKeepWindow(input.storage);
-        if (!isWithinCacheKeepWindow(window, new Date(now))) {
-            return { tracked: false, reason: 'outside configured window' };
+        if (!isCacheKeepActiveNow(input.storage, new Date(now))) {
+            return { tracked: false, reason: 'outside configured schedule' };
         }
-        const today = localWindowKey(window, new Date(now));
+        const today = cacheKeepPeriodKey(input.storage, window, new Date(now));
         this.pruneTargets(now, today);
         if (this.targets.has(input.sessionId))
             this.targets.delete(input.sessionId);
@@ -291,6 +359,7 @@ export class CacheKeepManager {
             oauthAccountId: input.oauthAccountId,
         });
         this.pruneTargets(now, today);
+        this.publishTrackedSessions();
         this.start();
         return { tracked: true };
     }
@@ -314,16 +383,25 @@ export class CacheKeepManager {
         const storage = await this.options.loadStorage();
         const window = getCacheKeepWindow(storage);
         const now = this.options.now?.() ?? Date.now();
-        const today = localWindowKey(window, new Date(now));
+        const today = cacheKeepPeriodKey(storage, window, new Date(now));
+        if (isCacheKeepAlways(storage)) {
+            for (const target of this.targets.values())
+                target.dayKey = 'always';
+        }
         this.pruneTargets(now, today);
         if (!this.targets.size) {
+            this.publishTrackedSessions();
             this.stop();
             return;
         }
-        if (!isCacheKeepHybridActive(storage))
+        if (!isCacheKeepHybridActive(storage)) {
+            this.publishTrackedSessions();
             return;
-        if (!isWithinCacheKeepWindow(window, new Date(now)))
+        }
+        if (!isCacheKeepActiveNow(storage, new Date(now))) {
+            this.publishTrackedSessions();
             return;
+        }
         logger.debug('cachekeep', 'fired', { targets: this.targets.size });
         const dueAt = now + CACHE_KEEP_PREWARM_LEAD_MS;
         for (const target of this.targets.values()) {
@@ -331,6 +409,7 @@ export class CacheKeepManager {
                 continue;
             await this.prewarm(target, now);
         }
+        this.publishTrackedSessions();
     }
     async sendPrewarm(target) {
         const prewarm = await buildCacheKeepPrewarmBody(target.bodyText);