@teamvibe/poller 0.8.3 → 0.8.4-rc.2

package/dist/subscription-runtime.d.ts

@@ -2,13 +2,13 @@ import { type PoolInfoLogger } from './pool-logging.js';
 import { type SubscriptionAccount } from './subscription-pool-client.js';
 import { type ResolvedPoolModel } from './subscription-pool.js';
 import { FileSubscriptionUsageStore, type SubscriptionUsageStore } from './subscription-usage-store.js';
-import { type PoolFetchResult } from './subscription-selection.js';
+import { type PoolFetchResult, type HeadroomScore } from './subscription-selection.js';
 import type { SubscriptionPin, TeamVibeQueueMessage, SessionMetrics } from './types.js';
 import type { PoolUsageLimitNotice } from './usage-limit-messages.js';
 import type { ClaudeRateLimitInfo } from './claude-rate-limit.js';
 import type { ClaudeQuotaFailure } from './claude-quota.js';
 import type { KilledByPoller } from './classify-failed-iteration.js';
-export interface PoolAttempt {
+export interface PoolAttempt extends Partial<HeadroomScore> {
     workspaceId: string;
     accountId: string;
     accountLabel?: string;
@@ -46,12 +46,30 @@ export declare function preparePool(msg: TeamVibeQueueMessage, resolved: Resolve
     account: SubscriptionAccount;
     store: FileSubscriptionUsageStore;
     pool: PoolFetchResult<SubscriptionAccount>;
+    selection: ({
+        kind: "selected";
+        account: SubscriptionAccount;
+        provenance: "known";
+        source: "passive" | "probe";
+    } & HeadroomScore & {
+        model: string | undefined;
+        modelSource: import("./claude-spawner.js").ModelSource;
+    }) | ({
+        kind: "selected";
+        account: SubscriptionAccount;
+        provenance: "unknown";
+        uncertainApplicability: boolean;
+    } & {
+        model: string | undefined;
+        modelSource: import("./claude-spawner.js").ModelSource;
+    });
 } | {
     account: undefined;
     store: FileSubscriptionUsageStore;
     pool: PoolFetchResult<SubscriptionAccount>;
+    selection: undefined;
 }>;
 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;
@@ -39,20 +39,20 @@ export async function preparePool(msg, resolved, pin, fetched, log) {
                         if (other.accountId !== account.accountId)
                             poolInfo(log, `skipped account=${poolLabel(other)} reason=session pinned elsewhere`);
                     }
-                return { account, store, pool };
+                return { account, store, pool, selection: selected };
             }
         }
     }
-    const selected = await selectPoolForResolvedModel(resolved, { workspaceId: msg.teamvibe.workspaceId, pool, store, now: Date.now(), log });
+    const selected = await selectPoolForResolvedModel(resolved, { workspaceId: msg.teamvibe.workspaceId, pool, store, now: Date.now(), log, currentAccountId: pin?.workspaceId === msg.teamvibe.workspaceId ? pin.accountId : undefined });
     if (selected.kind === 'selected') {
         if (log && pool.kind === 'ready' && pin?.workspaceId === msg.teamvibe.workspaceId && pin.accountId !== selected.account.accountId) {
             const previous = pool.accounts.find(a => a.accountId === pin.accountId);
             poolInfo(log, `switch from=${poolLabel(previous ?? {})} to=${poolLabel(selected.account)} reason=pinned account unavailable`);
         }
-        return { account: selected.account, store, pool };
+        return { account: selected.account, store, pool, selection: selected };
     }
     if (selected.kind === 'no_accounts_configured')
