@teamvibe/poller 0.8.8 → 0.8.9-rc.1

package/README.md

@@ -99,3 +99,8 @@ The poller authenticates with the TeamVibe API using your token, then continuous
 ## Subscription usage freshness
 
 Passive usage percentages remain usable lower bounds until each window's `resetAt`. Without a reset time, passive windows expire five minutes after observation. Probe windows retain their 60-second TTL. Reset windows are ignored; known accounts still rank before unknown accounts. A window at the account's threshold defers selection until its expiry (reset for passive windows, TTL fallback without a reset).
+
+## Channel Git credentials
+
+See [Agent Git credentials](docs/git-credentials.md) for multi-host channel bindings,
+provider CLI environment variables, helper matching and session file lifetime.

package/bin/tv-git-credential.mjs

@@ -16,15 +16,20 @@ if (process.argv[2] === 'get') {
       if (separator > 0) request[line.slice(0, separator)] = line.slice(separator + 1)
     }
     const file = process.env.TV_GIT_TOKEN_FILE
-    const credential = JSON.parse(readFileSync(file, 'utf8'))
-    if (request.protocol !== 'https' || request.host !== credential.host ||
-        credential.host !== 'github.com' || typeof credential.token !== 'string' ||
+    const stored = JSON.parse(readFileSync(file, 'utf8'))
+    const bindings = Array.isArray(stored) ? stored : [stored]
+    if (request.protocol !== 'https' || typeof request.host !== 'string' || request.host !== request.host.toLowerCase()) process.exit(0)
+    const credential = bindings.find(binding => binding?.host === request.host)
+    if (!credential ||
+        typeof credential.token !== 'string' ||
         !credential.token || /[\r\n\0]/.test(credential.token) ||
-        !['github_token', 'github_app'].includes(credential.kind)) process.exit(0)
+        !['github_token', 'github_app', 'gitlab_token'].includes(credential.kind)) process.exit(0)
+    const username = credential.username ?? (credential.kind === 'gitlab_token' ? 'oauth2' : 'x-access-token')
+    if (!['x-access-token', 'oauth2'].includes(username)) process.exit(0)
     if (credential.expiresAt !== undefined) {
       const expiry = Date.parse(credential.expiresAt)
       if (!Number.isFinite(expiry) || expiry <= Date.now()) {
-        const diagnostic = `git_credential_expired kind=${credential.kind}\n`
+        const diagnostic = `git_credential_expired kind=${credential.kind}${Array.isArray(stored) ? ` host=${credential.host}` : ''}\n`
         process.stderr.write(diagnostic)
         // Value-free spool lets the poller report detached-task expiry through
         // its usual error queue even after the launching agent has exited.
@@ -32,7 +37,7 @@ if (process.argv[2] === 'get') {
         process.exit(0)
       }
     }
-    process.stdout.write(`username=x-access-token\npassword=${credential.token}\n`)
+    process.stdout.write(`username=${username}\npassword=${credential.token}\n`)
   } catch {
     // No output and success means Git proceeds to its prompt-disabled failure.
   }

package/dist/brain-manager.js

@@ -29,7 +29,7 @@ if (config.PERSISTENT_STORAGE_PATH) {
     }
 }
 const gitCredentialContext = new AsyncLocalStorage();
