open-agents-ai 0.103.60 → 0.103.61

package/dist/index.js

@@ -37246,6 +37246,166 @@ function pick(key, variants) {
   narration.lastVariantIdx[key] = idx;
   return variants[idx];
 }
+function extractToolObject(toolName, args) {
+  const path = args["path"];
+  const file = path ? path.split("/").pop() ?? path : "";
+  switch (toolName) {
+    case "file_read":
+    case "file_write":
+    case "file_edit":
+    case "file_patch":
+    case "image_read":
+      return file || String(args["file_path"] ?? "").split("/").pop() || "";
+    case "shell": {
+      const cmd = String(args["command"] ?? "");
+      const essence = extractShellEssence(cmd);
+      if (essence)
+        return essence;
+      const cat = getShellCategory(cmd);
+      if (cat !== "generic")
+        return cat;
+      const snip = cmd.length > 50 ? cmd.slice(0, 47) + "..." : cmd;
+      return snip.replace(/[|><&;$`\\]/g, " ").replace(/\s+/g, " ").trim();
+    }
+    case "grep_search":
+      return String(args["pattern"] ?? "");
+    case "find_files":
+      return String(args["pattern"] ?? args["glob"] ?? "");
+    case "list_directory":
+      return file || String(args["directory"] ?? ".");
+    case "web_search":
+      return String(args["query"] ?? args["search"] ?? "");
+    case "web_fetch":
+      return String(args["url"] ?? "").replace(/https?:\/\//, "").split("/")[0] || "";
+    case "memory_read":
+      return String(args["key"] ?? args["topic"] ?? "notes");
+    case "memory_write":
+      return String(args["key"] ?? args["topic"] ?? "this");
+    case "sub_agent": {
+      const topic = extractSubAgentTopic(args);
+      if (topic)
+        return topic;
+      const agentType = String(args["subagent_type"] ?? args["type"] ?? "").replace(/-/g, " ");
+      return agentType || "sub agent";
+    }
+    case "batch_edit":
+      return `${Object.keys(args["edits"] ?? {}).length || "multiple"} files`;
+    case "browser_action":
+      return String(args["action"] ?? "action");
+    case "screenshot":
+      return "the screen";
+    case "ocr":
+      return file || "image";
+    case "codebase_map":
+      return "the project structure";
+    case "diagnostic":
+      return "system health";
+    case "git_info":
+      return "repository state";
+    default:
+      return file || "";
+  }
+}
+function extractToolVerb(toolName, args) {
+  switch (toolName) {
+    case "file_read":
+      return ["reading", "looking at"];
+    case "file_write":
+      return ["writing", "saving changes to"];
+    case "file_edit":
+    case "file_patch":
+      return ["editing", "modifying"];
+    case "shell": {
+      const cmd = String(args["command"] ?? "");
+      const essence = extractShellEssence(cmd);
+      if (essence)
+        return [essence, essence];
+      return ["running", "executing"];
+    }
+    case "grep_search":
+      return ["searching for", "scanning the code for"];
+    case "find_files":
+      return ["finding", "locating files matching"];
+    case "list_directory":
+      return ["listing", "browsing"];
+    case "web_search":
+      return ["searching", "looking up"];
+    case "web_fetch":
+      return ["fetching", "pulling content from"];
+    case "memory_read":
+      return ["recalling", "checking memory for"];
+    case "memory_write":
+      return ["storing", "saving to memory"];
+    case "sub_agent":
+      return ["delegating", "handing off to"];
+    case "batch_edit":
+      return ["batch editing", "editing across"];
+    case "browser_action": {
+      const action = String(args["action"] ?? "interacting");
+      return [
+        action === "navigate" ? "navigating to" : `browser ${action}`,
+        action === "navigate" ? "opening" : `performing browser ${action}`
+      ];
+    }
+    case "screenshot":
+      return ["capturing", "snapping"];
+    case "ocr":
+      return ["extracting text from", "running OCR on"];
+    case "codebase_map":
+      return ["mapping", "surveying"];
+    case "diagnostic":
+      return ["diagnosing", "running diagnostics on"];
+    case "git_info":
+      return ["checking", "inspecting"];
+    case "image_read":
+      return ["examining", "looking at"];
+    default: {
+      const readable = toolName.replace(/[_-]/g, " ");
+      return [`invoking ${readable}`, `calling ${readable}`];
+    }
+  }
+}
+function composeToolNarration(toolName, args, tier, _emotion) {
+  const obj = extractToolObject(toolName, args);
+  const [terseVerb, expandedVerb] = extractToolVerb(toolName, args);
+  if (toolName === "shell") {
+    const shellEssence = extractShellEssence(String(args["command"] ?? ""));
+    if (shellEssence) {
+      let core2 = shellEssence.charAt(0).toUpperCase() + shellEssence.slice(1);
+      return core2;
+    }
+  }
+  let core;
+  if (!obj) {
+    const cleanVerb = terseVerb.replace(/\s+(on|to|from|for|in|at|of)$/i, "");
+    core = cleanVerb.charAt(0).toUpperCase() + cleanVerb.slice(1);
+  } else if (tier === "terse") {
+    core = `${terseVerb.charAt(0).toUpperCase() + terseVerb.slice(1)} ${obj}`;
+  } else {
+    core = `${expandedVerb.charAt(0).toUpperCase() + expandedVerb.slice(1)} ${obj}`;
+  }
+  if (tier !== "terse") {
+    const count = narration.toolCounts[toolName] ?? 0;
+    const isRevisitFile = obj && narration.filesSeen.has(obj);
+    const isSameFile = obj && obj === narration.lastFile;
+    const isSameTool = toolName === narration.lastTool;
+    if (narration.consecutiveErrors >= 3) {
+      core = tier === "chatty" ? `Different angle now, ${core.charAt(0).toLowerCase() + core.slice(1)}` : `New approach, ${core.charAt(0).toLowerCase() + core.slice(1)}`;
+    } else if (narration.consecutiveErrors === 2) {
+      core = tier === "chatty" ? `That path didn't work, trying ${core.charAt(0).toLowerCase() + core.slice(1)}` : `Adjusting, ${core.charAt(0).toLowerCase() + core.slice(1)}`;
+    } else if (narration.consecutiveErrors === 1) {
+      core = `Recovering, ${core.charAt(0).toLowerCase() + core.slice(1)}`;
+    } else if (isSameFile && count > 1) {
+      const action = terseVerb.replace(/ing$/, "ing it again");
+      core = tier === "chatty" ? `Still in ${obj}, ${action}` : `Back to ${obj}`;
+    } else if (isRevisitFile && !isSameFile) {
+      core = tier === "chatty" ? `Returning to ${obj}` : `Coming back to ${obj}`;
+    } else if (isSameTool && count > 3 && tier === "chatty") {
+      core = `${core}, iteration ${count}`;
+    }
+  }
+  return core;
+}
 function extractSubAgentTopic(args) {
   const raw = String(args["description"] ?? args["prompt"] ?? "");
   if (!raw || raw.length < 5)
@@ -37308,42 +37468,6 @@ function getShellCategory(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 "";
-}
 function getTier(personality) {
   if (personality <= 2)
     return "terse";
@@ -37456,7 +37580,6 @@ function describeToolCall(toolName, args, personality = 2, emotion, stark = fals
   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;
@@ -37464,176 +37587,27 @@ function describeToolCall(toolName, args, personality = 2, emotion, stark = fals
     narration.filesSeen.add(file);
     narration.lastFile = file;
   }
-  let base;
-  const poolKey = `${toolName}_${tier}`;
-  switch (toolName) {
-    case "file_read":
-      base = pick(poolKey, (FILE_READ_VARIANTS[tier] ?? FILE_READ_VARIANTS.terse)(file, args));
-      break;
-    case "file_write":
-      base = pick(poolKey, (FILE_WRITE_VARIANTS[tier] ?? FILE_WRITE_VARIANTS.terse)(file, args));
-      break;
-    case "file_edit":
-    case "file_patch":
-      base = pick(poolKey, (FILE_EDIT_VARIANTS[tier] ?? FILE_EDIT_VARIANTS.terse)(file, args));
-      break;
-    case "shell": {
-      const cmd = String(args["command"] ?? "");
-      const cat = getShellCategory(cmd);
-      const essence = extractShellEssence(cmd);
-      if (essence && tier !== "terse") {
-        const essenceVariants = tier === "chatty" ? [`Alright, ${essence}`, `Let me handle ${essence}`, `Time to ${essence.startsWith("running") ? essence : "run " + essence}`] : [`Now ${essence}`, essence.charAt(0).toUpperCase() + essence.slice(1)];
-        base = pick(`shell_ess_${tier}`, essenceVariants);
-      } else {
-        const pool = SHELL_VARIANTS[cat] ?? SHELL_VARIANTS.generic;
-        base = pick(`shell_${cat}_${tier}`, pool[tier] ?? pool.terse);
-      }
-      break;
-    }
-    case "grep_search":
-      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":
-      base = pick(poolKey, (WEB_SEARCH_VARIANTS[tier] ?? WEB_SEARCH_VARIANTS.terse)(file, args));
-      break;
-    case "web_fetch":
-      base = pick(poolKey, (WEB_FETCH_VARIANTS[tier] ?? WEB_FETCH_VARIANTS.terse)(file, args));
-      break;
-    case "memory_read":
-      base = pick(poolKey, (MEMORY_READ_VARIANTS[tier] ?? MEMORY_READ_VARIANTS.terse)(file, args));
-      break;
-    case "memory_write":
-      base = pick(poolKey, (MEMORY_WRITE_VARIANTS[tier] ?? MEMORY_WRITE_VARIANTS.terse)(file, args));
-      break;
-    case "task_complete":
-      base = String(args["summary"] ?? (tier === "chatty" ? "And that's a wrap" : tier === "conv" ? "All done" : "Task complete"));
-      break;
-    case "sub_agent":
-      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;
-    }
+  let result = composeToolNarration(toolName, args, tier, emotion);
+  if (toolName === "task_complete") {
+    result = String(args["summary"] ?? "Task complete");
   }
   const emoPrefix = personality >= 3 ? emotionColor(emotion, stark) : "";
-  let result;
-  const fullPrefix = emoPrefix + prefix;
-  if (!fullPrefix) {
-    result = base;
-  } else if (fullPrefix.endsWith(". ") || fullPrefix.endsWith("! ")) {
-    result = fullPrefix + base;
-  } else if (base.length > 0) {
-    result = fullPrefix + base.charAt(0).toLowerCase() + base.slice(1);
-  } else {
-    result = base;
+  if (emoPrefix) {
+    if (emoPrefix.endsWith(". ") || emoPrefix.endsWith("! ")) {
+      result = emoPrefix + result;
+    } else {
+      result = emoPrefix + result.charAt(0).toLowerCase() + result.slice(1);
+    }
   }
-  if (narration.lastResultDigest && personality >= 3 && Math.random() < 0.4) {
+  if (narration.lastResultDigest && personality >= 3 && Math.random() < 0.5) {
     const ctx = narration.lastResultDigest;
-    const bridges = tier === "chatty" ? [` \u2014 earlier I saw ${ctx}`, `, building on what we found: ${ctx}`, `. Given that we got ${ctx}`] : [` \u2014 saw ${ctx} earlier`, `, following up on ${ctx}`];
-    result += pick("ctx_lastresult", bridges);
+    if (ctx.includes("error") || ctx.includes("fail")) {
+      result += `, addressing the ${ctx} from before`;
+    } else if (ctx.includes("pass") || ctx.includes("success")) {
+      result += `, building on ${ctx}`;
+    } else {
+      result += `, following up on ${ctx}`;
+    }
     narration.lastResultDigest = "";
   }
   return result;
@@ -37737,47 +37711,69 @@ function describeToolResult(toolName, success, personality = 2, resultContent, e
     narration.lastResultDigest = digest;
   }
   const emo = personality >= 3 ? emotionColor(emotion, stark) : "";
+  const readable = toolName.replace(/[_-]/g, " ");
+  const lastFile = narration.lastFile || "";
+  const subject = lastFile || readable;
   if (success) {
     narration.consecutiveErrors = 0;
-    if (!digest && !emo && personality >= 3 && Math.random() < 0.4)
-      return "";
-    const base = pick(`result_ok_${tier}`, RESULT_SUCCESS_VARIANTS[tier] ?? RESULT_SUCCESS_VARIANTS.terse);
-    if (digest && personality >= 2) {
+    if (digest) {
+      if (tier === "terse") {
+        return `${emo}${digest}`;
+      }
       if (tier === "chatty" && digest.length > 15) {
-        if (Math.random() < 0.5) {
-          const contentLeads = [
-            `${emo}Interesting, ${digest}`,
-            `${emo}So we've got ${digest}`,
-            `${emo}${digest.charAt(0).toUpperCase() + digest.slice(1)}, that's useful`
-          ];
-          return pick("digest_lead", contentLeads);
-        }
+        return `${emo}${digest.charAt(0).toUpperCase() + digest.slice(1)}`;
       }
-      const connectors = tier === "chatty" ? [` \u2014 ${digest}`, `, I see ${digest}`, `. Looks like ${digest}`, `, showing ${digest}`] : tier === "conv" ? [` \u2014 ${digest}`, `, ${digest}`, `. Shows ${digest}`] : [`: ${digest}`];
-      return emo + base + pick("digest_conn_ok", connectors);
+      return `${emo}${subject}: ${digest}`;
     }
-    return emo + base;
+    if (tier === "terse") {
+      return `${emo}${subject} clean`;
+    }
+    const [terseVerb] = extractToolVerb(toolName, {});
+    const pastVerb = terseVerb.replace(/ing$/, "ed").replace(/ching$/, "ched");
+    if (tier === "conv") {
+      return `${emo}${pastVerb.charAt(0).toUpperCase() + pastVerb.slice(1)} ${subject} successfully`;
+    }
+    return `${emo}${pastVerb.charAt(0).toUpperCase() + pastVerb.slice(1)} ${subject}, output was routine, moving forward`;
   }
   narration.consecutiveErrors++;
   narration.totalErrors++;
-  const failBase = narration.consecutiveErrors >= 3 ? pick(`result_multifail_${tier}`, RESULT_MULTI_FAIL_VARIANTS[tier] ?? RESULT_MULTI_FAIL_VARIANTS.terse) : pick(`result_fail_${tier}`, RESULT_FAIL_VARIANTS[tier] ?? RESULT_FAIL_VARIANTS.terse);
-  if (digest && personality >= 2) {
-    return emo + `${failBase} \u2014 ${digest}`;
+  const errCount = narration.consecutiveErrors;
+  const severity = errCount >= 3 ? "persistent" : errCount === 2 ? "repeated" : "single";
+  let failSentence;
+  if (digest) {
+    if (tier === "terse") {
+      failSentence = `${readable} failed: ${digest}`;
+    } else if (severity === "persistent") {
+      failSentence = `${readable} failed again on ${subject}, ${errCount} consecutive errors now, ${digest}`;
+    } else {
+      failSentence = `${readable} on ${subject} hit an issue: ${digest}`;
+    }
+  } else {
+    if (tier === "terse") {
+      failSentence = `${readable} on ${subject} failed`;
+    } else if (severity === "persistent") {
+      failSentence = `${readable} keeps failing on ${subject}, ${errCount} attempts now, no extractable error detail`;
+    } else if (severity === "repeated") {
+      failSentence = `${readable} failed again on ${subject}, second attempt`;
+    } else {
+      failSentence = `${readable} on ${subject} returned an error`;
+    }
   }
-  return emo + failBase;
+  return `${emo}${failSentence}`;
 }
-function describeTaskComplete(summary, completed, personality = 2, stark = false) {
-  const truncated = summary.length > 300 ? summary.slice(0, 300) + "..." : summary;
+function describeTaskComplete(summary, completed, personality = 2, _stark = false) {
   const tier = getTier(personality);
+  const truncated = summary.length > 200 ? summary.slice(0, 200) + "..." : summary;
   if (!completed) {
-    const pool2 = stark ? ["Not done. But I'll be back.", "It resisted. For now.", "Unfinished. This isn't over.", "Didn't crack it yet. Give me another shot."] : TASK_INCOMPLETE_VARIANTS[tier] ?? TASK_INCOMPLETE_VARIANTS.terse;
-    return pick(`task_incomplete_${stark ? "stark" : tier}`, pool2);
+    if (truncated) {
+      return tier === "terse" ? `Incomplete: ${truncated}` : `Could not finish. ${truncated}`;
+    }
+    return `Task ended without completion, no summary was provided`;
+  }
+  if (truncated) {
+    return truncated;
   }
-  const pool = stark ? ["Nailed it.", "That's how it's done.", "Clean execution.", "Another one down.", "Executed. Next.", "And that's that."] : TASK_COMPLETE_VARIANTS[tier] ?? TASK_COMPLETE_VARIANTS.terse;
-  const opener = pick(`task_complete_${stark ? "stark" : tier}`, pool);
-  if (truncated)
-    return `${opener} ${truncated}`;
-  return opener;
+  return `Task completed, but no summary was generated to describe the outcome`;
 }
 function formatBytes2(bytes) {
   if (bytes < 1024)
@@ -37786,7 +37782,7 @@ function formatBytes2(bytes) {
     return `${(bytes / 1024).toFixed(0)}KB`;
   return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
 }
-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 VOICE_MODELS, VoiceEngine, narration;
 var init_voice = __esm({
   "packages/cli/dist/tui/voice.js"() {
     "use strict";
@@ -38750,358 +38746,6 @@ Error: ${err instanceof Error ? err.message : String(err)}`);
       lastVariantIdx: {},
       lastResultDigest: ""
     };
-    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: (_f, a) => {
-        const topic = extractSubAgentTopic(a);
-        return topic ? [`Sub agent: ${topic}`, `Delegating: ${topic}`] : [`Delegating to sub agent`, `Spawning sub agent`];
-      },
-      conv: (_f, a) => {
-        const topic = extractSubAgentTopic(a);
-        return topic ? [`Handing off to a sub agent to ${topic}`, `Bringing in help to ${topic}`, `Delegating the ${topic} work`] : [`Handing this off to a sub agent`, `Bringing in some help for this`, `Delegating this part of the work`];
-      },
-      chatty: (_f, a) => {
-        const topic = extractSubAgentTopic(a);
-        return topic ? [`Spinning up a sub agent to ${topic}`, `This part needs a specialist, delegating to ${topic}`, `Calling in backup to handle ${topic}`] : [`Bringing in reinforcements for this one`, `Let me hand this off to a specialist`, `Calling in backup on this`];
-      }
-    };
-    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."
-      ]
-    };
   }
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.103.60",
+  "version": "0.103.61",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",