@teamvibe/poller 0.8.3-rc.2 → 0.8.3

package/dist/classify-failed-iteration.js

@@ -13,6 +13,8 @@
 // Exit codes are fragile — the Claude binary can legitimately return 143
 // for unrelated reasons; the marker decides on poller intent, not process
 // output.
+import { config } from './config.js';
+import { formatLegacyUsageLimitMessage } from './usage-limit-messages.js';
 export function classifyFailedIteration(result) {
     switch (result.killedByPoller) {
         case 'idle':
@@ -68,10 +70,12 @@ export function classifyFailedIteration(result) {
         case 'timeout':
         case undefined: {
             if (!result.killedByPoller && result.quota) {
-                const reset = result.quota.resetAt ? `Resets at ${result.quota.resetAt}.` : 'Reset time unavailable.';
                 return {
                     kind: 'quota', quota: result.quota,
-                    text: `Claude subscription usage limit reached. ${reset} Your message is saved. After the quota pause ends, the next inbox sweep will retry the saved request.`,
+                    text: formatLegacyUsageLimitMessage({
+                        resetAt: result.quota.resetAt ? Date.parse(result.quota.resetAt) : undefined,
+                        timeZone: config.POLLER_TZ,
+                    }),
                     reaction: 'hourglass',
                 };
             }

package/dist/claude-spawner.js

@@ -1,3 +1,4 @@
+import { logPoolFetch, logPoolUsageWrite, poolInfo, poolLabel } from './pool-logging.js';
 import { accountUsageTelemetry, emitCandidateUsage, poolRunTelemetry } from './pool-telemetry.js';
 import { spawn } from 'child_process';
 import { join } from 'path';
@@ -938,6 +939,8 @@ async function runClaudeCode(msg, sessionLog, cwd, brainPath, sessionId, isFirst
         const envPath = config.PERSISTENT_STORAGE_PATH
             ? `${config.PERSISTENT_STORAGE_PATH}/bin:${process.env['PATH'] || ''}`
             : process.env['PATH'];
+        if (runtime?.account)
+            poolInfo(sessionLog, `token target account=${poolLabel(runtime.account)} session=${JSON.stringify(sessionId ?? 'new')} credential=selected account token`);
         const proc = spawn(config.CLAUDE_CLI_PATH, args, {
             cwd,
             env: buildSpawnEnv({
@@ -1418,6 +1421,7 @@ export async function spawnPoolClaudeCode(msg, sessionLog, cwd, sessionId, isFir
     // the main working dir can't trample in-flight writes or pre-push commits.
     // See teamvibe.ai#120. cwd remains the main brain path on fallback / failure.
     let effectiveCwd = cwd;
+    let loggingPool = false;
     let retainWorktree = poolRuntime?.pin?.resumePending === true;
     const poolAttempts = poolRuntime?.attempts?.slice(-1000) ?? [];
     let worktreeOwner;
@@ -1462,12 +1466,15 @@ export async function spawnPoolClaudeCode(msg, sessionLog, cwd, sessionId, isFir
             effectiveSessionId = randomUUID();
         }
         const fetchedPool = poolRuntime ? poolRuntime.pool ?? await fetchRuntimePool(msg) : undefined;
+        loggingPool = fetchedPool !== undefined && fetchedPool.kind !== 'no_accounts_configured';
+        if (fetchedPool)
+            logPoolFetch(sessionLog, fetchedPool);
         const scoped = poolRuntime ? await fetchConfigForSpawn({ pollerId: getPollerId() || '', workspaceId: msg.teamvibe.workspaceId, channelId: msg.teamvibe.channelId }) : undefined;
         const settings = readBrainSettings(effectiveCwd);
         const resolved = fetchedPool?.kind !== 'no_accounts_configured' && poolRuntime?.pin?.workspaceId === msg.teamvibe.workspaceId
             ? { model: poolRuntime.pin.model, modelSource: poolRuntime.pin.modelSource }
             : resolveModel(typeof settings['model'] === 'string' ? settings['model'] : undefined, scoped ?? {}, config.CLAUDE_MODEL);
-        const prepared = poolRuntime ? await preparePool(msg, resolved, poolRuntime.pin, fetchedPool) : undefined;
+        const prepared = poolRuntime ? await preparePool(msg, resolved, poolRuntime.pin, fetchedPool, sessionLog) : undefined;
         const claudeConfigDir = poolRuntime?.pin?.resumePending ? poolRuntime.pin.claudeConfigDir ?? getBaseBrainPath() : getBaseBrainPath();
         const modelNormalizedFrom = scoped?.model === resolved.model && scoped?.modelSource === resolved.modelSource
             ? scoped?.modelNormalizedFrom : undefined;
@@ -1496,8 +1503,9 @@ export async function spawnPoolClaudeCode(msg, sessionLog, cwd, sessionId, isFir
                 if (result.success && id && poolRuntime) {
                     // Complete the inbox before any fallible post-inference store writes.
                     // The loop retains bookkeeping independently of the original prompt.
-                    await poolRuntime.complete(id, { ...accountPin(prepared.account, resolved), effectiveCwd, claudeConfigDir, resumePending: false }, poolAttempts, result.rateLimitInfo);
-                    await emitCandidateUsage(msg, [prepared.account], prepared.store);
+                    const bookkeepingComplete = await poolRuntime.complete(id, { ...accountPin(prepared.account, resolved), effectiveCwd, claudeConfigDir, resumePending: false }, poolAttempts, result.rateLimitInfo);
+                    if (bookkeepingComplete !== false)
+                        await emitCandidateUsage(msg, [prepared.account], prepared.store);
                     retainWorktree = false;
                     return result;
                 }
@@ -1509,9 +1517,9 @@ export async function spawnPoolClaudeCode(msg, sessionLog, cwd, sessionId, isFir
                 // retaining the attempt. Selection waits for all writes before switching.
                 const writes = [];
                 if (result.quota && !result.killedByPoller)
-                    writes.push(prepared.store.recordQuota(prepared.account, result.quota, Date.now(), { expireFutureObservations: true }));
+                    writes.push(logPoolUsageWrite(sessionLog, prepared.account, result.quota.window ? { rateLimitType: result.quota.window } : undefined, () => prepared.store.recordQuota(prepared.account, result.quota, Date.now(), { expireFutureObservations: true }), 'quota'));
                 if (result.rateLimitInfo)
-                    writes.push(prepared.store.recordPassive(prepared.account, result.rateLimitInfo, Date.now(), { expireFutureObservations: true }));
+                    writes.push(logPoolUsageWrite(sessionLog, prepared.account, result.rateLimitInfo, () => prepared.store.recordPassive(prepared.account, result.rateLimitInfo, Date.now(), { expireFutureObservations: true })));
                 if (id && poolRuntime)
                     writes.push(poolRuntime.persist(id, { ...accountPin(prepared.account, resolved), effectiveCwd, claudeConfigDir, resumePending: runtime?.resumePending, sawSendMessageCall }, poolAttempts));
                 const outcomes = await Promise.allSettled(writes);
@@ -1529,17 +1537,24 @@ export async function spawnPoolClaudeCode(msg, sessionLog, cwd, sessionId, isFir
                 if (poolRuntime.shouldStop() || attemptedAccounts.size >= 1000)
                     throw new PoolDeferredError();
                 prepared.pool = await fetchRuntimePool(msg);
+                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.
+                if (prepared.pool.kind === 'ready')
+                    for (const account of prepared.pool.accounts) {
+                        if (attemptedAccounts.has(account.accountId))
+                            poolInfo(sessionLog, `skipped account=${poolLabel(account)} reason=already exhausted in this session`);
+                    }
                 const remaining = prepared.pool.kind === 'ready' ? prepared.pool.accounts.filter(a => !attemptedAccounts.has(a.accountId)) : [];
-                const selected = await selectPoolForResolvedModel(resolved, { workspaceId: msg.teamvibe.workspaceId, pool: remaining.length ? { kind: 'ready', accounts: remaining } : prepared.pool, store: prepared.store, now: Date.now() });
+                const selected = await selectPoolForResolvedModel(resolved, { workspaceId: msg.teamvibe.workspaceId, pool: remaining.length && prepared.pool.kind === 'ready' ? { ...prepared.pool, accounts: remaining } : prepared.pool, store: prepared.store, now: Date.now(), log: sessionLog, logAllExhausted: remaining.length === 0 });
                 if (selected.kind !== 'selected' || attemptedAccounts.has(selected.account.accountId))
-                    throw await poolDeferredError(prepared.pool, resolved, prepared.store);
+                    throw await poolDeferredError(prepared.pool, resolved, prepared.store, undefined, remaining.length ? sessionLog : undefined);
                 effectiveSessionId = result.attemptedSessionId ?? effectiveSessionId;
                 if (!effectiveSessionId)
                     throw new PoolDeferredError();
                 const fromAccount = prepared.account;
+                poolInfo(sessionLog, `switch from=${poolLabel(fromAccount)} to=${poolLabel(selected.account)} session=${JSON.stringify(effectiveSessionId)}`);
                 prepared.account = selected.account;
                 runtime.account = selected.account;
                 runtime.resumePending = true;
@@ -1574,6 +1589,8 @@ export async function spawnPoolClaudeCode(msg, sessionLog, cwd, sessionId, isFir
     }
     catch (error) {
         if (error instanceof PoolDeferredError) {
+            if (loggingPool)
+                poolInfo(sessionLog, `work deferred eligibleAt=${new Date(error.eligibleAt).toISOString()} providerResetAt=${error.resetAt ?? 'unknown'}`);
             retainWorktree = true;
             error.attempts = poolAttempts;
         }

package/dist/event-queue.js

@@ -69,7 +69,7 @@ export async function flush() {
         return;
     isFlushing = true;
     try {
-        const batch = [...queue];
+        const batch = queue.splice(0);
         const failed = [];
         for (const event of batch) {
             const ok = await flushOne(event);
@@ -77,7 +77,7 @@ export async function flush() {
                 failed.push(event);
             }
         }
-        queue = failed;
+        queue = [...failed, ...queue].slice(-MAX_QUEUE_SIZE);
         if (failed.length > 0) {
             logger.debug(`[EventQueue] ${failed.length} event(s) failed to flush, will retry`);
         }

package/dist/poller.d.ts

@@ -33,6 +33,7 @@ export declare function describeFailureReason(killedByPoller: KilledByPoller | u
 export declare const END_OF_TURN_NO_FURTHER_RESPONSE_SENTINEL = "NO_FURTHER_RESPONSE_NEEDED";
 export declare function endOfTurnFallbackText(hasSlackContext: boolean, result: Pick<SpawnResult, 'success' | 'sawSendMessageCall' | 'lastPlainTextContent'>): string | undefined;
 export declare function runInboxLoop(threadId: string, kbPath: string, queueMessage: TeamVibeQueueMessage, sessionLog: ReturnType<typeof logger.createSession>): Promise<void>;
+export declare function pollLoop(): Promise<void>;
 export declare function __setSleepForTest(impl: (ms: number) => Promise<void>): void;
 export declare function __setShuttingDownForTest(value: boolean): void;
 export declare function startPoller(): Promise<void>;

package/dist/poller.js

@@ -1,4 +1,8 @@
-import { poolRunTelemetry } from './pool-telemetry.js';
+import { isUsageProbe, handleUsageProbe } from './usage-probe-job.js';
+import { fetchSubscriptionPool } from './subscription-pool-client.js';
+import { formatPoolUsageLimitMessage } from './usage-limit-messages.js';
+import { logPoolUsageWrite } from './pool-logging.js';
+import { emitCandidateUsage, poolRunTelemetry } from './pool-telemetry.js';
 import { config, POLLER_VERSION } from './config.js';
 import { logger, setLogContext } from './logger.js';
 import { pollMessages, deleteMessage, } from './sqs-poller.js';
@@ -284,14 +288,17 @@ export async function runInboxLoop(threadId, kbPath, queueMessage, sessionLog) {
         let currentPin = session.subscription_pin;
         let deferred = false;
         let poolIteration = false;
-        const retryCompletedBookkeeping = async (state, liveCompletion = false) => {
+        const retryCompletedBookkeeping = async (state, pool, liveCompletion = false) => {
             if (!state.completed)
                 return true;
             const writes = [];
             // A live run may expire evidence after clock rollback; replaying an old
             // completion must preserve observations produced by newer concurrent runs.
+            const lastAttempt = state.attempts?.at(-1);
+            // Existing telemetry falls back to account IDs. Local pool logs use labels only.
+            const accountLabel = lastAttempt?.accountLabel !== state.pin.accountId ? lastAttempt?.accountLabel : undefined;
             if (state.completed.rateLimitInfo)
-                writes.push(subscriptionUsageStore().recordPassive(state.pin, state.completed.rateLimitInfo, state.completed.observedAt, liveCompletion ? { expireFutureObservations: true } : undefined));
+                writes.push(logPoolUsageWrite(sessionLog, { label: accountLabel }, state.completed.rateLimitInfo, () => subscriptionUsageStore().recordPassive(state.pin, state.completed.rateLimitInfo, state.completed.observedAt, liveCompletion ? { expireFutureObservations: true } : undefined)));
             writes.push(lockToken ? updateSessionId(threadId, lockToken, state.sessionId, state.pin) : Promise.reject(new Error('Missing lock')));
             const outcomes = await Promise.allSettled(writes);
             if (outcomes.some(outcome => outcome.status === 'rejected' || outcome.value === false)) {
@@ -306,6 +313,17 @@ export async function runInboxLoop(threadId, kbPath, queueMessage, sessionLog) {
             }
             currentSessionId = state.sessionId;
             currentPin = state.pin;
+            // The spawner publishes live completions only after bookkeeping succeeds.
+            // Recovery uses a validated current account, without attributing an old
+            // credential's observation to its replacement.
+            if (!liveCompletion && pool.kind === 'ready') {
+                const account = pool.accounts.find(account => account.workspaceId === state.pin.workspaceId &&
+                    account.workspaceId === queueMessage.teamvibe.workspaceId &&
+                    account.accountId === state.pin.accountId &&
+                    account.credentialVersion === state.pin.credentialVersion);
+                if (account)
+                    await emitCandidateUsage(queueMessage, [account], subscriptionUsageStore());
+            }
             clearInboxRuntime(kbPath, threadId);
             return true;
         };
@@ -340,7 +358,7 @@ export async function runInboxLoop(threadId, kbPath, queueMessage, sessionLog) {
                     // Completed prompts never enter pickNextMessage/spawn again, even
                     // when the usage store or the session pin needs a later repair.
                     markProcessed(kbPath, threadId, completion.filename);
-                    if (Date.now() >= completion.completed.observedAt && Date.now() < completion.completed.retryAt || !await retryCompletedBookkeeping(completion)) {
+                    if (Date.now() >= completion.completed.observedAt && Date.now() < completion.completed.retryAt || !await retryCompletedBookkeeping(completion, pool)) {
                         deferred = hasUnprocessed(kbPath, threadId);
                         break;
                     }
@@ -428,7 +446,7 @@ export async function runInboxLoop(threadId, kbPath, queueMessage, sessionLog) {
                             currentPin = pin;
                             succeeded = true;
                             clearPoolDefer(threadId);
-                            await retryCompletedBookkeeping(state, true);
+                            return retryCompletedBookkeeping(state, pool, true);
                         },
                         persist: async (id, pin, attempts) => {
                             pin = { ...pin, inboxFilename: message.filename };
@@ -579,7 +597,13 @@ export async function runInboxLoop(threadId, kbPath, queueMessage, sessionLog) {
                         if (!reconcile && !setPoolNotice(threadId, pause.episodeId, 'claimed'))
                             throw new PoolDeferredError(error.eligibleAt);
                         try {
-                            await sendSlackMessage(deliveryMsg, `Claude subscription pool unavailable. ${pause.resetAt ? `Earliest reset: ${pause.resetAt}.` : 'Reset time unavailable.'} Your message is saved. The next inbox sweep at or after ${new Date(pause.resumeAt).toISOString()} will resume pending work.`, { clientMessageId: pause.episodeId, ...(reconcile ? { reconcile: true } : {}) });
+                            const notice = formatPoolUsageLimitMessage({
+                                ...error.notice,
+                                thresholdDeferred: error.notice?.thresholdDeferred && !error.attempts?.some(a => a.quota),
+                                resetAt: pause.resetAt ? Date.parse(pause.resetAt) : error.notice?.resetAt,
+                                timeZone: config.POLLER_TZ,
+                            });
+                            await sendSlackMessage(deliveryMsg, notice, { clientMessageId: pause.episodeId, ...(reconcile ? { reconcile: true } : {}) });
                             setPoolNotice(threadId, pause.episodeId, 'delivered');
                         }
                         catch (deliveryError) {
@@ -910,7 +934,7 @@ function isAuthError(error) {
         message.includes('security token') ||
         message.includes('Auth failed'));
 }
-async function pollLoop() {
+export async function pollLoop() {
     logger.info('Poll loop started');
     while (!shuttingDown) {
         try {
@@ -951,8 +975,35 @@ async function pollLoop() {
                 continue;
             }
             logger.info(`Received ${messages.length} message(s) from SQS`);
-            // Deduplicate: if multiple messages for the same thread, keep only the latest
-            const { unique, duplicates } = deduplicateMessages(messages);
+            // Workspace jobs have no thread and bypass every channel/session path.
+            const channelMessages = [];
+            for (const msg of messages) {
+                if (isUsageProbe(msg.queueMessage)) {
+                    const job = msg.queueMessage;
+                    await handleUsageProbe(job, {
+                        fetchPool: () => fetchSubscriptionPool({
+                            pollerId: getPollerId() || '',
+                            workspaceId: job.workspaceId,
+                            accountId: job.accountId,
+                            credentialVersion: job.credentialVersion,
+                            requestId: job.requestId,
+                        }, {
+                            apiUrl: config.TEAMVIBE_API_URL,
+                            pollerToken: config.TEAMVIBE_POLLER_TOKEN || '',
+                        }),
+                        store: subscriptionUsageStore(),
+                        cliPath: config.CLAUDE_CLI_PATH,
+                        isAtCapacity,
+                        emit: emitEvent,
+                        log: line => logger.info(line),
+                    });
+                    await deleteMessage(msg.receiptHandle);
+                    continue;
+                }
+                channelMessages.push(msg);
+            }
+            // Deduplicate real messages for the same thread, keeping the latest.
+            const { unique, duplicates } = deduplicateMessages(channelMessages);
             for (const dup of duplicates) {
                 logger.info(`Deleting duplicate message for thread ${dup.queueMessage.thread_id} (messageId: ${dup.messageId})`);
                 await deleteMessage(dup.receiptHandle);

package/dist/pool-logging.d.ts

@@ -0,0 +1,18 @@
+import type { SessionLogger } from './logger.js';
+import type { ClaudeRateLimitInfo } from './claude-rate-limit.js';
+import { type AccountIdentity, type AccountUsageState, type PoolFetchResult, type SelectionOutcome } from './subscription-selection.js';
+export type PoolInfoLogger = Pick<SessionLogger, 'info'>;
+type LabeledAccount = AccountIdentity & {
+    label?: string;
+};
+export declare function poolInfo(log: PoolInfoLogger, message: string): void;
+export declare function poolLabel(account: {
+    label?: string;
+}): string;
+export declare function logPoolFetch(log: PoolInfoLogger, pool: PoolFetchResult): void;
+export declare function logPoolSelection<A extends LabeledAccount>(log: PoolInfoLogger, pool: PoolFetchResult<A>, states: Readonly<Record<string, AccountUsageState>>, model: string | undefined, now: number, selected: SelectionOutcome<A>, logAllExhausted?: boolean): void;
+/** Log the real store promise without changing its rejection or retry behavior. */
+export declare function logPoolUsageWrite(log: PoolInfoLogger, account: {
+    label?: string;
+}, info: ClaudeRateLimitInfo | undefined, write: () => Promise<void>, source?: 'passive' | 'quota'): Promise<void>;
+export {};

package/dist/pool-logging.js

@@ -0,0 +1,79 @@
+import { redactStartupText } from './startup-auth.js';
+import { normalizePassiveUsage, selectSubscriptionAccount } 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
+// arbitrary model/label whitespace on one physical log line.
+export function poolInfo(log, message) {
+    log.info(redactStartupText(`[Pool] ${message}`).replace(/[\r\n]/g, ' '));
+}
+export function poolLabel(account) {
+    const label = account.label;
+    return JSON.stringify(label && label.length <= 128 && !/sk-ant-|Bearer\s|[\r\n]/i.test(label) ? label : 'unlabeled');
+}
+export function logPoolFetch(log, pool) {
+    if (pool.kind === 'no_accounts_configured')
+        return;
+    // The API exposes usable members only; hidden disabled labels are unavailable.
+    const enabled = pool.kind === 'ready' ? pool.accounts.filter(a => a.enabled).length : pool.kind === 'fetch_unavailable' && pool.reason === 'no_usable_accounts' ? 0 : 'unknown';
+    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}` : ''}`);
+}
+export function logPoolSelection(log, pool, states, model, now, selected, logAllExhausted = true) {
+    if (pool.kind !== 'ready')
+        return;
+    for (const account of pool.accounts) {
+        if (!account.enabled) {
+            poolInfo(log, `skipped account=${poolLabel(account)} reason=disabled`);
+            continue;
+        }
+        const candidate = selectSubscriptionAccount({ pool: { ...pool, accounts: [account] }, states, model, now });
+        if (candidate.kind === 'deferred') {
+            const usageOnly = selectSubscriptionAccount({ pool: { ...pool, accounts: [account] }, states: { [account.accountId]: { usage: states[account.accountId]?.usage } }, model, now });
+            poolInfo(log, `skipped account=${poolLabel(account)} reason=${usageOnly.kind === 'deferred' ? `usage >=${account.useFullQuota ? 100 : 90}%` : 'reactive quota'} eligibleAt=${new Date(candidate.eligibleAt).toISOString()}`);
+        }
+        else if (candidate.kind === 'selected' && selected.kind === 'selected' && account.accountId !== selected.account.accountId) {
+            const reason = candidate.provenance === 'unknown' && selected.provenance === 'known' ? 'known observation preferred' : candidate.provenance === 'known' && selected.provenance === 'known' && candidate.score > selected.score ? 'higher usage score' : 'deterministic account order';
+            poolInfo(log, `skipped account=${poolLabel(account)} reason=${reason}`);
+        }
+    }
+    if (selected.kind === 'deferred' && logAllExhausted) {
+        // Ask the same policy about each observation so model scope, freshness and
+        // reset expiry stay identical to selection. An account must clear ALL its
+        // blockers; the pool can resume when its first account clears them.
+        const resets = pool.accounts.filter(a => a.enabled).map(account => {
+            const state = states[account.accountId];
+            const deadlines = [];
+            for (const window of state?.usage?.windows ?? []) {
+                const candidate = selectSubscriptionAccount({ pool: { ...pool, accounts: [account] }, states: { [account.accountId]: { usage: { ...state.usage, windows: [window] } } }, model, now });
+                if (candidate.kind === 'deferred')
+                    deadlines.push(window.resetAt);
+            }
+            for (const reactive of state?.reactive ?? []) {
+                const candidate = selectSubscriptionAccount({ pool: { ...pool, accounts: [account] }, states: { [account.accountId]: { reactive: [reactive] } }, model, now });
+                if (candidate.kind === 'deferred')
+                    deadlines.push(reactive.quota.resetAt ? Date.parse(reactive.quota.resetAt) : undefined);
+            }
+            return deadlines.length && deadlines.every(d => d !== undefined && Number.isFinite(d)) ? Math.max(...deadlines) : undefined;
+        });
+        const earliestResetAt = resets.length && resets.every(r => r !== undefined) ? new Date(Math.min(...resets)).toISOString() : 'unknown';
+        poolInfo(log, `deferred reason=all accounts exhausted earliestResetAt=${earliestResetAt} eligibleAt=${new Date(selected.eligibleAt).toISOString()}`);
+    }
+    if (selected.kind === 'selected') {
+        const score = selected.provenance === 'known' ? `${selected.score}% headroom=${100 - selected.score}%` : 'unknown (no observation)';
+        poolInfo(log, `selected account=${poolLabel(selected.account)} model=${JSON.stringify(model ?? 'CLI default')} score=${score}`);
+    }
+}
+/** Log the real store promise without changing its rejection or retry behavior. */
+export async function logPoolUsageWrite(log, account, info, write, source = 'passive') {
+    const windows = info ? normalizePassiveUsage(safeRateLimitInfo(info), Date.now()).windows.map(w => `${w.window}${source === 'passive' ? `/${w.scope}` : ''}:${w.percent === undefined ? 'unknown' : `${Number(w.percent.toFixed(2))}%`}`).join(',') : '';
+    try {
+        await write();
+        poolInfo(log, `usage write account=${poolLabel(account)} result=ok windows=${windows || 'none'} source=${source}`);
+    }
+    catch (error) {
+        const name = error instanceof Error && ['Error', 'TypeError', 'RangeError', 'AbortError', 'TimeoutError', 'SubscriptionUsageStoreError'].includes(error.name) ? error.name : 'UnknownError';
+        poolInfo(log, `usage write account=${poolLabel(account)} result=failed errorClass=${name} windows=${windows || 'none'} source=${source}`);
+        throw error;
+    }
+}

package/dist/subscription-pool-client.d.ts

@@ -14,8 +14,11 @@ export interface SubscriptionAccount extends AccountIdentity {
 }
 export interface PoolFetchInput {
     workspaceId: string;
-    channelId: string;
+    channelId?: string;
     pollerId: string;
+    accountId?: string;
+    requestId?: string;
+    credentialVersion?: string;
 }
 export interface PoolClientOptions {
     apiUrl: string;

package/dist/subscription-pool-client.js

@@ -71,14 +71,18 @@ export async function readSubscriptionJson(response) {
 export async function fetchSubscriptionPool(input, options) {
     let url;
     try {
-        if (!input.pollerId || !input.workspaceId || !input.channelId || !options.pollerToken)
+        if (!input.pollerId || !input.workspaceId || (!input.channelId && !input.requestId) || !options.pollerToken)
             throw new Error('Missing configuration');
         url = new URL('/subscription-accounts/spawn', options.apiUrl);
         if (!['https:', 'http:'].includes(url.protocol) || url.username || url.password)
             throw new Error('Invalid URL');
         url.searchParams.set('pollerId', input.pollerId);
         url.searchParams.set('workspaceId', input.workspaceId);
-        url.searchParams.set('channelId', input.channelId);
+        if (input.channelId)
+            url.searchParams.set('channelId', input.channelId);
+        for (const name of ['accountId', 'requestId', 'credentialVersion'])
+            if (input[name])
+                url.searchParams.set(name, input[name]);
     }
     catch {
         return { kind: 'fetch_unavailable', reason: 'configuration' };
@@ -121,7 +125,7 @@ export async function fetchSubscriptionPool(input, options) {
                     return { kind: 'fetch_unavailable', reason: 'invalid_response' };
                 }
                 ids.add(item['accountId']);
-                accounts.push({ accountId: item['accountId'], workspaceId: input.workspaceId, credentialVersion: item['credentialVersion'], enabled: true, harness: 'CLAUDE', ...(typeof item['label'] === 'string' && item['label'].length <= 128 && !/sk-ant-|Bearer\s|[\r\n]/i.test(item['label']) ? { label: item['label'] } : {}), credential: new SubscriptionCredential(credential['token']) });
+                accounts.push({ accountId: item['accountId'], workspaceId: input.workspaceId, credentialVersion: item['credentialVersion'], enabled: true, useFullQuota: item['useFullQuota'] === true, harness: 'CLAUDE', ...(typeof item['label'] === 'string' && item['label'].length <= 128 && !/sk-ant-|Bearer\s|[\r\n]/i.test(item['label']) ? { label: item['label'] } : {}), credential: new SubscriptionCredential(credential['token']) });
             }
             if (accounts.length)
                 return { kind: 'ready', accounts };

package/dist/subscription-pool.d.ts

@@ -1,3 +1,4 @@
+import { type PoolInfoLogger } from './pool-logging.js';
 import type { resolveModel } from './claude-spawner.js';
 import { type AccountIdentity, type PoolFetchResult, type SelectionOutcome } from './subscription-selection.js';
 import { type SubscriptionUsageStore } from './subscription-usage-store.js';
@@ -15,4 +16,6 @@ export declare function selectPoolForResolvedModel<A extends AccountIdentity>(re
     pool: PoolFetchResult<A>;
     store: SubscriptionUsageStore;
     now: number;
+    log?: PoolInfoLogger;
+    logAllExhausted?: boolean;
 }): Promise<ResolvedPoolSelection<A>>;

package/dist/subscription-pool.js

@@ -1,3 +1,4 @@
+import { logPoolSelection } from './pool-logging.js';
 import { selectSubscriptionAccount } from './subscription-selection.js';
 import { usageStateForSelection } from './subscription-usage-store.js';
 /**
@@ -9,6 +10,8 @@ export async function selectPoolForResolvedModel(resolvedModel, input) {
     if (input.pool.kind !== 'ready')
         return { ...input.pool, ...resolvedModel };
     if (!input.pool.accounts.length || input.pool.accounts.some(a => a.workspaceId !== input.workspaceId || !a.enabled)) {
+        if (input.log)
+            logPoolSelection(input.log, input.pool, {}, resolvedModel.model, input.now, { kind: 'fetch_unavailable', reason: 'invalid_response' });
         return { kind: 'fetch_unavailable', reason: 'invalid_response', ...resolvedModel };
     }
     const states = Object.create(null);
@@ -20,5 +23,8 @@ export async function selectPoolForResolvedModel(resolvedModel, input) {
     catch {
         return { kind: 'usage_unavailable', ...resolvedModel };
     }
-    return { ...selectSubscriptionAccount({ pool: input.pool, states, model: resolvedModel.model, now: input.now }), ...resolvedModel };
+    const selected = selectSubscriptionAccount({ pool: input.pool, states, model: resolvedModel.model, now: input.now });
+    if (input.log)
+        logPoolSelection(input.log, input.pool, states, resolvedModel.model, input.now, selected, input.logAllExhausted);
+    return { ...selected, ...resolvedModel };
 }

package/dist/subscription-runtime.d.ts

@@ -1,8 +1,10 @@
+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 { 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';
@@ -25,6 +27,7 @@ export declare class PoolDeferredError extends Error {
     readonly eligibleAt: number;
     readonly resetAt?: string | undefined;
     attempts?: readonly PoolAttempt[];
+    notice?: PoolUsageLimitNotice;
     constructor(eligibleAt?: number, resetAt?: string | undefined);
 }
 export interface PoolRuntimeOptions {
@@ -33,12 +36,13 @@ export interface PoolRuntimeOptions {
     attempts?: readonly PoolAttempt[];
     quotaDeferEpisodes?: number;
     persist: (sessionId: string, pin: SubscriptionPin, attempts?: readonly PoolAttempt[]) => Promise<void>;
-    complete: (sessionId: string, pin: SubscriptionPin, attempts: readonly PoolAttempt[], rateLimitInfo?: ClaudeRateLimitInfo) => Promise<void>;
+    /** False retains bookkeeping for recovery, which owns the usage emission. */
+    complete: (sessionId: string, pin: SubscriptionPin, attempts: readonly PoolAttempt[], rateLimitInfo?: ClaudeRateLimitInfo) => Promise<boolean | void>;
     shouldStop: () => boolean;
 }
 export declare function subscriptionUsageStore(): FileSubscriptionUsageStore;
 export declare function fetchRuntimePool(msg: TeamVibeQueueMessage): Promise<PoolFetchResult<SubscriptionAccount>>;
-export declare function preparePool(msg: TeamVibeQueueMessage, resolved: ResolvedPoolModel, pin?: SubscriptionPin, fetched?: PoolFetchResult<SubscriptionAccount>): Promise<{
+export declare function preparePool(msg: TeamVibeQueueMessage, resolved: ResolvedPoolModel, pin?: SubscriptionPin, fetched?: PoolFetchResult<SubscriptionAccount>, log?: PoolInfoLogger): Promise<{
     account: SubscriptionAccount;
     store: FileSubscriptionUsageStore;
     pool: PoolFetchResult<SubscriptionAccount>;
@@ -50,4 +54,4 @@ 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. */
-export declare function poolDeferredError(pool: PoolFetchResult<SubscriptionAccount>, resolved: ResolvedPoolModel, store: SubscriptionUsageStore, eligibleAt?: number): Promise<PoolDeferredError>;
+export declare function poolDeferredError(pool: PoolFetchResult<SubscriptionAccount>, resolved: ResolvedPoolModel, store: SubscriptionUsageStore, eligibleAt?: number, log?: PoolInfoLogger): Promise<PoolDeferredError>;

package/dist/subscription-runtime.js

@@ -1,15 +1,17 @@
+import { poolInfo, poolLabel } from './pool-logging.js';
 import { emitCandidateUsage } from './pool-telemetry.js';
 import { join } from 'node:path';
 import { config } from './config.js';
 import { getPollerId } from './auth-provider.js';
 import { fetchSubscriptionPool } from './subscription-pool-client.js';
 import { selectPoolForResolvedModel } from './subscription-pool.js';
-import { FileSubscriptionUsageStore } from './subscription-usage-store.js';
-import { POOL_RECHECK_MS } from './subscription-selection.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';
 export class PoolDeferredError extends Error {
     eligibleAt;
     resetAt;
     attempts;
+    notice;
     constructor(eligibleAt = Date.now() + POOL_RECHECK_MS, resetAt) {
         super('Subscription pool unavailable; work retained');
         this.eligibleAt = eligibleAt;
@@ -22,7 +24,7 @@ export function subscriptionUsageStore() {
 export async function fetchRuntimePool(msg) {
     return fetchSubscriptionPool({ pollerId: getPollerId() || '', workspaceId: msg.teamvibe.workspaceId, channelId: msg.teamvibe.channelId }, { apiUrl: config.TEAMVIBE_API_URL, pollerToken: config.TEAMVIBE_POLLER_TOKEN || '' });
 }
-export async function preparePool(msg, resolved, pin, fetched) {
+export async function preparePool(msg, resolved, pin, fetched, log) {
     const pool = fetched ?? await fetchRuntimePool(msg);
     const store = subscriptionUsageStore();
     if (pool.kind === 'ready')
@@ -30,14 +32,25 @@ export async function preparePool(msg, resolved, pin, fetched) {
     if (pool.kind === 'ready' && pin?.workspaceId === msg.teamvibe.workspaceId) {
         const account = pool.accounts.find(a => a.accountId === pin.accountId);
         if (account) {
-            const selected = await selectPoolForResolvedModel(resolved, { workspaceId: msg.teamvibe.workspaceId, pool: { kind: 'ready', accounts: [account] }, store, now: Date.now() });
-            if (selected.kind === 'selected')
+            const selected = await selectPoolForResolvedModel(resolved, { workspaceId: msg.teamvibe.workspaceId, pool: { ...pool, accounts: [account] }, store, now: Date.now(), log, logAllExhausted: false });
+            if (selected.kind === 'selected') {
+                if (log)
+                    for (const other of pool.accounts) {
+                        if (other.accountId !== account.accountId)
+                            poolInfo(log, `skipped account=${poolLabel(other)} reason=session pinned elsewhere`);
+                    }
                 return { account, store, pool };
+            }
         }
     }
-    const selected = await selectPoolForResolvedModel(resolved, { workspaceId: msg.teamvibe.workspaceId, pool, store, now: Date.now() });
-    if (selected.kind === 'selected')
+    const selected = await selectPoolForResolvedModel(resolved, { workspaceId: msg.teamvibe.workspaceId, pool, store, now: Date.now(), log });
+    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 };
+    }
     if (selected.kind === 'no_accounts_configured')
         return { account: undefined, store, pool };
     throw await poolDeferredError(pool, resolved, store, selected.kind === 'deferred' ? selected.eligibleAt : undefined);
@@ -50,25 +63,64 @@ export async function validateAccount(account, resolved) {
     if (selected.kind !== 'selected')
         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) {
+    if (pool.kind !== 'ready')
+        return {};
+    const now = Date.now();
+    try {
+        const accounts = await Promise.all(pool.accounts.map(async (account) => {
+            const state = usageStateForSelection(await store.read(account), now);
+            const usage = state.usage;
+            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 blockers = windows.filter(w => 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,
+                thresholdBlocked: blockers.length > 0,
+                resetAt: resets.length && resets.every((r) => r !== undefined) ? Math.max(...resets) : undefined,
+            };
+        }));
+        const thresholdDeferred = accounts.length > 0 && accounts.every(a => a.thresholdBlocked) && !accounts.some(a => a.rejected);
+        // Snapshot expiry is only a recheck. Use actual window resets for the notice.
+        const resets = accounts.map(a => a.resetAt);
+        const resetAt = thresholdDeferred && resets.every((r) => r !== undefined) ? Math.min(...resets) : undefined;
+        return { accounts, thresholdDeferred, resetAt };
+    }
+    catch {
+        return {};
+    }
+}
 /** A snapshot TTL/recheck is not a provider reset. Report a reset only when reactive evidence establishes it. */
-export async function poolDeferredError(pool, resolved, store, eligibleAt) {
+export async function poolDeferredError(pool, resolved, store, eligibleAt, log) {
+    const notice = await poolUsageNotice(pool, store);
+    let usageDeferred = eligibleAt !== undefined;
+    const deferredError = (resetAt) => {
+        const error = new PoolDeferredError(eligibleAt, resetAt);
+        error.notice = { ...notice, thresholdDeferred: usageDeferred && notice.thresholdDeferred, resetAt: resetAt ? Date.parse(resetAt) : notice.resetAt };
+        return error;
+    };
     if (eligibleAt === undefined) {
-        const selected = await selectPoolForResolvedModel(resolved, { workspaceId: pool.kind === 'ready' ? pool.accounts[0]?.workspaceId ?? '' : '', pool, store, now: Date.now() });
+        const selected = await selectPoolForResolvedModel(resolved, { workspaceId: pool.kind === 'ready' ? pool.accounts[0]?.workspaceId ?? '' : '', pool, store, now: Date.now(), log });
+        usageDeferred = selected.kind === 'deferred';
         eligibleAt = selected.kind === 'deferred' ? selected.eligibleAt : Date.now() + POOL_RECHECK_MS;
     }
     if (pool.kind === 'ready') {
         try {
             for (const account of pool.accounts) {
-                const selected = await selectPoolForResolvedModel(resolved, { workspaceId: account.workspaceId, pool: { kind: 'ready', accounts: [account] }, store, now: Date.now() });
+                const selected = await selectPoolForResolvedModel(resolved, { workspaceId: account.workspaceId, pool: { ...pool, accounts: [account] }, store, now: Date.now() });
                 if (selected.kind !== 'deferred' || selected.eligibleAt !== eligibleAt)
                     continue;
                 const state = await store.read(account);
                 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 new PoolDeferredError(eligibleAt, new Date(eligibleAt).toISOString());
+                    return deferredError(new Date(eligibleAt).toISOString());
             }
         }
         catch { }
     }
-    return new PoolDeferredError(eligibleAt);
+    return deferredError();
 }

package/dist/subscription-selection.d.ts

@@ -8,6 +8,7 @@ export interface AccountIdentity {
     workspaceId: string;
     accountId: string;
     credentialVersion: string;
+    useFullQuota?: boolean;
     enabled: boolean;
 }
 export type PoolFetchResult<A extends AccountIdentity = AccountIdentity> = {
@@ -27,7 +28,8 @@ export type PoolFetchResult<A extends AccountIdentity = AccountIdentity> = {
 };
 export interface UsageWindow {
     window: 'five_hour' | 'seven_day';
-    scope: 'global' | 'sonnet' | 'opus' | 'haiku' | 'uncertain';
+    scope: 'global' | 'sonnet' | 'opus' | 'haiku' | 'fable' | 'uncertain';
+    status?: 'allowed' | 'allowed_warning' | 'rejected';
     percent?: number;
     resetAt?: number;
 }

package/dist/subscription-selection.js

@@ -35,12 +35,27 @@ export function normalizePassiveUsage(value, observedAt) {
     }
     const type = info['rateLimitType'];
     if (typeof type === 'string') {
-        const legacy = type.match(/^(five_hour|seven_day)(?:_(sonnet|opus|haiku))?$/);
-        windows.push({
+        const legacy = type.match(/^(five_hour|seven_day)(?:_(sonnet|opus|haiku|fable))?$/);
+        const candidate = {
             window: legacy?.[1] === 'five_hour' ? 'five_hour' : 'seven_day',
             scope: legacy ? (legacy[2] ?? 'global') : 'uncertain',
             percent: percent(info['utilization'], 1), resetAt: epoch(info['resetsAt']),
-        });
+            ...(info['status'] === 'allowed' || info['status'] === 'allowed_warning' || info['status'] === 'rejected'
+                ? { status: info['status'] } : {}),
+        };
+        const existing = windows.find(w => w.window === candidate.window && w.scope === candidate.scope);
+        if (existing) {
+            if (candidate.status !== undefined)
+                existing.status = candidate.status;
+            // Collapse the same quota while retaining conservative conflict evidence.
+            if (candidate.percent !== undefined)
+                existing.percent = Math.max(existing.percent ?? candidate.percent, candidate.percent);
+            if (candidate.resetAt !== undefined)
+                existing.resetAt = Math.max(existing.resetAt ?? candidate.resetAt, candidate.resetAt);
+        }
+        else {
+            windows.push(candidate);
+        }
     }
     return { source: 'passive', observedAt, windows };
 }
@@ -118,7 +133,7 @@ export function selectSubscriptionAccount(input) {
         const windows = fresh ? usage.windows.filter(w => 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 >= USAGE_THRESHOLD_PERCENT)
+            if (w.percent !== undefined && w.percent >= (account.useFullQuota ? 100 : USAGE_THRESHOLD_PERCENT))
                 blockers.push(Math.min(w.resetAt ?? expiry, expiry));
         }
         if (blockers.length) {

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

@@ -27,6 +27,7 @@ export interface SubscriptionUsageStore {
     recordQuota(key: UsageKey, quota: ClaudeQuotaFailure, observedAt: number, options?: UsageWriteOptions): Promise<void>;
     /** Persist BEFORE network I/O; one attempt per credential version, including restart. */
     beginProbe(key: UsageKey, observedAt: number): Promise<boolean>;
+    claimProbeRequest(requestId: string, expiresAt: number): Promise<boolean>;
     finishProbe(key: UsageKey, observation: ProbeObservation): Promise<void>;
 }
 export declare function usageStateForSelection(state: StoredAccountUsage, now: number): AccountUsageState;
@@ -43,5 +44,7 @@ export declare class FileSubscriptionUsageStore implements SubscriptionUsageStor
     recordPassive(key: UsageKey, rateLimitInfo: ClaudeRateLimitInfo, observedAt: number, options?: UsageWriteOptions): Promise<void>;
     recordQuota(key: UsageKey, quota: ClaudeQuotaFailure, observedAt: number, options?: UsageWriteOptions): Promise<void>;
     beginProbe(key: UsageKey, observedAt: number): Promise<boolean>;
+    /** Request claims live in the local data directory, alongside usage, never in a brain. */
+    claimProbeRequest(requestId: string, expiresAt: number): Promise<boolean>;
     finishProbe(key: UsageKey, observation: ProbeObservation): Promise<void>;
 }

package/dist/subscription-usage-store.js

@@ -33,9 +33,9 @@ function validTime(now) {
 export function safeRateLimitInfo(info) {
     const parsed = parseClaudeRateLimitInfo(info) ?? {};
     // Never persist arbitrary status strings or incidental stream fields.
-    if (parsed.status !== 'allowed' && parsed.status !== 'allowed_warning')
+    if (parsed.status !== 'allowed' && parsed.status !== 'allowed_warning' && parsed.status !== 'rejected')
         delete parsed.status;
-    if (parsed.rateLimitType && !/^(five_hour|seven_day)(?:_(sonnet|opus|haiku))?$/.test(parsed.rateLimitType))
+    if (parsed.rateLimitType && !/^(five_hour|seven_day)(?:_(sonnet|opus|haiku|fable))?$/.test(parsed.rateLimitType))
         parsed.rateLimitType = 'uncertain';
     delete parsed.overageStatus;
     delete parsed.overageDisabledReason;
@@ -69,7 +69,7 @@ function safeProbe(value) {
         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'].includes(w['scope']) ? w['scope'] : 'uncertain';
+            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 };
@@ -194,6 +194,23 @@ export class FileSubscriptionUsageStore {
             return true;
         });
     }
+    /** Request claims live in the local data directory, alongside usage, never in a brain. */
+    async claimProbeRequest(requestId, expiresAt) {
+        validTime(expiresAt);
+        const path = join(this.#directory, 'processed-probe-requests.json');
+        return serial(path, async () => {
+            const now = Date.now();
+            const stored = await this.#load(path, {});
+            if (Object.values(stored).some(expiry => !Number.isFinite(expiry)))
+                throw new SubscriptionUsageStoreError();
+            const claims = Object.fromEntries(Object.entries(stored).filter(([, expiry]) => expiry > now));
+            if (Object.hasOwn(claims, requestId))
+                return false;
+            claims[requestId] = Math.max(expiresAt, now + 30 * 60_000);
+            await this.#save(path, claims);
+            return true;
+        });
+    }
     async finishProbe(key, observation) {
         validTime(observation.observedAt);
         const path = this.#path(key, true);

package/dist/types.d.ts

@@ -4,7 +4,7 @@ export interface ControlMessage {
     action: 'restart' | 'update';
     targetVersion?: string;
 }
-export type QueueMessage = TeamVibeQueueMessage | ControlMessage;
+export type QueueMessage = TeamVibeQueueMessage | ControlMessage | UsageProbeMessage;
 export interface TeamVibeQueueMessage {
     id: string;
     source: 'slack' | 'email' | 'cron' | 'maintenance' | 'webhook';
@@ -107,3 +107,12 @@ 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

@@ -0,0 +1,22 @@
+/** Owner-facing account policy location. */
+export declare const FULL_QUOTA_SETTINGS_PATH = "Settings \u2192 Connections (account menu \u2192 Use until exhausted)";
+export interface UsageResetTiming {
+    resetAt?: number;
+    now?: number;
+    timeZone?: string;
+}
+export interface UsageLimitAccount {
+    useFullQuota?: boolean;
+    label?: string;
+    windows: readonly {
+        percent?: number;
+    }[];
+    rejected?: boolean;
+}
+export interface PoolUsageLimitNotice extends UsageResetTiming {
+    thresholdDeferred?: boolean;
+    accounts?: readonly UsageLimitAccount[];
+}
+export declare function formatUsageReset(input: UsageResetTiming): string | undefined;
+export declare function formatPoolUsageLimitMessage(input: PoolUsageLimitNotice): string;
+export declare function formatLegacyUsageLimitMessage(input: UsageResetTiming): string;

package/dist/usage-limit-messages.js

@@ -0,0 +1,44 @@
+/** Owner-facing account policy location. */
+export const FULL_QUOTA_SETTINGS_PATH = 'Settings → Connections (account menu → Use until exhausted)';
+export function formatUsageReset(input) {
+    if (input.resetAt === undefined || !Number.isFinite(input.resetAt))
+        return undefined;
+    const now = input.now ?? Date.now();
+    let time;
+    try {
+        time = new Intl.DateTimeFormat('en-GB', {
+            timeZone: input.timeZone || 'UTC', hour: '2-digit', minute: '2-digit', hourCycle: 'h23',
+        }).format(input.resetAt) + (input.timeZone ? '' : ' UTC');
+    }
+    catch {
+        time = new Intl.DateTimeFormat('en-GB', {
+            timeZone: 'UTC', hour: '2-digit', minute: '2-digit', hourCycle: 'h23',
+        }).format(input.resetAt) + ' UTC';
+    }
+    // Round up so a reset less than a minute away is not advertised as immediate.
+    const minutes = Math.max(0, Math.ceil((input.resetAt - now) / 60_000));
+    const days = Math.floor(minutes / 1440);
+    const hours = Math.floor(minutes % 1440 / 60);
+    const remainder = minutes % 60;
+    const relative = [days ? `${days} d` : '', hours ? `${hours} h` : '', remainder || !minutes ? `${remainder} min` : ''].filter(Boolean).join(' ');
+    return `${time} (in ${relative})`;
+}
+export function formatPoolUsageLimitMessage(input) {
+    const accounts = input.accounts ?? [];
+    const headroom = accounts.filter(account => !account.useFullQuota && !account.rejected).map(account => {
+        const percentages = account.windows.map(w => w.percent).filter((p) => p !== undefined && Number.isFinite(p) && p >= 0 && p <= 100);
+        return { label: account.label, remaining: percentages.length ? 100 - Math.max(...percentages) : 0 };
+    });
+    const threshold = input.thresholdDeferred === true &&
+        !accounts.some(a => a.rejected) && headroom.reduce((sum, a) => sum + a.remaining, 0) > 0;
+    const reset = formatUsageReset(input);
+    if (threshold) {
+        const labels = headroom.filter(a => a.label && a.remaining > 0).map(a => `${a.label} ${Number(a.remaining.toFixed(2))} %`).join(', ');
+        return `⏳ All Claude accounts in this workspace are above 90 % of their usage limit, so I'm waiting for the next reset${reset ? ` at ${reset}` : ''}. Your message is saved and will run automatically.\n💡 There is still some capacity left${labels ? ` (${labels})` : ''}. A workspace owner can allow the full quota per account in ${FULL_QUOTA_SETTINGS_PATH}.`;
+    }
+    return `⏳ All Claude accounts in this workspace have hit their usage limit. Your message is saved and will run automatically after ${reset ? `the earliest reset at ${reset}` : 'the next reset'}.`;
+}
+export function formatLegacyUsageLimitMessage(input) {
+    const reset = formatUsageReset(input);
+    return `⏳ This poller's Claude login has hit its usage limit. Your message is saved and will run automatically after ${reset ? `the reset at ${reset}` : 'the next reset'}.`;
+}

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

@@ -0,0 +1,17 @@
+import type { UsageProbeMessage } from './types.js';
+import type { PoolFetchResult } from './subscription-selection.js';
+import type { SubscriptionAccount } from './subscription-pool-client.js';
+import { type SubscriptionUsageStore } from './subscription-usage-store.js';
+interface Options {
+    fetchPool: () => Promise<PoolFetchResult<SubscriptionAccount>>;
+    store: SubscriptionUsageStore;
+    cliPath: string;
+    timeoutMs?: number;
+    isAtCapacity: () => boolean;
+    emit: (type: string, channelId: string, metadata: Record<string, unknown>) => void;
+    log: (line: string) => void;
+}
+export declare function isUsageProbe(value: unknown): value is UsageProbeMessage;
+/** This run deliberately has no message/session/brain context or normal spawn bookkeeping. */
+export declare function handleUsageProbe(job: UsageProbeMessage, options: Options): Promise<void>;
+export {};

package/dist/usage-probe-job.js

@@ -0,0 +1,186 @@
+import { spawn } from 'node:child_process';
+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 { parseClaudeRateLimitInfo, } from './claude-rate-limit.js';
+export function isUsageProbe(value) {
+    return (!!value &&
+        typeof value === 'object' &&
+        value.kind === 'usage_probe');
+}
+/** This run deliberately has no message/session/brain context or normal spawn bookkeeping. */
+export async function handleUsageProbe(job, options) {
+    let result = 'unknown';
+    let duplicate = false;
+    let cwd;
+    if (!['workspaceId', 'accountId', 'credentialVersion', 'requestId'].every((k) => {
+        const value = job[k];
+        return (typeof value === 'string' &&
+            /^[A-Za-z0-9_-]{1,128}$/.test(value) &&
+            !/sk-ant-/i.test(value));
+    }) ||
+        !Number.isFinite(job.expiresAt) ||
+        job.expiresAt <= Date.now())
+        return;
+    const metadata = {
+        workspaceId: job.workspaceId,
+        accountId: job.accountId,
+        credentialVersion: job.credentialVersion,
+        requestId: job.requestId,
+        source: 'probe',
+    };
+    try {
+        if (!(await options.store.claimProbeRequest(job.requestId, job.expiresAt))) {
+            duplicate = true;
+            options.log(`[Pool] usage probe request=${job.requestId} result=duplicate_ignored`);
+            return;
+        }
+        const pool = await options.fetchPool();
+        const account = pool.kind === 'ready'
+            ? pool.accounts.find((a) => a.workspaceId === job.workspaceId &&
+                a.accountId === job.accountId &&
+                a.credentialVersion === job.credentialVersion &&
+                a.enabled)
+            : undefined;
+        if (!account)
+            return;
+        if (options.isAtCapacity()) {
+            result = 'cli_at_capacity';
+            return;
+        }
+        cwd = await mkdtemp(join(tmpdir(), 'teamvibe-usage-'));
+        const configDir = join(cwd, 'config');
+        await mkdir(configDir);
+        // Allow only OS execution essentials. No ambient credentials, Slack, API,
+        // brain, hooks, or user's Claude settings reach this isolated child.
+        const env = {
+            PATH: process.env['PATH'],
+            HOME: cwd,
+            TMPDIR: cwd,
+            CLAUDE_CONFIG_DIR: configDir,
+            CLAUDE_CODE_OAUTH_TOKEN: account.credential.unwrap(),
+            CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1',
+        };
+        let info;
+        const outcome = await new Promise((resolve) => {
+            let done = false, buffer = '', errorText = '';
+            const child = spawn(options.cliPath, [
+                '-p',
+                'Reply OK.',
+                '--output-format',
+                'stream-json',
+                '--verbose',
+                '--max-turns',
+                '1',
+                '--tools',
+                '',
+                '--strict-mcp-config',
+                '--mcp-config',
+                '{"mcpServers":{}}',
+                '--no-session-persistence',
+                '--setting-sources',
+                '',
+            ], { cwd, env, stdio: ['ignore', 'pipe', 'pipe'], detached: true });
+            const kill = () => {
+                if (child.pid) {
+                    try {
+                        process.kill(-child.pid, 'SIGKILL');
+                    }
+                    catch {
+                        child.kill('SIGKILL');
+                    }
+                }
+            };
+            const finish = (reason) => {
+                if (done)
+                    return;
+                done = true;
+                clearTimeout(timer);
+                resolve(reason);
+            };
+            const timer = setTimeout(() => {
+                kill();
+                finish('timeout');
+            }, Math.min(options.timeoutMs ?? 60_000, Math.max(1, job.expiresAt - Date.now())));
+            const line = (text) => {
+                try {
+                    const event = JSON.parse(text);
+                    if (event?.type === 'rate_limit_event')
+                        info = parseClaudeRateLimitInfo(event.rate_limit_info);
+                    if (event?.type === 'result' && event.is_error)
+                        errorText = (errorText + String(event.result ?? '').slice(0, 4096)).slice(-8192);
+                }
+                catch { }
+            };
+            child.stdout.on('data', (chunk) => {
+                buffer += chunk.toString();
+                if (buffer.length > 1024 * 1024) {
+                    kill();
+                    finish('unknown');
+                    return;
+                }
+                let end;
+                while ((end = buffer.indexOf('\n')) >= 0) {
+                    line(buffer.slice(0, end));
+                    buffer = buffer.slice(end + 1);
+                }
+            });
+            child.stderr.on('data', (chunk) => {
+                errorText = (errorText + chunk.toString()).slice(-8192);
+            });
+            child.once('error', () => finish('unknown'));
+            // Quota rejection is still a successful observation: it reveals reset
+            // time without requiring the account to complete an assistant turn.
+            child.once('close', (code) => {
+                if (buffer)
+                    line(buffer);
+                finish(/401|unauthorized|invalid.*token|invalid api key|authentication.*(?:fail|error)/i.test(errorText)
+                    ? 'token_rejected'
+                    : /capacity|overloaded/i.test(errorText)
+                        ? 'cli_at_capacity'
+                        : info && (code === 0 || info.status === 'rejected')
+                            ? 'ok'
+                            : 'unknown');
+            });
+        });
+        result = outcome;
+        if (result !== 'ok' || !info)
+            return;
+        const now = Date.now();
+        const safe = safeRateLimitInfo(info);
+        const usage = {
+            ...normalizePassiveUsage(safe, now),
+            source: 'probe',
+        };
+        await options.store.finishProbe(account, {
+            status: 'ok',
+            observedAt: now,
+            usage,
+        });
+        options.emit('pool.usage_observed', 'usage_probe', {
+            ...metadata,
+            accountLabel: account.label ?? account.accountId,
+            reportedAt: now,
+            usage,
+            lastRateLimitInfo: safe,
+            probeStatus: 'ok',
+            probeObservedAt: now,
+        });
+    }
+    catch {
+        result = 'unknown';
+    }
+    finally {
+        if (cwd)
+            await rm(cwd, { recursive: true, force: true }).catch(() => { });
+        if (!duplicate && result !== 'ok')
+            options.emit('pool.probe_failed', 'usage_probe', {
+                ...metadata,
+                reason: result,
+            });
+        if (!duplicate)
+            options.log(`[Pool] usage probe account=${job.accountId} result=${result}`);
+    }
+}

package/npm-shrinkwrap.json

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