@teamvibe/poller 0.8.2-rc.1 → 0.8.2-rc.2

package/dist/claude-spawner.js

@@ -1137,7 +1137,7 @@ async function runClaudeCode(msg, sessionLog, cwd, brainPath, sessionId, isFirst
                 });
                 // Surface a visible status so the user isn't left with a stale/generic
                 // indicator during long silent stretches (e.g. context compaction).
-                typingIndicator?.updateStatus('Still working on a long response...');
+                typingIndicator?.updateStatus('Still working on a long response...', 'default');
                 idleWarned = true;
             }
         }, 30000); // Check every 30 seconds

package/dist/config.d.ts

@@ -18,6 +18,7 @@ declare const configSchema: z.ZodObject<{
     IDLE_WATCHDOG_COMPACTION_GRACE_MS: z.ZodDefault<z.ZodNumber>;
     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>;
     TEAMVIBE_DATA_DIR: z.ZodDefault<z.ZodString>;
     BRAINS_PATH: z.ZodDefault<z.ZodString>;
     DEFAULT_BRAIN_PATH: z.ZodDefault<z.ZodString>;
@@ -60,6 +61,7 @@ declare const configSchema: z.ZodObject<{
     IDLE_WATCHDOG_COMPACTION_GRACE_MS: number;
     NETWORK_ERROR_KILL_MS: number;
     MAX_CONSECUTIVE_NET_FAILURES: number;
+    TYPING_COMMENT_MIN_HOLD_MS: number;
     TEAMVIBE_DATA_DIR: string;
     BRAINS_PATH: string;
     DEFAULT_BRAIN_PATH: string;
@@ -108,6 +110,7 @@ declare const configSchema: z.ZodObject<{
     IDLE_WATCHDOG_COMPACTION_GRACE_MS?: number | undefined;
     NETWORK_ERROR_KILL_MS?: number | undefined;
     MAX_CONSECUTIVE_NET_FAILURES?: number | undefined;
+    TYPING_COMMENT_MIN_HOLD_MS?: number | undefined;
     TEAMVIBE_DATA_DIR?: string | undefined;
     BRAINS_PATH?: string | undefined;
     DEFAULT_BRAIN_PATH?: string | undefined;
@@ -153,6 +156,7 @@ export declare const config: {
     IDLE_WATCHDOG_COMPACTION_GRACE_MS: number;
     NETWORK_ERROR_KILL_MS: number;
     MAX_CONSECUTIVE_NET_FAILURES: number;
+    TYPING_COMMENT_MIN_HOLD_MS: number;
     TEAMVIBE_DATA_DIR: string;
     BRAINS_PATH: string;
     DEFAULT_BRAIN_PATH: string;

package/dist/config.js

@@ -27,6 +27,7 @@ const configSchema = z.object({
     IDLE_WATCHDOG_COMPACTION_GRACE_MS: z.coerce.number().default(300000), // 5 minutes — fixed grace from compact_boundary arrival, not a large speculative ceiling (compact_boundary only proves compaction STARTED, never that it finishes in bounded time)
     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
     // Paths
     TEAMVIBE_DATA_DIR: z.string().default(DEFAULT_DATA_DIR),
     BRAINS_PATH: z.string().default(''),

package/dist/slack-client.js

@@ -1,10 +1,13 @@
 import { WebClient } from '@slack/web-api';
 import { logger } from './logger.js';
 import { emitError } from './event-queue.js';
+import { config } from './config.js';
 // Cache user info to avoid repeated API calls
 const userCache = new Map();
 // Per-token Slack client cache
 const slackClients = new Map();
+// Slack: "must be less than 51 characters [json-pointer:/loading_messages/0]"
+const SLACK_LOADING_MESSAGE_MAX = 50;
 function getSlackClient(botToken) {
     let client = slackClients.get(botToken);
     if (!client) {
@@ -95,25 +98,59 @@ export async function setThreadStatus(msg, status) {
     const { channel, thread_ts } = msg.response_context.slack;
     const slack = getSlackClient(msg.teamvibe.botToken);
     const safeStatus = neutralizeSlackMarkup(status);
+    const payload = {
+        channel_id: channel,
+        thread_ts,
+        status: safeStatus,
+    };
     try {
         await slack.apiCall('assistant.threads.setStatus', {
-            channel_id: channel,
-            thread_ts,
-            status: safeStatus,
-            ...(safeStatus ? { loading_messages: [safeStatus] } : {}),
+            ...payload,
+            ...(safeStatus ? { loading_messages: [truncateLoadingMessage(safeStatus)] } : {}),
         });
     }
-    catch {
+    catch (error) {
+        const messages = error?.data?.response_metadata?.messages;
+        const details = [error?.message, ...(Array.isArray(messages) ? messages : [])].join(' ');
+        if (safeStatus && error?.data?.error === 'invalid_arguments' && details.includes('loading_messages')) {
+            // API errors may echo request fields; never log the error or status.
+            logger.warn('Slack rejected loading messages; retrying thread status');
+            try {
+                await slack.apiCall('assistant.threads.setStatus', payload);
+                return;
+            }
+            catch {
+                emitError('slack', 'Failed to set thread status', { severity: 'warn' });
+                return;
+            }
+        }
         // 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' });
     }
 }
+function truncateLoadingMessage(text) {
+    // Treat escaped markup as whole tokens so truncation never leaves a partial entity.
+    const tokens = text.match(/&(?:lt|gt|amp);|[\s\S]/gu) ?? [];
+    if (text.length <= SLACK_LOADING_MESSAGE_MAX)
+        return text;
+    let result = '';
+    for (const token of tokens) {
+        if (result.length + token.length >= SLACK_LOADING_MESSAGE_MAX)
+            break;
+        result += token;
+    }
+    return result + '…';
+}
 function neutralizeSlackMarkup(text) {
     return text.replace(/[<>&]/g, (character) => ({ '<': '&lt;', '>': '&gt;', '&': '&amp;' })[character]);
 }
 export function startTypingIndicator(msg, statusText = 'Thinking...') {
     let currentStatus = statusText;
+    let currentSource = statusText === 'Thinking...' ? 'default' : 'comment';
+    let commentShownAt = currentSource === 'comment' ? Date.now() : 0;
+    let pendingCanned = null;
+    let holdTimer;
     let stopped = false;
     const logStatus = (status, source) => {
         if (!status)
@@ -122,8 +159,25 @@ export function startTypingIndicator(msg, statusText = 'Thinking...') {
             logger.info(`[Typing] status -> ${source} (${status.length} chars)`);
     };
     // Set initial status
-    logStatus(currentStatus, statusText === 'Thinking...' ? 'default' : 'comment');
+    logStatus(currentStatus, currentSource);
     setThreadStatus(msg, currentStatus);
+    const cancelHold = () => {
+        if (holdTimer !== undefined)
+            clearTimeout(holdTimer);
+        holdTimer = undefined;
+        pendingCanned = null;
+    };
+    const showStatus = (text, source) => {
+        const changed = text !== currentStatus;
+        currentStatus = text;
+        currentSource = text ? source : 'default';
+        if (text && source === 'comment')
+            commentShownAt = Date.now();
+        if (changed) {
+            logStatus(text, source);
+            setThreadStatus(msg, text);
+        }
+    };
     // Keepalive every 3 seconds (Slack clears after ~2 min timeout)
     let failures = 0;
     const interval = setInterval(async () => {
@@ -142,16 +196,33 @@ export function startTypingIndicator(msg, statusText = 'Thinking...') {
         updateStatus: (newStatus, source = 'comment') => {
             if (stopped)
                 return;
-            if (newStatus !== currentStatus) {
-                currentStatus = newStatus;
-                logStatus(currentStatus, source);
-                setThreadStatus(msg, currentStatus);
+            if (!newStatus || source === 'comment') {
+                cancelHold();
+                showStatus(newStatus, source);
+                return;
+            }
+            const remainingHold = config.TYPING_COMMENT_MIN_HOLD_MS - (Date.now() - commentShownAt);
+            if (currentSource === 'comment' && remainingHold > 0) {
+                pendingCanned = { text: newStatus, source };
+                if (holdTimer === undefined) {
+                    holdTimer = setTimeout(() => {
+                        holdTimer = undefined;
+                        const pending = pendingCanned;
+                        pendingCanned = null;
+                        if (!stopped && pending)
+                            showStatus(pending.text, pending.source);
+                    }, remainingHold);
+                }
+                return;
             }
+            cancelHold();
+            showStatus(newStatus, source);
         },
         stop: () => {
             if (stopped)
                 return;
             stopped = true;
+            cancelHold();
             clearInterval(interval);
             if (currentStatus)
                 logStatus('', 'default');

package/npm-shrinkwrap.json

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