@teamvibe/poller 0.8.8 → 0.8.9-rc.2

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 {};