@teamvibe/poller 0.1.6 → 0.1.8

package/dist/brain-manager.d.ts

@@ -0,0 +1,29 @@
+interface BrainConfig {
+    brainId: string;
+    gitRepoUrl: string;
+    branch: string;
+    claudePath: string;
+}
+/**
+ * Get or clone brain repo. Returns the working directory path.
+ */
+export declare function getBrainPath(brain?: BrainConfig): Promise<string>;
+/**
+ * Ensure base brain repo is cloned and up to date.
+ * Uses same cooldown pattern as channel brains.
+ */
+export declare function ensureBaseBrain(): Promise<void>;
+/**
+ * Get the path to the base brain directory.
+ */
+export declare function getBaseBrainPath(): string;
+/**
+ * Commit and push any changes in a brain repo.
+ * Silently skips if there are no changes or no remote.
+ */
+export declare function pushBrainChanges(brainDir: string, brainId: string): Promise<void>;
+/**
+ * Ensure base paths exist
+ */
+export declare function ensureDirectories(): Promise<void>;
+export {};

package/dist/brain-manager.js

@@ -0,0 +1,130 @@
+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 brain
+const lastUpdateTimes = new Map();
+/**
+ * Get or clone brain repo. Returns the working directory path.
+ */
+export async function getBrainPath(brain) {
+    if (!brain?.gitRepoUrl)
+        return config.DEFAULT_BRAIN_PATH;
+    const brainDir = join(config.BRAINS_PATH, brain.brainId);
+    if (!existsSync(brainDir)) {
+        logger.info(`Cloning brain ${brain.brainId} from ${brain.gitRepoUrl} (branch: ${brain.branch})...`);
+        await execAsync(`git clone --recurse-submodules ${brain.gitRepoUrl} ${brainDir}`);
+        // Ensure the desired branch exists (handles empty repos and missing branches)
+        const { stdout: currentBranch } = await execAsync('git branch --show-current', { cwd: brainDir });
+        if (currentBranch.trim() !== brain.branch) {
+            // Check if the branch exists on remote
+            const { stdout: remoteBranches } = await execAsync('git branch -r', { cwd: brainDir });
+            if (remoteBranches.includes(`origin/${brain.branch}`)) {
+                await execAsync(`git checkout ${brain.branch}`, { cwd: brainDir });
+            }
+            else {
+                await execAsync(`git checkout -b ${brain.branch}`, { cwd: brainDir });
+            }
+        }
+        logger.info(`Brain ${brain.brainId} cloned successfully`);
+    }
+    else if (config.BRAIN_AUTO_UPDATE) {
+        await updateBrain(brainDir, brain.brainId, brain.branch);
+    }
+    return brainDir;
+}
+/**
+ * Update a brain repo (respects cooldown)
+ */
+async function updateBrain(brainDir, brainId, branch) {
+    const now = Date.now();
+    const lastUpdate = lastUpdateTimes.get(brainId) || 0;
+    if (now - lastUpdate < config.BRAIN_UPDATE_COOLDOWN_MS) {
+        logger.debug(`Brain ${brainId} update skipped - cooldown active (${Math.round((config.BRAIN_UPDATE_COOLDOWN_MS - (now - lastUpdate)) / 1000)}s remaining)`);
+        return;
+    }
+    try {
+        logger.info(`Updating brain ${brainId} at ${brainDir}...`);
+        await execAsync(`git fetch origin ${branch} && git reset --hard origin/${branch} && git submodule update --init --recursive`, {
+            cwd: brainDir,
+        });
+        lastUpdateTimes.set(brainId, Date.now());
+        logger.info(`Brain ${brainId} updated successfully`);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.error(`Failed to update brain ${brainId}: ${errorMessage}`);
+    }
+}
+/**
+ * Ensure base brain repo is cloned and up to date.
+ * Uses same cooldown pattern as channel brains.
+ */
+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})...`);
+        await execAsync(`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');
+    }
+    else if (config.BRAIN_AUTO_UPDATE) {
+        await updateBrain(brainDir, '__base_brain__', config.BASE_BRAIN_BRANCH);
+    }
+}
+/**
+ * Get the path to the base brain directory.
+ */
+export function getBaseBrainPath() {
+    return config.BASE_BRAIN_PATH;
+}
+/**
+ * Commit and push any changes in a brain repo.
+ * Silently skips if there are no changes or no remote.
+ */
+export async function pushBrainChanges(brainDir, brainId) {
+    try {
+        // Check if this is a git repo with a remote
+        try {
+            await execAsync('git remote get-url origin', { cwd: brainDir });
+        }
+        catch {
+            logger.debug(`Brain ${brainId} has no git remote, skipping push`);
+            return;
+        }
+        // Stage all changes
+        await execAsync('git add -A', { cwd: brainDir });
+        // Check if there are staged changes
+        try {
+            await execAsync('git diff --cached --quiet', { cwd: brainDir });
+            // If the command succeeds (exit 0), there are no changes
+            logger.debug(`Brain ${brainId} has no changes to push`);
+            return;
+        }
+        catch {
+            // Exit code 1 means there are changes — continue
+        }
+        await execAsync('git commit -m "auto: session update"', { cwd: brainDir });
+        await execAsync('git push', { cwd: brainDir });
+        logger.info(`Brain ${brainId} changes pushed successfully`);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.warn(`Failed to push brain ${brainId} changes: ${errorMessage}`);
+    }
+}
+/**
+ * Ensure base paths exist
+ */
+export async function ensureDirectories() {
+    const { mkdirSync } = await import('fs');
+    if (!existsSync(config.BRAINS_PATH)) {
+        mkdirSync(config.BRAINS_PATH, { recursive: true });
+    }
+    if (!existsSync(config.DEFAULT_BRAIN_PATH)) {
+        mkdirSync(config.DEFAULT_BRAIN_PATH, { recursive: true });
+    }
+}

