@teamvibe/poller 0.8.6-rc.2 → 0.8.6-rc.4

package/dist/claude-quota.js

@@ -21,10 +21,11 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */
+import { normalizePassiveUsage, projectLegacyFableUsage } from './subscription-selection.js';
 // Selectively adapted from Paperclip AI (MIT), Copyright (c) 2025 Paperclip AI.
 // https://github.com/paperclipai/paperclip/blob/cc88b61c0918f45f6d3215f5d2d2368c88297046/packages/adapters/claude-local/src/server/parse.ts#L24-L30
 // Excludes generic rate limits, extra-usage suggestions and AWS service quotas.
-const QUOTA_RE = /(?:you(?:'|’)ve\s+hit\s+your\s+(?:(?:usage|weekly|session|sonnet|opus|haiku)\s+)?limit\b(?!\s+of\b)|session\s+limit\s+(?:reached|exceeded)|out\s+of\s+extra\s+usage|(?:claude\s+)?usage\s+(?:limit|cap)\s+reached|5[-\s]?hour\s+limit\s+reached|weekly\s+limit\s+reached)/i;
+const QUOTA_RE = /(?:you(?:'|’)ve\s+hit\s+your\s+(?:(?:usage|weekly|session|sonnet|opus|haiku|fable)\s+)?limit\b(?!\s+of\b)|session\s+limit\s+(?:reached|exceeded)|out\s+of\s+extra\s+usage|(?:claude\s+)?usage\s+(?:limit|cap)\s+reached|5[-\s]?hour\s+limit\s+reached|weekly\s+limit\s+reached)/i;
 function record(value) {
     return value !== null && typeof value === 'object' ? value : {};
 }
@@ -82,27 +83,33 @@ export function parseClaudeQuotaFailure(input, now) {
                     : /out\s+of\s+extra\s+usage/i.test(evidence) ? 'extra_usage'
                         : 'usage_limit';
             // Scope is adjacent to this exhausted limit, never unrelated advice.
-            const model = diagnostic.slice(evidence.length).match(/^\s+(?:for|on)\s+(?:model\s+)?((?:claude-)?(?:sonnet|opus|haiku)(?:-\d+)*)(?![\w-])/i)?.[1]?.toLowerCase()
-                ?? evidence.match(/your\s+((?:claude-)?(?:sonnet|opus|haiku)(?:-\d+)*)\s+limit/i)?.[1]?.toLowerCase();
+            const model = diagnostic.slice(evidence.length).match(/^\s+(?:for|on)\s+(?:model\s+)?((?:claude-)?(?:sonnet|opus|haiku|fable)(?:-\d+)*)(?![\w-])/i)?.[1]?.toLowerCase()
+                ?? evidence.match(/your\s+((?:claude-)?(?:sonnet|opus|haiku|fable)(?:-\d+)*)\s+limit/i)?.[1]?.toLowerCase();
             const window = reason === 'weekly_limit' ? 'seven_day'
                 : reason === 'session_limit' || /5[-\s]?hour/i.test(evidence) ? 'five_hour' : undefined;
             const resetPrefix = diagnostic.slice(evidence.length).split(/\bresets?\b/i)[0] ?? '';
             // Another named window/model before "resets" makes that reset unrelated
             // or ambiguous. Strip only the directly attached model scope first.
-            const scopePrefix = resetPrefix.replace(/^\s+(?:for|on)\s+(?:model\s+)?(?:claude-)?(?:sonnet|opus|haiku)(?:-\d+)*(?![\w-])/i, '');
-            const unrelatedAllowance = /\b(?:5[-\s]?hour|five[-\s]?hour|weekly|seven[-\s]?day|session|(?:claude-)?(?:sonnet|opus|haiku)(?:-\d+)*)\b/i.test(scopePrefix);
+            const scopePrefix = resetPrefix.replace(/^\s+(?:for|on)\s+(?:model\s+)?(?:claude-)?(?:sonnet|opus|haiku|fable)(?:-\d+)*(?![\w-])/i, '');
+            const unrelatedAllowance = /\b(?:5[-\s]?hour|five[-\s]?hour|weekly|seven[-\s]?day|session|(?:claude-)?(?:sonnet|opus|haiku|fable)(?:-\d+)*)\b/i.test(scopePrefix);
             const resetAt = unrelatedAllowance ? undefined : parseResetAt(diagnostic, now);
             return [{ reason, ...(window ? { window } : {}), ...(model ? { modelScope: model } : {}), ...(resetAt ? { resetAt } : {}) }];
         });
     }));
     // Detailed weekly evidence beats a generic message, but its unknown reset
     // stays unknown; no search through the other candidates for a timestamp.
-    const quota = candidates.find(candidate => candidate.reason === 'weekly_limit') ?? candidates[0];
+    let quota = candidates.find(candidate => candidate.reason === 'weekly_limit') ?? candidates[0];
     if (!quota)
         return undefined;
     // Global windows cannot establish the reset of a model-specific allowance.
     // Prefer structured metadata for the exact text-classified window only.
     const info = input.rateLimitInfo;
+    if (info?.status === 'rejected' && !quota.modelScope) {
+        const windows = projectLegacyFableUsage(normalizePassiveUsage(info, now.getTime())).windows;
+        const rejected = windows.find(w => w.status === 'rejected');
+        if (rejected && rejected.scope !== 'global' && rejected.scope !== 'uncertain' && (!quota.window || quota.window === rejected.window))
+            quota = { ...quota, window: rejected.window, modelScope: rejected.scope, ...(rejected.resetAt && rejected.resetAt > now.getTime() ? { resetAt: new Date(rejected.resetAt).toISOString() } : {}) };
+    }
     if (quota.window && !quota.modelScope && info) {
         const matching = info.unifiedWindows?.[quota.window];
         // An explicitly present window with an unknown reset stays unknown;

package/dist/claude-spawner.js

@@ -1,5 +1,6 @@
+import { blockingUsageWindows, normalizePassiveUsage, selectSubscriptionAccount } from './subscription-selection.js';
 import { logPoolFetch, logPoolUsageWrite, poolInfo, poolLabel } from './pool-logging.js';
-import { accountUsageTelemetry, emitCandidateUsage, poolRunTelemetry } from './pool-telemetry.js';
+import { emitPoolSelection, accountUsageTelemetry, emitCandidateUsage, poolRunTelemetry } from './pool-telemetry.js';
 import { spawn } from 'child_process';
 import { join } from 'path';
 import { readFileSync, existsSync } from 'fs';
@@ -1046,6 +1047,8 @@ async function runClaudeCode(msg, sessionLog, cwd, directory, sessionId, isFirst
         activeProcessesByThread.set(msg.thread_id, proc);
         if (runtime?.account)
             activeSubscriptionAccounts.set(proc, runtime.account);
+        if (proc.pid !== undefined)
+            runtime?.onSpawn?.();
         for (const chunk of spawnStdinPlan.stdinChunks) {
             proc.stdin?.write(chunk);
         }
@@ -1579,7 +1582,31 @@ export async function spawnPoolClaudeCode(msg, sessionLog, selectedDirectory, se
         const prepared = poolRuntime ? await preparePool(msg, resolved, poolRuntime.pin, fetchedPool, sessionLog, { cliPath: config.CLAUDE_CLI_PATH, isAtCapacity, emit: emitEvent, log: line => sessionLog.info(line) }) : undefined;
         const modelNormalizedFrom = scoped?.model === resolved.model && scoped?.modelSource === resolved.modelSource
             ? scoped?.modelNormalizedFrom : undefined;
-        const runtime = poolRuntime ? { resolved, modelNormalizedFrom, claudeConfigDir, account: prepared?.account, shouldStop: poolRuntime.shouldStop, resumePending: fetchedPool?.kind !== 'no_accounts_configured' && poolRuntime.pin?.resumePending === true } : undefined;
+        const runtime = poolRuntime ? {
+            resolved, modelNormalizedFrom, claudeConfigDir, account: prepared?.account,
+            shouldStop: poolRuntime.shouldStop,
+            resumePending: fetchedPool?.kind !== 'no_accounts_configured' && poolRuntime.pin?.resumePending === true,
+            onSpawn: () => {
+                if (prepared?.selection) {
+                    emitPoolSelection(msg, prepared.selection);
+                    // Retries report each launch, but release the original pin only once.
+                    delete prepared.selection.switch;
+                }
+            },
+        } : undefined;
+        const rejectedForModel = (info) => {
+            if (!prepared?.account || info?.status !== 'rejected')
+                return false;
+            const now = Date.now();
+            return blockingUsageWindows(prepared.account, { usage: normalizePassiveUsage(info, now) }, resolved.model, now).some(w => w.status === 'rejected');
+        };
+        const quotaForModel = (quota) => {
+            if (!quota || !prepared?.account)
+                return quota;
+            const now = Date.now();
+            const selected = selectSubscriptionAccount({ pool: { kind: 'ready', accounts: [prepared.account] }, states: { [prepared.account.accountId]: { reactive: [{ observedAt: now, quota }] } }, model: resolved.model, now });
+            return selected.kind === 'deferred' ? quota : undefined;
+        };
         let sawSendMessageCall = poolRuntime?.pin?.resumePending === true && poolRuntime.pin.sawSendMessageCall === true;
         const attempt = async (id, first) => {
             if (prepared?.account && id && poolRuntime) {
@@ -1595,8 +1622,8 @@ export async function spawnPoolClaudeCode(msg, sessionLog, selectedDirectory, se
             if (!runtime?.resumePending)
                 sawSendMessageCall = false;
             const spawned = await runClaudeCode(msg, sessionLog, effectiveCwd, directory, id, runtime?.resumePending ? false : first, lastMessageTs, onMessageSent, typingIndicator, runtime);
-            const result = prepared?.account && spawned.rateLimitInfo?.status === 'rejected'
-                ? { ...spawned, success: false } : spawned;
+            const result = prepared?.account
+                ? { ...spawned, quota: quotaForModel(spawned.quota), success: rejectedForModel(spawned.rateLimitInfo) ? false : spawned.success } : spawned;
             sawSendMessageCall ||= result.sawSendMessageCall === true;
             if (prepared?.account) {
                 if (poolAttempts.length >= 1000)
@@ -1630,7 +1657,7 @@ export async function spawnPoolClaudeCode(msg, sessionLog, selectedDirectory, se
                     retainWorktree = false;
                     return result;
                 }
-                if ((result.quota || result.rateLimitInfo?.status === 'rejected') && !result.killedByPoller) {
+                if ((result.quota || rejectedForModel(result.rateLimitInfo)) && !result.killedByPoller) {
                     runtime.resumePending = true;
                     retainWorktree = true;
                 }
@@ -1654,7 +1681,7 @@ export async function spawnPoolClaudeCode(msg, sessionLog, selectedDirectory, se
         let switched = false;
         const finishQuota = async (initial) => {
             let result = initial;
-            while (prepared?.account && (result.quota || result.rateLimitInfo?.status === 'rejected') && !result.killedByPoller && poolRuntime && runtime) {
+            while (prepared?.account && (result.quota || rejectedForModel(result.rateLimitInfo)) && !result.killedByPoller && poolRuntime && runtime) {
                 attemptedAccounts.add(prepared.account.accountId);
                 if (poolRuntime.shouldStop())
                     throw new PoolDeferredError('infrastructure', { suppressNotice: true });
@@ -1689,6 +1716,12 @@ export async function spawnPoolClaudeCode(msg, sessionLog, selectedDirectory, se
                 abortLocalProbe(selected.account);
                 poolInfo(sessionLog, `switch from=${poolLabel(fromAccount)} to=${poolLabel(selected.account)} session=${JSON.stringify(effectiveSessionId)}`);
                 prepared.account = selected.account;
+                selected.candidates = [
+                    ...(selected.candidates ?? []).filter(c => !attemptedAccounts.has(c.accountId)),
+                    ...(prepared.pool.kind === 'ready' ? prepared.pool.accounts.filter(a => attemptedAccounts.has(a.accountId)).map(a => ({ accountId: a.accountId, accountLabel: JSON.parse(poolLabel(a)), outcome: 'skipped', reason: 'already exhausted in this session' })) : []),
+                ];
+                if (prepared.pool.kind === 'ready' && prepared.pool.accounts.some(a => a.accountId === fromAccount.accountId))
+                    selected.switch = { fromAccountId: fromAccount.accountId, reason: 'reactive quota' };
                 prepared.selection = selected;
                 runtime.account = selected.account;
                 runtime.resumePending = true;

package/dist/poller.js

@@ -11,7 +11,7 @@ import { spawnClaudeCode, spawnPoolClaudeCode, isAtCapacity, getActiveProcessCou
 import { sendSlackError, sendSlackMessage, addReaction, getUserInfo, startTypingIndicator } from './slack-client.js';
 import { classifyFailedIteration } from './classify-failed-iteration.js';
 import { fetchSecretsForSpawn } from './secrets-client.js';
-import { PoolDeferredError, fetchRuntimePool, subscriptionUsageStore } from './subscription-runtime.js';
+import { PoolDeferredError, fetchRuntimePool, subscriptionUsageStore, HELD_PROBE_INTERVAL_MS } from './subscription-runtime.js';
 import { POOL_RECHECK_MS } from './subscription-selection.js';
 import { isPoolDeferred, readPoolDefer, deferPool, setPoolNotice, clearPoolDefer } from './pool-defer.js';
 import { isQuotaPaused, pauseForQuota, clearQuotaPauseAfterSuccess, QuotaPausedError } from './quota-pause.js';
@@ -617,7 +617,10 @@ export async function runInboxLoop(threadId, selectedDirectory, queueMessage, se
                     }
                     quotaPaused = true;
                     deferred = true;
-                    const pause = deferPool(threadId, error.eligibleAt, error.resetAt);
+                    // Revisit held work hourly so background probes can refresh the account.
+                    // Selection still enforces each window's real reset before inference.
+                    const recheckAt = error.cause === 'usage' ? Math.min(error.eligibleAt, Date.now() + HELD_PROBE_INTERVAL_MS) : error.eligibleAt;
+                    const pause = deferPool(threadId, recheckAt, error.resetAt);
                     const retained = readInboxRuntime(kbPath, threadId);
                     // Rechecks of one exhaustion episode do not inflate the episode count.
                     quotaDeferEpisodes = Math.max(1, quotaDeferEpisodes);

package/dist/pool-logging.d.ts

@@ -14,6 +14,18 @@ export declare function poolErrorClass(error: unknown): string;
 /** Allowlisted class/code only: caught messages and arbitrary names may contain secrets. */
 export declare function poolErrorDiagnostic(error: unknown): string;
 export declare function logPoolFetch(log: PoolInfoLogger, pool: PoolFetchResult & PoolFetchDiagnostics): void;
+export interface PoolSelectionCandidate {
+    accountId: string;
+    accountLabel: string;
+    outcome: 'selected' | 'skipped';
+    reason: string;
+    score?: number;
+    headroom?: number;
+    rateWindow?: Pick<UsageWindow, 'window' | 'scope' | 'percent'>;
+    eligibleAt?: number;
+}
+/** The log and transport share a single explanation of the same selection snapshot. */
+export declare function poolSelectionCandidates<A extends LabeledAccount>(pool: PoolFetchResult<A>, states: Readonly<Record<string, AccountUsageState>>, model: string | undefined, now: number, selected: SelectionOutcome<A>): PoolSelectionCandidate[];
 export declare function logPoolSelection<A extends LabeledAccount>(log: PoolInfoLogger, pool: PoolFetchResult<A>, states: Readonly<Record<string, AccountUsageState>>, model: string | undefined, now: number, selected: SelectionOutcome<A>, logAllExhausted?: boolean): void;
 export declare function formatPoolUsageWindows(windows: readonly UsageWindow[], includeScope?: boolean): string;
 /** Log the real store promise without changing its rejection or retry behavior. */

package/dist/pool-logging.js

@@ -1,5 +1,5 @@
 import { redactStartupText } from './redact-text.js';
-import { normalizePassiveUsage, selectSubscriptionAccount } from './subscription-selection.js';
+import { normalizePassiveUsage, selectSubscriptionAccount, blockingUsageWindows } from './subscription-selection.js';
 import { safeRateLimitInfo } from './subscription-usage-store.js';
 // Never serialize accounts, credentials, provider strings or caught errors.
 // Labels have already been checked by the pool client; JSON quoting keeps
@@ -42,23 +42,37 @@ export function logPoolFetch(log, pool) {
     const configured = pool.kind === 'ready' || pool.kind === 'fetch_unavailable' && pool.reason === 'no_usable_accounts' ? 'true' : 'unknown';
     poolInfo(log, `fetch poolConfigured=${configured} enabled=${enabled} usable=${enabled} result=${pool.kind}${pool.kind === 'fetch_unavailable' ? ` reason=${pool.reason}` : ''}${pool.cause ? ` cause=${pool.cause}` : ''} attempts=${pool.attempts ?? 1}`);
 }
-export function logPoolSelection(log, pool, states, model, now, selected, logAllExhausted = true) {
+/** The log and transport share a single explanation of the same selection snapshot. */
+export function poolSelectionCandidates(pool, states, model, now, selected) {
     if (pool.kind !== 'ready')
-        return;
-    for (const account of pool.accounts) {
-        if (!account.enabled) {
-            poolInfo(log, `skipped account=${poolLabel(account)} reason=disabled`);
-            continue;
-        }
+        return [];
+    return pool.accounts.map(account => {
+        const base = { accountId: account.accountId, accountLabel: JSON.parse(poolLabel(account)), outcome: 'skipped' };
+        if (!account.enabled)
+            return { ...base, reason: 'disabled' };
         const candidate = selectSubscriptionAccount({ pool: { ...pool, accounts: [account] }, states, model, now });
         if (candidate.kind === 'deferred') {
             const usageOnly = selectSubscriptionAccount({ pool: { ...pool, accounts: [account] }, states: { [account.accountId]: { usage: states[account.accountId]?.usage } }, model, now });
-            poolInfo(log, `skipped account=${poolLabel(account)} reason=${usageOnly.kind === 'deferred' ? `usage >=${account.useFullQuota ? 100 : 90}%` : 'reactive quota'} eligibleAt=${new Date(candidate.eligibleAt).toISOString()}`);
-        }
-        else if (candidate.kind === 'selected' && selected.kind === 'selected' && account.accountId !== selected.account.accountId) {
-            const reason = candidate.provenance === 'unknown' && selected.provenance === 'known' ? 'known observation preferred' : candidate.provenance === 'known' && selected.provenance === 'known' && candidate.score < selected.score ? 'lower headroom per hour' : 'deterministic account order';
-            poolInfo(log, `skipped account=${poolLabel(account)} reason=${reason}`);
+            const window = blockingUsageWindows(account, states[account.accountId], model, now)[0];
+            return { ...base, ...(window ? { rateWindow: { window: window.window, scope: window.scope, percent: window.percent } } : {}), reason: usageOnly.kind === 'deferred' ? `usage >=${account.useFullQuota ? 100 : 90}%` : 'reactive quota', eligibleAt: candidate.eligibleAt };
         }
+        const metrics = candidate.kind === 'selected' && candidate.provenance === 'known'
+            ? { score: candidate.score, headroom: (account.useFullQuota ? 100 : 90) - candidate.rateWindow.percent, rateWindow: { window: candidate.rateWindow.window, scope: candidate.rateWindow.scope, percent: candidate.rateWindow.percent } } : {};
+        if (selected.kind === 'selected' && account.accountId === selected.account.accountId)
+            return { ...base, ...metrics, outcome: 'selected', reason: 'selected' };
+        const reason = candidate.kind === 'selected' && selected.kind === 'selected'
+            ? candidate.provenance === 'unknown' && selected.provenance === 'known' ? 'known observation preferred' : candidate.provenance === 'known' && selected.provenance === 'known' && candidate.score < selected.score ? 'lower headroom per hour' : 'deterministic account order'
+            : 'unavailable';
+        return { ...base, ...metrics, reason };
+    });
+}
+export function logPoolSelection(log, pool, states, model, now, selected, logAllExhausted = true) {
+    if (pool.kind !== 'ready')
+        return;
+    for (const candidate of poolSelectionCandidates(pool, states, model, now, selected)) {
+        if (candidate.outcome !== 'skipped' || candidate.reason === 'unavailable')
+            continue;
+        poolInfo(log, `skipped account=${JSON.stringify(candidate.accountLabel)} reason=${candidate.reason}${candidate.eligibleAt !== undefined && candidate.rateWindow ? ` window=${candidate.rateWindow.window}/${candidate.rateWindow.scope}` : ''}${candidate.eligibleAt === undefined ? '' : ` eligibleAt=${new Date(candidate.eligibleAt).toISOString()}`}`);
     }
     if (selected.kind === 'deferred' && logAllExhausted) {
         // Ask the same policy about each observation so model scope, freshness and

package/dist/pool-telemetry.d.ts

@@ -60,3 +60,5 @@ export declare function poolRunTelemetry(attempts: readonly PoolAttempt[], quota
     model?: string | undefined;
     observedAt?: number | undefined;
 };
+/** Labels and explicit decision metrics only; never spread account or credential objects. */
+export declare function emitPoolSelection(msg: TeamVibeQueueMessage, selection: import('./subscription-pool.js').ResolvedPoolSelection<SubscriptionAccount>): void;

package/dist/pool-telemetry.js

@@ -1,5 +1,5 @@
 import { emitEvent } from './event-queue.js';
-import { reactiveEligibleAt } from './subscription-selection.js';
+import { family, reactiveEligibleAt } from './subscription-selection.js';
 import { usageStateForSelection, safeQuota, safeRateLimitInfo, } from './subscription-usage-store.js';
 function safeText(value) {
     return value && value.length <= 128 && !/sk-ant-|Bearer\s|[\r\n]/i.test(value)
@@ -123,3 +123,22 @@ export function poolRunTelemetry(attempts, quotaDeferEpisodes = 0) {
         attempts: safeAttempts,
     };
 }
+// Keep ordering across retries and intervening threads even within one clock tick.
+let lastSelectionAt = 0;
+/** Labels and explicit decision metrics only; never spread account or credential objects. */
+export function emitPoolSelection(msg, selection) {
+    if (selection.kind !== 'selected')
+        return;
+    lastSelectionAt = Math.max(Date.now(), lastSelectionAt + 1);
+    emitEvent('pool.selection', msg.teamvibe.channelId, {
+        workspaceId: msg.teamvibe.workspaceId,
+        threadId: msg.thread_id,
+        model: safeText(selection.model) ?? 'CLI default',
+        modelFamily: family(selection.model) ?? 'default',
+        selectedAccountId: selection.account.accountId,
+        selectedAccountLabel: safeText(selection.account.label) ?? 'unlabeled',
+        decidedAt: lastSelectionAt,
+        candidates: selection.candidates ?? [],
+        ...(selection.switch ? { switch: selection.switch } : {}),
+    });
+}

package/dist/subscription-pool.d.ts

@@ -1,4 +1,4 @@
-import { type PoolInfoLogger } from './pool-logging.js';
+import { type PoolSelectionCandidate, type PoolInfoLogger } from './pool-logging.js';
 import type { resolveModel } from './claude-spawner.js';
 import { type AccountIdentity, type PoolFetchResult, type SelectionOutcome } from './subscription-selection.js';
 import { type SubscriptionUsageStore } from './subscription-usage-store.js';
@@ -6,7 +6,13 @@ export type ResolvedPoolModel = ReturnType<typeof resolveModel>;
 export type ResolvedPoolSelection<A extends AccountIdentity> = (SelectionOutcome<A> | {
     kind: 'usage_unavailable';
     error: unknown;
-}) & ResolvedPoolModel;
+}) & ResolvedPoolModel & {
+    candidates?: PoolSelectionCandidate[];
+    switch?: {
+        fromAccountId: string;
+        reason: string;
+    };
+};
 /**
  * #405 integration seam: resolveModel ONCE before calling, then reuse the
  * returned model/modelSource for --model. No fetch, probe, spawn or env fallback

package/dist/subscription-pool.js

@@ -1,5 +1,5 @@
 import { logger } from './logger.js';
-import { logPoolSelection, poolInfo, poolLabel, poolErrorClass } from './pool-logging.js';
+import { logPoolSelection, poolSelectionCandidates, poolInfo, poolLabel, poolErrorClass } from './pool-logging.js';
 import { selectSubscriptionAccount } from './subscription-selection.js';
 import { usageStateForSelection } from './subscription-usage-store.js';
 /**
@@ -33,5 +33,5 @@ export async function selectPoolForResolvedModel(resolvedModel, input) {
     const selected = selectSubscriptionAccount({ pool: input.pool, states, model: resolvedModel.model, now: input.now, currentAccountId: input.currentAccountId, currentAccountTolerance: input.currentAccountTolerance });
     if (input.log)
         logPoolSelection(input.log, input.pool, states, resolvedModel.model, input.now, selected, input.logAllExhausted);
-    return { ...selected, ...resolvedModel };
+    return { ...selected, ...resolvedModel, candidates: poolSelectionCandidates(input.pool, states, resolvedModel.model, input.now, selected) };
 }

package/dist/subscription-runtime.d.ts

@@ -54,6 +54,8 @@ export declare function subscriptionUsageStore(): FileSubscriptionUsageStore;
 export declare function fetchRuntimePool(msg: TeamVibeQueueMessage): Promise<PoolFetchResult<SubscriptionAccount> & PoolFetchDiagnostics>;
 /** Minimum gap between local measurements of one workspace/account/credential. */
 export declare const LOCAL_PROBE_MIN_INTERVAL_MS = 60000;
+/** Refresh held accounts without turning quota rejection into a busy loop. */
+export declare const HELD_PROBE_INTERVAL_MS: number;
 /** Bound background CLI load across every workspace in this poller process. */
 export declare const LOCAL_PROBE_MAX_CONCURRENT = 3;
 /** A local measurement has its own deadline, independent of session lifetime. */
@@ -89,6 +91,12 @@ export declare function preparePool(msg: TeamVibeQueueMessage, resolved: Resolve
     } & HeadroomScore & {
         model: string | undefined;
         modelSource: import("./claude-spawner.js").ModelSource;
+    } & {
+        candidates?: import("./pool-logging.js").PoolSelectionCandidate[];
+        switch?: {
+            fromAccountId: string;
+            reason: string;
+        };
     }) | ({
         kind: "selected";
         account: SubscriptionAccount;
@@ -97,6 +105,12 @@ export declare function preparePool(msg: TeamVibeQueueMessage, resolved: Resolve
     } & {
         model: string | undefined;
         modelSource: import("./claude-spawner.js").ModelSource;
+    } & {
+        candidates?: import("./pool-logging.js").PoolSelectionCandidate[];
+        switch?: {
+            fromAccountId: string;
+            reason: string;
+        };
     });
 } | {
     account: undefined;

package/dist/subscription-runtime.js

@@ -10,7 +10,7 @@ import { getPollerId } from './auth-provider.js';
 import { fetchSubscriptionPool } from './subscription-pool-client.js';
 import { selectPoolForResolvedModel } from './subscription-pool.js';
 import { FileSubscriptionUsageStore, usageStateForSelection } from './subscription-usage-store.js';
-import { normalizePassiveUsage, selectSubscriptionAccount, usageWindowExpiresAt, reactiveEligibleAt, PIN_HEADROOM_SWITCH_RELATIVE, USAGE_THRESHOLD_PERCENT, POOL_RECHECK_MS } from './subscription-selection.js';
+import { normalizePassiveUsage, selectSubscriptionAccount, blockingUsageWindows, usageWindowExpiresAt, PIN_HEADROOM_SWITCH_RELATIVE, USAGE_THRESHOLD_PERCENT, POOL_RECHECK_MS } from './subscription-selection.js';
 export const POOL_UNAVAILABLE_RECHECK_MS = 60_000;
 export class PoolDeferredError extends Error {
     cause;
@@ -37,6 +37,8 @@ export async function fetchRuntimePool(msg) {
 }
 /** Minimum gap between local measurements of one workspace/account/credential. */
 export const LOCAL_PROBE_MIN_INTERVAL_MS = 60_000;
+/** Refresh held accounts without turning quota rejection into a busy loop. */
+export const HELD_PROBE_INTERVAL_MS = 60 * 60_000;
 /** Bound background CLI load across every workspace in this poller process. */
 export const LOCAL_PROBE_MAX_CONCURRENT = 3;
 /** A local measurement has its own deadline, independent of session lifetime. */
@@ -53,64 +55,87 @@ export function abortLocalProbe(account) {
     }
 }
 function probeUnknownAccounts(accounts, selectedAccountId, resolved, store, options, channelId) {
-    for (const account of accounts) {
-        if (!account.enabled || account.accountId === selectedAccountId || isSubscriptionAccountRunning(account))
-            continue;
-        // Fire-and-forget ALL probe work, including disk claims and cleanup. No
-        // session signal/shouldStop is passed: the observation outlives its trigger.
-        void (async () => {
-            const key = JSON.stringify([account.workspaceId, account.accountId, account.credentialVersion]);
-            let probe;
+    void (async () => {
+        const candidates = await Promise.all(accounts
+            .filter(account => account.enabled && account.accountId !== selectedAccountId && !isSubscriptionAccountRunning(account))
+            .map(async (account) => {
             try {
-                const now = Date.now();
-                const state = usageStateForSelection(await store.read(account), now);
-                const candidate = selectSubscriptionAccount({ pool: { kind: 'ready', accounts: [account] }, states: { [account.accountId]: state }, model: resolved.model, now });
-                if (candidate.kind !== 'selected' || candidate.provenance !== 'unknown')
-                    return;
-                if (isSubscriptionAccountRunning(account))
-                    return;
-                if (localProbesInFlight.has(key)) {
-                    poolInfo({ info: options.log }, `local probe account=${poolLabel(account)} result=skipped reason=claimed`);
-                    return;
-                }
-                if (options.isAtCapacity() || localProbesInFlight.size >= LOCAL_PROBE_MAX_CONCURRENT)
-                    return;
-                // Reserve before asynchronous claiming, so concurrent preparePool calls
-                // cannot exceed the process-wide limit while claims are being written.
-                probe = { account, controller: new AbortController() };
-                localProbesInFlight.set(key, probe);
-                const claimed = await store.claimLocalProbe(account, now, LOCAL_PROBE_MIN_INTERVAL_MS);
-                if (probe.controller.signal.aborted) {
-                    poolInfo({ info: options.log }, `local probe account=${poolLabel(account)} result=cancelled reason=account selected`);
-                    return;
-                }
-                if (!claimed) {
-                    poolInfo({ info: options.log }, `local probe account=${poolLabel(account)} result=skipped reason=claimed`);
-                    return;
-                }
-                // Capacity may change while the durable claim is written.
-                if (options.isAtCapacity()) {
-                    poolInfo({ info: options.log }, `local probe account=${poolLabel(account)} result=cli_at_capacity`);
-                    return;
-                }
-                await runUsageProbe(account, { ...options, model: resolved.model, timeoutMs: LOCAL_PROBE_TIMEOUT_MS }, {
-                    channelId, signal: probe.controller.signal,
-                    onMeasurementComplete: () => {
-                        if (localProbesInFlight.get(key) === probe)
-                            localProbesInFlight.delete(key);
-                    },
-                });
+                return { account, stored: await store.read(account) };
             }
             catch {
-                poolInfo({ info: options.log }, `local probe account=${poolLabel(account)} result=${probe?.controller.signal.aborted ? 'cancelled reason=account selected' : 'unknown'}`);
-            }
-            finally {
-                // An aborted run must not delete a newer reservation for the same key.
-                if (probe && localProbesInFlight.get(key) === probe)
-                    localProbesInFlight.delete(key);
+                poolInfo({ info: options.log }, `local probe account=${poolLabel(account)} result=unknown`);
+                return undefined;
             }
-        })();
-    }
+        }));
+        // Failed attempts still consume a durable claim. Prefer the oldest attempt
+        // so overflow eventually gets a slot, including after a poller restart.
+        const ordered = candidates.filter(candidate => candidate !== undefined)
+            .sort((a, b) => (a.stored.localProbeClaimedAt ?? 0) - (b.stored.localProbeClaimedAt ?? 0));
+        for (const { account, stored } of ordered) {
+            // Fire-and-forget ALL probe work, including disk claims and cleanup. No
+            // session signal/shouldStop is passed: the observation outlives its trigger.
+            void (async () => {
+                const key = JSON.stringify([account.workspaceId, account.accountId, account.credentialVersion]);
+                let probe;
+                try {
+                    const now = Date.now();
+                    const state = usageStateForSelection(stored, now);
+                    const candidate = selectSubscriptionAccount({ pool: { kind: 'ready', accounts: [account] }, states: { [account.accountId]: state }, model: resolved.model, now });
+                    const held = selectSubscriptionAccount({ pool: { kind: 'ready', accounts: [account] }, states: { [account.accountId]: state }, model: undefined, now }).kind === 'deferred';
+                    if (!held && (candidate.kind !== 'selected' || candidate.provenance !== 'unknown'))
+                        return;
+                    // A recent measurement already refreshed the picture. Durable claims
+                    // also rate-limit failed attempts and concurrent callers across restarts.
+                    const slow = held && !(candidate.kind === 'selected' && candidate.provenance === 'unknown');
+                    const interval = slow ? HELD_PROBE_INTERVAL_MS : LOCAL_PROBE_MIN_INTERVAL_MS;
+                    const observedAt = Math.max(0, ...blockingUsageWindows(account, state, undefined, now).map(w => w.observedAt ?? state.usage?.observedAt ?? 0));
+                    if (slow && now >= observedAt && now - observedAt < interval)
+                        return;
+                    if (isSubscriptionAccountRunning(account))
+                        return;
+                    if (localProbesInFlight.has(key)) {
+                        poolInfo({ info: options.log }, `local probe account=${poolLabel(account)} result=skipped reason=claimed`);
+                        return;
+                    }
+                    if (options.isAtCapacity() || localProbesInFlight.size >= LOCAL_PROBE_MAX_CONCURRENT)
+                        return;
+                    // Reserve before asynchronous claiming, so concurrent preparePool calls
+                    // cannot exceed the process-wide limit while claims are being written.
+                    probe = { account, controller: new AbortController() };
+                    localProbesInFlight.set(key, probe);
+                    const claimed = await store.claimLocalProbe(account, now, interval);
+                    if (probe.controller.signal.aborted) {
+                        poolInfo({ info: options.log }, `local probe account=${poolLabel(account)} result=cancelled reason=account selected`);
+                        return;
+                    }
+                    if (!claimed) {
+                        poolInfo({ info: options.log }, `local probe account=${poolLabel(account)} result=skipped reason=claimed`);
+                        return;
+                    }
+                    // Capacity may change while the durable claim is written.
+                    if (options.isAtCapacity()) {
+                        poolInfo({ info: options.log }, `local probe account=${poolLabel(account)} result=cli_at_capacity`);
+                        return;
+                    }
+                    await runUsageProbe(account, { ...options, model: resolved.model, timeoutMs: LOCAL_PROBE_TIMEOUT_MS }, {
+                        channelId, signal: probe.controller.signal,
+                        onMeasurementComplete: () => {
+                            if (localProbesInFlight.get(key) === probe)
+                                localProbesInFlight.delete(key);
+                        },
+                    });
+                }
+                catch {
+                    poolInfo({ info: options.log }, `local probe account=${poolLabel(account)} result=${probe?.controller.signal.aborted ? 'cancelled reason=account selected' : 'unknown'}`);
+                }
+                finally {
+                    // An aborted run must not delete a newer reservation for the same key.
+                    if (probe && localProbesInFlight.get(key) === probe)
+                        localProbesInFlight.delete(key);
+                }
+            })();
+        }
+    })();
 }
 export async function preparePool(msg, resolved, pin, fetched, log, probeOptions) {
     const pool = fetched ?? await fetchRuntimePool(msg);
@@ -121,18 +146,21 @@ export async function preparePool(msg, resolved, pin, fetched, log, probeOptions
     // A pin is a spawn-boundary preference. Reactive same-session switches keep
     // their existing strict ranking and do not receive this tolerance.
     const selected = await selectPoolForResolvedModel(resolved, { workspaceId: msg.teamvibe.workspaceId, pool, store, now: Date.now(), log, currentAccountId, currentAccountTolerance: PIN_HEADROOM_SWITCH_RELATIVE });
+    if (pool.kind === 'ready')
+        probeUnknownAccounts(pool.accounts, selected.kind === 'selected' ? selected.account.accountId : undefined, resolved, store, {
+            cliPath: config.CLAUDE_CLI_PATH, isAtCapacity, emit: emitEvent,
+            log: line => (log ?? logger).info(line), ...probeOptions, store,
+        }, msg.teamvibe.channelId);
     if (selected.kind === 'selected') {
         abortLocalProbe(selected.account);
-        if (log && pool.kind === 'ready' && currentAccountId && currentAccountId !== selected.account.accountId) {
+        if (pool.kind === 'ready' && currentAccountId && currentAccountId !== selected.account.accountId) {
             const previous = pool.accounts.find(a => a.accountId === currentAccountId);
             const previousSelection = previous ? await selectPoolForResolvedModel(resolved, { workspaceId: msg.teamvibe.workspaceId, pool: { kind: 'ready', accounts: [previous] }, store, now: Date.now() }) : undefined;
-            poolInfo(log, `switch from=${poolLabel(previous ?? {})} to=${poolLabel(selected.account)} reason=${previousSelection?.kind === 'selected' ? 'better headroom' : 'pinned account unavailable'}`);
+            if (previous)
+                selected.switch = { fromAccountId: currentAccountId, reason: previousSelection?.kind === 'selected' ? 'better headroom' : 'pinned account unavailable' };
+            if (log)
+                poolInfo(log, `switch from=${poolLabel(previous ?? {})} to=${poolLabel(selected.account)} reason=${previousSelection?.kind === 'selected' ? 'better headroom' : 'pinned account unavailable'}`);
         }
-        if (pool.kind === 'ready')
-            probeUnknownAccounts(pool.accounts, selected.account.accountId, resolved, store, {
-                cliPath: config.CLAUDE_CLI_PATH, isAtCapacity, emit: emitEvent,
-                log: line => (log ?? logger).info(line), ...probeOptions, store,
-            }, msg.teamvibe.channelId);
         return { account: selected.account, store, pool, selection: selected };
     }
     if (selected.kind === 'no_accounts_configured')
@@ -168,16 +196,12 @@ async function poolUsageNotice(pool, resolved, store) {
             const usage = state.usage;
             const windows = usage && usage.observedAt <= now
                 ? usage.windows.filter(w => now < usageWindowExpiresAt(usage, w)) : [];
-            const rejection = selectSubscriptionAccount({
-                pool: { kind: 'ready', accounts: [account] },
-                states: { [account.accountId]: { usage: usage ? { ...usage, windows: usage.windows.filter(w => w.status === 'rejected') } : undefined } },
-                model: resolved.model, now,
-            });
-            const rejected = rejection.kind === 'deferred' || (state.reactive?.some(r => r.observedAt <= now && reactiveEligibleAt(r) > now) ?? false);
-            const blockers = windows.filter(w => w.percent !== undefined && w.percent >= (account.useFullQuota ? 100 : USAGE_THRESHOLD_PERCENT));
+            const binding = blockingUsageWindows(account, state, resolved.model, now);
+            const rejected = binding.some(w => w.status === 'rejected');
+            const blockers = binding.filter(w => w.status !== 'rejected' && w.percent !== undefined && w.percent >= (account.useFullQuota ? 100 : USAGE_THRESHOLD_PERCENT));
             const resets = blockers.map(w => w.resetAt);
             return {
-                label: account.label, useFullQuota: account.useFullQuota, windows, rejected,
+                label: account.label, useFullQuota: account.useFullQuota, windows: windows.filter(w => binding.some(b => b.window === w.window && b.scope === w.scope)), rejected,
                 thresholdBlocked: blockers.length > 0,
                 resetAt: resets.length && resets.every((r) => r !== undefined) ? Math.max(...resets) : undefined,
             };

package/dist/subscription-selection.d.ts

@@ -40,6 +40,7 @@ export interface UsageWindow {
     scope: 'global' | 'sonnet' | 'opus' | 'haiku' | 'fable' | 'uncertain';
     /** CLI kind, or the server compatibility provenance for a legacy Fable allowance. */
     kind?: 'seven_day_overage_included' | 'legacy-uncertain-seven-day';
+    pollerVersion?: string;
     status?: 'allowed' | 'allowed_warning' | 'rejected';
     /** Retained rejections keep their own clock when merged into newer measurements. */
     observedAt?: number;
@@ -48,14 +49,24 @@ export interface UsageWindow {
     resetAt?: number;
 }
 export interface UsageObservation {
+    pollerVersion?: string;
     source: 'passive' | 'probe';
     observedAt: number;
     windows: readonly UsageWindow[];
 }
 /** Passive and probe percentages remain lower bounds until each window resets. */
 export declare function usageWindowExpiresAt(usage: UsageObservation, window: UsageWindow): number;
-/** Latest measurements plus durable rejections; omission or success never clears a hold. */
+/** Release 0.8.4 preserves the raw kind. Unknown versions use the legacy path. */
+export declare function isLegacyReporter(version: string | undefined): boolean;
+/** Compatibility preserves reporter provenance even when projected windows are persisted.
+ * On Pro/Max the legacy distinct weekly allowance is Fable. Never infer a kind
+ * for modern reports, duplicate unknown windows, or an identical global copy.
+ */
+export declare function projectLegacyFableUsage<T extends UsageObservation | undefined>(usage: T, version?: string): T;
+/** Latest measurements plus durable genuine rejections; omission or success never clears a genuine hold. */
 export declare function mergeUsageObservations(observations: readonly (UsageObservation | undefined)[], now: number): UsageObservation | undefined;
+/** Preserve last-known meters, projecting legacy identity before its global companion is replaced. */
+export declare function mergePersistedUsageObservations(previous: UsageObservation | undefined, incoming: UsageObservation | undefined, now: number): UsageObservation | undefined;
 export interface ReactiveExhaustion {
     observedAt: number;
     quota: ClaudeQuotaFailure;
@@ -88,6 +99,7 @@ export type SelectionOutcome<A extends AccountIdentity = AccountIdentity> = ({
 export declare function record(value: unknown): Record<string, unknown>;
 export declare function normalizePassiveUsage(value: unknown, observedAt: number): UsageObservation;
 export declare function normalizeProbeUsage(value: unknown, observedAt: number): UsageObservation;
+export declare function family(model: string | undefined): 'sonnet' | 'opus' | 'haiku' | 'fable' | undefined;
 export declare function reactiveEligibleAt(reactive: ReactiveExhaustion): number;
 /** Pure policy. Unknown is eligible after every known/reactive blocker is ruled out. */
 export declare function selectSubscriptionAccount<A extends AccountIdentity>(input: {
@@ -100,3 +112,7 @@ export declare function selectSubscriptionAccount<A extends AccountIdentity>(inp
     currentAccountTolerance?: number;
     now: number;
 }): SelectionOutcome<A>;
+/** Explain actual blockers with the same scope, clocks and thresholds as selection. */
+export declare function blockingUsageWindows(account: AccountIdentity, state: AccountUsageState | undefined, model: string | undefined, now: number): (UsageWindow & {
+    eligibleAt: number;
+})[];

package/dist/subscription-selection.js

@@ -10,23 +10,97 @@ export const POOL_RECHECK_MS = 15 * 60_000;
 export const REJECTED_BLOCK_MS = 15 * 60_000;
 /** Passive and probe percentages remain lower bounds until each window resets. */
 export function usageWindowExpiresAt(usage, window) {
-    const ttlExpiry = usage.observedAt + (usage.source === 'passive' ? PASSIVE_USAGE_TTL_MS : PROBE_USAGE_TTL_MS);
+    const ttlExpiry = (window.observedAt ?? usage.observedAt) + ((window.source ?? usage.source) === 'passive' ? PASSIVE_USAGE_TTL_MS : PROBE_USAGE_TTL_MS);
     return window.resetAt ?? ttlExpiry;
 }
-/** Latest measurements plus durable rejections; omission or success never clears a hold. */
+function isLatestMeasurement(usage, window) {
+    return (window.observedAt ?? usage.observedAt) === usage.observedAt &&
+        (window.source ?? usage.source) === usage.source;
+}
+/** An omitted model allowance remains exhausted until measured again or reset. */
+function isScopedExhaustion(window) {
+    return window.scope !== 'global' && window.scope !== 'uncertain' &&
+        window.percent !== undefined && window.percent >= USAGE_THRESHOLD_PERCENT;
+}
+/** Release 0.8.4 preserves the raw kind. Unknown versions use the legacy path. */
+export function isLegacyReporter(version) {
+    const match = version?.match(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/);
+    if (!match)
+        return true;
+    if (match[4]?.split('.').some(part => /^0\d+$/.test(part)))
+        return true;
+    const [major, minor, patch] = match.slice(1, 4).map(BigInt);
+    return major === 0n && (minor < 8n || (minor === 8n && (patch < 4n || (patch === 4n && !!match[4]))));
+}
+/** Compatibility preserves reporter provenance even when projected windows are persisted.
+ * On Pro/Max the legacy distinct weekly allowance is Fable. Never infer a kind
+ * for modern reports, duplicate unknown windows, or an identical global copy.
+ */
+export function projectLegacyFableUsage(usage, version) {
+    if (!usage)
+        return usage;
+    const sameObservation = (a, b) => (a.observedAt ?? usage.observedAt) === (b.observedAt ?? usage.observedAt) &&
+        (a.source ?? usage.source) === (b.source ?? usage.source);
+    const uncertainWeekly = (w) => w.scope === 'uncertain' && w.window === 'seven_day';
+    return {
+        ...usage,
+        windows: usage.windows.map(w => {
+            if (!uncertainWeekly(w) || w.kind || !isLegacyReporter(w.pollerVersion ?? version ?? usage.pollerVersion))
+                return w;
+            if (usage.windows.filter(other => uncertainWeekly(other) && sameObservation(w, other)).length !== 1)
+                return w;
+            const global = usage.windows.find(other => other.scope === 'global' && other.window === 'seven_day' && sameObservation(w, other));
+            const distinct = global && ((w.percent !== undefined && w.percent !== global.percent) ||
+                (w.resetAt !== undefined && w.resetAt !== global.resetAt) ||
+                (w.status !== undefined && w.status !== global.status));
+            return distinct
+                ? { ...w, scope: 'fable', kind: 'legacy-uncertain-seven-day' }
+                : w;
+        }),
+    };
+}
+/** Genuine Fable data supersedes older compatibility projections, using each window's clock. */
+function supersedeLegacyFableProjections(observations, now) {
+    const projected = observations.map(usage => projectLegacyFableUsage(usage));
+    let newestGenuine = -Infinity;
+    for (const usage of projected) {
+        if (!usage || usage.observedAt > now)
+            continue;
+        for (const w of usage.windows) {
+            const observedAt = w.observedAt ?? usage.observedAt;
+            if (w.window === 'seven_day' && w.scope === 'fable' &&
+                w.kind !== 'legacy-uncertain-seven-day' && observedAt <= now)
+                newestGenuine = Math.max(newestGenuine, observedAt);
+        }
+    }
+    return projected.map(usage => usage && ({
+        ...usage,
+        windows: usage.windows.filter(w => !(w.window === 'seven_day' && w.scope === 'fable' &&
+            w.kind === 'legacy-uncertain-seven-day' && (w.observedAt ?? usage.observedAt) < newestGenuine)),
+    }));
+}
+/** Latest measurements plus durable genuine rejections; omission or success never clears a genuine hold. */
 export function mergeUsageObservations(observations, now) {
     let latest;
     const rejected = new Map();
-    for (const usage of observations) {
+    const scopedExhausted = new Map();
+    for (const usage of supersedeLegacyFableProjections(observations, now)) {
         if (!usage || usage.observedAt > now)
             continue;
         if (!latest || usage.observedAt >= latest.observedAt)
             latest = usage;
         for (const w of usage.windows) {
             const observedAt = w.observedAt ?? usage.observedAt;
-            if (w.status !== 'rejected' || observedAt > now)
+            if (observedAt > now)
                 continue;
             const key = `${w.window}:${w.scope}`;
+            if (w.scope !== 'global' && w.scope !== 'uncertain' && w.status !== 'rejected') {
+                const previous = scopedExhausted.get(key);
+                if (!previous || observedAt >= previous.observedAt)
+                    scopedExhausted.set(key, { ...w, observedAt, source: w.source ?? usage.source });
+            }
+            if (w.status !== 'rejected')
+                continue;
             const previous = rejected.get(key);
             if (!previous || observedAt >= previous.observedAt)
                 rejected.set(key, { ...w, observedAt, source: w.source ?? usage.source });
@@ -35,16 +109,64 @@ export function mergeUsageObservations(observations, now) {
     if (!latest)
         return undefined;
     const active = [...rejected.values()].filter(w => now < (w.resetAt ?? w.observedAt + REJECTED_BLOCK_MS));
+    const retained = [...scopedExhausted.values()].filter(w => isScopedExhaustion(w) &&
+        !latest.windows.some(other => other.window === w.window && other.scope === w.scope) &&
+        !active.some(other => other.window === w.window && other.scope === w.scope) &&
+        now < usageWindowExpiresAt(latest, w));
     return {
         ...latest,
         windows: [
             ...latest.windows.filter(w => w.status !== 'rejected' &&
-                (w.observedAt ?? latest.observedAt) === latest.observedAt &&
-                (w.source ?? latest.source) === latest.source).slice(0, 133 - active.length),
+                (w.observedAt ?? latest.observedAt) <= now &&
+                (isLatestMeasurement(latest, w) || (isScopedExhaustion(w) && now < usageWindowExpiresAt(latest, w))))
+                .slice(0, Math.max(0, 133 - active.length - retained.length)),
+            ...retained,
             ...active,
         ],
     };
 }
+/** Preserve last-known meters, projecting legacy identity before its global companion is replaced. */
+export function mergePersistedUsageObservations(previous, incoming, now) {
+    // Apply the same replacement before retaining last-known meters for storage.
+    [previous, incoming] = supersedeLegacyFableProjections([previous, incoming], now);
+    incoming ??= previous;
+    if (!incoming)
+        return undefined;
+    const merged = mergeUsageObservations([previous, incoming], now);
+    const rejected = merged?.windows.filter(w => w.status === 'rejected') ?? [];
+    const windows = (previous?.windows ?? []).filter(w => w.status !== 'rejected').map((w) => ({
+        ...w,
+        observedAt: w.observedAt ?? previous.observedAt,
+        source: w.source ?? previous.source,
+    }));
+    const groups = new Map();
+    for (const window of incoming.windows.filter(w => w.status !== 'rejected')) {
+        const group = `${window.window}:${window.scope}`;
+        const values = groups.get(group) ?? [];
+        values.push({
+            ...window,
+            observedAt: window.observedAt ?? incoming.observedAt,
+            source: window.source ?? incoming.source,
+        });
+        groups.set(group, values);
+    }
+    for (const [group, values] of groups) {
+        const matches = (w) => `${w.window}:${w.scope}` === group;
+        const old = windows.filter(matches);
+        const newest = Math.max(...values.map((w) => w.observedAt));
+        // A failed/incomplete observation must not erase a last-known measurement.
+        if (old.length &&
+            (newest <= Math.max(...old.map((w) => w.observedAt)) ||
+                values.every((w) => w.percent === undefined)))
+            continue;
+        for (let i = windows.length - 1; i >= 0; i--)
+            if (matches(windows[i]))
+                windows.splice(i, 1);
+        windows.push(...values);
+    }
+    const latest = previous && previous.observedAt > incoming.observedAt ? previous : incoming;
+    return { ...latest, windows: [...windows.slice(0, 133 - rejected.length), ...rejected] };
+}
 export function record(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : {};
 }
@@ -143,7 +265,7 @@ export function normalizeProbeUsage(value, observedAt) {
     }
     return { source: 'probe', observedAt, windows };
 }
-function family(model) {
+export function family(model) {
     return model?.toLowerCase().match(/^(?:claude-)?(sonnet|opus|haiku|fable)(?:-\d[\w.-]*)?(?:\[1m\])?$/)?.[1];
 }
 function applicable(scope, model) {
@@ -194,7 +316,7 @@ export function selectSubscriptionAccount(input) {
             if (input.now < until)
                 blockers.push(until);
         }
-        const usage = state?.usage;
+        const usage = projectLegacyFableUsage(state?.usage);
         // A provider rejection outlives snapshot freshness. Never score it as headroom.
         if (usage && usage.observedAt <= input.now) {
             for (const w of usage.windows) {
@@ -208,8 +330,13 @@ export function selectSubscriptionAccount(input) {
                     blockers.push(until);
             }
         }
-        const windows = usage && usage.observedAt <= input.now ? usage.windows.filter(w => w.status !== 'rejected' && (w.observedAt ?? usage.observedAt) === usage.observedAt && (w.source ?? usage.source) === usage.source && applicable(w.scope, input.model) && input.now < usageWindowExpiresAt(usage, w)) : [];
-        const uncertain = windows.some(w => w.scope === 'uncertain' || (w.scope !== 'global' && !family(input.model)));
+        const windows = usage && usage.observedAt <= input.now
+            ? usage.windows.filter(w => w.status !== 'rejected' &&
+                (w.observedAt ?? usage.observedAt) <= input.now &&
+                (isLatestMeasurement(usage, w) || isScopedExhaustion(w)) &&
+                applicable(w.scope, input.model) && input.now < usageWindowExpiresAt(usage, w))
+            : [];
+        const uncertain = windows.some(w => w.scope === 'uncertain' || (w.scope !== 'global' && input.model !== undefined && !family(input.model)));
         for (const w of windows) {
             if (w.percent !== undefined && w.percent >= (account.useFullQuota ? 100 : USAGE_THRESHOLD_PERCENT))
                 blockers.push(usageWindowExpiresAt(usage, w));
@@ -241,3 +368,20 @@ export function selectSubscriptionAccount(input) {
         return { kind: 'selected', provenance: 'unknown', ...unknown[0] };
     return { kind: 'deferred', eligibleAt: Math.min(...deadlines) };
 }
+/** Explain actual blockers with the same scope, clocks and thresholds as selection. */
+export function blockingUsageWindows(account, state, model, now) {
+    const pool = { kind: 'ready', accounts: [account] };
+    const usage = projectLegacyFableUsage(state?.usage);
+    const windows = [];
+    for (const window of usage?.windows ?? []) {
+        const result = selectSubscriptionAccount({ pool, states: { [account.accountId]: { usage: { ...usage, windows: [window] } } }, model, now });
+        if (result.kind === 'deferred')
+            windows.push({ ...window, eligibleAt: result.eligibleAt });
+    }
+    for (const reactive of state?.reactive ?? []) {
+        const result = selectSubscriptionAccount({ pool, states: { [account.accountId]: { reactive: [reactive] } }, model, now });
+        if (result.kind === 'deferred')
+            windows.push({ observedAt: reactive.observedAt, window: reactive.quota.window ?? 'seven_day', scope: reactive.quota.modelScope ? family(reactive.quota.modelScope) ?? 'uncertain' : 'global', status: 'rejected', resetAt: reactive.quota.resetAt ? Date.parse(reactive.quota.resetAt) : undefined, eligibleAt: result.eligibleAt });
+    }
+    return windows;
+}

package/dist/subscription-usage-store.d.ts

@@ -9,6 +9,8 @@ export interface ProbeObservation {
     usage?: UsageObservation;
 }
 export interface StoredAccountUsage {
+    /** Durable last attempt, including unsuccessful and cancelled local probes. */
+    localProbeClaimedAt?: number;
     /** Latest measured snapshot plus active rejected windows, persisted across observations. */
     usage?: UsageObservation;
     passive?: {

package/dist/subscription-usage-store.js

@@ -3,7 +3,7 @@ import { createHash, randomUUID } from 'node:crypto';
 import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
 import { parseClaudeRateLimitInfo } from './claude-rate-limit.js';
-import { normalizePassiveUsage, mergeUsageObservations, record, reactiveEligibleAt } from './subscription-selection.js';
+import { normalizePassiveUsage, mergeUsageObservations, record, reactiveEligibleAt, family } from './subscription-selection.js';
 export function usageStateForSelection(state, now) {
     return {
         usage: mergeUsageObservations([
@@ -55,7 +55,7 @@ export function safeRateLimitInfo(info) {
     return parsed;
 }
 export function safeQuota(quota) {
-    const scope = typeof quota.modelScope === 'string' ? quota.modelScope.toLowerCase().match(/^(?:claude-)?(sonnet|opus|haiku)(?:-\d[\w.-]*)?$/)?.[1] : undefined;
+    const scope = typeof quota.modelScope === 'string' ? family(quota.modelScope) : undefined;
     const reset = typeof quota.resetAt === 'string' ? Date.parse(quota.resetAt) : NaN;
     return {
         reason: ['usage_limit', 'weekly_limit', 'session_limit', 'extra_usage'].includes(quota.reason) ? quota.reason : 'usage_limit',
@@ -80,7 +80,7 @@ function safeUsage(value, source) {
         if (observedAt !== undefined)
             validTime(observedAt);
         const source = w['source'] === 'passive' || w['source'] === 'probe' ? w['source'] : undefined;
-        return { window, scope, ...(w['kind'] === 'seven_day_overage_included' ? { kind: w['kind'] } : {}), percent, resetAt, ...(status ? { status } : {}), ...(observedAt ? { observedAt } : {}), ...(source ? { source } : {}) };
+        return { window, scope, ...((w['kind'] === 'seven_day_overage_included' || w['kind'] === 'legacy-uncertain-seven-day') ? { kind: w['kind'] } : {}), percent, resetAt, ...(status ? { status } : {}), ...(observedAt ? { observedAt } : {}), ...(source ? { source } : {}) };
     });
     if (usage['windows'].length > 133)
         windows.push({ window: 'seven_day', scope: 'uncertain' });

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@teamvibe/poller",
-  "version": "0.8.6-rc.2",
+  "version": "0.8.6-rc.4",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@teamvibe/poller",
-      "version": "0.8.6-rc.2",
+      "version": "0.8.6-rc.4",
       "dependencies": {
         "@aws-sdk/client-dynamodb": "3.1108.0",
         "@aws-sdk/client-sqs": "3.1108.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teamvibe/poller",
-  "version": "0.8.6-rc.2",
+  "version": "0.8.6-rc.4",
   "type": "module",
   "main": "./dist/index.js",
   "bin": {