@teamvibe/poller 0.5.2 → 0.6.0

package/dist/claude-spawner.d.ts

@@ -1,6 +1,7 @@
 import type { TeamVibeQueueMessage, SessionMetrics } from './types.js';
 import { type SessionLogger } from './logger.js';
 import type { TypingIndicator } from './slack-client.js';
+import { type ResolvedModelConfig } from './config-client.js';
 import type { KilledByPoller } from './classify-failed-iteration.js';
 export interface ContextHintParams {
     isFirstMessage: boolean;
@@ -21,7 +22,38 @@ export interface SpawnResult {
     error?: string;
     metrics?: SessionMetrics;
     killedByPoller?: KilledByPoller;
+    modelSource?: ModelSource;
 }
+/**
+ * `settings.json` and `env-default` are poller-local, not DDB-resolved
+ * scopes — kept as a superset of `services/model-config.ts`'s
+ * `ModelConfigScope` rather than importing it, since the poller package
+ * doesn't depend on `modules-teamvibe`.
+ */
+export type ModelSource = 'settings.json' | 'poller' | 'workspace' | 'channel' | 'env-default' | undefined;
+/**
+ * 3-tier model resolution — teamvibe.ai#235 PR2.
+ *
+ * Precedence (highest to lowest): brain `settings.json` > DDB-resolved
+ * scoped config (poller/workspace/channel, fetched via
+ * `fetchConfigForSpawn`) > `CLAUDE_MODEL` env default.
+ *
+ * `settings.json` staying on top is a **known, documented, accepted
+ * blind spot** (see DevGuru's tv#235 approach-review addendum): a
+ * poller-level emergency model cap set via DDB can be silently
+ * overridden by any brain's local settings.json. Not fixed here — PR3
+ * adds a read-only "last observed override source" surfaced via the
+ * `session.completed` telemetry this function's return value feeds
+ * (see the `modelSource` field on `SpawnResult` / the `poller.ts`
+ * `emitEvent` call site).
+ *
+ * Pure function — no I/O — so it's unit-testable without mocking
+ * `fetch` or `child_process.spawn`.
+ */
+export declare function resolveModel(brainSettingsModel: string | undefined, ddbConfig: Pick<ResolvedModelConfig, 'model' | 'modelSource'>, envDefaultModel: string | undefined): {
+    model: string | undefined;
+    modelSource: ModelSource;
+};
 export declare function buildPrompt(msg: TeamVibeQueueMessage, contextHint?: string): string;
 export declare function spawnClaudeCode(msg: TeamVibeQueueMessage, sessionLog: SessionLogger, cwd: string, sessionId?: string, isFirstMessage?: boolean, lastMessageTs?: string, onMessageSent?: () => void, typingIndicator?: TypingIndicator): Promise<SpawnResult & {
     newSessionId?: string;

package/dist/claude-spawner.js

@@ -9,6 +9,7 @@ import { getPollerId } from './auth-provider.js';
 import { emitError } from './event-queue.js';
 import { createWorktree, removeWorktree, isWorktreeIsolationEnabled } from './worktree-manager.js';
 import { fetchSecretsForSpawn, buildSecretsReminder } from './secrets-client.js';
+import { fetchConfigForSpawn } from './config-client.js';
 /**
  * Maps tool names (or prefixes) to human-readable status messages.
  * More specific patterns are checked first.
@@ -167,6 +168,37 @@ function readBrainSettings(cwd) {
         return {};
     }
 }
+/**
+ * 3-tier model resolution — teamvibe.ai#235 PR2.
+ *
+ * Precedence (highest to lowest): brain `settings.json` > DDB-resolved
+ * scoped config (poller/workspace/channel, fetched via
+ * `fetchConfigForSpawn`) > `CLAUDE_MODEL` env default.
+ *
+ * `settings.json` staying on top is a **known, documented, accepted
+ * blind spot** (see DevGuru's tv#235 approach-review addendum): a
+ * poller-level emergency model cap set via DDB can be silently
+ * overridden by any brain's local settings.json. Not fixed here — PR3
+ * adds a read-only "last observed override source" surfaced via the
+ * `session.completed` telemetry this function's return value feeds
+ * (see the `modelSource` field on `SpawnResult` / the `poller.ts`
+ * `emitEvent` call site).
+ *
+ * Pure function — no I/O — so it's unit-testable without mocking
+ * `fetch` or `child_process.spawn`.
+ */
+export function resolveModel(brainSettingsModel, ddbConfig, envDefaultModel) {
+    if (brainSettingsModel) {
+        return { model: brainSettingsModel, modelSource: 'settings.json' };
+    }
+    if (ddbConfig.model) {
+        return { model: ddbConfig.model, modelSource: ddbConfig.modelSource };
+    }
+    if (envDefaultModel) {
+        return { model: envDefaultModel, modelSource: 'env-default' };
+    }
+    return { model: undefined, modelSource: undefined };
+}
 // Tags procs at SIGTERM time so the close handler can report poller intent.
 // WeakMap auto-cleans when proc is GC'd. Module-scope is required because
 // killZombieForThread fires outside the runClaudeCode closure.
@@ -191,6 +223,12 @@ export function buildPrompt(msg, contextHint) {
             ? 'Direct Message'
             : `Channel ${slack.channel}`;
         prompt += `**Channel:** ${channelType}\n`;
+        // The agent's reply defaults to this thread. Stating it here is what stops
+        // the agent from reconstructing "the thread we were in" from memory and
+        // replying into a stale one — see teamvibeai/teamvibe.ai#184.
+        if (slack.thread_ts) {
+            prompt += `**Thread TS:** \`${slack.thread_ts}\` (your reply defaults here)\n`;
+        }
     }
     // Inject human-readable timestamp from Slack message ts
     if (msg.response_context.slack?.message_ts) {
@@ -333,6 +371,14 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
         channelId: msg.teamvibe.channelId,
     });
     const secretsReminder = buildSecretsReminder(spawnSecrets.reminders);
+    // Fetch scoped model config for this spawn — same hoisting rationale as
+    // secrets above. Fail-soft: returns {} on any error, which resolveModel
+    // treats as "nothing at this tier" and falls through to the env default.
+    const ddbModelConfig = await fetchConfigForSpawn({
+        pollerId: getPollerId() || '',
+        workspaceId: msg.teamvibe.workspaceId,
+        channelId: msg.teamvibe.channelId,
+    });
     return new Promise((resolve) => {
         const prompt = buildPrompt(msg, contextHint);
         // MCP server config passed via --mcp-config flag (no temp files needed)
@@ -358,11 +404,15 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
             '--disallowedTools',
             'NotebookEdit',
         ];
-        // Model override: brain settings.json takes priority, then CLAUDE_MODEL env var
-        const model = (typeof brainSettings['model'] === 'string' && brainSettings['model']) || config.CLAUDE_MODEL;
+        // Model override — 3-tier precedence (teamvibe.ai#235 PR2): brain
+        // settings.json > DDB-resolved scoped config (poller/workspace/channel)
+        // > CLAUDE_MODEL env default. See resolveModel's docstring for why
+        // settings.json stays on top (known, accepted blind spot).
+        const brainSettingsModel = typeof brainSettings['model'] === 'string' ? brainSettings['model'] : undefined;
+        const { model, modelSource } = resolveModel(brainSettingsModel, ddbModelConfig, config.CLAUDE_MODEL);
         if (model) {
             args.push('--model', model);
-            sessionLog.info(`Using model: ${model}`);
+            sessionLog.info(`Using model: ${model} (source: ${modelSource ?? 'unknown'})`);
         }
         // Inbox protocol: instruct Claude to check for mid-task messages (thread-scoped)
         const inboxNewDir = `.inbox/${msg.thread_id}/new`;
@@ -595,6 +645,7 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
                 output: stdout,
                 exitCode: code,
                 metrics,
+                modelSource,
                 ...(killReason ? { killedByPoller: killReason } : {}),
             };
             if (killReason === 'timeout') {

package/dist/config-client.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Poller-side non-secret scoped config client — teamvibe.ai#235 (PR2).
+ *
+ * Fetches the resolved scoped config from the Poller API
+ * (GET /config/spawn?pollerId=&workspaceId=&channelId=) before spawn.
+ * Mirrors `secrets-client.ts`'s defensive-failure pattern: on any failure
+ * mode (missing config, network error, non-2xx, malformed JSON) this
+ * returns an empty result rather than throwing — spawn must never fail
+ * because this fetch failed, it just falls through to the next
+ * precedence tier (settings.json / CLAUDE_MODEL env default) in
+ * `claude-spawner.ts`.
+ *
+ * Unlike secrets, this config is NOT sensitive — no `Redacted`/opaque
+ * envelope wrapper needed, the resolved value is returned as a plain
+ * object.
+ *
+ * Wire shape is a generic `env`/`sources` envelope (see
+ * `poller-config.ts`'s `buildConfigResponse` on the server side) so
+ * future non-secret settings land as additional `env` keys without a new
+ * endpoint. This client unwraps that envelope into the typed
+ * `ResolvedModelConfig` shape `claude-spawner.ts` already consumes —
+ * today only the `MODEL`/`REASONING_EFFORT` keys exist, so the unwrap is
+ * a fixed 1:1 mapping, not a generic loop; widen it if/when a third key
+ * appears.
+ */
+export type ModelConfigScope = 'poller' | 'workspace' | 'channel';
+export interface ResolvedModelConfig {
+    model?: string;
+    reasoningEffort?: string;
+    modelSource?: ModelConfigScope;
+    reasoningEffortSource?: ModelConfigScope;
+}
+export interface FetchModelConfigInput {
+    pollerId: string;
+    workspaceId: string;
+    channelId: string;
+}
+/**
+ * Fetch the resolved config for a spawn. Returns `{}` on any failure
+ * mode — spawn continues, falling through to the env-default model tier.
+ * Errors are logged at warn level so monitoring can alarm; mirrors
+ * `fetchSecretsForSpawn`'s fail-soft contract exactly.
+ */
+export declare function fetchConfigForSpawn(input: FetchModelConfigInput): Promise<ResolvedModelConfig>;

package/dist/config-client.js

@@ -0,0 +1,113 @@
+/**
+ * Poller-side non-secret scoped config client — teamvibe.ai#235 (PR2).
+ *
+ * Fetches the resolved scoped config from the Poller API
+ * (GET /config/spawn?pollerId=&workspaceId=&channelId=) before spawn.
+ * Mirrors `secrets-client.ts`'s defensive-failure pattern: on any failure
+ * mode (missing config, network error, non-2xx, malformed JSON) this
+ * returns an empty result rather than throwing — spawn must never fail
+ * because this fetch failed, it just falls through to the next
+ * precedence tier (settings.json / CLAUDE_MODEL env default) in
+ * `claude-spawner.ts`.
+ *
+ * Unlike secrets, this config is NOT sensitive — no `Redacted`/opaque
+ * envelope wrapper needed, the resolved value is returned as a plain
+ * object.
+ *
+ * Wire shape is a generic `env`/`sources` envelope (see
+ * `poller-config.ts`'s `buildConfigResponse` on the server side) so
+ * future non-secret settings land as additional `env` keys without a new
+ * endpoint. This client unwraps that envelope into the typed
+ * `ResolvedModelConfig` shape `claude-spawner.ts` already consumes —
+ * today only the `MODEL`/`REASONING_EFFORT` keys exist, so the unwrap is
+ * a fixed 1:1 mapping, not a generic loop; widen it if/when a third key
+ * appears.
+ */
+import { logger } from './logger.js';
+import { config } from './config.js';
+const SCOPES = new Set(['poller', 'workspace', 'channel']);
+function isModelConfigScope(v) {
+    return typeof v === 'string' && SCOPES.has(v);
+}
+/**
+ * Fetch the resolved config for a spawn. Returns `{}` on any failure
+ * mode — spawn continues, falling through to the env-default model tier.
+ * Errors are logged at warn level so monitoring can alarm; mirrors
+ * `fetchSecretsForSpawn`'s fail-soft contract exactly.
+ */
+export async function fetchConfigForSpawn(input) {
+    if (!config.TEAMVIBE_API_URL || !config.TEAMVIBE_POLLER_TOKEN) {
+        logger.warn('config-client: TEAMVIBE_API_URL or TEAMVIBE_POLLER_TOKEN not set; skipping fetch');
+        return {};
+    }
+    // Upfront short-circuit: an empty pollerId would fail server-side
+    // validation and round-trip an HTTP error. Skip the call entirely so
+    // the warn log makes the cause obvious from poller stdout.
+    if (!input.pollerId) {
+        logger.warn('config-client: pollerId empty; skipping fetch (no scoped config for spawn)');
+        return {};
+    }
+    let url;
+    try {
+        url = new URL('/config/spawn', config.TEAMVIBE_API_URL);
+        url.searchParams.set('pollerId', input.pollerId);
+        url.searchParams.set('workspaceId', input.workspaceId);
+        url.searchParams.set('channelId', input.channelId);
+    }
+    catch (err) {
+        logger.warn(`config-client.config_error: invalid TEAMVIBE_API_URL=${String(config.TEAMVIBE_API_URL)} ` +
+            `error=${err?.message ?? String(err)}`);
+        return {};
+    }
+    let response;
+    try {
+        response = await fetch(url.toString(), {
+            method: 'GET',
+            headers: {
+                Authorization: `Bearer ${config.TEAMVIBE_POLLER_TOKEN}`,
+            },
+        });
+    }
+    catch (err) {
+        logger.warn(`config-client.fetch_failed: network error pollerId=${input.pollerId} ` +
+            `workspaceId=${input.workspaceId} channelId=${input.channelId} ` +
+            `error=${err?.message ?? String(err)}`);
+        return {};
+    }
+    if (!response.ok) {
+        let snippet = '';
+        try {
+            snippet = (await response.text()).slice(0, 200);
+        }
+        catch {
+            snippet = '<failed-to-read-body>';
+        }
+        logger.warn(`config-client.fetch_failed: status=${response.status} ` +
+            `pollerId=${input.pollerId} workspaceId=${input.workspaceId} ` +
+            `channelId=${input.channelId} bodySnippet=${snippet}`);
+        return {};
+    }
+    let parsed;
+    try {
+        parsed = (await response.json());
+    }
+    catch (err) {
+        logger.warn(`config-client.parse_failed: pollerId=${input.pollerId} ` +
+            `error=${err?.message ?? String(err)}`);
+        return {};
+    }
+    const env = parsed.env ?? {};
+    const sources = parsed.sources ?? {};
+    const result = {};
+    if (typeof env.MODEL === 'string' && env.MODEL)
+        result.model = env.MODEL;
+    if (typeof env.REASONING_EFFORT === 'string' && env.REASONING_EFFORT) {
+        result.reasoningEffort = env.REASONING_EFFORT;
+    }
+    if (isModelConfigScope(sources.MODEL))
+        result.modelSource = sources.MODEL;
+    if (isModelConfigScope(sources.REASONING_EFFORT))
+        result.reasoningEffortSource = sources.REASONING_EFFORT;
+    logger.info(`config-client: resolved model=${result.model ?? '(none)'} source=${result.modelSource ?? '(none)'}`);
+    return result;
+}

package/dist/logger.d.ts

@@ -1,3 +1,4 @@
+export declare function setLogContext(ctx: Record<string, string>): void;
 export declare class SessionLogger {
     private sessionId;
     private logFile;

package/dist/logger.js

@@ -15,6 +15,17 @@ function formatDate(date) {
     return date.toISOString();
 }
 const now = () => formatDate(new Date());
+// Optional global context (e.g. pollerId) prepended to every log line so an
+// operator watching Railway stdout can filter by poller without a session id.
+// Set once after auth resolves; see setLogContext call in poller startup.
+let logContext = {};
+export function setLogContext(ctx) {
+    logContext = { ...logContext, ...ctx };
+}
+function contextPrefix() {
+    const entries = Object.entries(logContext);
+    return entries.length ? entries.map(([k, v]) => `${k}=${v}`).join(' ') + ' ' : '';
+}
 function writeToFile(level, message, timestamp, ...args) {
     const formattedArgs = args
         .map((arg) => (typeof arg === 'object' ? JSON.stringify(arg) : String(arg)))
@@ -46,30 +57,34 @@ export class SessionLogger {
     }
     info(message) {
         const ts = now();
-        console.log(`[${ts}] [${this.sessionId}] ${message}`);
+        const cp = contextPrefix();
+        console.log(`[${ts}] [${this.sessionId}] ${cp}${message}`);
         this.write('INFO', message, ts);
         writeToFile('INFO', `[${this.sessionId}] ${message}`, ts);
     }
     error(message) {
         const ts = now();
-        console.error(`[${ts}] [${this.sessionId}] ${message}`);
+        const cp = contextPrefix();
+        console.error(`[${ts}] [${this.sessionId}] ${cp}${message}`);
         this.write('ERROR', message, ts);
         writeToFile('ERROR', `[${this.sessionId}] ${message}`, ts);
     }
     warn(message) {
         const ts = now();
-        console.warn(`[${ts}] [${this.sessionId}] ${message}`);
+        const cp = contextPrefix();
+        console.warn(`[${ts}] [${this.sessionId}] ${cp}${message}`);
         this.write('WARN', message, ts);
         writeToFile('WARN', `[${this.sessionId}] ${message}`, ts);
     }
     claude(stream, message) {
         const ts = now();
+        const cp = contextPrefix();
         const prefix = `[Claude ${stream}]`;
         if (stream === 'stderr') {
-            console.error(`[${ts}] [${this.sessionId}] ${prefix}`, message);
+            console.error(`[${ts}] [${this.sessionId}] ${cp}${prefix}`, message);
         }
         else {
-            console.log(`[${ts}] [${this.sessionId}] ${prefix}`, message);
+            console.log(`[${ts}] [${this.sessionId}] ${cp}${prefix}`, message);
         }
         this.write(`CLAUDE_${stream.toUpperCase()}`, message, ts);
     }
@@ -83,25 +98,29 @@ export class SessionLogger {
 export const logger = {
     info(message, ...args) {
         const ts = now();
-        console.log(`[${ts}] [INFO] ${message}`, ...args);
-        writeToFile('INFO', message, ts, ...args);
+        const cp = contextPrefix();
+        console.log(`[${ts}] [INFO] ${cp}${message}`, ...args);
+        writeToFile('INFO', `${cp}${message}`, ts, ...args);
     },
     error(message, ...args) {
         const ts = now();
-        console.error(`[${ts}] [ERROR] ${message}`, ...args);
-        writeToFile('ERROR', message, ts, ...args);
+        const cp = contextPrefix();
+        console.error(`[${ts}] [ERROR] ${cp}${message}`, ...args);
+        writeToFile('ERROR', `${cp}${message}`, ts, ...args);
     },
     warn(message, ...args) {
         const ts = now();
-        console.warn(`[${ts}] [WARN] ${message}`, ...args);
-        writeToFile('WARN', message, ts, ...args);
+        const cp = contextPrefix();
+        console.warn(`[${ts}] [WARN] ${cp}${message}`, ...args);
+        writeToFile('WARN', `${cp}${message}`, ts, ...args);
     },
     debug(message, ...args) {
         const ts = now();
+        const cp = contextPrefix();
         if (process.env['DEBUG']) {
-            console.debug(`[${ts}] [DEBUG] ${message}`, ...args);
+            console.debug(`[${ts}] [DEBUG] ${cp}${message}`, ...args);
         }
-        writeToFile('DEBUG', message, ts, ...args);
+        writeToFile('DEBUG', `${cp}${message}`, ts, ...args);
     },
     createSession(sessionId) {
         return new SessionLogger(sessionId);

package/dist/poller.js

@@ -1,5 +1,5 @@
-import { config } from './config.js';
-import { logger } from './logger.js';
+import { config, POLLER_VERSION } from './config.js';
+import { logger, setLogContext } from './logger.js';
 import { pollMessages, deleteMessage, } from './sqs-poller.js';
 import { spawnClaudeCode, isAtCapacity, getActiveProcessCount, killAllActiveProcesses, killZombieForThread } from './claude-spawner.js';
 import { sendSlackError, sendSlackMessage, addReaction, getUserInfo, startTypingIndicator } from './slack-client.js';
@@ -8,9 +8,9 @@ import { acquireSessionLock, releaseSessionLock, updateSessionId } from './sessi
 import { getBrainPath, ensureDirectories, ensureBaseBrain, pushBrainChanges } from './brain-manager.js';
 import { cleanupOrphanWorktreesForAllBrains, isWorktreeIsolationEnabled } from './worktree-manager.js';
 import { postMaintenanceReports } from './maintenance-reporter.js';
-import { initAuth, stopRefresh } from './auth-provider.js';
+import { initAuth, stopRefresh, getPollerId } from './auth-provider.js';
 import { registerBrain, startMaintenanceLoop, stopMaintenanceLoop } from './maintenance-cron.js';
-import { startEventQueue, stopEventQueue, flush as flushEventQueue, emitEvent } from './event-queue.js';
+import { startEventQueue, stopEventQueue, flush as flushEventQueue, emitEvent, emitError } from './event-queue.js';
 import { startMetricsCron, stopMetricsCron } from './metrics/scheduler.js';
 import { writeMessage, pickNextMessage, markProcessed, markFailed, hasUnprocessed } from './inbox-manager.js';
 import { Cron } from 'croner';
@@ -210,6 +210,11 @@ async function runInboxLoop(threadId, kbPath, queueMessage, sessionLog) {
                             duration_api_ms: result.metrics.duration_api_ms,
                             num_turns: result.metrics.num_turns,
                             model: result.metrics.model,
+                            // Which config layer actually chose the `--model` flag
+                            // (settings.json / poller / workspace / channel / env-default)
+                            // — teamvibe.ai#235 PR2. Distinct from `model` above, which is
+                            // Claude CLI's own report of the model it used.
+                            modelSource: result.modelSource,
                         });
                     }
                     if (queueMessage.teamvibe.brain?.brainId) {
@@ -533,14 +538,44 @@ async function shutdown(signal, exitCode = 0) {
     process.exit(exitCode);
 }
 export async function startPoller() {
-    logger.info('TeamVibe Poller starting...');
+    logger.info(`TeamVibe Poller v${POLLER_VERSION} starting...`);
     logger.info(`   Max concurrent: ${config.MAX_CONCURRENT_SESSIONS}`);
     logger.info(`   Brains path: ${config.BRAINS_PATH}`);
     process.on('SIGINT', () => shutdown('SIGINT'));
     process.on('SIGTERM', () => shutdown('SIGTERM'));
+    // Last-resort handlers so a hard crash produces one tagged ERROR line (+ a
+    // best-effort event flush) instead of an untagged default Node stack trace —
+    // these are exactly the failures that never reach /events on their own.
+    process.on('uncaughtException', (err) => {
+        const detail = err instanceof Error ? (err.stack ?? err.message) : String(err);
+        logger.error(`Uncaught exception, shutting down: ${detail}`);
+        emitError('session', `Uncaught exception: ${err instanceof Error ? err.message : String(err)}`, {
+            severity: 'error',
+        });
+        // The only invariant that matters in an undefined process state is that we
+        // actually exit. A stuck flush (e.g. the hung platform connection we want to
+        // report) must never block termination, so time-bound the best-effort flush.
+        const boundedFlush = Promise.race([
+            flushEventQueue(),
+            new Promise((resolve) => setTimeout(resolve, 2000)),
+        ]);
+        void boundedFlush.finally(() => process.exit(1));
+    });
+    process.on('unhandledRejection', (reason) => {
+        const detail = reason instanceof Error ? (reason.stack ?? reason.message) : String(reason);
+        logger.error(`Unhandled promise rejection: ${detail}`);
+        emitError('session', `Unhandled rejection: ${reason instanceof Error ? reason.message : String(reason)}`, {
+            severity: 'error',
+        });
+    });
     // Token-based auth: fetch credentials before starting
     if (config.TEAMVIBE_API_URL && config.TEAMVIBE_POLLER_TOKEN) {
         await initAuth(config.TEAMVIBE_API_URL, config.TEAMVIBE_POLLER_TOKEN);
+        const pollerId = getPollerId();
+        if (pollerId) {
+            setLogContext({ pollerId });
+            logger.info(`   Poller ID: ${pollerId}`);
+        }
     }
     else {
         logger.info(`   Queue: ${config.SQS_QUEUE_URL}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teamvibe/poller",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "type": "module",
   "main": "./dist/index.js",
   "bin": {