bloby-bot 0.19.2 → 0.20.0

package/supervisor/index.ts

@@ -14,6 +14,9 @@ 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, type RecentMessage } from './bloby-agent.js';
+import { parseDelegateBlocks } from './delegate-parser.js';
+import { spawnSubAgent } from './sub-agent.js';
+import { stopTask, stopAllTasks } from './task-board.js';
 import { ensureFileDirs, saveAttachment, type SavedFile } from './file-saver.js';
 import { startViteDevServers, stopViteDevServers } from './vite-dev.js';
 import { startScheduler, stopScheduler } from './scheduler.js';
@@ -1132,7 +1135,12 @@ ${!connected ? '<script>setTimeout(()=>location.reload(),4000)</script>' : ''}
             const waMirrorJid = waStatus?.connected ? waStatus.info?.phoneNumber : null;
             let waChunkBuf = '';
 
-            // Start agent query
+            // Start orchestrator query (maxTurns: 5 — fast, delegates heavy work)
+            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 = '';
@@ -1149,8 +1157,10 @@ ${!connected ? '<script>setTimeout(()=>location.reload(),4000)</script>' : ''}
                 waChunkBuf = '';
               }
 
-              // Intercept bot:done — Vite HMR handles file changes automatically
+              // 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 = '';
@@ -1180,20 +1190,55 @@ ${!connected ? '<script>setTimeout(()=>location.reload(),4000)</script>' : ''}
                   waChunkBuf = '';
                 }
 
+                // Parse <Delegate> blocks — spawn sub-agents, strip from visible text
+                log.info(`[orchestrator] Parsing response for <Delegate> blocks...`);
+                const { blocks, cleanText } = parseDelegateBlocks(eventData.content || '');
+
+                if (blocks.length) {
+                  log.info(`[orchestrator] Found ${blocks.length} delegation(s) — spawning sub-agent(s)`);
+                } else {
+                  log.info(`[orchestrator] No delegations — direct response`);
+                }
+
+                for (const block of blocks) {
+                  log.info(`[orchestrator] Spawning sub-agent: type=${block.type}, task="${block.description.slice(0, 80)}..."`);
+                  spawnSubAgent({
+                    type: block.type,
+                    description: block.description,
+                    conversationId: convId,
+                    model: freshConfig.ai.model,
+                    names: { botName, humanName },
+                    broadcastBloby,
+                    restartBackend: () => {
+                      resetBackendRestarts();
+                      stopBackend().then(() => spawnBackend(backendPort));
+                    },
+                  });
+                }
+
+                const displayContent = cleanText;
+
                 (async () => {
                   try {
                     await workerApi(`/api/conversations/${convId}/messages`, 'POST', {
-                      role: 'assistant', content: eventData.content, meta: { model: freshConfig.ai.model },
+                      role: 'assistant', content: displayContent, meta: { model: freshConfig.ai.model },
                     });
                   } catch (err: any) {
                     log.warn(`[bloby] DB persist bot response error: ${err.message}`);
                   }
                 })();
+
+                // Broadcast cleaned text (without <Delegate> blocks)
+                broadcastBloby('bot:response', { ...eventData, content: displayContent });
+                return; // prevent double-broadcast below
               }
 
-              // Stream all events to every connected client
+              // Stream all other events to every connected client
               broadcastBloby(type, eventData);
-            }, data.attachments, savedFiles, { botName, humanName }, recentMessages);
+            }, data.attachments, savedFiles, { botName, humanName }, recentMessages,
+            undefined, // no supportPrompt
+            5,         // maxTurns: orchestrator mode
+            );
           })();
           return;
         }
@@ -1231,6 +1276,23 @@ ${!connected ? '<script>setTimeout(()=>location.reload(),4000)</script>' : ''}
         return;
       }
 
