@teamvibe/poller 0.5.3 → 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/poller.js

@@ -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) {

package/package.json

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