package/dist/claude-spawner.d.ts

@@ -6,6 +6,6 @@ export interface SpawnResult {
     exitCode: number | null;
     error?: string;
 }
-export declare function spawnClaudeCode(msg: TeamVibeQueueMessage, sessionLog: SessionLogger, cwd: string, sessionId?: string, isFirstMessage?: boolean, lastMessageTs?: string): Promise<SpawnResult>;
+export declare function spawnClaudeCode(msg: TeamVibeQueueMessage, sessionLog: SessionLogger, cwd: string, sessionId?: string, isFirstMessage?: boolean, lastMessageTs?: string, onMessageSent?: () => void): Promise<SpawnResult>;
 export declare function getActiveProcessCount(): number;
 export declare function isAtCapacity(): boolean;

package/dist/claude-spawner.js

@@ -1,11 +1,9 @@
 import { spawn } from 'child_process';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
+import { join } from 'path';
 import { WebClient } from '@slack/web-api';
 import { config } from './config.js';
 import { logger } from './logger.js';
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const SLACK_TOOL_PATH = join(__dirname, 'scripts/slack-tool.js');
+import { getBaseBrainPath } from './brain-manager.js';
 // Per-token Slack client cache for thread context
 const slackClients = new Map();
 function getSlackClient(botToken) {
@@ -42,62 +40,8 @@ async function countNewThreadMessages(botToken, channel, threadTs, sinceTs) {
         return 0;
     }
 }
