open-agents-ai 0.59.0 → 0.61.0

package/dist/index.js

@@ -19081,7 +19081,7 @@ var require_extension = __commonJS({
 var require_websocket = __commonJS({
   "node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/websocket.js"(exports, module) {
     "use strict";
-    var EventEmitter3 = __require("events");
+    var EventEmitter4 = __require("events");
     var https = __require("https");
     var http = __require("http");
     var net = __require("net");
@@ -19113,7 +19113,7 @@ var require_websocket = __commonJS({
     var protocolVersions = [8, 13];
     var readyStates = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"];
     var subprotocolRegex = /^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/;
-    var WebSocket2 = class _WebSocket extends EventEmitter3 {
+    var WebSocket2 = class _WebSocket extends EventEmitter4 {
       /**
        * Create a new `WebSocket`.
        *
@@ -20110,7 +20110,7 @@ var require_subprotocol = __commonJS({
 var require_websocket_server = __commonJS({
   "node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/websocket-server.js"(exports, module) {
     "use strict";
-    var EventEmitter3 = __require("events");
+    var EventEmitter4 = __require("events");
     var http = __require("http");
     var { Duplex } = __require("stream");
     var { createHash: createHash2 } = __require("crypto");
@@ -20123,7 +20123,7 @@ var require_websocket_server = __commonJS({
     var RUNNING = 0;
     var CLOSING = 1;
     var CLOSED = 2;
-    var WebSocketServer2 = class extends EventEmitter3 {
+    var WebSocketServer2 = class extends EventEmitter4 {
       /**
        * Create a `WebSocketServer` instance.
        *
@@ -21604,7 +21604,10 @@ function connect() {
     ws = null;
   }
   const proto = location.protocol === 'https:' ? 'wss:' : 'ws:';
-  ws = new WebSocket(proto + '//' + location.host + '/ws');
+  const urlParams = new URLSearchParams(location.search);
+  const sessionKey = urlParams.get('key') || '';
+  const keyParam = sessionKey ? '?key=' + encodeURIComponent(sessionKey) : '';
+  ws = new WebSocket(proto + '//' + location.host + '/ws' + keyParam);
   ws.binaryType = 'arraybuffer';
 
   ws.onopen = () => {
@@ -21903,6 +21906,47 @@ var init_voice_session = __esm({
           }
         }
       }
+      /**
+       * Send TTS audio to a specific client by clientId.
+       */
+      sendAudioToClient(clientId, pcmInt16) {
+        const ws = this.wsClients.get(clientId);
+        if (ws) {
+          try {
+            if (ws.readyState === import_websocket.default.OPEN)
+              ws.send(pcmInt16);
+          } catch {
+          }
+        }
+      }
+      /**
+       * Send speaking state change to a specific client.
+       */
+      sendSpeakingStateToClient(clientId, speaking) {
+        const ws = this.wsClients.get(clientId);
+        if (ws) {
+          const msg = JSON.stringify({ type: speaking ? "speaking_start" : "speaking_end" });
+          try {
+            if (ws.readyState === import_websocket.default.OPEN)
+              ws.send(msg);
+          } catch {
+          }
+        }
+      }
+      /**
+       * Send a transcript message to a specific client.
+       */
+      sendTranscriptToClient(clientId, speaker, text) {
+        const ws = this.wsClients.get(clientId);
+        if (ws) {
+          const msg = JSON.stringify({ type: "transcript", speaker, text });
+          try {
+            if (ws.readyState === import_websocket.default.OPEN)
+              ws.send(msg);
+          } catch {
+          }
+        }
+      }
       /**
        * Signal TTS speaking state to clients.
        */
@@ -21951,9 +21995,11 @@ var init_voice_session = __esm({
       // ── WebSocket connection handler (using ws package) ──────────────────
       handleWSConnection(ws, req) {
         const clientId = `ws-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        const url = new URL(req.url ?? "/", `http://localhost`);
+        const sessionKey = url.searchParams.get("key") ?? null;
         this.wsClients.set(clientId, ws);
         this.state.connectedUsers.set(clientId, { username: "web-user", connectedAt: Date.now() });
-        this.emit("userConnected", clientId, "web-user");
+        this.emit("userConnected", clientId, "web-user", sessionKey);
         this.resetIdleTimer();
         const keepaliveInterval = setInterval(() => {
           if (ws.readyState !== import_websocket.default.OPEN) {
@@ -22079,6 +22125,279 @@ var init_voice_session = __esm({
   }
 });
 
+// packages/cli/dist/tui/call-agent.js
+import { EventEmitter as EventEmitter3 } from "node:events";
+import crypto2 from "node:crypto";
+function adaptTool(tool) {
+  return {
+    name: tool.name,
+    description: tool.description,
+    parameters: tool.parameters,
+    async execute(args) {
+      const result = await tool.execute(args);
+      return { success: result.success, output: result.output, error: result.error };
+    }
+  };
+}
+function getActivityFeed() {
+  if (!_globalFeed)
+    _globalFeed = new ActivityFeed();
+  return _globalFeed;
+}
+function generateSessionKey() {
+  return crypto2.randomBytes(16).toString("hex");
+}
+var ActivityFeed, _globalFeed, CallSubAgent;
+var init_call_agent = __esm({
+  "packages/cli/dist/tui/call-agent.js"() {
+    "use strict";
+    init_dist5();
+    init_dist2();
+    ActivityFeed = class {
+      entries = [];
+      maxEntries = 100;
+      push(entry) {
+        this.entries.push(entry);
+        if (this.entries.length > this.maxEntries) {
+          this.entries = this.entries.slice(-this.maxEntries);
+        }
+      }
+      /** Get recent activity as a text summary for sub-agent context */
+      getSummary(maxItems = 20, verbose = false) {
+        const recent = this.entries.slice(-maxItems);
+        if (recent.length === 0)
+          return "No recent activity.";
+        return recent.map((e) => {
+          const src = e.source === "main" ? "Agent" : "Call";
+          const tool = e.toolName ? ` [${e.toolName}]` : "";
+          const status = e.success !== void 0 ? e.success ? " ok" : " fail" : "";
+          if (verbose) {
+            return `[${new Date(e.ts).toLocaleTimeString()}] ${src}${tool}${status}: ${e.summary}`;
+          }
+          return `${src}${tool}${status}: ${e.summary}`;
+        }).join("\n");
+      }
+      /** Get entries since a timestamp */
+      since(ts) {
+        return this.entries.filter((e) => e.ts > ts);
+      }
+      clear() {
+        this.entries.length = 0;
+      }
+    };
+    _globalFeed = null;
+    CallSubAgent = class extends EventEmitter3 {
+      tier;
+      clientId;
+      runner = null;
+      config;
+      repoRoot;
+      opts;
+      processing = false;
+      pendingTranscripts = [];
+      conversationHistory = [];
+      disposed = false;
+      constructor(clientId, opts) {
+        super();
+        this.clientId = clientId;
+        this.tier = opts.tier;
+        this.config = opts.config;
+        this.repoRoot = opts.repoRoot;
+        this.opts = opts;
+      }
+      /** Initialize the runner with appropriate tools for the access tier */
+      async init() {
+        const backend = new OllamaAgenticBackend(this.config.backendUrl, this.config.model, this.config.apiKey);
+        const feed = getActivityFeed();
+        const systemPrompt = this.buildSystemPrompt();
+        const runnerOpts = {
+          maxTurns: this.tier === "admin" ? 15 : 5,
+          maxTokens: 4096,
+          temperature: 0.3,
+          requestTimeoutMs: 3e4,
+          taskTimeoutMs: 12e4,
+          modelTier: this.opts.modelTier ?? "large",
+          contextWindowSize: this.opts.contextWindowSize,
+          personality: this.opts.personality,
+          streamEnabled: false,
+          bruteForce: false,
+          dynamicContext: systemPrompt
+        };
+        this.runner = new AgenticRunner(backend, runnerOpts);
+        this.runner.setWorkingDirectory(this.repoRoot);
+        const tools = this.buildTools();
+        this.runner.registerTools(tools);
+        const clientId = this.clientId;
+        const self = this;
+        this.runner.registerTool({
+          name: "task_complete",
+          description: "Call this when you have fully answered the user's question or completed their request. The summary should be your spoken response to the user.",
+          parameters: {
+            type: "object",
+            properties: {
+              summary: {
+                type: "string",
+                description: "Your spoken response to the user. Keep it concise and conversational \u2014 this will be spoken aloud via TTS."
+              }
+            },
+            required: ["summary"]
+          },
+          execute: async (args) => {
+            const summary = String(args["summary"] ?? "");
+            self.emit("response", summary);
+            feed.push({
+              ts: Date.now(),
+              source: "call",
+              sourceId: clientId,
+              summary: `Responded: ${summary.slice(0, 100)}`
+            });
+            return { success: true, output: summary };
+          }
+        });
+        this.runner.onEvent((event) => {
+          if (event.type === "tool_call") {
+            const toolName = event.toolName ?? "unknown";
+            const args = event.toolArgs ?? {};
+            this.emit("toolCall", toolName, args);
+            feed.push({
+              ts: Date.now(),
+              source: "call",
+              sourceId: this.clientId,
+              summary: `${toolName}(${Object.keys(args).join(", ")})`,
+              toolName
+            });
+          }
+          if (event.type === "tool_result") {
+            const toolName = event.toolName ?? "unknown";
+            const success = event.success ?? false;
+            const content = String(event.content ?? "").slice(0, 100);
+            this.emit("toolResult", toolName, success, content);
+            feed.push({
+              ts: Date.now(),
+              source: "call",
+              sourceId: this.clientId,
+              summary: content,
+              toolName,
+              success
+            });
+          }
+          if (event.type === "model_response" && event.content) {
+            this.emit("response", event.content);
+          }
+        });
+      }
+      /** Process a voice transcript — queues if already processing */
+      handleTranscript(text) {
+        if (this.disposed)
+          return;
+        this.conversationHistory.push({ role: "user", text });
+        if (this.processing) {
+          this.pendingTranscripts.push(text);
+          return;
+        }
+        this.processTranscript(text).catch((err) => {
+          this.emit("error", err instanceof Error ? err : new Error(String(err)));
+        });
+      }
+      /** Dispose and clean up */
+      dispose() {
+        this.disposed = true;
+        this.pendingTranscripts.length = 0;
+        this.runner = null;
+      }
+      // ── Private ──────────────────────────────────────────────────────────
+      async processTranscript(text) {
+        if (!this.runner || this.disposed)
+          return;
+        this.processing = true;
+        try {
+          const historyContext = this.conversationHistory.slice(-10).map((h) => `${h.role === "user" ? "User" : "You"}: ${h.text}`).join("\n");
+          const feed = getActivityFeed();
+          const activitySummary = feed.getSummary(this.tier === "admin" ? 20 : 10, this.tier === "admin");
+          const taskPrompt = [
+            `The user said (via voice): "${text}"`,
+            "",
+            "Recent conversation:",
+            historyContext,
+            "",
+            "Recent agent activity:",
+            activitySummary,
+            "",
+            "Respond conversationally and concisely. Your response will be spoken aloud via TTS.",
+            "Call task_complete with your spoken response as the summary."
+          ].join("\n");
+          const result = await this.runner.run(taskPrompt, `Working directory: ${this.repoRoot}`);
+          if (result.summary) {
+            this.conversationHistory.push({ role: "assistant", text: result.summary });
+          }
+        } catch (err) {
+          this.emit("error", err instanceof Error ? err : new Error(String(err)));
+        } finally {
+          this.processing = false;
+          this.emit("done");
+          if (this.pendingTranscripts.length > 0) {
+            const next = this.pendingTranscripts.shift();
+            this.processTranscript(next).catch((err) => {
+              this.emit("error", err instanceof Error ? err : new Error(String(err)));
+            });
+          }
+        }
+      }
+      buildSystemPrompt() {
+        const base = [
+          "You are a voice assistant for an AI coding agent. Users are speaking to you through a live audio call.",
+          "Keep responses SHORT and conversational \u2014 they will be spoken aloud via text-to-speech.",
+          "Avoid code blocks, markdown formatting, or long technical explanations in your spoken responses.",
+          "If the user asks about what the agent is doing, summarize the recent activity concisely."
+        ];
+        if (this.opts.emotionContext) {
+          base.push("", "Current emotional context:", this.opts.emotionContext);
+        }
+        if (this.tier === "admin") {
+          base.push("", "This is an ADMIN call \u2014 you have full access to all tools and can execute commands, read/write files, search code, etc.", "You can take actions on behalf of the user just like the main agent.");
+        } else {
+          base.push("", "This is a PUBLIC call \u2014 you have read-only access. You can read files and search code but cannot modify anything.", "You can answer questions about the project and explain what the agent is working on.", "Be helpful and friendly but do not execute any write operations.");
+        }
+        return base.join("\n");
+      }
+      buildTools() {
+        if (this.tier === "admin") {
+          return this.buildAdminTools();
+        }
+        return this.buildPublicTools();
+      }
+      buildAdminTools() {
+        const tools = [
+          new FileReadTool(this.repoRoot),
+          new FileWriteTool(this.repoRoot),
+          new FileEditTool(this.repoRoot),
+          new ShellTool(this.repoRoot),
+          new GrepSearchTool(this.repoRoot),
+          new GlobFindTool(this.repoRoot),
+          new ListDirectoryTool(this.repoRoot),
+          new WebSearchTool(),
+          new WebFetchTool(),
+          new MemoryReadTool(this.repoRoot),
+          new MemoryWriteTool(this.repoRoot),
+          new MemorySearchTool(this.repoRoot)
+        ];
+        return tools.map(adaptTool);
+      }
+      buildPublicTools() {
+        const tools = [
+          new FileReadTool(this.repoRoot),
+          new GrepSearchTool(this.repoRoot),
+          new GlobFindTool(this.repoRoot),
+          new ListDirectoryTool(this.repoRoot),
+          new MemoryReadTool(this.repoRoot),
+          new MemorySearchTool(this.repoRoot)
+        ];
+        return tools.map(adaptTool);
+      }
+    };
+  }
+});
+
 // packages/cli/dist/tui/model-picker.js
 async function fetchOllamaModels(baseUrl) {
   const url = `${normalizeBaseUrl(baseUrl)}/api/tags`;
@@ -26671,265 +26990,286 @@ function modelOnnxPath(id) {
 function modelConfigPath(id) {
   return join34(modelDir(id), "config.json");
 }
-function describeToolCall(toolName, args, personality = 2) {
-  const path = args["path"];
-  const file = path ? path.split("/").pop() ?? path : "";
-  if (personality <= 2) {
-    return describeToolCallTerse(toolName, args, file);
-  }
-  if (personality <= 3) {
-    return describeToolCallConversational(toolName, args, file);
+function resetNarrationContext() {
+  narration.toolCount = 0;
+  narration.toolCounts = {};
+  narration.consecutiveErrors = 0;
+  narration.totalErrors = 0;
+  narration.lastTool = "";
+  narration.lastFile = "";
+  narration.filesSeen.clear();
+  narration.lastVariantIdx = {};
+}
+function pick(key, variants) {
+  if (variants.length === 1)
+    return variants[0];
+  const last = narration.lastVariantIdx[key] ?? -1;
+  let idx;
+  do {
+    idx = Math.floor(Math.random() * variants.length);
+  } while (idx === last && variants.length > 1);
+  narration.lastVariantIdx[key] = idx;
+  return variants[idx];
+}
+function getShellCategory(cmd) {
+  if (/npm\s+test|vitest|jest|mocha/.test(cmd))
+    return "test";
+  if (/npm\s+run\s+build|tsc|esbuild/.test(cmd))
+    return "build";
+  if (/npm\s+install|pnpm\s+install/.test(cmd))
+    return "install";
+  if (/git\s+/.test(cmd))
+    return "git";
+  if (/npm\s+run\s+lint|eslint|biome/.test(cmd))
+    return "lint";
+  if (/node\s+/.test(cmd))
+    return "node";
+  if (/python|pip/.test(cmd))
+    return "python";
+  if (/curl|wget|fetch/.test(cmd))
+    return "network";
+  if (/docker|podman/.test(cmd))
+    return "container";
+  return "generic";
+}
+function contextPrefix(toolName, file) {
+  const count = narration.toolCounts[toolName] ?? 0;
+  const isSameFile = file && file === narration.lastFile;
+  const isRevisit = file && narration.filesSeen.has(file);
+  if (narration.toolCount === 0)
+    return "";
+  if (narration.consecutiveErrors === 1) {
+    const afterError = ["Okay, ", "Right, ", "Alright, "];
+    return pick("ctx_aftererr", afterError);
+  }
+  if (narration.consecutiveErrors === 2) {
+    const afterMultiErr = ["Let me try something different. ", "New approach. ", "Switching tactics. "];
+    return pick("ctx_multierr", afterMultiErr);
+  }
+  if (narration.consecutiveErrors >= 3) {
+    const persistent = ["Third time's the charm. ", "One more try. ", "Okay, different angle entirely. "];
+    return pick("ctx_persistent", persistent);
+  }
+  if (isSameFile && count > 0) {
+    const sameFile = ["Back to ", "Still working on ", ""];
+    const chosen = pick("ctx_samefile", sameFile);
+    if (chosen)
+      return chosen;
+  }
+  if (isRevisit && !isSameFile) {
+    const revisit = ["Coming back to ", "Revisiting ", ""];
+    const chosen = pick("ctx_revisit", revisit);
+    if (chosen)
+      return chosen;
+  }
+  if (narration.toolCount > 0 && narration.toolCount % 8 === 0) {
+    const beats = ["Making good progress. ", "Moving along. ", ""];
+    return pick("ctx_beat", beats);
   }
-  return describeToolCallChatty(toolName, args, file);
+  return "";
 }
-function describeToolCallTerse(toolName, args, file) {
-  switch (toolName) {
-    case "file_read":
-      return `Reading ${file}`;
-    case "file_write":
-      return `Writing ${file}`;
-    case "file_edit":
-      return `Editing ${file}`;
-    case "file_patch":
-      return `Patching ${file}`;
-    case "shell":
-      return describeShellTerse(String(args["command"] ?? ""));
-    case "grep_search":
-      return `Searching for ${args["pattern"] ?? "pattern"}`;
-    case "find_files":
-      return `Finding files matching ${args["pattern"] ?? "pattern"}`;
-    case "list_directory":
-      return `Listing directory ${file || "contents"}`;
-    case "web_search":
-      return `Searching the web`;
-    case "web_fetch":
-      return `Fetching web page`;
-    case "memory_read":
-      return `Reading from memory`;
-    case "memory_write":
-      return `Saving to memory`;
-    case "task_complete":
-      return String(args["summary"] ?? "Task complete");
-    case "batch_edit":
-      return `Editing multiple files`;
-    case "codebase_map":
-      return `Mapping project structure`;
-    case "diagnostic":
-      return `Running diagnostics`;
-    case "git_info":
-      return `Checking git status`;
-    case "aiwg_setup":
-      return `Setting up development framework`;
-    case "aiwg_health":
-      return `Analyzing project health`;
-    case "aiwg_workflow":
-      return `Running workflow command`;
-    case "background_run":
-      return `Starting background task`;
-    case "task_status":
-      return `Checking task status`;
-    case "task_output":
-      return `Reading task output`;
-    case "task_stop":
-      return `Stopping background task`;
-    case "sub_agent":
-      return `Delegating to sub agent`;
-    case "image_read":
-      return `Reading image`;
-    case "screenshot":
-      return `Taking screenshot`;
-    case "ocr":
-      return `Extracting text from image`;
-    case "create_tool":
-      return `Creating custom tool`;
-    case "manage_tools":
-      return `Managing custom tools`;
-    case "browser_action":
-      return `Browser ${args["action"] ?? "action"}`;
-    case "scheduler":
-      return `${args["action"] === "create" ? "Scheduling task" : "Checking scheduler"}`;
-    case "reminder":
-      return `${args["action"] === "set" ? "Setting reminder" : "Checking reminders"}`;
-    case "agenda":
-      return `Checking agenda`;
-    default:
-      return `Using ${toolName}`;
-  }
+function getTier(personality) {
+  if (personality <= 2)
+    return "terse";
+  if (personality <= 3)
+    return "conv";
+  return "chatty";
 }
-function describeToolCallConversational(toolName, args, file) {
+function describeToolCall(toolName, args, personality = 2) {
+  const path = args["path"];
+  const file = path ? path.split("/").pop() ?? path : "";
+  const tier = getTier(personality);
+  const prefix = personality >= 3 ? contextPrefix(toolName, file) : "";
+  narration.toolCount++;
+  narration.toolCounts[toolName] = (narration.toolCounts[toolName] ?? 0) + 1;
+  narration.lastTool = toolName;
+  if (file) {
+    narration.filesSeen.add(file);
+    narration.lastFile = file;
+  }
+  let base;
+  const poolKey = `${toolName}_${tier}`;
   switch (toolName) {
     case "file_read":
-      return `Let me take a look at ${file}`;
+      base = pick(poolKey, (FILE_READ_VARIANTS[tier] ?? FILE_READ_VARIANTS.terse)(file, args));
+      break;
     case "file_write":
-      return `Writing changes to ${file}`;
+      base = pick(poolKey, (FILE_WRITE_VARIANTS[tier] ?? FILE_WRITE_VARIANTS.terse)(file, args));
+      break;
     case "file_edit":
-      return `Making some edits to ${file}`;
     case "file_patch":
-      return `Patching up ${file}`;
-    case "shell":
-      return describeShellConversational(String(args["command"] ?? ""));
+      base = pick(poolKey, (FILE_EDIT_VARIANTS[tier] ?? FILE_EDIT_VARIANTS.terse)(file, args));
+      break;
+    case "shell": {
+      const cat = getShellCategory(String(args["command"] ?? ""));
+      const pool = SHELL_VARIANTS[cat] ?? SHELL_VARIANTS.generic;
+      base = pick(`shell_${cat}_${tier}`, pool[tier] ?? pool.terse);
+      break;
+    }
     case "grep_search":
-      return `Searching the code for ${args["pattern"] ?? "that pattern"}`;
-    case "find_files":
-      return `Looking for files matching ${args["pattern"] ?? "that pattern"}`;
-    case "list_directory":
-      return `Checking what's in ${file || "the directory"}`;
+      base = pick(poolKey, (GREP_VARIANTS[tier] ?? GREP_VARIANTS.terse)(file, args));
+      break;
+    case "find_files": {
+      const pat = args["pattern"] ?? "pattern";
+      const findVariants = {
+        terse: [`Finding ${pat}`, `Searching for ${pat}`],
+        conv: [`Looking for files matching ${pat}`, `Finding files that match ${pat}`],
+        chatty: [`Scouring the project for ${pat}`, `Searching far and wide for ${pat}`, `Let me find everything matching ${pat}`]
+      };
+      base = pick(poolKey, findVariants[tier] ?? findVariants.terse);
+      break;
+    }
+    case "list_directory": {
+      const dir = file || "the directory";
+      const listVariants = {
+        terse: [`Listing ${dir}`, `Checking ${dir}`],
+        conv: [`Checking what's in ${dir}`, `Looking at ${dir} contents`],
+        chatty: [`Let's see what we've got in ${dir}`, `Browsing through ${dir}`]
+      };
+      base = pick(poolKey, listVariants[tier] ?? listVariants.terse);
+      break;
+    }
     case "web_search":
-      return `Let me search the web for that`;
+      base = pick(poolKey, (WEB_SEARCH_VARIANTS[tier] ?? WEB_SEARCH_VARIANTS.terse)(file, args));
+      break;
     case "web_fetch":
-      return `Pulling up that web page`;
+      base = pick(poolKey, (WEB_FETCH_VARIANTS[tier] ?? WEB_FETCH_VARIANTS.terse)(file, args));
+      break;
     case "memory_read":
-      return `Checking my notes`;
+      base = pick(poolKey, (MEMORY_READ_VARIANTS[tier] ?? MEMORY_READ_VARIANTS.terse)(file, args));
+      break;
     case "memory_write":
-      return `Making a note of that`;
+      base = pick(poolKey, (MEMORY_WRITE_VARIANTS[tier] ?? MEMORY_WRITE_VARIANTS.terse)(file, args));
+      break;
     case "task_complete":
-      return String(args["summary"] ?? "All done");
-    case "batch_edit":
-      return `Editing several files at once`;
-    case "codebase_map":
-      return `Mapping out the project structure`;
-    case "diagnostic":
-      return `Running some diagnostics`;
-    case "git_info":
-      return `Checking the git status`;
+      base = String(args["summary"] ?? (tier === "chatty" ? "And that's a wrap" : tier === "conv" ? "All done" : "Task complete"));
+      break;
     case "sub_agent":
-      return `Handing this off to a sub agent`;
-    case "image_read":
-      return `Taking a look at that image`;
-    case "screenshot":
-      return `Grabbing a screenshot`;
-    case "browser_action":
-      return `Let me ${args["action"] === "navigate" ? "open that page" : args["action"] === "screenshot" ? "grab a screenshot of the browser" : `do a browser ${args["action"] ?? "action"}`}`;
-    case "scheduler":
-      return `${args["action"] === "create" ? "Setting up a scheduled task" : "Checking the schedule"}`;
-    case "reminder":
-      return `${args["action"] === "set" ? "Making a note for next time" : "Looking at reminders"}`;
-    case "agenda":
-      return `Let me check what's on the agenda`;
-    default:
-      return `Working with ${toolName}`;
+      base = pick(poolKey, (SUB_AGENT_VARIANTS[tier] ?? SUB_AGENT_VARIANTS.terse)(file, args));
+      break;
+    case "batch_edit": {
+      const batchV = {
+        terse: ["Editing multiple files", "Batch editing"],
+        conv: ["Editing several files at once", "Making changes across multiple files"],
+        chatty: ["Okay, editing a bunch of files here, bear with me", "Touching several files at once, lot of ground to cover"]
+      };
+      base = pick(poolKey, batchV[tier] ?? batchV.terse);
+      break;
+    }
+    case "codebase_map": {
+      const mapV = {
+        terse: ["Mapping project", "Scanning structure"],
+        conv: ["Mapping out the project structure", "Getting the project layout"],
+        chatty: ["Let me get the lay of the land on this project", "Mapping the whole codebase out"]
+      };
+      base = pick(poolKey, mapV[tier] ?? mapV.terse);
+      break;
+    }
+    case "diagnostic": {
+      const diagV = {
+        terse: ["Running diagnostics", "Diagnostic check"],
+        conv: ["Running some diagnostics", "Let me run a diagnostic"],
+        chatty: ["Running diagnostics, let's see if anything looks off", "Time for a health check"]
+      };
+      base = pick(poolKey, diagV[tier] ?? diagV.terse);
+      break;
+    }
+    case "git_info": {
+      const gitV = {
+        terse: ["Checking git", "Git status"],
+        conv: ["Checking the git status", "Looking at git info"],
+        chatty: ["Checking in with git to see where things stand", "Let me see what git has to say"]
+      };
+      base = pick(poolKey, gitV[tier] ?? gitV.terse);
+      break;
+    }
+    case "image_read": {
+      const imgV = {
+        terse: ["Reading image", "Loading image"],
+        conv: ["Taking a look at that image", "Opening the image"],
+        chatty: ["Let me get a good look at that image", "Opening up the image to see what's there"]
+      };
+      base = pick(poolKey, imgV[tier] ?? imgV.terse);
+      break;
+    }
+    case "screenshot": {
+      const ssV = {
+        terse: ["Taking screenshot", "Capturing screen"],
+        conv: ["Grabbing a screenshot", "Capturing what's on screen"],
+        chatty: ["Snapping a screenshot to see what's happening", "Let me grab a visual"]
+      };
+      base = pick(poolKey, ssV[tier] ?? ssV.terse);
+      break;
+    }
+    case "ocr": {
+      const ocrV = {
+        terse: ["Extracting text", "Running OCR"],
+        conv: ["Extracting text from the image", "Running OCR on this"],
+        chatty: ["Let me pull the text out of this image", "Running optical character recognition"]
+      };
+      base = pick(poolKey, ocrV[tier] ?? ocrV.terse);
+      break;
+    }
+    case "browser_action": {
+      const action = args["action"] ?? "action";
+      const browserV = {
+        terse: [`Browser ${action}`],
+        conv: [
+          action === "navigate" ? "Opening that page" : action === "screenshot" ? "Grabbing a screenshot of the browser" : `Browser ${action}`
+        ],
+        chatty: [
+          action === "navigate" ? "Firing up the browser, let's see what's on that page" : action === "screenshot" ? "Getting a visual from the browser" : `Doing a browser ${action}`
+        ]
+      };
+      base = pick(poolKey, browserV[tier] ?? browserV.terse);
+      break;
+    }
+    default: {
+      const defaultV = {
+        terse: [`Using ${toolName}`],
+        conv: [`Working with ${toolName}`, `Using ${toolName}`],
+        chatty: [`Pulling in ${toolName}, hang tight`, `Using ${toolName} for this`, `Working with ${toolName} here`]
+      };
+      base = pick(poolKey, defaultV[tier] ?? defaultV.terse);
+      break;
+    }
   }
-}
-function describeToolCallChatty(toolName, args, file) {
-  switch (toolName) {
-    case "file_read":
-      return `Alright, let's crack open ${file} and see what we're working with`;
-    case "file_write":
-      return `Time to write this out to ${file}`;
-    case "file_edit":
-      return `Let me tweak ${file}, I think I see what needs to change`;
-    case "file_patch":
-      return `Patching up ${file}, this should do the trick`;
-    case "shell":
-      return describeShellChatty(String(args["command"] ?? ""));
-    case "grep_search":
-      return `Hunting through the code for ${args["pattern"] ?? "what we need"}`;
-    case "find_files":
-      return `Scouring the project for files matching ${args["pattern"] ?? "our target"}`;
-    case "list_directory":
-      return `Let's see what we've got in ${file || "this directory"}`;
-    case "web_search":
-      return `Off to the web to track this down`;
-    case "web_fetch":
-      return `Grabbing that page, one moment`;
-    case "memory_read":
-      return `Let me dig through my notes on this`;
-    case "memory_write":
-      return `Stashing this away for later`;
-    case "task_complete":
-      return String(args["summary"] ?? "And that's a wrap");
-    case "batch_edit":
-      return `Okay, editing a bunch of files here, bear with me`;
-    case "codebase_map":
-      return `Let me get the lay of the land on this project`;
-    case "diagnostic":
-      return `Running diagnostics, let's see if anything looks off`;
-    case "git_info":
-      return `Checking in with git to see where things stand`;
-    case "sub_agent":
-      return `Bringing in reinforcements for this one`;
-    case "image_read":
-      return `Let me get a good look at that image`;
-    case "screenshot":
-      return `Snapping a screenshot to see what's happening`;
-    case "browser_action":
-      return `Firing up the browser, let's ${args["action"] === "navigate" ? "see what's on that page" : args["action"] === "screenshot" ? "get a visual" : `${args["action"] ?? "do this"}`}`;
-    case "scheduler":
-      return `${args["action"] === "create" ? "Alright, let me set up a recurring task for you" : "Let me pull up the schedule and see what's coming up"}`;
-    case "reminder":
-      return `${args["action"] === "set" ? "Leaving myself a note for future me, don't let me forget" : "Let me check if past me left any reminders"}`;
-    case "agenda":
-      return `Let me see the full picture of what needs doing`;
-    default:
-      return `Pulling in ${toolName}, hang tight`;
+  if (!prefix)
+    return base;
+  if (prefix.endsWith(". ") || prefix.endsWith("! "))
+    return prefix + base;
+  if (prefix && base.length > 0) {
+    return prefix + base.charAt(0).toLowerCase() + base.slice(1);
   }
-}
-function describeShellTerse(cmd) {
-  if (/npm\s+test|vitest|jest|mocha/.test(cmd))
-    return "Running tests";
-  if (/npm\s+run\s+build|tsc|esbuild/.test(cmd))
-    return "Building project";
-  if (/npm\s+install|pnpm\s+install/.test(cmd))
-    return "Installing dependencies";
-  if (/git\s+/.test(cmd))
-    return "Running git command";
-  if (/npm\s+run\s+lint|eslint|biome/.test(cmd))
-    return "Running linter";
-  if (cmd.length > 40)
-    return "Running shell command";
-  return `Running ${cmd.slice(0, 30)}`;
-}
-function describeShellConversational(cmd) {
-  if (/npm\s+test|vitest|jest|mocha/.test(cmd))
-    return "Let's run the tests and see how we're doing";
-  if (/npm\s+run\s+build|tsc|esbuild/.test(cmd))
-    return "Building the project now";
-  if (/npm\s+install|pnpm\s+install/.test(cmd))
-    return "Installing the dependencies";
-  if (/git\s+/.test(cmd))
-    return "Running a git command";
-  if (/npm\s+run\s+lint|eslint|biome/.test(cmd))
-    return "Checking the code with the linter";
-  return "Running a command";
-}
-function describeShellChatty(cmd) {
-  if (/npm\s+test|vitest|jest|mocha/.test(cmd))
-    return "Alright, moment of truth, let's see if the tests pass";
-  if (/npm\s+run\s+build|tsc|esbuild/.test(cmd))
-    return "Kicking off a build, fingers crossed";
-  if (/npm\s+install|pnpm\s+install/.test(cmd))
-    return "Pulling in dependencies, this might take a sec";
-  if (/git\s+/.test(cmd))
-    return "Checking in with git";
-  if (/npm\s+run\s+lint|eslint|biome/.test(cmd))
-    return "Running the linter, let's keep things tidy";
-  return "Firing off a shell command";
+  return base;
 }
 function describeToolResult(toolName, success, personality = 2) {
   if (toolName === "task_complete")
     return "";
-  if (personality <= 2) {
-    return success ? "Done" : "That failed, trying to fix it";
+  const tier = getTier(personality);
+  if (success) {
+    narration.consecutiveErrors = 0;
+    if (personality >= 3 && Math.random() < 0.4)
+      return "";
+    return pick(`result_ok_${tier}`, RESULT_SUCCESS_VARIANTS[tier] ?? RESULT_SUCCESS_VARIANTS.terse);
   }
-  if (personality <= 3) {
-    return success ? "Got it" : "That didn't work, let me try another approach";
+  narration.consecutiveErrors++;
+  narration.totalErrors++;
+  if (narration.consecutiveErrors >= 3) {
+    return pick(`result_multifail_${tier}`, RESULT_MULTI_FAIL_VARIANTS[tier] ?? RESULT_MULTI_FAIL_VARIANTS.terse);
   }
-  return success ? "Looking good, moving on" : "Hmm, that didn't go as planned. Let me take a different angle";
+  return pick(`result_fail_${tier}`, RESULT_FAIL_VARIANTS[tier] ?? RESULT_FAIL_VARIANTS.terse);
 }
 function describeTaskComplete(summary, completed, personality = 2) {
   const truncated = summary.length > 300 ? summary.slice(0, 300) + "..." : summary;
+  const tier = getTier(personality);
   if (!completed) {
-    if (personality <= 2)
-      return "Task did not complete.";
-    if (personality <= 3)
-      return "I wasn't able to finish that one.";
-    return "Well, that didn't quite get there. You might want to take a look at what's left.";
+    return pick(`task_incomplete_${tier}`, TASK_INCOMPLETE_VARIANTS[tier] ?? TASK_INCOMPLETE_VARIANTS.terse);
   }
-  if (personality <= 2)
-    return `Task complete. ${truncated}`;
-  if (personality <= 3)
-    return `All done. ${truncated}`;
-  return `And we're done! ${truncated}`;
+  const opener = pick(`task_complete_${tier}`, TASK_COMPLETE_VARIANTS[tier] ?? TASK_COMPLETE_VARIANTS.terse);
+  if (truncated)
+    return `${opener} ${truncated}`;
+  return opener;
 }
 function formatBytes2(bytes) {
   if (bytes < 1024)
@@ -26938,7 +27278,7 @@ function formatBytes2(bytes) {
     return `${(bytes / 1024).toFixed(0)}KB`;
   return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
 }
-var VOICE_MODELS, VoiceEngine;
+var VOICE_MODELS, VoiceEngine, narration, FILE_READ_VARIANTS, FILE_WRITE_VARIANTS, FILE_EDIT_VARIANTS, GREP_VARIANTS, WEB_SEARCH_VARIANTS, WEB_FETCH_VARIANTS, MEMORY_READ_VARIANTS, MEMORY_WRITE_VARIANTS, SUB_AGENT_VARIANTS, SHELL_VARIANTS, RESULT_SUCCESS_VARIANTS, RESULT_FAIL_VARIANTS, RESULT_MULTI_FAIL_VARIANTS, TASK_COMPLETE_VARIANTS, TASK_INCOMPLETE_VARIANTS;
 var init_voice = __esm({
   "packages/cli/dist/tui/voice.js"() {
     "use strict";
@@ -27500,6 +27840,368 @@ Error: ${err instanceof Error ? err.message : String(err)}`);
         renderInfo("Voice model loaded.");
       }
     };
+    narration = {
+      toolCount: 0,
+      toolCounts: {},
+      consecutiveErrors: 0,
+      totalErrors: 0,
+      lastTool: "",
+      lastFile: "",
+      filesSeen: /* @__PURE__ */ new Set(),
+      lastVariantIdx: {}
+    };
+    FILE_READ_VARIANTS = {
+      terse: (f) => [`Reading ${f}`, `Opening ${f}`, `Loading ${f}`],
+      conv: (f) => [
+        `Let me take a look at ${f}`,
+        `Opening up ${f}`,
+        `Pulling up ${f}`,
+        `Checking ${f}`,
+        `Let me see what's in ${f}`
+      ],
+      chatty: (f) => [
+        `Alright, let's crack open ${f} and see what we're working with`,
+        `Diving into ${f}`,
+        `Let me pull up ${f} and see what's going on`,
+        `Time to see what ${f} has for us`,
+        `Opening ${f}, let's see what we've got`,
+        `Taking a look inside ${f}`
+      ]
+    };
+    FILE_WRITE_VARIANTS = {
+      terse: (f) => [`Writing ${f}`, `Saving ${f}`, `Creating ${f}`],
+      conv: (f) => [
+        `Writing changes to ${f}`,
+        `Saving the updates to ${f}`,
+        `Putting this into ${f}`,
+        `Writing this out to ${f}`
+      ],
+      chatty: (f) => [
+        `Time to write this out to ${f}`,
+        `Laying down the changes in ${f}`,
+        `Writing the new version of ${f}`,
+        `Let me save this to ${f} before I forget`,
+        `Committing these changes to ${f}`
+      ]
+    };
+    FILE_EDIT_VARIANTS = {
+      terse: (f) => [`Editing ${f}`, `Modifying ${f}`, `Updating ${f}`],
+      conv: (f) => [
+        `Making some edits to ${f}`,
+        `Adjusting ${f}`,
+        `Tweaking ${f}`,
+        `Updating ${f} with the fix`,
+        `Applying changes to ${f}`
+      ],
+      chatty: (f) => [
+        `Let me tweak ${f}, I think I see what needs to change`,
+        `Making some surgical edits to ${f}`,
+        `Alright, adjusting ${f} now`,
+        `Got it, let me fix that up in ${f}`,
+        `Reshaping ${f} a bit here`,
+        `Modifying ${f}, this should get us closer`
+      ]
+    };
+    GREP_VARIANTS = {
+      terse: (_f, a) => [`Searching for ${a["pattern"] ?? "pattern"}`, `Grepping ${a["pattern"] ?? "code"}`],
+      conv: (_f, a) => [
+        `Searching the code for ${a["pattern"] ?? "that pattern"}`,
+        `Looking for ${a["pattern"] ?? "matches"} in the codebase`,
+        `Scanning for ${a["pattern"] ?? "that"} across the files`
+      ],
+      chatty: (_f, a) => [
+        `Hunting through the code for ${a["pattern"] ?? "what we need"}`,
+        `Let me track down ${a["pattern"] ?? "that"} in the source`,
+        `Scouring the codebase for ${a["pattern"] ?? "our target"}`,
+        `Searching high and low for ${a["pattern"] ?? "this pattern"}`
+      ]
+    };
+    WEB_SEARCH_VARIANTS = {
+      terse: () => [`Searching the web`, `Web search`, `Looking it up online`],
+      conv: () => [
+        `Let me search the web for that`,
+        `Checking online for that`,
+        `Let me look that up`,
+        `Searching the web real quick`
+      ],
+      chatty: () => [
+        `Off to the web to track this down`,
+        `Let me see what the internet has to say about this`,
+        `Heading online to dig up some answers`,
+        `Time for a quick web search`,
+        `Let me consult the wider world on this one`
+      ]
+    };
+    WEB_FETCH_VARIANTS = {
+      terse: () => [`Fetching page`, `Loading page`, `Downloading page`],
+      conv: () => [
+        `Pulling up that web page`,
+        `Fetching the page now`,
+        `Loading that page`,
+        `Grabbing the content from that URL`
+      ],
+      chatty: () => [
+        `Grabbing that page, one moment`,
+        `Let me pull that page up and see what's there`,
+        `Fetching the goods from that URL`,
+        `Loading up that page now`
+      ]
+    };
+    MEMORY_READ_VARIANTS = {
+      terse: () => [`Reading memory`, `Checking notes`, `Recalling`],
+      conv: () => [
+        `Checking my notes`,
+        `Let me see what I remember`,
+        `Pulling up my notes on this`,
+        `Looking through memory`
+      ],
+      chatty: () => [
+        `Let me dig through my notes on this`,
+        `Checking what I've got stored away`,
+        `Searching my memory for something relevant`,
+        `Let me recall what I know about this`
+      ]
+    };
+    MEMORY_WRITE_VARIANTS = {
+      terse: () => [`Saving to memory`, `Noting that`, `Remembering`],
+      conv: () => [
+        `Making a note of that`,
+        `Saving this for later`,
+        `Jotting that down`,
+        `Storing that away`
+      ],
+      chatty: () => [
+        `Stashing this away for later`,
+        `Making a mental note of this one`,
+        `Saving this to memory so I don't forget`,
+        `Filing this away for next time`
+      ]
+    };
+    SUB_AGENT_VARIANTS = {
+      terse: () => [`Delegating to sub agent`, `Spawning sub agent`, `Handing off`],
+      conv: () => [
+        `Handing this off to a sub agent`,
+        `Bringing in some help for this`,
+        `Delegating this part of the work`
+      ],
+      chatty: () => [
+        `Bringing in reinforcements for this one`,
+        `Let me hand this off to a specialist`,
+        `Calling in backup on this`,
+        `This needs a dedicated agent, passing it along`
+      ]
+    };
+    SHELL_VARIANTS = {
+      test: {
+        terse: ["Running tests", "Testing", "Executing tests"],
+        conv: [
+          "Let's run the tests and see how we're doing",
+          "Running the test suite",
+          "Time to check if the tests pass",
+          "Let me run those tests"
+        ],
+        chatty: [
+          "Alright, moment of truth, let's see if the tests pass",
+          "Running the tests, fingers crossed",
+          "Test time, let's see where we stand",
+          "Kicking off the test suite, here goes nothing",
+          "Let's put this to the test, literally"
+        ]
+      },
+      build: {
+        terse: ["Building project", "Compiling", "Building"],
+        conv: [
+          "Building the project now",
+          "Compiling everything",
+          "Starting the build",
+          "Let me build this"
+        ],
+        chatty: [
+          "Kicking off a build, fingers crossed",
+          "Time to compile and see if everything holds together",
+          "Building the project, let's see how it goes",
+          "Alright, build time",
+          "Compiling the whole thing, one moment"
+        ]
+      },
+      install: {
+        terse: ["Installing dependencies", "Installing packages", "Running install"],
+        conv: [
+          "Installing the dependencies",
+          "Pulling in the packages",
+          "Getting the dependencies set up"
+        ],
+        chatty: [
+          "Pulling in dependencies, this might take a sec",
+          "Installing packages, grab a coffee",
+          "Setting up the dependencies now"
+        ]
+      },
+      git: {
+        terse: ["Running git command", "Git operation", "Checking git"],
+        conv: [
+          "Running a git command",
+          "Checking with git",
+          "Let me do a git operation"
+        ],
+        chatty: [
+          "Checking in with git to see where things stand",
+          "Let me consult git on this",
+          "Running a quick git operation",
+          "Talking to git for a second"
+        ]
+      },
+      lint: {
+        terse: ["Running linter", "Linting", "Checking style"],
+        conv: [
+          "Checking the code with the linter",
+          "Running the linter",
+          "Let me check the code style"
+        ],
+        chatty: [
+          "Running the linter, let's keep things tidy",
+          "Lint check time, making sure everything's clean",
+          "Let's see if the linter is happy with this"
+        ]
+      },
+      node: {
+        terse: ["Running Node script", "Executing script"],
+        conv: [
+          "Running a Node script",
+          "Executing this script",
+          "Let me run this"
+        ],
+        chatty: [
+          "Firing up this Node script, let's see what happens",
+          "Running the script now",
+          "Executing this one, stand by"
+        ]
+      },
+      python: {
+        terse: ["Running Python", "Executing Python script"],
+        conv: ["Running a Python script", "Executing the Python code"],
+        chatty: [
+          "Running the Python script, one moment",
+          "Firing up Python for this one"
+        ]
+      },
+      network: {
+        terse: ["Making network request", "Fetching data"],
+        conv: ["Making a network request", "Fetching some data"],
+        chatty: ["Reaching out to the network", "Making a request, let's see what comes back"]
+      },
+      container: {
+        terse: ["Running container command", "Docker operation"],
+        conv: ["Running a container command", "Working with containers"],
+        chatty: ["Spinning up containers, one moment", "Doing some container work"]
+      },
+      generic: {
+        terse: ["Running command", "Executing command", "Shell command"],
+        conv: [
+          "Running a command",
+          "Executing a shell command",
+          "Let me run this command",
+          "Firing off a command"
+        ],
+        chatty: [
+          "Running a command, one moment",
+          "Let me execute this and see what we get",
+          "Firing off a shell command, stand by",
+          "Executing this, let's see the output",
+          "Running something in the shell real quick"
+        ]
+      }
+    };
+    RESULT_SUCCESS_VARIANTS = {
+      terse: ["Done", "OK", "Complete", "Got it"],
+      conv: [
+        "Got it",
+        "That worked",
+        "Good to go",
+        "Looking good",
+        "All set",
+        "Done"
+      ],
+      chatty: [
+        "Looking good, moving on",
+        "That went well, next step",
+        "Nice, onward",
+        "Perfect, let's keep going",
+        "Got what I needed, moving on",
+        "That came through, great",
+        "Worked like a charm"
+      ]
+    };
+    RESULT_FAIL_VARIANTS = {
+      terse: [
+        "Failed, retrying",
+        "Error, adjusting",
+        "That failed, fixing"
+      ],
+      conv: [
+        "That didn't work, let me try another approach",
+        "Hit a snag, adjusting course",
+        "Ran into an issue, trying again",
+        "Didn't go as expected, let me rethink this",
+        "Not quite, let me try something else"
+      ],
+      chatty: [
+        "Hmm, that didn't go as planned, let me try a different angle",
+        "Well that didn't work, but I've got another idea",
+        "Okay, that approach didn't pan out, pivoting",
+        "Hit a wall there, but I think I see another way",
+        "Not the result I was hoping for, let me regroup",
+        "That blew up, but no worries, I'll come at it differently",
+        "Alright, that wasn't it, but I'm not giving up"
+      ]
+    };
+    RESULT_MULTI_FAIL_VARIANTS = {
+      terse: ["Still failing, changing approach", "Error again, different method"],
+      conv: [
+        "Another miss, time to rethink this fundamentally",
+        "Still not working, let me step back and reconsider",
+        "Okay, clearly this approach isn't it"
+      ],
+      chatty: [
+        "That's a few misses now, time to really change things up",
+        "Alright, clearly I need a completely different strategy here",
+        "This keeps failing, let me take a step back and think about this differently",
+        "Okay, I've been going about this wrong, new plan"
+      ]
+    };
+    TASK_COMPLETE_VARIANTS = {
+      terse: ["Task complete.", "Done.", "Finished."],
+      conv: [
+        "All done.",
+        "That's everything.",
+        "Finished up.",
+        "All taken care of.",
+        "Wrapped that up."
+      ],
+      chatty: [
+        "And we're done!",
+        "That's a wrap!",
+        "All finished, good stuff.",
+        "Mission accomplished.",
+        "Everything's taken care of.",
+        "Done and dusted."
+      ]
+    };
+    TASK_INCOMPLETE_VARIANTS = {
+      terse: ["Task did not complete.", "Incomplete.", "Could not finish."],
+      conv: [
+        "I wasn't able to finish that one.",
+        "Didn't quite get there.",
+        "Ran out of steam on that one.",
+        "Couldn't quite wrap that up."
+      ],
+      chatty: [
+        "Well, that didn't quite get there. You might want to take a look at what's left.",
+        "I gave it my best shot, but couldn't finish everything.",
+        "Got partway there, but some things still need attention.",
+        "Not fully done, but I made progress on it."
+      ]
+    };
   }
 });
 
@@ -28134,7 +28836,7 @@ ${sections.join("\n\n")}`;
     return "";
   }
 }
-function adaptTool(tool) {
+function adaptTool2(tool) {
   return {
     name: tool.name,
     description: tool.description,
@@ -28836,7 +29538,7 @@ After synthesis, call task_complete with the final prioritized summary.`, toolMo
               new MemoryReadTool(this.repoRoot),
               new MemorySearchTool(this.repoRoot)
             ];
-            return [...tools.map(adaptTool), taskComplete];
+            return [...tools.map(adaptTool2), taskComplete];
           }
           case "monitor": {
             const tools = [
@@ -28846,7 +29548,7 @@ After synthesis, call task_complete with the final prioritized summary.`, toolMo
               new AutoresearchTool(this.repoRoot)
               // status-only in prompt
             ];
-            return [...tools.map(adaptTool), taskComplete];
+            return [...tools.map(adaptTool2), taskComplete];
           }
           case "evaluator": {
             const tools = [
@@ -28858,7 +29560,7 @@ After synthesis, call task_complete with the final prioritized summary.`, toolMo
               new MemoryWriteTool(this.repoRoot),
               new GrepSearchTool(this.repoRoot)
             ];
-            return [...tools.map(adaptTool), taskComplete];
+            return [...tools.map(adaptTool2), taskComplete];
           }
           case "critic": {
             const tools = [
@@ -28867,7 +29569,7 @@ After synthesis, call task_complete with the final prioritized summary.`, toolMo
               new MemorySearchTool(this.repoRoot),
               new GrepSearchTool(this.repoRoot)
             ];
-            return [...tools.map(adaptTool), taskComplete];
+            return [...tools.map(adaptTool2), taskComplete];
           }
           case "flow_maintainer": {
             const tools = [
@@ -28875,7 +29577,7 @@ After synthesis, call task_complete with the final prioritized summary.`, toolMo
               new MemoryWriteTool(this.repoRoot),
               new MemorySearchTool(this.repoRoot)
             ];
-            return [...tools.map(adaptTool), taskComplete];
+            return [...tools.map(adaptTool2), taskComplete];
           }
         }
       }
@@ -29233,7 +29935,7 @@ ${summaryResult}
             new WebSearchTool()
           ];
           return [
-            ...tools.map(adaptTool),
+            ...tools.map(adaptTool2),
             this.createTaskCompleteTool()
           ];
         }
@@ -29252,8 +29954,8 @@ ${summaryResult}
           new DreamShellTool(this.repoRoot)
         ];
         return [
-          ...readTools.map(adaptTool),
-          ...dreamWriteTools.map(adaptTool),
+          ...readTools.map(adaptTool2),
+          ...dreamWriteTools.map(adaptTool2),
           this.createTaskCompleteTool()
         ];
       }
@@ -29661,7 +30363,7 @@ Write consolidation insights and new reflections to memory before selecting a ta
 The next DMN cycle (and the main agent) will benefit from anything you store now.
 `;
 }
-function adaptTool2(tool) {
+function adaptTool3(tool) {
   return {
     name: tool.name,
     description: tool.description,
@@ -29929,7 +30631,7 @@ DMN state directory: ${this.stateDir}`);
           new WebSearchTool()
         ];
         return [
-          ...tools.map(adaptTool2),
+          ...tools.map(adaptTool3),
           this.createTaskCompleteTool()
         ];
       }
@@ -30204,7 +30906,7 @@ OUTPUT: Call task_complete with JSON:
           tools.push(new MemoryWriteTool(this.repoRoot));
         }
         runner.registerTools([
-          ...tools.map(adaptTool2),
+          ...tools.map(adaptTool3),
           {
             name: "task_complete",
             description: `Signal that the ${role} analysis is complete.`,
@@ -30448,7 +31150,7 @@ function computeSparsity(entries) {
   const avgOverlap = totalJaccard / totalPairs;
   return Math.max(0, Math.min(1, 1 - avgOverlap));
 }
-function adaptTool3(tool) {
+function adaptTool4(tool) {
   return {
     name: tool.name,
     description: tool.description,
@@ -30625,7 +31327,7 @@ Call task_complete with the JSON array when done.`, onEvent)
           new MemorySearchTool(this.repoRoot)
         ];
         runner.registerTools([
-          ...tools.map(adaptTool3),
+          ...tools.map(adaptTool4),
           {
             name: "task_complete",
             description: "Signal evaluation is complete with your scored results.",
@@ -31115,7 +31817,7 @@ function formatIntermediateState(event) {
   }
   return null;
 }
-function adaptTool4(tool) {
+function adaptTool5(tool) {
   return {
     name: tool.name,
     description: tool.description,
@@ -31774,7 +32476,7 @@ Telegram admin: @${msg.username}` : `Telegram ${isGroup ? "group" : "public"} ch
           new TranscribeFileTool(repoRoot),
           new TranscribeUrlTool(repoRoot)
         ];
-        let adaptedTools = allTools.map(adaptTool4);
+        let adaptedTools = allTools.map(adaptTool5);
         adaptedTools = applyToolPolicy(adaptedTools, context, this.toolPolicyConfig);
         if (context !== "telegram-admin-dm") {
           const memWriteIdx = adaptedTools.findIndex((t) => t.name === "memory_write");
@@ -33407,7 +34109,7 @@ function getVersion() {
   }
   return "0.0.0";
 }
-function adaptTool5(tool) {
+function adaptTool6(tool) {
   return {
     name: tool.name,
     description: tool.description,
@@ -33505,7 +34207,7 @@ function buildTools(repoRoot, config, contextWindowSize) {
     new AgendaTool(repoRoot)
   ];
   return [
-    ...executionTools.map(adaptTool5),
+    ...executionTools.map(adaptTool6),
     createSubAgentTool(config, repoRoot, contextWindowSize),
     createTaskCompleteTool()
   ];
@@ -33557,7 +34259,7 @@ function createSubAgentTool(config, repoRoot, ctxWindowSize) {
         new MemoryReadTool(repoRoot),
         new MemoryWriteTool(repoRoot)
       ];
-      subRunner.registerTools(subTools.map(adaptTool5));
+      subRunner.registerTools(subTools.map(adaptTool6));
       subRunner.registerTool(createTaskCompleteTool());
       if (background) {
         const promise = subRunner.run(task, `Working directory: ${repoRoot}`).then((result2) => {
@@ -33793,6 +34495,13 @@ ${entry.fullContent}`
             filesTouched.add(event.toolArgs.path);
           }
         }
+        getActivityFeed().push({
+          ts: Date.now(),
+          source: "main",
+          sourceId: "main",
+          summary: `${event.toolName ?? "unknown"}(${Object.keys(event.toolArgs ?? {}).join(", ")})`,
+          toolName: event.toolName ?? "unknown"
+        });
         lastToolCall = { name: event.toolName ?? "unknown", args: event.toolArgs ?? {} };
         statusBar?.recordSpeedToolCall(event.toolName ?? "unknown");
         toolCallStartMs = Date.now();
@@ -33811,6 +34520,14 @@ ${entry.fullContent}`
           editHistory.logToolCall(lastToolCall.name, lastToolCall.args, event.success ?? false);
           lastToolCall = null;
         }
+        getActivityFeed().push({
+          ts: Date.now(),
+          source: "main",
+          sourceId: "main",
+          summary: String(event.content ?? "").slice(0, 120),
+          toolName: event.toolName ?? "unknown",
+          success: event.success ?? false
+        });
         const resultLen = event.content?.length ?? 0;
         if (resultLen > 0) {
           statusBar?.recordSpeedToolResult(event.toolName ?? "unknown", resultLen);
@@ -33922,6 +34639,7 @@ ${entry.fullContent}`
   const systemContext = emotionContext ? `Working directory: ${repoRoot}
 
 ${emotionContext}` : `Working directory: ${repoRoot}`;
+  resetNarrationContext();
   const promise = runner.run(task, systemContext).then((result) => {
     const tokens = { total: result.totalTokens, estimated: result.estimatedTokens };
     contentWrite(() => {
@@ -34187,6 +34905,8 @@ async function startInteractive(config, repoPath) {
   });
   const voiceEngine = new VoiceEngine();
   let voiceSession = null;
+  let adminSessionKey = null;
+  const callSubAgents = /* @__PURE__ */ new Map();
   const streamRenderer = new StreamRenderer();
   if (savedSettings.voice) {
     voiceEngine.toggle().catch(() => {
@@ -34854,34 +35574,83 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
       return text ? `Stopped. Last transcript: "${text}"` : "Stopped listening.";
     },
     // Voice call session — standalone cloudflared tunnel for /call
-    // Wires: WebSocket audio → ASR transcription → agent input → TTS → WebSocket broadcast
+    // Each connecting WebSocket client gets a dedicated CallSubAgent.
+    // Admin callers (matching session key) get full tool access; public callers get read-only.
     async callStart() {
       if (voiceSession?.isActive) {
         return voiceSession.tunnelUrl;
       }
+      if (!adminSessionKey) {
+        adminSessionKey = generateSessionKey();
+      }
       voiceSession = new VoiceSession();
-      const callState = { transcriber: null, loading: false };
+      const callState = {
+        transcribers: /* @__PURE__ */ new Map(),
+        loading: false,
+        sharedTranscriber: null
+      };
       const engine = getListenEngine();
       voiceSession.onUserAudio = (pcmChunk, userId) => {
-        if (callState.transcriber)
-          callState.transcriber.write(pcmChunk);
+        if (callState.sharedTranscriber)
+          callState.sharedTranscriber.write(pcmChunk);
       };
-      voiceSession.on("userConnected", (id, username) => {
+      voiceSession.on("userConnected", (id, username, sessionKey) => {
         writeContent(() => renderVoiceSessionUser("connected", username));
-        if (!callState.transcriber && !callState.loading) {
+        const tier = sessionKey && sessionKey === adminSessionKey ? "admin" : "public";
+        writeContent(() => renderInfo(`Call client ${id} connected as ${tier.toUpperCase()}`));
+        const emotionState = emotionEngine?.getState?.();
+        const subAgent = new CallSubAgent(id, {
+          config: currentConfig,
+          repoRoot,
+          tier,
+          emotionContext: emotionState?.label ? `Current mood: ${emotionState.emoji ?? ""} ${emotionState.label}` : void 0,
+          modelTier: getModelTier(currentConfig.model),
+          contextWindowSize: resolvedContextWindowSize > 0 ? resolvedContextWindowSize : void 0
+        });
+        subAgent.on("response", (text) => {
+          writeContent(() => renderVoiceSessionTranscript("agent", text));
+          voiceSession?.sendTranscriptToClient(id, "agent", text);
+          if (voiceEngine.enabled && voiceEngine.ready) {
+            const session = voiceSession;
+            voiceEngine.synthesizeToPCM(text).then((result) => {
+              if (result && session?.isActive) {
+                const { pcm, sampleRate } = result;
+                session.sendSpeakingStateToClient(id, true);
+                session.sendAudioToClient(id, pcm);
+                const durationMs = pcm.length / 2 / sampleRate * 1e3;
+                setTimeout(() => session.sendSpeakingStateToClient(id, false), durationMs);
+              }
+            }).catch(() => {
+            });
+          }
+        });
+        subAgent.on("error", (err) => {
+          writeContent(() => renderWarning(`Call sub-agent error (${id}): ${err.message}`));
+        });
+        subAgent.init().then(() => {
+          callSubAgents.set(id, subAgent);
+        }).catch((err) => {
+          writeContent(() => renderWarning(`Call sub-agent init failed (${id}): ${err instanceof Error ? err.message : String(err)}`));
+        });
+        if (!callState.sharedTranscriber && !callState.loading) {
           callState.loading = true;
           engine.createCallTranscriber().then((t) => {
             if (!t || !voiceSession?.isActive)
               return;
-            callState.transcriber = t;
-            callState.transcriber.on("transcript", (evt) => {
+            callState.sharedTranscriber = t;
+            callState.sharedTranscriber.on("transcript", (evt) => {
               if (!evt.text?.trim() || !voiceSession?.isActive)
                 return;
               const text = evt.text.trim();
               writeContent(() => renderVoiceSessionTranscript("user", text));
               voiceSession?.sendTranscript("user", text);
               if (evt.isFinal) {
-                rl.write(text + "\n");
+                for (const [clientId, agent] of callSubAgents) {
+                  agent.handleTranscript(text);
+                }
+                if (callSubAgents.size === 0) {
+                  rl.write(text + "\n");
+                }
               }
             });
             writeContent(() => renderInfo("Call ASR ready \u2014 listening for speech"));
@@ -34892,6 +35661,11 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
       });
       voiceSession.on("userDisconnected", (id) => {
         writeContent(() => renderVoiceSessionUser("disconnected", id));
+        const subAgent = callSubAgents.get(id);
+        if (subAgent) {
+          subAgent.dispose();
+          callSubAgents.delete(id);
+        }
       });
       voiceSession.on("wsClose", (id, code, reason) => {
         if (code > 0)
@@ -34902,15 +35676,21 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
       });
       voiceSession.on("idle_timeout", () => {
         writeContent(() => renderWarning("Call session auto-closed (1 min idle \u2014 no users connected)"));
-        if (callState.transcriber) {
-          callState.transcriber.stop();
-          callState.transcriber = null;
+        if (callState.sharedTranscriber) {
+          callState.sharedTranscriber.stop();
+          callState.sharedTranscriber = null;
         }
+        for (const agent of callSubAgents.values())
+          agent.dispose();
+        callSubAgents.clear();
         voiceSession = null;
       });
       try {
         const tunnelUrl = await voiceSession.start();
+        const adminUrl = adminSessionKey ? `${tunnelUrl}?key=${adminSessionKey}` : tunnelUrl;
         writeContent(() => renderVoiceSessionStart(tunnelUrl));
+        writeContent(() => renderInfo(`Admin call URL (includes key): ${adminUrl}`));
+        writeContent(() => renderInfo(`Public call URL (read-only): ${tunnelUrl}`));
         if (voiceEngine.enabled && voiceEngine.ready) {
           const session = voiceSession;
           voiceEngine.onPCMOutput = (pcm, sampleRate) => {
@@ -34925,8 +35705,13 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
         return tunnelUrl;
       } catch (err) {
         writeContent(() => renderWarning(`Voice session failed: ${err instanceof Error ? err.message : String(err)}`));
-        callState.transcriber?.stop();
-        callState.transcriber = null;
+        if (callState.sharedTranscriber) {
+          callState.sharedTranscriber.stop();
+          callState.sharedTranscriber = null;
+        }
+        for (const agent of callSubAgents.values())
+          agent.dispose();
+        callSubAgents.clear();
         voiceSession = null;
         return null;
       }
@@ -34938,6 +35723,9 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
         writeContent(() => renderVoiceSessionStop(runtime));
         voiceSession = null;
         voiceEngine.onPCMOutput = null;
+        for (const agent of callSubAgents.values())
+          agent.dispose();
+        callSubAgents.clear();
       }
     },
     isCallActive() {
@@ -35624,6 +36412,7 @@ var init_interactive = __esm({
     init_dist();
     init_listen();
     init_voice_session();
+    init_call_agent();
     init_config();
     init_updater();
     init_commands();