@teamvibe/poller 0.1.67 → 0.1.68

package/dist/claude-spawner.d.ts

@@ -13,5 +13,10 @@ export declare function spawnClaudeCode(msg: TeamVibeQueueMessage, sessionLog: S
     newSessionId?: string;
 }>;
 export declare function getActiveProcessCount(): number;
+/**
+ * Kill a zombie process for a given thread ID.
+ * Returns true if a process was found and killed.
+ */
+export declare function killZombieForThread(threadId: string): boolean;
 export declare function isAtCapacity(): boolean;
 export declare function killAllActiveProcesses(): Promise<void>;

package/dist/claude-spawner.js

@@ -128,6 +128,14 @@ export function buildPrompt(msg, resumeHint) {
             : `Channel ${slack.channel}`;
         prompt += `**Channel:** ${channelType}\n`;
     }
+    // Inject human-readable timestamp from Slack message ts
+    if (msg.response_context.slack?.message_ts) {
+        const msgDate = new Date(parseFloat(msg.response_context.slack.message_ts) * 1000);
+        const dayOfWeek = msgDate.toLocaleDateString('en-US', { weekday: 'long', timeZone: 'UTC' });
+        const dateStr = msgDate.toISOString().slice(0, 10);
+        const timeStr = msgDate.toISOString().slice(11, 16);
+        prompt += `**Sent at:** ${dayOfWeek}, ${dateStr} ${timeStr} UTC\n`;
+    }
     prompt += `\n**Message:**\n${msg.text}`;
     if (msg.attachments.length > 0) {
         prompt += '\n\n**Attachments:**\n';
@@ -333,8 +341,9 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
             },
             stdio: ['pipe', 'pipe', 'pipe'],
         });
-        // Track active process
+        // Track active process by message ID and thread ID
         activeProcesses.set(msg.id, proc);
+        activeProcessesByThread.set(msg.thread_id, proc);
         proc.stdin?.write(prompt);
         proc.stdin?.end();
         let stdout = '';
@@ -342,6 +351,7 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
         let stdoutBuffer = '';
         let metrics;
         let lastActivityTime = Date.now();
+        let networkErrorStart = null; // timestamp when continuous network errors began
         proc.stdout.on('data', (data) => {
             const chunk = data.toString();
             stdout += chunk;
@@ -406,10 +416,21 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
                 }
             }
         });
+        const NETWORK_ERROR_PATTERNS = /ETIMEDOUT|ECONNRESET|ENOTFOUND|ECONNREFUSED|fetch failed|getaddrinfo/i;
         proc.stderr.on('data', (data) => {
             const chunk = data.toString();
             stderr += chunk;
             sessionLog.claude('stderr', chunk.trimEnd());
+            // Track continuous network errors for early kill
+            if (NETWORK_ERROR_PATTERNS.test(chunk)) {
+                if (networkErrorStart === null) {
+                    networkErrorStart = Date.now();
+                }
+            }
+            else {
+                // Non-network stderr output resets the counter
+                networkErrorStart = null;
+            }
         });
         let timedOut = false;
         const timeoutMinutes = Math.round(config.CLAUDE_TIMEOUT_MS / 60000);
