@teamvibe/poller 0.8.3 → 0.8.4-rc.1

package/dist/maintenance-cron.js

@@ -1,3 +1,4 @@
+import { executionDirectory } from './brain-directory.js';
 import { Cron } from 'croner';
 import { config } from './config.js';
 import { logger } from './logger.js';
@@ -8,7 +9,7 @@ import { collectMetrics } from './metrics/collector.js';
 import { sendMetrics } from './metrics/sender.js';
 import { markMaintenanceJobFired, markMaintenanceJobSuccess, markMaintenanceJobSkipped, } from './cron-telemetry.js';
 import { shouldSkipMaintenance } from './maintenance-activity.js';
-import { join } from 'path';
+import { resolveBrainDir, fallbackBrainPath, validateBrainId } from './brain-path.js';
 const trackedBrains = new Map();
 /**
  * Read-only view of brains seen so far (via registerBrain). Used by the inbox
@@ -42,7 +43,7 @@ let maintenanceJob = null;
  * opposite bug — a genuinely-quiet brain wrongly evaluated as "nothing new,
  * skip" on its very first post-restart cron tick.
  *
- * Skips (rather than overwrites) any brainId already present in
+ * Skips (rather than overwrites) any workspace/channel already present in
  * trackedBrains. This guard is load-bearing, not just defensive (DevGuru
  * review, round 4): since round 3's critical-path detachment
  * (brains-bootstrap.ts's `void (async () => {...})()` retry), the retry
@@ -80,9 +81,21 @@ let maintenanceJob = null;
 export function seedTrackedBrains(brains) {
     let seeded = 0;
     for (const b of brains) {
-        if (trackedBrains.has(b.brainId))
+        if (trackedBrains.has(`${b.workspaceId}:${b.channelId}`))
             continue;
-        trackedBrains.set(b.brainId, {
+        let directory;
+        try {
+            validateBrainId(b.workspaceId);
+            validateBrainId(b.brainId);
+            directory = b.gitRepoUrl
+                ? { path: resolveBrainDir(b.workspaceId, b.brainId), workspaceId: b.workspaceId, brainId: b.brainId }
+                : { path: fallbackBrainPath() };
+        }
+        catch {
+            continue;
+        } // Validator logs + emits; invalid bootstrap records are never registered.
+        trackedBrains.set(`${b.workspaceId}:${b.channelId}`, {
+            directory,
             brainId: b.brainId,
             gitRepoUrl: b.gitRepoUrl,
             branch: b.branch,
@@ -91,7 +104,7 @@ export function seedTrackedBrains(brains) {
             botToken: b.botToken,
             channelId: b.channelId,
         });
-        registerBrainForMetrics(b.brainId);
+        registerBrainForMetrics(b.brainId, b.workspaceId, directory);
         seeded++;
     }
     return seeded;
@@ -100,15 +113,26 @@ export function seedTrackedBrains(brains) {
  * Register a brain from a real message so the maintenance cron knows about it.
  * Called from processMessage() after brain path is resolved.
  */
