@teamvibe/poller 0.8.1 → 0.8.2-rc.2

package/dist/auth-provider.d.ts

@@ -9,6 +9,12 @@ interface AuthConfig {
     sessionsTable: string;
     region: string;
 }
+export declare class AuthHttpError extends Error {
+    readonly status: number;
+    constructor(status: number, _body?: string);
+}
+export declare class StartupConfigurationError extends Error {
+}
 export declare function initAuth(apiUrl: string, token: string): Promise<void>;
 export declare function getCredentials(): AuthCredentials;
 export declare function getAuthConfig(): AuthConfig;

package/dist/auth-provider.js

@@ -1,6 +1,17 @@
-import { POLLER_VERSION } from './config.js';
+import { config, POLLER_VERSION } from './config.js';
 import { logger } from './logger.js';
 import { emitError } from './event-queue.js';
+import { getBaseBrainCommitSha } from './base-brain-metadata.js';
+export class AuthHttpError extends Error {
+    status;
+    constructor(status, _body) {
+        super(`Auth failed (${status})`);
+        this.status = status;
+        this.name = 'AuthHttpError';
+    }
+}
+export class StartupConfigurationError extends Error {
+}
 let currentCredentials = null;
 let currentConfig = null;
 let currentPollerId = null;
@@ -13,13 +24,16 @@ const REFRESH_INTERVAL_MS = 50 * 60 * 1000; // 50 minutes (before 1hr expiry)
 const HEARTBEAT_INTERVAL_MS = 60 * 1000; // 1 minute
 async function sendHeartbeat(apiUrl, token, version) {
     try {
+        const baseBrainSha = await getBaseBrainCommitSha(config.BASE_BRAIN_PATH);
+        if (!baseBrainSha)
+            logger.warn('[Heartbeat] Could not read base-brain HEAD for pin readback');
         const response = await fetch(`${apiUrl}/heartbeat`, {
             method: 'POST',
             headers: {
                 Authorization: `Bearer ${token}`,
                 'Content-Type': 'application/json',
             },
-            body: JSON.stringify({ version }),
+            body: JSON.stringify({ version, baseBrainSha, baseBrainBranch: config.BASE_BRAIN_BRANCH }),
         });
         if (!response.ok) {
             logger.warn(`Heartbeat failed (${response.status})`);
@@ -31,25 +45,56 @@ async function sendHeartbeat(apiUrl, token, version) {
         emitError('auth', `Heartbeat error: ${error instanceof Error ? error.message : String(error)}`, { severity: 'warn' });
     }
 }
-async function fetchCredentials(apiUrl, token) {
+async function fetchCredentials(apiUrl, token, signal) {
     const response = await fetch(`${apiUrl}/auth`, {
         method: 'POST',
+        signal,
         headers: {
             Authorization: `Bearer ${token}`,
             'Content-Type': 'application/json',
         },
     });
     if (!response.ok) {
-        const body = await response.text();
-        throw new Error(`Auth failed (${response.status}): ${body}`);
+        throw new AuthHttpError(response.status);
+    }
+    try {
+        return await response.json();
     }
-    return response.json();
+    catch {
+        throw new StartupConfigurationError('Auth response is not valid JSON');
+    }
+}
+function validateStartupAuthResponse(auth) {
+    const value = auth;
+    const authRecord = value;
+    const credentials = authRecord?.credentials;
+    const authConfig = authRecord?.config;
+    if (typeof authRecord?.pollerId !== 'string' || !authRecord.pollerId ||
+        typeof credentials?.accessKeyId !== 'string' || !credentials.accessKeyId ||
+        typeof credentials?.secretAccessKey !== 'string' || !credentials.secretAccessKey ||
+        typeof credentials?.sessionToken !== 'string' || !credentials.sessionToken ||
+        typeof credentials?.expiration !== 'string' || !credentials.expiration ||
+        typeof authConfig?.sqsQueueUrl !== 'string' || !authConfig.sqsQueueUrl ||
+        typeof authConfig?.sessionsTable !== 'string' || !authConfig.sessionsTable ||
+        typeof authConfig?.region !== 'string' || !authConfig.region)
+        throw new StartupConfigurationError('Auth response is missing or has malformed credentials/config');
 }
 export async function initAuth(apiUrl, token) {
+    if (!token.trim())
+        throw new StartupConfigurationError('TEAMVIBE_POLLER_TOKEN is missing or empty');
+    try {
+        const url = new URL(apiUrl);
+        if (!['http:', 'https:'].includes(url.protocol))
+            throw new Error('unsupported protocol');
+    }
+    catch {
+        throw new StartupConfigurationError('TEAMVIBE_API_URL is malformed');
+    }
     logger.info('Authenticating with TeamVibe API...');
     storedApiUrl = apiUrl;
     storedToken = token;
-    const auth = await fetchCredentials(apiUrl, token);
+    const auth = await fetchCredentials(apiUrl, token, AbortSignal.timeout(15_000));
+    validateStartupAuthResponse(auth);
     currentCredentials = auth.credentials;
     currentConfig = auth.config;
     currentPollerId = auth.pollerId;

package/dist/base-brain-metadata.js

@@ -3,6 +3,7 @@ import { join } from 'path';
 import { execFile } from 'child_process';
 import { promisify } from 'util';
 const execFileAsync = promisify(execFile);
+const GIT_HEAD_TIMEOUT_MS = 2_000;
 /**
  * Read the current HEAD commit SHA of a git repo. Returns null on any error
  * (not a git repo, git missing, dir missing, etc.) so callers can attach a
@@ -10,7 +11,11 @@ const execFileAsync = promisify(execFile);
  */
 export async function getBaseBrainCommitSha(repoDir) {
     try {
-        const { stdout } = await execFileAsync('git', ['rev-parse', 'HEAD'], { cwd: repoDir });
+        const { stdout } = await execFileAsync('git', ['rev-parse', 'HEAD'], {
+            cwd: repoDir,
+            timeout: GIT_HEAD_TIMEOUT_MS,
+            killSignal: 'SIGKILL',
+        });
         const sha = stdout.trim();
         return sha || null;
     }

package/dist/brain-manager.js

@@ -6,6 +6,7 @@ import { join, basename } from 'path';
 import { config } from './config.js';
 import { logger } from './logger.js';
 import { emitError } from './event-queue.js';
+import { startupFailureDetail } from './startup-auth.js';
 const execAsync = promisify(exec);
 // Clean env for git commands:
 // - npm/npx sets GIT_ASKPASS which prevents credential helpers from working
@@ -257,7 +258,7 @@ async function updateBrainLocked(brainDir, brainId, branch) {
     catch (error) {
         // Pre-check itself failed (e.g. brainDir not a git repo). Fail-safe to skip;
         // the next iteration will retry.
-        const errorMessage = error instanceof Error ? error.message : String(error);
+        const errorMessage = startupFailureDetail(error, 'BaseBrain', [config.TEAMVIBE_POLLER_TOKEN ?? '', config.BASE_BRAIN_REPO]);
         logger.warn(`Brain ${brainId} pre-check failed, skipping update: ${errorMessage}`);
         return;
     }
@@ -271,7 +272,7 @@ async function updateBrainLocked(brainDir, brainId, branch) {
         logger.info(`Brain ${brainId} updated successfully`);
     }
     catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
+        const errorMessage = startupFailureDetail(error, 'BaseBrain', [config.TEAMVIBE_POLLER_TOKEN ?? '', config.BASE_BRAIN_REPO]);
         logger.error(`Failed to update brain ${brainId}: ${errorMessage}`);
         emitError('brain', `Failed to update brain ${brainId}: ${errorMessage}`, { context: { brainId, brainDir } });
     }
@@ -283,7 +284,7 @@ async function updateBrainLocked(brainDir, brainId, branch) {
 export async function ensureBaseBrain() {
     const brainDir = config.BASE_BRAIN_PATH;
     if (!existsSync(brainDir)) {
-        logger.info(`Cloning base brain from ${config.BASE_BRAIN_REPO} (branch: ${config.BASE_BRAIN_BRANCH})...`);
+        logger.info(`Cloning base brain (branch: ${config.BASE_BRAIN_BRANCH})...`);
         await gitExec(`git clone --recurse-submodules --branch ${config.BASE_BRAIN_BRANCH} ${config.BASE_BRAIN_REPO} ${brainDir}`);
         lastUpdateTimes.set('__base_brain__', Date.now());
         logger.info('Base brain cloned successfully');

package/dist/claude-spawner.js

@@ -702,22 +702,13 @@ export function assistantCalledTool(event, 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) {
+function oneLineStatus(text) {
+    const oneLine = text.replace(/\s+/g, ' ').trim();
+    return oneLine.length > TYPING_STATUS_MAX_LEN
+        ? oneLine.slice(0, TYPING_STATUS_MAX_LEN - 1) + '…'
+        : oneLine;
+}
+function resolveTypingStatusDetail(event, assistantText) {
     if (event?.type !== 'assistant' || !Array.isArray(event.message?.content)) {
         return null;
     }
@@ -729,19 +720,22 @@ export function resolveTypingStatus(event, assistantText) {
     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;
+        return { text: oneLineStatus(text), source: 'comment' };
     }
     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;
+        if (status) {
+            const safeToolName = /^(?:Bash|Read|Edit|Write|WebFetch|WebSearch|Grep|Glob|Agent)$/.test(block.name)
+                ? block.name : 'other';
+            return { text: oneLineStatus(status), source: `tool:${safeToolName}` };
+        }
     }
-    return 'Thinking...';
+    return { text: 'Thinking...', source: 'default' };
+}
+export function resolveTypingStatus(event, assistantText) {
+    return resolveTypingStatusDetail(event, assistantText)?.text ?? null;
 }
 async function runClaudeCode(msg, sessionLog, cwd, brainPath, sessionId, isFirstMessage = true, lastMessageTs, onMessageSent, typingIndicator) {
     const slackContext = msg.response_context.slack;
@@ -1050,9 +1044,9 @@ async function runClaudeCode(msg, sessionLog, cwd, brainPath, sessionId, isFirst
                     }
                     // Auto-update typing indicator status based on tool usage (tv#369, tv#291)
                     if (typingIndicator) {
-                        const status = resolveTypingStatus(event, assistantText);
+                        const status = resolveTypingStatusDetail(event, assistantText);
                         if (status) {
-                            typingIndicator.updateStatus(status);
+                            typingIndicator.updateStatus(status.text, status.source);
                         }
                     }
                 }
@@ -1143,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/maintenance-reporter.d.ts

@@ -1,3 +1,11 @@
+/** Best-effort runtime identity, sampled when each report is posted. */
+export declare function collectReportProvenance(brainPath: string): Promise<{
+    pollerId: string | null;
+    pollerVersion: string;
+    baseBrainSha: string | null;
+    baseBrainBranch: string;
+    brainSha: string | null;
+}>;
 /**
  * Scan for JSON maintenance reports in the brain's reports/ directory
  * and POST each to the /events endpoint. Fire-and-forget — never throws.

package/dist/maintenance-reporter.js

@@ -3,10 +3,29 @@ import { join } from 'path';
 import { execFile } from 'child_process';
 import { promisify } from 'util';
 import { config, POLLER_VERSION } from './config.js';
+import { getPollerId } from './auth-provider.js';
 import { logger } from './logger.js';
 import { emitError } from './event-queue.js';
 import { getBaseBrainCommitSha, getBaseBrainAgeHours, } from './base-brain-metadata.js';
 const execFileAsync = promisify(execFile);
+/** Best-effort runtime identity, sampled when each report is posted. */
+export async function collectReportProvenance(brainPath) {
+    const [baseBrainSha, brainSha] = await Promise.all([
+        getBaseBrainCommitSha(config.BASE_BRAIN_PATH),
+        getBaseBrainCommitSha(brainPath),
+    ]);
+    if (!baseBrainSha)
+        logger.warn('[MaintenanceReporter] Could not read base-brain HEAD for report provenance');
+    if (!brainSha)
+        logger.warn('[MaintenanceReporter] Could not read channel-brain HEAD for report provenance');
+    return {
+        pollerId: getPollerId(),
+        pollerVersion: POLLER_VERSION,
+        baseBrainSha,
+        baseBrainBranch: config.BASE_BRAIN_BRANCH,
+        brainSha,
+    };
+}
 const OPERATION_TO_EVENT_TYPE = {
     consolidation: 'maintenance.consolidation',
     reflection: 'maintenance.reflection',
@@ -131,7 +150,7 @@ export async function postMaintenanceReports(brainPath, channelId) {
                     const payload = {
                         eventType,
                         channelId,
-                        pollerVersion: POLLER_VERSION,
+                        ...(await collectReportProvenance(brainPath)),
                         baseBrainCommitSha,
                         baseBrainAgeHours,
                         metadata: report,

package/dist/poller.js

@@ -9,6 +9,7 @@ import { getBrainPath, ensureDirectories, ensureBaseBrain, pushBrainChanges } fr
 import { cleanupOrphanWorktreesForAllBrains, isWorktreeIsolationEnabled } from './worktree-manager.js';
 import { postMaintenanceReports } from './maintenance-reporter.js';
 import { initAuth, stopRefresh, getPollerId } from './auth-provider.js';
+import { retryStartupAuth, retryStartupOperation, startupFailureDetail } from './startup-auth.js';
 import { registerBrain, startMaintenanceLoop, stopMaintenanceLoop } from './maintenance-cron.js';
 import { bootstrapTrackedBrains } from './brains-bootstrap.js';
 import { startEventQueue, stopEventQueue, flush as flushEventQueue, emitEvent, emitError } from './event-queue.js';
@@ -870,8 +871,9 @@ export async function startPoller() {
     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'));
+    const startupAbort = new AbortController();
+    process.on('SIGINT', () => { startupAbort.abort(); void shutdown('SIGINT'); });
+    process.on('SIGTERM', () => { startupAbort.abort(); void 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.
@@ -899,7 +901,15 @@ export async function startPoller() {
     });
     // 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);
+        try {
+            const ready = await retryStartupAuth(() => initAuth(config.TEAMVIBE_API_URL, config.TEAMVIBE_POLLER_TOKEN), startupAbort.signal, logger, Math.random, [config.TEAMVIBE_POLLER_TOKEN ?? '', config.BASE_BRAIN_REPO]);
+            if (!ready)
+                return;
+        }
+        catch (error) {
+            logger.error(`Startup authentication failed permanently: ${startupFailureDetail(error, 'StartupAuth', [config.TEAMVIBE_POLLER_TOKEN ?? '', config.BASE_BRAIN_REPO])}`);
+            process.exit(1);
+        }
         const pollerId = getPollerId();
         if (pollerId) {
             setLogContext({ pollerId });
@@ -910,9 +920,19 @@ export async function startPoller() {
         logger.info(`   Queue: ${config.SQS_QUEUE_URL}`);
         logger.info(`   Sessions table: ${config.SESSIONS_TABLE}`);
     }
+    if (startupAbort.signal.aborted)
+        return;
     startEventQueue();
     await ensureDirectories();
-    await ensureBaseBrain();
+    try {
+        const ready = await retryStartupOperation('BaseBrain', ensureBaseBrain, startupAbort.signal, logger, Math.random, [config.TEAMVIBE_POLLER_TOKEN ?? '', config.BASE_BRAIN_REPO]);
+        if (!ready)
+            return;
+    }
+    catch (error) {
+        logger.error(`Startup base brain failed permanently: ${startupFailureDetail(error, 'BaseBrain', [config.TEAMVIBE_POLLER_TOKEN ?? '', config.BASE_BRAIN_REPO])}`);
+        process.exit(1);
+    }
     reconcileBgTasksOnBoot();
     if (config.IDLE_RESTART_ENABLED) {
         // Defaults off (tv#317 follow-up, DevGuru review): a silent disabled gate and an

package/dist/slack-client.d.ts

@@ -7,11 +7,13 @@ export declare function sendSlackMessage(msg: TeamVibeQueueMessage, text: string
 export declare function sendSlackError(msg: TeamVibeQueueMessage, error: string): Promise<void>;
 export declare function addReaction(msg: TeamVibeQueueMessage, emoji: string): Promise<void>;
 export declare function setThreadStatus(msg: TeamVibeQueueMessage, status: string): Promise<void>;
+type TypingStatusSource = 'comment' | 'default' | `tool:${string}`;
 export interface TypingIndicator {
     /** Update the displayed status text */
-    updateStatus: (newStatus: string) => void;
+    updateStatus: (newStatus: string, source?: TypingStatusSource) => void;
     /** Stop the typing indicator and clear the status */
     stop: () => void;
 }
 export declare function startTypingIndicator(msg: TeamVibeQueueMessage, statusText?: string): TypingIndicator;
 export declare function removeReaction(msg: TeamVibeQueueMessage, emoji: string): Promise<void>;
+export {};

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) {
@@ -94,22 +97,87 @@ export async function setThreadStatus(msg, status) {
         return;
     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,
+            ...payload,
+            ...(safeStatus ? { loading_messages: [truncateLoadingMessage(safeStatus)] } : {}),
         });
     }
     catch (error) {
-        logger.warn(`Failed to set thread status: ${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' });
     }
 }
-export function startTypingIndicator(msg, statusText = 'is thinking...') {
+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)
+            logger.info('[Typing] status cleared');
+        else
+            logger.info(`[Typing] status -> ${source} (${status.length} chars)`);
+    };
     // Set initial status
+    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 () => {
@@ -125,14 +193,39 @@ export function startTypingIndicator(msg, statusText = 'is thinking...') {
         }
     }, 3000);
     return {
-        updateStatus: (newStatus) => {
-            if (newStatus !== currentStatus) {
-                currentStatus = newStatus;
-                setThreadStatus(msg, currentStatus);
+        updateStatus: (newStatus, source = 'comment') => {
+            if (stopped)
+                return;
+            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');
             setThreadStatus(msg, '');
         },
     };

package/dist/startup-auth.d.ts

@@ -0,0 +1,15 @@
+export interface StartupAuthLogger {
+    warn(message: string): void;
+    error(message: string): void;
+}
+export declare class UnknownStartupFailureError extends Error {
+    readonly attempts: number;
+    constructor(attempts: number);
+}
+/** The only formatter used for startup retry and terminal failure logs. */
+export declare function redactStartupText(text: string, configuredTokens?: readonly string[]): string;
+export declare function startupFailureDetail(error: unknown, operation: string, configuredTokens?: readonly string[]): string;
+export declare function isPermanentStartupFailure(error: unknown): boolean;
+/** Returns false when shutdown cancels startup. Permanent errors propagate to the caller. */
+export declare function retryStartupOperation(operation: string, run: () => Promise<void>, signal: AbortSignal, log: StartupAuthLogger, random?: () => number, configuredTokens?: readonly string[]): Promise<boolean>;
+export declare function retryStartupAuth(authenticate: () => Promise<void>, signal: AbortSignal, log: StartupAuthLogger, random?: () => number, configuredTokens?: readonly string[]): Promise<boolean>;

package/dist/startup-auth.js

@@ -0,0 +1,137 @@
+import { AuthHttpError, StartupConfigurationError } from './auth-provider.js';
+export class UnknownStartupFailureError extends Error {
+    attempts;
+    constructor(attempts) {
+        super(`unclassified startup failure after ${attempts} attempts`);
+        this.attempts = attempts;
+        this.name = 'UnknownStartupFailureError';
+    }
+}
+const NETWORK_CODES = new Set([
+    'EAI_AGAIN', 'ENOTFOUND', 'ECONNREFUSED', 'ECONNRESET', 'ETIMEDOUT',
+    'EHOSTUNREACH', 'ENETUNREACH', 'UND_ERR_CONNECT_TIMEOUT', 'UND_ERR_HEADERS_TIMEOUT',
+]);
+function isTransient(error) {
+    if (error instanceof AuthHttpError)
+        return error.status === 429 || error.status >= 500;
+    if (error instanceof StartupConfigurationError)
+        return false;
+    if (!(error instanceof Error))
+        return false;
+    if (error.name === 'AbortError' || error.name === 'TimeoutError')
+        return true;
+    if (error instanceof TypeError && /fetch failed|network|timeout/i.test(error.message))
+        return true;
+    if (/could not resolve host|could not resolve hostname|temporary failure in name resolution|failed to connect|connection (timed out|refused|reset)|network is unreachable|(?:HTTP|response|returned error:?)\s*(?:429|5\d\d)\b/i.test(error.message))
+        return true;
+    let cause = error;
+    for (let depth = 0; depth < 4 && cause && typeof cause === 'object'; depth++) {
+        const code = cause.code;
+        if (typeof code === 'string' && NETWORK_CODES.has(code))
+            return true;
+        cause = cause.cause;
+    }
+    return false;
+}
+/** The only formatter used for startup retry and terminal failure logs. */
+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]');
+    for (const token of configuredTokens) {
+        if (token)
+            safe = safe.split(token).join('[REDACTED]');
+    }
+    return safe;
+}
+export function startupFailureDetail(error, operation, configuredTokens = []) {
+    let detail;
+    if (error instanceof AuthHttpError)
+        detail = `HTTP ${error.status}`;
+    else if (error instanceof StartupConfigurationError)
+        detail = 'invalid startup configuration';
+    else if (error instanceof UnknownStartupFailureError)
+        detail = error.message;
+    else if (operation === 'BaseBrain') {
+        const code = error && typeof error === 'object' ? error.code : undefined;
+        const exit = typeof code === 'number' ? code : 'unknown';
+        const message = error instanceof Error ? error.message : '';
+        const category = /could not resolve|name resolution|ENOTFOUND|EAI_AGAIN/i.test(message) ? 'DNS failure'
+            : /timed out|timeout|ETIMEDOUT/i.test(message) ? 'connection timeout'
+                : /failed to connect|connection refused|ECONNREFUSED/i.test(message) ? 'connection failure'
+                    : /authentication failed|permission denied|403|401/i.test(message) ? 'authentication failure'
+                        : 'git failure';
+        detail = `${category} (exit ${exit})`;
+    }
+    else {
+        let code = error;
+        for (let depth = 0; depth < 4 && code && typeof code === 'object'; depth++) {
+            const value = code.code;
+            if (typeof value === 'string' && NETWORK_CODES.has(value)) {
+                detail = value;
+                break;
+            }
+            code = code.cause;
+        }
+        detail ??= error instanceof TypeError && /fetch failed/i.test(error.message) ? 'fetch failed'
+            : error instanceof Error && ['AbortError', 'TimeoutError'].includes(error.name) ? error.name
+                : 'unclassified error';
+    }
+    return redactStartupText(detail ?? 'unclassified error', configuredTokens);
+}
+export function isPermanentStartupFailure(error) {
+    return error instanceof StartupConfigurationError ||
+        (error instanceof AuthHttpError && error.status !== 429 && error.status < 500);
+}
+function waitForBackoff(ms, signal) {
+    if (signal.aborted)
+        return Promise.resolve(false);
+    return new Promise((resolve) => {
+        const finish = (ready) => {
+            clearTimeout(timer);
+            signal.removeEventListener('abort', onAbort);
+            resolve(ready);
+        };
+        const onAbort = () => finish(false);
+        const timer = setTimeout(() => finish(true), ms);
+        signal.addEventListener('abort', onAbort, { once: true });
+        if (signal.aborted)
+            onAbort();
+    });
+}
+/** Returns false when shutdown cancels startup. Permanent errors propagate to the caller. */
+export async function retryStartupOperation(operation, run, signal, log, random = Math.random, configuredTokens = []) {
+    let attempt = 0;
+    while (!signal.aborted) {
+        attempt++;
+        try {
+            await run();
+            return !signal.aborted;
+        }
+        catch (error) {
+            if (signal.aborted)
+                return false;
+            if (isPermanentStartupFailure(error))
+                throw error;
+            const transient = isTransient(error);
+            if (!transient && attempt >= 5) {
+                log.error(`[${operation}] attempt ${attempt} failed: ${startupFailureDetail(error, operation, configuredTokens)}; unclassified failure limit reached`);
+                throw new UnknownStartupFailureError(attempt);
+            }
+            const baseMs = Math.min(1000 * 2 ** Math.min(attempt - 1, 6), 60_000);
+            const delayMs = Math.min(60_000, Math.round(baseMs * (1 + 0.2 * random())));
+            const message = `[${operation}] attempt ${attempt} failed: ${startupFailureDetail(error, operation, configuredTokens)}; retrying in ${delayMs}ms`;
+            if (transient)
+                log.warn(message);
+            else
+                log.error(message);
+            if (!await waitForBackoff(delayMs, signal))
+                return false;
+        }
+    }
+    return false;
+}
+export function retryStartupAuth(authenticate, signal, log, random = Math.random, configuredTokens = []) {
+    return retryStartupOperation('StartupAuth', authenticate, signal, log, random, configuredTokens);
+}

package/npm-shrinkwrap.json

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