@teamvibe/poller 0.8.7-rc.1 → 0.8.8

package/dist/claude-spawner.d.ts

@@ -28,6 +28,8 @@ export interface SpawnResult {
     poolAttempts?: readonly PoolAttempt[];
     quota?: ClaudeQuotaFailure;
     rateLimitInfo?: ClaudeRateLimitInfo;
+    /** Rejections anywhere in this attempt survive a later allowed stream event. */
+    rateLimitRejections?: readonly ClaudeRateLimitInfo[];
     /** Actual ID passed to this CLI attempt, including a failed first turn. */
     attemptedSessionId?: string;
     success: boolean;

package/dist/claude-spawner.js

@@ -20,7 +20,7 @@ import { fetchSecretsForSpawn, buildSecretsReminder } from './secrets-client.js'
 import { fetchConfigForSpawn } from './config-client.js';
 import { parseClaudeRateLimitInfo } from './claude-rate-limit.js';
 import { parseClaudeQuotaFailure } from './claude-quota.js';
-import { abortLocalProbe, accountPin, preparePool, fetchRuntimePool, validateAccount, poolDeferredError, PoolDeferredError } from './subscription-runtime.js';
+import { abortLocalProbe, accountPin, preparePool, fetchRuntimePool, validateAccount, subscriptionUsageStore, poolDeferredError, PoolDeferredError } from './subscription-runtime.js';
 import { selectPoolForResolvedModel } from './subscription-pool.js';
 import { isQuotaPaused, QuotaPausedError } from './quota-pause.js';
 import { redactStartupText } from './startup-auth.js';
@@ -911,6 +911,14 @@ async function runClaudeCode(msg, sessionLog, cwd, directory, sessionId, isFirst
     });
     if (runtime?.account)
         await validateAccount(runtime.account, runtime.resolved);
+    if (runtime?.account && !runtime.shouldStop()) {
+        const store = subscriptionUsageStore();
+        const attemptAt = Date.now();
+        const windows = await store.beginVerification(runtime.account, runtime.resolved.model, attemptAt);
+        if (windows === undefined)
+            throw await poolDeferredError('usage', { kind: 'ready', accounts: [runtime.account] }, runtime.resolved, store);
+        runtime.verificationAttemptAt = windows.length ? attemptAt : undefined;
+    }
     return new Promise((resolve) => {
         // Preparation above awaits remote config/context. Another thread may
         // have exhausted the shared account meanwhile. No awaits before spawn.
@@ -1083,6 +1091,16 @@ async function runClaudeCode(msg, sessionLog, cwd, directory, sessionId, isFirst
         // Retain CLI error/result evidence, not the full parsed assistant/tool stream.
         const failureEvents = [];
         let rateLimitInfo;
+        const rateLimitRejections = new Map();
+        const captureRateLimit = (value) => {
+            rateLimitInfo = parseClaudeRateLimitInfo(value);
+            if (!runtime?.account || rateLimitInfo?.status !== 'rejected')
+                return;
+            for (const w of normalizePassiveUsage(rateLimitInfo, Date.now()).windows) {
+                if (w.status === 'rejected')
+                    rateLimitRejections.set(`${w.window}:${w.scope}`, rateLimitInfo);
+            }
+        };
         let metrics;
         let lastAssistant;
         // teamvibe.ai#284 (poller-brain#235): end-of-turn guard state — tracked
@@ -1143,7 +1161,7 @@ async function runClaudeCode(msg, sessionLog, cwd, directory, sessionId, isFirst
                     // (including metadata keys) to logs, telemetry, typing, or Slack.
                     const event = safeEvent(rawEvent);
                     if (rawEvent?.type === 'rate_limit_event') {
-                        rateLimitInfo = parseClaudeRateLimitInfo(event.rate_limit_info);
+                        captureRateLimit(event.rate_limit_info);
                     }
                     if (rawEvent?.type === 'result' || rawEvent?.type === 'error' || (rawEvent?.type === 'assistant' && rawEvent.error)) {
                         failureEvents.push(rawEvent);
@@ -1367,7 +1385,7 @@ async function runClaudeCode(msg, sessionLog, cwd, directory, sessionId, isFirst
                     const rawEvent = JSON.parse(stdoutBuffer);
                     const event = safeEvent(rawEvent);
                     if (event?.type === 'rate_limit_event') {
-                        rateLimitInfo = parseClaudeRateLimitInfo(event.rate_limit_info);
+                        captureRateLimit(event.rate_limit_info);
                     }
                     failureEvents.push(rawEvent);
                     if (event?.type === 'assistant') {
@@ -1386,6 +1404,7 @@ async function runClaudeCode(msg, sessionLog, cwd, directory, sessionId, isFirst
                 attemptedSessionId: sessionId,
                 ...(quota ? { quota } : {}),
                 ...(rateLimitInfo ? { rateLimitInfo } : {}),
+                ...(rateLimitRejections.size ? { rateLimitRejections: [...rateLimitRejections.values()] } : {}),
                 output: redactOutput(stdout),
                 exitCode: code,
                 metrics,
@@ -1610,7 +1629,7 @@ export async function spawnPoolClaudeCode(msg, sessionLog, selectedDirectory, se
         const modelNormalizedFrom = scoped?.model === resolved.model && scoped?.modelSource === resolved.modelSource
             ? scoped?.modelNormalizedFrom : undefined;
         const runtime = poolRuntime ? {
-            resolved, modelNormalizedFrom, claudeConfigDir, account: prepared?.account,
+            resolved, modelNormalizedFrom, claudeConfigDir, account: prepared?.account, verificationAttemptAt: undefined,
             shouldStop: poolRuntime.shouldStop,
             resumePending: fetchedPool?.kind !== 'no_accounts_configured' && poolRuntime.pin?.resumePending === true,
             onSpawn: () => {
@@ -1649,10 +1668,12 @@ export async function spawnPoolClaudeCode(msg, sessionLog, selectedDirectory, se
             if (!runtime?.resumePending)
                 sawSendMessageCall = false;
             const spawned = await runClaudeCode(msg, sessionLog, effectiveCwd, directory, id, runtime?.resumePending ? false : first, lastMessageTs, onMessageSent, typingIndicator, runtime, gitDelivery);
+            const rejected = spawned.rateLimitRejections?.find(rejectedForModel);
             const result = prepared?.account
-                ? { ...spawned, quota: quotaForModel(spawned.quota), success: rejectedForModel(spawned.rateLimitInfo) ? false : spawned.success } : spawned;
+                ? { ...spawned, ...(rejected ? { rateLimitInfo: rejected } : {}), quota: quotaForModel(spawned.quota), success: rejected || rejectedForModel(spawned.rateLimitInfo) ? false : spawned.success } : spawned;
             sawSendMessageCall ||= result.sawSendMessageCall === true;
             if (prepared?.account) {
+                const observedAt = Date.now();
                 if (poolAttempts.length >= 1000)
                     poolAttempts.shift();
                 const selection = prepared.selection;
@@ -1664,7 +1685,8 @@ export async function spawnPoolClaudeCode(msg, sessionLog, selectedDirectory, se
                     accountId: prepared.account.accountId,
                     credentialVersion: prepared.account.credentialVersion,
                     accountLabel: prepared.account.label ?? prepared.account.accountId,
-                    observedAt: Date.now(),
+                    observedAt,
+                    verificationAttemptAt: runtime?.verificationAttemptAt,
                     rateLimitInfo: result.rateLimitInfo,
                     sessionId: id,
                     model: resolved.model ?? result.metrics?.model,
@@ -1675,13 +1697,19 @@ export async function spawnPoolClaudeCode(msg, sessionLog, selectedDirectory, se
                     metrics: result.metrics,
                 });
                 emitEvent('pool.account_attempted', msg.teamvibe.channelId, { workspaceId: msg.teamvibe.workspaceId, threadId: msg.thread_id, ...poolRunTelemetry(poolAttempts, poolRuntime?.quotaDeferEpisodes) });
+                // Retain every rejected scope before completion can clear a verified
+                // hold or return early. A failed write must not skip another scope.
+                const rejectionOutcomes = await Promise.allSettled((result.rateLimitRejections ?? []).map(info => logPoolUsageWrite(sessionLog, prepared.account, info, () => prepared.store.recordPassive(prepared.account, info, observedAt, { expireFutureObservations: true }))));
                 if (result.success && id && poolRuntime) {
-                    // Complete the inbox before any fallible post-inference store writes.
-                    // The loop retains bookkeeping independently of the original prompt.
+                    // Complete the inbox even if rejection bookkeeping failed. The loop
+                    // retains completion independently of the original prompt.
                     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;
+                    const failed = rejectionOutcomes.find((outcome) => outcome.status === 'rejected');
+                    if (failed)
+                        throw new PoolDeferredError('infrastructure', { error: failed.reason });
                     return result;
                 }
                 if ((result.quota || rejectedForModel(result.rateLimitInfo)) && !result.killedByPoller) {
@@ -1692,15 +1720,17 @@ export async function spawnPoolClaudeCode(msg, sessionLog, selectedDirectory, se
                 // retaining the attempt. Selection waits for all writes before switching.
                 const writes = [];
                 if (result.quota && !result.killedByPoller)
-                    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(logPoolUsageWrite(sessionLog, prepared.account, result.rateLimitInfo, () => prepared.store.recordPassive(prepared.account, result.rateLimitInfo, 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, observedAt, { expireFutureObservations: true }), 'quota'));
+                if (!result.rateLimitRejections?.length && result.rateLimitInfo)
+                    writes.push(logPoolUsageWrite(sessionLog, prepared.account, result.rateLimitInfo, () => prepared.store.recordPassive(prepared.account, result.rateLimitInfo, observedAt, { 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);
+                const outcomes = [...rejectionOutcomes, ...await Promise.allSettled(writes)];
                 const failed = outcomes.find((outcome) => outcome.status === 'rejected');
                 if (failed)
                     throw new PoolDeferredError('infrastructure', { error: failed.reason });
+                if (runtime?.verificationAttemptAt !== undefined && !result.killedByPoller && result.exitCode !== null)
+                    await prepared.store.completeVerification(prepared.account, runtime.verificationAttemptAt, observedAt);
             }
             return result;
         };

package/dist/event-queue.js

@@ -4,6 +4,8 @@ import { logger } from './logger.js';
 const MAX_QUEUE_SIZE = 200;
 const FLUSH_INTERVAL_MS = 30_000;
 const DEDUP_WINDOW_MS = 60_000;
+const rejectedWarnings = new Map();
+const REJECTION_WARN_INTERVAL_MS = 3600_000;
 let queue = [];
 let flushTimer = null;
 let isFlushing = false;
@@ -60,6 +62,15 @@ async function flushOne(event) {
             logger.info(`[Pool] usage probe request=${event.metadata['requestId']} completion downgraded for legacy platform`);
             response = await post();
         }
+        if ([400, 404, 422].includes(response.status)) {
+            const now = Date.now();
+            const previous = rejectedWarnings.get(event.eventType);
+            if (previous === undefined || now - previous >= REJECTION_WARN_INTERVAL_MS) {
+                rejectedWarnings.set(event.eventType, now);
+                logger.warn(`[EventQueue] ${event.eventType} rejected with HTTP ${response.status}; dropping event`);
+            }
+            return true;
+        }
         return response.ok;
     }
     catch {

package/dist/inbox-manager.d.ts

@@ -1,3 +1,4 @@
+import type { PoolDefer } from './pool-defer.js';
 import type { ClaudeRateLimitInfo } from './claude-rate-limit.js';
 import type { PoolAttempt } from './subscription-runtime.js';
 import type { TeamVibeQueueMessage, SubscriptionPin } from './types.js';
@@ -81,3 +82,6 @@ export declare function discardHandledInboxDrops(brainPath: string, threadId: st
 export declare function restartInboxInDirectory(source: string, target: string, threadId: string): void;
 /** Preserve unroutable work for operator review and remove it from replay queues. */
 export declare function quarantineInbox(brainPath: string, threadId: string, includeFailed?: boolean): void;
+/** Only original queue deliveries carry inbound identity; synthetic drops never wake holds. */
+export declare function inboxQueueMessageIds(brainPath: string, threadId: string): string[];
+export declare function hasInboxMessageAfter(brainPath: string, threadId: string, pause: Pick<PoolDefer, 'handledInboundIds'>): boolean;

package/dist/inbox-manager.js

@@ -305,3 +305,32 @@ export function quarantineInbox(brainPath, threadId, includeFailed = false) {
         renameSync(join(root, name), join(quarantine, `${Date.now()}-${name}`));
     }
 }
+/** Only original queue deliveries carry inbound identity; synthetic drops never wake holds. */
+export function inboxQueueMessageIds(brainPath, threadId) {
+    const ids = new Set();
+    for (const subdir of [PROCESSING_DIR, NEW_DIR]) {
+        const directory = join(getInboxPath(brainPath, threadId), subdir);
+        let names;
+        try {
+            names = readdirSync(directory);
+        }
+        catch {
+            continue;
+        }
+        for (const name of names) {
+            if (!name.endsWith('.txt'))
+                continue;
+            try {
+                const message = JSON.parse(readFileSync(join(directory, name), 'utf8'));
+                if (message.executionOrigin === 'queue' && message.thread_id === threadId && typeof message.id === 'string' && message.id)
+                    ids.add(message.id);
+            }
+            catch { /* Plain background drops and concurrent moves have no inbound identity. */ }
+        }
+    }
+    return [...ids];
+}
+export function hasInboxMessageAfter(brainPath, threadId, pause) {
+    const handled = new Set(pause.handledInboundIds ?? []);
+    return inboxQueueMessageIds(brainPath, threadId).some(id => !handled.has(id));
+}

package/dist/inbox-watcher.js

@@ -1,7 +1,7 @@
 import { executionDirectory } from './brain-directory.js';
-import { discardHandledInboxDrops, markProcessed, quarantineInbox, readInboxChannelContext, readInboxContext, readInboxRuntime, restartInboxInDirectory } from './inbox-manager.js';
+import { hasInboxMessageAfter, discardHandledInboxDrops, markProcessed, quarantineInbox, readInboxChannelContext, readInboxContext, readInboxRuntime, restartInboxInDirectory } from './inbox-manager.js';
 import { listThreadRoutings, readThreadRouting, removeThreadRouting, threadRoutingKey } from './thread-routing.js';
-import { isPoolDeferred, readPoolDefer } from './pool-defer.js';
+import { observePoolAccounts, isPoolDeferred, readPoolDefer } from './pool-defer.js';
 import { existsSync, readdirSync, rmSync, watch as fsWatch } from 'fs';
 import { join } from 'path';
 import { config } from './config.js';
@@ -11,6 +11,7 @@ import { logger } from './logger.js';
 import { isAtCapacity } from './claude-spawner.js';
 import { getTrackedBrains } from './maintenance-cron.js';
 import { runInboxLoop, isInboxLoopActive } from './poller.js';
+import { fetchRuntimePool } from './subscription-runtime.js';
 import { isQuotaPaused } from './quota-pause.js';
 import { emitError } from './event-queue.js';
 import { sendSlackMessage } from './slack-client.js';
@@ -151,6 +152,7 @@ export async function checkInboxForNewSessions(deps = defaultDeps()) {
     const expired = await sweepThreadRouting(deps, brains);
     const started = new Set();
     const recoveries = [];
+    const checkedPools = new Set();
     scan: for (const brainPath of brains) {
         if (deps.isAtCapacity())
             break;
@@ -160,7 +162,7 @@ export async function checkInboxForNewSessions(deps = defaultDeps()) {
                 break scan;
             if (expired.has(threadRoutingKey(threadId)))
                 continue;
-            if (started.has(threadId) || recoveringThreads.has(threadId) || deps.isInboxLoopActive(threadId) || isPoolDeferred(threadId))
+            if (started.has(threadId) || recoveringThreads.has(threadId) || deps.isInboxLoopActive(threadId))
                 continue;
             discardHandledInboxDrops(brainPath, threadId);
             const runtime = readInboxRuntime(brainPath, threadId);
@@ -193,6 +195,17 @@ export async function checkInboxForNewSessions(deps = defaultDeps()) {
                 quarantineRetainedThread(deps, brainPath, threadId, durable);
                 continue;
             }
+            if (isPoolDeferred(threadId)) {
+                // Held work still observes pool membership on every watcher tick.
+                const key = JSON.stringify([info.workspaceId, info.channelId]);
+                if (!checkedPools.has(key)) {
+                    checkedPools.add(key);
+                    observePoolAccounts(info.workspaceId, await fetchRuntimePool(message));
+                }
+                const pause = readPoolDefer(threadId);
+                if (isPoolDeferred(threadId) && pause && !hasInboxMessageAfter(brainPath, threadId, pause))
+                    continue;
+            }
             started.add(threadId);
             recoveringThreads.add(threadId);
             recoveries.push((async () => {

package/dist/poller.js

@@ -14,7 +14,7 @@ import { classifyFailedIteration } from './classify-failed-iteration.js';
 import { fetchSecretsForSpawn } from './secrets-client.js';
 import { PoolDeferredError, fetchRuntimePool, subscriptionUsageStore, HELD_PROBE_INTERVAL_MS } from './subscription-runtime.js';
 import { POOL_RECHECK_MS } from './subscription-selection.js';
-import { isPoolDeferred, readPoolDefer, deferPool, setPoolNotice, clearPoolDefer } from './pool-defer.js';
+import { invalidatePoolDefer, invalidateWorkspacePoolDefers, observePoolAccounts, isPoolDeferred, readPoolDefer, deferPool, setPoolNotice, clearPoolDefer } from './pool-defer.js';
 import { isQuotaPaused, pauseForQuota, clearQuotaPauseAfterSuccess, QuotaPausedError } from './quota-pause.js';
 import { acquireSessionLock, releaseSessionLock, updateSessionId } from './session-store.js';
 import { ensureDirectories, ensureBaseBrain, pushBrainChanges } from './brain-manager.js';
@@ -26,7 +26,7 @@ import { registerBrain, startMaintenanceLoop, stopMaintenanceLoop } from './main
 import { bootstrapTrackedBrains } from './brains-bootstrap.js';
 import { startEventQueue, stopEventQueue, flush as flushEventQueue, emitEvent, emitError } from './event-queue.js';
 import { startMetricsCron, stopMetricsCron } from './metrics/scheduler.js';
-import { writeMessage, pickNextMessage, markProcessed, markFailed, hasUnprocessed, requeueMessage, saveInboxContext, saveInboxRuntime, readInboxRuntime, clearInboxRuntime } from './inbox-manager.js';
+import { inboxQueueMessageIds, hasInboxMessageAfter, writeMessage, pickNextMessage, markProcessed, markFailed, hasUnprocessed, requeueMessage, saveInboxContext, saveInboxRuntime, readInboxRuntime, clearInboxRuntime } from './inbox-manager.js';
 import { saveThreadRouting } from './thread-routing.js';
 import { startInboxWatcher, stopInboxWatcher } from './inbox-watcher.js';
 import { Cron } from 'croner';
@@ -257,12 +257,17 @@ export async function runInboxLoop(threadId, selectedDirectory, queueMessage, se
     if (isQuotaPaused() && !getPollerId())
         return;
     const initialPool = await fetchRuntimePool(queueMessage);
+    observePoolAccounts(queueMessage.teamvibe.workspaceId, initialPool, { log: line => sessionLog.info(line) });
     if (initialPool.kind === 'no_accounts_configured') {
         if (isQuotaPaused())
             return;
     }
-    else if (isPoolDeferred(threadId))
-        return;
+    else if (isPoolDeferred(threadId)) {
+        const pause = readPoolDefer(threadId);
+        if (!hasInboxMessageAfter(kbPath, threadId, pause))
+            return;
+        invalidatePoolDefer(threadId, queueMessage.teamvibe.workspaceId, 'new_message', { log: line => sessionLog.info(line) }, inboxQueueMessageIds(kbPath, threadId));
+    }
     if (activeLoops.has(threadId)) {
         sessionLog.info(`Loop already running for thread ${threadId}, skipping`);
         return;
@@ -318,8 +323,10 @@ export async function runInboxLoop(threadId, selectedDirectory, queueMessage, se
             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;
+            // Reuse the spawn's observation clock: the spawner already recorded all
+            // rejected scopes, and replaying its final event is the same evidence.
             if (state.completed.rateLimitInfo)
-                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(logPoolUsageWrite(sessionLog, { label: accountLabel }, state.completed.rateLimitInfo, () => subscriptionUsageStore().recordPassive(state.pin, state.completed.rateLimitInfo, lastAttempt?.observedAt ?? state.completed.observedAt, liveCompletion ? { expireFutureObservations: true } : undefined)));
             writes.push(persistSessionId(state.sessionId, state.pin));
             const outcomes = await Promise.allSettled(writes);
             if (outcomes.some(outcome => outcome.status === 'rejected' || outcome.value === false)) {
@@ -332,6 +339,21 @@ export async function runInboxLoop(threadId, selectedDirectory, queueMessage, se
                 }
                 return false;
             }
+            if (lastAttempt?.verificationAttemptAt !== undefined) {
+                try {
+                    await subscriptionUsageStore().completeVerification(state.pin, lastAttempt.verificationAttemptAt, state.completed.observedAt);
+                }
+                catch {
+                    sessionLog.warn('[Loop] Verification bookkeeping failed and will retry without running the agent');
+                    try {
+                        saveInboxRuntime(kbPath, threadId, { ...state, completed: { ...state.completed, retryAt: Date.now() + POOL_RECHECK_MS } });
+                    }
+                    catch {
+                        sessionLog.warn('[Loop] Could not save bookkeeping retry; completion remains recorded');
+                    }
+                    return false;
+                }
+            }
             currentSessionId = state.sessionId;
             currentPin = state.pin;
             // The spawner publishes live completions only after bookkeeping succeeds.
@@ -370,6 +392,7 @@ export async function runInboxLoop(threadId, selectedDirectory, queueMessage, se
             // Dispatch before ANY pool state/context/model preparation. The explicit
             // no-pool outcome runs the original spawn and #408 pause gates.
             const pool = iteration === 0 ? initialPool : await fetchRuntimePool(queueMessage);
+            observePoolAccounts(queueMessage.teamvibe.workspaceId, pool, { log: line => sessionLog.info(line) });
             poolIteration = pool.kind !== 'no_accounts_configured';
             if (!poolIteration && isQuotaPaused())
                 break;
@@ -619,9 +642,9 @@ export async function runInboxLoop(threadId, selectedDirectory, queueMessage, se
                     quotaPaused = true;
                     deferred = true;
                     // Revisit held work hourly so background probes can refresh the account.
-                    // Selection still enforces each window's real reset before inference.
+                    // Selection enforces resets or a contradicted rejection's verification backoff.
                     const recheckAt = error.cause === 'usage' ? Math.min(error.eligibleAt, Date.now() + HELD_PROBE_INTERVAL_MS) : error.eligibleAt;
-                    const pause = deferPool(threadId, recheckAt, error.resetAt);
+                    const pause = deferPool(threadId, recheckAt, error.resetAt, inboxQueueMessageIds(kbPath, threadId));
                     const retained = readInboxRuntime(kbPath, threadId);
                     // Rechecks of one exhaustion episode do not inflate the episode count.
                     quotaDeferEpisodes = Math.max(1, quotaDeferEpisodes);
@@ -638,7 +661,7 @@ export async function runInboxLoop(threadId, selectedDirectory, queueMessage, se
                                 cause: error.cause,
                                 thresholdDeferred: error.notice?.thresholdDeferred && !error.attempts?.some(a => a.quota),
                                 resetAt: pause.resetAt ? Date.parse(pause.resetAt) : error.notice?.resetAt,
-                                timeZone: config.POLLER_TZ,
+                                timeZone: deliveryMsg.teamvibe.timeZone ?? error.notice?.timeZone,
                             });
                             await sendSlackMessage(deliveryMsg, notice, { clientMessageId: pause.episodeId, ...(reconcile ? { reconcile: true } : {}) });
                             setPoolNotice(threadId, pause.episodeId, 'delivered');
@@ -901,7 +924,7 @@ async function processMessage(received) {
     const kbPath = directory.path;
     // Write raw message to inbox (spawnClaudeCode handles prompt formatting)
     const { botToken: _inboxToken, ...inboxTeamvibe } = queueMessage.teamvibe;
-    writeMessage(kbPath, threadId, JSON.stringify({ ...queueMessage, teamvibe: inboxTeamvibe }));
+    writeMessage(kbPath, threadId, JSON.stringify({ ...queueMessage, executionOrigin: receiptHandle ? 'queue' : 'maintenance', teamvibe: inboxTeamvibe }));
     sessionLog.info(`Wrote message to inbox`);
     // Delete SQS message immediately — it's now persisted in the inbox
     if (receiptHandle) {
@@ -1029,6 +1052,7 @@ export async function pollLoop() {
                             apiUrl: config.TEAMVIBE_API_URL,
                             pollerToken: config.TEAMVIBE_POLLER_TOKEN || '',
                         }),
+                        onHeadroom: workspaceId => invalidateWorkspacePoolDefers(workspaceId, 'usage_update'),
                         store: subscriptionUsageStore(),
                         cliPath: config.CLAUDE_CLI_PATH,
                         isAtCapacity,

package/dist/pool-defer.d.ts

@@ -1,4 +1,16 @@
+import { emitEvent } from './event-queue.js';
+import type { PoolFetchResult } from './subscription-selection.js';
 export interface PoolDefer {
+    /** Additive ownership index; older markers use the existing hashed routing file. */
+    scope?: {
+        workspaceId: string;
+        threadId: string;
+        channelId: string;
+    };
+    /** Enabled capacity known when this hold was last evaluated. */
+    poolAccountIds?: string[];
+    /** Queue arrivals already considered in this exhaustion episode. */
+    handledInboundIds?: string[];
     createdAt: number;
     resumeAt: number;
     resetAt?: string;
@@ -7,7 +19,18 @@ export interface PoolDefer {
 }
 export declare function readPoolDefer(threadId: string): PoolDefer | undefined;
 export declare function isPoolDeferred(threadId: string): boolean;
-export declare function deferPool(threadId: string, eligibleAt: number, resetAt?: string): PoolDefer;
+export declare function deferPool(threadId: string, eligibleAt: number, resetAt?: string, handledInboundIds?: string[]): PoolDefer;
 /** Claim durably before Slack I/O. Ambiguous sends are never blindly replayed. */
 export declare function setPoolNotice(threadId: string, episodeId: string, notice: PoolDefer['notice']): boolean;
 export declare function clearPoolDefer(threadId: string): void;
+export type PoolDeferInvalidationReason = 'usage_update' | 'pool_changed' | 'new_message';
+interface InvalidationObserver {
+    emit?: typeof emitEvent;
+    log?: (line: string) => void;
+}
+/** Expire atomically, retaining the episode and notice claim until a successful spawn. */
+export declare function invalidatePoolDefer(threadId: string, workspaceId: string, reason: PoolDeferInvalidationReason, observer?: InvalidationObserver, handledInboundIds?: string[]): void;
+export declare function invalidateWorkspacePoolDefers(workspaceId: string, reason: Exclude<PoolDeferInvalidationReason, 'new_message'>, observer?: InvalidationObserver): void;
+/** Only authoritative enabled account sets advance the baseline; never cache credentials. */
+export declare function observePoolAccounts(workspaceId: string, pool: PoolFetchResult, observer?: InvalidationObserver): void;
+export {};

package/dist/pool-defer.js

@@ -1,19 +1,27 @@
 import { createHash, randomUUID } from 'node:crypto';
-import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { config } from './config.js';
 import { logger } from './logger.js';
+import { emitEvent } from './event-queue.js';
+import { readThreadRouting, threadRoutingKey } from './thread-routing.js';
 import { POOL_RECHECK_MS } from './subscription-selection.js';
 function pathFor(threadId) {
     return join(config.TEAMVIBE_DATA_DIR, 'pool-defer', `${createHash('sha256').update(threadId).digest('hex')}.json`);
 }
 const warned = new Set();
 export function readPoolDefer(threadId) {
-    const path = pathFor(threadId);
+    return readMarker(pathFor(threadId));
+}
+function readMarker(path) {
     try {
         const state = JSON.parse(readFileSync(path, 'utf8'));
-        if (!Number.isFinite(state.createdAt) || !Number.isFinite(state.resumeAt) || state.resumeAt <= state.createdAt || state.resumeAt > 253402300799000 || typeof state.episodeId !== 'string' || !['pending', 'claimed', 'delivered', 'ambiguous'].includes(state.notice))
+        if (!Number.isFinite(state.createdAt) || !Number.isFinite(state.resumeAt) || state.resumeAt < state.createdAt || state.resumeAt > 253402300799000 || typeof state.episodeId !== 'string' || !['pending', 'claimed', 'delivered', 'ambiguous'].includes(state.notice))
             throw new Error('Invalid defer');
+        for (const ids of [state.poolAccountIds, state.handledInboundIds]) {
+            if (ids !== undefined && (!Array.isArray(ids) || ids.some(id => typeof id !== 'string')))
+                throw new Error('Invalid defer baseline');
+        }
         warned.delete(path);
         return state;
     }
@@ -56,10 +64,14 @@ function write(threadId, state) {
         catch { }
     }
 }
-export function deferPool(threadId, eligibleAt, resetAt) {
+export function deferPool(threadId, eligibleAt, resetAt, handledInboundIds = []) {
     const previous = readPoolDefer(threadId);
     const now = Date.now();
-    const state = { createdAt: now, resumeAt: Number.isFinite(eligibleAt) && eligibleAt > now ? eligibleAt : now + POOL_RECHECK_MS, episodeId: previous?.episodeId ?? randomUUID(), notice: previous?.notice ?? 'pending', ...(resetAt ? { resetAt } : {}) };
+    const routing = readThreadRouting(threadId);
+    const scope = routing ? { workspaceId: routing.workspaceId, channelId: routing.channelId, threadId } : previous?.scope;
+    const fingerprint = scope ? poolFingerprints.get(poolKey(scope.workspaceId)) : undefined;
+    const poolAccountIds = fingerprint === undefined ? previous?.poolAccountIds : JSON.parse(fingerprint);
+    const state = { ...(scope ? { scope } : {}), ...(poolAccountIds ? { poolAccountIds } : {}), handledInboundIds: [...new Set([...(previous?.handledInboundIds ?? []), ...handledInboundIds])], createdAt: now, resumeAt: Number.isFinite(eligibleAt) && eligibleAt > now ? eligibleAt : now + POOL_RECHECK_MS, episodeId: previous?.episodeId ?? randomUUID(), notice: previous?.notice ?? 'pending', ...(resetAt ? { resetAt } : {}) };
     write(threadId, state);
     return state;
 }
@@ -79,3 +91,87 @@ export function clearPoolDefer(threadId) {
         logger.warn('[PoolDefer] Completed episode cleanup will be retried');
     }
 }
+/** Expire atomically, retaining the episode and notice claim until a successful spawn. */
+export function invalidatePoolDefer(threadId, workspaceId, reason, observer = {}, handledInboundIds = []) {
+    const state = readPoolDefer(threadId);
+    if (!state || !isPoolDeferred(threadId))
+        return;
+    const routing = readThreadRouting(threadId);
+    const scope = state.scope ?? (routing ? { ...routing, threadId } : undefined);
+    if (!scope || scope.workspaceId !== workspaceId)
+        return;
+    write(threadId, { ...state, resumeAt: state.createdAt, handledInboundIds: [...new Set([...(state.handledInboundIds ?? []), ...handledInboundIds])] });
+    const metadata = { workspaceId, threadId, reason, episodeId: state.episodeId };
+    // Observability cannot undo the durable wake-up.
+    try {
+        (observer.log ?? (line => logger.info(line)))(`[Pool] defer invalidated workspace=${JSON.stringify(workspaceId)} thread=${JSON.stringify(threadId)} reason=${reason} episode=${JSON.stringify(state.episodeId)}`);
+    }
+    catch { }
+    try {
+        (observer.emit ?? emitEvent)('pool.defer_invalidated', scope.channelId, metadata);
+    }
+    catch { }
+}
+/** One directory scan, one bounded routing lookup per legacy marker; no inbox scan. */
+function* workspacePoolDefers(workspaceId) {
+    const root = join(config.TEAMVIBE_DATA_DIR, 'pool-defer');
+    let names;
+    try {
+        names = readdirSync(root);
+    }
+    catch {
+        return;
+    }
+    for (const name of names) {
+        if (!/^[a-f0-9]{64}\.json$/.test(name))
+            continue;
+        try {
+            const state = readMarker(join(root, name));
+            if (!state)
+                continue;
+            let scope = state.scope;
+            if (!scope) {
+                // Pre-#572 markers share their hash with durable thread routing.
+                scope = JSON.parse(readFileSync(join(config.TEAMVIBE_DATA_DIR, 'thread-routing', name), 'utf8'));
+            }
+            if (scope?.workspaceId === workspaceId && typeof scope.threadId === 'string' && threadRoutingKey(scope.threadId) === name)
+                yield { state, scope };
+        }
+        catch {
+            logger.warn('[PoolDefer] Workspace invalidation will be retried');
+        }
+    }
+}
+export function invalidateWorkspacePoolDefers(workspaceId, reason, observer = {}) {
+    for (const { scope } of workspacePoolDefers(workspaceId))
+        invalidatePoolDefer(scope.threadId, workspaceId, reason, observer);
+}
+const poolFingerprints = new Map();
+function poolKey(workspaceId) {
+    return JSON.stringify([config.TEAMVIBE_DATA_DIR, workspaceId]);
+}
+/** Only authoritative enabled account sets advance the baseline; never cache credentials. */
+export function observePoolAccounts(workspaceId, pool, observer = {}) {
+    if (pool.kind !== 'ready' && pool.kind !== 'no_accounts_configured' && !(pool.kind === 'fetch_unavailable' && pool.reason === 'no_usable_accounts'))
+        return;
+    const poolAccountIds = pool.kind === 'ready' ? [...new Set(pool.accounts.filter(a => a.enabled && a.workspaceId === workspaceId).map(a => a.accountId))].sort() : [];
+    const fingerprint = JSON.stringify(poolAccountIds);
+    const key = poolKey(workspaceId);
+    if (poolFingerprints.get(key) === fingerprint)
+        return;
+    // The first fetch after boot also compares the durable per-marker baselines.
+    for (const { state, scope } of workspacePoolDefers(workspaceId)) {
+        const now = Date.now();
+        if (now < state.createdAt || now >= state.resumeAt)
+            continue;
+        if (state.poolAccountIds && poolAccountIds.some(id => !state.poolAccountIds.includes(id))) {
+            invalidatePoolDefer(scope.threadId, workspaceId, 'pool_changed', observer);
+        }
+        else {
+            // Reductions never add capacity. Adopt them so a later re-enable wakes work.
+            // A legacy marker adopts its first observed baseline without waking work.
+            write(scope.threadId, { ...state, poolAccountIds });
+        }
+    }
+    poolFingerprints.set(key, fingerprint);
+}

package/dist/subscription-runtime.d.ts

@@ -10,6 +10,8 @@ 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 extends Partial<HeadroomScore> {
+    /** Local completion bookkeeping token; omitted from event transport DTOs. */
+    verificationAttemptAt?: number;
     workspaceId: string;
     accountId: string;
     accountLabel?: string;

package/dist/subscription-runtime.js

@@ -1,4 +1,5 @@
 import { isAtCapacity, isSubscriptionAccountRunning } from './claude-spawner.js';
+import { invalidateWorkspacePoolDefers } from './pool-defer.js';
 import { emitEvent } from './event-queue.js';
 import { logger } from './logger.js';
 import { runUsageProbe } from './usage-probe-job.js';
@@ -149,6 +150,7 @@ export async function preparePool(msg, resolved, pin, fetched, log, probeOptions
     if (pool.kind === 'ready')
         probeUnknownAccounts(pool.accounts, selected.kind === 'selected' ? selected.account.accountId : undefined, resolved, store, {
             cliPath: config.CLAUDE_CLI_PATH, isAtCapacity, emit: emitEvent,
+            onHeadroom: workspaceId => invalidateWorkspacePoolDefers(workspaceId, 'usage_update'),
             log: line => (log ?? logger).info(line), ...probeOptions, store,
         }, msg.teamvibe.channelId);
     if (selected.kind === 'selected') {
@@ -203,6 +205,8 @@ async function poolUsageNotice(pool, resolved, store) {
             return {
                 label: account.label, useFullQuota: account.useFullQuota, windows: windows.filter(w => binding.some(b => b.window === w.window && b.scope === w.scope)), rejected,
                 thresholdBlocked: blockers.length > 0,
+                blockedWindows: binding.map(w => ({ window: w.window, scope: w.scope })),
+                providerResetAt: binding.length && binding.every(w => w.resetAt !== undefined) ? Math.max(...binding.map(w => w.resetAt)) : undefined,
                 resetAt: resets.length && resets.every((r) => r !== undefined) ? Math.max(...resets) : undefined,
             };
         }));
@@ -210,7 +214,8 @@ async function poolUsageNotice(pool, resolved, store) {
         // 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 };
+        const providerResets = accounts.map(a => a.providerResetAt);
+        return { accounts, thresholdDeferred, resetAt: resetAt ?? (providerResets.length && providerResets.every((r) => r !== undefined) ? Math.min(...providerResets) : undefined), blockedWindows: accounts.flatMap(a => a.blockedWindows) };
     }
     catch {
         return {};
@@ -224,8 +229,9 @@ export async function poolDeferredError(cause, pool, resolved, store, options =
         return new PoolDeferredError(cause, { error: options.error ?? (pool.kind === 'fetch_unavailable' && pool.cause ? { code: pool.cause } : undefined) });
     const notice = await poolUsageNotice(pool, resolved, store);
     const deferredError = (resetAt) => {
+        resetAt ??= !notice.thresholdDeferred && notice.resetAt !== undefined ? new Date(notice.resetAt).toISOString() : undefined;
         const error = new PoolDeferredError('usage', { eligibleAt, resetAt });
-        error.notice = { ...notice, resetAt: resetAt ? Date.parse(resetAt) : notice.resetAt };
+        error.notice = { ...notice, eligibleAt: error.eligibleAt, resetAt: resetAt ? Date.parse(resetAt) : notice.resetAt };
         return error;
     };
     if (eligibleAt === undefined) {