@teamvibe/poller 0.8.3 → 0.8.4-rc.1

package/dist/claude-spawner.js

@@ -3,10 +3,10 @@ import { accountUsageTelemetry, emitCandidateUsage, poolRunTelemetry } from './p
 import { spawn } from 'child_process';
 import { join } from 'path';
 import { readFileSync, existsSync } from 'fs';
-import { mkdir } from 'fs/promises';
 import { WebClient } from '@slack/web-api';
 import { config } from './config.js';
 import { logger } from './logger.js';
+import { executionDirectory } from './brain-directory.js';
 import { getBaseBrainPath } from './brain-manager.js';
 import { getPollerId } from './auth-provider.js';
 import { sendSlackMessage } from './slack-client.js';
@@ -19,6 +19,44 @@ import { parseClaudeQuotaFailure } from './claude-quota.js';
 import { 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';
+/** Inspect Claude's user/project settings without changing any brain files. */
+function warnTokenAliasSettings(claudeConfigDir, cwd, brainPath, sessionLog) {
+    // CLAUDE_CONFIG_DIR replaces ~/.claude for user settings. settings.local.json
+    // is a project source, not a second user-settings file. Recent CLI versions
+    // also read local settings from the main checkout when running in a worktree.
+    // https://code.claude.com/docs/en/settings
+    const paths = new Set([
+        join(claudeConfigDir, 'settings.json'),
+        join(cwd, '.claude', 'settings.json'),
+        join(cwd, '.claude', 'settings.local.json'),
+        ...(cwd !== brainPath && existsSync(join(brainPath, '.git'))
+            ? [join(brainPath, '.claude', 'settings.local.json')] : []),
+    ]);
+    const conflicts = [];
+    for (const path of paths) {
+        let settings;
+        try {
+            settings = JSON.parse(readFileSync(path, 'utf8'));
+        }
+        catch {
+            // Missing/unreadable/malformed files are CLI concerns. In particular,
+            // never log parse errors: their messages can contain setting values.
+            continue;
+        }
+        const env = settings && typeof settings === 'object' && 'env' in settings ? settings.env : undefined;
+        if (!env || typeof env !== 'object' || Array.isArray(env))
+            continue;
+        for (const key of ['TEAMVIBE_CLAUDE_OAUTH_TOKEN', 'TEAMVIBE_POOL_ACCOUNT_ID']) {
+            if (Object.hasOwn(env, key)) {
+                conflicts.push(`${path} defines env.${key}`);
+            }
+        }
+    }
+    if (conflicts.length) {
+        sessionLog.warn(`[Claude settings] ${conflicts.join('; ')}; Claude can override the poller-injected environment, including when EXPOSE_CLAUDE_TOKEN_TO_AGENT is off`);
+    }
+}
 /**
  * Maps tool names (or prefixes) to human-readable status messages.
  * More specific patterns are checked first.
@@ -197,9 +235,10 @@ function readBrainSettings(cwd) {
         const raw = readFileSync(settingsPath, 'utf-8');
         return JSON.parse(raw);
     }
-    catch (error) {
-        logger.warn(`Failed to read brain settings at ${settingsPath}: ${error}`);
-        emitError('brain', `Failed to read brain settings at ${settingsPath}: ${error instanceof Error ? error.message : String(error)}`, { severity: 'warn' });
+    catch {
+        // JSON parser errors can quote env values from the source file.
+        logger.warn(`Failed to read brain settings at ${settingsPath}`);
+        emitError('brain', `Failed to read brain settings at ${settingsPath}`, { severity: 'warn' });
         return {};
     }
 }
@@ -421,6 +460,9 @@ export function sweepProcessGroup(proc, graceMs, options = {}) {
  * would look like if left uncapped.
  */
 export function buildSpawnEnv(params) {
+    const exposeToken = /^(1|true|yes|on)$/i.test(params.processEnv['EXPOSE_CLAUDE_TOKEN_TO_AGENT'] ?? '');
+    const accountToken = params.subscriptionAccount?.credential.unwrap();
+    const sessionToken = accountToken ?? params.processEnv['CLAUDE_CODE_OAUTH_TOKEN'];
     return {
         // Secrets platform (#105) injection — SOLE call site of
         // `SpawnSecretsEnvelope.unwrap()` in the entire poller codebase.
@@ -470,8 +512,13 @@ export function buildSpawnEnv(params) {
         // drops against this var so they land somewhere still being
         // watched after the session (and worktree) is gone. See tv#265.
         POLLER_BRAIN_PATH: params.brainPath,
+        // Claude strips its own token name from Bash subprocesses. This alias
+        // deliberately opts out of that protection, only at the poller level.
+        // Explicit undefined values also clear inherited/overlay aliases.
+        TEAMVIBE_CLAUDE_OAUTH_TOKEN: exposeToken ? sessionToken || undefined : undefined,
+        TEAMVIBE_POOL_ACCOUNT_ID: exposeToken ? params.subscriptionAccount?.accountId : undefined,
         ...(params.subscriptionAccount ? {
-            CLAUDE_CODE_OAUTH_TOKEN: params.subscriptionAccount.credential.unwrap(),
+            CLAUDE_CODE_OAUTH_TOKEN: accountToken,
             ANTHROPIC_API_KEY: undefined,
             ANTHROPIC_AUTH_TOKEN: undefined,
             ANTHROPIC_BASE_URL: undefined,
@@ -800,7 +847,7 @@ function resultMetrics(event, pooled, lastAssistant) {
         metrics.context_window = window;
     return metrics;
 }
-async function runClaudeCode(msg, sessionLog, cwd, brainPath, sessionId, isFirstMessage = true, lastMessageTs, onMessageSent, typingIndicator, runtime) {
+async function runClaudeCode(msg, sessionLog, cwd, directory, sessionId, isFirstMessage = true, lastMessageTs, onMessageSent, typingIndicator, runtime) {
     const slackContext = msg.response_context.slack;
     const isCronMessage = msg.source === 'cron';
     const isMaintenance = msg.source === 'maintenance';
@@ -941,25 +988,44 @@ async function runClaudeCode(msg, sessionLog, cwd, brainPath, sessionId, isFirst
             : process.env['PATH'];
         if (runtime?.account)
             poolInfo(sessionLog, `token target account=${poolLabel(runtime.account)} session=${JSON.stringify(sessionId ?? 'new')} credential=selected account token`);
+        const spawnEnv = buildSpawnEnv({
+            spawnSecretsEnv: spawnSecrets.env.unwrap(),
+            processEnv: process.env,
+            envPath,
+            claudeConfigDir: runtime?.claudeConfigDir ?? getBaseBrainPath(),
+            persistentStoragePath: config.PERSISTENT_STORAGE_PATH,
+            slackContext,
+            teamvibeApiUrl: config.TEAMVIBE_API_URL,
+            teamvibePollerToken: config.TEAMVIBE_POLLER_TOKEN || '',
+            teamvibeWorkspaceId: msg.teamvibe.workspaceId,
+            teamvibeChannelId: msg.teamvibe.channelId,
+            teamvibeBotId: msg.teamvibe.botId,
+            teamvibePollerId: getPollerId() || '',
+            inboxThreadId: msg.thread_id,
+            brainPath: directory.path,
+            subscriptionAccount: runtime?.account,
+        });
+        // Capture the actual credentials for this attempt, including pool selection
+        // and secrets overlays, regardless of whether alias exposure is enabled.
+        const outputTokens = [spawnEnv['CLAUDE_CODE_OAUTH_TOKEN'], spawnEnv['TEAMVIBE_CLAUDE_OAUTH_TOKEN']]
+            .filter((token) => !!token);
+        const redactOutput = (text) => redactStartupText(text, outputTokens);
+        const safeEvent = (value) => {
+            if (typeof value === 'string')
+                return redactOutput(value);
+            if (Array.isArray(value))
+                return value.map(safeEvent);
+            if (!value || typeof value !== 'object')
+                return value;
+            return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
+                redactOutput(key),
+                /^(?:CLAUDE_CODE_OAUTH_TOKEN|TEAMVIBE_CLAUDE_OAUTH_TOKEN)$/i.test(key) ? '[REDACTED]' : safeEvent(entry),
+            ]));
+        };
+        warnTokenAliasSettings(spawnEnv['CLAUDE_CONFIG_DIR'], cwd, directory.path, sessionLog);
         const proc = spawn(config.CLAUDE_CLI_PATH, args, {
             cwd,
-            env: buildSpawnEnv({
-                spawnSecretsEnv: spawnSecrets.env.unwrap(),
-                processEnv: process.env,
-                envPath,
-                claudeConfigDir: runtime?.claudeConfigDir ?? getBaseBrainPath(),
-                persistentStoragePath: config.PERSISTENT_STORAGE_PATH,
-                slackContext,
-                teamvibeApiUrl: config.TEAMVIBE_API_URL,
-                teamvibePollerToken: config.TEAMVIBE_POLLER_TOKEN || '',
-                teamvibeWorkspaceId: msg.teamvibe.workspaceId,
-                teamvibeChannelId: msg.teamvibe.channelId,
-                teamvibeBotId: msg.teamvibe.botId,
-                teamvibePollerId: getPollerId() || '',
-                inboxThreadId: msg.thread_id,
-                brainPath,
-                subscriptionAccount: runtime?.account,
-            }),
+            env: spawnEnv,
             stdio: ['pipe', 'pipe', 'pipe'],
             // teamvibeai/teamvibe.ai#73: run `claude` (via setsid) as the leader of
             // its own new process group, separate from the poller's. This is what
@@ -980,6 +1046,12 @@ async function runClaudeCode(msg, sessionLog, cwd, brainPath, sessionId, isFirst
         proc.stdin?.end();
         let stdout = '';
         let stderr = '';
+        let stderrLogBuffer = '';
+        const flushStderrLog = () => {
+            if (stderrLogBuffer)
+                sessionLog.claude('stderr', redactOutput(stderrLogBuffer).trimEnd());
+            stderrLogBuffer = '';
+        };
         let stdoutBuffer = '';
         // Retain CLI error/result evidence, not the full parsed assistant/tool stream.
         const failureEvents = [];
@@ -1039,12 +1111,15 @@ async function runClaudeCode(msg, sessionLog, cwd, brainPath, sessionId, isFirst
             const lines = completeData.split('\n').filter((line) => line.trim());
             for (const line of lines) {
                 try {
-                    const event = JSON.parse(line);
-                    if (event?.type === 'rate_limit_event') {
+                    const rawEvent = JSON.parse(line);
+                    // Redact before formatting/truncation or forwarding any string fields
+                    // (including metadata keys) to logs, telemetry, typing, or Slack.
+                    const event = safeEvent(rawEvent);
+                    if (rawEvent?.type === 'rate_limit_event') {
                         rateLimitInfo = parseClaudeRateLimitInfo(event.rate_limit_info);
                     }
-                    if (event?.type === 'result' || event?.type === 'error' || (event?.type === 'assistant' && event.error)) {
-                        failureEvents.push(event);
+                    if (rawEvent?.type === 'result' || rawEvent?.type === 'error' || (rawEvent?.type === 'assistant' && rawEvent.error)) {
+                        failureEvents.push(rawEvent);
                     }
                     // Capture the pre-event activity timestamp BEFORE the unconditional
                     // overwrite below — needed to compute the "original 10min deadline
@@ -1093,7 +1168,7 @@ async function runClaudeCode(msg, sessionLog, cwd, brainPath, sessionId, isFirst
                     }
                     const formatted = formatStreamEvent(event);
                     if (formatted) {
-                        sessionLog.claude('stdout', formatted);
+                        sessionLog.claude('stdout', redactOutput(formatted));
                     }
                     // teamvibe.ai#284: track the last non-empty plain-text assistant
                     // content seen, regardless of tool calls — candidate for the
@@ -1131,7 +1206,8 @@ async function runClaudeCode(msg, sessionLog, cwd, brainPath, sessionId, isFirst
                     }
                 }
                 catch {
-                    const truncated = line.length > 500 ? line.slice(0, 500) + '...' : line;
+                    const safeLine = redactOutput(line);
+                    const truncated = safeLine.length > 500 ? safeLine.slice(0, 500) + '...' : safeLine;
                     sessionLog.claude('stdout', truncated.trimEnd());
                 }
             }
@@ -1140,7 +1216,14 @@ async function runClaudeCode(msg, sessionLog, cwd, brainPath, sessionId, isFirst
         proc.stderr.on('data', (data) => {
             const chunk = data.toString();
             stderr += chunk;
-            sessionLog.claude('stderr', chunk.trimEnd());
+            // Wait for complete lines so a token split across data events cannot
+            // escape redaction. Flush a final unterminated line on close/error.
+            stderrLogBuffer += chunk;
+            const lastNewline = stderrLogBuffer.lastIndexOf('\n');
+            if (lastNewline !== -1) {
+                sessionLog.claude('stderr', redactOutput(stderrLogBuffer.slice(0, lastNewline + 1)).trimEnd());
+                stderrLogBuffer = stderrLogBuffer.slice(lastNewline + 1);
+            }
             // Track continuous network errors for early kill
             if (NETWORK_ERROR_PATTERNS.test(chunk)) {
                 if (networkErrorStart === null) {
@@ -1249,16 +1332,19 @@ async function runClaudeCode(msg, sessionLog, cwd, brainPath, sessionId, isFirst
             // not something shutdown() awaits.
             void sweepProcessGroup(proc, CLOSE_SWEEP_GRACE_MS, { unref: true });
             const killReason = killReasonByProc.get(proc);
+            flushStderrLog();
             // Preserve a final unterminated stream-json error/result and its metrics.
             if (stdoutBuffer.trim()) {
                 try {
-                    const event = JSON.parse(stdoutBuffer);
+                    const rawEvent = JSON.parse(stdoutBuffer);
+                    const event = safeEvent(rawEvent);
                     if (event?.type === 'rate_limit_event') {
                         rateLimitInfo = parseClaudeRateLimitInfo(event.rate_limit_info);
                     }
-                    failureEvents.push(event);
-                    if (event?.type === 'assistant')
+                    failureEvents.push(rawEvent);
+                    if (event?.type === 'assistant') {
                         lastAssistant = { usage: event.message?.usage, model: event.message?.model };
+                    }
                     if (event?.type === 'result')
                         metrics = resultMetrics(event, !!runtime?.account, lastAssistant);
                 }
@@ -1272,7 +1358,7 @@ async function runClaudeCode(msg, sessionLog, cwd, brainPath, sessionId, isFirst
                 attemptedSessionId: sessionId,
                 ...(quota ? { quota } : {}),
                 ...(rateLimitInfo ? { rateLimitInfo } : {}),
-                output: stdout,
+                output: redactOutput(stdout),
                 exitCode: code,
                 metrics,
                 modelSource,
@@ -1305,25 +1391,26 @@ async function runClaudeCode(msg, sessionLog, cwd, brainPath, sessionId, isFirst
                 // buildSpawnEnv above), a future OOM is more likely to surface this
                 // way — a cgroup-level SIGKILL — rather than as a V8-level FATAL
                 // ERROR visible in stderr, so this is the replacement visibility.
-                result.error = stderr || (signal ? `Process was killed by signal ${signal}` : `Process exited with code ${code}`);
+                result.error = redactOutput(stderr || (signal ? `Process was killed by signal ${signal}` : `Process exited with code ${code}`));
             }
             resolve(result);
         });
         proc.on('error', (error) => {
+            flushStderrLog();
             clearTimeout(timeout);
             clearInterval(idleWatchdog);
             activeProcesses.delete(msg.id);
             activeProcessesByThread.delete(msg.thread_id);
             lastSessionEndTs = Date.now();
-            emitError('session', `Claude Code process spawn error: ${error.message}`, {
+            emitError('session', `Claude Code process spawn error: ${redactOutput(error.message)}`, {
                 channelId: msg.teamvibe.channelId,
                 context: { threadId: msg.thread_id },
             });
             resolve({
                 success: false,
-                output: stdout,
+                output: redactOutput(stdout),
                 exitCode: null,
-                error: error.message,
+                error: redactOutput(error.message),
                 ...(rateLimitInfo ? { rateLimitInfo } : {}),
                 attemptedSessionId: sessionId,
                 sawSendMessageCall,
@@ -1361,7 +1448,9 @@ export function finalizeSpawnResult(retryResult, isFirstMessage, effectiveSessio
     }
     return retryResult;
 }
-export async function spawnClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = true, lastMessageTs, onMessageSent, typingIndicator) {
+export async function spawnClaudeCode(msg, sessionLog, selectedDirectory, sessionId, isFirstMessage = true, lastMessageTs, onMessageSent, typingIndicator) {
+    const directory = executionDirectory(selectedDirectory);
+    const cwd = directory.path;
     // Worktree isolation: spawned (non-foreground) sessions run in
     // <brain>/.worktrees/<thread_id>/ so the sync-watchdog's reset --hard on
     // the main working dir can't trample in-flight writes or pre-push commits.
@@ -1387,12 +1476,12 @@ export async function spawnClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMe
             const { randomUUID } = await import('crypto');
             effectiveSessionId = randomUUID();
         }
-        const result = await runClaudeCode(msg, sessionLog, effectiveCwd, cwd, effectiveSessionId, isFirstMessage, lastMessageTs, onMessageSent, typingIndicator);
+        const result = await runClaudeCode(msg, sessionLog, effectiveCwd, directory, effectiveSessionId, isFirstMessage, lastMessageTs, onMessageSent, typingIndicator);
         // If --resume failed, retry as a fresh session (session files may have been lost on container restart)
         let retryResult = result;
         if (!result.success && !result.quota && effectiveSessionId && !isFirstMessage) {
             sessionLog.info('Resume failed, retrying as fresh session (session files may have been lost)');
-            retryResult = await runClaudeCode(msg, sessionLog, effectiveCwd, cwd, effectiveSessionId, true, lastMessageTs, onMessageSent, typingIndicator);
+            retryResult = await runClaudeCode(msg, sessionLog, effectiveCwd, directory, effectiveSessionId, true, lastMessageTs, onMessageSent, typingIndicator);
         }
         // If session ID is "already in use" (stale lock file), retry immediately with a
         // fresh ID — no zombie kill first. Zombie cleanup is #73's concern, not spawn
@@ -1401,7 +1490,7 @@ export async function spawnClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMe
             sessionLog.info('Session ID already in use (stale lock), retrying with fresh session ID');
             const { randomUUID } = await import('crypto');
             const freshId = randomUUID();
-            const freshResult = await runClaudeCode(msg, sessionLog, effectiveCwd, cwd, freshId, true, lastMessageTs, onMessageSent, typingIndicator);
+            const freshResult = await runClaudeCode(msg, sessionLog, effectiveCwd, directory, freshId, true, lastMessageTs, onMessageSent, typingIndicator);
             return finalizeSpawnResult(freshResult, true, freshId);
         }
         return finalizeSpawnResult(retryResult, isFirstMessage, effectiveSessionId);
@@ -1415,44 +1504,51 @@ export async function spawnClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMe
     }
 }
 // Configured-pool orchestration is deliberately separate from legacy spawns.
-export async function spawnPoolClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = true, lastMessageTs, onMessageSent, typingIndicator, poolRuntime) {
+export async function spawnPoolClaudeCode(msg, sessionLog, selectedDirectory, sessionId, isFirstMessage = true, lastMessageTs, onMessageSent, typingIndicator, poolRuntime) {
+    const directory = executionDirectory(selectedDirectory);
+    const cwd = directory.path;
     // Worktree isolation: spawned (non-foreground) sessions run in
     // <brain>/.worktrees/<thread_id>/ so the sync-watchdog's reset --hard on
     // the main working dir can't trample in-flight writes or pre-push commits.
     // See teamvibe.ai#120. cwd remains the main brain path on fallback / failure.
+    const claudeConfigDir = getBaseBrainPath();
+    const isolate = shouldIsolateInWorktree(msg);
+    const derivedCwd = isolate ? join(cwd, '.worktrees', msg.thread_id) : cwd;
+    const pin = poolRuntime?.pin;
+    // Persisted directories are agent-writable evidence, never execution inputs.
+    // Compare against the same platform-selected paths used by a fresh spawn.
+    if (pin?.resumePending && (pin.effectiveCwd !== undefined && pin.effectiveCwd !== derivedCwd ||
+        pin.claudeConfigDir !== undefined && pin.claudeConfigDir !== claudeConfigDir)) {
+        sessionLog.warn('[Pool] Pending session directory mismatch; starting a fresh session in the current channel brain');
+        emitError('session', 'Pending session directory mismatch; starting a fresh session', {
+            severity: 'warn', channelId: msg.teamvibe.channelId,
+            context: { workspaceId: msg.teamvibe.workspaceId, threadId: msg.thread_id, reason: 'directory_mismatch' },
+        });
+        poolRuntime = { ...poolRuntime, pin: { ...pin, resumePending: false, sawSendMessageCall: false } };
+        sessionId = undefined;
+        isFirstMessage = true;
+    }
+    const resumePending = poolRuntime?.pin?.resumePending === true;
     let effectiveCwd = cwd;
     let loggingPool = false;
-    let retainWorktree = poolRuntime?.pin?.resumePending === true;
+    let retainWorktree = resumePending;
     const poolAttempts = poolRuntime?.attempts?.slice(-1000) ?? [];
     let worktreeOwner;
-    if (poolRuntime?.pin?.resumePending && poolRuntime.pin.effectiveCwd) {
-        const pinnedCwd = poolRuntime.pin.effectiveCwd;
-        if (pinnedCwd !== cwd && pinnedCwd !== join(cwd, '.worktrees', msg.thread_id))
-            throw new PoolDeferredError();
-        if (!existsSync(pinnedCwd)) {
-            sessionLog.warn(`[Worktree] Pinned worktree missing; recreating ${pinnedCwd} for pending session ${sessionId ?? 'unknown'}`);
-            try {
-                if (pinnedCwd === cwd)
-                    await mkdir(cwd, { recursive: true });
-                else
-                    await createWorktree(cwd, msg.thread_id);
-            }
-            catch {
-                sessionLog.warn('[Worktree] Pinned worktree recreation failed; pending work retained for the next recheck');
-                throw new PoolDeferredError();
-            }
-        }
-        effectiveCwd = pinnedCwd;
-        if (effectiveCwd !== cwd)
-            worktreeOwner = { brainPath: cwd, id: msg.thread_id };
-    }
-    else if (shouldIsolateInWorktree(msg)) {
+    if (isolate) {
         try {
-            effectiveCwd = await createWorktree(cwd, msg.thread_id);
+            // Retain pending work only at the independently derived worktree path.
+            if (resumePending && !existsSync(derivedCwd)) {
+                sessionLog.warn(`[Worktree] Pinned worktree missing; recreating ${derivedCwd} for pending session ${sessionId ?? 'unknown'}`);
+            }
+            effectiveCwd = resumePending && existsSync(derivedCwd) ? derivedCwd : await createWorktree(cwd, msg.thread_id);
             worktreeOwner = { brainPath: cwd, id: msg.thread_id };
             sessionLog.info(`[Worktree] Spawned session running in ${effectiveCwd}`);
         }
         catch (err) {
+            if (resumePending) {
+                sessionLog.warn('[Worktree] Pending worktree recreation failed; retaining work for the next recheck');
+                throw new PoolDeferredError();
+            }
             sessionLog.warn(`[Worktree] Failed to create worktree, falling back to main brain dir: ${err instanceof Error ? err.message : err}`);
         }
     }
@@ -1475,7 +1571,6 @@ export async function spawnPoolClaudeCode(msg, sessionLog, cwd, sessionId, isFir
             ? { 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 claudeConfigDir = poolRuntime?.pin?.resumePending ? poolRuntime.pin.claudeConfigDir ?? getBaseBrainPath() : getBaseBrainPath();
         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;
@@ -1493,12 +1588,30 @@ export async function spawnPoolClaudeCode(msg, sessionLog, cwd, sessionId, isFir
             // fallback must report the fresh attempt's delivery flags independently.
             if (!runtime?.resumePending)
                 sawSendMessageCall = false;
-            const result = await runClaudeCode(msg, sessionLog, effectiveCwd, cwd, id, runtime?.resumePending ? false : first, lastMessageTs, onMessageSent, typingIndicator, runtime);
+            const result = await runClaudeCode(msg, sessionLog, effectiveCwd, directory, id, runtime?.resumePending ? false : first, lastMessageTs, onMessageSent, typingIndicator, runtime);
             sawSendMessageCall ||= result.sawSendMessageCall === true;
             if (prepared?.account) {
                 if (poolAttempts.length >= 1000)
                     poolAttempts.shift();
-                poolAttempts.push({ workspaceId: prepared.account.workspaceId, accountId: prepared.account.accountId, credentialVersion: prepared.account.credentialVersion, accountLabel: prepared.account.label ?? prepared.account.accountId, observedAt: Date.now(), rateLimitInfo: result.rateLimitInfo, sessionId: id, model: resolved.model ?? result.metrics?.model, success: result.success, exitCode: result.exitCode, killedByPoller: result.killedByPoller, quota: result.quota, metrics: result.metrics });
+                const selection = prepared.selection;
+                poolAttempts.push({
+                    ...(selection?.kind === 'selected' && selection.provenance === 'known'
+                        ? { score: selection.score, rateWindow: selection.rateWindow, reason: selection.reason }
+                        : {}),
+                    workspaceId: prepared.account.workspaceId,
+                    accountId: prepared.account.accountId,
+                    credentialVersion: prepared.account.credentialVersion,
+                    accountLabel: prepared.account.label ?? prepared.account.accountId,
+                    observedAt: Date.now(),
+                    rateLimitInfo: result.rateLimitInfo,
+                    sessionId: id,
+                    model: resolved.model ?? result.metrics?.model,
+                    success: result.success,
+                    exitCode: result.exitCode,
+                    killedByPoller: result.killedByPoller,
+                    quota: result.quota,
+                    metrics: result.metrics,
+                });
                 emitEvent('pool.account_attempted', msg.teamvibe.channelId, { workspaceId: msg.teamvibe.workspaceId, threadId: msg.thread_id, ...poolRunTelemetry(poolAttempts, poolRuntime?.quotaDeferEpisodes) });
                 if (result.success && id && poolRuntime) {
                     // Complete the inbox before any fallible post-inference store writes.
@@ -1556,11 +1669,16 @@ export async function spawnPoolClaudeCode(msg, sessionLog, cwd, sessionId, isFir
                 const fromAccount = prepared.account;
                 poolInfo(sessionLog, `switch from=${poolLabel(fromAccount)} to=${poolLabel(selected.account)} session=${JSON.stringify(effectiveSessionId)}`);
                 prepared.account = selected.account;
+                prepared.selection = selected;
                 runtime.account = selected.account;
                 runtime.resumePending = true;
                 switched = true;
                 const selectedUsage = await prepared.store.read(selected.account).catch(() => ({ reactive: [], passive: undefined }));
-                emitEvent('pool.account_switched', msg.teamvibe.channelId, { workspaceId: msg.teamvibe.workspaceId, threadId: msg.thread_id, ...poolRunTelemetry(poolAttempts, poolRuntime.quotaDeferEpisodes), ...accountUsageTelemetry(selected.account, selectedUsage), lastRateLimitInfo: selectedUsage.passive?.rateLimitInfo, observedAt: selectedUsage.passive?.observedAt, fromAccountId: fromAccount.accountId, fromAccountLabel: fromAccount.label ?? fromAccount.accountId, model: resolved.model, chainLength: poolAttempts.length + 1, switchedAccounts: true });
+                // A switch reports the newly selected account's decision.
+                const selectionDetails = selected.provenance === 'known'
+                    ? { score: selected.score, reason: selected.reason, rateWindow: { window: selected.rateWindow.window, scope: selected.rateWindow.scope, percent: selected.rateWindow.percent, resetAt: selected.rateWindow.resetAt } }
+                    : { score: undefined, reason: undefined, rateWindow: undefined };
+                emitEvent('pool.account_switched', msg.teamvibe.channelId, { workspaceId: msg.teamvibe.workspaceId, threadId: msg.thread_id, ...poolRunTelemetry(poolAttempts, poolRuntime.quotaDeferEpisodes), ...selectionDetails, ...accountUsageTelemetry(selected.account, selectedUsage), lastRateLimitInfo: selectedUsage.passive?.rateLimitInfo, observedAt: selectedUsage.passive?.observedAt, fromAccountId: fromAccount.accountId, fromAccountLabel: fromAccount.label ?? fromAccount.accountId, model: resolved.model, chainLength: poolAttempts.length + 1, switchedAccounts: true });
                 result = await attempt(effectiveSessionId, false);
                 sawSendMessageCall ||= result.sawSendMessageCall === true;
             }

package/dist/config.d.ts

@@ -41,6 +41,7 @@ declare const configSchema: z.ZodObject<{
     AUTO_UPDATE_POLICY: z.ZodDefault<z.ZodEnum<["patch", "minor", "off"]>>;
     AUTO_UPDATE_SCHEDULE: z.ZodDefault<z.ZodString>;
     INBOX_WATCH_FALLBACK_INTERVAL_MS: z.ZodDefault<z.ZodNumber>;
+    INBOX_ROUTING_TTL_DAYS: z.ZodDefault<z.ZodNumber>;
     INBOX_WATCH_DEBOUNCE_MS: z.ZodDefault<z.ZodNumber>;
     IDLE_RESTART_ENABLED: z.ZodEffects<z.ZodDefault<z.ZodString>, boolean, string | undefined>;
     IDLE_RESTART_IDLE_MS: z.ZodDefault<z.ZodNumber>;
@@ -83,6 +84,7 @@ declare const configSchema: z.ZodObject<{
     AUTO_UPDATE_POLICY: "patch" | "minor" | "off";
     AUTO_UPDATE_SCHEDULE: string;
     INBOX_WATCH_FALLBACK_INTERVAL_MS: number;
+    INBOX_ROUTING_TTL_DAYS: number;
     INBOX_WATCH_DEBOUNCE_MS: number;
     IDLE_RESTART_ENABLED: boolean;
     IDLE_RESTART_IDLE_MS: number;
@@ -133,6 +135,7 @@ declare const configSchema: z.ZodObject<{
     AUTO_UPDATE_POLICY?: "patch" | "minor" | "off" | undefined;
     AUTO_UPDATE_SCHEDULE?: string | undefined;
     INBOX_WATCH_FALLBACK_INTERVAL_MS?: number | undefined;
+    INBOX_ROUTING_TTL_DAYS?: number | undefined;
     INBOX_WATCH_DEBOUNCE_MS?: number | undefined;
     IDLE_RESTART_ENABLED?: string | undefined;
     IDLE_RESTART_IDLE_MS?: number | undefined;
@@ -178,6 +181,7 @@ export declare const config: {
     AUTO_UPDATE_POLICY: "patch" | "minor" | "off";
     AUTO_UPDATE_SCHEDULE: string;
     INBOX_WATCH_FALLBACK_INTERVAL_MS: number;
+    INBOX_ROUTING_TTL_DAYS: number;
     INBOX_WATCH_DEBOUNCE_MS: number;
     IDLE_RESTART_ENABLED: boolean;
     IDLE_RESTART_IDLE_MS: number;

package/dist/config.js

@@ -80,6 +80,7 @@ const configSchema = z.object({
     // catches missed/coalesced events, picks up brains whose .inbox/ didn't
     // exist at watcher startup, and prunes empty thread dirs.
     INBOX_WATCH_FALLBACK_INTERVAL_MS: z.coerce.number().default(300_000), // 5 minutes
+    INBOX_ROUTING_TTL_DAYS: z.coerce.number().positive().default(14),
     INBOX_WATCH_DEBOUNCE_MS: z.coerce.number().default(300), // coalesce bursty fs events into one scan
     // Idle restart (tv#317): Railway bills on cgroup memory usage, which includes page
     // cache that Linux only reclaims under real memory pressure — a large Railway memory

package/dist/event-queue.js

@@ -34,7 +34,7 @@ function enqueue(event) {
 }
 async function flushOne(event) {
     try {
-        const response = await fetch(`${config.TEAMVIBE_API_URL}/events`, {
+        const post = () => fetch(`${config.TEAMVIBE_API_URL}/events`, {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
@@ -47,6 +47,19 @@ async function flushOne(event) {
                 error: event.error,
             }),
         });
+        let response = await post();
+        if (response.status === 400 &&
+            event.eventType === 'pool.probe_failed' &&
+            event.channelId === 'usage_probe' &&
+            event.metadata?.['source'] === 'probe' &&
+            event.metadata['requestId'] &&
+            event.metadata['reason'] !== 'unknown') {
+            // Pre-#480 platforms accept unknown but reject the new account reasons.
+            // Keep the downgrade on queued retries if the second post is transiently unavailable.
+            event.metadata = { ...event.metadata, reason: 'unknown' };
+            logger.info(`[Pool] usage probe request=${event.metadata['requestId']} completion downgraded for legacy platform`);
+            response = await post();
+        }
         return response.ok;
     }
     catch {

package/dist/inbox-manager.d.ts

@@ -53,6 +53,11 @@ export declare function requeueMessage(brainPath: string, threadId: string, file
  */
 export declare function hasUnprocessed(brainPath: string, threadId: string): boolean;
 export declare function saveInboxContext(brainPath: string, msg: TeamVibeQueueMessage): void;
+/** Even partial envelopes carrying channel context must never use a singleton guess. */
+export declare function readInboxChannelContext(brainPath: string, threadId: string): {
+    workspaceId: unknown;
+    channelId: unknown;
+} | undefined;
 export declare function readInboxContext(brainPath: string, threadId: string): TeamVibeQueueMessage | undefined;
 export interface InboxRuntime {
     sessionId: string;
@@ -70,3 +75,9 @@ export interface InboxRuntime {
 export declare function saveInboxRuntime(brainPath: string, threadId: string, state: InboxRuntime): void;
 export declare function readInboxRuntime(brainPath: string, threadId: string): InboxRuntime | undefined;
 export declare function clearInboxRuntime(brainPath: string, threadId: string): void;
+/** Remove transfer remnants and completed copies before discovery or replay. */
+export declare function discardHandledInboxDrops(brainPath: string, threadId: string): void;
+/** Move pending content only; a different brain must never inherit continuation state. */
+export declare function restartInboxInDirectory(source: string, target: string, threadId: string): void;
+/** Preserve unroutable work for operator review and remove it from replay queues. */
+export declare function quarantineInbox(brainPath: string, threadId: string, includeFailed?: boolean): void;