@teamvibe/poller 0.8.4-rc.1 → 0.8.4-rc.2

package/dist/claude-spawner.js

@@ -1588,7 +1588,9 @@ export async function spawnPoolClaudeCode(msg, sessionLog, selectedDirectory, se
             // fallback must report the fresh attempt's delivery flags independently.
             if (!runtime?.resumePending)
                 sawSendMessageCall = false;
-            const result = await runClaudeCode(msg, sessionLog, effectiveCwd, directory, id, runtime?.resumePending ? false : first, lastMessageTs, onMessageSent, typingIndicator, runtime);
+            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;
             sawSendMessageCall ||= result.sawSendMessageCall === true;
             if (prepared?.account) {
                 if (poolAttempts.length >= 1000)
@@ -1622,7 +1624,7 @@ export async function spawnPoolClaudeCode(msg, sessionLog, selectedDirectory, se
                     retainWorktree = false;
                     return result;
                 }
-                if (result.quota && !result.killedByPoller) {
+                if ((result.quota || result.rateLimitInfo?.status === 'rejected') && !result.killedByPoller) {
                     runtime.resumePending = true;
                     retainWorktree = true;
                 }
@@ -1645,7 +1647,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.killedByPoller && poolRuntime && runtime) {
+            while (prepared?.account && (result.quota || result.rateLimitInfo?.status === 'rejected') && !result.killedByPoller && poolRuntime && runtime) {
                 attemptedAccounts.add(prepared.account.accountId);
                 if (poolRuntime.shouldStop() || attemptedAccounts.size >= 1000)
                     throw new PoolDeferredError();
@@ -1653,7 +1655,8 @@ export async function spawnPoolClaudeCode(msg, sessionLog, selectedDirectory, se
                 logPoolFetch(sessionLog, prepared.pool);
                 if (prepared.pool.kind === 'ready')
                     await emitCandidateUsage(msg, prepared.pool.accounts, prepared.store);
-                // Reactive evidence was persisted by attempt() before choosing another account.
+                // Quota and passive rejection evidence were persisted before selection.
+                // The chain also excludes attempted accounts even if a concurrent observation replaces that evidence.
                 if (prepared.pool.kind === 'ready')
                     for (const account of prepared.pool.accounts) {
                         if (attemptedAccounts.has(account.accountId))

package/dist/pool-telemetry.d.ts

@@ -3,7 +3,7 @@ import { type StoredAccountUsage, type SubscriptionUsageStore } from './subscrip
 import type { PoolAttempt } from './subscription-runtime.js';
 import type { SessionMetrics, TeamVibeQueueMessage } from './types.js';
 /** Explicit transport DTO: never serialize a pool account/credential envelope. */
-export declare function accountUsageTelemetry(account: SubscriptionAccount, state: StoredAccountUsage): {
+export declare function accountUsageTelemetry(account: SubscriptionAccount, state: StoredAccountUsage, reportedAt?: number): {
     reactive: {
         observedAt: number;
         window: import("./claude-rate-limit.js").ClaudeQuotaWindow | undefined;

package/dist/pool-telemetry.js

@@ -1,6 +1,6 @@
 import { emitEvent } from './event-queue.js';
-import { normalizePassiveUsage, reactiveEligibleAt, } from './subscription-selection.js';
-import { safeQuota, safeRateLimitInfo, } from './subscription-usage-store.js';
+import { 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)
         ? value
@@ -30,18 +30,12 @@ function safeMetrics(metrics) {
     return result;
 }
 /** Explicit transport DTO: never serialize a pool account/credential envelope. */
-export function accountUsageTelemetry(account, state) {
-    const passive = state.passive
-        ? normalizePassiveUsage(state.passive.rateLimitInfo, state.passive.observedAt)
-        : undefined;
-    const probe = state.probe?.usage;
-    const usage = passive && (!probe || passive.observedAt >= probe.observedAt)
-        ? passive
-        : probe;
+export function accountUsageTelemetry(account, state, reportedAt = Date.now()) {
+    const { usage } = usageStateForSelection(state, reportedAt);
     return {
         accountId: account.accountId,
         accountLabel: account.label ?? account.accountId,
-        reportedAt: Date.now(),
+        reportedAt,
         ...(usage ? { usage } : {}),
         ...(state.probe
             ? {

package/dist/subscription-runtime.d.ts

@@ -71,5 +71,5 @@ export declare function preparePool(msg: TeamVibeQueueMessage, resolved: Resolve
 }>;
 export declare function accountPin(account: SubscriptionAccount, resolved: ResolvedPoolModel): SubscriptionPin;
 export declare function validateAccount(account: SubscriptionAccount, resolved: ResolvedPoolModel): Promise<void>;
-/** A snapshot TTL/recheck is not a provider reset. Report a reset only when reactive evidence establishes it. */
+/** A snapshot TTL/recheck is not a provider reset. Explicit rejections also establish resets. */
 export declare function poolDeferredError(pool: PoolFetchResult<SubscriptionAccount>, resolved: ResolvedPoolModel, store: SubscriptionUsageStore, eligibleAt?: number, log?: PoolInfoLogger): Promise<PoolDeferredError>;

package/dist/subscription-runtime.js

@@ -6,7 +6,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 { PASSIVE_USAGE_TTL_MS, PROBE_USAGE_TTL_MS, reactiveEligibleAt, USAGE_THRESHOLD_PERCENT, POOL_RECHECK_MS } from './subscription-selection.js';
+import { normalizePassiveUsage, selectSubscriptionAccount, PASSIVE_USAGE_TTL_MS, PROBE_USAGE_TTL_MS, reactiveEligibleAt, USAGE_THRESHOLD_PERCENT, POOL_RECHECK_MS } from './subscription-selection.js';
 export class PoolDeferredError extends Error {
     eligibleAt;
     resetAt;
@@ -64,7 +64,7 @@ export async function validateAccount(account, resolved) {
         throw new PoolDeferredError(selected.kind === 'deferred' ? selected.eligibleAt : undefined);
 }
 /** Message-only evidence; never changes selection, eligibility or durable pause state. */
-async function poolUsageNotice(pool, store) {
+async function poolUsageNotice(pool, resolved, store) {
     if (pool.kind !== 'ready')
         return {};
     const now = Date.now();
@@ -75,7 +75,12 @@ async function poolUsageNotice(pool, store) {
             const ttl = usage?.source === 'passive' ? PASSIVE_USAGE_TTL_MS : PROBE_USAGE_TTL_MS;
             const windows = usage && usage.observedAt <= now && now < usage.observedAt + ttl
                 ? usage.windows.filter(w => w.resetAt === undefined || w.resetAt > now) : [];
-            const rejected = state.reactive?.some(r => r.observedAt <= now && reactiveEligibleAt(r) > now) ?? false;
+            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 resets = blockers.map(w => w.resetAt);
             return {
@@ -94,9 +99,9 @@ async function poolUsageNotice(pool, store) {
         return {};
     }
 }
-/** A snapshot TTL/recheck is not a provider reset. Report a reset only when reactive evidence establishes it. */
+/** A snapshot TTL/recheck is not a provider reset. Explicit rejections also establish resets. */
 export async function poolDeferredError(pool, resolved, store, eligibleAt, log) {
-    const notice = await poolUsageNotice(pool, store);
+    const notice = await poolUsageNotice(pool, resolved, store);
     let usageDeferred = eligibleAt !== undefined;
     const deferredError = (resetAt) => {
         const error = new PoolDeferredError(eligibleAt, resetAt);
@@ -115,6 +120,9 @@ export async function poolDeferredError(pool, resolved, store, eligibleAt, log)
                 if (selected.kind !== 'deferred' || selected.eligibleAt !== eligibleAt)
                     continue;
                 const state = await store.read(account);
+                const usage = state.passive ? normalizePassiveUsage(state.passive.rateLimitInfo, state.passive.observedAt) : undefined;
+                if (usage?.windows.some(w => w.status === 'rejected' && w.resetAt === eligibleAt))
+                    return deferredError(new Date(eligibleAt).toISOString());
                 const live = state.reactive.filter(r => !r.quota.resetAt || Date.parse(r.quota.resetAt) > Date.now());
                 if (live.length && live.every(r => r.quota.resetAt && Number.isFinite(Date.parse(r.quota.resetAt))) && live.some(r => Date.parse(r.quota.resetAt) === eligibleAt))
                     return deferredError(new Date(eligibleAt).toISOString());

package/dist/subscription-selection.d.ts

@@ -5,6 +5,8 @@ export declare const USAGE_THRESHOLD_PERCENT = 90;
 export declare const PASSIVE_USAGE_TTL_MS: number;
 export declare const PROBE_USAGE_TTL_MS = 60000;
 export declare const POOL_RECHECK_MS: number;
+/** Safety hold from the rejection observation when the provider gives no reset. */
+export declare const REJECTED_BLOCK_MS: number;
 export interface AccountIdentity {
     workspaceId: string;
     accountId: string;
@@ -34,6 +36,9 @@ export interface UsageWindow {
     window: 'five_hour' | 'seven_day';
     scope: 'global' | 'sonnet' | 'opus' | 'haiku' | 'fable' | 'uncertain';
     status?: 'allowed' | 'allowed_warning' | 'rejected';
+    /** Retained rejections keep their own clock when merged into newer measurements. */
+    observedAt?: number;
+    source?: 'passive' | 'probe';
     percent?: number;
     resetAt?: number;
 }
@@ -42,6 +47,8 @@ export interface UsageObservation {
     observedAt: number;
     windows: readonly UsageWindow[];
 }
+/** Latest measurements plus durable rejections; omission or success never clears a hold. */
+export declare function mergeUsageObservations(observations: readonly (UsageObservation | undefined)[], now: number): UsageObservation | undefined;
 export interface ReactiveExhaustion {
     observedAt: number;
     quota: ClaudeQuotaFailure;

package/dist/subscription-selection.js

@@ -3,6 +3,40 @@ export const USAGE_THRESHOLD_PERCENT = 90;
 export const PASSIVE_USAGE_TTL_MS = 5 * 60_000;
 export const PROBE_USAGE_TTL_MS = 60_000;
 export const POOL_RECHECK_MS = 15 * 60_000;
+/** Safety hold from the rejection observation when the provider gives no reset. */
+export const REJECTED_BLOCK_MS = 15 * 60_000;
+/** Latest measurements plus durable rejections; omission or success never clears a hold. */
+export function mergeUsageObservations(observations, now) {
+    let latest;
+    const rejected = new Map();
+    for (const usage of observations) {
+        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)
+                continue;
+            const key = `${w.window}:${w.scope}`;
+            const previous = rejected.get(key);
+            if (!previous || observedAt >= previous.observedAt)
+                rejected.set(key, { ...w, observedAt, source: w.source ?? usage.source });
+        }
+    }
+    if (!latest)
+        return undefined;
+    const active = [...rejected.values()].filter(w => now < (w.resetAt ?? w.observedAt + REJECTED_BLOCK_MS));
+    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),
+            ...active,
+        ],
+    };
+}
 export function record(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : {};
 }
@@ -143,9 +177,22 @@ export function selectSubscriptionAccount(input) {
                 blockers.push(until);
         }
         const usage = 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) {
+                if (w.status !== 'rejected' || !applicable(w.scope, input.model))
+                    continue;
+                const observedAt = w.observedAt ?? usage.observedAt;
+                if (observedAt > input.now)
+                    continue;
+                const until = w.resetAt ?? observedAt + REJECTED_BLOCK_MS;
+                if (input.now < until)
+                    blockers.push(until);
+            }
+        }
         const expiry = usage ? usage.observedAt + (usage.source === 'passive' ? PASSIVE_USAGE_TTL_MS : PROBE_USAGE_TTL_MS) : 0;
         const fresh = usage && usage.observedAt <= input.now && input.now < expiry;
-        const windows = fresh ? usage.windows.filter(w => applicable(w.scope, input.model) && (w.resetAt === undefined || w.resetAt > input.now)) : [];
+        const windows = fresh ? usage.windows.filter(w => w.status !== 'rejected' && (w.observedAt ?? usage.observedAt) === usage.observedAt && (w.source ?? usage.source) === usage.source && applicable(w.scope, input.model) && (w.resetAt === undefined || w.resetAt > input.now)) : [];
         const uncertain = windows.some(w => w.scope === 'uncertain' || (w.scope !== 'global' && !family(input.model)));
         for (const w of windows) {
             if (w.percent !== undefined && w.percent >= (account.useFullQuota ? 100 : USAGE_THRESHOLD_PERCENT))

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

@@ -9,6 +9,8 @@ export interface ProbeObservation {
     usage?: UsageObservation;
 }
 export interface StoredAccountUsage {
+    /** Latest measured snapshot plus active rejected windows, persisted across observations. */
+    usage?: UsageObservation;
     passive?: {
         rateLimitInfo: ClaudeRateLimitInfo;
         observedAt: number;

package/dist/subscription-usage-store.js

@@ -2,12 +2,16 @@ 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, record, reactiveEligibleAt, PASSIVE_USAGE_TTL_MS } from './subscription-selection.js';
+import { normalizePassiveUsage, mergeUsageObservations, record, reactiveEligibleAt } from './subscription-selection.js';
 export function usageStateForSelection(state, now) {
-    const passive = state.passive ? normalizePassiveUsage(state.passive.rateLimitInfo, state.passive.observedAt) : undefined;
-    // Passive is primary while fresh; a completed optional probe may supplement a stale/missing snapshot.
-    const fresh = passive && passive.observedAt <= now && now < passive.observedAt + PASSIVE_USAGE_TTL_MS;
-    return { usage: fresh ? passive : state.probe?.status === 'ok' ? state.probe.usage : passive, reactive: state.reactive };
+    return {
+        usage: mergeUsageObservations([
+            state.usage,
+            state.passive ? normalizePassiveUsage(state.passive.rateLimitInfo, state.passive.observedAt) : undefined,
+            state.probe?.status === 'ok' ? state.probe.usage : undefined,
+        ], now),
+        reactive: state.reactive,
+    };
 }
 export class SubscriptionUsageStoreError extends Error {
     constructor() { super('Subscription usage store unavailable'); this.name = 'SubscriptionUsageStoreError'; }
@@ -51,6 +55,28 @@ export function safeQuota(quota) {
         ...(Number.isFinite(reset) && reset > 0 ? { resetAt: new Date(reset).toISOString() } : {}),
     };
 }
+function safeUsage(value, source) {
+    const usage = record(value);
+    if (typeof usage['observedAt'] !== 'number' || !Array.isArray(usage['windows']))
+        throw new SubscriptionUsageStoreError();
+    validTime(usage['observedAt']);
+    const windows = usage['windows'].slice(0, 133).map(raw => {
+        const w = record(raw);
+        const window = w['window'] === 'five_hour' ? 'five_hour' : 'seven_day';
+        const scope = typeof w['scope'] === 'string' && ['global', 'sonnet', 'opus', 'haiku', 'fable'].includes(w['scope']) ? w['scope'] : 'uncertain';
+        const percent = typeof w['percent'] === 'number' && Number.isFinite(w['percent']) && w['percent'] >= 0 && w['percent'] <= 100 ? w['percent'] : undefined;
+        const resetAt = typeof w['resetAt'] === 'number' && Number.isFinite(w['resetAt']) && w['resetAt'] > 0 && w['resetAt'] <= 253402300799000 ? w['resetAt'] : undefined;
+        const status = w['status'] === 'allowed' || w['status'] === 'allowed_warning' || w['status'] === 'rejected' ? w['status'] : undefined;
+        const observedAt = typeof w['observedAt'] === 'number' ? w['observedAt'] : undefined;
+        if (observedAt !== undefined)
+            validTime(observedAt);
+        const source = w['source'] === 'passive' || w['source'] === 'probe' ? w['source'] : undefined;
+        return { window, scope, percent, resetAt, ...(status ? { status } : {}), ...(observedAt ? { observedAt } : {}), ...(source ? { source } : {}) };
+    });
+    if (usage['windows'].length > 133)
+        windows.push({ window: 'seven_day', scope: 'uncertain' });
+    return { source, observedAt: usage['observedAt'], windows };
+}
 function safeProbe(value) {
     const obj = record(value);
     const status = obj['status'];
@@ -62,21 +88,7 @@ function safeProbe(value) {
     validTime(observedAt);
     const result = { status: status, observedAt };
     if (status === 'ok' && obj['usage']) {
-        const usage = record(obj['usage']);
-        if (typeof usage['observedAt'] !== 'number' || !Array.isArray(usage['windows']))
-            throw new SubscriptionUsageStoreError();
-        validTime(usage['observedAt']);
-        const windows = usage['windows'].slice(0, 133).map(raw => {
-            const w = record(raw);
-            const window = w['window'] === 'five_hour' ? 'five_hour' : 'seven_day';
-            const scope = typeof w['scope'] === 'string' && ['global', 'sonnet', 'opus', 'haiku', 'fable'].includes(w['scope']) ? w['scope'] : 'uncertain';
-            const percent = typeof w['percent'] === 'number' && Number.isFinite(w['percent']) && w['percent'] >= 0 && w['percent'] <= 100 ? w['percent'] : undefined;
-            const resetAt = typeof w['resetAt'] === 'number' && Number.isFinite(w['resetAt']) && w['resetAt'] > 0 && w['resetAt'] <= 253402300799000 ? w['resetAt'] : undefined;
-            return { window, scope, percent, resetAt };
-        });
-        if (usage['windows'].length > 133)
-            windows.push({ window: 'seven_day', scope: 'uncertain' });
-        result.usage = { source: 'probe', observedAt: usage['observedAt'], windows };
+        result.usage = safeUsage(obj['usage'], 'probe');
     }
     return result;
 }
@@ -88,6 +100,9 @@ function safeVersion(value) {
     }
     if (value.probe)
         state.probe = safeProbe(value.probe);
+    if (value.usage) {
+        state.usage = safeUsage(value.usage, value.usage.source === 'passive' ? 'passive' : 'probe');
+    }
     return state;
 }
 function safeReactive(value) {
@@ -158,7 +173,9 @@ 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;
             state.passive = { rateLimitInfo: safeRateLimitInfo(rateLimitInfo), observedAt };
+            state.usage = mergeUsageObservations([previous, normalizePassiveUsage(state.passive.rateLimitInfo, observedAt)], observedAt);
             await this.#save(path, state);
         });
     }
@@ -216,7 +233,11 @@ export class FileSubscriptionUsageStore {
         const path = this.#path(key, true);
         await serial(path, async () => {
             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;
             state.probe = safeProbe(observation);
+            state.usage = mergeUsageObservations([previous, state.probe.usage], mergeAt);
             await this.#save(path, state);
         });
     }

package/dist/usage-probe-job.js

@@ -3,7 +3,7 @@ import { mkdtemp, rm, mkdir } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { normalizePassiveUsage } from './subscription-selection.js';
-import { safeRateLimitInfo, } from './subscription-usage-store.js';
+import { safeRateLimitInfo, usageStateForSelection, } from './subscription-usage-store.js';
 import { parseClaudeRateLimitInfo, } from './claude-rate-limit.js';
 export function isUsageProbe(value) {
     return (!!value &&
@@ -176,7 +176,7 @@ export async function handleUsageProbe(job, options) {
             ...metadata,
             accountLabel: account.label ?? account.accountId,
             reportedAt: now,
-            usage,
+            usage: usageStateForSelection(await options.store.read(account), now).usage,
             lastRateLimitInfo: safe,
             probeStatus: 'ok',
             probeObservedAt: now,

package/npm-shrinkwrap.json

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