bloby-bot 0.20.8 → 0.21.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bloby-bot",
-  "version": "0.20.8",
+  "version": "0.21.0",
   "releaseNotes": [
     "1. react router implemented",
     "2. new workspace design",

package/supervisor/bloby-agent.ts

@@ -1,6 +1,13 @@
 /**
- * Lightweight Claude Agent SDK wrapper for the supervisor's bloby chat.
- * Fresh context per turn — memory files and conversation history are injected into the system prompt.
+ * Claude Agent SDK wrapper — v2 Long-lived Query Model
+ *
+ * Two modes:
+ * 1. Live Conversation (main chat + admin WhatsApp):
+ *    Single long-lived query() per conversation. User messages pushed into async queue.
+ *    Agent stays alive, processes messages as they arrive, reports sub-agent completions.
+ *
+ * 2. One-shot Query (customer WhatsApp, scheduler):
+ *    Classic request-response: one query() per message. Backward compat.
  */
 
 import { query, type SDKMessage, type SDKUserMessage } from '@anthropic-ai/claude-agent-sdk';
@@ -13,18 +20,13 @@ import { getClaudeAccessToken } from '../worker/claude-auth.js';
 import { assembleSystemPrompt } from '../worker/prompts/prompt-assembler.js';
 import { buildAgents } from './agents/index.js';
 
+// ── Types ──────────────────────────────────────────────────────────────────
+
 export interface RecentMessage {
   role: 'user' | 'assistant';
   content: string;
 }
 
-interface ActiveQuery {
-  abortController: AbortController;
-  queryHandle?: any; // SDK query handle for stopTask()
-}
-
-const activeQueries = new Map<string, ActiveQuery>();
-
 export interface AgentAttachment {
   type: 'image' | 'file';
   name: string;
@@ -32,6 +34,68 @@ export interface AgentAttachment {
   data: string; // base64
 }
 
+// ── Async Queue ────────────────────────────────────────────────────────────
+
+interface AsyncQueue<T> extends AsyncIterable<T> {
+  push(item: T): void;
+  end(): void;
+}
+
+/** Create an async queue that can be used as an AsyncIterable prompt for the SDK */
+function createAsyncQueue<T>(): AsyncQueue<T> {
+  const pending: T[] = [];
+  let resolve: ((value: IteratorResult<T>) => void) | null = null;
+  let done = false;
+
+  return {
+    push(item: T) {
+      if (done) return;
+      if (resolve) {
+        resolve({ value: item, done: false });
+        resolve = null;
+      } else {
+        pending.push(item);
+      }
+    },
+    end() {
+      done = true;
+      if (resolve) resolve({ value: undefined as any, done: true });
+    },
+    [Symbol.asyncIterator]() {
+      return {
+        next(): Promise<IteratorResult<T>> {
+          if (pending.length > 0) {
+            return Promise.resolve({ value: pending.shift()!, done: false });
+          }
+          if (done) return Promise.resolve({ value: undefined as any, done: true });
+          return new Promise((r) => { resolve = r; });
+        },
+      };
+    },
+  };
+}
+
+// ── Live Conversation Manager ──────────────────────────────────────────────
+
+interface LiveConversation {
+  id: string;
+  inputQueue: AsyncQueue<SDKUserMessage>;
+  abortController: AbortController;
+  queryHandle: any;
+  onMessage: (type: string, data: any) => void;
+  /** True while the model is actively processing (between message push and result) */
+  busy: boolean;
+}
+
+const liveConversations = new Map<string, LiveConversation>();
+
+/** Check if a live conversation exists */
+export function hasConversation(conversationId: string): boolean {
+  return liveConversations.has(conversationId);
+}
+
+// ── Helpers ─────────────────────────────────────────────────────────────────
+
 /** Read a memory file from workspace, returning '(empty)' if missing or empty */
 function readMemoryFile(filename: string): string {
   try {
@@ -42,8 +106,8 @@ function readMemoryFile(filename: string): string {
   }
 }
 
-/** Read all memory + config files and return their contents */
-function readMemoryFiles(): { myself: string; myhuman: string; memory: string; pulse: string; crons: string } {
+/** Read all memory + config files */
+function readMemoryFiles() {
   return {
     myself: readMemoryFile('MYSELF.md'),
     myhuman: readMemoryFile('MYHUMAN.md'),
@@ -59,11 +123,25 @@ function formatConversationHistory(messages: RecentMessage[]): string {
   return messages.map((m) => `${m.role}: ${m.content}`).join('\n\n');
 }
 
-/** Build a multi-part prompt with attachments for the SDK */
-function buildMultiPartPrompt(text: string, attachments: AgentAttachment[], savedFiles?: SavedFile[]): AsyncIterable<SDKUserMessage> {
-  return (async function* () {
-    const content: any[] = [];
+/** Load MCP server config from workspace/MCP.json */
+function loadMcpServers(): Record<string, any> | undefined {
+  try {
+    const mcpConfigPath = path.join(WORKSPACE_DIR, 'MCP.json');
+    const mcpConfig = JSON.parse(fs.readFileSync(mcpConfigPath, 'utf-8'));
+    if (mcpConfig && typeof mcpConfig === 'object' && !Array.isArray(mcpConfig) && Object.keys(mcpConfig).length) {
+      return mcpConfig;
+    } else if (Array.isArray(mcpConfig) && mcpConfig.length) {
+      return Object.assign({}, ...mcpConfig);
+    }
+  } catch {}
+  return undefined;
+}
+
+/** Build an SDKUserMessage from text + optional attachments */
+function buildUserMessage(text: string, attachments?: AgentAttachment[], savedFiles?: SavedFile[]): SDKUserMessage {
+  const content: any[] = [];
 
+  if (attachments?.length) {
     for (const att of attachments) {
       if (att.type === 'image') {
         content.push({
@@ -77,28 +155,338 @@ function buildMultiPartPrompt(text: string, attachments: AgentAttachment[], save
         });
       }
     }
+  }
+
+  let promptText = text || '(attached files)';
+  if (savedFiles?.length) {
+    const lines = savedFiles.map((f) => `- ${f.name} -> ${f.relPath}`);
+    promptText += `\n\n[Attached files saved to disk]\n${lines.join('\n')}\nYou can read or reference these files using the paths above (relative to your cwd).`;
+  }
+
+  content.push({ type: 'text', text: promptText });
+
+  return {
+    type: 'user' as const,
+    message: { role: 'user' as const, content },
+    parent_tool_use_id: null,
+  } as SDKUserMessage;
+}
+
+// ── Live Conversation API ──────────────────────────────────────────────────
 
-    // Append local file paths so Claude can reference them with tools
-    let promptText = text || '(attached files)';
-    if (savedFiles?.length) {
-      const lines = savedFiles.map((f) => `- ${f.name} -> ${f.relPath}`);
-      promptText += `\n\n[Attached files saved to disk]\n${lines.join('\n')}\nYou can read or reference these files using the paths above (relative to your cwd).`;
+/**
+ * Start a long-lived conversation.
+ * Creates a single query() with an async input queue.
+ * Messages are pushed via pushMessage(). The query stays alive until endConversation().
+ */
+export async function startConversation(
+  conversationId: string,
+  model: string,
+  onMessage: (type: string, data: any) => void,
+  names?: { botName: string; humanName: string },
+  recentMessages?: RecentMessage[],
+): Promise<boolean> {
+  log.info(`[conversation] ──── STARTING CONVERSATION ────`);
+  log.info(`[conversation] Conv ID: ${conversationId}`);
+  log.info(`[conversation] Model: ${model}`);
+
+  // End any existing conversation with this ID
+  if (liveConversations.has(conversationId)) {
+    log.info(`[conversation] Ending existing conversation ${conversationId} before starting new one`);
+    endConversation(conversationId);
+  }
+
+  const oauthToken = await getClaudeAccessToken();
+  if (!oauthToken) {
+    log.warn('[conversation] No OAuth token — cannot start');
+    onMessage('bot:error', { conversationId, error: 'Claude OAuth token not found. Please authenticate via the dashboard.' });
+    return false;
+  }
+
+  // Assemble system prompt (once for the conversation lifetime)
+  const memoryFiles = readMemoryFiles();
+  const basePrompt = await assembleSystemPrompt(names?.botName, names?.humanName);
+  let systemPrompt = basePrompt;
+  systemPrompt += `\n\n---\n# Your Memory Files\n\n## MYSELF.md\n${memoryFiles.myself}\n\n## MYHUMAN.md\n${memoryFiles.myhuman}\n\n## MEMORY.md\n${memoryFiles.memory}\n\n---\n# Your Config Files\n\n## PULSE.json\n${memoryFiles.pulse}\n\n## CRONS.json\n${memoryFiles.crons}`;
+
+  // Inject channel config
+  try {
+    const { loadConfig: loadCfg } = await import('../shared/config.js');
+    const cfg = loadCfg();
+    const channels = (cfg as any).channels;
+    if (channels) {
+      systemPrompt += `\n\n---\n# Channel Config\n\`\`\`json\n${JSON.stringify(channels, null, 2)}\n\`\`\``;
     }
+  } catch {}
+
+  // Inject recent conversation history for context continuity
+  if (recentMessages?.length) {
+    systemPrompt += `\n\n---\n# Recent Conversation\n${formatConversationHistory(recentMessages)}`;
+  }
+
+  // Build sub-agent definitions
+  const agents = buildAgents();
+  log.info(`[conversation] Loaded ${Object.keys(agents).length} sub-agent(s): ${Object.keys(agents).join(', ')}`);
+
+  // Load MCP servers
+  const mcpServers = loadMcpServers();
+  if (mcpServers) {
+    log.info(`[conversation] MCP servers: ${Object.keys(mcpServers).join(', ')}`);
+  }
+
+  // Create the async input queue
+  const inputQueue = createAsyncQueue<SDKUserMessage>();
+  const abortController = new AbortController();
+
+  // Store the conversation
+  const conv: LiveConversation = {
+    id: conversationId,
+    inputQueue,
+    abortController,
+    queryHandle: null,
+    onMessage,
+    busy: false,
+  };
+  liveConversations.set(conversationId, conv);
+
+  log.info(`[conversation] System prompt: ${systemPrompt.length} chars`);
+  log.info(`[conversation] Starting long-lived query...`);
+
+  // Run the for-await loop in the background (fire and forget)
+  (async () => {
+    let fullText = '';
+    const usedTools = new Set<string>();
+    let stderrBuf = '';
+
+    try {
+      const claudeQuery = query({
+        prompt: inputQueue,
+        options: {
+          model,
+          cwd: WORKSPACE_DIR,
+          permissionMode: 'bypassPermissions',
+          allowDangerouslySkipPermissions: true,
+          abortController,
+          systemPrompt,
+          mcpServers,
+          agents,
+          agentProgressSummaries: true,
+          stderr: (chunk: string) => { stderrBuf += chunk; },
+          env: {
+            ...process.env as Record<string, string>,
+            CLAUDE_CODE_OAUTH_TOKEN: oauthToken,
+            CLAUDE_CODE_BUBBLEWRAP: '1',
+          },
+        },
+      });
+
+      conv.queryHandle = claudeQuery;
+      log.info(`[conversation] ──── QUERY LOOP STARTED ────`);
+
+      for await (const msg of claudeQuery) {
+        if (abortController.signal.aborted) {
+          log.info(`[conversation] Query aborted — exiting loop`);
+          break;
+        }
+
+        switch (msg.type) {
+          case 'assistant': {
+            const assistantMsg = msg.message;
+            if (!assistantMsg?.content) break;
+
+            for (const block of assistantMsg.content) {
+              if (block.type === 'text' && block.text) {
+                if (fullText && !fullText.endsWith('\n')) {
+                  fullText += '\n\n';
+                  onMessage('bot:token', { conversationId, token: '\n\n' });
+                }
+                fullText += block.text;
+                onMessage('bot:token', { conversationId, token: block.text });
+              } else if (block.type === 'tool_use') {
+                usedTools.add(block.name);
+                onMessage('bot:tool', { conversationId, name: block.name, input: block.input });
+              }
+            }
+            break;
+          }
 
-    content.push({ type: 'text', text: promptText });
+          case 'result': {
+            // Agent finished processing the current message
+            log.info(`[conversation] ──── TURN COMPLETE ────`);
+            log.info(`[conversation] Response length: ${fullText.length} chars`);
+            log.info(`[conversation] Tools used this turn: ${Array.from(usedTools).join(', ') || 'none'}`);
+
+            if (fullText) {
+              onMessage('bot:response', { conversationId, content: fullText });
+              fullText = '';
+            } else if (msg.subtype?.startsWith('error')) {
+              const errorText = (msg as any).errors?.join('; ') || 'Agent turn failed';
+              log.warn(`[conversation] Turn error: ${errorText}`);
+              onMessage('bot:error', { conversationId, error: errorText });
+            }
+
+            // Signal turn complete — backend restart + UI update
+            const FILE_TOOLS = ['Write', 'Edit'];
+            const usedFileTools = FILE_TOOLS.some((t) => usedTools.has(t));
+            onMessage('bot:turn-complete', { conversationId, usedFileTools });
+
+            // Reset per-turn state
+            usedTools.clear();
+            conv.busy = false;
+            log.info(`[conversation] Agent idle — waiting for next message`);
+            break;
+          }
+
+          case 'tool_progress':
+            onMessage('bot:tool', {
+              conversationId,
+              name: (msg as any).tool_name || 'working',
+              status: 'running',
+            });
+            break;
+
+          // ── Background sub-agent events ──
+          case 'system': {
+            const sysMsg = msg as any;
+            if (sysMsg.subtype === 'task_started') {
+              log.info(`[conversation] ──── SUB-AGENT STARTED ────`);
+              log.info(`[conversation] Task ID: ${sysMsg.task_id}`);
+              log.info(`[conversation] Description: ${sysMsg.description}`);
+              onMessage('bot:task-created', {
+                conversationId,
+                taskId: sysMsg.task_id,
+                description: sysMsg.description,
+                type: sysMsg.task_type,
+              });
+            } else if (sysMsg.subtype === 'task_progress') {
+              const summary = sysMsg.summary || sysMsg.last_tool_name || 'working';
+              log.info(`[conversation] Sub-agent ${sysMsg.task_id} | ${summary} | Tools: ${sysMsg.usage?.tool_uses || 0} | ${Math.round((sysMsg.usage?.duration_ms || 0) / 1000)}s`);
+              onMessage('bot:task-progress', {
+                conversationId,
+                taskId: sysMsg.task_id,
+                summary,
+                lastTool: sysMsg.last_tool_name,
+                usage: sysMsg.usage,
+              });
+            } else if (sysMsg.subtype === 'task_notification') {
+              log.info(`[conversation] ──── SUB-AGENT ${sysMsg.status?.toUpperCase()} ────`);
+              log.info(`[conversation] Task ID: ${sysMsg.task_id}`);
+              log.info(`[conversation] Status: ${sysMsg.status}`);
+              log.info(`[conversation] Summary: ${sysMsg.summary?.slice(0, 200)}`);
+              log.info(`[conversation] Tokens: ${sysMsg.usage?.total_tokens || 0} | Tools: ${sysMsg.usage?.tool_uses || 0} | Duration: ${Math.round((sysMsg.usage?.duration_ms || 0) / 1000)}s`);
+              onMessage('bot:task-done', {
+                conversationId,
+                taskId: sysMsg.task_id,
+                status: sysMsg.status,
+                summary: sysMsg.summary,
+                usage: sysMsg.usage,
+              });
+              // Sub-agent completion may have written files
+              if (sysMsg.status === 'completed') {
+                onMessage('bot:turn-complete', { conversationId, usedFileTools: true });
+              }
+            }
+            break;
+          }
+        }
+      }
+
+      log.info(`[conversation] ──── QUERY LOOP ENDED ────`);
 
-    yield {
-      type: 'user' as const,
-      message: { role: 'user' as const, content },
-      parent_tool_use_id: null,
-    } as SDKUserMessage;
+      // Send any remaining text
+      if (fullText && !abortController.signal.aborted) {
+        onMessage('bot:response', { conversationId, content: fullText });
+      }
+    } catch (err: any) {
+      if (!abortController.signal.aborted) {
+        const detail = stderrBuf.trim();
+        const errMsg = detail ? `${err.message}\n\nCLI stderr:\n${detail}` : err.message;
+        log.warn(`[conversation] Query error: ${errMsg}`);
+        onMessage('bot:error', { conversationId, error: errMsg });
+      }
+    } finally {
+      log.info(`[conversation] Cleaning up conversation ${conversationId}`);
+      liveConversations.delete(conversationId);
+      onMessage('bot:conversation-ended', { conversationId });
+    }
   })();
+
+  return true;
+}
+
+/**
+ * Push a user message into an existing live conversation.
+ * The agent will process it as part of the ongoing conversation.
+ */
+export function pushMessage(
+  conversationId: string,
+  content: string,
+  attachments?: AgentAttachment[],
+  savedFiles?: SavedFile[],
+): boolean {
+  const conv = liveConversations.get(conversationId);
+  if (!conv) {
+    log.warn(`[conversation] pushMessage — no live conversation ${conversationId}`);
+    return false;
+  }
+
+  log.info(`[conversation] ──── PUSH MESSAGE ────`);
+  log.info(`[conversation] Conv: ${conversationId}`);
+  log.info(`[conversation] Content: "${content.slice(0, 100)}..."`);
+  log.info(`[conversation] Attachments: ${attachments?.length || 0}`);
+  log.info(`[conversation] Agent busy: ${conv.busy}`);
+
+  const userMessage = buildUserMessage(content, attachments, savedFiles);
+  conv.busy = true;
+  conv.inputQueue.push(userMessage);
+
+  // Emit typing indicator
+  conv.onMessage('bot:typing', { conversationId });
+
+  return true;
+}
+
+/** End a live conversation */
+export function endConversation(conversationId: string): void {
+  const conv = liveConversations.get(conversationId);
+  if (!conv) return;
+
+  log.info(`[conversation] ──── ENDING CONVERSATION ────`);
+  log.info(`[conversation] Conv: ${conversationId}`);
+
+  conv.inputQueue.end();
+  conv.abortController.abort();
+  liveConversations.delete(conversationId);
+}
+
+/** Check if the agent is currently busy processing a message */
+export function isConversationBusy(conversationId: string): boolean {
+  return liveConversations.get(conversationId)?.busy || false;
+}
+
+/** Stop a specific background sub-agent task */
+export async function stopSubAgentTask(conversationId: string, taskId: string): Promise<void> {
+  const conv = liveConversations.get(conversationId);
+  if (conv?.queryHandle?.stopTask) {
+    log.info(`[conversation] Stopping sub-agent task: ${taskId}`);
+    await conv.queryHandle.stopTask(taskId);
+  } else {
+    log.warn(`[conversation] Cannot stop task ${taskId} — no live conversation ${conversationId}`);
+  }
+}
+
+// ── One-shot Query API (backward compat) ────────────────────────────────────
+// Used by: customer WhatsApp (handleCustomerMessage), scheduler (triggerAgent)
+
+interface ActiveQuery {
+  abortController: AbortController;
 }
 
+const activeQueries = new Map<string, ActiveQuery>();
 
 /**
- * Run an Agent SDK query for a bloby chat conversation.
- * Fresh context each turn — memory files and history are injected into the system prompt.
+ * Run a one-shot Agent SDK query (classic request-response).
+ * Used for customer-facing messages and scheduler triggers.
  */
 export async function startBlobyAgentQuery(
   conversationId: string,
@@ -109,9 +497,7 @@ export async function startBlobyAgentQuery(
   savedFiles?: SavedFile[],
   names?: { botName: string; humanName: string },
   recentMessages?: RecentMessage[],
-  /** Override system prompt (used for customer-facing channel messages via SUPPORT.md) */
   supportPrompt?: string,
-  /** Max agentic turns. Default 50. Orchestrator uses 5. */
   maxTurns?: number,
 ): Promise<void> {
   const oauthToken = await getClaudeAccessToken();
@@ -123,19 +509,14 @@ export async function startBlobyAgentQuery(
   const abortController = new AbortController();
   const memoryFiles = readMemoryFiles();
 
-  // Build enriched system prompt
   let enrichedPrompt: string;
   if (supportPrompt) {
-    // Customer-facing: SCRIPT.md is the ENTIRE prompt. Nothing else.
-    // No memory files, no skill instructions, no config — just the script + conversation history.
     enrichedPrompt = supportPrompt;
   } else {
-    // Admin/chat: full main system prompt with all context (dynamic fragments applied)
     const basePrompt = await assembleSystemPrompt(names?.botName, names?.humanName);
     enrichedPrompt = basePrompt;
     enrichedPrompt += `\n\n---\n# Your Memory Files\n\n## MYSELF.md\n${memoryFiles.myself}\n\n## MYHUMAN.md\n${memoryFiles.myhuman}\n\n## MEMORY.md\n${memoryFiles.memory}\n\n---\n# Your Config Files\n\n## PULSE.json\n${memoryFiles.pulse}\n\n## CRONS.json\n${memoryFiles.crons}`;
 
-    // Inject channel config (admin only)
     try {
       const { loadConfig: loadCfg } = await import('../shared/config.js');
       const cfg = loadCfg();
@@ -144,19 +525,18 @@ export async function startBlobyAgentQuery(
         enrichedPrompt += `\n\n---\n# Channel Config\n\`\`\`json\n${JSON.stringify(channels, null, 2)}\n\`\`\``;
       }
     } catch {}
-
-    // Task board is now managed natively by the SDK via background agents
   }
 
   if (recentMessages?.length) {
     enrichedPrompt += `\n\n---\n# Recent Conversation\n${formatConversationHistory(recentMessages)}`;
   }
 
+  activeQueries.set(conversationId, { abortController });
+
   let fullText = '';
   const usedTools = new Set<string>();
   let stderrBuf = '';
 
-  // If there are saved files but no inline attachments, append path info to plain text prompt
   let plainPrompt = prompt;
   if (savedFiles?.length && !attachments?.length) {
     const lines = savedFiles.map((f) => `- ${f.name} -> ${f.relPath}`);
@@ -164,43 +544,15 @@ export async function startBlobyAgentQuery(
   }
 
   const sdkPrompt: string | AsyncIterable<SDKUserMessage> =
-    attachments?.length ? buildMultiPartPrompt(prompt, attachments, savedFiles) : plainPrompt;
-
-  // Skills are discovered natively by the Claude Agent SDK via .claude-plugin/plugin.json
-  // in each skill folder. No manual injection needed — the SDK handles lazy loading.
-  // Customer mode uses SCRIPT.md exclusively (passed via supportPrompt parameter).
+    attachments?.length ? (async function* () {
+      yield buildUserMessage(prompt, attachments, savedFiles);
+    })() : plainPrompt;
 
   try {
-
-    // Load MCP server config from workspace/MCP.json if it exists
-    // Format: { "server-name": { command, args, env }, ... } (object, not array)
-    let mcpServers: Record<string, any> | undefined;
-    try {
-      const mcpConfigPath = path.join(WORKSPACE_DIR, 'MCP.json');
-      const mcpConfig = JSON.parse(fs.readFileSync(mcpConfigPath, 'utf-8'));
-      if (mcpConfig && typeof mcpConfig === 'object' && !Array.isArray(mcpConfig) && Object.keys(mcpConfig).length) {
-        // Already in correct format: { "name": { command, args, env } }
-        mcpServers = mcpConfig;
-      } else if (Array.isArray(mcpConfig) && mcpConfig.length) {
-        // Legacy array format: merge all entries into a single object
-        mcpServers = Object.assign({}, ...mcpConfig);
-      }
-      if (mcpServers) {
-        const names = Object.keys(mcpServers).join(', ');
-        log.info(`Loaded MCP server(s): [${names}]`);
-      }
-    } catch {}
-
+    const mcpServers = loadMcpServers();
     const effectiveMaxTurns = maxTurns ?? 50;
 
-    // Build sub-agent definitions (only for orchestrator/admin, not customer support)
-    let agents: Record<string, any> | undefined;
-    if (!supportPrompt && effectiveMaxTurns <= 10) {
-      agents = buildAgents();
-      log.info(`[bloby-agent] Orchestrator mode — loaded ${Object.keys(agents).length} sub-agent(s): ${Object.keys(agents).join(', ')}`);
-    }
-
-    log.info(`[bloby-agent] Starting query: conv=${conversationId}, model=${model}, maxTurns=${effectiveMaxTurns}, agents=${agents ? Object.keys(agents).join(',') : 'none'}, promptLen=${enrichedPrompt.length}`);
+    log.info(`[bloby-agent] One-shot query: conv=${conversationId}, maxTurns=${effectiveMaxTurns}`);
 
     const claudeQuery = query({
       prompt: sdkPrompt,
@@ -213,8 +565,6 @@ export async function startBlobyAgentQuery(
         abortController,
         systemPrompt: enrichedPrompt,
         mcpServers,
-        ...(agents && { agents }),
-        ...(agents && { agentProgressSummaries: true }),
         stderr: (chunk: string) => { stderrBuf += chunk; },
         env: {
           ...process.env as Record<string, string>,
@@ -224,9 +574,6 @@ export async function startBlobyAgentQuery(
       },
     });
 
-    // Store query handle for stopTask() support
-    activeQueries.set(conversationId, { abortController, queryHandle: claudeQuery });
-
     onMessage('bot:typing', { conversationId });
 
     for await (const msg of claudeQuery) {
@@ -236,10 +583,8 @@ export async function startBlobyAgentQuery(
         case 'assistant': {
           const assistantMsg = msg.message;
           if (!assistantMsg?.content) break;
-
           for (const block of assistantMsg.content) {
             if (block.type === 'text' && block.text) {
-              // Add separator between text from different assistant turns
               if (fullText && !fullText.endsWith('\n')) {
                 fullText += '\n\n';
                 onMessage('bot:token', { conversationId, token: '\n\n' });
@@ -253,83 +598,30 @@ export async function startBlobyAgentQuery(
           }
           break;
         }
-
         case 'result': {
           if (fullText) {
             onMessage('bot:response', { conversationId, content: fullText });
-            fullText = ''; // prevent duplicate
+            fullText = '';
           } else if (msg.subtype?.startsWith('error')) {
-            const errorText = (msg as any).errors?.join('; ') || 'Agent query failed';
-            onMessage('bot:error', { conversationId, error: errorText });
+            onMessage('bot:error', { conversationId, error: (msg as any).errors?.join('; ') || 'Agent query failed' });
           }
           break;
         }
-
         case 'tool_progress':
-          onMessage('bot:tool', {
-            conversationId,
-            name: (msg as any).tool_name || 'working',
-            status: 'running',
-          });
-          break;
-
-        // ── Background sub-agent events (SDK-managed) ──
-        case 'system': {
-          const sysMsg = msg as any;
-          if (sysMsg.subtype === 'task_started') {
-            log.info(`[bloby-agent] ──── SUB-AGENT STARTED ────`);
-            log.info(`[bloby-agent] Task ID: ${sysMsg.task_id}`);
-            log.info(`[bloby-agent] Description: ${sysMsg.description}`);
-            log.info(`[bloby-agent] Type: ${sysMsg.task_type || 'agent'}`);
-            onMessage('bot:task-created', {
-              conversationId,
-              taskId: sysMsg.task_id,
-              description: sysMsg.description,
-              type: sysMsg.task_type,
-            });
-          } else if (sysMsg.subtype === 'task_progress') {
-            const summary = sysMsg.summary || sysMsg.last_tool_name || 'working';
-            log.info(`[bloby-agent] Sub-agent ${sysMsg.task_id} | Progress: ${summary} | Tools: ${sysMsg.usage?.tool_uses || 0} | ${Math.round((sysMsg.usage?.duration_ms || 0) / 1000)}s`);
-            onMessage('bot:task-progress', {
-              conversationId,
-              taskId: sysMsg.task_id,
-              summary,
-              lastTool: sysMsg.last_tool_name,
-              usage: sysMsg.usage,
-            });
-          } else if (sysMsg.subtype === 'task_notification') {
-            log.info(`[bloby-agent] ──── SUB-AGENT ${sysMsg.status?.toUpperCase()} ────`);
-            log.info(`[bloby-agent] Task ID: ${sysMsg.task_id}`);
-            log.info(`[bloby-agent] Status: ${sysMsg.status}`);
-            log.info(`[bloby-agent] Summary: ${sysMsg.summary?.slice(0, 200)}`);
-            log.info(`[bloby-agent] Tokens: ${sysMsg.usage?.total_tokens || 0} | Tools: ${sysMsg.usage?.tool_uses || 0} | Duration: ${Math.round((sysMsg.usage?.duration_ms || 0) / 1000)}s`);
-            onMessage('bot:task-done', {
-              conversationId,
-              taskId: sysMsg.task_id,
-              status: sysMsg.status,
-              summary: sysMsg.summary,
-              usage: sysMsg.usage,
-            });
-            // If the sub-agent wrote files, flag it
-            if (sysMsg.status === 'completed') {
-              usedTools.add('Write'); // ensure backend restart
-            }
-          }
+          onMessage('bot:tool', { conversationId, name: (msg as any).tool_name || 'working', status: 'running' });
           break;
-        }
       }
     }
 
-    // If we accumulated text but didn't hit a result message, send what we have
     if (fullText && !abortController.signal.aborted) {
       onMessage('bot:response', { conversationId, content: fullText });
     }
   } catch (err: any) {
     if (!abortController.signal.aborted) {
       const detail = stderrBuf.trim();
-      const msg = detail ? `${err.message}\n\nCLI stderr:\n${detail}` : err.message;
-      log.warn(`Bloby agent error (${conversationId}): ${msg}`);
-      onMessage('bot:error', { conversationId, error: msg });
+      const errMsg = detail ? `${err.message}\n\nCLI stderr:\n${detail}` : err.message;
+      log.warn(`Bloby agent error (${conversationId}): ${errMsg}`);
+      onMessage('bot:error', { conversationId, error: errMsg });
     }
   } finally {
     activeQueries.delete(conversationId);
@@ -339,7 +631,7 @@ export async function startBlobyAgentQuery(
   }
 }
 
-/** Stop an in-flight query */
+/** Stop a one-shot query */
 export function stopBlobyAgentQuery(conversationId: string): void {
   const q = activeQueries.get(conversationId);
   if (q) {
@@ -347,14 +639,3 @@ export function stopBlobyAgentQuery(conversationId: string): void {
     activeQueries.delete(conversationId);
   }
 }
-
-/** Stop a specific background sub-agent task */
-export async function stopSubAgentTask(conversationId: string, taskId: string): Promise<void> {
-  const q = activeQueries.get(conversationId);
-  if (q?.queryHandle?.stopTask) {
-    log.info(`[bloby-agent] Stopping sub-agent task: ${taskId}`);
-    await q.queryHandle.stopTask(taskId);
-  } else {
-    log.warn(`[bloby-agent] Cannot stop task ${taskId} — no active query for ${conversationId}`);
-  }
-}

package/supervisor/channels/manager.ts

@@ -20,7 +20,7 @@ import path from 'path';
 import { loadConfig } from '../../shared/config.js';
 import { WORKSPACE_DIR } from '../../shared/paths.js';
 import { log } from '../../shared/logger.js';
-import { startBlobyAgentQuery, type RecentMessage } from '../bloby-agent.js';
+import { startBlobyAgentQuery, startConversation, pushMessage, hasConversation, type RecentMessage } from '../bloby-agent.js';
 import { WhatsAppChannel } from './whatsapp.js';
 import type { ChannelConfig, ChannelProvider, ChannelStatus, ChannelType, InboundMessage, InboundMessageAttachment, SenderRole } from './types.js';
 import type { AgentAttachment } from '../bloby-agent.js';
@@ -392,14 +392,14 @@ export class ChannelManager {
     // Show "typing..." while the agent processes
     this.startTyping(msg.channel, msg.rawSender);
 
-    // Track text chunks for WhatsApp — send intermediate chunks when agent pauses for tool use
+    // Track text chunks for WhatsApp — lives for the conversation lifetime
     let waChunkBuf = '';
 
-    startBlobyAgentQuery(
-      convId,
-      channelContext + msg.text,
-      model,
-      (type, eventData) => {
+    // Start a live conversation if one doesn't exist (shared with chat UI)
+    if (!hasConversation(convId)) {
+      log.info(`[channels] Starting live conversation for admin: ${convId}`);
+
+      await startConversation(convId, model, (type, eventData) => {
         // Accumulate text tokens
         if (type === 'bot:token' && eventData.token) {
           waChunkBuf += eventData.token;
@@ -414,7 +414,7 @@ export class ChannelManager {
         }
 
         if (type === 'bot:response' && eventData.content) {
-          // Send remaining text after the last tool use (or the full response if no tools were used)
+          // Send remaining text
           const remaining = waChunkBuf.trim();
           if (remaining) {
             this.sendMessage(msg.channel, msg.rawSender, remaining).catch((err) => {
@@ -431,22 +431,22 @@ export class ChannelManager {
           }).catch(() => {});
         }
 
-        // Mirror streaming + task events to chat clients
-        if (type === 'bot:token' || type === 'bot:response' || type === 'bot:typing' || type === 'bot:tool' || type.startsWith('bot:task-')) {
-          broadcastBloby(type, eventData);
-        }
-
-        if (type === 'bot:done' && eventData.usedFileTools) {
+        // Handle turn completion — restart backend if needed
+        if (type === 'bot:turn-complete' && eventData.usedFileTools) {
           this.opts.restartBackend();
         }
-      },
-      agentAttachments,
-      undefined,
-      { botName, humanName },
-      recentMessages,
-      undefined, // no supportPrompt
-      8,         // maxTurns: orchestrator mode
-    );
+
+        // Don't forward internal events to chat clients
+        if (type === 'bot:turn-complete' || type === 'bot:conversation-ended') return;
+
+        // Mirror streaming + task events to chat clients
+        broadcastBloby(type, eventData);
+      }, { botName, humanName }, recentMessages);
+    }
+
+    // Push the message into the live conversation
+    const channelContent = channelContext + msg.text;
+    pushMessage(convId, channelContent, agentAttachments);
   }
 
   /** Handle message from a customer — runs support agent in parallel with conversation context */

package/supervisor/index.ts

@@ -13,7 +13,12 @@ import { createWorkerApp } from '../worker/index.js';
 import { closeDb, getSession, getSetting } from '../worker/db.js';
 import { spawnBackend, stopBackend, getBackendPort, isBackendAlive, isBackendStopping, resetBackendRestarts } from './backend.js';
 import { updateTunnelUrl, startHeartbeat, stopHeartbeat, disconnect } from '../shared/relay.js';
-import { startBlobyAgentQuery, stopBlobyAgentQuery, stopSubAgentTask, type RecentMessage } from './bloby-agent.js';
+import {
+  startConversation, pushMessage, hasConversation, endConversation,
+  isConversationBusy, stopSubAgentTask,
+  startBlobyAgentQuery, stopBlobyAgentQuery,
+  type RecentMessage,
+} from './bloby-agent.js';
 import { ensureFileDirs, saveAttachment, type SavedFile } from './file-saver.js';
 import { startViteDevServers, stopViteDevServers } from './vite-dev.js';
 import { startScheduler, stopScheduler } from './scheduler.js';
@@ -1127,84 +1132,101 @@ ${!connected ? '<script>setTimeout(()=>location.reload(),4000)</script>' : ''}
               }
             } catch {}
 
-            // Mirror chat responses to WhatsApp self-chat (if connected)
-            const waStatus = channelManager.getStatus('whatsapp');
-            const waMirrorJid = waStatus?.connected ? waStatus.info?.phoneNumber : null;
-            let waChunkBuf = '';
-
-            // Start orchestrator query (maxTurns: 8 — quick tasks direct, coding delegated)
             log.info(`[orchestrator] ──── USER MESSAGE ────`);
             log.info(`[orchestrator] Content: "${content.slice(0, 100)}..."`);
-            log.info(`[orchestrator] Model: ${freshConfig.ai.model}`);
             log.info(`[orchestrator] Conv: ${convId}`);
-            log.info(`[orchestrator] MaxTurns: 5 (orchestrator mode)`);
-            agentQueryActive = true;
-            currentStreamConvId = convId;
-            currentStreamBuffer = '';
-            startBlobyAgentQuery(convId, content, freshConfig.ai.model, (type, eventData) => {
-              // Track stream buffer for reconnecting clients
-              if (type === 'bot:token' && eventData.token) {
-                currentStreamBuffer += eventData.token;
-                if (waMirrorJid) waChunkBuf += eventData.token;
-              }
+            log.info(`[orchestrator] Live conversation exists: ${hasConversation(convId)}`);
 
-              // WhatsApp mirror: send intermediate chunk when agent pauses for tool use
-              if (type === 'bot:tool' && waMirrorJid && waChunkBuf.trim()) {
-                channelManager.sendMessage('whatsapp', `${waMirrorJid}@s.whatsapp.net`, waChunkBuf.trim()).catch(() => {});
-                waChunkBuf = '';
-              }
+            // Start a live conversation if one doesn't exist
+            if (!hasConversation(convId)) {
+              log.info(`[orchestrator] Starting new live conversation...`);
 
-              // Intercept bot:done — orchestrator turn finished
-              if (type === 'bot:done') {
-                log.info(`[orchestrator] ──── TURN COMPLETE ────`);
-                log.info(`[orchestrator] File tools used: ${eventData.usedFileTools}`);
-                agentQueryActive = false;
-                currentStreamConvId = null;
-                currentStreamBuffer = '';
-                // Restart if agent used file tools OR file watcher detected changes during the turn
-                if (eventData.usedFileTools || pendingBackendRestart) {
-                  console.log('[supervisor] Agent turn ended — restarting backend');
-                  pendingBackendRestart = false;
-                  if (backendRestartTimer) { clearTimeout(backendRestartTimer); backendRestartTimer = null; }
-                  resetBackendRestarts();
-                  stopBackend().then(() => spawnBackend(backendPort));
-                }
-                // Run deferred update if agent requested one
-                if (pendingUpdate) {
-                  pendingUpdate = false;
-                  runDeferredUpdate();
+              // WhatsApp mirror state — lives for the conversation lifetime
+              let waChunkBuf = '';
+
+              await startConversation(convId, freshConfig.ai.model, (type, eventData) => {
+                // Check WA mirror on each event (connection state may change)
+                const waStatus = channelManager.getStatus('whatsapp');
+                const waMirrorJid = waStatus?.connected ? waStatus.info?.phoneNumber : null;
+
+                // Track stream buffer for reconnecting clients
+                if (type === 'bot:typing') {
+                  currentStreamConvId = convId;
+                  currentStreamBuffer = '';
+                  agentQueryActive = true;
                 }
-                return; // don't forward bot:done to client
-              }
 
-              // Save assistant response to DB + clear stream state
-              if (type === 'bot:response') {
-                currentStreamBuffer = '';
+                if (type === 'bot:token' && eventData.token) {
+                  currentStreamBuffer += eventData.token;
+                  if (waMirrorJid) waChunkBuf += eventData.token;
+                }
 
-                // WhatsApp mirror: send remaining chunk
-                if (waMirrorJid && waChunkBuf.trim()) {
+                // WhatsApp mirror: send intermediate chunk when agent pauses for tool use
+                if (type === 'bot:tool' && waMirrorJid && waChunkBuf.trim()) {
                   channelManager.sendMessage('whatsapp', `${waMirrorJid}@s.whatsapp.net`, waChunkBuf.trim()).catch(() => {});
                   waChunkBuf = '';
                 }
 
-                (async () => {
-                  try {
-                    await workerApi(`/api/conversations/${convId}/messages`, 'POST', {
-                      role: 'assistant', content: eventData.content, meta: { model: freshConfig.ai.model },
-                    });
-                  } catch (err: any) {
-                    log.warn(`[bloby] DB persist bot response error: ${err.message}`);
+                // Agent finished a turn — handle backend restart + state cleanup
+                if (type === 'bot:turn-complete') {
+                  log.info(`[orchestrator] ──── TURN COMPLETE ────`);
+                  log.info(`[orchestrator] File tools used: ${eventData.usedFileTools}`);
+                  agentQueryActive = false;
+                  currentStreamConvId = null;
+                  currentStreamBuffer = '';
+
+                  if (eventData.usedFileTools || pendingBackendRestart) {
+                    log.info('[orchestrator] Restarting backend (file tools used)');
+                    pendingBackendRestart = false;
+                    if (backendRestartTimer) { clearTimeout(backendRestartTimer); backendRestartTimer = null; }
+                    resetBackendRestarts();
+                    stopBackend().then(() => spawnBackend(backendPort));
                   }
-                })();
-              }
+                  if (pendingUpdate) {
+                    pendingUpdate = false;
+                    runDeferredUpdate();
+                  }
+                  return; // don't forward to client
+                }
+
+                // Conversation ended (query loop exited)
+                if (type === 'bot:conversation-ended') {
+                  log.info(`[orchestrator] Conversation ended: ${convId}`);
+                  agentQueryActive = false;
+                  currentStreamConvId = null;
+                  currentStreamBuffer = '';
+                  return;
+                }
 
-              // Stream all events to every connected client
-              // (includes bot:task-created, bot:task-progress, bot:task-done from SDK)
-              broadcastBloby(type, eventData);
-            }, data.attachments, savedFiles, { botName, humanName }, recentMessages,
-            undefined, // no supportPrompt
-            8,         // maxTurns: orchestrator mode
-            );
+                // Save assistant response to DB
+                if (type === 'bot:response') {
+                  currentStreamBuffer = '';
+
+                  // WhatsApp mirror: send remaining chunk
+                  if (waMirrorJid && waChunkBuf.trim()) {
+                    channelManager.sendMessage('whatsapp', `${waMirrorJid}@s.whatsapp.net`, waChunkBuf.trim()).catch(() => {});
+                    waChunkBuf = '';
+                  }
+
+                  (async () => {
+                    try {
+                      await workerApi(`/api/conversations/${convId}/messages`, 'POST', {
+                        role: 'assistant', content: eventData.content, meta: { model: freshConfig.ai.model },
+                      });
+                    } catch (err: any) {
+                      log.warn(`[bloby] DB persist bot response error: ${err.message}`);
+                    }
+                  })();
+                }
+
+                // Stream all events to every connected client
+                broadcastBloby(type, eventData);
+              }, { botName, humanName }, recentMessages);
+            }
+
+            // Push the user message into the live conversation
+            log.info(`[orchestrator] Pushing message into live conversation`);
+            pushMessage(convId, content, data.attachments, savedFiles);
           })();
           return;
         }
@@ -1238,7 +1260,13 @@ ${!connected ? '<script>setTimeout(()=>location.reload(),4000)</script>' : ''}
       }
 
       if (msg.type === 'user:stop') {
-        stopBlobyAgentQuery(convId);
+        // End the live conversation (if any) or stop a one-shot query
+        if (hasConversation(convId)) {
+          log.info(`[orchestrator] user:stop — ending live conversation ${convId}`);
+          endConversation(convId);
+        } else {
+          stopBlobyAgentQuery(convId);
+        }
         return;
       }
 
@@ -1256,6 +1284,11 @@ ${!connected ? '<script>setTimeout(()=>location.reload(),4000)</script>' : ''}
       if (msg.type === 'user:clear-context') {
         (async () => {
           try {
+            // End the live conversation
+            if (hasConversation(convId)) {
+              log.info(`[orchestrator] clear-context — ending live conversation ${convId}`);
+              endConversation(convId);
+            }
             clientConvs.delete(ws);
             await workerApi('/api/context/clear', 'POST');
           } catch (err: any) {
@@ -1325,11 +1358,14 @@ ${!connected ? '<script>setTimeout(()=>location.reload(),4000)</script>' : ''}
     }
   });
 
-  // Track whether an agent query is active — file watcher defers to bot:done during turns
+  // Track whether an agent is actively processing — file watcher defers restarts during active turns
   let agentQueryActive = false;
   let pendingBackendRestart = false; // Set when file watcher fires during agent turn
   let pendingUpdate = false; // Set when .update file is created during agent turn
 
+  // Note: with live conversations, agentQueryActive is true while the agent processes a message
+  // and false when it's idle (waiting for next message). The live conversation stays alive between messages.
+
   // Run bloby update as a child process.
   // BLOBY_SELF_UPDATE=1 tells bin/cli.js to skip daemon stop/restart —
   // the supervisor exits after the update finishes, and systemd (Restart=on-failure)

package/worker/prompts/bloby-system-prompt.txt

@@ -221,7 +221,7 @@ You handle two kinds of work differently:
 - Complex research or data gathering
 - Any coding task that touches workspace source files (client/, backend/)
 
-For quick tasks, use your tools directly — Read, Write, Edit, Bash. You have 5 turns, plenty for a config edit or memory write.
+For quick tasks, use your tools directly — Read, Write, Edit, Bash.
 
 For coding tasks, use the Agent tool. It runs in the background — you respond immediately while the work happens behind the scenes.