@teamvibe/poller 0.8.7 → 0.8.9-rc.1

package/dist/inbox-watcher.js

@@ -38,8 +38,8 @@ function defaultDeps() {
  * threads (see modules-teamvibe/hooks/slack-events.ts). Synthetic threadIds
  * used elsewhere (`maintenance_<brainId>_<ts>`, and
  * `scheduled:<scheduleId>:<ts>` from
- * modules-teamvibe/src/functions/scheduler.ts:86) never sit idle waiting on
- * a background-task drop, so they're skipped rather than guessed at.
+ * modules-teamvibe/src/functions/scheduler.ts) carry no Slack destination;
+ * scheduler recovery needs the poller-owned routing record exclusively.
  * `scheduled:*:*` has the same 3-colon-segment shape as a real Slack
  * threadId, so it's rejected explicitly rather than by segment count alone
  * — otherwise a leftover unprocessed file in a stale scheduled-session inbox
@@ -65,20 +65,16 @@ function platformRouting(info) {
         brain: { brainId: info.brainId, gitRepoUrl: info.gitRepoUrl, branch: info.branch },
     };
 }
-function buildSyntheticMessage(info, threadId, parsed) {
+function buildSyntheticMessage(info, threadId, slack, source = 'slack') {
     return {
         id: `inbox_watch_${threadId}`,
-        source: 'slack',
+        source,
         thread_id: threadId,
         sender: { id: 'system', name: 'Background Task' },
         text: '',
         attachments: [],
         response_context: {
-            slack: {
-                channel: parsed.channel,
-                thread_ts: parsed.threadTs,
-                message_ts: parsed.threadTs,
-            },
+            slack,
         },
         type: 'message',
         teamvibe: platformRouting(info),
@@ -174,9 +170,13 @@ export async function checkInboxForNewSessions(deps = defaultDeps()) {
                 continue;
             const durable = readInboxContext(brainPath, threadId);
             const parsed = parseSlackThreadId(threadId);
+            const scheduled = threadId.startsWith('scheduled:');
             // Context or poller-owned per-thread routing selects a channel in the
             // full map. Never infer ownership from a directory's current channels.
-            const storedRoute = readInboxChannelContext(brainPath, threadId) ?? readThreadRouting(threadId);
+            const routingRecord = readThreadRouting(threadId);
+            // Scheduler routing is trusted poller state. Brain-writable envelopes and
+            // sidecars cannot select either its platform channel or Slack destination.
+            const storedRoute = scheduled ? routingRecord : readInboxChannelContext(brainPath, threadId) ?? routingRecord;
             const route = storedRoute
                 ? routes.find(({ info }) => info.workspaceId === storedRoute.workspaceId && info.channelId === storedRoute.channelId)
                 : undefined;
@@ -186,9 +186,16 @@ export async function checkInboxForNewSessions(deps = defaultDeps()) {
             }
             const info = route.info;
             const directory = route.directory;
-            const current = parsed ? buildSyntheticMessage(info, threadId, parsed) : undefined;
+            // Synthetic IDs need the original Slack destination captured at spawn.
+            // Match its platform scope before using it alongside the current route.
+            const slack = parsed
+                ? { channel: parsed.channel, thread_ts: parsed.threadTs, message_ts: parsed.threadTs }
+                : routingRecord?.workspaceId === info.workspaceId && routingRecord.channelId === info.channelId
+                    ? routingRecord.responseContext?.slack
+                    : undefined;
+            const current = slack ? buildSyntheticMessage(info, threadId, slack, scheduled ? routingRecord?.source ?? 'cron' : 'slack') : undefined;
             // Stored context supplies content, never the selected directory identity.
-            const message = durable
+            const message = scheduled ? current : durable
                 ? { ...durable, teamvibe: platformRouting(info) }
                 : current;
             if (!message) {
@@ -324,7 +331,7 @@ function quarantineRetainedThread(deps, brainPath, threadId, durable, expired =
     const info = [...deps.getTrackedBrains().values()].find(info => info.botId === threadId.split(':')[0] && (!durable || info.workspaceId === durable.teamvibe.workspaceId));
     if (!info)
         return true;
-    void deps.sendSlackMessage(buildSyntheticMessage(info, threadId, parsed), 'A retained background result could not be routed to a current channel. It has been saved for operator review; please contact your poller operator.')
+    void deps.sendSlackMessage(buildSyntheticMessage(info, threadId, { channel: parsed.channel, thread_ts: parsed.threadTs, message_ts: parsed.threadTs }), 'A retained background result could not be routed to a current channel. It has been saved for operator review; please contact your poller operator.')
         .catch(() => logger.error('[InboxWatcher] Could not send unroutable inbox notice'));
     return true;
 }

package/dist/poller.d.ts

@@ -1,5 +1,6 @@
 import { type BrainDirectory } from './brain-directory.js';
 import { logger } from './logger.js';
+import { type ReceivedMessage } from './sqs-poller.js';
 import { type SpawnResult } from './claude-spawner.js';
 import { type KilledByPoller } from './classify-failed-iteration.js';
 import type { TeamVibeQueueMessage } from './types.js';
@@ -31,11 +32,11 @@ export declare function isPollerInitiatedFailure(result: {
     killedByPoller?: KilledByPoller;
 }): boolean;
 export declare function describeFailureReason(killedByPoller: KilledByPoller | undefined, exitCode: number | null): string;
-export declare const END_OF_TURN_NO_FURTHER_RESPONSE_SENTINEL = "NO_FURTHER_RESPONSE_NEEDED";
+export { END_OF_TURN_NO_FURTHER_RESPONSE_SENTINEL } from './end-of-turn-sentinel.js';
 export declare function endOfTurnFallbackText(hasSlackContext: boolean, result: Pick<SpawnResult, 'success' | 'sawSendMessageCall' | 'lastPlainTextContent'>): string | undefined;
-export declare function runInboxLoop(threadId: string, selectedDirectory: BrainDirectory | string, queueMessage: TeamVibeQueueMessage, sessionLog: ReturnType<typeof logger.createSession>): Promise<void>;
+export declare function runInboxLoop(threadId: string, selectedDirectory: BrainDirectory | string, queueMessage: TeamVibeQueueMessage, sessionLog: ReturnType<typeof logger.createSession>, executionOrigin?: 'queue' | 'recovery'): Promise<void>;
+export declare function processMessage(received: ReceivedMessage): 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>;
-export {};

package/dist/poller.js

@@ -1,3 +1,4 @@
+import { END_OF_TURN_NO_FURTHER_RESPONSE_SENTINEL } from './end-of-turn-sentinel.js';
 import { startGitCredentialJanitor, registeredGitCredentialTasks } from './git-credential-session.js';
 import { isUsageProbe, handleUsageProbe } from './usage-probe-job.js';
 import { fetchSubscriptionPool } from './subscription-pool-client.js';
@@ -26,8 +27,8 @@ 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 { inboxQueueMessageIds, hasInboxMessageAfter, writeMessage, pickNextMessage, markProcessed, markFailed, hasUnprocessed, requeueMessage, saveInboxContext, saveInboxRuntime, readInboxRuntime, clearInboxRuntime } from './inbox-manager.js';
-import { saveThreadRouting } from './thread-routing.js';
+import { inboxQueueMessageIds, hasInboxMessageAfter, writeMessage, pickNextMessage, markProcessed, markFailed, hasUnprocessed, requeueMessage, saveInboxContext, saveInboxRuntime, readInboxRuntime, clearInboxRuntime, quarantineInbox } from './inbox-manager.js';
+import { readThreadRouting, saveThreadRouting } from './thread-routing.js';
 import { startInboxWatcher, stopInboxWatcher } from './inbox-watcher.js';
 import { Cron } from 'croner';
 import { isControlMessage, handleControlMessage } from './control-handler.js';
@@ -232,9 +233,9 @@ export function describeFailureReason(killedByPoller, exitCode) {
 // string match, not a content heuristic — anything else (including real
 // content an agent forgot to send via send_message) still delivers as
 // before, so this can't silently drop a forgotten reply.
-export const END_OF_TURN_NO_FURTHER_RESPONSE_SENTINEL = 'NO_FURTHER_RESPONSE_NEEDED';
+export { END_OF_TURN_NO_FURTHER_RESPONSE_SENTINEL } from './end-of-turn-sentinel.js';
 // tv#358 (revised): the sentinel agents emit and the guard matches is
-// unchanged — still the exact ALL_CAPS literal above, still an exact-match
+// unchanged — still the exact shared ALL_CAPS literal, still an exact-match
 // suppression. What changes is purely cosmetic: poller-brain#428's leak
 // failure mode (a sentence written before the sentinel breaks the exact
 // match, so the whole thing delivers as-is) showed the raw literal reads as
@@ -251,9 +252,23 @@ export function endOfTurnFallbackText(hasSlackContext, result) {
     }
     return text.split(END_OF_TURN_NO_FURTHER_RESPONSE_SENTINEL).join(END_OF_TURN_SENTINEL_DISPLAY);
 }
-export async function runInboxLoop(threadId, selectedDirectory, queueMessage, sessionLog) {
+export async function runInboxLoop(threadId, selectedDirectory, queueMessage, sessionLog, executionOrigin = 'recovery') {
     const directory = executionDirectory(selectedDirectory);
     const kbPath = directory.path;
+    const scheduled = threadId.startsWith('scheduled:');
+    // A trusted queue job may legitimately have no destination. Only retained
+    // inbox recovery requires a captured destination before executing its drop.
+    if (scheduled && executionOrigin === 'recovery') {
+        const routing = readThreadRouting(threadId);
+        if (!routing?.responseContext?.slack) {
+            quarantineInbox(kbPath, threadId);
+            const detail = 'Retained scheduler inbox has no trusted Slack destination; saved in unroutable/ for operator review';
+            sessionLog.error(`[Loop] ${detail}: ${threadId}`);
+            emitError('session', detail, { context: { threadId, reason: 'unroutable_inbox' } });
+            return;
+        }
+        queueMessage = { ...queueMessage, source: routing.source ?? 'cron', response_context: routing.responseContext };
+    }
     if (isQuotaPaused() && !getPollerId())
         return;
     const initialPool = await fetchRuntimePool(queueMessage);
@@ -275,6 +290,7 @@ export async function runInboxLoop(threadId, selectedDirectory, queueMessage, se
     activeLoops.add(threadId);
     let iteration = 0;
     const failureCounts = new Map();
+    const loggedRoutingDrops = new Set();
     try {
         let lockResult = await acquireSessionLock(threadId, kbPath);
         if (!lockResult.success) {
@@ -323,8 +339,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)) {
@@ -337,6 +355,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.
@@ -413,6 +446,10 @@ export async function runInboxLoop(threadId, selectedDirectory, queueMessage, se
             try {
                 // Reconstruct queue message from stored inbox data
                 const storedData = JSON.parse(message.content);
+                if (scheduled && 'response_context' in storedData && !loggedRoutingDrops.has(message.filename)) {
+                    logger.debug(`[Loop] Ignoring inbox response_context for scheduler routing: ${threadId} (${message.filename})`);
+                    loggedRoutingDrops.add(message.filename);
+                }
                 const storedScope = storedData.teamvibe;
                 const scopeMismatch = storedScope && (storedScope.workspaceId !== queueMessage.teamvibe.workspaceId ||
                     storedScope.channelId !== queueMessage.teamvibe.channelId ||
@@ -427,7 +464,8 @@ export async function runInboxLoop(threadId, selectedDirectory, queueMessage, se
                     // inbox data. This guard applies to both direct and pool execution.
                     thread_id: threadId,
                     teamvibe: { ...storedScope, ...queueMessage.teamvibe, brain: queueMessage.teamvibe.brain },
-                    ...(scopeMismatch ? { response_context: queueMessage.response_context } : {}),
+                    ...(scopeMismatch || scheduled ? { response_context: queueMessage.response_context } : {}),
+                    ...(scheduled ? { source: queueMessage.source } : {}),
                 };
                 // Legacy delivery uses the original routing, just as on main.
                 let result;
@@ -625,7 +663,7 @@ 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, inboxQueueMessageIds(kbPath, threadId));
                     const retained = readInboxRuntime(kbPath, threadId);
@@ -644,7 +682,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');
@@ -860,7 +898,7 @@ export async function runInboxLoop(threadId, selectedDirectory, queueMessage, se
         activeLocks.delete(threadId);
     }
 }
-async function processMessage(received) {
+export async function processMessage(received) {
     const { queueMessage, receiptHandle, messageId } = received;
     const logSessionId = messageId.slice(0, 8);
     const threadId = queueMessage.thread_id;
@@ -905,6 +943,20 @@ async function processMessage(received) {
     // Register brain so the maintenance cron knows about it.
     registerBrain(queueMessage, directory);
     const kbPath = directory.path;
+    // This is the trusted queue boundary, before creating any brain-writable
+    // inbox copy. Recovery may update assignment/bookkeeping, never destination
+    // or source. Synthetic scheduler IDs retain their independent lock identity.
+    if (threadId.startsWith('scheduled:')) {
+        saveThreadRouting(threadId, {
+            workspaceId: queueMessage.teamvibe.workspaceId,
+            channelId: queueMessage.teamvibe.channelId,
+            brainId: queueMessage.teamvibe.brain?.brainId,
+            directory: kbPath,
+            source: queueMessage.source,
+            responseContext: queueMessage.response_context.slack?.channel
+                ? { slack: { ...queueMessage.response_context.slack } } : undefined,
+        });
+    }
     // Write raw message to inbox (spawnClaudeCode handles prompt formatting)
     const { botToken: _inboxToken, ...inboxTeamvibe } = queueMessage.teamvibe;
     writeMessage(kbPath, threadId, JSON.stringify({ ...queueMessage, executionOrigin: receiptHandle ? 'queue' : 'maintenance', teamvibe: inboxTeamvibe }));
@@ -916,7 +968,7 @@ async function processMessage(received) {
     }
     processingMessages.add(messageId);
     try {
-        await runInboxLoop(threadId, directory, queueMessage, sessionLog);
+        await runInboxLoop(threadId, directory, queueMessage, sessionLog, 'queue');
     }
     catch (error) {
         sessionLog.error(`Error in inbox loop: ${error instanceof Error ? error.message : error}`);

package/dist/redact-text.js

@@ -19,7 +19,7 @@ export function redactStartupText(text, configuredTokens = []) {
     let safe = text
         .replace(/https?:\/\/[^\s/@]+@/gi, 'https://[REDACTED]@')
         .replace(/\b(?:Authorization\s*:\s*)?Bearer\s+[^\s,;]+/gi, 'Bearer [REDACTED]')
-        .replace(/\bx-access-token\s*:\s*[^\s/@,;]+/gi, 'x-access-token:[REDACTED]')
+        .replace(/\b(x-access-token|oauth2)\s*:\s*[^\s/@,;]+/gi, '$1:[REDACTED]')
         // Cover both Claude's token name and the opt-in subprocess alias in
         // shell assignments and JSON env diagnostics, even without a token list.
         .replace(/(\b(?:CLAUDE_CODE_OAUTH_TOKEN|TEAMVIBE_CLAUDE_OAUTH_TOKEN)["']?\s*[:=]\s*)(?:"(?:\\.|[^"\\])*"|'[^']*'|[^\s,;]+)/gi, '$1[REDACTED]');

package/dist/slack-client.d.ts

@@ -17,6 +17,8 @@ export interface TypingIndicator {
     /** Stop the typing indicator and clear the status */
     stop: () => void;
 }
-export declare function startTypingIndicator(msg: TeamVibeQueueMessage, statusText?: string): TypingIndicator;
+export declare function startTypingIndicator(msg: TeamVibeQueueMessage, statusText?: string): TypingIndicator & {
+    __flushForTest: () => Promise<void>;
+};
 export declare function removeReaction(msg: TeamVibeQueueMessage, emoji: string): Promise<void>;
 export {};

package/dist/slack-client.js

@@ -1,4 +1,4 @@
-import { WebClient } from '@slack/web-api';
+import { LogLevel, WebClient } from '@slack/web-api';
 import { logger } from './logger.js';
 import { emitError } from './event-queue.js';
 import { config } from './config.js';
@@ -6,6 +6,20 @@ import { config } from './config.js';
 const userCache = new Map();
 // Per-token Slack client cache
 const slackClients = new Map();
+const slackStatusClients = new Map();
+// tv#589 review: the SDK's own logger prints raw `response_metadata.messages`,
+// which can echo the status text (agent narration) on an API error. The
+// status client therefore gets a silent logger; application code owns the
+// redacted warnings in requestThreadStatus below.
+const silentSlackLogger = {
+    debug: () => { },
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+    setLevel: () => { },
+    getLevel: () => LogLevel.ERROR,
+    setName: () => { },
+};
 // Slack: "must be less than 51 characters [json-pointer:/loading_messages/0]"
 const SLACK_LOADING_MESSAGE_MAX = 50;
 function getSlackClient(botToken) {
@@ -16,6 +30,21 @@ function getSlackClient(botToken) {
     }
     return client;
 }
+function getSlackStatusClient(botToken) {
+    let client = slackStatusClients.get(botToken);
+    if (!client) {
+        client = new WebClient(botToken, {
+            // The SDK passes timeout to Axios, which aborts the underlying HTTP request.
+            timeout: config.TYPING_STATUS_REQUEST_TIMEOUT_MS,
+            // Let the indicator recover immediately and own the single clear retry.
+            retryConfig: { retries: 0 },
+            rejectRateLimitedCalls: true,
+            logger: silentSlackLogger, // Never let the SDK echo status text; warnings are redacted below.
+        });
+        slackStatusClients.set(botToken, client);
+    }
+    return client;
+}
 export async function getUserInfo(botToken, userId) {
     const cached = userCache.get(userId);
     if (cached)
@@ -111,16 +140,29 @@ export async function addReaction(msg, emoji) {
     }
 }
 export async function setThreadStatus(msg, status) {
+    // Standalone callers retain best-effort delivery; indicators handle retries.
+    await requestThreadStatus(msg, status).catch(() => { });
+}
+async function requestThreadStatus(msg, status, onTimeout = () => logger.warn('Slack thread status request timed out')) {
     if (!msg.response_context.slack)
         return;
     const { channel, thread_ts } = msg.response_context.slack;
-    const slack = getSlackClient(msg.teamvibe.botToken);
+    const slack = getSlackStatusClient(msg.teamvibe.botToken);
     const safeStatus = neutralizeSlackMarkup(status);
     const payload = {
         channel_id: channel,
         thread_ts,
         status: safeStatus,
     };
+    const reportFailure = (error) => {
+        // WebClient wraps Axios errors in a WebAPIRequestError with the original attached.
+        const code = error?.original?.code ?? error?.code;
+        if (code === 'ECONNABORTED' || code === 'ETIMEDOUT')
+            onTimeout();
+        else
+            logger.warn('Failed to set thread status');
+        emitError('slack', 'Failed to set thread status', { severity: 'warn' });
+    };
     try {
         await slack.apiCall('assistant.threads.setStatus', {
             ...payload,
@@ -137,14 +179,14 @@ export async function setThreadStatus(msg, status) {
                 await slack.apiCall('assistant.threads.setStatus', payload);
                 return;
             }
-            catch {
-                emitError('slack', 'Failed to set thread status', { severity: 'warn' });
-                return;
+            catch (retryError) {
+                reportFailure(retryError);
+                throw retryError;
             }
         }
         // API errors may echo request fields; status can contain private narration.
-        logger.warn('Failed to set thread status');
-        emitError('slack', `Failed to set thread status`, { severity: 'warn' });
+        reportFailure(error);
+        throw error;
     }
 }
 function truncateLoadingMessage(text) {
@@ -176,9 +218,36 @@ export function startTypingIndicator(msg, statusText = 'Thinking...') {
         else
             logger.info(`[Typing] status -> ${source} (${status.length} chars)`);
     };
+    // Serialize all writes so an older request cannot land after a newer status.
+    let statusChain = Promise.resolve();
+    let pendingRequests = 0;
+    let timeoutWarned = false;
+    const warnTimeout = () => {
+        if (timeoutWarned)
+            return;
+        timeoutWarned = true;
+        logger.warn('Slack thread status request timed out');
+    };
+    const enqueueStatus = (text, retryClear = false) => {
+        pendingRequests++;
+        const request = statusChain.then(async () => {
+            try {
+                await requestThreadStatus(msg, text, warnTimeout);
+            }
+            catch (error) {
+                if (!retryClear)
+                    throw error;
+                await new Promise(resolve => setTimeout(resolve, 500));
+                await requestThreadStatus(msg, text, warnTimeout);
+            }
+        });
+        // Recover the chain so a failed write never blocks later writes or the clear.
+        statusChain = request.catch(() => { }).finally(() => { pendingRequests--; });
+        return request;
+    };
     // Set initial status
     logStatus(currentStatus, currentSource);
-    setThreadStatus(msg, currentStatus);
+    void enqueueStatus(currentStatus).catch(() => { });
     const cancelHold = () => {
         if (holdTimer !== undefined)
             clearTimeout(holdTimer);
@@ -190,17 +259,19 @@ export function startTypingIndicator(msg, statusText = 'Thinking...') {
         currentStatus = text;
         currentSource = text ? source : 'default';
         if (text && source === 'comment')
-            commentShownAt = Date.now();
+            commentShownAt = Date.now(); // Pre-existing enqueue-time hold, before successful display (#589 review P2-2).
         if (changed) {
             logStatus(text, source);
-            setThreadStatus(msg, text);
+            void enqueueStatus(text).catch(() => { });
         }
     };
     // Keepalive every 3 seconds (Slack clears after ~2 min timeout)
     let failures = 0;
     const interval = setInterval(async () => {
+        if (stopped || pendingRequests > 0)
+            return;
         try {
-            await setThreadStatus(msg, currentStatus);
+            await enqueueStatus(currentStatus);
             failures = 0;
         }
         catch {
@@ -211,6 +282,7 @@ export function startTypingIndicator(msg, statusText = 'Thinking...') {
         }
     }, 3000);
     return {
+        __flushForTest: () => statusChain,
         updateStatus: (newStatus, source = 'comment') => {
             if (stopped)
                 return;
@@ -244,7 +316,7 @@ export function startTypingIndicator(msg, statusText = 'Thinking...') {
             clearInterval(interval);
             if (currentStatus)
                 logStatus('', 'default');
-            setThreadStatus(msg, '');
+            void enqueueStatus('', true).catch(() => { });
         },
     };
 }

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

@@ -205,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,
             };
         }));
@@ -212,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 {};
@@ -226,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) {

package/dist/subscription-selection.d.ts

@@ -10,6 +10,13 @@ export declare const PROBE_USAGE_TTL_MS = 60000;
 export declare const POOL_RECHECK_MS: number;
 /** Safety hold from the rejection observation when the provider gives no reset. */
 export declare const REJECTED_BLOCK_MS: number;
+export declare const VERIFICATION_MAX_BACKOFF_MS: number;
+export interface VerificationEvidence {
+    observedAt: number;
+    source: 'passive' | 'probe';
+    status: 'allowed' | 'allowed_warning';
+    percent: number;
+}
 export interface AccountIdentity {
     workspaceId: string;
     accountId: string;
@@ -47,6 +54,11 @@ export interface UsageWindow {
     source?: 'passive' | 'probe';
     percent?: number;
     resetAt?: number;
+    /** Missing on legacy rejections means the first consecutive rejection. */
+    rejectionCount?: number;
+    lastVerificationAttemptAt?: number;
+    /** A genuine same-window measurement; never inferred from an omitted meter. */
+    verificationEvidence?: VerificationEvidence;
 }
 export interface UsageObservation {
     pollerVersion?: string;
@@ -67,11 +79,11 @@ export declare function projectLegacyFableUsage<T extends UsageObservation | und
  * Deduplicate uncertain windows before splitting measurements from rejections.
  */
 export declare function supersedeLegacyFableProjections(observations: readonly (UsageObservation | undefined)[], now: number): (UsageObservation | undefined)[];
-/** Latest measurements plus durable genuine rejections; omission or success never clears a genuine hold. */
+/** Latest measurements plus durable rejections; only a claimed real spawn can clear a hold. */
 export declare function mergeUsageObservations(observations: readonly (UsageObservation | undefined)[], now: number): UsageObservation | undefined;
 /** Preserve last-known meters, projecting legacy identity before its global companion is replaced. */
 export declare function mergePersistedUsageObservations(previous: UsageObservation | undefined, incoming: UsageObservation | undefined, now: number): UsageObservation | undefined;
-export interface ReactiveExhaustion {
+export interface ReactiveExhaustion extends Pick<UsageWindow, 'rejectionCount' | 'lastVerificationAttemptAt' | 'verificationEvidence'> {
     observedAt: number;
     quota: ClaudeQuotaFailure;
 }
@@ -106,6 +118,13 @@ export declare function record(value: unknown): Record<string, unknown>;
 export declare function normalizePassiveUsage(value: unknown, observedAt: number): UsageObservation;
 export declare function normalizeProbeUsage(value: unknown, observedAt: number): UsageObservation;
 export declare function family(model: string | undefined): 'sonnet' | 'opus' | 'haiku' | 'fable' | undefined;
+export declare function rejectionResetAt(window: UsageWindow, observedAt: number): number;
+export declare function verificationEligibleAt(window: UsageWindow, observedAt: number): number;
+export declare function rejectionEvidence(usage: UsageObservation | undefined, window: UsageWindow, now: number): VerificationEvidence | undefined;
+export declare function rejectionEligibleAt(usage: UsageObservation | undefined, window: UsageWindow, account: AccountIdentity, now: number): number;
+export declare function reactiveUsageWindow(reactive: ReactiveExhaustion): UsageWindow;
+/** Due windows are claimed durably at the real spawn boundary, never by pure selection. */
+export declare function verificationWindows(account: AccountIdentity, state: AccountUsageState, model: string | undefined, now: number): UsageWindow[];
 export declare function reactiveEligibleAt(reactive: ReactiveExhaustion): number;
 /** Pure policy. Unknown is eligible after every known/reactive blocker is ruled out. */
 export declare function selectSubscriptionAccount<A extends AccountIdentity>(input: {