@teamvibe/poller 0.8.6-rc.3 → 0.8.6-rc.5

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,3 +1,4 @@
+import { blockingUsageWindows, normalizePassiveUsage, selectSubscriptionAccount } from './subscription-selection.js';
 import { logPoolFetch, logPoolUsageWrite, poolInfo, poolLabel } from './pool-logging.js';
 import { emitPoolSelection, accountUsageTelemetry, emitCandidateUsage, poolRunTelemetry } from './pool-telemetry.js';
 import { spawn } from 'child_process';
@@ -1593,6 +1594,19 @@ export async function spawnPoolClaudeCode(msg, sessionLog, selectedDirectory, se
                 }
             },
         } : 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) {
@@ -1608,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)
@@ -1643,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;
                 }
@@ -1667,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 });

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

@@ -21,7 +21,7 @@ export interface PoolSelectionCandidate {
     reason: string;
     score?: number;
     headroom?: number;
-    rateWindow?: Pick<UsageWindow, 'window' | 'scope'>;
+    rateWindow?: Pick<UsageWindow, 'window' | 'scope' | 'percent'>;
     eligibleAt?: number;
 }
 /** The log and transport share a single explanation of the same selection snapshot. */

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,6 +42,20 @@ 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}`);
 }
+function skippedSelectionReason(candidate, selected) {
+    if (candidate.provenance === 'unknown' && selected.provenance === 'known')
+        return 'known observation preferred';
+    if (candidate.provenance === 'known' && selected.provenance === 'known' && candidate.score < selected.score)
+        return 'lower headroom per hour';
+    if (candidate.provenance === selected.provenance && selected.pinned)
+        return 'pinned thread kept (within tolerance)';
+    if (candidate.provenance === 'known' && selected.provenance === 'known' && candidate.score === selected.score)
+        return 'equal headroom, account id order';
+    if (candidate.provenance === 'unknown' && selected.provenance === 'unknown')
+        return 'no measurements, account id order';
+    // Should be unreachable: the policy explains every available skipped candidate above.
+    return 'deterministic account order';
+}
 /** 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')
@@ -53,14 +67,15 @@ export function poolSelectionCandidates(pool, states, model, now, selected) {
         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 });
-            return { ...base, reason: usageOnly.kind === 'deferred' ? `usage >=${account.useFullQuota ? 100 : 90}%` : 'reactive quota', eligibleAt: candidate.eligibleAt };
+            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 } } : {};
+            ? { 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'
+            ? skippedSelectionReason(candidate, selected)
             : 'unavailable';
         return { ...base, ...metrics, reason };
     });
@@ -71,7 +86,7 @@ export function logPoolSelection(log, pool, states, model, now, selected, logAll
     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 ? '' : ` eligibleAt=${new Date(candidate.eligibleAt).toISOString()}`}`);