-        return { account: undefined, store, pool };
+        return { account: undefined, store, pool, selection: undefined };
     throw await poolDeferredError(pool, resolved, store, selected.kind === 'deferred' ? selected.eligibleAt : undefined);
 }
 export function accountPin(account, resolved) {
@@ -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

@@ -1,9 +1,12 @@
+import type { AccountProbeFailureReason } from './usage-probe-contract.js';
 import type { ClaudeQuotaFailure } from './claude-quota.js';
 export declare const USAGE_THRESHOLD_PERCENT = 90;
 /** Passive snapshots are useful for five minutes, then become unknown. */
 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;
@@ -14,6 +17,9 @@ export interface AccountIdentity {
 export type PoolFetchResult<A extends AccountIdentity = AccountIdentity> = {
     kind: 'ready';
     accounts: readonly A[];
+} | {
+    kind: 'probe_account_unavailable';
+    reason: AccountProbeFailureReason;
 } | {
     kind: 'no_accounts_configured';
 } | {
@@ -30,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;
 }
@@ -38,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;
@@ -46,13 +57,17 @@ export interface AccountUsageState {
     usage?: UsageObservation;
     reactive?: readonly ReactiveExhaustion[];
 }
-export type SelectionOutcome<A extends AccountIdentity = AccountIdentity> = {
+export interface HeadroomScore {
+    score: number;
+    rateWindow: UsageWindow;
+    reason: 'headroom_per_hour';
+}
+export type SelectionOutcome<A extends AccountIdentity = AccountIdentity> = ({
     kind: 'selected';
     account: A;
     provenance: 'known';
-    score: number;
     source: 'passive' | 'probe';
-} | {
+} & HeadroomScore) | {
     kind: 'selected';
     account: A;
     provenance: 'unknown';
@@ -73,5 +88,7 @@ export declare function selectSubscriptionAccount<A extends AccountIdentity>(inp
     /** Stable account ID within the pool's single workspace. */
     states: Readonly<Record<string, AccountUsageState | undefined>>;
     model: string | undefined;
+    /** Tie preference only; session pins are enforced separately by the runtime. */
+    currentAccountId?: string;
     now: number;
 }): SelectionOutcome<A>;

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 : {};
 }
@@ -92,7 +126,7 @@ export function normalizeProbeUsage(value, observedAt) {
     return { source: 'probe', observedAt, windows };
 }
 function family(model) {
-    return model?.toLowerCase().match(/^(?:claude-)?(sonnet|opus|haiku)(?:-\d[\w.-]*)?(?:\[1m\])?$/)?.[1];
+    return model?.toLowerCase().match(/^(?:claude-)?(sonnet|opus|haiku|fable)(?:-\d[\w.-]*)?(?:\[1m\])?$/)?.[1];
 }
 function applicable(scope, model) {
     return scope === 'global' || scope === 'uncertain' || family(model) === undefined || scope === family(model);
@@ -101,6 +135,21 @@ export function reactiveEligibleAt(reactive) {
     const parsed = reactive.quota.resetAt ? Date.parse(reactive.quota.resetAt) : NaN;
     return Number.isFinite(parsed) && parsed > reactive.observedAt ? parsed : reactive.observedAt + POOL_RECHECK_MS;
 }
+/** Called only for nonempty, applicable known windows after all blockers are ruled out.
+ * The minimum rate is the account's binding window; retain its numbers for explanation.
+ */
+function scoreHeadroom(windows, threshold, now) {
+    let score = Infinity;
+    let rateWindow = windows[0];
+    for (const window of windows) {
+        const rate = (threshold - window.percent) / Math.max((window.resetAt - now) / 3600_000, 0.25);
+        if (rate < score) {
+            score = rate;
+            rateWindow = window;
+        }
+    }
+    return { score, rateWindow, reason: 'headroom_per_hour' };
+}
 /** Pure policy. Unknown is eligible after every known/reactive blocker is ruled out. */
 export function selectSubscriptionAccount(input) {
     if (input.pool.kind !== 'ready')
@@ -128,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))
@@ -140,14 +202,14 @@ export function selectSubscriptionAccount(input) {
             deadlines.push(Math.max(...blockers));
         }
         else if (windows.length && !uncertain && windows.every(w => w.percent !== undefined && w.resetAt !== undefined)) {
-            known.push({ account, score: Math.max(...windows.map(w => w.percent)), source: usage.source });
+            known.push({ account, ...scoreHeadroom(windows, account.useFullQuota ? 100 : USAGE_THRESHOLD_PERCENT, input.now), source: usage.source });
         }
         else {
             unknown.push({ account, uncertainApplicability: uncertain });
         }
     }
     const compare = (a, b) => a.accountId < b.accountId ? -1 : a.accountId > b.accountId ? 1 : 0;
-    known.sort((a, b) => a.score - b.score || compare(a.account, b.account));
+    known.sort((a, b) => b.score - a.score || Number(b.account.accountId === input.currentAccountId) - Number(a.account.accountId === input.currentAccountId) || compare(a.account, b.account));
     unknown.sort((a, b) => compare(a.account, b.account));
     if (known[0])
         return { kind: 'selected', provenance: 'known', ...known[0] };

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/thread-routing.d.ts

@@ -0,0 +1,23 @@
+export interface ThreadRouting {
+    workspaceId: string;
+    channelId: string;
+    brainId?: string;
+    /** Historical evidence only. Recovery always derives the current directory. */
+    directory: string;
+    threadId?: string;
+    processedDropIds?: string[];
+}
+/** Poller state survives inbox pruning and process restarts; contains no credentials. */
+export declare function saveThreadRouting(threadId: string, routing: ThreadRouting): void;
+export declare function readThreadRouting(threadId: string): ThreadRouting | undefined;
+export declare function inboxDropId(threadId: string, filename: string, content: string | Uint8Array): string;
+export declare function recordProcessedDrop(threadId: string, filename: string, content: string | Uint8Array): void;
+export interface StoredThreadRouting {
+    key: string;
+    threadId?: string;
+    modifiedAt: number;
+}
+/** Older records have no threadId; discovery can match their hashed file name. */
+export declare function listThreadRoutings(): StoredThreadRouting[];
+export declare function threadRoutingKey(threadId: string): string;
+export declare function removeThreadRouting(key: string): void;

package/dist/thread-routing.js

@@ -0,0 +1,81 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { config } from './config.js';
+function routingPath(threadId) {
+    return join(config.TEAMVIBE_DATA_DIR, 'thread-routing', threadRoutingKey(threadId));
+}
+/** Poller state survives inbox pruning and process restarts; contains no credentials. */
+export function saveThreadRouting(threadId, routing) {
+    mkdirSync(join(config.TEAMVIBE_DATA_DIR, 'thread-routing'), { recursive: true, mode: 0o700 });
+    const path = routingPath(threadId);
+    const temporary = `${path}.${randomUUID()}.tmp`;
+    try {
+        writeFileSync(temporary, JSON.stringify({ ...readThreadRouting(threadId), ...routing, threadId, updatedAt: Date.now() }), { mode: 0o600 });
+        renameSync(temporary, path);
+    }
+    finally {
+        rmSync(temporary, { force: true });
+    }
+}
+export function readThreadRouting(threadId) {
+    try {
+        const routing = JSON.parse(readFileSync(routingPath(threadId), 'utf8'));
+        if (typeof routing.workspaceId !== 'string' || typeof routing.channelId !== 'string' || typeof routing.directory !== 'string' || routing.brainId !== undefined && typeof routing.brainId !== 'string')
+            return undefined;
+        if (routing.processedDropIds !== undefined && (!Array.isArray(routing.processedDropIds) || !routing.processedDropIds.every((id) => typeof id === 'string')))
+            return undefined;
+        return routing;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function inboxDropId(threadId, filename, content) {
+    return createHash('sha256').update(JSON.stringify([threadId, filename, createHash('sha256').update(content).digest('hex')])).digest('hex');
+}
+export function recordProcessedDrop(threadId, filename, content) {
+    const routing = readThreadRouting(threadId);
+    if (!routing)
+        return;
+    const id = inboxDropId(threadId, filename, content);
+    saveThreadRouting(threadId, { ...routing, processedDropIds: [...new Set([...(routing.processedDropIds ?? []), id])] });
+}
+/** Older records have no threadId; discovery can match their hashed file name. */
+export function listThreadRoutings() {
+    const root = join(config.TEAMVIBE_DATA_DIR, 'thread-routing');
+    let names;
+    try {
+        names = readdirSync(root);
+    }
+    catch {
+        return [];
+    }
+    return names.filter(name => /^[a-f0-9]{64}\.json$/.test(name)).flatMap(name => {
+        try {
+            const path = join(root, name);
+            let modifiedAt = statSync(path).mtimeMs;
+            let threadId;
+            try {
+                const value = JSON.parse(readFileSync(path, 'utf8'));
+                if (typeof value.updatedAt === 'number' && Number.isFinite(value.updatedAt))
+                    modifiedAt = value.updatedAt;
+                if (typeof value.threadId === 'string' && routingPath(value.threadId) === path)
+                    threadId = value.threadId;
+            }
+            catch { /* Corrupt records still expire; match any drops by the hash. */ }
+            return [{ key: name, threadId, modifiedAt }];
+        }
+        catch {
+            return [];
+        }
+    });
+}
+export function threadRoutingKey(threadId) {
+    return `${createHash('sha256').update(threadId).digest('hex')}.json`;
+}
+export function removeThreadRouting(key) {
+    if (!/^[a-f0-9]{64}\.json$/.test(key))
+        throw new Error('Invalid routing key');
+    rmSync(join(config.TEAMVIBE_DATA_DIR, 'thread-routing', key), { force: true });
+}

package/dist/types.d.ts

@@ -1,3 +1,5 @@
+import type { UsageProbeMessage } from './usage-probe-contract.js';
+export type { UsageProbeMessage, UsageProbeFailureReason } from './usage-probe-contract.js';
 export interface ControlMessage {
     id: string;
     source: 'control';
@@ -69,6 +71,7 @@ export interface TeamVibeQueueMessage {
 export interface SubscriptionPin {
     inboxFilename?: string;
     resumePending?: boolean;
+    /** Comparison evidence only; replay derives execution paths from current routing. */
     effectiveCwd?: string;
     claudeConfigDir?: string;
     sawSendMessageCall?: boolean;
@@ -92,7 +95,7 @@ export interface SessionRecord {
     last_message_ts?: string;
     ttl: number;
 }
-export type SessionStatus = 'processing' | 'idle' | 'waiting_for_input';
+export type SessionStatus = 'processing' | 'idle' | 'waiting_for_input' | 'completed' | 'failed' | 'aborted';
 export interface SessionMetrics {
     /** Input occupancy of the last assistant message, independent of run totals. */
     context_tokens?: number;
@@ -107,12 +110,3 @@ export interface SessionMetrics {
     cache_creation_input_tokens?: number;
     model?: string;
 }
-export interface UsageProbeMessage {
-    kind: 'usage_probe';
-    id: string;
-    workspaceId: string;
-    accountId: string;
-    credentialVersion: string;
-    requestId: string;
-    expiresAt: number;
-}

package/dist/usage-limit-messages.d.ts

@@ -1,5 +1,5 @@
 /** Owner-facing account policy location. */
-export declare const FULL_QUOTA_SETTINGS_PATH = "Settings \u2192 Connections (account menu \u2192 Use until exhausted)";
+export declare const FULL_QUOTA_SETTINGS_PATH = "Connections (account menu \u2192 Use until exhausted)";
 export interface UsageResetTiming {
     resetAt?: number;
     now?: number;

package/dist/usage-limit-messages.js

@@ -1,5 +1,5 @@
 /** Owner-facing account policy location. */
-export const FULL_QUOTA_SETTINGS_PATH = 'Settings → Connections (account menu → Use until exhausted)';
+export const FULL_QUOTA_SETTINGS_PATH = 'Connections (account menu → Use until exhausted)';
 export function formatUsageReset(input) {
     if (input.resetAt === undefined || !Number.isFinite(input.resetAt))
         return undefined;

package/dist/usage-probe-contract.d.ts

@@ -0,0 +1,15 @@
+/** Shared wire contract for request-scoped usage probes. */
+export declare const ACCOUNT_PROBE_FAILURE_REASONS: readonly ["account_changed", "account_disabled", "account_missing"];
+export declare const USAGE_PROBE_FAILURE_REASONS: readonly ["account_changed", "account_disabled", "account_missing", "token_rejected", "cli_at_capacity", "timeout", "unknown"];
+export type AccountProbeFailureReason = (typeof ACCOUNT_PROBE_FAILURE_REASONS)[number];
+export type UsageProbeFailureReason = (typeof USAGE_PROBE_FAILURE_REASONS)[number];
+export declare const USAGE_UPDATE_TTL_MS: number;
+export interface UsageProbeMessage {
+    kind: 'usage_probe';
+    id: string;
+    workspaceId: string;
+    accountId: string;
+    credentialVersion: string;
+    requestId: string;
+    expiresAt: number;
+}

package/dist/usage-probe-contract.js

@@ -0,0 +1,14 @@
+/** Shared wire contract for request-scoped usage probes. */
+export const ACCOUNT_PROBE_FAILURE_REASONS = [
+    'account_changed',
+    'account_disabled',
+    'account_missing',
+];
+export const USAGE_PROBE_FAILURE_REASONS = [
+    ...ACCOUNT_PROBE_FAILURE_REASONS,
+    'token_rejected',
+    'cli_at_capacity',
+    'timeout',
+    'unknown',
+];
+export const USAGE_UPDATE_TTL_MS = 10 * 60_000;