bloby-bot 0.20.8 → 0.21.1

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}`);
-  }
-}