@teamvibe/poller 0.8.5 → 0.8.6-rc.2

package/dist/claude-spawner.d.ts

@@ -248,6 +248,7 @@ export declare function spawnClaudeCode(msg: TeamVibeQueueMessage, sessionLog: S
 export declare function spawnPoolClaudeCode(msg: TeamVibeQueueMessage, sessionLog: SessionLogger, selectedDirectory: BrainDirectory | string, sessionId?: string, isFirstMessage?: boolean, lastMessageTs?: string, onMessageSent?: () => void, typingIndicator?: TypingIndicator, poolRuntime?: PoolRuntimeOptions): Promise<SpawnResult & {
     newSessionId?: string;
 }>;
+export declare function isSubscriptionAccountRunning(account: Pick<SubscriptionAccount, 'workspaceId' | 'accountId'>): boolean;
 export declare function getActiveProcessCount(): number;
 export declare function getLastSessionEndTs(): number;
 /**

package/dist/claude-spawner.js

@@ -16,7 +16,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 { accountPin, preparePool, fetchRuntimePool, validateAccount, poolDeferredError, PoolDeferredError } from './subscription-runtime.js';
+import { abortLocalProbe, accountPin, preparePool, fetchRuntimePool, validateAccount, 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';
@@ -1023,6 +1023,10 @@ async function runClaudeCode(msg, sessionLog, cwd, directory, sessionId, isFirst
             ]));
         };
         warnTokenAliasSettings(spawnEnv['CLAUDE_CONFIG_DIR'], cwd, directory.path, sessionLog);
+        // Preparation awaits remote calls: cancel again at the actual launch site.
+        // No await between cancellation, spawn and running-account registration.
+        if (runtime?.account)
+            abortLocalProbe(runtime.account);
         const proc = spawn(config.CLAUDE_CLI_PATH, args, {
             cwd,
             env: spawnEnv,
@@ -1040,6 +1044,8 @@ async function runClaudeCode(msg, sessionLog, cwd, directory, sessionId, isFirst
         // Track active process by message ID and thread ID
         activeProcesses.set(msg.id, proc);
         activeProcessesByThread.set(msg.thread_id, proc);
+        if (runtime?.account)
+            activeSubscriptionAccounts.set(proc, runtime.account);
         for (const chunk of spawnStdinPlan.stdinChunks) {
             proc.stdin?.write(chunk);
         }
@@ -1310,6 +1316,7 @@ async function runClaudeCode(msg, sessionLog, cwd, directory, sessionId, isFirst
             clearNotificationTimers();
             activeProcesses.delete(msg.id);
             activeProcessesByThread.delete(msg.thread_id);
+            activeSubscriptionAccounts.delete(proc);
             lastSessionEndTs = Date.now();
             // #73 gap 2 (flagged independently by two reviews): `close` firing means
             // `claude` itself has exited, but its MCP server children — spawned
@@ -1401,6 +1408,7 @@ async function runClaudeCode(msg, sessionLog, cwd, directory, sessionId, isFirst
             clearInterval(idleWatchdog);
             activeProcesses.delete(msg.id);
             activeProcessesByThread.delete(msg.thread_id);
+            activeSubscriptionAccounts.delete(proc);
             lastSessionEndTs = Date.now();
             emitError('session', `Claude Code process spawn error: ${redactOutput(error.message)}`, {
                 channelId: msg.teamvibe.channelId,
@@ -1568,7 +1576,7 @@ export async function spawnPoolClaudeCode(msg, sessionLog, selectedDirectory, se
         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, sessionLog) : undefined;
+        const prepared = poolRuntime ? await preparePool(msg, resolved, poolRuntime.pin, fetchedPool, sessionLog, { cliPath: config.CLAUDE_CLI_PATH, isAtCapacity, emit: emitEvent, log: line => sessionLog.info(line) }) : undefined;
         const modelNormalizedFrom = scoped?.model === resolved.model && scoped?.modelSource === resolved.modelSource
             ? scoped?.modelNormalizedFrom : undefined;
         const runtime = poolRuntime ? { resolved, modelNormalizedFrom, claudeConfigDir, account: prepared?.account, shouldStop: poolRuntime.shouldStop, resumePending: fetchedPool?.kind !== 'no_accounts_configured' && poolRuntime.pin?.resumePending === true } : undefined;
@@ -1678,6 +1686,7 @@ export async function spawnPoolClaudeCode(msg, sessionLog, selectedDirectory, se
                 if (!effectiveSessionId)
                     throw new PoolDeferredError('infrastructure');
                 const fromAccount = prepared.account;
+                abortLocalProbe(selected.account);
                 poolInfo(sessionLog, `switch from=${poolLabel(fromAccount)} to=${poolLabel(selected.account)} session=${JSON.stringify(effectiveSessionId)}`);
                 prepared.account = selected.account;
                 prepared.selection = selected;
@@ -1733,6 +1742,10 @@ export async function spawnPoolClaudeCode(msg, sessionLog, selectedDirectory, se
 }
 const activeProcesses = new Map();
 const activeProcessesByThread = new Map();
+const activeSubscriptionAccounts = new Map();
+export function isSubscriptionAccountRunning(account) {
+    return [...activeSubscriptionAccounts.values()].some(active => active.workspaceId === account.workspaceId && active.accountId === account.accountId);
+}
 // tv#317: when the last `claude` process ended, so the idle-restart gate can require
 // a quiet period since real work last happened. Starts at module load (poller boot) so
 // a poller that never runs a session still becomes eligible once IDLE_RESTART_MIN_UPTIME_MS

package/dist/pool-logging.d.ts

@@ -1,7 +1,7 @@
 import type { PoolFetchDiagnostics } from './subscription-pool-client.js';
 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';
+import { type AccountIdentity, type AccountUsageState, type PoolFetchResult, type SelectionOutcome, type UsageWindow } from './subscription-selection.js';
 export type PoolInfoLogger = Pick<SessionLogger, 'info'>;
 type LabeledAccount = AccountIdentity & {
     label?: string;
@@ -15,6 +15,7 @@ export declare function poolErrorClass(error: unknown): string;
 export declare function poolErrorDiagnostic(error: unknown): string;
 export declare function logPoolFetch(log: PoolInfoLogger, pool: PoolFetchResult & PoolFetchDiagnostics): 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;
+export declare function formatPoolUsageWindows(windows: readonly UsageWindow[], includeScope?: boolean): string;
 /** Log the real store promise without changing its rejection or retry behavior. */
 export declare function logPoolUsageWrite(log: PoolInfoLogger, account: {
     label?: string;

package/dist/pool-logging.js

@@ -1,4 +1,4 @@
-import { redactStartupText } from './startup-auth.js';
+import { redactStartupText } from './redact-text.js';
 import { normalizePassiveUsage, selectSubscriptionAccount } from './subscription-selection.js';
 import { safeRateLimitInfo } from './subscription-usage-store.js';
 // Never serialize accounts, credentials, provider strings or caught errors.
@@ -87,9 +87,12 @@ export function logPoolSelection(log, pool, states, model, now, selected, logAll
         poolInfo(log, `selected account=${poolLabel(selected.account)} model=${JSON.stringify(model ?? 'CLI default')} score=${score}`);
     }
 }
+export function formatPoolUsageWindows(windows, includeScope = true) {
+    return windows.map(w => `${w.window}${includeScope ? `/${w.scope}` : ''}:${w.percent === undefined ? 'unknown' : `${Number(w.percent.toFixed(2))}%`}`).join(',') || 'none';
+}
 /** 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(',') : '';
+    const windows = formatPoolUsageWindows(info ? normalizePassiveUsage(safeRateLimitInfo(info), Date.now()).windows : [], source === 'passive');
     try {
         await write();
         poolInfo(log, `usage write account=${poolLabel(account)} result=ok windows=${windows || 'none'} source=${source}`);

package/dist/subscription-pool.d.ts

@@ -20,6 +20,7 @@ export declare function selectPoolForResolvedModel<A extends AccountIdentity & {
     store: SubscriptionUsageStore;
     now: number;
     currentAccountId?: string;
+    currentAccountTolerance?: number;
     log?: PoolInfoLogger;
     logAllExhausted?: boolean;
 }): Promise<ResolvedPoolSelection<A>>;

package/dist/subscription-pool.js

@@ -30,7 +30,7 @@ export async function selectPoolForResolvedModel(resolvedModel, input) {
     catch (error) {
         return { kind: 'usage_unavailable', error, ...resolvedModel };
     }
-    const selected = selectSubscriptionAccount({ pool: input.pool, states, model: resolvedModel.model, now: input.now, currentAccountId: input.currentAccountId });
+    const selected = selectSubscriptionAccount({ pool: input.pool, states, model: resolvedModel.model, now: input.now, currentAccountId: input.currentAccountId, currentAccountTolerance: input.currentAccountTolerance });
     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,3 +1,4 @@
+import { type UsageProbeOptions } from './usage-probe-job.js';
 import { type PoolInfoLogger } from './pool-logging.js';
 import { type PoolFetchDiagnostics, type SubscriptionAccount } from './subscription-pool-client.js';
 import { type ResolvedPoolModel } from './subscription-pool.js';
@@ -51,7 +52,15 @@ export interface PoolRuntimeOptions {
 }
 export declare function subscriptionUsageStore(): FileSubscriptionUsageStore;
 export declare function fetchRuntimePool(msg: TeamVibeQueueMessage): Promise<PoolFetchResult<SubscriptionAccount> & PoolFetchDiagnostics>;
-export declare function preparePool(msg: TeamVibeQueueMessage, resolved: ResolvedPoolModel, pin?: SubscriptionPin, fetched?: PoolFetchResult<SubscriptionAccount>, log?: PoolInfoLogger): Promise<{
+/** Minimum gap between local measurements of one workspace/account/credential. */
+export declare const LOCAL_PROBE_MIN_INTERVAL_MS = 60000;
+/** Bound background CLI load across every workspace in this poller process. */
+export declare const LOCAL_PROBE_MAX_CONCURRENT = 3;
+/** A local measurement has its own deadline, independent of session lifetime. */
+export declare const LOCAL_PROBE_TIMEOUT_MS = 30000;
+/** Synchronous: kill the isolated child and free its slot before session spawn. */
+export declare function abortLocalProbe(account: SubscriptionAccount): void;
+export declare function preparePool(msg: TeamVibeQueueMessage, resolved: ResolvedPoolModel, pin?: SubscriptionPin, fetched?: PoolFetchResult<SubscriptionAccount>, log?: PoolInfoLogger, probeOptions?: Omit<UsageProbeOptions, 'store'>): Promise<{
     account: SubscriptionAccount;
     store: FileSubscriptionUsageStore;
     pool: {

package/dist/subscription-runtime.js

@@ -1,3 +1,7 @@
+import { isAtCapacity, isSubscriptionAccountRunning } from './claude-spawner.js';
+import { emitEvent } from './event-queue.js';
+import { logger } from './logger.js';
+import { runUsageProbe } from './usage-probe-job.js';
 import { poolInfo, poolLabel, poolErrorDiagnostic } from './pool-logging.js';
 import { emitCandidateUsage } from './pool-telemetry.js';
 import { join } from 'node:path';
@@ -6,7 +10,7 @@ import { getPollerId } from './auth-provider.js';
 import { fetchSubscriptionPool } from './subscription-pool-client.js';
 import { selectPoolForResolvedModel } from './subscription-pool.js';
 import { FileSubscriptionUsageStore, usageStateForSelection } from './subscription-usage-store.js';
-import { normalizePassiveUsage, selectSubscriptionAccount, usageWindowExpiresAt, reactiveEligibleAt, USAGE_THRESHOLD_PERCENT, POOL_RECHECK_MS } from './subscription-selection.js';
+import { normalizePassiveUsage, selectSubscriptionAccount, usageWindowExpiresAt, reactiveEligibleAt, PIN_HEADROOM_SWITCH_RELATIVE, USAGE_THRESHOLD_PERCENT, POOL_RECHECK_MS } from './subscription-selection.js';
 export const POOL_UNAVAILABLE_RECHECK_MS = 60_000;
 export class PoolDeferredError extends Error {
     cause;
@@ -31,31 +35,104 @@ 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, log) {
+/** Minimum gap between local measurements of one workspace/account/credential. */
+export const LOCAL_PROBE_MIN_INTERVAL_MS = 60_000;
+/** Bound background CLI load across every workspace in this poller process. */
+export const LOCAL_PROBE_MAX_CONCURRENT = 3;
+/** A local measurement has its own deadline, independent of session lifetime. */
+export const LOCAL_PROBE_TIMEOUT_MS = 30_000;
+const localProbesInFlight = new Map();
+/** Synchronous: kill the isolated child and free its slot before session spawn. */
+export function abortLocalProbe(account) {
+    for (const [key, probe] of localProbesInFlight) {
+        // A credential rotation must not leave an older probe on the same account.
+        if (probe.account.workspaceId !== account.workspaceId || probe.account.accountId !== account.accountId)
+            continue;
+        localProbesInFlight.delete(key);
+        probe.controller.abort();
+    }
+}
+function probeUnknownAccounts(accounts, selectedAccountId, resolved, store, options, channelId) {
+    for (const account of accounts) {
+        if (!account.enabled || account.accountId === selectedAccountId || isSubscriptionAccountRunning(account))
+            continue;
+        // Fire-and-forget ALL probe work, including disk claims and cleanup. No
+        // session signal/shouldStop is passed: the observation outlives its trigger.
+        void (async () => {
+            const key = JSON.stringify([account.workspaceId, account.accountId, account.credentialVersion]);
+            let probe;
+            try {
+                const now = Date.now();
+                const state = usageStateForSelection(await store.read(account), now);
+                const candidate = selectSubscriptionAccount({ pool: { kind: 'ready', accounts: [account] }, states: { [account.accountId]: state }, model: resolved.model, now });
+                if (candidate.kind !== 'selected' || candidate.provenance !== 'unknown')
+                    return;
+                if (isSubscriptionAccountRunning(account))
+                    return;
+                if (localProbesInFlight.has(key)) {
+                    poolInfo({ info: options.log }, `local probe account=${poolLabel(account)} result=skipped reason=claimed`);
+                    return;
+                }
+                if (options.isAtCapacity() || localProbesInFlight.size >= LOCAL_PROBE_MAX_CONCURRENT)
+                    return;
+                // Reserve before asynchronous claiming, so concurrent preparePool calls
+                // cannot exceed the process-wide limit while claims are being written.
+                probe = { account, controller: new AbortController() };
+                localProbesInFlight.set(key, probe);
+                const claimed = await store.claimLocalProbe(account, now, LOCAL_PROBE_MIN_INTERVAL_MS);
+                if (probe.controller.signal.aborted) {
+                    poolInfo({ info: options.log }, `local probe account=${poolLabel(account)} result=cancelled reason=account selected`);
+                    return;
+                }
+                if (!claimed) {
+                    poolInfo({ info: options.log }, `local probe account=${poolLabel(account)} result=skipped reason=claimed`);
+                    return;
+                }
+                // Capacity may change while the durable claim is written.
+                if (options.isAtCapacity()) {
+                    poolInfo({ info: options.log }, `local probe account=${poolLabel(account)} result=cli_at_capacity`);
+                    return;
+                }
+                await runUsageProbe(account, { ...options, model: resolved.model, timeoutMs: LOCAL_PROBE_TIMEOUT_MS }, {
+                    channelId, signal: probe.controller.signal,
+                    onMeasurementComplete: () => {
+                        if (localProbesInFlight.get(key) === probe)
+                            localProbesInFlight.delete(key);
+                    },
+                });
+            }
+            catch {
+                poolInfo({ info: options.log }, `local probe account=${poolLabel(account)} result=${probe?.controller.signal.aborted ? 'cancelled reason=account selected' : 'unknown'}`);
+            }
+            finally {
+                // An aborted run must not delete a newer reservation for the same key.
+                if (probe && localProbesInFlight.get(key) === probe)
+                    localProbesInFlight.delete(key);
+            }
+        })();
+    }
+}
+export async function preparePool(msg, resolved, pin, fetched, log, probeOptions) {
     const pool = fetched ?? await fetchRuntimePool(msg);
     const store = subscriptionUsageStore();
     if (pool.kind === 'ready')
         await emitCandidateUsage(msg, pool.accounts, store);
-    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: { ...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, selection: selected };
-            }
-        }
-    }
-    const selected = await selectPoolForResolvedModel(resolved, { workspaceId: msg.teamvibe.workspaceId, pool, store, now: Date.now(), log, currentAccountId: pin?.workspaceId === msg.teamvibe.workspaceId ? pin.accountId : undefined });
+    const currentAccountId = pin?.workspaceId === msg.teamvibe.workspaceId ? pin.accountId : undefined;
+    // A pin is a spawn-boundary preference. Reactive same-session switches keep
+    // their existing strict ranking and do not receive this tolerance.
+    const selected = await selectPoolForResolvedModel(resolved, { workspaceId: msg.teamvibe.workspaceId, pool, store, now: Date.now(), log, currentAccountId, currentAccountTolerance: PIN_HEADROOM_SWITCH_RELATIVE });
     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`);
+        abortLocalProbe(selected.account);
+        if (log && pool.kind === 'ready' && currentAccountId && currentAccountId !== selected.account.accountId) {
+            const previous = pool.accounts.find(a => a.accountId === currentAccountId);
+            const previousSelection = previous ? await selectPoolForResolvedModel(resolved, { workspaceId: msg.teamvibe.workspaceId, pool: { kind: 'ready', accounts: [previous] }, store, now: Date.now() }) : undefined;
+            poolInfo(log, `switch from=${poolLabel(previous ?? {})} to=${poolLabel(selected.account)} reason=${previousSelection?.kind === 'selected' ? 'better headroom' : 'pinned account unavailable'}`);
         }
+        if (pool.kind === 'ready')
+            probeUnknownAccounts(pool.accounts, selected.account.accountId, resolved, store, {
+                cliPath: config.CLAUDE_CLI_PATH, isAtCapacity, emit: emitEvent,
+                log: line => (log ?? logger).info(line), ...probeOptions, store,
+            }, msg.teamvibe.channelId);
         return { account: selected.account, store, pool, selection: selected };
     }
     if (selected.kind === 'no_accounts_configured')

package/dist/subscription-selection.d.ts

@@ -1,8 +1,11 @@
 import type { AccountProbeFailureReason } from './usage-probe-contract.js';
 import type { ClaudeQuotaFailure } from './claude-quota.js';
+/** Switch a spawn-boundary pin when the best score is at least 25% higher. */
+export declare const PIN_HEADROOM_SWITCH_RELATIVE = 0.25;
 export declare const USAGE_THRESHOLD_PERCENT = 90;
 /** Fallback freshness for passive windows without a reset time. */
 export declare const PASSIVE_USAGE_TTL_MS: number;
+/** Fallback freshness for probe windows without a reset time. */
 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. */
@@ -49,7 +52,7 @@ export interface UsageObservation {
     observedAt: number;
     windows: readonly UsageWindow[];
 }
-/** Passive percentages remain lower bounds until reset; probes retain their short TTL. */
+/** Passive and probe percentages remain lower bounds until each window resets. */
 export declare function usageWindowExpiresAt(usage: UsageObservation, window: UsageWindow): number;
 /** Latest measurements plus durable rejections; omission or success never clears a hold. */
 export declare function mergeUsageObservations(observations: readonly (UsageObservation | undefined)[], now: number): UsageObservation | undefined;
@@ -92,7 +95,8 @@ export declare function selectSubscriptionAccount<A extends AccountIdentity>(inp
     /** Stable account ID within the pool's single workspace. */
     states: Readonly<Record<string, AccountUsageState | undefined>>;
     model: string | undefined;
-    /** Tie preference only; session pins are enforced separately by the runtime. */
+    /** Tie preference by default; runtime pins can also supply a relative tolerance. */
     currentAccountId?: string;
+    currentAccountTolerance?: number;
     now: number;
 }): SelectionOutcome<A>;

package/dist/subscription-selection.js

@@ -1,14 +1,17 @@
+/** Switch a spawn-boundary pin when the best score is at least 25% higher. */
+export const PIN_HEADROOM_SWITCH_RELATIVE = 0.25;
 export const USAGE_THRESHOLD_PERCENT = 90;
 /** Fallback freshness for passive windows without a reset time. */
 export const PASSIVE_USAGE_TTL_MS = 5 * 60_000;
+/** Fallback freshness for probe windows without a reset time. */
 export const PROBE_USAGE_TTL_MS = 60_000;
 export const POOL_RECHECK_MS = 15 * 60_000;
 /** Safety hold from the rejection observation when the provider gives no reset. */
 export const REJECTED_BLOCK_MS = 15 * 60_000;
-/** Passive percentages remain lower bounds until reset; probes retain their short TTL. */
+/** Passive and probe percentages remain lower bounds until each window resets. */
 export function usageWindowExpiresAt(usage, window) {
     const ttlExpiry = usage.observedAt + (usage.source === 'passive' ? PASSIVE_USAGE_TTL_MS : PROBE_USAGE_TTL_MS);
-    return usage.source === 'passive' ? window.resetAt ?? ttlExpiry : Math.min(window.resetAt ?? ttlExpiry, ttlExpiry);
+    return window.resetAt ?? ttlExpiry;
 }
 /** Latest measurements plus durable rejections; omission or success never clears a hold. */
 export function mergeUsageObservations(observations, now) {
@@ -223,7 +226,15 @@ export function selectSubscriptionAccount(input) {
     }
     const compare = (a, b) => a.accountId < b.accountId ? -1 : a.accountId > b.accountId ? 1 : 0;
     known.sort((a, b) => b.score - a.score || Number(b.account.accountId === input.currentAccountId) - Number(a.account.accountId === input.currentAccountId) || compare(a.account, b.account));
-    unknown.sort((a, b) => compare(a.account, b.account));
+    // Unknown pin preference is opt-in for preparePool; preserve the default
+    // policy's stable ID order (also used by the server and reactive selection).
+    unknown.sort((a, b) => (input.currentAccountTolerance === undefined ? 0 : Number(b.account.accountId === input.currentAccountId) - Number(a.account.accountId === input.currentAccountId)) || compare(a.account, b.account));
+    const current = known.find(candidate => candidate.account.accountId === input.currentAccountId);
+    if (current && known[0] && input.currentAccountTolerance !== undefined &&
+        known[0].score < current.score * (1 + input.currentAccountTolerance))
+        return { kind: 'selected', provenance: 'known', ...current };
+    // Known-first is only this spawn's transitional fallback: background CLI
+    // probes measure non-selected unknowns so the next spawn can score them.
     if (known[0])
         return { kind: 'selected', provenance: 'known', ...known[0] };
     if (unknown[0])

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

@@ -29,6 +29,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>;
+    claimLocalProbe(key: UsageKey, observedAt: number, minIntervalMs: number): Promise<boolean>;
     claimProbeRequest(requestId: string, expiresAt: number): Promise<boolean>;
     finishProbe(key: UsageKey, observation: ProbeObservation): Promise<void>;
 }
@@ -46,6 +47,8 @@ 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>;
+    /** Atomic across store instances; separate from optional HTTP and platform claims. */
+    claimLocalProbe(key: UsageKey, observedAt: number, minIntervalMs: 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

@@ -103,6 +103,10 @@ function safeProbe(value) {
 }
 function safeVersion(value) {
     const state = {};
+    if (value.localProbeClaimedAt !== undefined) {
+        validTime(value.localProbeClaimedAt);
+        state.localProbeClaimedAt = value.localProbeClaimedAt;
+    }
     if (value.passive) {
         validTime(value.passive.observedAt);
         state.passive = { observedAt: value.passive.observedAt, rateLimitInfo: safeRateLimitInfo(value.passive.rateLimitInfo) };
@@ -220,6 +224,20 @@ export class FileSubscriptionUsageStore {
             return true;
         });
     }
+    /** Atomic across store instances; separate from optional HTTP and platform claims. */
+    async claimLocalProbe(key, observedAt, minIntervalMs) {
+        validTime(observedAt);
+        const path = this.#path(key, true);
+        return serial(path, async () => {
+            const state = safeVersion(await this.#load(path, {}));
+            if (state.localProbeClaimedAt !== undefined && observedAt >= state.localProbeClaimedAt &&
+                observedAt - state.localProbeClaimedAt < minIntervalMs)
+                return false;
+            state.localProbeClaimedAt = observedAt;
+            await this.#save(path, state);
+            return true;
+        });
+    }
     /** Request claims live in the local data directory, alongside usage, never in a brain. */
     async claimProbeRequest(requestId, expiresAt) {
         validTime(expiresAt);

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

@@ -1,17 +1,34 @@
+import { spawn } from 'node:child_process';
 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>>;
+import type { UsageProbeFailureReason as Reason } from './usage-probe-contract.js';
+type ProbeResult = Reason | 'ok' | 'cancelled';
+export interface UsageProbeOptions {
     store: SubscriptionUsageStore;
     cliPath: string;
+    /** Use the session's resolved model for local probes; platform jobs default to CLI behavior. */
+    model?: string;
     timeoutMs?: number;
+    /** Injectable child for deterministic tests; production uses node spawn. */
+    spawn?: typeof spawn;
     isAtCapacity: () => boolean;
     emit: (type: string, channelId: string, metadata: Record<string, unknown>) => void;
     log: (line: string) => void;
 }
+interface Options extends UsageProbeOptions {
+    fetchPool: () => Promise<PoolFetchResult<SubscriptionAccount>>;
+}
 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>;
+/** Shared isolated CLI measurement; independent of any triggering session. */
+export declare function runUsageProbe(account: SubscriptionAccount, options: UsageProbeOptions, context?: {
+    requestId?: string;
+    expiresAt?: number;
+    channelId?: string;
+    signal?: AbortSignal;
+    onMeasurementComplete?: () => void;
+}): Promise<ProbeResult>;
 export {};

package/dist/usage-probe-job.js

@@ -5,6 +5,7 @@ import { join } from 'node:path';
 import { normalizePassiveUsage } from './subscription-selection.js';
 import { safeRateLimitInfo, usageStateForSelection, } from './subscription-usage-store.js';
 import { parseClaudeRateLimitInfo, } from './claude-rate-limit.js';
+import { formatPoolUsageWindows, poolInfo, poolLabel } from './pool-logging.js';
 export function isUsageProbe(value) {
     return (!!value &&
         typeof value === 'object' &&
@@ -14,7 +15,7 @@ export function isUsageProbe(value) {
 export async function handleUsageProbe(job, options) {
     let result = 'unknown';
     let duplicate = false;
-    let cwd;
+    let probed = false;
     if (!['workspaceId', 'accountId', 'credentialVersion', 'requestId'].every((k) => {
         const value = job[k];
         return (typeof value === 'string' &&
@@ -63,9 +64,36 @@ export async function handleUsageProbe(job, options) {
             result = 'cli_at_capacity';
             return;
         }
+        probed = true;
+        result = await runUsageProbe(account, options, { requestId: job.requestId, expiresAt: job.expiresAt });
+    }
+    catch {
+        result = 'unknown';
+    }
+    finally {
+        if (!duplicate && result !== 'ok' && result !== 'cancelled')
+            options.emit('pool.probe_failed', 'usage_probe', {
+                ...metadata,
+                reason: result,
+            });
+        if (!duplicate && !probed)
+            options.log(`[Pool] usage probe request=${job.requestId} result=${result}`);
+    }
+}
+/** Shared isolated CLI measurement; independent of any triggering session. */
+export async function runUsageProbe(account, options, context = {}) {
+    let result = 'unknown';
+    let cwd;
+    let measuredWindows;
+    const cancelled = () => context.signal?.aborted === true;
+    try {
+        if (cancelled())
+            return result = 'cancelled';
         cwd = await mkdtemp(join(tmpdir(), 'teamvibe-usage-'));
         const configDir = join(cwd, 'config');
         await mkdir(configDir);
+        if (cancelled())
+            return result = 'cancelled';
         // Allow only OS execution essentials. No ambient credentials, Slack, API,
         // brain, hooks, or user's Claude settings reach this isolated child.
         const env = {
@@ -79,9 +107,10 @@ export async function handleUsageProbe(job, options) {
         let info;
         const outcome = await new Promise((resolve) => {
             let done = false, buffer = '', errorText = '';
-            const child = spawn(options.cliPath, [
+            const child = (options.spawn ?? spawn)(options.cliPath, [
                 '-p',
                 'Reply OK.',
+                ...(options.model ? ['--model', options.model] : []),
                 '--output-format',
                 'stream-json',
                 '--verbose',
@@ -105,18 +134,25 @@ export async function handleUsageProbe(job, options) {
                         child.kill('SIGKILL');
                     }
                 }
+                else
+                    child.kill('SIGKILL');
             };
             const finish = (reason) => {
                 if (done)
                     return;
                 done = true;
                 clearTimeout(timer);
+                context.signal?.removeEventListener('abort', onAbort);
                 resolve(reason);
             };
-            const timer = setTimeout(() => {
+            const onAbort = () => {
+                finish('cancelled');
                 kill();
+            };
+            const timer = setTimeout(() => {
                 finish('timeout');
-            }, Math.min(options.timeoutMs ?? 60_000, Math.max(1, job.expiresAt - Date.now())));
+                kill();
+            }, Math.min(options.timeoutMs ?? 60_000, Math.max(1, (context.expiresAt ?? Infinity) - Date.now())));
             const line = (text) => {
                 try {
                     const event = JSON.parse(text);
@@ -128,6 +164,8 @@ export async function handleUsageProbe(job, options) {
                 catch { }
             };
             child.stdout.on('data', (chunk) => {
+                if (done)
+                    return;
                 buffer += chunk.toString();
                 if (buffer.length > 1024 * 1024) {
                     kill();
@@ -147,6 +185,8 @@ export async function handleUsageProbe(job, options) {
             // 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 (done)
+                    return;
                 if (buffer)
                     line(buffer);
                 finish(/401|unauthorized|invalid.*token|invalid api key|authentication.*(?:fail|error)/i.test(errorText)
@@ -157,43 +197,57 @@ export async function handleUsageProbe(job, options) {
                             ? 'ok'
                             : 'unknown');
             });
+            context.signal?.addEventListener('abort', onAbort, { once: true });
+            if (cancelled())
+                onAbort();
         });
-        result = outcome;
+        result = cancelled() ? 'cancelled' : outcome;
+        // The CLI has finished. Stop treating this as an in-flight measurement
+        // before publishing its result, so a later selection cannot retroactively
+        // cancel an observation whose store write has already started.
+        context.onMeasurementComplete?.();
         if (result !== 'ok' || !info)
-            return;
+            return result;
         const now = Date.now();
         const safe = safeRateLimitInfo(info);
         const usage = {
             ...normalizePassiveUsage(safe, now),
             source: 'probe',
         };
+        measuredWindows = formatPoolUsageWindows(usage.windows);
         await options.store.finishProbe(account, {
             status: 'ok',
             observedAt: now,
             usage,
         });
-        options.emit('pool.usage_observed', 'usage_probe', {
-            ...metadata,
+        const stored = await options.store.read(account);
+        // Requestless local observations use real channel authorization; the
+        // workspace-job namespace is reserved for platform request IDs.
+        options.emit('pool.usage_observed', context.channelId ?? 'usage_probe', {
+            workspaceId: account.workspaceId,
+            accountId: account.accountId,
+            credentialVersion: account.credentialVersion,
+            ...(context.requestId ? { requestId: context.requestId } : {}),
+            source: 'probe',
             accountLabel: account.label ?? account.accountId,
             reportedAt: now,
-            usage: usageStateForSelection(await options.store.read(account), now).usage,
+            usage: usageStateForSelection(stored, now).usage,
             lastRateLimitInfo: safe,
             probeStatus: 'ok',
             probeObservedAt: now,
         });
+        return result;
     }
     catch {
-        result = 'unknown';
+        result = cancelled() ? 'cancelled' : 'unknown';
+        return result;
     }
     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 request=${job.requestId} result=${result}`);
+        const description = context.requestId
+            ? `usage probe request=${context.requestId}`
+            : `local probe account=${poolLabel(account)}`;
+        poolInfo({ info: options.log }, `${description} result=${result}${result === 'ok' && !context.requestId ? ` windows=${measuredWindows}` : ''}${result === 'cancelled' ? ' reason=account selected' : ''}`);
     }
 }

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@teamvibe/poller",
-  "version": "0.8.5",
+  "version": "0.8.6-rc.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@teamvibe/poller",
-      "version": "0.8.5",
+      "version": "0.8.6-rc.2",
       "dependencies": {
         "@aws-sdk/client-dynamodb": "3.1108.0",
         "@aws-sdk/client-sqs": "3.1108.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teamvibe/poller",
-  "version": "0.8.5",
+  "version": "0.8.6-rc.2",
   "type": "module",
   "main": "./dist/index.js",
   "bin": {