open-agents-ai 0.59.0 → 0.60.0

package/dist/index.js

@@ -26671,265 +26671,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 +26959,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 +27521,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."
+      ]
+    };
   }
 });
 
@@ -33922,6 +34305,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(() => {

package/package.json

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