+      if (msg.type === 'user:stop-task') {
+        const taskId = (msg as any).data?.taskId;
+        if (taskId) {
+          log.info(`[orchestrator] Stopping task: ${taskId}`);
+          stopTask(taskId);
+          broadcastBloby('bot:task-stopped', { taskId });
+        }
+        return;
+      }
+
+      if (msg.type === 'user:stop-all-tasks') {
+        log.info(`[orchestrator] Stopping all background tasks`);
+        stopAllTasks();
+        broadcastBloby('bot:tasks-cleared', {});
+        return;
+      }
+
       if (msg.type === 'user:clear-context') {
         (async () => {
           try {

package/supervisor/sub-agent.ts

@@ -0,0 +1,175 @@
+/**
+ * Sub-Agent Spawner — creates and manages background agent queries.
+ * Sub-agents run independently from the orchestrator, handling
+ * heavy work (coding, research) while the user keeps chatting.
+ */
+
+import { log } from '../shared/logger.js';
+import { startBlobyAgentQuery } from './bloby-agent.js';
+import { createTask, completeTask, failTask, setOnTaskPromoted, type SubAgentTask, type SubAgentType } from './task-board.js';
+import { assembleSubAgentPrompt } from '../worker/prompts/sub-agent-prompts.js';
+
+export interface SpawnOpts {
+  type: SubAgentType;
+  description: string;
+  conversationId: string;
+  model: string;
+  names: { botName: string; humanName: string };
+  broadcastBloby: (type: string, data: any) => void;
+  restartBackend: () => void;
+}
+
+/** Pending spawn options for queued tasks, keyed by task ID */
+const pendingOpts = new Map<string, SpawnOpts>();
+
+// Register the global promotion handler once (handles all queued tasks)
+setOnTaskPromoted((task: SubAgentTask) => {
+  const opts = pendingOpts.get(task.id);
+  if (opts) {
+    pendingOpts.delete(task.id);
+    log.info(`[sub-agent] Queued task ${task.id} promoted — starting agent`);
+    opts.broadcastBloby('bot:task-progress', {
+      taskId: task.id,
+      tool: 'starting',
+    });
+    runSubAgent(task, opts);
+  }
+});
+
+/**
+ * Spawn a background sub-agent for a delegated task.
+ * Returns the created task, or null if the queue is full.
+ */
+export function spawnSubAgent(opts: SpawnOpts): SubAgentTask | null {
+  log.info(`[sub-agent] ──── SPAWN REQUEST ────`);
+  log.info(`[sub-agent] Type: ${opts.type}`);
+  log.info(`[sub-agent] Description: "${opts.description.slice(0, 120)}..."`);
+  log.info(`[sub-agent] Model: ${opts.model}`);
+  log.info(`[sub-agent] Conversation: ${opts.conversationId}`);
+
+  const task = createTask(opts.type, opts.description, opts.conversationId);
+  if (!task) {
+    log.warn(`[sub-agent] Could not create task — queue full`);
+    opts.broadcastBloby('bot:task-error', {
+      error: 'Too many background tasks. Try again in a moment.',
+    });
+    return null;
+  }
+
+  // Broadcast task creation
+  opts.broadcastBloby('bot:task-created', {
+    taskId: task.id,
+    type: task.type,
+    description: task.description,
+    status: task.status,
+  });
+
+  if (task.status === 'queued') {
+    // Store opts so we can start the agent when promoted
+    pendingOpts.set(task.id, opts);
+    log.info(`[sub-agent] Task ${task.id} queued — will start when a slot opens`);
+    return task;
+  }
+
+  // Task is immediately running
+  log.info(`[sub-agent] Task ${task.id} starting immediately (slot available)`);
+  runSubAgent(task, opts);
+  return task;
+}
+
+/** Actually start the agent query for a task */
+function runSubAgent(task: SubAgentTask, opts: SpawnOpts): void {
+  const systemPrompt = assembleSubAgentPrompt(opts.type, opts.names);
+  const convId = `subagent-${task.id}`;
+
+  log.info(`[sub-agent] ──── STARTING AGENT ────`);
+  log.info(`[sub-agent] Task ID: ${task.id}`);
+  log.info(`[sub-agent] Type: ${task.type}`);
+  log.info(`[sub-agent] Conv ID: ${convId}`);
+  log.info(`[sub-agent] Prompt length: ${systemPrompt.length} chars`);
+  log.info(`[sub-agent] Task description: "${task.description.slice(0, 120)}..."`);
+
+  let fullText = '';
+  let toolCount = 0;
+
+  startBlobyAgentQuery(
+    convId,
+    task.description,
+    opts.model,
+    (type, eventData) => {
+      // Track tool usage for progress
+      if (type === 'bot:tool') {
+        toolCount++;
+        const toolName = eventData.name || 'working';
+        task.progress.push(toolName);
+        if (toolName === 'Write' || toolName === 'Edit') {
+          task.usedFileTools = true;
+        }
+        log.info(`[sub-agent] Task ${task.id} | Tool #${toolCount}: ${toolName}${eventData.input?.file_path ? ` → ${eventData.input.file_path}` : ''}`);
+        opts.broadcastBloby('bot:task-progress', {
+          taskId: task.id,
+          tool: toolName,
+          input: eventData.input,
+        });
+      }
+
+      // Accumulate response text
+      if (type === 'bot:token' && eventData.token) {
+        fullText += eventData.token;
+      }
+
+      // Store final response
+      if (type === 'bot:response') {
+        fullText = eventData.content || fullText;
+        log.info(`[sub-agent] Task ${task.id} | Response received (${fullText.length} chars)`);
+      }
+
+      // Handle completion
+      if (type === 'bot:done') {
+        const usedFiles = task.usedFileTools || eventData.usedFileTools;
+        const elapsed = Math.round((Date.now() - task.createdAt) / 1000);
+        completeTask(task.id, fullText || '(completed)', usedFiles);
+
+        log.info(`[sub-agent] ──── TASK COMPLETED ────`);
+        log.info(`[sub-agent] Task ID: ${task.id}`);
+        log.info(`[sub-agent] Duration: ${elapsed}s`);
+        log.info(`[sub-agent] Tools used: ${toolCount}`);
+        log.info(`[sub-agent] File tools: ${usedFiles}`);
+        log.info(`[sub-agent] Result preview: "${(fullText || '').slice(0, 200)}..."`);
+
+        opts.broadcastBloby('bot:task-done', {
+          taskId: task.id,
+          type: task.type,
+          description: task.description,
+          result: fullText?.slice(0, 500) || '(completed)',
+          usedFileTools: usedFiles,
+        });
+
+        // Restart backend if file tools were used
+        if (usedFiles) {
+          log.info(`[sub-agent] Task ${task.id} used file tools — restarting backend`);
+          opts.restartBackend();
+        }
+      }
+
+      // Handle errors
+      if (type === 'bot:error') {
+        const errorMsg = eventData.error || 'Unknown error';
+        failTask(task.id, errorMsg);
+        opts.broadcastBloby('bot:task-error', {
+          taskId: task.id,
+          error: errorMsg,
+        });
+        log.warn(`[sub-agent] ──── TASK FAILED ────`);
+        log.warn(`[sub-agent] Task ID: ${task.id}`);
+        log.warn(`[sub-agent] Error: ${errorMsg}`);
+      }
+    },
+    undefined, // no attachments
+    undefined, // no savedFiles
+    opts.names,
+    undefined, // no recentMessages — sub-agents don't need chat history
+    systemPrompt, // passed as supportPrompt to bypass main prompt assembly
+    50, // maxTurns — full power for sub-agents
+  );
+}

package/supervisor/task-board.ts

@@ -0,0 +1,231 @@
+/**
+ * Task Board — tracks background sub-agent tasks.
+ * In-memory only (no DB persistence). Tasks are ephemeral — they exist
+ * for the duration of the work and a short window after for reporting.
+ */
+
+import { log } from '../shared/logger.js';
+
+export type SubAgentType = 'coder' | 'researcher';
+
+export interface SubAgentTask {
+  id: string;
+  type: SubAgentType;
+  description: string;
+  status: 'queued' | 'running' | 'done' | 'error';
+  progress: string[];
+  result?: string;
+  error?: string;
+  usedFileTools: boolean;
+  createdAt: number;
+  completedAt?: number;
+  conversationId: string;
+  abortController: AbortController;
+}
+
+const tasks = new Map<string, SubAgentTask>();
+const taskQueue: SubAgentTask[] = [];
+const MAX_CONCURRENT = 3;
+const MAX_QUEUED = 5;
+/** Keep completed tasks for 5 minutes before cleanup */
+const COMPLETED_TTL = 5 * 60 * 1000;
+
+/** Callback invoked when a queued task gets promoted to running */
+let onTaskPromoted: ((task: SubAgentTask) => void) | null = null;
+
+/** Register a callback for when queued tasks are promoted */
+export function setOnTaskPromoted(cb: (task: SubAgentTask) => void) {
+  onTaskPromoted = cb;
+}
+
+function generateId(): string {
+  return 'task-' + Math.random().toString(36).slice(2, 8) + Date.now().toString(36).slice(-4);
+}
+
+function getRunningCount(): number {
+  let count = 0;
+  for (const t of tasks.values()) {
+    if (t.status === 'running') count++;
+  }
+  return count;
+}
+
+/** Create a task. Returns the task (queued or running), or null if queue is full. */
+export function createTask(
+  type: SubAgentType,
+  description: string,
+  conversationId: string,
+): SubAgentTask | null {
+  const task: SubAgentTask = {
+    id: generateId(),
+    type,
+    description,
+    status: 'queued',
+    progress: [],
+    usedFileTools: false,
+    createdAt: Date.now(),
+    conversationId,
+    abortController: new AbortController(),
+  };
+
+  if (getRunningCount() < MAX_CONCURRENT) {
+    task.status = 'running';
+    tasks.set(task.id, task);
+    log.info(`[task-board] Created task ${task.id} (${type}) — running`);
+    return task;
+  }
+
+  if (taskQueue.length >= MAX_QUEUED) {
+    log.warn(`[task-board] Queue full (${MAX_QUEUED}) — rejecting task`);
+    return null;
+  }
+
+  tasks.set(task.id, task);
+  taskQueue.push(task);
+  log.info(`[task-board] Created task ${task.id} (${type}) — queued (position ${taskQueue.length})`);
+  return task;
+}
+
+/** Mark a task as completed */
+export function completeTask(id: string, result: string, usedFileTools: boolean): void {
+  const task = tasks.get(id);
+  if (!task) return;
+  task.status = 'done';
+  task.result = result;
+  task.usedFileTools = usedFileTools;
+  task.completedAt = Date.now();
+  log.info(`[task-board] Task ${id} completed`);
+  promoteNext();
+  scheduleCleanup(id);
+}
+
+/** Mark a task as failed */
+export function failTask(id: string, error: string): void {
+  const task = tasks.get(id);
+  if (!task) return;
+  task.status = 'error';
+  task.error = error;
+  task.completedAt = Date.now();
+  log.warn(`[task-board] Task ${id} failed: ${error}`);
+  promoteNext();
+  scheduleCleanup(id);
+}
+
+/** Stop a task by aborting its controller */
+export function stopTask(id: string): boolean {
+  const task = tasks.get(id);
+  if (!task) return false;
+
+  // If queued, just remove from queue
+  if (task.status === 'queued') {
+    const idx = taskQueue.indexOf(task);
+    if (idx !== -1) taskQueue.splice(idx, 1);
+    tasks.delete(id);
+    log.info(`[task-board] Removed queued task ${id}`);
+    return true;
+  }
+
+  if (task.status === 'running') {
+    task.abortController.abort();
+    task.status = 'error';
+    task.error = 'Stopped by user';
+    task.completedAt = Date.now();
+    log.info(`[task-board] Stopped task ${id}`);
+    promoteNext();
+    scheduleCleanup(id);
+    return true;
+  }
+
+  return false;
+}
+
+/** Stop all active tasks */
+export function stopAllTasks(): void {
+  for (const task of tasks.values()) {
+    if (task.status === 'running') {
+      task.abortController.abort();
+      task.status = 'error';
+      task.error = 'Stopped by user';
+      task.completedAt = Date.now();
+    }
+  }
+  // Clear queue
+  while (taskQueue.length) {
+    const t = taskQueue.pop()!;
+    tasks.delete(t.id);
+  }
+  log.info('[task-board] All tasks stopped');
+}
+
+/** Get all active (running + queued) tasks */
+export function getActiveTasks(): SubAgentTask[] {
+  return Array.from(tasks.values()).filter(
+    (t) => t.status === 'running' || t.status === 'queued',
+  );
+}
+
+/** Get recently completed/failed tasks (within TTL window) */
+export function getRecentCompletedTasks(): SubAgentTask[] {
+  const cutoff = Date.now() - COMPLETED_TTL;
+  return Array.from(tasks.values()).filter(
+    (t) => (t.status === 'done' || t.status === 'error') && (t.completedAt || 0) > cutoff,
+  );
+}
+
+/** Format the task board as markdown for system prompt injection */
+export function formatTaskBoard(): string {
+  const active = getActiveTasks();
+  const completed = getRecentCompletedTasks();
+
+  if (!active.length && !completed.length) return '';
+
+  const lines: string[] = [];
+
+  if (active.length) {
+    lines.push('## Active Tasks');
+    for (const t of active) {
+      const elapsed = Math.round((Date.now() - t.createdAt) / 1000);
+      const time = elapsed < 60 ? `${elapsed}s ago` : `${Math.round(elapsed / 60)}m ago`;
+      const lastTool = t.progress.length ? t.progress[t.progress.length - 1] : 'starting';
+      lines.push(`- **${t.id}** (${t.type}, ${t.status}): "${t.description.slice(0, 100)}"`);
+      lines.push(`  Started ${time} | Last: ${lastTool}`);
+    }
+  }
+
+  if (completed.length) {
+    lines.push('');
+    lines.push('## Recently Completed Tasks');
+    for (const t of completed) {
+      const statusLabel = t.status === 'done' ? 'DONE' : `ERROR: ${t.error}`;
+      lines.push(`- **${t.id}** (${t.type}, ${statusLabel}): "${t.description.slice(0, 100)}"`);
+      if (t.result) {
+        lines.push(`  Result: ${t.result.slice(0, 300)}`);
+      }
+    }
+  }
+
+  return lines.join('\n');
+}
+
+// ── Internal ──
+
+function promoteNext() {
+  if (!taskQueue.length || getRunningCount() >= MAX_CONCURRENT) return;
+
+  const next = taskQueue.shift()!;
+  next.status = 'running';
+  log.info(`[task-board] Promoted queued task ${next.id} to running`);
+
+  if (onTaskPromoted) {
+    onTaskPromoted(next);
+  }
+}
+
+function scheduleCleanup(id: string) {
+  setTimeout(() => {
+    const task = tasks.get(id);
+    if (task && (task.status === 'done' || task.status === 'error')) {
+      tasks.delete(id);
+    }
+  }, COMPLETED_TTL);
+}

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

@@ -204,6 +204,70 @@ Complex cron tasks can have detailed instruction files in `tasks/{cron-id}.md`.
 
 ---
 
+# Delegation
+
+You can delegate heavy work to background sub-agents. This lets you respond quickly while work happens in parallel. The user keeps chatting with you while sub-agents build, research, or process in the background.
+
+## When to Delegate
+
+**Delegate to a sub-agent** (takes many tool calls, runs in background):
+- Building new features (pages, APIs, components)
+- Multi-file refactoring or code changes
+- Complex bug fixes requiring investigation
+- Any coding task that would take more than 2-3 tool calls
+
+**Handle directly** (quick, do it yourself):
+- Conversational responses, chitchat, questions
+- Memory file writes (MEMORY.md, MYSELF.md, MYHUMAN.md, daily notes)
+- Config edits (PULSE.json, CRONS.json, MCP.json)
+- Channel configuration (mode, admins)
+- Simple file reads or status checks
+- Setting up reminders or crons
+
+## How to Delegate
+
+Include a `<Delegate>` block in your response. The supervisor strips it from your visible message, spawns a background coding agent, and your human never sees the XML — they just see your conversational response.
+
+```
+<Delegate type="coder">
+Build a contacts page with search and tag filtering.
+- Backend: Express API at /api/contacts (GET, POST, DELETE) using SQLite
+- Frontend: React page at client/src/components/Dashboard/ContactsPage.tsx
+- Add sidebar link and route in App.tsx
+</Delegate>
+```
+
+You can include multiple `<Delegate>` blocks in one response for parallel work. Always write a natural conversational message alongside the delegation — your human should know what you're doing.
+
+**Good example:**
+> "On it! I'll build that contacts page with search and tags. Give me a few minutes."
+> `<Delegate type="coder">...</Delegate>`
+
+## Available Sub-Agent Types
+
+| Type | Use For |
+|------|---------|
+| `coder` | All coding tasks — features, fixes, refactoring, full-stack development |
+
+## Task Board
+
+A "Background Tasks" section appears in your context showing active and recently completed sub-agent tasks. Use it to:
+
+- **Report results naturally** when tasks complete: "That contacts page is ready — I added search and tag filtering."
+- **Give progress updates** if the user asks: "Still working on it — currently editing the API routes."
+- **Avoid duplicates** — check if a similar task is already running before delegating again.
+
+When a task completes, report the results to your human in your next response. Be specific about what was built or changed.
+
+## Rules
+
+- **Max 3 concurrent sub-agents.** If all slots are busy, tasks queue automatically (up to 5 queued).
+- **Keep task descriptions specific and actionable.** Include file paths, technologies, and acceptance criteria when relevant.
+- **Never delegate memory or config edits** — MYSELF.md, MYHUMAN.md, MEMORY.md, PULSE.json, CRONS.json are yours to manage directly.
+- **Always respond conversationally alongside delegation.** Don't just silently delegate — tell your human what you're doing.
+
+---
+
 ## Skills
 
 Skills live in `skills/` — each skill is a folder with instructions and resources: