@bahulam/code 0.1.6 → 0.1.7

package/src/core/stream-client.mjs

@@ -820,7 +820,7 @@ export class TarangStreamClient {
             tool,
             args || {},
             true,
-            { risk, reason },
+            { risk, reason, tool_id, call_id: tool_id, request_id: tool_id },
         );
 
         // Map ApprovalManager decision to framework scope
@@ -930,9 +930,10 @@ export class TarangStreamClient {
     }
 
     /**
-     * Submit a live-steering follow-up on the current running task (PRD-081 §5.2).
-     * Unlike resume(), this does NOT pause/unpause — the text is queued and
-     * delivered at the next tool boundary.
+     * Submit a live-steering user follow-up on the current running task
+     * (PRD-081 §5.2). Unlike resume(), this does NOT pause/unpause — the text
+     * is queued and delivered at the next tool boundary as a high-priority user
+     * intervention, never as a tool call.
      *
      * Returns a status object; callers should NOT swallow errors:
      *   { status: 'accepted', interventionId }        — queued on backend, SSE ack forthcoming
@@ -946,6 +947,7 @@ export class TarangStreamClient {
      * @param {string} [opts.idempotencyKey]  Optional client-generated id.
      *                                        Auto-generated when omitted; pass the same key
      *                                        for retries to stay idempotent.
+     * @param {string} [opts.priority]        User-message priority metadata.
      */
     async sendIntervention(instruction, opts = {}) {
         if (!this.currentTaskId) {
@@ -967,6 +969,9 @@ export class TarangStreamClient {
                     body: JSON.stringify({
                         instruction: text,
                         intervention_id: interventionId,
+                        role: 'user',
+                        message_type: 'user_intervention',
+                        priority: opts.priority || 'high',
                     }),
                 },
             );

package/src/core/tool-executor.mjs

@@ -19,12 +19,14 @@ import { SkillsLoader } from '../skills/loader.mjs';
 import { createAgentFile, listLocalAgents, syncAgentsToBackend } from '../agents/scaffold.mjs';
 import { createWorkflowFile, listLocalWorkflows, WORKFLOW_SYNC_ENDPOINT, slugifyWorkflowName } from '../agents/workflow_scaffold.mjs';
 import { TarangAuth } from '../auth/tarang-auth.mjs';
+import { detectImageFile } from './attachments.mjs';
 import { streamResponse } from './streaming.mjs';
 import { sendApprovalDecision, sendCallback } from './callback-client.mjs';
 import { HookRunner } from '../config/hook-runner.mjs';
 import { buildFileDiff } from './file-diff.mjs';
 import { buildWorkScope } from './work-scope.mjs';
 import { loadDiskMemory, ensureBahulamDir, globalMemoryPath, projectMemoryPath } from './memory-disk.mjs';
+import { resolveLintCommand } from './lint-resolver.mjs';
 import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
@@ -487,15 +489,6 @@ export function createToolExecutor({
 
     // ── Auto-lint after file writes ────────────────────────────
 
-    const LINT_COMMANDS = {
-        '.py':  (file) => `python3 -m py_compile "${file}" 2>&1`,
-        '.js':  (file) => `npx eslint --no-eslintrc --rule '{}' "${file}" 2>&1 || true`,
-        '.ts':  (file) => `npx tsc --noEmit --pretty "${file}" 2>&1 || true`,
-        '.tsx': (file) => `npx tsc --noEmit --pretty "${file}" 2>&1 || true`,
-        '.go':  (file) => `go vet "${file}" 2>&1`,
-        '.rs':  (file) => `rustfmt --check "${file}" 2>&1`,
-    };
-
     // tsc --pretty and eslint emit ANSI codes (including background-red
     // highlights) which bleed when our renderer slices the first 80 chars.
     // Strip color codes so the stored lint string is always plain text.
@@ -503,15 +496,19 @@ export function createToolExecutor({
     function stripAnsi(s) { return String(s || '').replace(ANSI_RE, ''); }
 
     function autoLint(filePath) {
-        const ext = path.extname(filePath);
-        const cmdFn = LINT_COMMANDS[ext];
-        if (!cmdFn) return null;
+        const project = projectRegistry.projectForPath(filePath);
+        const lint = resolveLintCommand(filePath, {
+            projectRoot: project?.resource?.root || projectRootFor(filePath),
+            projectCommands: project?.resource?.commands || {},
+            allowProjectScript: false,
+        });
+        if (!lint?.command) return null;
 
         try {
-            const output = execSync(cmdFn(filePath), {
+            const output = execSync(lint.command, {
                 encoding: 'utf-8',
                 timeout: 15_000,
-                cwd: process.cwd(),
+                cwd: lint.cwd,
                 stdio: ['pipe', 'pipe', 'pipe'],
                 env: { ...process.env, FORCE_COLOR: '0', NO_COLOR: '1', TERM: 'dumb' },
             });
@@ -695,6 +692,52 @@ export function createToolExecutor({
             };
         },
 
+        analyze_image: async (args, options = {}) => {
+            throwIfAborted(options.signal);
+            const tool = occRegistry.get('analyze_image');
+            if (!tool) {
+                return { success: false, output: 'analyze_image tool is not registered in the CLI.', _tool: 'analyze_image' };
+            }
+            try {
+                const result = await tool.call(args || {});
+                throwIfAborted(options.signal);
+                if (typeof result === 'string') {
+                    return { success: !/^error\b/i.test(result), output: result, _tool: 'analyze_image' };
+                }
+                return {
+                    success: result?.success !== false,
+                    output: result?.output || result?.summary || JSON.stringify(result),
+                    ...result,
+                    _tool: 'analyze_image',
+                };
+            } catch (err) {
+                return { success: false, output: String(err?.message || err), _tool: 'analyze_image' };
+            }
+        },
+
+        generate_image: async (args, options = {}) => {
+            throwIfAborted(options.signal);
+            const tool = occRegistry.get('generate_image');
+            if (!tool) {
+                return { success: false, output: 'generate_image tool is not registered in the CLI.', _tool: 'generate_image' };
+            }
+            try {
+                const result = await tool.call(args || {});
+                throwIfAborted(options.signal);
+                if (typeof result === 'string') {
+                    return { success: !/^error\b/i.test(result), output: result, _tool: 'generate_image' };
+                }
+                return {
+                    success: result?.success !== false,
+                    output: result?.output || JSON.stringify(result),
+                    ...result,
+                    _tool: 'generate_image',
+                };
+            } catch (err) {
+                return { success: false, output: String(err?.message || err), _tool: 'generate_image' };
+            }
+        },
+
         // 0b. read_attachment → chunked text extraction from a local document.
         // Backend registers the schema; execution happens client-side because
         // only the CLI has the user's filesystem. Supports the `path` mode
@@ -734,6 +777,17 @@ export function createToolExecutor({
                 return { success: false, output: String(err?.message || err), _tool: 'read_attachment' };
             }
 
+            const imageInfo = detectImageFile(abs);
+            if (imageInfo) {
+                return {
+                    success: false,
+                    output: `This file is an image (${imageInfo.mime_type}). read_attachment only extracts text documents. Use analyze_image with a specific question. If analyze_image already failed, report that vision error directly instead of retrying this image with read_attachment.`,
+                    _tool: 'read_attachment',
+                    _path: abs,
+                    _mime: imageInfo.mime_type,
+                };
+            }
+
             const { extractFromPath } = await import('../context/prose-chunker.mjs');
             let mime, chunks;
             try {
@@ -747,7 +801,7 @@ export function createToolExecutor({
             if (!chunks.length) {
                 return {
                     success: false,
-                    output: `Unsupported or empty file (mime=${mime}). Supported: pdf, txt, md/mdx, csv, tsv, json, yaml, toml, html, log, rst. For CSV/Excel analysis use read_table; for images use analyze_image.`,
+                    output: `Unsupported or empty file (mime=${mime}). Supported text: pdf, txt, md/mdx, ipynb, csv, tsv, json, yaml, toml, xml, html, log, rst, sql, sh, .env, .ini, Dockerfile, .gitignore — plus any file whose first 8KB is valid UTF-8 (auto-sniffed). For CSV/Excel analysis use read_table; for images use analyze_image. If analyze_image already failed for this file, report that vision error directly instead of retrying with read_attachment.`,
                     _tool: 'read_attachment',
                 };
             }
@@ -966,10 +1020,12 @@ export function createToolExecutor({
                     filteredLines: rawOutput.split('\n').length,
                 }
                 : filterOutput(rawOutput, args.command, success);
+            const agentOutput = observationTimeout && timedOut ? filtered.output : rawOutput;
 
             return {
                 success,
-                output: filtered.output,
+                output: agentOutput,
+                output_preview: filtered.output,
                 exit_code: exitCode,
                 _tool: 'shell',
                 _classification: args._classification,
@@ -1608,24 +1664,44 @@ print('OK: replaced')
             try {
                 throwIfAborted(options.signal);
                 const filePath = await resolvePath(args.file_path || args.path, args);
-                const ext = path.extname(filePath);
-                let cmd;
-                if (ext === '.py') cmd = `python3 -m ruff check "${filePath}" 2>&1 || true`;
-                else if (['.js', '.mjs', '.ts', '.tsx'].includes(ext)) cmd = `npx eslint "${filePath}" 2>&1 || true`;
-                else return { success: true, issues: [], message: 'No linter for this file type', _tool: 'lint_check' };
+                const project = projectRegistry.projectForPath(filePath);
+                const lint = resolveLintCommand(filePath, {
+                    projectRoot: project?.resource?.root || projectRootFor(filePath),
+                    projectCommands: project?.resource?.commands || {},
+                    allowProjectScript: true,
+                });
+                if (!lint?.command) {
+                    return {
+                        success: true,
+                        issues: [],
+                        message: 'No project-aware linter for this path or file type',
+                        _tool: 'lint_check',
+                    };
+                }
 
-                const output = await occRegistry.call('shell', {
-                    command: cmd,
+                const shellResult = await executeToolWithHooks('shell', {
+                    command: lint.command,
                     timeout: 30_000,
-                    description: `Lint: ${path.basename(filePath)}`,
-                    cwd: projectRootFor(filePath),
-                    signal: options.signal,
-                });
-                const rawOutput = typeof output === 'string' ? output : String(output);
+                    description: `Lint: ${path.basename(filePath)} (${lint.source})`,
+                    cwd: lint.cwd,
+                }, options);
+                const rawOutput = typeof shellResult?.output === 'string'
+                    ? shellResult.output
+                    : (typeof shellResult === 'string' ? shellResult : String(shellResult));
                 if (/^Error:\s*Command cancelled by user/i.test(rawOutput)) {
                     return { success: false, output: 'Cancelled by user', _cancelled: true, _tool: 'lint_check' };
                 }
-                return { success: true, output: rawOutput, issues: rawOutput.split('\n').filter(Boolean), _tool: 'lint_check' };
+                const normalizedOutput = rawOutput === '(no output)' ? '' : rawOutput;
+                return {
+                    success: true,
+                    output: normalizedOutput || 'No lint issues found.',
+                    command: lint.command,
+                    cwd: lint.cwd,
+                    language: lint.language,
+                    lint_source: lint.source,
+                    issues: normalizedOutput.split('\n').filter(Boolean),
+                    _tool: 'lint_check',
+                };
             } catch (err) {
                 if (isAbortError(err) || options.signal?.aborted) return cancelledToolResult('lint_check');
                 return { success: false, output: err.message, _tool: 'lint_check' };

package/src/daemon/http-dashboard.mjs

@@ -0,0 +1,400 @@
+/**
+ * HTTP + WebSocket dashboard — mirrors the CLI session in a browser.
+ *
+ * Uses ONLY Node built-ins (http, crypto, buffer). No npm dependencies.
+ * Serves an inline single-page HTML dashboard with a WebSocket-backed event
+ * stream showing agent/sub-agent activity, tool calls, handoffs, spawns.
+ *
+ * Architecture (matching socket-server.mjs):
+ *   startHttpDashboard({ sessionId, port }) -> { url, broadcastEvent, close }
+ *   - Registers itself via registerBroadcaster(fn) from event-tap.mjs
+ *   - Binds to 127.0.0.1 only
+ *   - WebSocket at /ws (RFC 6455 handshake)
+ *   - Dashboard HTML served at /
+ *   - Auth token in URL path for basic access control
+ *
+ * @module
+ */
+import http from 'node:http';
+import crypto from 'node:crypto';
+import { registerBroadcaster } from './event-tap.mjs';
+
+const WS_GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11';
+
+/**
+ * @param {object} opts
+ * @param {string} opts.sessionId
+ * @param {number} [opts.port=0]        — 0 = OS-assigned
+ * @param {string} [opts.secret]         — random token for URL path
+ * @returns {Promise<{url:string, port:number, broadcastEvent:(obj:any)=>void, close:()=>void}>}
+ */
+export async function startHttpDashboard({ sessionId, port = 0, secret } = {}) {
+  const token = secret || crypto.randomBytes(12).toString('hex');
+  const pathPrefix = `/dashboard/${token}`;
+
+  /** @type {Set<import('net').Socket>} */
+  const wsClients = new Set();
+
+  const server = http.createServer((req, res) => {
+    // WebSocket upgrade
+    if (req.headers.upgrade?.toLowerCase() === 'websocket') {
+      return handleWebSocketUpgrade(req, res, wsClients);
+    }
+    // Serve the HTML dashboard
+    if (req.url.startsWith(pathPrefix) || req.url === '/') {
+      res.writeHead(200, {
+        'Content-Type': 'text/html; charset=utf-8',
+        'Cache-Control': 'no-store',
+      });
+      res.end(DASHBOARD_HTML(token));
+      return;
+    }
+    // Health endpoint
+    if (req.url === '/health') {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ ok: true, sessionId, clients: wsClients.size }));
+      return;
+    }
+    res.writeHead(404);
+    res.end('Not found');
+  });
+
+  // Bind to localhost only
+  await new Promise((resolve, reject) => {
+    server.listen(port, '127.0.0.1', () => {
+      const addr = server.address();
+      resolve(addr);
+    });
+    server.once('error', reject);
+  });
+
+  const addr = server.address();
+  const actualPort = addr.port;
+  const url = `http://127.0.0.1:${actualPort}/${pathPrefix}`;
+
+  // Register as event broadcaster so tapSseEvent pushes to us
+  const unregister = registerBroadcaster((event) => {
+    broadcastEvent(event);
+  });
+
+  function broadcastEvent(obj) {
+    if (wsClients.size === 0) return;
+    const frame = encodeWSFrame(JSON.stringify(obj));
+    for (const sock of wsClients) {
+      try { sock.write(frame); } catch { /* single-client failure doesn't cascade */ }
+    }
+  }
+
+  function close() {
+    unregister();
+    for (const sock of wsClients) {
+      try { sock.end(); } catch { /* no-op */ }
+    }
+    wsClients.clear();
+    server.close();
+  }
+
+  return { url, port: actualPort, broadcastEvent, close };
+}
+
+// ── WebSocket helpers (RFC 6455, text frames only) ──
+
+function handleWebSocketUpgrade(req, sock, clients) {
+  const key = req.headers['sec-websocket-key'];
+  if (!key) {
+    sock.destroy();
+    return;
+  }
+  const accept = crypto.createHash('sha1').update(key + WS_GUID).digest('base64');
+  sock.write(
+    'HTTP/1.1 101 Switching Protocols\r\n' +
+    'Upgrade: websocket\r\n' +
+    'Connection: Upgrade\r\n' +
+    `Sec-WebSocket-Accept: ${accept}\r\n` +
+    '\r\n'
+  );
+  clients.add(sock);
+  sock.once('close', () => clients.delete(sock));
+  sock.once('error', () => clients.delete(sock));
+}
+
+function encodeWSFrame(payload) {
+  const data = Buffer.from(payload, 'utf-8');
+  const len = data.length;
+  let header;
+  if (len < 126) {
+    header = Buffer.alloc(2);
+    header[0] = 0x81; // FIN + text opcode
+    header[1] = len;
+  } else if (len < 65536) {
+    header = Buffer.alloc(4);
+    header[0] = 0x81;
+    header[1] = 126;
+    header.writeUInt16BE(len, 2);
+  } else {
+    header = Buffer.alloc(10);
+    header[0] = 0x81;
+    header[1] = 127;
+    header.writeBigUInt64BE(BigInt(len), 2);
+  }
+  return Buffer.concat([header, data]);
+}
+
+// ── Inline Dashboard HTML ──
+
+function DASHBOARD_HTML(token) {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width,initial-scale=1.0">
+<title>Bahulam Agent Dashboard</title>
+<style>
+*,*::before,*::after{box-sizing:border-box;margin:0;padding:0}
+:root{--bg:#0d1117;--surface:#161b22;--border:#30363d;--text:#c9d1d9;
+  --dim:#8b949e;--green:#3fb950;--cyan:#58a6ff;--yellow:#d29922;
+  --red:#f85149;--brand:#58a6ff}
+body{background:var(--bg);color:var(--text);font-family:ui-monospace,SFMono-Regular,'SF Mono',Menlo,Consolas,monospace;
+  font-size:13px;line-height:1.5;padding:16px;overflow-y:scroll}
+h1{font-size:16px;font-weight:600;color:var(--brand);margin-bottom:8px;display:flex;align-items:center;gap:8px}
+h1 small{font-size:11px;color:var(--dim);font-weight:400}
+#status{display:flex;gap:16px;margin-bottom:12px;flex-wrap:wrap}
+.stat{background:var(--surface);border:1px solid var(--border);border-radius:6px;padding:6px 12px;font-size:12px}
+.stat .num{color:var(--brand);font-weight:600}
+.stat .lbl{color:var(--dim)}
+.toolbar{margin-bottom:8px;display:flex;gap:6px;flex-wrap:wrap}
+.toolbar button{background:var(--surface);border:1px solid var(--border);color:var(--text);
+  padding:3px 10px;border-radius:4px;cursor:pointer;font-size:11px;font-family:inherit}
+.toolbar button.active{background:var(--brand);color:#fff;border-color:var(--brand)}
+.toolbar button:hover{background:var(--border)}
+.split{display:flex;gap:12px;height:calc(100vh - 160px)}
+.panel{flex:1;background:var(--surface);border:1px solid var(--border);border-radius:6px;
+  overflow-y:auto;padding:4px 0;min-width:0}
+.panel h2{font-size:11px;font-weight:600;color:var(--dim);text-transform:uppercase;
+  letter-spacing:0.5px;padding:6px 10px;border-bottom:1px solid var(--border);position:sticky;top:0;
+  background:var(--surface);z-index:1}
+.event-line{padding:2px 10px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;font-size:12px;border-bottom:1px solid #1c2128}
+.event-line:hover{background:#1c2128}
+.tag{display:inline-block;padding:0 5px;border-radius:3px;font-size:10px;font-weight:600;margin-right:4px}
+.tag-spawn{background:#1b3628;color:var(--green)}
+.tag-active{background:#1c2d45;color:var(--cyan)}
+.tag-done{background:#1b3628;color:var(--green)}
+.tag-tool{background:#26242b;color:var(--dim)}
+.tag-handoff{background:#2a2318;color:var(--yellow)}
+.tag-error{background:#2d1b1b;color:var(--red)}
+.time{color:var(--dim);font-size:11px;margin-left:6px}
+.detail{color:var(--dim)}
+::-webkit-scrollbar{width:6px}
+::-webkit-scrollbar-track{background:transparent}
+::-webkit-scrollbar-thumb{background:var(--border);border-radius:3px}
+</style>
+</head>
+<body>
+<h1>⚡ Agent Dashboard <small id="sessionLabel">connecting…</small></h1>
+<div id="status">
+  <div class="stat"><span class="num" id="statEvents">0</span> <span class="lbl">events</span></div>
+  <div class="stat"><span class="num" id="statSubAgents">0</span> <span class="lbl">sub-agents</span></div>
+  <div class="stat"><span class="num" id="statTools">0</span> <span class="lbl">tools</span></div>
+  <div class="stat"><span class="num" id="statHandoffs">0</span> <span class="lbl">handoffs</span></div>
+  <div class="stat"><span class="lbl" id="connStatus">● disconnected</span></div>
+</div>
+<div class="toolbar">
+  <button data-filter="all" class="active">All</button>
+  <button data-filter="sub_agent_start,sub_agent_complete">Sub-Agents</button>
+  <button data-filter="delegation">Handoffs</button>
+  <button data-filter="tool_call,tool_done">Tools</button>
+  <button data-filter="error">Errors</button>
+  <button id="btnAutoScroll" class="active">Auto-scroll</button>
+  <button id="btnClear">Clear</button>
+</div>
+<div class="split">
+  <div class="panel" id="eventLog"><h2>Event Log</h2></div>
+  <div class="panel" id="subAgentTree"><h2>Sub-Agent Activity</h2></div>
+</div>
+<script>
+(function(){
+const token = '${token}';
+const wsProto = location.protocol === 'https:' ? 'wss:' : 'ws:';
+const wsUrl = wsProto + '//' + location.host + '/ws';
+let ws;
+let filters = ['all'];
+let autoScroll = true;
+let eventCount = 0;
+let subAgentCount = 0;
+let toolCount = 0;
+let handoffCount = 0;
+// Sub-agent state: id -> { id, type, query, startTime, tools, status }
+const subAgents = new Map();
+
+function connect() {
+  ws = new WebSocket(wsUrl);
+  ws.onopen = () => { document.getElementById('connStatus').textContent = '● connected'; };
+  ws.onclose = () => {
+    document.getElementById('connStatus').textContent = '● disconnected';
+    setTimeout(connect, 3000);
+  };
+  ws.onmessage = (msg) => {
+    try {
+      const ev = JSON.parse(msg.data);
+      handleEvent(ev);
+    } catch(e) { /* ignore parse errors */ }
+  };
+}
+
+function handleEvent(ev) {
+  eventCount++;
+  updateStats();
+  const line = renderEventLine(ev);
+  if (line) appendEvent(line);
+  updateSubAgentTree(ev);
+}
+
+function renderEventLine(ev) {
+  const type = ev.type || 'unknown';
+  const data = ev.data || {};
+  const now = Date.now();
+  let tag, label, detail = '';
+
+  switch(type) {
+    case 'sub_agent_start':
+      tag = '<span class="tag tag-spawn">spawn</span>';
+      label = (data.type || 'agent') + (data.query ? ' "' + data.query.slice(0, 60) + '"' : '');
+      subAgentCount++; toolCount++; break;
+    case 'sub_agent_complete':
+      tag = '<span class="tag tag-done">done</span>';
+      label = (data.type || 'agent');
+      detail = data.tool_calls != null ? ' · ' + data.tool_calls + ' tools' : '';
+      if (data.duration_s) detail += ' · ' + data.duration_s.toFixed(1) + 's';
+      break;
+    case 'delegation':
+      tag = '<span class="tag tag-handoff">handoff</span>';
+      label = (data.from || '?') + ' → ' + (data.to || '?');
+      if (data.instruction) detail = ' "' + data.instruction.slice(0, 50) + '"';
+      handoffCount++; break;
+    case 'tool_call':
+    case 'tool_request':
+      tag = '<span class="tag tag-tool">▶ tool</span>';
+      label = (data.tool || '?') + (data.args && data.args.file_path ? ' ' + data.args.file_path : '');
+      toolCount++; break;
+    case 'tool_done':
+    case 'tool_result':
+      tag = '<span class="tag tag-tool">✓ tool</span>';
+      label = (data.tool || '?');
+      if (data.duration_s) detail = ' · ' + data.duration_s.toFixed(1) + 's';
+      break;
+    case 'error':
+      tag = '<span class="tag tag-error">error</span>';
+      label = (data.message || '').slice(0, 80);
+      break;
+    case 'complete':
+      tag = '<span class="tag tag-done">complete</span>';
+      label = 'Agent finished';
+      if (data.tool_calls) detail = ' · ' + data.tool_calls + ' tools';
+      break;
+    case 'thinking':
+      return null; // too noisy
+    case 'content':
+    case 'content_partial':
+      return null;
+    default:
+      tag = '<span class="tag tag-active">' + type.slice(0, 8) + '</span>';
+      label = type;
+  }
+
+  eventCount++;
+  updateStats();
+  return '<div class="event-line">' + tag + esc(label) + '<span class="detail">' + esc(detail) + '</span></div>';
+}
+
+function appendEvent(html) {
+  if (!html) return;
+  const log = document.getElementById('eventLog');
+  log.insertAdjacentHTML('beforeend', html);
+  if (autoScroll) log.scrollTop = log.scrollHeight;
+}
+
+function updateSubAgentTree(ev) {
+  const type = ev.type;
+  const data = ev.data || {};
+  const container = document.getElementById('subAgentTree');
+  let changed = false;
+
+  if (type === 'sub_agent_start') {
+    const id = data.id || 'sa-' + Date.now();
+    subAgents.set(id, { id, type: data.type || 'agent', query: data.query || '', startTime: Date.now(), tools: 0, status: 'active' });
+    changed = true;
+  } else if (type === 'sub_agent_complete') {
+    const id = data.id;
+    if (id && subAgents.has(id)) {
+      const sa = subAgents.get(id);
+      sa.status = 'done';
+      sa.tools = data.tool_calls || sa.tools;
+      changed = true;
+    }
+  } else if (type === 'sub_agent_tool') {
+    const agentType = data.type || '';
+    // Find the most recent active sub-agent of this type
+    let found = null;
+    for (const [id, sa] of subAgents) {
+      if (sa.type === agentType && sa.status === 'active') { found = sa; }
+    }
+    if (found) { found.tools++; changed = true; }
+  }
+
+  if (changed) {
+    let html = '<h2>Sub-Agent Activity</h2>';
+    if (subAgents.size === 0) { html += '<div class="event-line" style="color:var(--dim)">(none yet)</div>'; }
+    else {
+      for (const [id, sa] of subAgents) {
+        const elapsed = ((Date.now() - sa.startTime) / 1000).toFixed(1);
+        const statusTag = sa.status === 'active'
+          ? '<span class="tag tag-active">active</span>'
+          : '<span class="tag tag-done">done</span>';
+        html += '<div class="event-line">' + statusTag + ' <b>' + esc(sa.type) + '</b>';
+        if (sa.query) html += ' ' + esc(sa.query.slice(0, 40));
+        html += ' · <span class="time">' + sa.tools + ' tools · ' + elapsed + 's</span></div>';
+      }
+    }
+    container.innerHTML = html;
+  }
+}
+
+function updateStats() {
+  document.getElementById('statEvents').textContent = eventCount;
+  document.getElementById('statSubAgents').textContent = subAgents.size;
+  document.getElementById('statTools').textContent = toolCount;
+  document.getElementById('statHandoffs').textContent = handoffCount;
+}
+
+function esc(s) { return String(s || '').replace(/[&<>"]/g, function(m) {
+  return {'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;'}[m]; });
+}
+
+// Toolbar filter buttons
+document.querySelectorAll('[data-filter]').forEach(btn => {
+  btn.addEventListener('click', () => {
+    document.querySelectorAll('[data-filter]').forEach(b => b.classList.remove('active'));
+    btn.classList.add('active');
+    filters = btn.dataset.filter === 'all' ? ['all'] : btn.dataset.filter.split(',');
+  });
+});
+
+document.getElementById('btnAutoScroll').addEventListener('click', function() {
+  autoScroll = !autoScroll;
+  this.classList.toggle('active');
+});
+
+document.getElementById('btnClear').addEventListener('click', () => {
+  document.getElementById('eventLog').innerHTML = '<h2>Event Log</h2>';
+  document.getElementById('subAgentTree').innerHTML = '<h2>Sub-Agent Activity</h2>';
+  subAgents.clear();
+  eventCount = 0; subAgentCount = 0; toolCount = 0; handoffCount = 0;
+  updateStats();
+});
+
+connect();
+})();
+</script>
+</body>
+</html>`;
+}

package/src/daemon/session-core.mjs

@@ -58,6 +58,7 @@ export const DAEMON_OWNED_FIELDS = Object.freeze([
   'user',
   'model',
   'modelLimits',
+  'subAgentModels',
   'blockedOps',
   'delegations',
   'phases',