-export function registerBrain(msg) {
+export function registerBrain(msg, directory) {
     const brain = msg.teamvibe.brain;
     if (!brain?.brainId)
         return;
     // Don't register from maintenance messages (avoid self-referential loop)
     if (msg.source === 'maintenance')
         return;
-    const isNew = !trackedBrains.has(brain.brainId);
-    trackedBrains.set(brain.brainId, {
+    const key = `${msg.teamvibe.workspaceId}:${msg.teamvibe.channelId}`;
+    const isNew = ![...trackedBrains.values()].some(info => info.workspaceId === msg.teamvibe.workspaceId && info.brainId === brain.brainId);
+    validateBrainId(msg.teamvibe.workspaceId);
+    validateBrainId(brain.brainId);
+    const selectedDirectory = executionDirectory(directory ?? (brain.gitRepoUrl
+        ? { path: resolveBrainDir(msg.teamvibe.workspaceId, brain.brainId), workspaceId: msg.teamvibe.workspaceId, brainId: brain.brainId }
+        : { path: fallbackBrainPath(msg.response_context.slack?.channel) }));
+    const previous = trackedBrains.get(key);
+    if (previous && previous.directory.path !== selectedDirectory.path) {
+        logger.warn(`[Maintenance] Channel ${msg.teamvibe.channelId} reassigned; retained work will restart in the current brain ${brain.brainId}`);
+    }
+    trackedBrains.set(key, {
+        directory: selectedDirectory,
         brainId: brain.brainId,
         gitRepoUrl: brain.gitRepoUrl,
         branch: brain.branch,
@@ -122,12 +146,12 @@ export function registerBrain(msg) {
     // Metrics pipeline (teamvibe.ai#110): register for hourly collection. On the
     // first sighting of this brain, fire one immediate collect+send so we don't
     // wait up to an hour for the first sample.
-    registerBrainForMetrics(brain.brainId);
+    registerBrainForMetrics(brain.brainId, msg.teamvibe.workspaceId, selectedDirectory);
     if (isNew) {
         const brainId = brain.brainId;
         void (async () => {
             try {
-                const brainPath = join(config.BRAINS_PATH, brainId);
+                const brainPath = executionDirectory(selectedDirectory).path;
                 const payload = await collectMetrics(brainPath, brainId);
                 await sendMetrics(payload);
             }
@@ -142,21 +166,39 @@ export function registerBrain(msg) {
  */
 async function triggerAllBrains(processMessageFn) {
     const now = Date.now();
-    for (const [brainId, info] of trackedBrains.entries()) {
+    // Channel routing is tracked independently, but maintenance still runs once
+    // per clone and uses the latest real activity across all of its channels.
+    const clones = new Map();
+    for (const info of trackedBrains.values()) {
+        const key = `${info.workspaceId}:${info.brainId}`;
+        const previous = clones.get(key);
+        if (!previous || (info.lastRealMessageAt ?? 0) > (previous.lastRealMessageAt ?? 0))
+            clones.set(key, info);
+    }
+    for (const info of clones.values()) {
+        const brainId = info.brainId;
+        const key = `${info.workspaceId}:${brainId}`;
         if (isAtCapacity()) {
             logger.debug(`[Maintenance] At capacity, skipping ${brainId}`);
             continue;
         }
-        if (await shouldSkipMaintenance(config.BRAINS_PATH, brainId, info.lastRealMessageAt)) {
+        let directory;
+        try {
+            directory = executionDirectory(info.directory);
+        }
+        catch {
+            continue;
+        } // Validator logged + emitted; never reuse an aliased clone.
+        if (await shouldSkipMaintenance(directory.path, '', info.lastRealMessageAt)) {
             markMaintenanceJobSkipped();
             logger.debug(`[Maintenance] Skipping ${brainId} — no real activity since last maintenance (#131)`);
             continue;
         }
         logger.info(`[Maintenance] Triggering maintenance for brain ${brainId}`);
         const syntheticMessage = {
-            id: `maintenance_${brainId}_${now}`,
+            id: `maintenance_${key}_${now}`,
             source: 'maintenance',
-            thread_id: `maintenance_${brainId}_${now}`,
+            thread_id: `maintenance_${key}_${now}`,
             sender: {
                 id: 'system',
                 name: 'System',

package/dist/metrics/scheduler.d.ts

@@ -1,11 +1,14 @@
+import { type BrainDirectory } from '../brain-directory.js';
 interface RegisteredBrain {
     brainId: string;
+    workspaceId: string;
+    directory: BrainDirectory;
 }
 /**
  * Register (or update) a brain for hourly metrics collection.
  * Safe to call repeatedly with the same brainId.
  */
-export declare function registerBrainForMetrics(brainId: string): void;
+export declare function registerBrainForMetrics(brainId: string, workspaceId: string, directory?: BrainDirectory): void;
 /**
  * Deterministic 32-bit FNV-1a hash of a string. Used to derive a stable
  * per-brain jitter offset for hourly cron alignment (see #110 review):

package/dist/metrics/scheduler.js

@@ -1,4 +1,5 @@
-import { join } from 'path';
+import { resolveBrainDir, validateBrainId } from '../brain-path.js';
+import { executionDirectory } from '../brain-directory.js';
 import { Cron } from 'croner';
 import { config } from '../config.js';
 import { logger } from '../logger.js';
@@ -12,17 +13,18 @@ let metricsJob = null;
  * Register (or update) a brain for hourly metrics collection.
  * Safe to call repeatedly with the same brainId.
  */
-export function registerBrainForMetrics(brainId) {
-    if (!brainId)
-        return;
-    registered.set(brainId, { brainId });
+export function registerBrainForMetrics(brainId, workspaceId, directory) {
+    validateBrainId(workspaceId);
+    validateBrainId(brainId);
+    const selected = executionDirectory(directory ?? { path: resolveBrainDir(workspaceId, brainId), workspaceId, brainId });
+    registered.set(`${workspaceId}:${brainId}`, { brainId, workspaceId, directory: selected });
 }
 /**
  * Collect + send metrics for a single brain. Never throws.
  */
 async function collectAndSendOne(brain) {
     try {
-        const brainPath = join(config.BRAINS_PATH, brain.brainId);
+        const brainPath = executionDirectory(brain.directory).path;
         const payload = await collectMetrics(brainPath, brain.brainId);
         await sendMetrics(payload);
     }

package/dist/poller.d.ts

@@ -1,3 +1,4 @@
+import { type BrainDirectory } from './brain-directory.js';
 import { logger } from './logger.js';
 import { type SpawnResult } from './claude-spawner.js';
 import { type KilledByPoller } from './classify-failed-iteration.js';
@@ -32,7 +33,7 @@ export declare function isPollerInitiatedFailure(result: {
 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 declare function endOfTurnFallbackText(hasSlackContext: boolean, result: Pick<SpawnResult, 'success' | 'sawSendMessageCall' | 'lastPlainTextContent'>): string | undefined;
-export declare function runInboxLoop(threadId: string, kbPath: string, queueMessage: TeamVibeQueueMessage, sessionLog: ReturnType<typeof logger.createSession>): Promise<void>;
+export declare function runInboxLoop(threadId: string, selectedDirectory: BrainDirectory | string, queueMessage: TeamVibeQueueMessage, sessionLog: ReturnType<typeof logger.createSession>): Promise<void>;
 export declare function pollLoop(): Promise<void>;
 export declare function __setSleepForTest(impl: (ms: number) => Promise<void>): void;
 export declare function __setShuttingDownForTest(value: boolean): void;

package/dist/poller.js

@@ -3,6 +3,7 @@ import { fetchSubscriptionPool } from './subscription-pool-client.js';
 import { formatPoolUsageLimitMessage } from './usage-limit-messages.js';
 import { logPoolUsageWrite } from './pool-logging.js';
 import { emitCandidateUsage, poolRunTelemetry } from './pool-telemetry.js';
+import { executionDirectory, selectBrainDirectory } from './brain-directory.js';
 import { config, POLLER_VERSION } from './config.js';
 import { logger, setLogContext } from './logger.js';
 import { pollMessages, deleteMessage, } from './sqs-poller.js';
@@ -15,7 +16,7 @@ import { POOL_RECHECK_MS } from './subscription-selection.js';
 import { 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 { getBrainPath, ensureDirectories, ensureBaseBrain, pushBrainChanges } from './brain-manager.js';
+import { ensureDirectories, ensureBaseBrain, pushBrainChanges } from './brain-manager.js';
 import { cleanupOrphanWorktreesForAllBrains, isWorktreeIsolationEnabled } from './worktree-manager.js';
 import { postMaintenanceReports } from './maintenance-reporter.js';
 import { initAuth, stopRefresh, getPollerId } from './auth-provider.js';
@@ -25,6 +26,7 @@ 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 { saveThreadRouting } from './thread-routing.js';
 import { startInboxWatcher, stopInboxWatcher } from './inbox-watcher.js';
 import { Cron } from 'croner';
 import { isControlMessage, handleControlMessage } from './control-handler.js';
@@ -248,7 +250,9 @@ 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, kbPath, queueMessage, sessionLog) {
+export async function runInboxLoop(threadId, selectedDirectory, queueMessage, sessionLog) {
+    const directory = executionDirectory(selectedDirectory);
+    const kbPath = directory.path;
     if (isQuotaPaused() && !getPollerId())
         return;
     const initialPool = await fetchRuntimePool(queueMessage);
@@ -284,10 +288,26 @@ export async function runInboxLoop(threadId, kbPath, queueMessage, sessionLog) {
         if (lockToken) {
             activeLocks.set(threadId, lockToken);
         }
-        let currentSessionId = session.session_id || undefined;
-        let currentPin = session.subscription_pin;
+        saveThreadRouting(threadId, {
+            workspaceId: queueMessage.teamvibe.workspaceId,
+            channelId: queueMessage.teamvibe.channelId,
+            brainId: queueMessage.teamvibe.brain?.brainId,
+            directory: kbPath,
+        });
+        const directoryChanged = Boolean(session.workspace_path && session.workspace_path !== kbPath);
+        if (directoryChanged)
+            sessionLog.warn('[Loop] Session belonged to a different brain directory; restarting in the current brain');
+        let currentSessionId = directoryChanged ? undefined : session.session_id || undefined;
+        let currentPin = directoryChanged ? undefined : session.subscription_pin;
         let deferred = false;
         let poolIteration = false;
+        const persistSessionId = (id, pin) => {
+            if (!lockToken)
+                return Promise.reject(new Error('Missing lock'));
+            if (directoryChanged)
+                return updateSessionId(threadId, lockToken, id, pin, kbPath);
+            return pin ? updateSessionId(threadId, lockToken, id, pin) : updateSessionId(threadId, lockToken, id);
+        };
         const retryCompletedBookkeeping = async (state, pool, liveCompletion = false) => {
             if (!state.completed)
                 return true;
@@ -299,7 +319,7 @@ export async function runInboxLoop(threadId, kbPath, queueMessage, sessionLog) {
             const accountLabel = lastAttempt?.accountLabel !== state.pin.accountId ? lastAttempt?.accountLabel : undefined;
             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(lockToken ? updateSessionId(threadId, lockToken, state.sessionId, state.pin) : Promise.reject(new Error('Missing lock')));
+            writes.push(persistSessionId(state.sessionId, state.pin));
             const outcomes = await Promise.allSettled(writes);
             if (outcomes.some(outcome => outcome.status === 'rejected' || outcome.value === false)) {
                 sessionLog.warn('[Loop] Inference completed; pool bookkeeping failed and will retry without running the agent');
@@ -370,7 +390,7 @@ export async function runInboxLoop(threadId, kbPath, queueMessage, sessionLog) {
                 break;
             }
             iteration++;
-            const isFirstMessage = session.message_count === 1 && iteration === 1;
+            const isFirstMessage = (directoryChanged || session.message_count === 1) && iteration === 1;
             sessionLog.info(`[Loop] Iteration #${iteration} — processing: ${message.filename}`);
             await ensureBaseBrain();
             let inboxMsg = queueMessage;
@@ -386,21 +406,28 @@ export async function runInboxLoop(threadId, kbPath, queueMessage, sessionLog) {
             try {
                 // Reconstruct queue message from stored inbox data
                 const storedData = JSON.parse(message.content);
+                const storedScope = storedData.teamvibe;
+                const scopeMismatch = storedScope && (storedScope.workspaceId !== queueMessage.teamvibe.workspaceId ||
+                    storedScope.channelId !== queueMessage.teamvibe.channelId ||
+                    storedScope.brain?.brainId !== queueMessage.teamvibe.brain?.brainId);
+                if (scopeMismatch) {
+                    sessionLog.warn('[Loop] Inbox scope mismatch; executing with the current channel brain in its selected directory');
+                }
                 inboxMsg = {
                     ...queueMessage,
                     ...storedData,
-                    // Durable inbox routing omits credentials. Preserve live metadata
-                    // missing from older payloads, and always use the live bot token.
-                    teamvibe: { ...queueMessage.teamvibe, ...storedData.teamvibe, botToken: queueMessage.teamvibe.botToken },
+                    // Routing comes from the current platform record, never agent-writable
+                    // 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 } : {}),
                 };
                 // Legacy delivery uses the original routing, just as on main.
                 let result;
                 if (!poolIteration) {
-                    result = await spawnClaudeCode(inboxMsg, sessionLog, kbPath, currentSessionId, isFirstMessage, session.last_message_ts, () => typing?.stop(), typing);
+                    result = await spawnClaudeCode(inboxMsg, sessionLog, directory, currentSessionId, isFirstMessage, session.last_message_ts, () => typing?.stop(), typing);
                 }
                 else {
-                    if (storedData.teamvibe && (storedData.teamvibe.workspaceId !== queueMessage.teamvibe.workspaceId || storedData.teamvibe.channelId !== queueMessage.teamvibe.channelId))
-                        throw new PoolDeferredError();
                     if (!queueMessage.teamvibe.botToken && queueMessage.response_context.slack) {
                         const secrets = await fetchSecretsForSpawn({ pollerId: getPollerId() || '', workspaceId: queueMessage.teamvibe.workspaceId, channelId: queueMessage.teamvibe.channelId });
                         const token = secrets.env.unwrap()['SLACK_BOT_TOKEN'];
@@ -421,7 +448,7 @@ export async function runInboxLoop(threadId, kbPath, queueMessage, sessionLog) {
                         currentSessionId = savedRuntime.sessionId;
                         currentPin = savedRuntime.pin;
                     }
-                    result = await spawnPoolClaudeCode(inboxMsg, sessionLog, kbPath, currentSessionId, isFirstMessage, session.last_message_ts, () => typing?.stop(), typing, {
+                    result = await spawnPoolClaudeCode(inboxMsg, sessionLog, directory, currentSessionId, isFirstMessage, session.last_message_ts, () => typing?.stop(), typing, {
                         pool,
                         quotaDeferEpisodes,
                         attempts: savedRuntime?.filename === message.filename ? savedRuntime.attempts : undefined,
@@ -450,7 +477,7 @@ export async function runInboxLoop(threadId, kbPath, queueMessage, sessionLog) {
                         },
                         persist: async (id, pin, attempts) => {
                             pin = { ...pin, inboxFilename: message.filename };
-                            if (!lockToken || await updateSessionId(threadId, lockToken, id, pin) === false)
+                            if (!lockToken || await persistSessionId(id, pin) === false)
                                 throw new PoolDeferredError();
                             currentSessionId = id;
                             currentPin = pin;
@@ -466,9 +493,7 @@ export async function runInboxLoop(threadId, kbPath, queueMessage, sessionLog) {
                     currentSessionId = result.newSessionId;
                     if (lockToken) {
                         try {
-                            await (poolIteration
-                                ? updateSessionId(threadId, lockToken, result.newSessionId, currentPin)
-                                : updateSessionId(threadId, lockToken, result.newSessionId));
+                            await persistSessionId(result.newSessionId, poolIteration ? currentPin : undefined);
                         }
                         catch (err) {
                             sessionLog.error(`[Loop] Failed to persist new session ID to DynamoDB: ${err instanceof Error ? err.message : err}`);
@@ -528,8 +553,8 @@ export async function runInboxLoop(threadId, kbPath, queueMessage, sessionLog) {
                             context: { threadId: deliveryMsg.thread_id },
                         });
                     }
-                    if (deliveryMsg.teamvibe.brain?.brainId) {
-                        await pushBrainChanges(kbPath, deliveryMsg.teamvibe.brain.brainId, deliveryMsg.teamvibe.workspaceId);
+                    if (directory.brainId) {
+                        await pushBrainChanges(directory.path, directory.brainId, directory.workspaceId);
                     }
                     await postMaintenanceReports(kbPath, deliveryMsg.teamvibe.channelId);
                 }
@@ -693,7 +718,7 @@ export async function runInboxLoop(threadId, kbPath, queueMessage, sessionLog) {
                                 currentPin = { ...pin, resumePending: false, sawSendMessageCall: false };
                                 try {
                                     if (lockToken && currentSessionId)
-                                        await updateSessionId(threadId, lockToken, currentSessionId, currentPin);
+                                        await persistSessionId(currentSessionId, currentPin);
                                 }
                                 catch {
                                     sessionLog.warn('[Loop] Terminal failure cleared local continuation; stale pin is fenced by inbox filename');
@@ -838,9 +863,9 @@ async function processMessage(received) {
     const hasSlackContext = Boolean(queueMessage.response_context.slack?.channel &&
         queueMessage.response_context.slack?.message_ts);
     // Get brain path for this channel
-    let kbPath;
+    let directory;
     try {
-        kbPath = await getBrainPath(queueMessage.teamvibe.brain, queueMessage.response_context.slack?.channel, queueMessage.teamvibe.workspaceId);
+        directory = await selectBrainDirectory(queueMessage);
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
@@ -860,7 +885,8 @@ async function processMessage(received) {
         return;
     }
     // Register brain so the maintenance cron knows about it.
-    registerBrain(queueMessage);
+    registerBrain(queueMessage, directory);
+    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 }));
@@ -872,7 +898,7 @@ async function processMessage(received) {
     }
     processingMessages.add(messageId);
     try {
-        await runInboxLoop(threadId, kbPath, queueMessage, sessionLog);
+        await runInboxLoop(threadId, directory, queueMessage, sessionLog);
     }
     catch (error) {
         sessionLog.error(`Error in inbox loop: ${error instanceof Error ? error.message : error}`);

package/dist/pool-logging.js

@@ -33,7 +33,7 @@ export function logPoolSelection(log, pool, states, model, now, selected, logAll
             poolInfo(log, `skipped account=${poolLabel(account)} reason=${usageOnly.kind === 'deferred' ? `usage >=${account.useFullQuota ? 100 : 90}%` : 'reactive quota'} eligibleAt=${new Date(candidate.eligibleAt).toISOString()}`);
         }
         else if (candidate.kind === 'selected' && selected.kind === 'selected' && account.accountId !== selected.account.accountId) {
-            const reason = candidate.provenance === 'unknown' && selected.provenance === 'known' ? 'known observation preferred' : candidate.provenance === 'known' && selected.provenance === 'known' && candidate.score > selected.score ? 'higher usage score' : 'deterministic account order';
+            const reason = candidate.provenance === 'unknown' && selected.provenance === 'known' ? 'known observation preferred' : candidate.provenance === 'known' && selected.provenance === 'known' && candidate.score < selected.score ? 'lower headroom per hour' : 'deterministic account order';
             poolInfo(log, `skipped account=${poolLabel(account)} reason=${reason}`);
         }
     }
@@ -60,7 +60,7 @@ export function logPoolSelection(log, pool, states, model, now, selected, logAll
         poolInfo(log, `deferred reason=all accounts exhausted earliestResetAt=${earliestResetAt} eligibleAt=${new Date(selected.eligibleAt).toISOString()}`);
     }
     if (selected.kind === 'selected') {
-        const score = selected.provenance === 'known' ? `${selected.score}% headroom=${100 - selected.score}%` : 'unknown (no observation)';
+        const score = selected.provenance === 'known' ? `${Number(selected.score.toFixed(2))}%/h headroom=${Number(((selected.account.useFullQuota ? 100 : 90) - selected.rateWindow.percent).toFixed(2))}% rateWindow=${selected.rateWindow.window}/${selected.rateWindow.scope} reason=${selected.reason}` : 'unknown (no observation)';
         poolInfo(log, `selected account=${poolLabel(selected.account)} model=${JSON.stringify(model ?? 'CLI default')} score=${score}`);
     }
 }

package/dist/pool-telemetry.d.ts

@@ -25,6 +25,17 @@ export declare function poolRunTelemetry(attempts: readonly PoolAttempt[], quota
     switchedAccounts: boolean;
     quotaDeferEpisodes: number;
     attempts: {
+        quota: import("./claude-quota.js").ClaudeQuotaFailure | undefined;
+        metrics: SessionMetrics | undefined;
+        lastRateLimitInfo: import("./claude-rate-limit.js").ClaudeRateLimitInfo | undefined;
+        score?: number | undefined;
+        reason?: "headroom_per_hour" | undefined;
+        rateWindow?: {
+            window: "five_hour" | "seven_day";
+            scope: "opus" | "haiku" | "global" | "sonnet" | "fable" | "uncertain";
+            percent: number | undefined;
+            resetAt: number | undefined;
+        } | undefined;
         accountId: string;
         accountLabel: string;
         sessionId: string | undefined;
@@ -32,13 +43,18 @@ export declare function poolRunTelemetry(attempts: readonly PoolAttempt[], quota
         success: boolean;
         exitCode: number | null;
         observedAt: number | undefined;
-        quota: import("./claude-quota.js").ClaudeQuotaFailure | undefined;
-        metrics: SessionMetrics | undefined;
-        lastRateLimitInfo: import("./claude-rate-limit.js").ClaudeRateLimitInfo | undefined;
     }[];
+    lastRateLimitInfo?: import("./claude-rate-limit.js").ClaudeRateLimitInfo | undefined;
+    score?: number | undefined;
+    reason?: "headroom_per_hour" | undefined;
+    rateWindow?: {
+        window: "five_hour" | "seven_day";
+        scope: "opus" | "haiku" | "global" | "sonnet" | "fable" | "uncertain";
+        percent: number | undefined;
+        resetAt: number | undefined;
+    } | undefined;
     accountId?: string | undefined;
     accountLabel?: string | undefined;
     model?: string | undefined;
     observedAt?: number | undefined;
-    lastRateLimitInfo?: import("./claude-rate-limit.js").ClaudeRateLimitInfo | undefined;
 };

package/dist/pool-telemetry.js

@@ -82,6 +82,22 @@ export function poolRunTelemetry(attempts, quotaDeferEpisodes = 0) {
         success: a.success,
         exitCode: a.exitCode,
         observedAt: a.observedAt,
+        ...(typeof a.score === 'number' &&
+            Number.isFinite(a.score) &&
+            a.score >= 0 &&
+            a.reason === 'headroom_per_hour' &&
+            a.rateWindow
+            ? {
+                score: a.score,
+                reason: a.reason,
+                rateWindow: {
+                    window: a.rateWindow.window,
+                    scope: a.rateWindow.scope,
+                    percent: a.rateWindow.percent,
+                    resetAt: a.rateWindow.resetAt,
+                },
+            }
+            : {}),
         quota: a.quota ? safeQuota(a.quota) : undefined,
         metrics: safeMetrics(a.metrics),
         lastRateLimitInfo: a.rateLimitInfo
@@ -96,6 +112,13 @@ export function poolRunTelemetry(attempts, quotaDeferEpisodes = 0) {
                 accountLabel: last.accountLabel,
                 model: last.model,
                 observedAt: last.observedAt,
+                ...(last.score !== undefined
+                    ? {
+                        score: last.score,
+                        reason: last.reason,
+                        rateWindow: last.rateWindow,
+                    }
+                    : {}),
                 lastRateLimitInfo: last.lastRateLimitInfo,
             }
             : {}),

package/dist/session-store.d.ts

@@ -7,6 +7,6 @@ export interface AcquireLockResult {
     lockToken: string | null;
 }
 export declare function acquireSessionLock(threadId: string, workspacePath: string): Promise<AcquireLockResult>;
-export declare function updateSessionId(threadId: string, lockToken: string, newSessionId: string, pin?: SubscriptionPin): Promise<boolean>;
+export declare function updateSessionId(threadId: string, lockToken: string, newSessionId: string, pin?: SubscriptionPin, workspacePath?: string): Promise<boolean>;
 export declare function releaseSessionLock(threadId: string, lockToken: string, newStatus?: SessionStatus, lastMessageTs?: string): Promise<void>;
 export declare function forceReleaseStalelock(threadId: string, maxAgeMs: number): Promise<boolean>;

package/dist/session-store.js

@@ -150,15 +150,19 @@ export async function acquireSessionLock(threadId, workspacePath) {
         throw error;
     }
 }
-export async function updateSessionId(threadId, lockToken, newSessionId, pin) {
+export async function updateSessionId(threadId, lockToken, newSessionId, pin, workspacePath) {
     try {
         await createDocClient().send(new UpdateCommand({
             TableName: getTableName(),
             Key: buildKey(threadId),
-            UpdateExpression: pin ? 'SET session_id = :newSessionId, subscription_pin = :pin' : 'SET session_id = :newSessionId',
+            UpdateExpression: 'SET session_id = :newSessionId'
+                + (pin ? ', subscription_pin = :pin' : '')
+                + (workspacePath ? ', workspace_path = :workspacePath' : '')
+                + (workspacePath && !pin ? ' REMOVE subscription_pin' : ''),
             ConditionExpression: 'lock_token = :lockToken',
             ExpressionAttributeValues: {
                 ':newSessionId': newSessionId,
+                ...(workspacePath ? { ':workspacePath': workspacePath } : {}),
                 ...(pin ? { ':pin': Object.fromEntries(Object.entries(pin).filter(([, value]) => value !== undefined)) } : {}),
                 ':lockToken': lockToken,
             },

package/dist/startup-auth.js

@@ -38,7 +38,10 @@ 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(/\bx-access-token\s*:\s*[^\s/@,;]+/gi, 'x-access-token:[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]');
     for (const token of configuredTokens) {
         if (token)
             safe = safe.split(token).join('[REDACTED]');

package/dist/subscription-pool-client.js

@@ -1,3 +1,4 @@
+import { ACCOUNT_PROBE_FAILURE_REASONS } from './usage-probe-contract.js';
 import { record } from './subscription-selection.js';
 /** Unwrap only at the optional Claude probe or future child-spawn boundary. */
 export class SubscriptionCredential {
@@ -109,6 +110,12 @@ export async function fetchSubscriptionPool(input, options) {
             const raw = envelope['accounts'];
             if (!Array.isArray(raw) || raw.length > 1000)
                 return { kind: 'fetch_unavailable', reason: 'invalid_response' };
+            const failureReason = envelope['probeFailureReason'];
+            if (failureReason !== undefined) {
+                if (!input.requestId || raw.length || !ACCOUNT_PROBE_FAILURE_REASONS.includes(failureReason))
+                    return { kind: 'fetch_unavailable', reason: 'invalid_response' };
+                return { kind: 'probe_account_unavailable', reason: failureReason };
+            }
             const poolConfigured = envelope['poolConfigured'];
             if (('poolConfigured' in envelope && typeof poolConfigured !== 'boolean') ||
                 (poolConfigured === false && raw.length > 0))

package/dist/subscription-pool.d.ts

@@ -16,6 +16,7 @@ export declare function selectPoolForResolvedModel<A extends AccountIdentity>(re
     pool: PoolFetchResult<A>;
     store: SubscriptionUsageStore;
     now: number;
+    currentAccountId?: string;
     log?: PoolInfoLogger;
     logAllExhausted?: boolean;
 }): Promise<ResolvedPoolSelection<A>>;

package/dist/subscription-pool.js

@@ -23,7 +23,7 @@ export async function selectPoolForResolvedModel(resolvedModel, input) {
     catch {
         return { kind: 'usage_unavailable', ...resolvedModel };
     }
-    const selected = selectSubscriptionAccount({ pool: input.pool, states, model: resolvedModel.model, now: input.now });
+    const selected = selectSubscriptionAccount({ pool: input.pool, states, model: resolvedModel.model, now: input.now, currentAccountId: input.currentAccountId });
     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

@@ -2,13 +2,13 @@ import { type PoolInfoLogger } from './pool-logging.js';
 import { type SubscriptionAccount } from './subscription-pool-client.js';
 import { type ResolvedPoolModel } from './subscription-pool.js';
 import { FileSubscriptionUsageStore, type SubscriptionUsageStore } from './subscription-usage-store.js';
-import { type PoolFetchResult } from './subscription-selection.js';
+import { type PoolFetchResult, type HeadroomScore } from './subscription-selection.js';
 import type { SubscriptionPin, TeamVibeQueueMessage, SessionMetrics } from './types.js';
 import type { PoolUsageLimitNotice } from './usage-limit-messages.js';
 import type { ClaudeRateLimitInfo } from './claude-rate-limit.js';
 import type { ClaudeQuotaFailure } from './claude-quota.js';
 import type { KilledByPoller } from './classify-failed-iteration.js';
-export interface PoolAttempt {
+export interface PoolAttempt extends Partial<HeadroomScore> {
     workspaceId: string;
     accountId: string;
     accountLabel?: string;
@@ -46,10 +46,28 @@ export declare function preparePool(msg: TeamVibeQueueMessage, resolved: Resolve
     account: SubscriptionAccount;
     store: FileSubscriptionUsageStore;
     pool: PoolFetchResult<SubscriptionAccount>;
+    selection: ({
+        kind: "selected";
+        account: SubscriptionAccount;
+        provenance: "known";
+        source: "passive" | "probe";
+    } & HeadroomScore & {
+        model: string | undefined;
+        modelSource: import("./claude-spawner.js").ModelSource;
+    }) | ({
+        kind: "selected";
+        account: SubscriptionAccount;
+        provenance: "unknown";
+        uncertainApplicability: boolean;
+    } & {
+        model: string | undefined;
+        modelSource: import("./claude-spawner.js").ModelSource;
+    });
 } | {
     account: undefined;
     store: FileSubscriptionUsageStore;
     pool: PoolFetchResult<SubscriptionAccount>;
+    selection: undefined;
 }>;
 export declare function accountPin(account: SubscriptionAccount, resolved: ResolvedPoolModel): SubscriptionPin;
 export declare function validateAccount(account: SubscriptionAccount, resolved: ResolvedPoolModel): Promise<void>;