@teamvibe/poller 0.7.2 → 0.8.1

package/dist/auto-update.js

@@ -72,10 +72,17 @@ export async function checkForUpdate() {
         logger.info(`[AutoUpdate] Already on latest version (${POLLER_VERSION})`);
         return false;
     }
-    // Check if update type is within policy
-    const policyAllows = config.AUTO_UPDATE_POLICY === 'minor'
-        ? updateType === 'patch' || updateType === 'minor'
-        : updateType === 'patch'; // policy === 'patch'
+    // Check if update type is within policy. Explicit 'off' branch (tv#312):
+    // startAutoUpdateCron() never schedules this job at all when policy is
+    // 'off', so this path is currently unreachable in practice — kept
+    // explicit so a future caller of checkForUpdate() outside the cron
+    // (manual trigger, control message) can't silently apply patch updates
+    // to a poller configured not to auto-update.
+    const policyAllows = config.AUTO_UPDATE_POLICY === 'off'
+        ? false
+        : config.AUTO_UPDATE_POLICY === 'minor'
+            ? updateType === 'patch' || updateType === 'minor'
+            : updateType === 'patch'; // policy === 'patch'
     if (!policyAllows) {
         logger.info(`[AutoUpdate] ${updateType} update available (${POLLER_VERSION} → ${latestVersion}) but policy is "${config.AUTO_UPDATE_POLICY}", skipping`);
         return false;

package/dist/claude-spawner.d.ts

@@ -212,6 +212,7 @@ export interface SpawnStdinPlan {
 export declare function buildSpawnStdinPlan(prompt: string, inlineImages: TeamVibeQueueMessage['inlineImages'], now?: number): SpawnStdinPlan;
 export declare function extractAssistantText(event: any): string | undefined;
 export declare function assistantCalledTool(event: any, toolName: string): boolean;
+export declare function resolveTypingStatus(event: any, assistantText?: string): string | null;
 /**
  * Decides whether a spawn attempt should report its session ID back to the
  * caller (poller.ts) for persistence to DynamoDB via updateSessionId().

package/dist/claude-spawner.js

@@ -699,6 +699,50 @@ export function assistantCalledTool(event, toolName) {
     }
     return event.message.content.some((c) => c?.type === 'tool_use' && c.name === toolName);
 }
+// Status text is a one-line UI label, not a chat message — cap it well short
+// of a full sentence.
+const TYPING_STATUS_MAX_LEN = 100;
+// tv#369: decide what the typing indicator should show for a given
+// stream-json event. Prefers Claude's own narration text over a generic
+// placeholder — surfaces the same "what I'm doing / found" signal the CLI's
+// own transcript view already shows. Falls back to a per-tool canned status
+// (tv#291) when the assistant event carries a tool_use block but no
+// narration text, and to 'Thinking...' when neither is present. Reads
+// tool_use blocks from `event.message.content[]` rather than a top-level
+// `event.type === 'tool_use'` check — see assistantCalledTool's comment
+// above for why the latter never matches the real stream shape.
+//
+// `assistantText`, when passed, is the caller's already-extracted
+// extractAssistantText(event) result (the stdout handler computes it a few
+// lines above for the end-of-turn guard) — avoids re-parsing the same event
+// twice per line. Falls back to extracting it internally so the function
+// stays a self-contained, directly-testable unit.
+export function resolveTypingStatus(event, assistantText) {
+    if (event?.type !== 'assistant' || !Array.isArray(event.message?.content)) {
+        return null;
+    }
+    // The caller clears the indicator when this tool sends a reply. Do not
+    // restore a status from that same event, even if it also contains narration.
+    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.
+        const oneLine = text.replace(/\s+/g, ' ').trim();
+        return oneLine.length > TYPING_STATUS_MAX_LEN
+            ? oneLine.slice(0, TYPING_STATUS_MAX_LEN - 1) + '…'
+            : oneLine;
+    }
+    for (const block of event.message.content) {
+        if (block?.type !== 'tool_use' || typeof block.name !== 'string')
+            continue;
+        const status = getStatusForTool(block.name);
+        if (status)
+            return status;
+    }
+    return 'Thinking...';
+}
 async function runClaudeCode(msg, sessionLog, cwd, brainPath, sessionId, isFirstMessage = true, lastMessageTs, onMessageSent, typingIndicator) {
     const slackContext = msg.response_context.slack;
     const isCronMessage = msg.source === 'cron';
@@ -1004,18 +1048,11 @@ async function runClaudeCode(msg, sessionLog, cwd, brainPath, sessionId, isFirst
                             scheduleProgressNotifications(progressNotificationMarks(minutes));
                         }
                     }
-                    // Auto-update typing indicator status based on tool usage
+                    // Auto-update typing indicator status based on tool usage (tv#369, tv#291)
                     if (typingIndicator) {
-                        if (event.type === 'tool_use' && event.name) {
-                            const status = getStatusForTool(event.name);
-                            if (status !== null && status !== '') {
-                                typingIndicator.updateStatus(status);
-                            }
-                            // When status is '' (e.g. set_status tool), don't override — Claude is managing it
-                        }
-                        else if (event.type === 'assistant') {
-                            // Reset to "Thinking..." when Claude is reasoning between tool calls
-                            typingIndicator.updateStatus('Thinking...');
+                        const status = resolveTypingStatus(event, assistantText);
+                        if (status) {
+                            typingIndicator.updateStatus(status);
                         }
                     }
                 }

package/dist/config.js

@@ -65,8 +65,12 @@ const configSchema = z.object({
     POLLER_TZ: z.string().optional(),
     MAINTENANCE_CRON: z.string().default('30 3 * * *'), // Daily at 03:30 in POLLER_TZ (or host TZ)
     MAINTENANCE_ENABLED: z.string().default('true').transform((v) => v.toLowerCase() === 'true'),
-    // Auto-update settings
-    AUTO_UPDATE_POLICY: z.enum(['patch', 'minor', 'off']).default('patch'),
+    // Auto-update settings — defaults to 'off': most pollers run as pinned
+    // Railway container images (see Dockerfile), where an in-process
+    // `npm install -g` update can't survive the next redeploy anyway. Set
+    // explicitly (e.g. AUTO_UPDATE_POLICY=patch) for bare-metal/VM installs
+    // that actually benefit from self-updating.
+    AUTO_UPDATE_POLICY: z.enum(['patch', 'minor', 'off']).default('off'),
     AUTO_UPDATE_SCHEDULE: z.string().default('03:00'), // HH:MM in UTC — daily check time
     // Inbox watcher (teamvibe.ai#242): fs.watch()'s .inbox/ per tracked brain so a
     // file dropped while no session is running (e.g. a background-task result)

package/dist/poller.js

@@ -219,6 +219,14 @@ export function describeFailureReason(killedByPoller, exitCode) {
 // 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';
+// tv#358 (revised): the sentinel agents emit and the guard matches is
+// unchanged — still the exact ALL_CAPS literal above, 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
+// jarring when it does surface. Swap it for a quieter display token
+// wherever it appears in text that's actually being delivered.
+const END_OF_TURN_SENTINEL_DISPLAY = '[silent]';
 export function endOfTurnFallbackText(hasSlackContext, result) {
     if (!hasSlackContext || !result.success || result.sawSendMessageCall) {
         return undefined;
@@ -227,7 +235,7 @@ export function endOfTurnFallbackText(hasSlackContext, result) {
     if (!text || text === END_OF_TURN_NO_FURTHER_RESPONSE_SENTINEL) {
         return undefined;
     }
-    return text;
+    return text.split(END_OF_TURN_NO_FURTHER_RESPONSE_SENTINEL).join(END_OF_TURN_SENTINEL_DISPLAY);
 }
 export async function runInboxLoop(threadId, kbPath, queueMessage, sessionLog) {
     if (activeLoops.has(threadId)) {