+        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/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. */
@@ -86,6 +88,7 @@ export declare function preparePool(msg: TeamVibeQueueMessage, resolved: Resolve
         account: SubscriptionAccount;
         provenance: "known";
         source: "passive" | "probe";
+        pinned?: true;
     } & HeadroomScore & {
         model: string | undefined;
         modelSource: import("./claude-spawner.js").ModelSource;
@@ -100,6 +103,7 @@ export declare function preparePool(msg: TeamVibeQueueMessage, resolved: Resolve
         account: SubscriptionAccount;
         provenance: "unknown";
         uncertainApplicability: boolean;
+        pinned?: true;
     } & {
         model: string | undefined;
         modelSource: import("./claude-spawner.js").ModelSource;

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,6 +146,11 @@ 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 (pool.kind === 'ready' && currentAccountId && currentAccountId !== selected.account.accountId) {
@@ -131,11 +161,6 @@ export async function preparePool(msg, resolved, pin, fetched, log, probeOptions
             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')
@@ -171,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,28 @@ 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;
+/** Genuine Fable data replaces raw uncertain windows observed at or before it.
+ * Deduplicate uncertain windows before splitting measurements from rejections.
+ */
+export declare function supersedeLegacyFableProjections(observations: readonly (UsageObservation | undefined)[], now: number): (UsageObservation | undefined)[];
+/** 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;
@@ -74,11 +89,13 @@ export type SelectionOutcome<A extends AccountIdentity = AccountIdentity> = ({
     account: A;
     provenance: 'known';
     source: 'passive' | 'probe';
+    pinned?: true;
 } & HeadroomScore) | {
     kind: 'selected';
     account: A;
     provenance: 'unknown';
     uncertainApplicability: boolean;
+    pinned?: true;
 } | {
     kind: 'deferred';
     eligibleAt: number;
@@ -101,3 +118,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,134 @@ 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 replaces raw uncertain windows observed at or before it.
+ * Deduplicate uncertain windows before splitting measurements from rejections.
+ */
+export function supersedeLegacyFableProjections(observations, now) {
+    // Preserve explicit-scope compatibility for already projected legacy Fable data.
+    let newestFable = -Infinity;
+    let newestGenuine = -Infinity;
+    for (const usage of observations) {
+        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)
+                newestFable = Math.max(newestFable, observedAt);
+            if (w.window === 'seven_day' && w.scope === 'fable' &&
+                w.kind === 'seven_day_overage_included' && observedAt <= now)
+                newestGenuine = Math.max(newestGenuine, observedAt);
+        }
+    }
+    // Reporter versions and missing kinds cannot date raw uncertain windows.
+    // Keep newer evidence unprojected so its rejection still holds every family.
+    const projected = observations.map(usage => {
+        const filtered = usage && ({
+            ...usage,
+            windows: usage.windows.filter(w => !(newestGenuine > -Infinity &&
+                w.window === 'seven_day' && w.scope === 'uncertain' &&
+                (w.observedAt ?? usage.observedAt) <= newestGenuine)),
+        });
+        return newestGenuine > -Infinity ? filtered : projectLegacyFableUsage(filtered);
+    });
+    const newestUncertain = new Map();
+    projected.forEach((usage, observation) => {
+        if (!usage || usage.observedAt > now)
+            return;
+        usage.windows.forEach((w, window) => {
+            const observedAt = w.observedAt ?? usage.observedAt;
+            if (w.scope !== 'uncertain' || observedAt > now)
+                return;
+            const previous = newestUncertain.get(w.window);
+            if (!previous || observedAt >= previous.observedAt)
+                newestUncertain.set(w.window, { observation, window, observedAt });
+        });
+    });
+    return projected.map((usage, observation) => usage && ({
+        ...usage,
+        windows: usage.windows.filter((w, window) => {
+            if (w.window === 'seven_day' && newestFable > -Infinity && (w.scope === 'fable' && w.kind === 'legacy-uncertain-seven-day' &&
+                (w.observedAt ?? usage.observedAt) < newestFable))
+                return false;
+            if (w.scope !== 'uncertain')
+                return true;
+            const newest = newestUncertain.get(w.window);
+            return newest?.observation === observation && newest.window === window;
+        }),
+    }));
+}
+/** 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 +146,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 : {};
 }
@@ -194,7 +353,7 @@ export function selectSubscriptionAccount(input) {
             if (input.now < until)
                 blockers.push(until);
         }
-        const usage = state?.usage;
+        const usage = supersedeLegacyFableProjections([state?.usage], input.now)[0];
         // A provider rejection outlives snapshot freshness. Never score it as headroom.
         if (usage && usage.observedAt <= input.now) {
             for (const w of usage.windows) {
@@ -208,7 +367,12 @@ 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 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))
@@ -232,12 +396,32 @@ export function selectSubscriptionAccount(input) {
     const current = known.find(candidate => candidate.account.accountId === input.currentAccountId);
     if (current && known[0] && input.currentAccountTolerance !== undefined &&
         known[0].score < current.score * (1 + input.currentAccountTolerance))
-        return { kind: 'selected', provenance: 'known', ...current };
+        return { kind: 'selected', provenance: 'known', ...current, pinned: true };
     // Known-first is only this spawn's transitional fallback: background CLI
     // probes measure non-selected unknowns so the next spawn can score them.
+    // Preserve pin provenance for equal scores (including zero) and unknowns too.
     if (known[0])
-        return { kind: 'selected', provenance: 'known', ...known[0] };
+        return { kind: 'selected', provenance: 'known', ...known[0],
+            ...(known[0].account.accountId === input.currentAccountId ? { pinned: true } : {}) };
     if (unknown[0])
-        return { kind: 'selected', provenance: 'unknown', ...unknown[0] };
+        return { kind: 'selected', provenance: 'unknown', ...unknown[0],
+            ...(input.currentAccountTolerance !== undefined && unknown[0].account.accountId === input.currentAccountId ? { pinned: true } : {}) };
     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 = supersedeLegacyFableProjections([state?.usage], now)[0];
+    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, mergePersistedUsageObservations, 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' });
@@ -186,9 +186,10 @@ export class FileSubscriptionUsageStore {
             const state = safeVersion(await this.#load(path, {}));
             if (state.passive && state.passive.observedAt > observedAt && !options?.expireFutureObservations)
                 return;
-            const previous = usageStateForSelection({ ...state, reactive: [] }, observedAt).usage;
+            // Retain Fable observation clocks even when the latest report omits its meter.
+            const previous = state.usage ?? usageStateForSelection({ ...state, reactive: [] }, observedAt).usage;
             state.passive = { rateLimitInfo: safeRateLimitInfo(rateLimitInfo), observedAt };
-            state.usage = mergeUsageObservations([previous, normalizePassiveUsage(state.passive.rateLimitInfo, observedAt)], observedAt);
+            state.usage = mergePersistedUsageObservations(previous, normalizePassiveUsage(state.passive.rateLimitInfo, observedAt), observedAt);
             await this.#save(path, state);
         });
     }
@@ -262,9 +263,10 @@ export class FileSubscriptionUsageStore {
             const state = safeVersion(await this.#load(path, {}));
             // Network completion order must not discard a newer stored snapshot.
             const mergeAt = Math.max(observation.observedAt, state.usage?.observedAt ?? 0, state.passive?.observedAt ?? 0);
-            const previous = usageStateForSelection({ ...state, reactive: [] }, mergeAt).usage;
+            // Retain Fable observation clocks even when the latest report omits its meter.
+            const previous = state.usage ?? usageStateForSelection({ ...state, reactive: [] }, mergeAt).usage;
             state.probe = safeProbe(observation);
-            state.usage = mergeUsageObservations([previous, state.probe.usage], mergeAt);
+            state.usage = mergePersistedUsageObservations(previous, state.probe.usage, mergeAt);
             await this.#save(path, state);
         });
     }

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@teamvibe/poller",
-  "version": "0.8.6-rc.3",
+  "version": "0.8.6-rc.5",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@teamvibe/poller",
-      "version": "0.8.6-rc.3",
+      "version": "0.8.6-rc.5",
       "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.3",
+  "version": "0.8.6-rc.5",
   "type": "module",
   "main": "./dist/index.js",
   "bin": {