-const githubBrains = new Set();
+const httpsBrains = new Set();
 async function gitExec(command, options) {
     const context = gitCredentialContext.getStore();
     const run = async (credential) => {
@@ -86,7 +86,7 @@ async function gitExec(command, options) {
     }
 }
 async function withGitCredential(brainId, workspaceId, fn) {
-    if (!workspaceId || !githubBrains.has(brainId) || !config.TEAMVIBE_API_URL || !config.TEAMVIBE_POLLER_TOKEN)
+    if (!workspaceId || !httpsBrains.has(brainId) || !config.TEAMVIBE_API_URL || !config.TEAMVIBE_POLLER_TOKEN)
         return fn();
     const credential = await connectionsClient.get('brain', brainId);
     return gitCredentialContext.run({ brainId, credential }, fn);
@@ -253,8 +253,8 @@ export async function getBrainPath(brain, channelId, workspaceId) {
         return config.DEFAULT_BRAIN_PATH;
     }
     const brainDir = resolveBrainDir(workspaceId, brain.brainId);
-    if (/^https:\/\/github\.com\//i.test(brain.gitRepoUrl))
-        githubBrains.add(brain.brainId);
+    if (/^https:\/\//i.test(brain.gitRepoUrl))
+        httpsBrains.add(brain.brainId);
     return withBrainLock(brainLockKey(brainDir, brain.brainId, workspaceId), () => withGitCredential(brain.brainId, workspaceId, () => getWorkspaceBrainPath(brain, workspaceId)));
 }
 async function getWorkspaceBrainPath(brain, workspaceId) {

package/dist/claude-spawner.d.ts

@@ -9,7 +9,7 @@ import { type ClaudeRateLimitInfo } from './claude-rate-limit.js';
 import { type ClaudeQuotaFailure } from './claude-quota.js';
 import { type PoolRuntimeOptions, type PoolAttempt } from './subscription-runtime.js';
 import type { SubscriptionAccount } from './subscription-pool-client.js';
-import { type GitCredential } from './connections-client.js';
+import { type GitCredential, type GitCredentialSet } from './connections-client.js';
 export declare function progressNotificationMarks(estimateMinutes: number): number[];
 export declare function computeCompactionKillDeadline(previousActivityTime: number, now: number, idleKillMs: number, graceMs: number): number;
 export interface ContextHintParams {
@@ -179,7 +179,7 @@ export interface BuildSpawnEnvParams {
     inboxThreadId: string;
     brainPath: string;
     subscriptionAccount?: SubscriptionAccount;
-    gitCredential?: GitCredential;
+    gitCredential?: GitCredential | GitCredentialSet;
     gitTokenFile?: string;
 }
 /**

package/dist/claude-spawner.js

@@ -1,3 +1,4 @@
+import { END_OF_TURN_NO_FURTHER_RESPONSE_SENTINEL } from './end-of-turn-sentinel.js';
 import { createSessionInstance, writeSessionOwner } from './session-instance.js';
 import { buildGitCredentialEnv } from './git-credential-env.js';
 import { createGitCredentialSession, finishGitCredentialSession, setGitCredentialSessionPid } from './git-credential-session.js';
@@ -794,10 +795,10 @@ function resolveTypingStatusDetail(event, assistantText) {
     if (assistantCalledTool(event, 'mcp__slack__send_message'))
         return null;
     const text = assistantText ?? extractAssistantText(event);
-    if (text) {
-        // Collapse newlines/whitespace runs so a multi-line narration doesn't
-        // land a literal `\n` in the one-line status surface.
-        return { text: oneLineStatus(text), source: 'comment' };
+    // tv#589: the silence marker is control text, including inside narration.
+    const narration = text?.split(END_OF_TURN_NO_FURTHER_RESPONSE_SENTINEL).join('').replace(/\s+/g, ' ').trim();
+    if (narration) {
+        return { text: oneLineStatus(narration), source: 'comment' };
     }
     for (const block of event.message.content) {
         if (block?.type !== 'tool_use' || typeof block.name !== 'string')
@@ -809,6 +810,9 @@ function resolveTypingStatusDetail(event, assistantText) {
             return { text: oneLineStatus(status), source: `tool:${safeToolName}` };
         }
     }
+    // A sentinel-only event keeps the current status when no tool status applies.
+    if (text?.includes(END_OF_TURN_NO_FURTHER_RESPONSE_SENTINEL))
+        return null;
     return { text: 'Thinking...', source: 'default' };
 }
 export function resolveTypingStatus(event, assistantText) {

package/dist/config.d.ts

@@ -19,6 +19,7 @@ declare const configSchema: z.ZodObject<{
     NETWORK_ERROR_KILL_MS: z.ZodDefault<z.ZodNumber>;
     MAX_CONSECUTIVE_NET_FAILURES: z.ZodDefault<z.ZodNumber>;
     TYPING_COMMENT_MIN_HOLD_MS: z.ZodDefault<z.ZodNumber>;
+    TYPING_STATUS_REQUEST_TIMEOUT_MS: z.ZodDefault<z.ZodNumber>;
     TEAMVIBE_DATA_DIR: z.ZodDefault<z.ZodString>;
     BRAINS_PATH: z.ZodDefault<z.ZodString>;
     DEFAULT_BRAIN_PATH: z.ZodDefault<z.ZodString>;
@@ -63,6 +64,7 @@ declare const configSchema: z.ZodObject<{
     NETWORK_ERROR_KILL_MS: number;
     MAX_CONSECUTIVE_NET_FAILURES: number;
     TYPING_COMMENT_MIN_HOLD_MS: number;
+    TYPING_STATUS_REQUEST_TIMEOUT_MS: number;
     TEAMVIBE_DATA_DIR: string;
     BRAINS_PATH: string;
     DEFAULT_BRAIN_PATH: string;
@@ -113,6 +115,7 @@ declare const configSchema: z.ZodObject<{
     NETWORK_ERROR_KILL_MS?: number | undefined;
     MAX_CONSECUTIVE_NET_FAILURES?: number | undefined;
     TYPING_COMMENT_MIN_HOLD_MS?: number | undefined;
+    TYPING_STATUS_REQUEST_TIMEOUT_MS?: number | undefined;
     TEAMVIBE_DATA_DIR?: string | undefined;
     BRAINS_PATH?: string | undefined;
     DEFAULT_BRAIN_PATH?: string | undefined;
@@ -160,6 +163,7 @@ export declare const config: {
     NETWORK_ERROR_KILL_MS: number;
     MAX_CONSECUTIVE_NET_FAILURES: number;
     TYPING_COMMENT_MIN_HOLD_MS: number;
+    TYPING_STATUS_REQUEST_TIMEOUT_MS: number;
     TEAMVIBE_DATA_DIR: string;
     BRAINS_PATH: string;
     DEFAULT_BRAIN_PATH: string;

package/dist/config.js

@@ -28,6 +28,7 @@ const configSchema = z.object({
     NETWORK_ERROR_KILL_MS: z.coerce.number().default(120000), // Per-session: kill stuck session after 2 min of network errors
     MAX_CONSECUTIVE_NET_FAILURES: z.coerce.number().default(5), // Poll loop: DNS flush at N, exit(1) at 2×N consecutive failures
     TYPING_COMMENT_MIN_HOLD_MS: z.coerce.number().default(4500), // Minimum time to display agent narration before a canned status
+    TYPING_STATUS_REQUEST_TIMEOUT_MS: z.coerce.number().int().positive().default(10_000), // Abort stalled Slack status requests
     // Paths
     TEAMVIBE_DATA_DIR: z.string().default(DEFAULT_DATA_DIR),
     BRAINS_PATH: z.string().default(''),

package/dist/connections-client.d.ts

@@ -1,13 +1,24 @@
+export type GitCredentialKind = 'github_token' | 'github_app' | 'gitlab_token';
 export type GitCredential = {
     source: 'platform';
-    host: 'github.com';
-    username: 'x-access-token';
+    host: string;
+    username: 'x-access-token' | 'oauth2';
     token: string;
     connectionId: string;
     credentialVersion: string;
     bindingVersion: number;
     expiresAt?: string;
-    kind?: 'github_token' | 'github_app';
+    kind: GitCredentialKind;
+} | {
+    source: 'none';
+    legacyAllowed?: boolean;
+};
+export type PlatformCredential = Omit<Extract<GitCredential, {
+    source: 'platform';
+}>, 'source'>;
+export type GitCredentialSet = {
+    source: 'platform';
+    bindings: PlatformCredential[];
 } | {
     source: 'none';
     legacyAllowed?: boolean;
@@ -59,7 +70,8 @@ export declare class ConnectionsClient {
     recordBrainSource(brainId: string, source: 'platform' | 'legacy'): void;
     get legacyGitBrains(): number;
     private noticeLegacyServer;
-    get(scope: Scope, id: string, force?: boolean): Promise<GitCredential>;
+    get(scope: 'brain', id: string, force?: boolean): Promise<GitCredential>;
+    get(scope: Scope, id: string, force?: boolean): Promise<GitCredential | GitCredentialSet>;
 }
 export declare const connectionsClient: ConnectionsClient;
 export declare function refreshConnectionTuples(pollerId: string): Promise<void>;

package/dist/connections-client.js

@@ -1,3 +1,4 @@
+import { gitCredentialBindings } from './git-credential-bindings.js';
 import { config } from './config.js';
 import { registerConfiguredToken } from './redact-text.js';
 export class ConnectionFetchError extends Error {
@@ -9,6 +10,22 @@ export class ConnectionFetchError extends Error {
         this.status = status;
     }
 }
+// RFC 1123 hostname: lowercase labels of 1–63 characters, 253 total,
+// with no scheme, port, path, trailing dot or leading/trailing hyphens.
+function isCredentialHost(host) {
+    return typeof host === 'string' && host.length <= 253 && !/[^a-z0-9.-]/.test(host) &&
+        host.split('.').every(label => /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/.test(label));
+}
+function isPlatformCredential(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const body = value;
+    return isCredentialHost(body.host) &&
+        ((body.kind === 'github_token' || body.kind === 'github_app') && body.host === 'github.com' && body.username === 'x-access-token' ||
+            body.kind === 'gitlab_token' && body.host !== 'github.com' && body.username === 'oauth2') &&
+        typeof body.token === 'string' && !!body.token && typeof body.connectionId === 'string' &&
+        typeof body.credentialVersion === 'string' && typeof body.bindingVersion === 'number';
+}
 /** Cache keys include consumer scope. Binding tuples arrive at startup and
  * each brains refresh; a changed tuple evicts immediately. */
 export class ConnectionsClient {
@@ -75,8 +92,10 @@ export class ConnectionsClient {
         if (!/^[A-Za-z0-9_-]{1,128}$/.test(id))
             throw new ConnectionFetchError('invalid_request', 400);
         const url = new URL(scope === 'brain' ? `/brains/${encodeURIComponent(id)}/git-credential` : '/connections/git/spawn', this.options.apiUrl);
-        if (scope === 'channel')
+        if (scope === 'channel') {
             url.searchParams.set('channelId', id);
+            url.searchParams.set('format', 'bindings');
+        }
         const response = await (this.options.fetch ?? fetch)(url, { headers: { Authorization: `Bearer ${this.options.pollerToken}`, 'Cache-Control': 'no-store' }, redirect: 'error' });
         if (!response.ok) {
             if (response.status === 405 || response.status === 404 && !(await response.clone().json().catch(() => ({}))).code) {
@@ -87,20 +106,32 @@ export class ConnectionsClient {
             const code = { 400: 'invalid_request', 401: 'unauthorized', 403: 'forbidden', 404: 'connection_unbound', 409: 'connection_disabled', 410: 'connection_deleted' }[response.status] ?? 'credential_store_unavailable';
             throw new ConnectionFetchError(code, response.status);
         }
-        const body = await response.json();
+        const body = await response.json().catch(() => null);
         let value;
-        if (body.source === 'none')
-            value = { source: 'none', ...(body.legacyAllowed === true ? { legacyAllowed: true } : {}) };
-        else if (body.source === 'platform' && body.host === 'github.com' && body.username === 'x-access-token' &&
-            typeof body.token === 'string' && body.token && typeof body.connectionId === 'string' &&
-            typeof body.credentialVersion === 'string' && typeof body.bindingVersion === 'number') {
-            value = body;
-            registerConfiguredToken(body.token);
+        if (body?.['source'] === 'none')
+            value = { source: 'none', ...(body['legacyAllowed'] === true ? { legacyAllowed: true } : {}) };
+        else if (body?.['source'] === 'platform') {
+            if (scope === 'channel') {
+                // Older servers may ignore format=bindings; tolerate their single body.
+                const { source: _, ...single } = body;
+                const bindings = Object.hasOwn(body, 'bindings') ? body['bindings'] : [single];
+                if (!Array.isArray(bindings) || bindings.length === 0 || !bindings.every(isPlatformCredential) ||
+                    new Set(bindings.map(binding => binding.host.toLowerCase())).size !== bindings.length)
+                    throw new ConnectionFetchError('invalid_response', 503);
+                value = { source: 'platform', bindings };
+            }
+            else if (isPlatformCredential(body))
+                value = body;
+            else
+                throw new ConnectionFetchError('invalid_response', 503);
+            for (const binding of gitCredentialBindings(value))
+                registerConfiguredToken(binding.token);
         }
         else
             throw new ConnectionFetchError('invalid_response', 503);
-        const validUntil = value.source === 'platform' && value.expiresAt
-            ? Date.parse(value.expiresAt) - 5 * 60_000 : this.now() + 10 * 60_000;
+        const bindings = gitCredentialBindings(value);
+        const validUntil = bindings.length ? Math.min(...bindings.map(binding => binding.expiresAt
+            ? Date.parse(binding.expiresAt) - 5 * 60_000 : this.now() + 10 * 60_000)) : this.now() + 10 * 60_000;
         if (validUntil > this.now())
             this.entries.set(key, { value, tuple: tuple ?? '', validUntil });
         return value;

package/dist/end-of-turn-sentinel.d.ts

@@ -0,0 +1,2 @@
+/** Claude's end-of-turn marker when no further visible reply is needed. */
+export declare const END_OF_TURN_NO_FURTHER_RESPONSE_SENTINEL = "NO_FURTHER_RESPONSE_NEEDED";

package/dist/end-of-turn-sentinel.js

@@ -0,0 +1,2 @@
+/** Claude's end-of-turn marker when no further visible reply is needed. */
+export const END_OF_TURN_NO_FURTHER_RESPONSE_SENTINEL = 'NO_FURTHER_RESPONSE_NEEDED';

package/dist/git-credential-bindings.d.ts

@@ -0,0 +1,2 @@
+import type { GitCredential, GitCredentialSet, PlatformCredential } from './connections-client.js';
+export declare function gitCredentialBindings(credential: GitCredential | GitCredentialSet): PlatformCredential[];

package/dist/git-credential-bindings.js

@@ -0,0 +1,4 @@
+// Shared single-consumer adapter; preserves the brain credential contract.
+export function gitCredentialBindings(credential) {
+    return credential.source === 'none' ? [] : 'bindings' in credential ? credential.bindings : [credential];
+}

package/dist/git-credential-env.d.ts

@@ -1,3 +1,3 @@
-import type { GitCredential } from './connections-client.js';
+import type { GitCredential, GitCredentialSet } from './connections-client.js';
 export declare const GIT_CREDENTIAL_HELPER: string;
-export declare function buildGitCredentialEnv(base: NodeJS.ProcessEnv, credential: GitCredential, tokenFile?: string): NodeJS.ProcessEnv;
+export declare function buildGitCredentialEnv(base: NodeJS.ProcessEnv, credential: GitCredential | GitCredentialSet, tokenFile?: string): NodeJS.ProcessEnv;

package/dist/git-credential-env.js

@@ -1,3 +1,4 @@
+import { gitCredentialBindings } from './git-credential-bindings.js';
 import { fileURLToPath } from 'node:url';
 import { registerConfiguredToken } from './redact-text.js';
 // Works from both src/ (tests) and dist/ (published package).
@@ -9,29 +10,41 @@ export function buildGitCredentialEnv(base, credential, tokenFile) {
         // Do not inherit a prior session's helper/file, even on eligible legacy.
         if (key.startsWith('TV_GIT_') || !legacy && (/^GIT_(?:CONFIG|CREDENTIAL|TRACE|SSL|HTTP|SSH)(?:_|$)/.test(key) ||
             ['GIT_ASKPASS', 'GIT_EXEC_PATH', 'GIT_PROXY_COMMAND', 'GIT_DIR', 'GIT_COMMON_DIR', 'GIT_WORK_TREE', 'GIT_NAMESPACE', 'GIT_TEMPLATE_DIR', 'GIT_PROTOCOL', 'GIT_ALLOW_PROTOCOL', 'SSH_ASKPASS'].includes(key) ||
-            ['GITHUB_TOKEN', 'GH_TOKEN', 'GITLAB_TOKEN'].includes(key)))
+            ['GITHUB_TOKEN', 'GH_TOKEN', 'GITLAB_TOKEN', 'GITLAB_HOST'].includes(key)))
             delete env[key];
     }
     if (legacy)
         return env;
     env['GIT_TERMINAL_PROMPT'] = '0';
-    env['GIT_CONFIG_COUNT'] = credential.source === 'platform' ? '3' : '1';
+    const bindings = gitCredentialBindings(credential);
+    env['GIT_CONFIG_COUNT'] = String(1 + 2 * bindings.length);
     env['GIT_CONFIG_KEY_0'] = 'credential.helper';
     env['GIT_CONFIG_VALUE_0'] = '';
     if (credential.source === 'platform') {
         if (!tokenFile)
             throw new Error('Git credential token file required');
-        registerConfiguredToken(credential.token);
         env['TV_GIT_TOKEN_FILE'] = tokenFile;
-        env['GIT_CONFIG_KEY_1'] = `credential.https://${credential.host}.helper`;
         // Strip CLI snapshots before the helper process starts. Git appends only
         // get/store/erase; the token remains exclusively in the private file.
         const helperPath = "'" + GIT_CREDENTIAL_HELPER.replace(/'/g, "'\\''") + "'";
-        env['GIT_CONFIG_VALUE_1'] = `!env -u GITHUB_TOKEN -u GH_TOKEN -u GITLAB_TOKEN ${helperPath}`;
-        env['GIT_CONFIG_KEY_2'] = `credential.https://${credential.host}.useHttpPath`;
-        env['GIT_CONFIG_VALUE_2'] = 'true';
-        env['GH_TOKEN'] = credential.token;
-        env['GITHUB_TOKEN'] = credential.token;
+        for (const [index, binding] of bindings.entries()) {
+            registerConfiguredToken(binding.token);
+            const key = 1 + 2 * index;
+            env[`GIT_CONFIG_KEY_${key}`] = `credential.https://${binding.host}.helper`;
+            env[`GIT_CONFIG_VALUE_${key}`] = `!env -u GITHUB_TOKEN -u GH_TOKEN -u GITLAB_TOKEN ${helperPath}`;
+            env[`GIT_CONFIG_KEY_${key + 1}`] = `credential.https://${binding.host}.useHttpPath`;
+            env[`GIT_CONFIG_VALUE_${key + 1}`] = 'true';
+            if (binding.host === 'github.com') {
+                env['GH_TOKEN'] = binding.token;
+                env['GITHUB_TOKEN'] = binding.token;
+            }
+            else if (binding.kind === 'gitlab_token' && env['GITLAB_TOKEN'] === undefined) {
+                // glab/API env covers the first GitLab host in canonical order;
+                // Git's host-scoped helpers cover every binding.
+                env['GITLAB_TOKEN'] = binding.token;
+                env['GITLAB_HOST'] = binding.host;
+            }
+        }
     }
     return env;
 }

package/dist/git-credential-session.d.ts

@@ -1,6 +1,6 @@
-import type { GitCredential } from './connections-client.js';
+import type { GitCredential, GitCredentialKind, GitCredentialSet, PlatformCredential } from './connections-client.js';
 import { type SessionInstance } from './session-instance.js';
-type PlatformCredential = Extract<GitCredential, {
+type PlatformDelivery = Extract<GitCredential | GitCredentialSet, {
     source: 'platform';
 }>;
 export interface GitCredentialSession extends SessionInstance {
@@ -10,13 +10,13 @@ export interface GitCredentialSession extends SessionInstance {
 }
 export interface AgentGitDelivery {
     instance?: SessionInstance;
-    credential?: GitCredential;
+    credential?: GitCredential | GitCredentialSet;
     session?: GitCredentialSession;
 }
 export declare function gitCredentialRoot(): string;
-export declare function gitCredentialKind(credential: PlatformCredential): 'github_app' | 'github_token';
-export declare function writeGitTokenFile(dir: string, credential: PlatformCredential): void;
-export declare function createGitCredentialSession(credential: PlatformCredential, options: {
+export declare function gitCredentialKind(credential: PlatformCredential): GitCredentialKind;
+export declare function writeGitTokenFile(dir: string, credential: PlatformDelivery): void;
+export declare function createGitCredentialSession(credential: PlatformDelivery, options: {
     root?: string;
     channelId: string;
     threadId: string;

package/dist/git-credential-session.js

@@ -1,3 +1,4 @@
+import { gitCredentialBindings } from './git-credential-bindings.js';
 import { execFileSync } from 'node:child_process';
 import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { randomUUID } from 'node:crypto';
@@ -47,8 +48,13 @@ export function gitCredentialKind(credential) {
     return credential.kind ?? (credential.expiresAt ? 'github_app' : 'github_token');
 }
 export function writeGitTokenFile(dir, credential) {
-    registerConfiguredToken(credential.token);
-    atomicWrite(join(dir, 'git-token'), JSON.stringify({ host: credential.host, token: credential.token, expiresAt: credential.expiresAt, kind: gitCredentialKind(credential) }));
+    const entries = gitCredentialBindings(credential).map(binding => {
+        registerConfiguredToken(binding.token);
+        return { host: binding.host, username: binding.username, token: binding.token, expiresAt: binding.expiresAt, kind: gitCredentialKind(binding) };
+    });
+    // Channel sets use an ordered array; single brain credentials keep their
+    // existing file shape. The helper reads either format on every invocation.
+    atomicWrite(join(dir, 'git-token'), JSON.stringify('bindings' in credential ? entries : entries[0]));
 }
 export function createGitCredentialSession(credential, options) {
     const root = options.root ?? gitCredentialRoot();
@@ -60,7 +66,9 @@ export function createGitCredentialSession(credential, options) {
         const instance = options.instance ?? createSessionInstance();
         writeSessionOwner(join(dir, 'owner.json'), instance);
         writeGitTokenFile(dir, credential);
-        const metadata = { ...instance, ownerPid: process.pid, ownerIdentity, active: true, channelId: options.channelId, threadId: options.threadId, connectionId: credential.connectionId, kind: gitCredentialKind(credential) };
+        const metadata = { ...instance, ownerPid: process.pid, ownerIdentity, active: true, channelId: options.channelId, threadId: options.threadId, ...('bindings' in credential
+                ? { bindings: credential.bindings.map(binding => ({ connectionId: binding.connectionId, kind: gitCredentialKind(binding), host: binding.host })) }
+                : { connectionId: credential.connectionId, kind: gitCredentialKind(credential) }) };
         atomicWrite(join(dir, 'session.json'), JSON.stringify(metadata));
         const tasksFile = join(dir, 'bg-tasks');
         writeFileSync(tasksFile, '', { mode: 0o600, flag: 'wx' });
@@ -187,7 +195,19 @@ function sweepSession(dir) {
         reportSessionOwnerMismatch(expected, current);
     const events = join(dir, 'git-credential-events');
     if (metadata && matches && existsSync(events)) {
-        if (!metadata.expiryReported) {
+        if (metadata.bindings) {
+            const diagnostics = new Set(readFileSync(events, 'utf8').split('\n'));
+            const expiredHosts = new Set(metadata.expiredHosts);
+            for (const binding of metadata.bindings) {
+                if (!expiredHosts.has(binding.host) && diagnostics.has(`git_credential_expired kind=${binding.kind} host=${binding.host}`)) {
+                    emitError('session', `git_credential_expired kind=${binding.kind} host=${binding.host}`, { channelId: metadata.channelId, context: { code: 'git_credential_expired', ...binding, threadId: metadata.threadId } });
+                    expiredHosts.add(binding.host);
+                }
+            }
+            metadata.expiredHosts = [...expiredHosts];
+            atomicWrite(path, JSON.stringify(metadata));
+        }
+        else if (!metadata.expiryReported) {
             emitError('session', `git_credential_expired kind=${metadata.kind}`, { channelId: metadata.channelId, context: { code: 'git_credential_expired', kind: metadata.kind, connectionId: metadata.connectionId, threadId: metadata.threadId } });
             metadata.expiryReported = true;
             atomicWrite(path, JSON.stringify(metadata));

package/dist/inbox-watcher.d.ts

@@ -27,8 +27,8 @@ export interface InboxWatcherDeps {
  * threads (see modules-teamvibe/hooks/slack-events.ts). Synthetic threadIds
  * used elsewhere (`maintenance_<brainId>_<ts>`, and
  * `scheduled:<scheduleId>:<ts>` from
- * modules-teamvibe/src/functions/scheduler.ts:86) never sit idle waiting on
- * a background-task drop, so they're skipped rather than guessed at.
+ * modules-teamvibe/src/functions/scheduler.ts) carry no Slack destination;
+ * scheduler recovery needs the poller-owned routing record exclusively.
  * `scheduled:*:*` has the same 3-colon-segment shape as a real Slack
  * threadId, so it's rejected explicitly rather than by segment count alone
  * — otherwise a leftover unprocessed file in a stale scheduled-session inbox

package/dist/inbox-watcher.js

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

package/dist/poller.d.ts

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

package/dist/poller.js

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

package/dist/redact-text.js

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

package/dist/slack-client.d.ts

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

package/dist/slack-client.js

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

package/dist/thread-routing.d.ts

@@ -1,3 +1,4 @@
+import type { TeamVibeQueueMessage } from './types.js';
 export interface ThreadRouting {
     workspaceId: string;
     channelId: string;
@@ -6,6 +7,12 @@ export interface ThreadRouting {
     directory: string;
     threadId?: string;
     processedDropIds?: string[];
+    /** Original queue source; recovery must preserve its worktree isolation policy. */
+    source?: TeamVibeQueueMessage['source'];
+    /** Captured only from trusted queue input, never inbox drops or context files. */
+    responseContext?: {
+        slack: NonNullable<TeamVibeQueueMessage['response_context']['slack']>;
+    };
 }
 /** Poller state survives inbox pruning and process restarts; contains no credentials. */
 export declare function saveThreadRouting(threadId: string, routing: ThreadRouting): void;

package/dist/thread-routing.js

@@ -25,6 +25,13 @@ export function readThreadRouting(threadId) {
             return undefined;
         if (routing.processedDropIds !== undefined && (!Array.isArray(routing.processedDropIds) || !routing.processedDropIds.every((id) => typeof id === 'string')))
             return undefined;
+        if (routing.source !== undefined && !['slack', 'email', 'cron', 'maintenance', 'webhook'].includes(routing.source))
+            return undefined;
+        if (routing.responseContext !== undefined) {
+            const slack = routing.responseContext?.slack;
+            if (!slack || typeof slack.channel !== 'string' || !slack.channel || typeof slack.thread_ts !== 'string' || typeof slack.message_ts !== 'string')
+                return undefined;
+        }
         return routing;
     }
     catch {

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@teamvibe/poller",
-  "version": "0.8.8",
+  "version": "0.8.9-rc.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@teamvibe/poller",
-      "version": "0.8.8",
+      "version": "0.8.9-rc.1",
       "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.8",
+  "version": "0.8.9-rc.1",
   "type": "module",
   "main": "./dist/index.js",
   "bin": {