@@ -427,6 +448,21 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
         let idleWarned = false;
         const idleWatchdog = setInterval(() => {
             const idleMs = Date.now() - lastActivityTime;
+            // Network error watchdog: kill faster if seeing sustained network errors with no productive stdout
+            if (networkErrorStart !== null) {
+                const networkErrorDuration = Date.now() - networkErrorStart;
+                if (networkErrorDuration > config.NETWORK_ERROR_KILL_MS) {
+                    const errorSec = Math.round(networkErrorDuration / 1000);
+                    logger.error(`Claude Code has sustained network errors for ${errorSec}s, killing process`);
+                    emitError('session', `Network errors for ${errorSec}s — killing process (likely network outage)`, {
+                        context: { channelId: msg.teamvibe.channelId, threadId: msg.thread_id },
+                        channelId: msg.teamvibe.channelId,
+                    });
+                    proc.kill('SIGTERM');
+                    setTimeout(() => proc.kill('SIGKILL'), 5000);
+                    return;
+                }
+            }
             if (idleMs > config.IDLE_WATCHDOG_KILL_MS) {
                 const idleMin = Math.round(idleMs / 60000);
                 logger.error(`Claude Code idle for ${idleMin} minutes, killing process`);
@@ -452,6 +488,7 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
             clearTimeout(timeout);
             clearInterval(idleWatchdog);
             activeProcesses.delete(msg.id);
+            activeProcessesByThread.delete(msg.thread_id);
             const result = {
                 success: code === 0,
                 output: stdout,
@@ -470,6 +507,7 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
             clearTimeout(timeout);
             clearInterval(idleWatchdog);
             activeProcesses.delete(msg.id);
+            activeProcessesByThread.delete(msg.thread_id);
             emitError('session', `Claude Code process spawn error: ${error.message}`, {
                 channelId: msg.teamvibe.channelId,
                 context: { threadId: msg.thread_id },
@@ -491,8 +529,15 @@ export async function spawnClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMe
         sessionLog.info('Resume failed, retrying as fresh session (session files may have been lost)');
         retryResult = await runClaudeCode(msg, sessionLog, cwd, sessionId, true, lastMessageTs, onMessageSent, typingIndicator);
     }
-    // If session ID is "already in use" (stale lock file), retry with a fresh session ID
+    // If session ID is "already in use" (stale lock file), kill any zombie and retry with fresh ID
     if (!retryResult.success && sessionId && retryResult.error?.includes('already in use')) {
+        // Kill zombie process for this thread if still alive
+        const killed = killZombieForThread(msg.thread_id);
+        if (killed) {
+            sessionLog.info('Killed zombie process before fresh session retry');
+            // Give the process a moment to fully exit and release lock files
+            await new Promise((resolve) => setTimeout(resolve, 2000));
+        }
         sessionLog.info('Session ID already in use (stale lock), retrying with fresh session ID');
         const { randomUUID } = await import('crypto');
         const freshId = randomUUID();
@@ -502,9 +547,30 @@ export async function spawnClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMe
     return retryResult;
 }
 const activeProcesses = new Map();
+const activeProcessesByThread = new Map();
 export function getActiveProcessCount() {
     return activeProcesses.size;
 }
+/**
+ * Kill a zombie process for a given thread ID.
+ * Returns true if a process was found and killed.
+ */
+export function killZombieForThread(threadId) {
+    const proc = activeProcessesByThread.get(threadId);
+    if (!proc || proc.exitCode !== null) {
+        activeProcessesByThread.delete(threadId);
+        return false;
+    }
+    logger.warn(`Killing zombie process for thread ${threadId} (pid: ${proc.pid})`);
+    emitError('session', `Killing zombie process for thread ${threadId}`, { severity: 'warn' });
+    proc.kill('SIGTERM');
+    setTimeout(() => {
+        if (proc.exitCode === null) {
+            proc.kill('SIGKILL');
+        }
+    }, 5000);
+    return true;
+}
 export function isAtCapacity() {
     return activeProcesses.size >= config.MAX_CONCURRENT_SESSIONS;
 }

package/dist/config.d.ts

@@ -15,6 +15,7 @@ declare const configSchema: z.ZodObject<{
     LOCK_RETRY_INTERVAL_MS: z.ZodDefault<z.ZodNumber>;
     IDLE_WATCHDOG_WARN_MS: z.ZodDefault<z.ZodNumber>;
     IDLE_WATCHDOG_KILL_MS: z.ZodDefault<z.ZodNumber>;
+    NETWORK_ERROR_KILL_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>;
@@ -41,6 +42,7 @@ declare const configSchema: z.ZodObject<{
     LOCK_RETRY_INTERVAL_MS: number;
     IDLE_WATCHDOG_WARN_MS: number;
     IDLE_WATCHDOG_KILL_MS: number;
+    NETWORK_ERROR_KILL_MS: number;
     TEAMVIBE_DATA_DIR: string;
     BRAINS_PATH: string;
     DEFAULT_BRAIN_PATH: string;
@@ -73,6 +75,7 @@ declare const configSchema: z.ZodObject<{
     LOCK_RETRY_INTERVAL_MS?: number | undefined;
     IDLE_WATCHDOG_WARN_MS?: number | undefined;
     IDLE_WATCHDOG_KILL_MS?: number | undefined;
+    NETWORK_ERROR_KILL_MS?: number | undefined;
     TEAMVIBE_DATA_DIR?: string | undefined;
     BRAINS_PATH?: string | undefined;
     DEFAULT_BRAIN_PATH?: string | undefined;
@@ -102,6 +105,7 @@ export declare const config: {
     LOCK_RETRY_INTERVAL_MS: number;
     IDLE_WATCHDOG_WARN_MS: number;
     IDLE_WATCHDOG_KILL_MS: number;
+    NETWORK_ERROR_KILL_MS: number;
     TEAMVIBE_DATA_DIR: string;
     BRAINS_PATH: string;
     DEFAULT_BRAIN_PATH: string;

package/dist/config.js

@@ -20,10 +20,11 @@ const configSchema = z.object({
     VISIBILITY_TIMEOUT_SECONDS: z.coerce.number().default(60),
     HEARTBEAT_INTERVAL_MS: z.coerce.number().default(40000), // 40 seconds
     CLAUDE_TIMEOUT_MS: z.coerce.number().default(3600000), // 60 minutes
-    STALE_LOCK_TIMEOUT_MS: z.coerce.number().default(3900000), // 65 minutes
+    STALE_LOCK_TIMEOUT_MS: z.coerce.number().default(900000), // 15 minutes (above idle watchdog kill time of 10 min)
     LOCK_RETRY_INTERVAL_MS: z.coerce.number().default(30000), // 30 seconds
     IDLE_WATCHDOG_WARN_MS: z.coerce.number().default(300000), // 5 minutes
     IDLE_WATCHDOG_KILL_MS: z.coerce.number().default(600000), // 10 minutes
+    NETWORK_ERROR_KILL_MS: z.coerce.number().default(120000), // 2 minutes of continuous network errors → kill
     // Paths
     TEAMVIBE_DATA_DIR: z.string().default(DEFAULT_DATA_DIR),
     BRAINS_PATH: z.string().default(''),

package/dist/kb-manager.d.ts

@@ -0,0 +1,15 @@
+interface KBConfig {
+    kbId: string;
+    gitRepoUrl: string;
+    branch: string;
+    claudePath: string;
+}
+/**
+ * Get or clone KB for a persona. Returns the working directory path.
+ */
+export declare function getKnowledgeBasePath(kb?: KBConfig): Promise<string>;
+/**
+ * Ensure base paths exist
+ */
+export declare function ensureDirectories(): Promise<void>;
+export {};

package/dist/kb-manager.js

@@ -0,0 +1,61 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { config } from './config.js';
+import { logger } from './logger.js';
+const execAsync = promisify(exec);
+// Cooldown tracker per KB
+const lastUpdateTimes = new Map();
+/**
+ * Get or clone KB for a persona. Returns the working directory path.
+ */
+export async function getKnowledgeBasePath(kb) {
+    if (!kb?.gitRepoUrl)
+        return config.DEFAULT_KB_PATH;
+    const kbDir = join(config.KB_BASE_PATH, kb.kbId);
+    if (!existsSync(kbDir)) {
+        logger.info(`Cloning KB ${kb.kbId} from ${kb.gitRepoUrl} (branch: ${kb.branch})...`);
+        await execAsync(`git clone --branch ${kb.branch} ${kb.gitRepoUrl} ${kbDir}`);
+        logger.info(`KB ${kb.kbId} cloned successfully`);
+    }
+    else if (config.KB_AUTO_UPDATE) {
+        await updateKB(kbDir, kb.kbId, kb.branch);
+    }
+    return kbDir;
+}
+/**
+ * Update a KB repo (respects cooldown)
+ */
+async function updateKB(kbDir, kbId, branch) {
+    const now = Date.now();
+    const lastUpdate = lastUpdateTimes.get(kbId) || 0;
+    if (now - lastUpdate < config.KB_UPDATE_COOLDOWN_MS) {
+        logger.debug(`KB ${kbId} update skipped - cooldown active (${Math.round((config.KB_UPDATE_COOLDOWN_MS - (now - lastUpdate)) / 1000)}s remaining)`);
+        return;
+    }
+    try {
+        logger.info(`Updating KB ${kbId} at ${kbDir}...`);
+        await execAsync(`git fetch origin ${branch} && git reset --hard origin/${branch}`, {
+            cwd: kbDir,
+        });
+        lastUpdateTimes.set(kbId, Date.now());
+        logger.info(`KB ${kbId} updated successfully`);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.error(`Failed to update KB ${kbId}: ${errorMessage}`);
+    }
+}
+/**
+ * Ensure base paths exist
+ */
+export async function ensureDirectories() {
+    const { mkdirSync } = await import('fs');
+    if (!existsSync(config.KB_BASE_PATH)) {
+        mkdirSync(config.KB_BASE_PATH, { recursive: true });
+    }
+    if (!existsSync(config.DEFAULT_KB_PATH)) {
+        mkdirSync(config.DEFAULT_KB_PATH, { recursive: true });
+    }
+}

package/dist/mailbox-manager.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Write a new message to the mailbox.
+ * Returns the filename of the created message file.
+ */
+export declare function writeMessage(brainPath: string, threadId: string, content: string): string;
+/**
+ * Pick the oldest message from processing/ (crash recovery) or new/.
+ * If found in new/, moves it to processing/.
+ * Returns { filename, content } or null if no messages.
+ */
+export declare function pickNextMessage(brainPath: string, threadId: string): {
+    filename: string;
+    content: string;
+} | null;
+/**
+ * Delete a message file from processing/ (marks it as done).
+ */
+export declare function markProcessed(brainPath: string, threadId: string, filename: string): void;
+/**
+ * Check if there are unprocessed messages in new/ or processing/.
+ */
+export declare function hasUnprocessed(brainPath: string, threadId: string): boolean;
+/**
+ * Get the mailbox new/ directory path for use in Claude's system prompt.
+ */
+export declare function getMailboxNewPath(brainPath: string, threadId: string): string;

package/dist/mailbox-manager.js

@@ -0,0 +1,95 @@
+import { mkdirSync, writeFileSync, readFileSync, renameSync, unlinkSync, readdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import { logger } from './logger.js';
+const MAILBOX_DIR = '.mailbox';
+const NEW_DIR = 'new';
+const PROCESSING_DIR = 'processing';
+function getMailboxPath(brainPath, threadId) {
+    return join(brainPath, MAILBOX_DIR, threadId);
+}
+function ensureMailboxDirs(brainPath, threadId) {
+    const mailbox = getMailboxPath(brainPath, threadId);
+    mkdirSync(join(mailbox, NEW_DIR), { recursive: true });
+    mkdirSync(join(mailbox, PROCESSING_DIR), { recursive: true });
+}
+/**
+ * Write a new message to the mailbox.
+ * Returns the filename of the created message file.
+ */
+export function writeMessage(brainPath, threadId, content) {
+    ensureMailboxDirs(brainPath, threadId);
+    const timestamp = process.hrtime.bigint().toString();
+    const filename = `${timestamp}.txt`;
+    const filepath = join(getMailboxPath(brainPath, threadId), NEW_DIR, filename);
+    writeFileSync(filepath, content, 'utf-8');
+    logger.info(`[Mailbox] Wrote message: ${filename} to ${getMailboxPath(brainPath, threadId)}/new/ (${content.length} chars, threadId=${threadId})`);
+    return filename;
+}
+/**
+ * Pick the oldest message from processing/ (crash recovery) or new/.
+ * If found in new/, moves it to processing/.
+ * Returns { filename, content } or null if no messages.
+ */
+export function pickNextMessage(brainPath, threadId) {
+    ensureMailboxDirs(brainPath, threadId);
+    const mailbox = getMailboxPath(brainPath, threadId);
+    const processingDir = join(mailbox, PROCESSING_DIR);
+    const newDir = join(mailbox, NEW_DIR);
+    // First check processing/ (crash recovery)
+    const processingFiles = readdirSync(processingDir).filter(f => f.endsWith('.txt')).sort();
+    if (processingFiles.length > 0) {
+        const filename = processingFiles[0];
+        const content = readFileSync(join(processingDir, filename), 'utf-8');
+        logger.info(`[Mailbox] Resuming processing message: ${filename}`);
+        return { filename, content };
+    }
+    // Then check new/
+    const newFiles = readdirSync(newDir).filter(f => f.endsWith('.txt')).sort();
+    if (newFiles.length > 0) {
+        const filename = newFiles[0];
+        const srcPath = join(newDir, filename);
+        const dstPath = join(processingDir, filename);
+        const content = readFileSync(srcPath, 'utf-8');
+        renameSync(srcPath, dstPath);
+        logger.info(`[Mailbox] Picked message: ${filename} (moved to processing)`);
+        return { filename, content };
+    }
+    return null;
+}
+/**
+ * Delete a message file from processing/ (marks it as done).
+ */
+export function markProcessed(brainPath, threadId, filename) {
+    const filepath = join(getMailboxPath(brainPath, threadId), PROCESSING_DIR, filename);
+    try {
+        if (existsSync(filepath)) {
+            unlinkSync(filepath);
+            logger.info(`[Mailbox] Deleted processed message: ${filename}`);
+        }
+    }
+    catch (error) {
+        logger.warn(`[Mailbox] Failed to delete ${filename}: ${error}`);
+    }
+}
+/**
+ * Check if there are unprocessed messages in new/ or processing/.
+ */
+export function hasUnprocessed(brainPath, threadId) {
+    const mailbox = getMailboxPath(brainPath, threadId);
+    const newDir = join(mailbox, NEW_DIR);
+    const processingDir = join(mailbox, PROCESSING_DIR);
+    try {
+        const newCount = existsSync(newDir) ? readdirSync(newDir).filter(f => f.endsWith('.txt')).length : 0;
+        const procCount = existsSync(processingDir) ? readdirSync(processingDir).filter(f => f.endsWith('.txt')).length : 0;
+        return (newCount + procCount) > 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get the mailbox new/ directory path for use in Claude's system prompt.
+ */
+export function getMailboxNewPath(brainPath, threadId) {
+    return join(getMailboxPath(brainPath, threadId), NEW_DIR);
+}

package/dist/poller.js

@@ -1,7 +1,7 @@
 import { config } from './config.js';
 import { logger } from './logger.js';
 import { pollMessages, deleteMessage, } from './sqs-poller.js';
-import { spawnClaudeCode, isAtCapacity, getActiveProcessCount, killAllActiveProcesses } from './claude-spawner.js';
+import { spawnClaudeCode, isAtCapacity, getActiveProcessCount, killAllActiveProcesses, killZombieForThread } from './claude-spawner.js';
 import { sendSlackError, addReaction, getUserInfo, startTypingIndicator } from './slack-client.js';
 import { acquireSessionLock, releaseSessionLock, updateSessionId } from './session-store.js';
 import { getBrainPath, ensureDirectories, ensureBaseBrain, pushBrainChanges } from './brain-manager.js';
@@ -25,8 +25,17 @@ async function runInboxLoop(threadId, kbPath, queueMessage, sessionLog) {
     try {
         let lockResult = await acquireSessionLock(threadId, kbPath);
         if (!lockResult.success) {
-            sessionLog.info(`Session ${threadId} is locked, inbox message will be picked up by active session`);
-            return;
+            // If lock acquisition failed, check for zombie processes holding the lock
+            const killed = killZombieForThread(threadId);
+            if (killed) {
+                sessionLog.info(`Killed zombie for thread ${threadId}, retrying lock acquisition`);
+                await new Promise((resolve) => setTimeout(resolve, 2000));
+                lockResult = await acquireSessionLock(threadId, kbPath);
+            }
+            if (!lockResult.success) {
+                sessionLog.info(`Session ${threadId} is locked, inbox message will be picked up by active session`);
+                return;
+            }
         }
         const { session, lockToken } = lockResult;
         let currentSessionId = session.session_id || undefined;

package/dist/scripts/add-reaction.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+/**
+ * Add an emoji reaction to the original message.
+ *
+ * Usage:
+ *   node add-reaction.js emoji_name
+ *   node add-reaction.js --channel C123 --message_ts 123.456 emoji_name
+ */
+export {};

package/dist/scripts/add-reaction.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+/**
+ * Add an emoji reaction to the original message.
+ *
+ * Usage:
+ *   node add-reaction.js emoji_name
+ *   node add-reaction.js --channel C123 --message_ts 123.456 emoji_name
+ */
+import { slack, fail, succeed, parseArgs } from './lib/slack-client.js';
+const { channel, messageTs, positional } = parseArgs();
+const emoji = positional[0];
+if (!emoji)
+    fail('Emoji name required');
+if (!channel)
+    fail('Channel required (--channel or SLACK_CHANNEL env)');
+if (!messageTs)
+    fail('Message TS required (--message_ts or SLACK_MESSAGE_TS env)');
+async function main() {
+    await slack.reactions.add({ channel: channel, timestamp: messageTs, name: emoji });
+    succeed();
+}
+main().catch((err) => fail(err instanceof Error ? err.message : String(err)));

package/dist/scripts/lib/slack-client.d.ts

@@ -0,0 +1,16 @@
+import { WebClient } from '@slack/web-api';
+export declare function fail(error: string): never;
+export declare function succeed(data?: Record<string, unknown>): never;
+export declare const slack: WebClient;
+/**
+ * Parse CLI args: extracts known --flags and returns remaining positional args.
+ * Supports both --flag value and --flag=value syntax.
+ * Falls back to env vars for channel/thread_ts/message_ts.
+ */
+export declare function parseArgs(argv?: string[]): {
+    channel: string | undefined;
+    threadTs: string | undefined;
+    messageTs: string | undefined;
+    positional: string[];
+    textFromFlag: string | undefined;
+};

package/dist/scripts/lib/slack-client.js

@@ -0,0 +1,48 @@
+import { WebClient } from '@slack/web-api';
+const BOT_TOKEN = process.env['SLACK_BOT_TOKEN'];
+export function fail(error) {
+    console.log(JSON.stringify({ ok: false, error }));
+    process.exit(1);
+}
+export function succeed(data = {}) {
+    console.log(JSON.stringify({ ok: true, ...data }));
+    process.exit(0);
+}
+if (!BOT_TOKEN)
+    fail('SLACK_BOT_TOKEN not set');
+export const slack = new WebClient(BOT_TOKEN);
+/**
+ * Parse CLI args: extracts known --flags and returns remaining positional args.
+ * Supports both --flag value and --flag=value syntax.
+ * Falls back to env vars for channel/thread_ts/message_ts.
+ */
+export function parseArgs(argv = process.argv.slice(2)) {
+    const flags = {};
+    const positional = [];
+    const knownFlags = ['--channel', '--thread_ts', '--thread-ts', '--message_ts', '--message-ts', '--text'];
+    let i = 0;
+    while (i < argv.length) {
+        const arg = argv[i];
+        // --flag=value
+        const eqMatch = arg.match(/^(--[\w-]+)=(.*)$/);
+        if (eqMatch) {
+            flags[eqMatch[1]] = eqMatch[2];
+            i++;
+            continue;
+        }
+        // --flag value
+        if (knownFlags.includes(arg) && i + 1 < argv.length) {
+            flags[arg] = argv[i + 1];
+            i += 2;
+            continue;
+        }
+        positional.push(arg);
+        i++;
+    }
+    // If --text was provided, use it (and any remaining positional after it)
+    const textFromFlag = flags['--text'];
+    const channel = flags['--channel'] || process.env['SLACK_CHANNEL'];
+    const threadTs = flags['--thread_ts'] || flags['--thread-ts'] || process.env['SLACK_THREAD_TS'];
+    const messageTs = flags['--message_ts'] || flags['--message-ts'] || process.env['SLACK_MESSAGE_TS'];
+    return { channel, threadTs, messageTs, positional, textFromFlag };
+}

package/dist/scripts/read-thread.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+/**
+ * Read thread history from a Slack thread.
+ *
+ * Usage:
+ *   node read-thread.js [limit]
+ *   node read-thread.js --channel C123 --thread_ts 123.456 [limit]
+ */
+export {};

package/dist/scripts/read-thread.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+/**
+ * Read thread history from a Slack thread.
+ *
+ * Usage:
+ *   node read-thread.js [limit]
+ *   node read-thread.js --channel C123 --thread_ts 123.456 [limit]
+ */
+import { slack, fail, succeed, parseArgs } from './lib/slack-client.js';
+const { channel, threadTs, positional } = parseArgs();
+const limit = parseInt(positional[0] || '20', 10);
+if (!channel)
+    fail('Channel required (--channel or SLACK_CHANNEL env)');
+if (!threadTs)
+    fail('Thread TS required (--thread_ts or SLACK_THREAD_TS env)');
+async function main() {
+    const result = await slack.conversations.replies({ channel: channel, ts: threadTs, limit });
+    const messages = (result.messages || []).map((m) => ({
+        user: m.user || m.bot_id || 'unknown',
+        text: m.text || '',
+        ts: m.ts,
+        is_bot: Boolean(m.bot_id),
+    }));
+    succeed({ messages });
+}
+main().catch((err) => fail(err instanceof Error ? err.message : String(err)));

package/dist/scripts/remove-reaction.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+/**
+ * Remove an emoji reaction from the original message.
+ *
+ * Usage:
+ *   node remove-reaction.js emoji_name
+ *   node remove-reaction.js --channel C123 --message_ts 123.456 emoji_name
+ */
+export {};

package/dist/scripts/remove-reaction.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+/**
+ * Remove an emoji reaction from the original message.
+ *
+ * Usage:
+ *   node remove-reaction.js emoji_name
+ *   node remove-reaction.js --channel C123 --message_ts 123.456 emoji_name
+ */
+import { slack, fail, succeed, parseArgs } from './lib/slack-client.js';
+const { channel, messageTs, positional } = parseArgs();
+const emoji = positional[0];
+if (!emoji)
+    fail('Emoji name required');
+if (!channel)
+    fail('Channel required (--channel or SLACK_CHANNEL env)');
+if (!messageTs)
+    fail('Message TS required (--message_ts or SLACK_MESSAGE_TS env)');
+async function main() {
+    await slack.reactions.remove({ channel: channel, timestamp: messageTs, name: emoji });
+    succeed();
+}
+main().catch((err) => fail(err instanceof Error ? err.message : String(err)));

package/dist/scripts/send-message.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+/**
+ * Send a message to a Slack thread.
+ *
+ * Usage:
+ *   node send-message.js "Your message here"
+ *   node send-message.js --text "Your message here"
+ *   node send-message.js --channel C123 --thread_ts 123.456 "Your message"
+ */
+export {};

package/dist/scripts/send-message.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+/**
+ * Send a message to a Slack thread.
+ *
+ * Usage:
+ *   node send-message.js "Your message here"
+ *   node send-message.js --text "Your message here"
+ *   node send-message.js --channel C123 --thread_ts 123.456 "Your message"
+ */
+import { slack, fail, succeed, parseArgs } from './lib/slack-client.js';
+const { channel, threadTs, positional, textFromFlag } = parseArgs();
+const text = textFromFlag || positional.join(' ');
+if (!text)
+    fail('Message text required');
+if (!channel)
+    fail('Channel required (--channel or SLACK_CHANNEL env)');
+if (!threadTs)
+    fail('Thread TS required (--thread_ts or SLACK_THREAD_TS env)');
+async function main() {
+    console.error(`[slack] send_message: channel=${channel}, thread_ts=${threadTs}`);
+    const result = await slack.chat.postMessage({
+        channel: channel,
+        thread_ts: threadTs,
+        text,
+        unfurl_links: false,
+        unfurl_media: false,
+    });
+    console.error(`[slack] posted: ts=${result.ts}`);
+    succeed({ ts: result.ts });
+}
+main().catch((err) => fail(err instanceof Error ? err.message : String(err)));

package/dist/scripts/set-status.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * Set the assistant thread status.
+ *
+ * Usage:
+ *   node set-status.js "Status text"
+ */
+export {};

package/dist/scripts/set-status.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+/**
+ * Set the assistant thread status.
+ *
+ * Usage:
+ *   node set-status.js "Status text"
+ */
+import { slack, fail, succeed, parseArgs } from './lib/slack-client.js';
+const { channel, threadTs, positional } = parseArgs();
+const status = positional.join(' ');
+if (!channel)
+    fail('Channel required');
+if (!threadTs)
+    fail('Thread TS required');
+async function main() {
+    await slack.apiCall('assistant.threads.setStatus', { channel_id: channel, thread_ts: threadTs, status });
+    succeed();
+}
+main().catch((err) => fail(err instanceof Error ? err.message : String(err)));

package/dist/scripts/slack-tool.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/slack-tool.js

@@ -0,0 +1,155 @@
+import { WebClient } from '@slack/web-api';
+const BOT_TOKEN = process.env['SLACK_BOT_TOKEN'];
+const CHANNEL = process.env['SLACK_CHANNEL'];
+const THREAD_TS = process.env['SLACK_THREAD_TS'];
+const MESSAGE_TS = process.env['SLACK_MESSAGE_TS'];
+function fail(error) {
+    console.log(JSON.stringify({ ok: false, error }));
+    process.exit(1);
+}
+function succeed(data = {}) {
+    console.log(JSON.stringify({ ok: true, ...data }));
+    process.exit(0);
+}
+if (!BOT_TOKEN)
+    fail('SLACK_BOT_TOKEN not set');
+const slack = new WebClient(BOT_TOKEN);
+const [, , command, ...args] = process.argv;
+/**
+ * Strip --channel, --thread_ts, --text flags that Claude sometimes adds.
+ * These values come from env vars, not CLI args.
+ */
+function stripFlags(rawArgs) {
+    const flagsToStrip = ['--channel', '--thread_ts', '--thread-ts', '--text'];
+    const cleaned = [];
+    let i = 0;
+    while (i < rawArgs.length) {
+        if (flagsToStrip.includes(rawArgs[i])) {
+            // If this is --text, everything after the next arg is the message
+            if (rawArgs[i] === '--text') {
+                return rawArgs.slice(i + 1).join(' ');
+            }
+            i += 2; // skip flag + value
+        }
+        else {
+            cleaned.push(rawArgs[i]);
+            i++;
+        }
+    }
+    return cleaned.join(' ');
+}
+async function main() {
+    switch (command) {
+        case 'send_message': {
+            const text = stripFlags(args);
+            if (!text)
+                fail('Message text required');
+            if (!CHANNEL)
+                fail('SLACK_CHANNEL not set');
+            if (!THREAD_TS)
+                fail('SLACK_THREAD_TS not set');
+            console.error(`[slack-tool] send_message: channel=${CHANNEL}, thread_ts=${THREAD_TS}`);
+            const result = await slack.chat.postMessage({
+                channel: CHANNEL,
+                thread_ts: THREAD_TS,
+                text,
+                unfurl_links: false,
+                unfurl_media: false,
+            });
+            console.error(`[slack-tool] posted: ts=${result.ts}, thread_ts=${result.message?.thread_ts}`);
+            succeed({ ts: result.ts });
+            break;
+        }
+        case 'add_reaction': {
+            const emoji = args[0];
+            if (!emoji)
+                fail('Emoji name required');
+            if (!CHANNEL)
+                fail('SLACK_CHANNEL not set');
+            if (!MESSAGE_TS)
+                fail('SLACK_MESSAGE_TS not set');
+            await slack.reactions.add({
+                channel: CHANNEL,
+                timestamp: MESSAGE_TS,
+                name: emoji,
+            });
+            succeed();
+            break;
+        }
+        case 'remove_reaction': {
+            const emoji = args[0];
+            if (!emoji)
+                fail('Emoji name required');
+            if (!CHANNEL)
+                fail('SLACK_CHANNEL not set');
+            if (!MESSAGE_TS)
+                fail('SLACK_MESSAGE_TS not set');
+            await slack.reactions.remove({
+                channel: CHANNEL,
+                timestamp: MESSAGE_TS,
+                name: emoji,
+            });
+            succeed();
+            break;
+        }
+        case 'read_thread': {
+            if (!CHANNEL)
+                fail('SLACK_CHANNEL not set');
+            if (!THREAD_TS)
+                fail('SLACK_THREAD_TS not set');
+            const limit = parseInt(args[0] || '20', 10);
+            const result = await slack.conversations.replies({
+                channel: CHANNEL,
+                ts: THREAD_TS,
+                limit,
+            });
+            const messages = (result.messages || []).map((m) => ({
+                user: m.user || m.bot_id || 'unknown',
+                text: m.text || '',
+                ts: m.ts,
+                is_bot: Boolean(m.bot_id),
+            }));
+            succeed({ messages });
+            break;
+        }
+        case 'set_status': {
+            const status = args.join(' ');
+            if (!CHANNEL)
+                fail('SLACK_CHANNEL not set');
+            if (!THREAD_TS)
+                fail('SLACK_THREAD_TS not set');
+            await slack.apiCall('assistant.threads.setStatus', {
+                channel_id: CHANNEL,
+                thread_ts: THREAD_TS,
+                status,
+            });
+            succeed();
+            break;
+        }
+        case 'upload_snippet': {
+            const title = args[0];
+            const content = args[1];
+            const filetype = args[2] || 'text';
+            if (!title || !content)
+                fail('Title and content required');
+            if (!CHANNEL)
+                fail('SLACK_CHANNEL not set');
+            if (!THREAD_TS)
+                fail('SLACK_THREAD_TS not set');
+            await slack.filesUploadV2({
+                channel_id: CHANNEL,
+                thread_ts: THREAD_TS,
+                title,
+                content,
+                filetype,
+            });
+            succeed();
+            break;
+        }
+        default:
+            fail(`Unknown command: ${command}. Available: send_message, add_reaction, remove_reaction, read_thread, set_status, upload_snippet`);
+    }
+}
+main().catch((err) => {
+    fail(err instanceof Error ? err.message : String(err));
+});

package/dist/scripts/upload-snippet.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * Upload a code/text snippet to a Slack thread.
+ *
+ * Usage:
+ *   node upload-snippet.js "title" "content" [filetype]
+ */
+export {};

package/dist/scripts/upload-snippet.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+/**
+ * Upload a code/text snippet to a Slack thread.
+ *
+ * Usage:
+ *   node upload-snippet.js "title" "content" [filetype]
+ */
+import { slack, fail, succeed, parseArgs } from './lib/slack-client.js';
+const { channel, threadTs, positional } = parseArgs();
+const [title, content, filetype = 'text'] = positional;
+if (!title || !content)
+    fail('Title and content required');
+if (!channel)
+    fail('Channel required');
+if (!threadTs)
+    fail('Thread TS required');
+async function main() {
+    await slack.filesUploadV2({ channel_id: channel, thread_ts: threadTs, title: title, content: content, filetype });
+    succeed();
+}
+main().catch((err) => fail(err instanceof Error ? err.message : String(err)));

package/package.json

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