-function buildSystemPrompt(persona) {
-    let prompt = persona?.systemPrompt || getDefaultSystemPrompt();
-    // Append standard communication instructions
-    prompt += `\n\n## Communication
-You have Slack tools available via Bash. Use these commands to communicate:
-
-**Send a message** (REQUIRED - always use this to respond):
-\`\`\`bash
-node $SLACK_TOOL_PATH send_message "Your message here"
-\`\`\`
-
-**Add emoji reaction:**
-\`\`\`bash
-node $SLACK_TOOL_PATH add_reaction emoji_name
-\`\`\`
-
-**Remove emoji reaction:**
-\`\`\`bash
-node $SLACK_TOOL_PATH remove_reaction emoji_name
-\`\`\`
-
-**Read thread history:**
-\`\`\`bash
-node $SLACK_TOOL_PATH read_thread [limit]
-\`\`\`
-
-**Upload code/text snippet:**
-\`\`\`bash
-node $SLACK_TOOL_PATH upload_snippet "title" "content" [filetype]
-\`\`\`
-
-**Important:** To respond to the user, you MUST use the send_message command via Bash - plain text output will NOT be seen by the user. Always send at least one message back.
-All commands return JSON: {"ok": true, ...} on success or {"ok": false, "error": "..."} on failure.
-
-## Response Guidelines
-1. **Always respond** - Use send_message to reply
-2. **Acknowledge long tasks** - Send a quick message first for time-consuming work
-3. **Be concise** - Use bullet points, keep it focused
-4. **Use Slack formatting** - \`code\`, *bold*, _italic_, \\\`\\\`\\\`code blocks\\\`\\\`\\\`, > quotes
-5. **For long code** - Use upload_snippet instead of huge code blocks`;
-    return prompt;
-}
-function getDefaultSystemPrompt() {
-    return `You are a helpful assistant operating in a team's Slack workspace. Team members contact you via Slack messages.
-
-## Your Setup
-You have access to the company's **knowledge base** (the current working directory). You should:
-- Read and search files to understand available tools and information
-- Execute available commands, skills, and automation scripts
-- Run shell commands for tasks (API calls, data processing, etc.)
-- Create temporary local files when needed for your work
-- Do NOT create new permanent files or edit existing files unless explicitly asked`;
-}
-function buildPrompt(msg, systemPrompt, resumeHint) {
-    let prompt = systemPrompt;
-    prompt += '\n\n---\n\n## Incoming Slack Message\n\n';
+function buildPrompt(msg, resumeHint) {
+    let prompt = '## Incoming Slack Message\n\n';
     prompt += `**From:** ${msg.sender.name}`;
     if (msg.sender.id && msg.sender.id !== msg.sender.name) {
         prompt += ` (${msg.sender.id})`;
@@ -123,7 +67,7 @@ function buildPrompt(msg, systemPrompt, resumeHint) {
     if (resumeHint) {
         prompt += `\n\n${resumeHint}`;
     }
-    prompt += '\n\n---\n\nNow respond to this user using the send_message command via Bash.';
+    prompt += `\n\n---\n\nRespond to this user NOW using the send_message tool.`;
     return prompt;
 }
 function truncateOutput(output, maxLen = 200) {
@@ -182,7 +126,7 @@ function formatStreamEvent(event) {
             return null;
     }
 }
-async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = true, lastMessageTs) {
+async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = true, lastMessageTs, onMessageSent) {
     const slackContext = msg.response_context.slack;
     const isCronMessage = msg.source === 'cron';
     if (!slackContext && !isCronMessage) {
@@ -200,8 +144,14 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
         }
     }
     return new Promise((resolve) => {
-        const systemPrompt = buildSystemPrompt(msg.teamvibe.persona);
-        const prompt = buildPrompt(msg, systemPrompt, resumeHint);
+        const prompt = buildPrompt(msg, resumeHint);
+        // MCP server config passed via --mcp-config flag (no temp files needed)
+        const mcpServerPath = join(getBaseBrainPath(), 'mcp', 'slack.mjs');
+        const mcpConfig = JSON.stringify({
+            mcpServers: {
+                slack: { command: 'node', args: [mcpServerPath] },
+            },
+        });
         const args = [
             '--print',
             '--verbose',
@@ -209,8 +159,10 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
             'stream-json',
             '--max-turns',
             '50',
+            '--mcp-config',
+            mcpConfig,
             '--allowedTools',
-            'Bash,Read,WebFetch',
+            'Bash,Read,Write,Edit,WebFetch,mcp__slack__send_message,mcp__slack__add_reaction,mcp__slack__remove_reaction,mcp__slack__read_thread,mcp__slack__read_channel,mcp__slack__upload_snippet,mcp__slack__download_file,mcp__slack__upload_file,mcp__slack__set_status',
         ];
         // Handle session continuity
         if (sessionId) {
@@ -225,14 +177,22 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
         sessionLog.info(`Working directory: ${cwd}`);
         sessionLog.info(`Prompt length: ${prompt.length} chars`);
         sessionLog.logPrompt(prompt);
+        // Prepend persistent bin dir to PATH if configured
+        const envPath = config.PERSISTENT_STORAGE_PATH
+            ? `${config.PERSISTENT_STORAGE_PATH}/bin:${process.env['PATH'] || ''}`
+            : process.env['PATH'];
         const proc = spawn(config.CLAUDE_CLI_PATH, args, {
             cwd,
             env: {
                 ...process.env,
+                CLAUDECODE: undefined,
+                PATH: envPath,
                 CI: 'true',
+                CLAUDE_CONFIG_DIR: getBaseBrainPath(),
                 SLACK_BOT_TOKEN: msg.teamvibe.botToken,
-                SLACK_TOOL_PATH,
-                SLACK_FILES_DIR: join(cwd, '.local/slack-files'),
+                ...(config.PERSISTENT_STORAGE_PATH && {
+                    PERSISTENT_STORAGE_PATH: config.PERSISTENT_STORAGE_PATH,
+                }),
                 ...(slackContext && {
                     SLACK_CHANNEL: slackContext.channel,
                     SLACK_THREAD_TS: slackContext.thread_ts,
@@ -265,6 +225,12 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
                     if (formatted) {
                         sessionLog.claude('stdout', formatted);
                     }
+                    // Detect when Claude sends a Slack message and clear typing indicator
+                    if (onMessageSent &&
+                        event.type === 'tool_use' &&
+                        event.name === 'mcp__slack__send_message') {
+                        onMessageSent();
+                    }
                 }
                 catch {
                     const truncated = line.length > 500 ? line.slice(0, 500) + '...' : line;
@@ -307,12 +273,12 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
         });
     });
 }
-export async function spawnClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = true, lastMessageTs) {
-    const result = await runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage, lastMessageTs);
+export async function spawnClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = true, lastMessageTs, onMessageSent) {
+    const result = await runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage, lastMessageTs, onMessageSent);
     // If --resume failed, retry as a fresh session (session files may have been lost on container restart)
     if (!result.success && sessionId && !isFirstMessage) {
         sessionLog.info('Resume failed, retrying as fresh session (session files may have been lost)');
-        return runClaudeCode(msg, sessionLog, cwd, sessionId, true, lastMessageTs);
+        return runClaudeCode(msg, sessionLog, cwd, sessionId, true, lastMessageTs, onMessageSent);
     }
     return result;
 }

package/dist/config.d.ts

@@ -12,11 +12,15 @@ declare const configSchema: z.ZodObject<{
     CLAUDE_TIMEOUT_MS: z.ZodDefault<z.ZodNumber>;
     STALE_LOCK_TIMEOUT_MS: z.ZodDefault<z.ZodNumber>;
     TEAMVIBE_DATA_DIR: z.ZodDefault<z.ZodString>;
-    KB_BASE_PATH: z.ZodDefault<z.ZodString>;
-    DEFAULT_KB_PATH: z.ZodDefault<z.ZodString>;
+    BRAINS_PATH: z.ZodDefault<z.ZodString>;
+    DEFAULT_BRAIN_PATH: z.ZodDefault<z.ZodString>;
     CLAUDE_CLI_PATH: z.ZodDefault<z.ZodString>;
-    KB_AUTO_UPDATE: z.ZodEffects<z.ZodDefault<z.ZodString>, boolean, string | undefined>;
-    KB_UPDATE_COOLDOWN_MS: z.ZodDefault<z.ZodNumber>;
+    PERSISTENT_STORAGE_PATH: z.ZodDefault<z.ZodString>;
+    BASE_BRAIN_REPO: z.ZodDefault<z.ZodString>;
+    BASE_BRAIN_BRANCH: z.ZodDefault<z.ZodString>;
+    BASE_BRAIN_PATH: z.ZodDefault<z.ZodString>;
+    BRAIN_AUTO_UPDATE: z.ZodEffects<z.ZodDefault<z.ZodString>, boolean, string | undefined>;
+    BRAIN_UPDATE_COOLDOWN_MS: z.ZodDefault<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     AWS_REGION: string;
     TEAMVIBE_API_URL: string;
@@ -27,11 +31,15 @@ declare const configSchema: z.ZodObject<{
     CLAUDE_TIMEOUT_MS: number;
     STALE_LOCK_TIMEOUT_MS: number;
     TEAMVIBE_DATA_DIR: string;
-    KB_BASE_PATH: string;
-    DEFAULT_KB_PATH: string;
+    BRAINS_PATH: string;
+    DEFAULT_BRAIN_PATH: string;
     CLAUDE_CLI_PATH: string;
-    KB_AUTO_UPDATE: boolean;
-    KB_UPDATE_COOLDOWN_MS: number;
+    PERSISTENT_STORAGE_PATH: string;
+    BASE_BRAIN_REPO: string;
+    BASE_BRAIN_BRANCH: string;
+    BASE_BRAIN_PATH: string;
+    BRAIN_AUTO_UPDATE: boolean;
+    BRAIN_UPDATE_COOLDOWN_MS: number;
     SQS_QUEUE_URL?: string | undefined;
     SESSIONS_TABLE?: string | undefined;
     TEAMVIBE_POLLER_TOKEN?: string | undefined;
@@ -48,11 +56,15 @@ declare const configSchema: z.ZodObject<{
     CLAUDE_TIMEOUT_MS?: number | undefined;
     STALE_LOCK_TIMEOUT_MS?: number | undefined;
     TEAMVIBE_DATA_DIR?: string | undefined;
-    KB_BASE_PATH?: string | undefined;
-    DEFAULT_KB_PATH?: string | undefined;
+    BRAINS_PATH?: string | undefined;
+    DEFAULT_BRAIN_PATH?: string | undefined;
     CLAUDE_CLI_PATH?: string | undefined;
-    KB_AUTO_UPDATE?: string | undefined;
-    KB_UPDATE_COOLDOWN_MS?: number | undefined;
+    PERSISTENT_STORAGE_PATH?: string | undefined;
+    BASE_BRAIN_REPO?: string | undefined;
+    BASE_BRAIN_BRANCH?: string | undefined;
+    BASE_BRAIN_PATH?: string | undefined;
+    BRAIN_AUTO_UPDATE?: string | undefined;
+    BRAIN_UPDATE_COOLDOWN_MS?: number | undefined;
 }>;
 export type Config = z.infer<typeof configSchema>;
 export declare function loadConfig(): Config;
@@ -66,11 +78,15 @@ export declare const config: {
     CLAUDE_TIMEOUT_MS: number;
     STALE_LOCK_TIMEOUT_MS: number;
     TEAMVIBE_DATA_DIR: string;
-    KB_BASE_PATH: string;
-    DEFAULT_KB_PATH: string;
+    BRAINS_PATH: string;
+    DEFAULT_BRAIN_PATH: string;
     CLAUDE_CLI_PATH: string;
-    KB_AUTO_UPDATE: boolean;
-    KB_UPDATE_COOLDOWN_MS: number;
+    PERSISTENT_STORAGE_PATH: string;
+    BASE_BRAIN_REPO: string;
+    BASE_BRAIN_BRANCH: string;
+    BASE_BRAIN_PATH: string;
+    BRAIN_AUTO_UPDATE: boolean;
+    BRAIN_UPDATE_COOLDOWN_MS: number;
     SQS_QUEUE_URL?: string | undefined;
     SESSIONS_TABLE?: string | undefined;
     TEAMVIBE_POLLER_TOKEN?: string | undefined;

package/dist/config.js

@@ -19,15 +19,20 @@ const configSchema = z.object({
     STALE_LOCK_TIMEOUT_MS: z.coerce.number().default(2100000), // 35 minutes
     // Paths
     TEAMVIBE_DATA_DIR: z.string().default(DEFAULT_DATA_DIR),
-    KB_BASE_PATH: z.string().default(''),
-    DEFAULT_KB_PATH: z.string().default(''),
+    BRAINS_PATH: z.string().default(''),
+    DEFAULT_BRAIN_PATH: z.string().default(''),
     CLAUDE_CLI_PATH: z.string().default('claude'),
-    // Knowledge base auto-update
-    KB_AUTO_UPDATE: z
+    PERSISTENT_STORAGE_PATH: z.string().default(''),
+    // Base brain repo (user-scope config for Claude Code)
+    BASE_BRAIN_REPO: z.string().default('https://github.com/teamvibeai/poller-brain.git'),
+    BASE_BRAIN_BRANCH: z.string().default('main'),
+    BASE_BRAIN_PATH: z.string().default(''),
+    // Brain auto-update
+    BRAIN_AUTO_UPDATE: z
         .string()
         .default('true')
         .transform((v) => v.toLowerCase() === 'true'),
-    KB_UPDATE_COOLDOWN_MS: z.coerce.number().default(300000), // 5 minutes
+    BRAIN_UPDATE_COOLDOWN_MS: z.coerce.number().default(300000), // 5 minutes
 });
 export function loadConfig() {
     const result = configSchema.safeParse(process.env);
@@ -47,8 +52,9 @@ export function loadConfig() {
     }
     // Derive paths from TEAMVIBE_DATA_DIR if not explicitly set
     const dataDir = data.TEAMVIBE_DATA_DIR;
-    data.KB_BASE_PATH = data.KB_BASE_PATH || `${dataDir}/knowledge-bases`;
-    data.DEFAULT_KB_PATH = data.DEFAULT_KB_PATH || `${dataDir}/workspace`;
+    data.BRAINS_PATH = data.BRAINS_PATH || `${dataDir}/brains`;
+    data.DEFAULT_BRAIN_PATH = data.DEFAULT_BRAIN_PATH || `${dataDir}/workspace`;
+    data.BASE_BRAIN_PATH = data.BASE_BRAIN_PATH || `${dataDir}/base-brain`;
     return data;
 }
 export const config = loadConfig();

package/dist/index.js

@@ -5,11 +5,11 @@ import { pollMessages, deleteMessage, extendVisibility, } from './sqs-poller.js'
 import { spawnClaudeCode, isAtCapacity, getActiveProcessCount } from './claude-spawner.js';
 import { sendSlackError, addReaction, getUserInfo, startTypingIndicator } from './slack-client.js';
 import { acquireSessionLock, releaseSessionLock } from './session-store.js';
-import { getKnowledgeBasePath, ensureDirectories } from './kb-manager.js';
+import { getBrainPath, ensureDirectories, ensureBaseBrain, pushBrainChanges } from './brain-manager.js';
 import { initAuth, stopRefresh } from './auth-provider.js';
 logger.info('TeamVibe Poller starting...');
 logger.info(`   Max concurrent: ${config.MAX_CONCURRENT_SESSIONS}`);
-logger.info(`   KB base path: ${config.KB_BASE_PATH}`);
+logger.info(`   Brains path: ${config.BRAINS_PATH}`);
 // Track active message processing
 const processingMessages = new Set();
 // Per-thread completion signals
@@ -78,11 +78,31 @@ async function processMessage(received) {
     }
     sessionLog.info(`Processing message from ${queueMessage.sender.name} (${queueMessage.sender.id})`);
     sessionLog.info(`Thread: ${threadId}`);
-    sessionLog.info(`Persona: ${queueMessage.teamvibe.persona?.name ?? 'none'}`);
+    sessionLog.info(`Brain: ${queueMessage.teamvibe.brain?.brainId ?? 'none'}`);
     sessionLog.info(`Type: ${queueMessage.type}`);
     sessionLog.info(`Log file: ${sessionLog.getLogFile()}`);
-    // Get knowledge base path for this persona
-    const kbPath = await getKnowledgeBasePath(queueMessage.teamvibe.persona?.knowledgeBase);
+    const hasSlackContext = Boolean(queueMessage.response_context.slack?.channel &&
+        queueMessage.response_context.slack?.message_ts);
+    // Get brain path for this channel
+    let kbPath;
+    try {
+        kbPath = await getBrainPath(queueMessage.teamvibe.brain);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        sessionLog.error(`Failed to clone brain: ${errorMessage}`);
+        if (hasSlackContext) {
+            try {
+                await sendSlackError(queueMessage, `Failed to clone brain repository: ${errorMessage}`);
+                await addReaction(queueMessage, 'x');
+            }
+            catch (slackError) {
+                sessionLog.error(`Failed to send Slack error: ${slackError}`);
+            }
+        }
+        await deleteMessage(receiptHandle);
+        return;
+    }
     // Try to acquire session lock
     let lockResult = await acquireSessionLock(threadId, kbPath);
     if (!lockResult.success) {
@@ -108,17 +128,19 @@ async function processMessage(received) {
     logQueueState(`Lock acquired for ${threadId}`);
     processingMessages.add(messageId);
     const heartbeat = startHeartbeat(receiptHandle, sessionLog);
-    const hasSlackContext = Boolean(queueMessage.response_context.slack?.channel &&
-        queueMessage.response_context.slack?.message_ts);
     // Start typing indicator
     const stopTyping = hasSlackContext
         ? startTypingIndicator(queueMessage)
         : undefined;
     try {
-        const result = await spawnClaudeCode(queueMessage, sessionLog, kbPath, session.session_id || undefined, isFirstMessage, session.last_message_ts);
+        const result = await spawnClaudeCode(queueMessage, sessionLog, kbPath, session.session_id || undefined, isFirstMessage, session.last_message_ts, () => stopTyping?.());
         stopTyping?.();
         if (result.success) {
             sessionLog.info('Claude Code completed successfully');
+            // Push any changes in the channel brain repo
+            if (queueMessage.teamvibe.brain?.brainId) {
+                await pushBrainChanges(kbPath, queueMessage.teamvibe.brain.brainId);
+            }
             if (lockToken) {
                 const lastMessageTs = queueMessage.response_context.slack?.message_ts;
                 await releaseSessionLock(threadId, lockToken, 'idle', lastMessageTs);
@@ -230,6 +252,7 @@ async function main() {
         logger.info(`   Sessions table: ${config.SESSIONS_TABLE}`);
     }
     await ensureDirectories();
+    await ensureBaseBrain();
     await pollLoop();
 }
 main().catch((error) => {

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.js

@@ -15,10 +15,33 @@ 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 = args.join(' ');
+            const text = stripFlags(args);
             if (!text)
                 fail('Message text required');
             if (!CHANNEL)

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/dist/types.d.ts

@@ -29,16 +29,11 @@ export interface TeamVibeQueueMessage {
         botId: string;
         botToken: string;
         channelId: string;
-        persona: {
-            personaId: string;
-            name: string;
-            systemPrompt?: string;
-            knowledgeBase?: {
-                kbId: string;
-                gitRepoUrl: string;
-                branch: string;
-                claudePath: string;
-            };
+        brain?: {
+            brainId: string;
+            gitRepoUrl: string;
+            branch: string;
+            claudePath: string;
         };
     };
 }

package/package.json

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