@levelcode/sdk 0.0.4 → 0.1.0

package/dist/index.cjs

@@ -7269,8 +7269,8 @@ var require_uri_all = __commonJS((exports3, module2) => {
           wsComponents.secure = undefined;
         }
         if (wsComponents.resourceName) {
-          var _wsComponents$resourc = wsComponents.resourceName.split("?"), _wsComponents$resourc2 = slicedToArray(_wsComponents$resourc, 2), path4 = _wsComponents$resourc2[0], query = _wsComponents$resourc2[1];
-          wsComponents.path = path4 && path4 !== "/" ? path4 : undefined;
+          var _wsComponents$resourc = wsComponents.resourceName.split("?"), _wsComponents$resourc2 = slicedToArray(_wsComponents$resourc, 2), path6 = _wsComponents$resourc2[0], query = _wsComponents$resourc2[1];
+          wsComponents.path = path6 && path6 !== "/" ? path6 : undefined;
           wsComponents.query = query;
           wsComponents.resourceName = undefined;
         }
@@ -7663,12 +7663,12 @@ var require_util = __commonJS((exports3, module2) => {
     return "'" + escapeQuotes(str) + "'";
   }
   function getPathExpr(currentPath, expr, jsonPointers, isNumber2) {
-    var path4 = jsonPointers ? "'/' + " + expr + (isNumber2 ? "" : ".replace(/~/g, '~0').replace(/\\//g, '~1')") : isNumber2 ? "'[' + " + expr + " + ']'" : "'[\\'' + " + expr + " + '\\']'";
-    return joinPaths(currentPath, path4);
+    var path6 = jsonPointers ? "'/' + " + expr + (isNumber2 ? "" : ".replace(/~/g, '~0').replace(/\\//g, '~1')") : isNumber2 ? "'[' + " + expr + " + ']'" : "'[\\'' + " + expr + " + '\\']'";
+    return joinPaths(currentPath, path6);
   }
   function getPath(currentPath, prop, jsonPointers) {
-    var path4 = jsonPointers ? toQuotedString("/" + escapeJsonPointer(prop)) : toQuotedString(getProperty(prop));
-    return joinPaths(currentPath, path4);
+    var path6 = jsonPointers ? toQuotedString("/" + escapeJsonPointer(prop)) : toQuotedString(getProperty(prop));
+    return joinPaths(currentPath, path6);
   }
   var JSON_POINTER = /^\/(?:[^~]|~0|~1)*$/;
   var RELATIVE_JSON_POINTER = /^([0-9]+)(#|\/(?:[^~]|~0|~1)*)?$/;
@@ -12633,8 +12633,8 @@ var require_ajv = __commonJS((exports3, module2) => {
 var require_windows = __commonJS((exports3, module2) => {
   module2.exports = isexe;
   isexe.sync = sync;
-  var fs = require("fs");
-  function checkPathExt(path4, options) {
+  var fs8 = require("fs");
+  function checkPathExt(path6, options) {
     var pathext = options.pathExt !== undefined ? options.pathExt : process.env.PATHEXT;
     if (!pathext) {
       return true;
@@ -12645,25 +12645,25 @@ var require_windows = __commonJS((exports3, module2) => {
     }
     for (var i = 0;i < pathext.length; i++) {
       var p = pathext[i].toLowerCase();
-      if (p && path4.substr(-p.length).toLowerCase() === p) {
+      if (p && path6.substr(-p.length).toLowerCase() === p) {
         return true;
       }
     }
     return false;
   }
-  function checkStat(stat, path4, options) {
+  function checkStat(stat, path6, options) {
     if (!stat.isSymbolicLink() && !stat.isFile()) {
       return false;
     }
-    return checkPathExt(path4, options);
+    return checkPathExt(path6, options);
   }
-  function isexe(path4, options, cb) {
-    fs.stat(path4, function(er, stat) {
-      cb(er, er ? false : checkStat(stat, path4, options));
+  function isexe(path6, options, cb) {
+    fs8.stat(path6, function(er, stat) {
+      cb(er, er ? false : checkStat(stat, path6, options));
     });
   }
-  function sync(path4, options) {
-    return checkStat(fs.statSync(path4), path4, options);
+  function sync(path6, options) {
+    return checkStat(fs8.statSync(path6), path6, options);
   }
 });
 
@@ -12671,14 +12671,14 @@ var require_windows = __commonJS((exports3, module2) => {
 var require_mode = __commonJS((exports3, module2) => {
   module2.exports = isexe;
   isexe.sync = sync;
-  var fs = require("fs");
-  function isexe(path4, options, cb) {
-    fs.stat(path4, function(er, stat) {
+  var fs8 = require("fs");
+  function isexe(path6, options, cb) {
+    fs8.stat(path6, function(er, stat) {
       cb(er, er ? false : checkStat(stat, options));
     });
   }
-  function sync(path4, options) {
-    return checkStat(fs.statSync(path4), options);
+  function sync(path6, options) {
+    return checkStat(fs8.statSync(path6), options);
   }
   function checkStat(stat, options) {
     return stat.isFile() && checkMode(stat, options);
@@ -12700,7 +12700,7 @@ var require_mode = __commonJS((exports3, module2) => {
 
 // ../node_modules/isexe/index.js
 var require_isexe = __commonJS((exports3, module2) => {
-  var fs = require("fs");
+  var fs8 = require("fs");
   var core;
   if (process.platform === "win32" || global.TESTING_WINDOWS) {
     core = require_windows();
@@ -12709,7 +12709,7 @@ var require_isexe = __commonJS((exports3, module2) => {
   }
   module2.exports = isexe;
   isexe.sync = sync;
-  function isexe(path4, options, cb) {
+  function isexe(path6, options, cb) {
     if (typeof options === "function") {
       cb = options;
       options = {};
@@ -12719,7 +12719,7 @@ var require_isexe = __commonJS((exports3, module2) => {
         throw new TypeError("callback not provided");
       }
       return new Promise(function(resolve2, reject) {
-        isexe(path4, options || {}, function(er, is) {
+        isexe(path6, options || {}, function(er, is) {
           if (er) {
             reject(er);
           } else {
@@ -12728,7 +12728,7 @@ var require_isexe = __commonJS((exports3, module2) => {
         });
       });
     }
-    core(path4, options || {}, function(er, is) {
+    core(path6, options || {}, function(er, is) {
       if (er) {
         if (er.code === "EACCES" || options && options.ignoreErrors) {
           er = null;
@@ -12738,9 +12738,9 @@ var require_isexe = __commonJS((exports3, module2) => {
       cb(er, is);
     });
   }
-  function sync(path4, options) {
+  function sync(path6, options) {
     try {
-      return core.sync(path4, options || {});
+      return core.sync(path6, options || {});
     } catch (er) {
       if (options && options.ignoreErrors || er.code === "EACCES") {
         return false;
@@ -12754,7 +12754,7 @@ var require_isexe = __commonJS((exports3, module2) => {
 // ../node_modules/which/which.js
 var require_which = __commonJS((exports3, module2) => {
   var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
-  var path4 = require("path");
+  var path6 = require("path");
   var COLON = isWindows ? ";" : ":";
   var isexe = require_isexe();
   var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
@@ -12790,7 +12790,7 @@ var require_which = __commonJS((exports3, module2) => {
         return opt.all && found.length ? resolve2(found) : reject(getNotFoundError(cmd));
       const ppRaw = pathEnv[i];
       const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-      const pCmd = path4.join(pathPart, cmd);
+      const pCmd = path6.join(pathPart, cmd);
       const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
       resolve2(subStep(p, i, 0));
     });
@@ -12817,7 +12817,7 @@ var require_which = __commonJS((exports3, module2) => {
     for (let i = 0;i < pathEnv.length; i++) {
       const ppRaw = pathEnv[i];
       const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-      const pCmd = path4.join(pathPart, cmd);
+      const pCmd = path6.join(pathPart, cmd);
       const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
       for (let j = 0;j < pathExt.length; j++) {
         const cur = p + pathExt[j];
@@ -12858,7 +12858,7 @@ var require_path_key = __commonJS((exports3, module2) => {
 
 // ../node_modules/cross-spawn/lib/util/resolveCommand.js
 var require_resolveCommand = __commonJS((exports3, module2) => {
-  var path4 = require("path");
+  var path6 = require("path");
   var which = require_which();
   var getPathKey = require_path_key();
   function resolveCommandAttempt(parsed, withoutPathExt) {
@@ -12875,7 +12875,7 @@ var require_resolveCommand = __commonJS((exports3, module2) => {
     try {
       resolved = which.sync(parsed.command, {
         path: env2[getPathKey({ env: env2 })],
-        pathExt: withoutPathExt ? path4.delimiter : undefined
+        pathExt: withoutPathExt ? path6.delimiter : undefined
       });
     } catch (e) {} finally {
       if (shouldSwitchCwd) {
@@ -12883,7 +12883,7 @@ var require_resolveCommand = __commonJS((exports3, module2) => {
       }
     }
     if (resolved) {
-      resolved = path4.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+      resolved = path6.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
     }
     return resolved;
   }
@@ -12928,8 +12928,8 @@ var require_shebang_command = __commonJS((exports3, module2) => {
     if (!match) {
       return null;
     }
-    const [path4, argument] = match[0].replace(/#! ?/, "").split(" ");
-    const binary = path4.split("/").pop();
+    const [path6, argument] = match[0].replace(/#! ?/, "").split(" ");
+    const binary = path6.split("/").pop();
     if (binary === "env") {
       return argument;
     }
@@ -12939,16 +12939,16 @@ var require_shebang_command = __commonJS((exports3, module2) => {
 
 // ../node_modules/cross-spawn/lib/util/readShebang.js
 var require_readShebang = __commonJS((exports3, module2) => {
-  var fs = require("fs");
+  var fs8 = require("fs");
   var shebangCommand = require_shebang_command();
   function readShebang(command) {
     const size = 150;
     const buffer = Buffer.alloc(size);
     let fd;
     try {
-      fd = fs.openSync(command, "r");
-      fs.readSync(fd, buffer, 0, size, 0);
-      fs.closeSync(fd);
+      fd = fs8.openSync(command, "r");
+      fs8.readSync(fd, buffer, 0, size, 0);
+      fs8.closeSync(fd);
     } catch (e) {}
     return shebangCommand(buffer.toString());
   }
@@ -12957,7 +12957,7 @@ var require_readShebang = __commonJS((exports3, module2) => {
 
 // ../node_modules/cross-spawn/lib/parse.js
 var require_parse = __commonJS((exports3, module2) => {
-  var path4 = require("path");
+  var path6 = require("path");
   var resolveCommand = require_resolveCommand();
   var escape = require_escape();
   var readShebang = require_readShebang();
@@ -12982,7 +12982,7 @@ var require_parse = __commonJS((exports3, module2) => {
     const needsShell = !isExecutableRegExp.test(commandFile);
     if (parsed.options.forceShell || needsShell) {
       const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
-      parsed.command = path4.normalize(parsed.command);
+      parsed.command = path6.normalize(parsed.command);
       parsed.command = escape.command(parsed.command);
       parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
       const shellCommand = [parsed.command].concat(parsed.args).join(" ");
@@ -16906,6 +16906,7 @@ var toolNames = [
   "read_subtree",
   "run_file_change_hooks",
   "run_terminal_command",
+  "send_message",
   "set_messages",
   "set_output",
   "skill",
@@ -16914,6 +16915,12 @@ var toolNames = [
   "str_replace",
   "suggest_followups",
   "task_completed",
+  "task_create",
+  "task_get",
+  "task_list",
+  "task_update",
+  "team_create",
+  "team_delete",
   "think_deeply",
   "update_subgoal",
   "web_search",
@@ -18415,7 +18422,7 @@ function clearProposedContentForRun(runId) {
 }
 
 // ../common/src/tools/list.ts
-var import_v452 = __toESM(require("zod/v4"));
+var import_v459 = __toESM(require("zod/v4"));
 
 // ../common/src/actions.ts
 var import_v417 = require("zod/v4");
@@ -19828,18 +19835,79 @@ var runFileChangeHooksParams = {
   ]).array())
 };
 
-// ../common/src/tools/params/tool/set-messages.ts
+// ../common/src/tools/params/tool/send-message.ts
 var import_v440 = __toESM(require("zod/v4"));
-var toolName20 = "set_messages";
-var endsAgentStep20 = true;
+var toolName20 = "send_message";
+var endsAgentStep20 = false;
 var inputSchema20 = import_v440.default.object({
-  messages: import_v440.default.any()
-}).describe(`Set the conversation history to the provided messages.`);
+  type: import_v440.default.enum([
+    "message",
+    "broadcast",
+    "shutdown_request",
+    "shutdown_response",
+    "plan_approval_response"
+  ]).describe('Message type: "message" for DMs, "broadcast" to all teammates, "shutdown_request" to request shutdown, "shutdown_response" to respond to shutdown, "plan_approval_response" to approve/reject plans'),
+  recipient: import_v440.default.string().optional().describe("Agent name of the recipient (required for message, shutdown_request, plan_approval_response)"),
+  content: import_v440.default.string().optional().describe("Message text, reason, or feedback"),
+  summary: import_v440.default.string().optional().describe("A 5-10 word summary of the message, shown as a preview in the UI (required for message, broadcast)"),
+  request_id: import_v440.default.string().optional().describe("Request ID to respond to (required for shutdown_response, plan_approval_response)"),
+  approve: import_v440.default.boolean().optional().describe("Whether to approve the request (required for shutdown_response, plan_approval_response)")
+}).describe(`Send a message to a teammate or broadcast to all teammates in the current team/swarm.`);
 var description20 = `
-Example:
+Send messages to agent teammates and handle protocol requests/responses in a team.
+
+Message types:
+- "message": Send a direct message to a specific teammate (requires recipient)
+- "broadcast": Send a message to all teammates (use sparingly)
+- "shutdown_request": Request a teammate to shut down (requires recipient)
+- "shutdown_response": Respond to a shutdown request (requires request_id, approve)
+- "plan_approval_response": Approve or reject a teammate's plan (requires request_id, recipient, approve)
+
+Example - Direct message:
 ${$getNativeToolCallExampleString({
   toolName: toolName20,
   inputSchema: inputSchema20,
+  input: {
+    type: "message",
+    recipient: "researcher",
+    content: "Found the bug in the auth module",
+    summary: "Auth bug found"
+  },
+  endsAgentStep: endsAgentStep20
+})}
+
+Example - Broadcast:
+${$getNativeToolCallExampleString({
+  toolName: toolName20,
+  inputSchema: inputSchema20,
+  input: {
+    type: "broadcast",
+    content: "Blocking issue found, please pause work",
+    summary: "Critical blocking issue"
+  },
+  endsAgentStep: endsAgentStep20
+})}
+`.trim();
+var sendMessageParams = {
+  toolName: toolName20,
+  endsAgentStep: endsAgentStep20,
+  description: description20,
+  inputSchema: inputSchema20,
+  outputSchema: textToolResultSchema()
+};
+
+// ../common/src/tools/params/tool/set-messages.ts
+var import_v441 = __toESM(require("zod/v4"));
+var toolName21 = "set_messages";
+var endsAgentStep21 = true;
+var inputSchema21 = import_v441.default.object({
+  messages: import_v441.default.any()
+}).describe(`Set the conversation history to the provided messages.`);
+var description21 = `
+Example:
+${$getNativeToolCallExampleString({
+  toolName: toolName21,
+  inputSchema: inputSchema21,
   input: {
     messages: [
       {
@@ -19852,25 +19920,25 @@ ${$getNativeToolCallExampleString({
       }
     ]
   },
-  endsAgentStep: endsAgentStep20
+  endsAgentStep: endsAgentStep21
 })}
 `.trim();
 var setMessagesParams = {
-  toolName: toolName20,
-  endsAgentStep: endsAgentStep20,
-  description: description20,
-  inputSchema: inputSchema20,
+  toolName: toolName21,
+  endsAgentStep: endsAgentStep21,
+  description: description21,
+  inputSchema: inputSchema21,
   outputSchema: textToolResultSchema()
 };
 
 // ../common/src/tools/params/tool/set-output.ts
-var import_v441 = __toESM(require("zod/v4"));
-var toolName21 = "set_output";
-var endsAgentStep21 = false;
-var inputSchema21 = import_v441.default.looseObject({
-  data: import_v441.default.record(import_v441.default.string(), import_v441.default.any()).optional()
+var import_v442 = __toESM(require("zod/v4"));
+var toolName22 = "set_output";
+var endsAgentStep22 = false;
+var inputSchema22 = import_v442.default.looseObject({
+  data: import_v442.default.record(import_v442.default.string(), import_v442.default.any()).optional()
 }).describe("JSON object to set as the agent output. The shape of the parameters are specified dynamically further down in the conversation. This completely replaces any previous output. If the agent was spawned, this value will be passed back to its parent. If the agent has an outputSchema defined, the output will be validated against it.");
-var description21 = `
+var description22 = `
 Subagents must use this tool as it is the only way to report any findings. Nothing else you write will be visible to the user/parent agent.
 
 Note that the output schema is provided dynamically in a user prompt further down in the conversation. Be sure to follow what the latest output schema is when using this tool.
@@ -19878,41 +19946,41 @@ Note that the output schema is provided dynamically in a user prompt further dow
 Please set the output with all the information and analysis you want to pass on. If you just want to send a simple message, use an object with the key "message" and value of the message you want to send.
 Example:
 ${$getNativeToolCallExampleString({
-  toolName: toolName21,
-  inputSchema: inputSchema21,
+  toolName: toolName22,
+  inputSchema: inputSchema22,
   input: {
     message: "I found a bug in the code!"
   },
-  endsAgentStep: endsAgentStep21
+  endsAgentStep: endsAgentStep22
 })}
 `.trim();
 var setOutputParams = {
-  toolName: toolName21,
-  endsAgentStep: endsAgentStep21,
-  description: description21,
-  inputSchema: inputSchema21,
-  outputSchema: import_v441.default.tuple([
-    import_v441.default.object({
-      type: import_v441.default.literal("json"),
-      value: import_v441.default.object({
-        message: import_v441.default.string()
+  toolName: toolName22,
+  endsAgentStep: endsAgentStep22,
+  description: description22,
+  inputSchema: inputSchema22,
+  outputSchema: import_v442.default.tuple([
+    import_v442.default.object({
+      type: import_v442.default.literal("json"),
+      value: import_v442.default.object({
+        message: import_v442.default.string()
       })
     })
   ])
 };
 
 // ../common/src/tools/params/tool/skill.ts
-var import_v442 = __toESM(require("zod/v4"));
-var toolName22 = "skill";
-var endsAgentStep22 = true;
-var inputSchema22 = import_v442.default.object({
-  name: import_v442.default.string().min(1).describe("The name of the skill to load")
+var import_v443 = __toESM(require("zod/v4"));
+var toolName23 = "skill";
+var endsAgentStep23 = true;
+var inputSchema23 = import_v443.default.object({
+  name: import_v443.default.string().min(1).describe("The name of the skill to load")
 }).describe("Load a skill by name to get its full instructions. Skills provide reusable behaviors and instructions.");
-var outputValueSchema = import_v442.default.object({
-  name: import_v442.default.string(),
-  description: import_v442.default.string(),
-  content: import_v442.default.string(),
-  license: import_v442.default.string().optional()
+var outputValueSchema = import_v443.default.object({
+  name: import_v443.default.string(),
+  description: import_v443.default.string(),
+  content: import_v443.default.string(),
+  license: import_v443.default.string().optional()
 });
 var AVAILABLE_SKILLS_PLACEHOLDER = "{{AVAILABLE_SKILLS}}";
 var baseDescription = `Load a skill by name to get its full instructions. Skills provide reusable behaviors and domain-specific knowledge that you can use to complete tasks.
@@ -19921,32 +19989,32 @@ ${AVAILABLE_SKILLS_PLACEHOLDER}
 
 Example:
 ${$getNativeToolCallExampleString({
-  toolName: toolName22,
-  inputSchema: inputSchema22,
+  toolName: toolName23,
+  inputSchema: inputSchema23,
   input: {
     name: "git-release"
   },
-  endsAgentStep: endsAgentStep22
+  endsAgentStep: endsAgentStep23
 })}
 `;
 var skillParams = {
-  toolName: toolName22,
-  endsAgentStep: endsAgentStep22,
+  toolName: toolName23,
+  endsAgentStep: endsAgentStep23,
   description: baseDescription.trim(),
-  inputSchema: inputSchema22,
+  inputSchema: inputSchema23,
   outputSchema: jsonToolResultSchema(outputValueSchema)
 };
 
 // ../common/src/tools/params/tool/spawn-agent-inline.ts
-var import_v443 = __toESM(require("zod/v4"));
-var toolName23 = "spawn_agent_inline";
-var endsAgentStep23 = true;
-var inputSchema23 = import_v443.default.object({
-  agent_type: import_v443.default.string().describe("Agent to spawn"),
-  prompt: import_v443.default.string().optional().describe("Prompt to send to the agent"),
-  params: import_v443.default.record(import_v443.default.string(), import_v443.default.any()).optional().describe("Parameters object for the agent (if any)")
+var import_v444 = __toESM(require("zod/v4"));
+var toolName24 = "spawn_agent_inline";
+var endsAgentStep24 = true;
+var inputSchema24 = import_v444.default.object({
+  agent_type: import_v444.default.string().describe("Agent to spawn"),
+  prompt: import_v444.default.string().optional().describe("Prompt to send to the agent"),
+  params: import_v444.default.record(import_v444.default.string(), import_v444.default.any()).optional().describe("Parameters object for the agent (if any)")
 }).describe(`Spawn a single agent that runs within the current message history.`);
-var description22 = `
+var description23 = `
 Spawn a single agent that runs within the current message history. 
 The spawned agent sees all previous messages and any messages it adds 
 are preserved when control returns to you.
@@ -19960,39 +20028,41 @@ This is useful for:
 The agent will run until it calls end_turn, then control returns to you. There is no tool result for this tool.
 Example:
 ${$getNativeToolCallExampleString({
-  toolName: toolName23,
-  inputSchema: inputSchema23,
+  toolName: toolName24,
+  inputSchema: inputSchema24,
   input: {
     agent_type: "file-picker",
     prompt: "Find files related to authentication",
     params: { paths: ["src/auth.ts", "src/user.ts"] }
   },
-  endsAgentStep: endsAgentStep23
+  endsAgentStep: endsAgentStep24
 })}
 `.trim();
 var spawnAgentInlineParams = {
-  toolName: toolName23,
-  endsAgentStep: endsAgentStep23,
-  description: description22,
-  inputSchema: inputSchema23,
+  toolName: toolName24,
+  endsAgentStep: endsAgentStep24,
+  description: description23,
+  inputSchema: inputSchema24,
   outputSchema: textToolResultSchema()
 };
 
 // ../common/src/tools/params/tool/spawn-agents.ts
-var import_v444 = __toESM(require("zod/v4"));
-var spawnAgentsOutputSchema = import_v444.default.object({
-  agentType: import_v444.default.string()
+var import_v445 = __toESM(require("zod/v4"));
+var spawnAgentsOutputSchema = import_v445.default.object({
+  agentType: import_v445.default.string()
 }).and(jsonObjectSchema).array();
-var toolName24 = "spawn_agents";
-var endsAgentStep24 = true;
-var inputSchema24 = import_v444.default.object({
-  agents: import_v444.default.object({
-    agent_type: import_v444.default.string().describe("Agent to spawn"),
-    prompt: import_v444.default.string().optional().describe("Prompt to send to the agent"),
-    params: import_v444.default.record(import_v444.default.string(), import_v444.default.any()).optional().describe("Parameters object for the agent (if any)")
+var toolName25 = "spawn_agents";
+var endsAgentStep25 = true;
+var inputSchema25 = import_v445.default.object({
+  agents: import_v445.default.object({
+    agent_type: import_v445.default.string().describe("Agent to spawn"),
+    prompt: import_v445.default.string().optional().describe("Prompt to send to the agent"),
+    params: import_v445.default.record(import_v445.default.string(), import_v445.default.any()).optional().describe("Parameters object for the agent (if any)"),
+    team_name: import_v445.default.string().optional().describe("Optional team name to register this agent as a member of. The team must already exist (created via team_create)."),
+    team_role: import_v445.default.string().optional().describe('Optional role for the agent within the team (e.g. "senior-engineer", "researcher"). Defaults to "mid-level-engineer".')
   }).array()
 }).describe(`Spawn multiple agents and send a prompt and/or parameters to each of them. These agents will run in parallel. Note that that means they will run independently. If you need to run agents sequentially, use spawn_agents with one agent at a time instead.`);
-var description23 = `
+var description24 = `
 Use this tool to spawn agents to help you complete the user request. Each agent has specific requirements for prompt and params based on their tools schema.
 
 The prompt field is a simple string, while params is a JSON object that gets validated against the agent's schema.
@@ -20007,8 +20077,8 @@ You can call agents either as direct tool calls (e.g., \`example-agent\`) or use
 
 Example:
 ${$getNativeToolCallExampleString({
-  toolName: toolName24,
-  inputSchema: inputSchema24,
+  toolName: toolName25,
+  inputSchema: inputSchema25,
   input: {
     agents: [
       {
@@ -20026,32 +20096,32 @@ ${$getNativeToolCallExampleString({
       }
     ]
   },
-  endsAgentStep: endsAgentStep24
+  endsAgentStep: endsAgentStep25
 })}
 `.trim();
 var spawnAgentsParams = {
-  toolName: toolName24,
-  endsAgentStep: endsAgentStep24,
-  description: description23,
-  inputSchema: inputSchema24,
+  toolName: toolName25,
+  endsAgentStep: endsAgentStep25,
+  description: description24,
+  inputSchema: inputSchema25,
   outputSchema: jsonToolResultSchema(spawnAgentsOutputSchema)
 };
 
 // ../common/src/tools/params/tool/suggest-followups.ts
-var import_v445 = __toESM(require("zod/v4"));
-var toolName25 = "suggest_followups";
-var endsAgentStep25 = false;
-var followupSchema = import_v445.default.object({
-  prompt: import_v445.default.string().describe("The full prompt text to send as a user message when clicked"),
-  label: import_v445.default.string().optional().describe("Short display label for the card (defaults to truncated prompt if not provided)")
+var import_v446 = __toESM(require("zod/v4"));
+var toolName26 = "suggest_followups";
+var endsAgentStep26 = false;
+var followupSchema = import_v446.default.object({
+  prompt: import_v446.default.string().describe("The full prompt text to send as a user message when clicked"),
+  label: import_v446.default.string().optional().describe("Short display label for the card (defaults to truncated prompt if not provided)")
 });
-var inputSchema25 = import_v445.default.object({
-  followups: import_v445.default.array(followupSchema).min(1, "Must provide at least one followup").describe("List of suggested followup prompts the user can click to send")
+var inputSchema26 = import_v446.default.object({
+  followups: import_v446.default.array(followupSchema).min(1, "Must provide at least one followup").describe("List of suggested followup prompts the user can click to send")
 }).describe(`Suggest clickable followup prompts to the user. Each followup becomes a card the user can click to send that prompt.`);
-var outputSchema2 = import_v445.default.object({
-  message: import_v445.default.string()
+var outputSchema2 = import_v446.default.object({
+  message: import_v446.default.string()
 });
-var description24 = `
+var description25 = `
 Suggest clickable followup prompts to the user. When the user clicks a suggestion, it sends that prompt as a new user message.
 
 Use this tool after completing a task to suggest what the user might want to do next. Good suggestions include:
@@ -20070,8 +20140,8 @@ Try to make different suggestions than you did in past steps. That's because use
 Aim for around 3 suggestions. The suggestions persist and remain clickable, with clicked ones visually updated to show they were used.
 
 ${$getNativeToolCallExampleString({
-  toolName: toolName25,
-  inputSchema: inputSchema25,
+  toolName: toolName26,
+  inputSchema: inputSchema26,
   input: {
     followups: [
       {
@@ -20088,28 +20158,28 @@ ${$getNativeToolCallExampleString({
       }
     ]
   },
-  endsAgentStep: endsAgentStep25
+  endsAgentStep: endsAgentStep26
 })}
 `.trim();
 var suggestFollowupsParams = {
-  toolName: toolName25,
-  endsAgentStep: endsAgentStep25,
-  description: description24,
-  inputSchema: inputSchema25,
+  toolName: toolName26,
+  endsAgentStep: endsAgentStep26,
+  description: description25,
+  inputSchema: inputSchema26,
   outputSchema: jsonToolResultSchema(outputSchema2)
 };
 
 // ../common/src/tools/params/tool/task-completed.ts
-var import_v446 = __toESM(require("zod/v4"));
-var toolName26 = "task_completed";
-var endsAgentStep26 = true;
-var inputSchema26 = import_v446.default.object({}).describe(`Signal that the task is complete. Use this tool when:
+var import_v447 = __toESM(require("zod/v4"));
+var toolName27 = "task_completed";
+var endsAgentStep27 = true;
+var inputSchema27 = import_v447.default.object({}).describe(`Signal that the task is complete. Use this tool when:
 - The user's request is completely fulfilled
 - You need clarification from the user before continuing
 - You are stuck or need help from the user to continue
 
 This tool explicitly marks the end of your work on the current task.`);
-var description25 = `
+var description26 = `
 Use this tool to signal that the task is complete.
 
 - When to use:
@@ -20129,36 +20199,248 @@ Use this tool to signal that the task is complete.
 
 All changes have been implemented and tested successfully!
 
-${$getNativeToolCallExampleString({ toolName: toolName26, inputSchema: inputSchema26, input: {}, endsAgentStep: endsAgentStep26 })}
+${$getNativeToolCallExampleString({ toolName: toolName27, inputSchema: inputSchema27, input: {}, endsAgentStep: endsAgentStep27 })}
 
 OR
 
 I need more information to proceed. Which database schema should I use for this migration?
 
-${$getNativeToolCallExampleString({ toolName: toolName26, inputSchema: inputSchema26, input: {}, endsAgentStep: endsAgentStep26 })}
+${$getNativeToolCallExampleString({ toolName: toolName27, inputSchema: inputSchema27, input: {}, endsAgentStep: endsAgentStep27 })}
 
 OR
 
 I can't get the tests to pass after several different attempts. I need help from the user to proceed.
 
-${$getNativeToolCallExampleString({ toolName: toolName26, inputSchema: inputSchema26, input: {}, endsAgentStep: endsAgentStep26 })}
+${$getNativeToolCallExampleString({ toolName: toolName27, inputSchema: inputSchema27, input: {}, endsAgentStep: endsAgentStep27 })}
 `.trim();
 var taskCompletedParams = {
-  toolName: toolName26,
-  endsAgentStep: endsAgentStep26,
-  description: description25,
-  inputSchema: inputSchema26,
+  toolName: toolName27,
+  endsAgentStep: endsAgentStep27,
+  description: description26,
+  inputSchema: inputSchema27,
+  outputSchema: textToolResultSchema()
+};
+
+// ../common/src/tools/params/tool/task-create.ts
+var import_v448 = __toESM(require("zod/v4"));
+var toolName28 = "task_create";
+var endsAgentStep28 = false;
+var inputSchema28 = import_v448.default.object({
+  subject: import_v448.default.string().describe("A brief, actionable title for the task"),
+  description: import_v448.default.string().describe("A detailed description of what needs to be done"),
+  activeForm: import_v448.default.string().optional().describe('Present continuous form shown in spinner when in_progress (e.g., "Running tests")'),
+  metadata: import_v448.default.record(import_v448.default.string(), import_v448.default.unknown()).optional().describe("Arbitrary metadata to attach to the task")
+}).describe(`Create a new task in the team task list for tracking work items.`);
+var description27 = `
+Create a structured task for tracking work in the current team/swarm.
+
+- When to use: When a task requires multiple steps or needs to be tracked and coordinated across agents.
+- The subject should be imperative (e.g., "Fix authentication bug").
+- The activeForm should be present continuous (e.g., "Fixing authentication bug").
+- New tasks are created with status "pending".
+
+Example:
+${$getNativeToolCallExampleString({
+  toolName: toolName28,
+  inputSchema: inputSchema28,
+  input: {
+    subject: "Fix authentication bug in login flow",
+    description: "The login endpoint returns 500 when password contains special characters",
+    activeForm: "Fixing authentication bug"
+  },
+  endsAgentStep: endsAgentStep28
+})}
+`.trim();
+var taskCreateParams = {
+  toolName: toolName28,
+  endsAgentStep: endsAgentStep28,
+  description: description27,
+  inputSchema: inputSchema28,
+  outputSchema: textToolResultSchema()
+};
+
+// ../common/src/tools/params/tool/task-get.ts
+var import_v449 = __toESM(require("zod/v4"));
+var toolName29 = "task_get";
+var endsAgentStep29 = false;
+var inputSchema29 = import_v449.default.object({
+  taskId: import_v449.default.string().describe("The ID of the task to retrieve")
+}).describe(`Retrieve a task by its ID from the team task list.`);
+var description28 = `
+Retrieve the full details of a task by its ID.
+
+- When to use: When you need the full description and context before starting work on a task.
+- Returns: subject, description, status, blocks, blockedBy, and other task details.
+
+Example:
+${$getNativeToolCallExampleString({
+  toolName: toolName29,
+  inputSchema: inputSchema29,
+  input: {
+    taskId: "1"
+  },
+  endsAgentStep: endsAgentStep29
+})}
+`.trim();
+var taskGetParams = {
+  toolName: toolName29,
+  endsAgentStep: endsAgentStep29,
+  description: description28,
+  inputSchema: inputSchema29,
+  outputSchema: textToolResultSchema()
+};
+
+// ../common/src/tools/params/tool/task-list.ts
+var import_v450 = __toESM(require("zod/v4"));
+var toolName30 = "task_list";
+var endsAgentStep30 = false;
+var inputSchema30 = import_v450.default.object({}).describe(`List all tasks in the team task list.`);
+var description29 = `
+List all tasks in the current team's task list.
+
+- When to use: To see available tasks, check progress, or find unblocked work to claim.
+- Returns a summary of each task: id, subject, status, owner, blockedBy.
+
+Example:
+${$getNativeToolCallExampleString({
+  toolName: toolName30,
+  inputSchema: inputSchema30,
+  input: {},
+  endsAgentStep: endsAgentStep30
+})}
+`.trim();
+var taskListParams = {
+  toolName: toolName30,
+  endsAgentStep: endsAgentStep30,
+  description: description29,
+  inputSchema: inputSchema30,
+  outputSchema: textToolResultSchema()
+};
+
+// ../common/src/tools/params/tool/task-update.ts
+var import_v451 = __toESM(require("zod/v4"));
+var toolName31 = "task_update";
+var endsAgentStep31 = false;
+var inputSchema31 = import_v451.default.object({
+  taskId: import_v451.default.string().describe("The ID of the task to update"),
+  status: import_v451.default.string().optional().describe('New status for the task: "pending", "in_progress", "completed", or "deleted"'),
+  subject: import_v451.default.string().optional().describe("New subject for the task"),
+  description: import_v451.default.string().optional().describe("New description for the task"),
+  activeForm: import_v451.default.string().optional().describe('Present continuous form shown in spinner when in_progress (e.g., "Running tests")'),
+  owner: import_v451.default.string().optional().describe("New owner for the task (agent name)"),
+  addBlocks: import_v451.default.array(import_v451.default.string()).optional().describe("Task IDs that this task blocks"),
+  addBlockedBy: import_v451.default.array(import_v451.default.string()).optional().describe("Task IDs that block this task"),
+  metadata: import_v451.default.record(import_v451.default.string(), import_v451.default.unknown()).optional().describe("Metadata keys to merge into the task. Set a key to null to delete it.")
+}).describe(`Update an existing task in the team task list.`);
+var description30 = `
+Update a task's status, details, or dependencies.
+
+- When to use: To mark tasks as in_progress, completed, or to update task details.
+- Status workflow: pending -> in_progress -> completed. Use "deleted" to remove a task.
+- Only mark a task as completed when you have fully accomplished it.
+
+Example - Mark as in progress:
+${$getNativeToolCallExampleString({
+  toolName: toolName31,
+  inputSchema: inputSchema31,
+  input: {
+    taskId: "1",
+    status: "in_progress"
+  },
+  endsAgentStep: endsAgentStep31
+})}
+
+Example - Mark as completed:
+${$getNativeToolCallExampleString({
+  toolName: toolName31,
+  inputSchema: inputSchema31,
+  input: {
+    taskId: "1",
+    status: "completed"
+  },
+  endsAgentStep: endsAgentStep31
+})}
+`.trim();
+var taskUpdateParams = {
+  toolName: toolName31,
+  endsAgentStep: endsAgentStep31,
+  description: description30,
+  inputSchema: inputSchema31,
+  outputSchema: textToolResultSchema()
+};
+
+// ../common/src/tools/params/tool/team-create.ts
+var import_v452 = __toESM(require("zod/v4"));
+var toolName32 = "team_create";
+var endsAgentStep32 = false;
+var inputSchema32 = import_v452.default.object({
+  team_name: import_v452.default.string().describe("Name of the team to create"),
+  description: import_v452.default.string().optional().describe("Optional description of the team purpose"),
+  agent_type: import_v452.default.string().optional().describe("Optional agent type template to use for the team")
+}).describe(`Create a new team/swarm with the given name and optional configuration.`);
+var description31 = `
+Create a new team for collaborative multi-agent work.
+
+- When to use: When you need to create a new team/swarm to coordinate multiple agents on a task.
+- Before calling: Ensure the team name is unique and descriptive.
+- Effect: Creates a new team context that agents can be spawned into.
+
+Example:
+${$getNativeToolCallExampleString({
+  toolName: toolName32,
+  inputSchema: inputSchema32,
+  input: {
+    team_name: "backend-refactor",
+    description: "Team for refactoring the backend API layer",
+    agent_type: "coordinator"
+  },
+  endsAgentStep: endsAgentStep32
+})}
+`.trim();
+var teamCreateParams = {
+  toolName: toolName32,
+  endsAgentStep: endsAgentStep32,
+  description: description31,
+  inputSchema: inputSchema32,
+  outputSchema: textToolResultSchema()
+};
+
+// ../common/src/tools/params/tool/team-delete.ts
+var import_v453 = __toESM(require("zod/v4"));
+var toolName33 = "team_delete";
+var endsAgentStep33 = false;
+var inputSchema33 = import_v453.default.object({}).describe(`Delete the current team/swarm. Uses the current team context to determine which team to delete.`);
+var description32 = `
+Delete the current team and clean up all associated resources.
+
+- When to use: When a team's work is complete and it should be disbanded.
+- Before calling: Ensure all agents in the team have completed their work.
+- Effect: Removes the team context and all associated state.
+
+Example:
+${$getNativeToolCallExampleString({
+  toolName: toolName33,
+  inputSchema: inputSchema33,
+  input: {},
+  endsAgentStep: endsAgentStep33
+})}
+`.trim();
+var teamDeleteParams = {
+  toolName: toolName33,
+  endsAgentStep: endsAgentStep33,
+  description: description32,
+  inputSchema: inputSchema33,
   outputSchema: textToolResultSchema()
 };
 
 // ../common/src/tools/params/tool/think-deeply.ts
-var import_v447 = __toESM(require("zod/v4"));
-var toolName27 = "think_deeply";
-var endsAgentStep27 = false;
-var inputSchema27 = import_v447.default.object({
-  thought: import_v447.default.string().min(1, "Thought cannot be empty").describe(`Detailed step-by-step analysis. Initially keep each step concise (max ~5-7 words per step).`)
+var import_v454 = __toESM(require("zod/v4"));
+var toolName34 = "think_deeply";
+var endsAgentStep34 = false;
+var inputSchema34 = import_v454.default.object({
+  thought: import_v454.default.string().min(1, "Thought cannot be empty").describe(`Detailed step-by-step analysis. Initially keep each step concise (max ~5-7 words per step).`)
 }).describe(`Deeply consider complex tasks by brainstorming approaches and tradeoffs step-by-step.`);
-var description26 = `
+var description33 = `
 Use when user request:
 - Explicitly asks for deep planning.
 - Requires multi-file changes or complex logic.
@@ -20170,8 +20452,8 @@ This tool does not generate a tool result.
 
 Example:
 ${$getNativeToolCallExampleString({
-  toolName: toolName27,
-  inputSchema: inputSchema27,
+  toolName: toolName34,
+  inputSchema: inputSchema34,
   input: {
     thought: [
       "1. Check current user authentication",
@@ -20181,94 +20463,94 @@ ${$getNativeToolCallExampleString({
     ].join(`
 `)
   },
-  endsAgentStep: endsAgentStep27
+  endsAgentStep: endsAgentStep34
 })}
 `.trim();
 var thinkDeeplyParams = {
-  toolName: toolName27,
-  endsAgentStep: endsAgentStep27,
-  description: description26,
-  inputSchema: inputSchema27,
+  toolName: toolName34,
+  endsAgentStep: endsAgentStep34,
+  description: description33,
+  inputSchema: inputSchema34,
   outputSchema: textToolResultSchema()
 };
 
 // ../common/src/tools/params/tool/update-subgoal.ts
-var import_v448 = __toESM(require("zod/v4"));
-var toolName28 = "update_subgoal";
-var endsAgentStep28 = false;
-var inputSchema28 = import_v448.default.object({
-  id: import_v448.default.string().min(1, "Id cannot be empty").describe(`The id of the subgoal to update.`),
-  status: import_v448.default.enum(["NOT_STARTED", "IN_PROGRESS", "COMPLETE", "ABORTED"]).optional().describe(`Change the status of the subgoal.`),
-  plan: import_v448.default.string().optional().describe(`Change the plan for the subgoal.`),
-  log: import_v448.default.string().optional().describe(`Add a log message to the subgoal. This will create a new log entry and append it to the existing logs. Use this to record your progress and any new information you learned as you go.`)
+var import_v455 = __toESM(require("zod/v4"));
+var toolName35 = "update_subgoal";
+var endsAgentStep35 = false;
+var inputSchema35 = import_v455.default.object({
+  id: import_v455.default.string().min(1, "Id cannot be empty").describe(`The id of the subgoal to update.`),
+  status: import_v455.default.enum(["NOT_STARTED", "IN_PROGRESS", "COMPLETE", "ABORTED"]).optional().describe(`Change the status of the subgoal.`),
+  plan: import_v455.default.string().optional().describe(`Change the plan for the subgoal.`),
+  log: import_v455.default.string().optional().describe(`Add a log message to the subgoal. This will create a new log entry and append it to the existing logs. Use this to record your progress and any new information you learned as you go.`)
 }).describe(`Update a subgoal in the context given the id, and optionally the status or plan, or a new log to append. Feel free to update any combination of the status, plan, or log in one invocation.`);
-var description27 = `
+var description34 = `
 Examples:
 
 Usage 1 (update status):
 ${$getNativeToolCallExampleString({
-  toolName: toolName28,
-  inputSchema: inputSchema28,
+  toolName: toolName35,
+  inputSchema: inputSchema35,
   input: {
     id: "1",
     status: "COMPLETE"
   },
-  endsAgentStep: endsAgentStep28
+  endsAgentStep: endsAgentStep35
 })}
 
 Usage 2 (update plan):
 ${$getNativeToolCallExampleString({
-  toolName: toolName28,
-  inputSchema: inputSchema28,
+  toolName: toolName35,
+  inputSchema: inputSchema35,
   input: {
     id: "3",
     plan: "Create file for endpoint in the api. Register it in the router."
   },
-  endsAgentStep: endsAgentStep28
+  endsAgentStep: endsAgentStep35
 })}
 
 Usage 3 (add log):
 ${$getNativeToolCallExampleString({
-  toolName: toolName28,
-  inputSchema: inputSchema28,
+  toolName: toolName35,
+  inputSchema: inputSchema35,
   input: {
     id: "1",
     log: "Found the error in the tests. Culprit: foo function."
   },
-  endsAgentStep: endsAgentStep28
+  endsAgentStep: endsAgentStep35
 })}
 
 Usage 4 (update status and add log):
 ${$getNativeToolCallExampleString({
-  toolName: toolName28,
-  inputSchema: inputSchema28,
+  toolName: toolName35,
+  inputSchema: inputSchema35,
   input: {
     id: "1",
     status: "COMPLETE",
     log: "Reran the tests (passed)"
   },
-  endsAgentStep: endsAgentStep28
+  endsAgentStep: endsAgentStep35
 })}
 `.trim();
 var updateSubgoalParams = {
-  toolName: toolName28,
-  endsAgentStep: endsAgentStep28,
-  description: description27,
-  inputSchema: inputSchema28,
-  outputSchema: jsonToolResultSchema(import_v448.default.object({
-    message: import_v448.default.string()
+  toolName: toolName35,
+  endsAgentStep: endsAgentStep35,
+  description: description34,
+  inputSchema: inputSchema35,
+  outputSchema: jsonToolResultSchema(import_v455.default.object({
+    message: import_v455.default.string()
   }))
 };
 
 // ../common/src/tools/params/tool/web-search.ts
-var import_v449 = __toESM(require("zod/v4"));
-var toolName29 = "web_search";
-var endsAgentStep29 = true;
-var inputSchema29 = import_v449.default.object({
-  query: import_v449.default.string().min(1, "Query cannot be empty").describe(`The search query to find relevant web content`),
-  depth: import_v449.default.enum(["standard", "deep"]).optional().default("standard").describe(`Search depth - 'standard' for quick results, 'deep' for more comprehensive search. Default is 'standard'.`)
+var import_v456 = __toESM(require("zod/v4"));
+var toolName36 = "web_search";
+var endsAgentStep36 = true;
+var inputSchema36 = import_v456.default.object({
+  query: import_v456.default.string().min(1, "Query cannot be empty").describe(`The search query to find relevant web content`),
+  depth: import_v456.default.enum(["standard", "deep"]).optional().default("standard").describe(`Search depth - 'standard' for quick results, 'deep' for more comprehensive search. Default is 'standard'.`)
 }).describe(`Search the web for current information using Linkup API.`);
-var description28 = `
+var description35 = `
 Purpose: Search the web for current, up-to-date information on any topic. This tool uses Linkup's web search API to find relevant content from across the internet.
 
 Use cases:
@@ -20282,50 +20564,50 @@ The tool will return search results with titles, URLs, and content snippets.
 
 Example:
 ${$getNativeToolCallExampleString({
-  toolName: toolName29,
-  inputSchema: inputSchema29,
+  toolName: toolName36,
+  inputSchema: inputSchema36,
   input: {
     query: "Next.js 15 new features",
     depth: "standard"
   },
-  endsAgentStep: endsAgentStep29
+  endsAgentStep: endsAgentStep36
 })}
 
 ${$getNativeToolCallExampleString({
-  toolName: toolName29,
-  inputSchema: inputSchema29,
+  toolName: toolName36,
+  inputSchema: inputSchema36,
   input: {
     query: "React Server Components tutorial",
     depth: "deep"
   },
-  endsAgentStep: endsAgentStep29
+  endsAgentStep: endsAgentStep36
 })}
 `.trim();
 var webSearchParams = {
-  toolName: toolName29,
-  endsAgentStep: endsAgentStep29,
-  description: description28,
-  inputSchema: inputSchema29,
-  outputSchema: jsonToolResultSchema(import_v449.default.union([
-    import_v449.default.object({
-      result: import_v449.default.string()
+  toolName: toolName36,
+  endsAgentStep: endsAgentStep36,
+  description: description35,
+  inputSchema: inputSchema36,
+  outputSchema: jsonToolResultSchema(import_v456.default.union([
+    import_v456.default.object({
+      result: import_v456.default.string()
     }),
-    import_v449.default.object({
-      errorMessage: import_v449.default.string()
+    import_v456.default.object({
+      errorMessage: import_v456.default.string()
     })
   ]))
 };
 
 // ../common/src/tools/params/tool/write-file.ts
-var import_v450 = __toESM(require("zod/v4"));
-var toolName30 = "write_file";
-var endsAgentStep30 = false;
-var inputSchema30 = import_v450.default.object({
-  path: import_v450.default.string().min(1, "Path cannot be empty").describe(`Path to the file relative to the **project root**`),
-  instructions: import_v450.default.string().describe("What the change is intended to do in only one sentence."),
-  content: import_v450.default.string().describe(`Edit snippet to apply to the file.`)
+var import_v457 = __toESM(require("zod/v4"));
+var toolName37 = "write_file";
+var endsAgentStep37 = false;
+var inputSchema37 = import_v457.default.object({
+  path: import_v457.default.string().min(1, "Path cannot be empty").describe(`Path to the file relative to the **project root**`),
+  instructions: import_v457.default.string().describe("What the change is intended to do in only one sentence."),
+  content: import_v457.default.string().describe(`Edit snippet to apply to the file.`)
 }).describe(`Create or edit a file with the given content.`);
-var description29 = `
+var description36 = `
 Create or replace a file with the given content.
 
 ####  Edit Snippet
@@ -20346,20 +20628,20 @@ Examples:
 
 Example 1 - Simple file creation:
 ${$getNativeToolCallExampleString({
-  toolName: toolName30,
-  inputSchema: inputSchema30,
+  toolName: toolName37,
+  inputSchema: inputSchema37,
   input: {
     path: "new-file.ts",
     instructions: "Prints Hello, world",
     content: 'console.log("Hello, world!");'
   },
-  endsAgentStep: endsAgentStep30
+  endsAgentStep: endsAgentStep37
 })}
 
 Example 2 - Editing with placeholder comments:
 ${$getNativeToolCallExampleString({
-  toolName: toolName30,
-  inputSchema: inputSchema30,
+  toolName: toolName37,
+  inputSchema: inputSchema37,
   input: {
     path: "foo.ts",
     instructions: "Update foo and remove console.log",
@@ -20379,28 +20661,28 @@ function foo() {
 
 // ... existing code ...`
   },
-  endsAgentStep: endsAgentStep30
+  endsAgentStep: endsAgentStep37
 })}
 `.trim();
 var writeFileParams = {
-  toolName: toolName30,
-  endsAgentStep: endsAgentStep30,
-  description: description29,
-  inputSchema: inputSchema30,
+  toolName: toolName37,
+  endsAgentStep: endsAgentStep37,
+  description: description36,
+  inputSchema: inputSchema37,
   outputSchema: jsonToolResultSchema(updateFileResultSchema)
 };
 
 // ../common/src/tools/params/tool/write-todos.ts
-var import_v451 = __toESM(require("zod/v4"));
-var toolName31 = "write_todos";
-var endsAgentStep31 = false;
-var inputSchema31 = import_v451.default.object({
-  todos: import_v451.default.array(import_v451.default.object({
-    task: import_v451.default.string().describe("Description of the task"),
-    completed: import_v451.default.boolean().describe("Whether the task is completed")
+var import_v458 = __toESM(require("zod/v4"));
+var toolName38 = "write_todos";
+var endsAgentStep38 = false;
+var inputSchema38 = import_v458.default.object({
+  todos: import_v458.default.array(import_v458.default.object({
+    task: import_v458.default.string().describe("Description of the task"),
+    completed: import_v458.default.boolean().describe("Whether the task is completed")
   })).describe("List of todos with their completion status. Add ALL of the applicable tasks to the list, so you don't forget to do anything. Try to order the todos the same way you will complete them. Do not mark todos as completed if you have not completed them yet!")
 }).describe("Write a todo list to track tasks for multi-step implementations. Use this frequently to maintain an updated step-by-step plan.");
-var description30 = `
+var description37 = `
 Use this tool to track your objectives through an ordered step-by-step plan. Call this tool after you have gathered context on the user's request to plan out the implementation steps for the user's request.
 
 After completing each todo step, call this tool again to update the list and mark that task as completed. Note that each time you call this tool, rewrite ALL todos with their current status.
@@ -20409,8 +20691,8 @@ Use this tool frequently as you work through tasks to update the list of todos w
 
 Example:
 ${$getNativeToolCallExampleString({
-  toolName: toolName31,
-  inputSchema: inputSchema31,
+  toolName: toolName38,
+  inputSchema: inputSchema38,
   input: {
     todos: [
       { task: "Create new implementation in foo.ts", completed: true },
@@ -20422,19 +20704,19 @@ ${$getNativeToolCallExampleString({
       }
     ]
   },
-  endsAgentStep: endsAgentStep31
+  endsAgentStep: endsAgentStep38
 })}
 `.trim();
 var writeTodosParams = {
-  toolName: toolName31,
-  endsAgentStep: endsAgentStep31,
-  description: description30,
-  inputSchema: inputSchema31,
-  outputSchema: import_v451.default.tuple([
-    import_v451.default.object({
-      type: import_v451.default.literal("json"),
-      value: import_v451.default.object({
-        message: import_v451.default.string()
+  toolName: toolName38,
+  endsAgentStep: endsAgentStep38,
+  description: description37,
+  inputSchema: inputSchema38,
+  outputSchema: import_v458.default.tuple([
+    import_v458.default.object({
+      type: import_v458.default.literal("json"),
+      value: import_v458.default.object({
+        message: import_v458.default.string()
       })
     })
   ])
@@ -20460,6 +20742,7 @@ var toolParams = {
   read_subtree: readSubtreeParams,
   run_file_change_hooks: runFileChangeHooksParams,
   run_terminal_command: runTerminalCommandParams,
+  send_message: sendMessageParams,
   set_messages: setMessagesParams,
   set_output: setOutputParams,
   skill: skillParams,
@@ -20468,51 +20751,57 @@ var toolParams = {
   str_replace: strReplaceParams,
   suggest_followups: suggestFollowupsParams,
   task_completed: taskCompletedParams,
+  task_create: taskCreateParams,
+  task_get: taskGetParams,
+  task_list: taskListParams,
+  task_update: taskUpdateParams,
+  team_create: teamCreateParams,
+  team_delete: teamDeleteParams,
   think_deeply: thinkDeeplyParams,
   update_subgoal: updateSubgoalParams,
   web_search: webSearchParams,
   write_file: writeFileParams,
   write_todos: writeTodosParams
 };
-var clientToolCallSchema = import_v452.default.discriminatedUnion("toolName", [
-  import_v452.default.object({
-    toolName: import_v452.default.literal("ask_user"),
+var clientToolCallSchema = import_v459.default.discriminatedUnion("toolName", [
+  import_v459.default.object({
+    toolName: import_v459.default.literal("ask_user"),
     input: toolParams.ask_user.inputSchema
   }),
-  import_v452.default.object({
-    toolName: import_v452.default.literal("browser_logs"),
+  import_v459.default.object({
+    toolName: import_v459.default.literal("browser_logs"),
     input: toolParams.browser_logs.inputSchema
   }),
-  import_v452.default.object({
-    toolName: import_v452.default.literal("code_search"),
+  import_v459.default.object({
+    toolName: import_v459.default.literal("code_search"),
     input: toolParams.code_search.inputSchema
   }),
-  import_v452.default.object({
-    toolName: import_v452.default.literal("create_plan"),
+  import_v459.default.object({
+    toolName: import_v459.default.literal("create_plan"),
     input: FileChangeSchema
   }),
-  import_v452.default.object({
-    toolName: import_v452.default.literal("glob"),
+  import_v459.default.object({
+    toolName: import_v459.default.literal("glob"),
     input: toolParams.glob.inputSchema
   }),
-  import_v452.default.object({
-    toolName: import_v452.default.literal("list_directory"),
+  import_v459.default.object({
+    toolName: import_v459.default.literal("list_directory"),
     input: toolParams.list_directory.inputSchema
   }),
-  import_v452.default.object({
-    toolName: import_v452.default.literal("run_file_change_hooks"),
+  import_v459.default.object({
+    toolName: import_v459.default.literal("run_file_change_hooks"),
     input: toolParams.run_file_change_hooks.inputSchema
   }),
-  import_v452.default.object({
-    toolName: import_v452.default.literal("run_terminal_command"),
-    input: toolParams.run_terminal_command.inputSchema.and(import_v452.default.object({ mode: import_v452.default.enum(["assistant", "user"]) }))
+  import_v459.default.object({
+    toolName: import_v459.default.literal("run_terminal_command"),
+    input: toolParams.run_terminal_command.inputSchema.and(import_v459.default.object({ mode: import_v459.default.enum(["assistant", "user"]) }))
   }),
-  import_v452.default.object({
-    toolName: import_v452.default.literal("str_replace"),
+  import_v459.default.object({
+    toolName: import_v459.default.literal("str_replace"),
     input: FileChangeSchema
   }),
-  import_v452.default.object({
-    toolName: import_v452.default.literal("write_file"),
+  import_v459.default.object({
+    toolName: import_v459.default.literal("write_file"),
     input: FileChangeSchema
   })
 ]);
@@ -20741,13 +21030,13 @@ var escapeString = (str) => {
 var import_lodash13 = __toESM(require_lodash());
 
 // ../common/src/util/zod-schema.ts
-var import_v453 = __toESM(require("zod/v4"));
+var import_v460 = __toESM(require("zod/v4"));
 function schemaToJsonStr(schema, options) {
   if (!schema)
     return "None";
   try {
-    if (schema instanceof import_v453.default.ZodType) {
-      const jsonSchema = import_v453.default.toJSONSchema(schema, options);
+    if (schema instanceof import_v460.default.ZodType) {
+      const jsonSchema = import_v460.default.toJSONSchema(schema, options);
       delete jsonSchema["$schema"];
       return JSON.stringify(jsonSchema, null, 2);
     }
@@ -20758,27 +21047,27 @@ function schemaToJsonStr(schema, options) {
 }
 
 // ../packages/agent-runtime/src/templates/prompts.ts
-var import_v456 = require("zod/v4");
+var import_v463 = require("zod/v4");
 
 // ../common/src/types/dynamic-agent-template.ts
-var import_v455 = require("zod/v4");
+var import_v462 = require("zod/v4");
 init_old_constants();
 
 // ../common/src/types/mcp.ts
-var import_v454 = require("zod/v4");
-var mcpConfigStdioSchema = import_v454.z.strictObject({
-  type: import_v454.z.literal("stdio").default("stdio"),
-  command: import_v454.z.string(),
-  args: import_v454.z.string().array().default(() => []),
-  env: import_v454.z.record(import_v454.z.string(), import_v454.z.string()).default(() => ({}))
+var import_v461 = require("zod/v4");
+var mcpConfigStdioSchema = import_v461.z.strictObject({
+  type: import_v461.z.literal("stdio").default("stdio"),
+  command: import_v461.z.string(),
+  args: import_v461.z.string().array().default(() => []),
+  env: import_v461.z.record(import_v461.z.string(), import_v461.z.string()).default(() => ({}))
 });
-var mcpConfigRemoteSchema = import_v454.z.strictObject({
-  type: import_v454.z.enum(["http", "sse"]).default("http"),
-  url: import_v454.z.string(),
-  params: import_v454.z.record(import_v454.z.string(), import_v454.z.string()).default(() => ({})),
-  headers: import_v454.z.record(import_v454.z.string(), import_v454.z.string()).default(() => ({}))
+var mcpConfigRemoteSchema = import_v461.z.strictObject({
+  type: import_v461.z.enum(["http", "sse"]).default("http"),
+  url: import_v461.z.string(),
+  params: import_v461.z.record(import_v461.z.string(), import_v461.z.string()).default(() => ({})),
+  headers: import_v461.z.record(import_v461.z.string(), import_v461.z.string()).default(() => ({}))
 });
-var mcpConfigSchema = import_v454.z.union([
+var mcpConfigSchema = import_v461.z.union([
   mcpConfigRemoteSchema,
   mcpConfigStdioSchema
 ]);
@@ -20788,8 +21077,8 @@ var filteredModels = Object.values(models).filter((model) => ALLOWED_MODEL_PREFI
 if (filteredModels.length === 0) {
   throw new Error("No valid models found with allowed prefixes");
 }
-var JsonSchemaSchema = import_v455.z.lazy(() => import_v455.z.looseObject({
-  type: import_v455.z.enum([
+var JsonSchemaSchema = import_v462.z.lazy(() => import_v462.z.looseObject({
+  type: import_v462.z.enum([
     "object",
     "array",
     "string",
@@ -20798,78 +21087,78 @@ var JsonSchemaSchema = import_v455.z.lazy(() => import_v455.z.looseObject({
     "null",
     "integer"
   ]).optional(),
-  description: import_v455.z.string().optional(),
-  properties: import_v455.z.record(import_v455.z.string(), JsonSchemaSchema.or(import_v455.z.boolean())).optional(),
-  required: import_v455.z.string().array().optional(),
-  enum: import_v455.z.union([import_v455.z.string(), import_v455.z.number(), import_v455.z.boolean(), import_v455.z.null()]).array().optional()
+  description: import_v462.z.string().optional(),
+  properties: import_v462.z.record(import_v462.z.string(), JsonSchemaSchema.or(import_v462.z.boolean())).optional(),
+  required: import_v462.z.string().array().optional(),
+  enum: import_v462.z.union([import_v462.z.string(), import_v462.z.number(), import_v462.z.boolean(), import_v462.z.null()]).array().optional()
 }));
-var JsonObjectSchemaSchema = import_v455.z.intersection(JsonSchemaSchema, import_v455.z.object({ type: import_v455.z.literal("object") }));
-var InputSchemaObjectSchema = import_v455.z.looseObject({
-  prompt: import_v455.z.looseObject({
-    type: import_v455.z.literal("string"),
-    description: import_v455.z.string().optional()
+var JsonObjectSchemaSchema = import_v462.z.intersection(JsonSchemaSchema, import_v462.z.object({ type: import_v462.z.literal("object") }));
+var InputSchemaObjectSchema = import_v462.z.looseObject({
+  prompt: import_v462.z.looseObject({
+    type: import_v462.z.literal("string"),
+    description: import_v462.z.string().optional()
   }).optional(),
   params: JsonObjectSchemaSchema.optional()
 }).optional();
-var PromptFieldSchema = import_v455.z.union([
-  import_v455.z.string(),
-  import_v455.z.object({ path: import_v455.z.string() })
+var PromptFieldSchema = import_v462.z.union([
+  import_v462.z.string(),
+  import_v462.z.object({ path: import_v462.z.string() })
 ]);
-var functionSchema = (schema) => import_v455.z.custom((fn) => schema.implement(fn));
-var LoggerSchema = import_v455.z.object({
-  debug: import_v455.z.function({
-    input: [import_v455.z.any(), import_v455.z.string().optional()],
-    output: import_v455.z.void()
+var functionSchema = (schema) => import_v462.z.custom((fn) => schema.implement(fn));
+var LoggerSchema = import_v462.z.object({
+  debug: import_v462.z.function({
+    input: [import_v462.z.any(), import_v462.z.string().optional()],
+    output: import_v462.z.void()
   }),
-  info: import_v455.z.function({
-    input: [import_v455.z.any(), import_v455.z.string().optional()],
-    output: import_v455.z.void()
+  info: import_v462.z.function({
+    input: [import_v462.z.any(), import_v462.z.string().optional()],
+    output: import_v462.z.void()
   }),
-  warn: import_v455.z.function({
-    input: [import_v455.z.any(), import_v455.z.string().optional()],
-    output: import_v455.z.void()
+  warn: import_v462.z.function({
+    input: [import_v462.z.any(), import_v462.z.string().optional()],
+    output: import_v462.z.void()
   }),
-  error: import_v455.z.function({
-    input: [import_v455.z.any(), import_v455.z.string().optional()],
-    output: import_v455.z.void()
+  error: import_v462.z.function({
+    input: [import_v462.z.any(), import_v462.z.string().optional()],
+    output: import_v462.z.void()
   })
 });
-var HandleStepsSchema = functionSchema(import_v455.z.function({
+var HandleStepsSchema = functionSchema(import_v462.z.function({
   input: [
-    import_v455.z.object({
-      agentState: import_v455.z.object({
-        agentId: import_v455.z.string(),
-        parentId: import_v455.z.string(),
-        messageHistory: import_v455.z.array(import_v455.z.any())
+    import_v462.z.object({
+      agentState: import_v462.z.object({
+        agentId: import_v462.z.string(),
+        parentId: import_v462.z.string(),
+        messageHistory: import_v462.z.array(import_v462.z.any())
       }),
-      prompt: import_v455.z.string().optional(),
-      params: import_v455.z.any().optional()
+      prompt: import_v462.z.string().optional(),
+      params: import_v462.z.any().optional()
     }),
     LoggerSchema.optional()
   ],
-  output: import_v455.z.any()
+  output: import_v462.z.any()
 })).optional();
-var DynamicAgentDefinitionSchema = import_v455.z.object({
-  id: import_v455.z.string().regex(/^[a-z0-9-]+$/, "Agent ID must contain only lowercase letters, numbers, and hyphens"),
-  version: import_v455.z.string().optional(),
-  publisher: import_v455.z.string().optional(),
-  displayName: import_v455.z.string(),
-  model: import_v455.z.string(),
-  reasoningOptions: import_v455.z.object({
-    enabled: import_v455.z.boolean().optional(),
-    exclude: import_v455.z.boolean().optional()
-  }).and(import_v455.z.union([
-    import_v455.z.object({ max_tokens: import_v455.z.number() }),
-    import_v455.z.object({ effort: import_v455.z.enum(["high", "medium", "low", "minimal", "none"]) })
+var DynamicAgentDefinitionSchema = import_v462.z.object({
+  id: import_v462.z.string().regex(/^[a-z0-9-]+$/, "Agent ID must contain only lowercase letters, numbers, and hyphens"),
+  version: import_v462.z.string().optional(),
+  publisher: import_v462.z.string().optional(),
+  displayName: import_v462.z.string(),
+  model: import_v462.z.string(),
+  reasoningOptions: import_v462.z.object({
+    enabled: import_v462.z.boolean().optional(),
+    exclude: import_v462.z.boolean().optional()
+  }).and(import_v462.z.union([
+    import_v462.z.object({ max_tokens: import_v462.z.number() }),
+    import_v462.z.object({ effort: import_v462.z.enum(["high", "medium", "low", "minimal", "none"]) })
   ])).optional(),
-  providerOptions: import_v455.z.object({
-    order: import_v455.z.array(import_v455.z.string()).optional(),
-    allow_fallbacks: import_v455.z.boolean().optional(),
-    require_parameters: import_v455.z.boolean().optional(),
-    data_collection: import_v455.z.enum(["allow", "deny"]).optional(),
-    only: import_v455.z.array(import_v455.z.string()).optional(),
-    ignore: import_v455.z.array(import_v455.z.string()).optional(),
-    quantizations: import_v455.z.array(import_v455.z.enum([
+  providerOptions: import_v462.z.object({
+    order: import_v462.z.array(import_v462.z.string()).optional(),
+    allow_fallbacks: import_v462.z.boolean().optional(),
+    require_parameters: import_v462.z.boolean().optional(),
+    data_collection: import_v462.z.enum(["allow", "deny"]).optional(),
+    only: import_v462.z.array(import_v462.z.string()).optional(),
+    ignore: import_v462.z.array(import_v462.z.string()).optional(),
+    quantizations: import_v462.z.array(import_v462.z.enum([
       "int4",
       "int8",
       "fp4",
@@ -20880,34 +21169,34 @@ var DynamicAgentDefinitionSchema = import_v455.z.object({
       "fp32",
       "unknown"
     ])).optional(),
-    sort: import_v455.z.enum(["price", "throughput", "latency"]).optional(),
-    max_price: import_v455.z.object({
-      prompt: import_v455.z.union([import_v455.z.number(), import_v455.z.string()]).optional(),
-      completion: import_v455.z.union([import_v455.z.number(), import_v455.z.string()]).optional(),
-      image: import_v455.z.union([import_v455.z.number(), import_v455.z.string()]).optional(),
-      audio: import_v455.z.union([import_v455.z.number(), import_v455.z.string()]).optional(),
-      request: import_v455.z.union([import_v455.z.number(), import_v455.z.string()]).optional()
+    sort: import_v462.z.enum(["price", "throughput", "latency"]).optional(),
+    max_price: import_v462.z.object({
+      prompt: import_v462.z.union([import_v462.z.number(), import_v462.z.string()]).optional(),
+      completion: import_v462.z.union([import_v462.z.number(), import_v462.z.string()]).optional(),
+      image: import_v462.z.union([import_v462.z.number(), import_v462.z.string()]).optional(),
+      audio: import_v462.z.union([import_v462.z.number(), import_v462.z.string()]).optional(),
+      request: import_v462.z.union([import_v462.z.number(), import_v462.z.string()]).optional()
     }).optional()
   }).optional(),
-  mcpServers: import_v455.z.record(import_v455.z.string(), mcpConfigSchema).default(() => ({})),
-  toolNames: import_v455.z.string().array().optional().default(() => []),
-  spawnableAgents: import_v455.z.array(import_v455.z.string()).optional().default(() => []),
+  mcpServers: import_v462.z.record(import_v462.z.string(), mcpConfigSchema).default(() => ({})),
+  toolNames: import_v462.z.string().array().optional().default(() => []),
+  spawnableAgents: import_v462.z.array(import_v462.z.string()).optional().default(() => []),
   inputSchema: InputSchemaObjectSchema,
-  includeMessageHistory: import_v455.z.boolean().default(false),
-  inheritParentSystemPrompt: import_v455.z.boolean().default(false),
-  outputMode: import_v455.z.enum(["last_message", "all_messages", "structured_output"]).default("last_message"),
+  includeMessageHistory: import_v462.z.boolean().default(false),
+  inheritParentSystemPrompt: import_v462.z.boolean().default(false),
+  outputMode: import_v462.z.enum(["last_message", "all_messages", "structured_output"]).default("last_message"),
   outputSchema: JsonObjectSchemaSchema.optional(),
-  spawnerPrompt: import_v455.z.string().optional(),
-  systemPrompt: import_v455.z.string().optional(),
-  instructionsPrompt: import_v455.z.string().optional(),
-  stepPrompt: import_v455.z.string().optional(),
-  handleSteps: import_v455.z.union([import_v455.z.string(), HandleStepsSchema]).optional()
+  spawnerPrompt: import_v462.z.string().optional(),
+  systemPrompt: import_v462.z.string().optional(),
+  instructionsPrompt: import_v462.z.string().optional(),
+  stepPrompt: import_v462.z.string().optional(),
+  handleSteps: import_v462.z.union([import_v462.z.string(), HandleStepsSchema]).optional()
 });
 var DynamicAgentTemplateSchema = DynamicAgentDefinitionSchema.extend({
-  systemPrompt: import_v455.z.string(),
-  instructionsPrompt: import_v455.z.string(),
-  stepPrompt: import_v455.z.string(),
-  handleSteps: import_v455.z.string().optional()
+  systemPrompt: import_v462.z.string(),
+  instructionsPrompt: import_v462.z.string(),
+  stepPrompt: import_v462.z.string(),
+  handleSteps: import_v462.z.string().optional()
 }).refine((data) => {
   if (data.outputSchema && data.outputMode !== "structured_output") {
     return false;
@@ -21016,9 +21305,9 @@ function validateSingleAgent(params2) {
         error: `${agentContext2}: Schema validation failed: ${error.message}`
       };
     }
-    let inputSchema32;
+    let inputSchema39;
     try {
-      inputSchema32 = convertInputSchema(validatedConfig.inputSchema?.prompt, validatedConfig.inputSchema?.params, filePath);
+      inputSchema39 = convertInputSchema(validatedConfig.inputSchema?.prompt, validatedConfig.inputSchema?.params, filePath);
     } catch (error) {
       const agentContext2 = validatedConfig.id ? `Agent "${validatedConfig.id}"${validatedConfig.displayName ? ` (${validatedConfig.displayName})` : ""}` : filePath ? `Agent in ${filePath}` : "Agent";
       return {
@@ -21053,7 +21342,7 @@ function validateSingleAgent(params2) {
       instructionsPrompt: validatedConfig.instructionsPrompt ?? "",
       stepPrompt: validatedConfig.stepPrompt ?? "",
       outputSchema: outputSchema3,
-      inputSchema: inputSchema32
+      inputSchema: inputSchema39
     };
     return {
       success: true,
@@ -21237,10 +21526,10 @@ function assembleLocalAgentTemplates(params2) {
 // ../packages/agent-runtime/src/templates/prompts.ts
 function ensureJsonSchemaCompatible(schema) {
   try {
-    import_v456.z.toJSONSchema(schema, { io: "input" });
+    import_v463.z.toJSONSchema(schema, { io: "input" });
     return schema;
   } catch {
-    const fallback = import_v456.z.object({}).passthrough();
+    const fallback = import_v463.z.object({}).passthrough();
     return schema.description ? fallback.describe(schema.description) : fallback;
   }
 }
@@ -21250,15 +21539,15 @@ function getAgentShortName(agentType) {
   return parts[parts.length - 1];
 }
 function buildAgentToolInputSchema(agentTemplate) {
-  const { inputSchema: inputSchema32 } = agentTemplate;
+  const { inputSchema: inputSchema39 } = agentTemplate;
   let schemaFields = {};
-  if (inputSchema32?.prompt) {
-    schemaFields.prompt = inputSchema32.prompt;
+  if (inputSchema39?.prompt) {
+    schemaFields.prompt = inputSchema39.prompt;
   }
-  if (inputSchema32?.params) {
-    schemaFields.params = inputSchema32.params;
+  if (inputSchema39?.params) {
+    schemaFields.params = inputSchema39.params;
   }
-  return import_v456.z.object(schemaFields).describe(agentTemplate.spawnerPrompt || `Spawn the ${agentTemplate.displayName} agent`);
+  return import_v463.z.object(schemaFields).describe(agentTemplate.spawnerPrompt || `Spawn the ${agentTemplate.displayName} agent`);
 }
 async function buildAgentToolSet(params2) {
   const { spawnableAgents, agentTemplates } = params2;
@@ -21272,10 +21561,10 @@ async function buildAgentToolSet(params2) {
     if (!agentTemplate)
       continue;
     const shortName = getAgentShortName(agentType);
-    const inputSchema32 = ensureJsonSchemaCompatible(buildAgentToolInputSchema(agentTemplate));
+    const inputSchema39 = ensureJsonSchemaCompatible(buildAgentToolInputSchema(agentTemplate));
     toolSet[shortName] = {
       description: agentTemplate.spawnerPrompt || `Spawn the ${agentTemplate.displayName} agent`,
-      inputSchema: inputSchema32
+      inputSchema: inputSchema39
     };
   }
   return toolSet;
@@ -21286,10 +21575,10 @@ function buildSingleAgentDescription(agentType, agentTemplate) {
 prompt: {"description": "A coding task to complete", "type": "string"}
 params: None`;
   }
-  const { inputSchema: inputSchema32 } = agentTemplate;
-  const inputSchemaStr = inputSchema32 ? [
-    `prompt: ${schemaToJsonStr(inputSchema32.prompt)}`,
-    `params: ${schemaToJsonStr(inputSchema32.params)}`
+  const { inputSchema: inputSchema39 } = agentTemplate;
+  const inputSchemaStr = inputSchema39 ? [
+    `prompt: ${schemaToJsonStr(inputSchema39.prompt)}`,
+    `params: ${schemaToJsonStr(inputSchema39.params)}`
   ].join(`
 `) : ["prompt: None", "params: None"].join(`
 `);
@@ -21377,49 +21666,49 @@ init_model_config();
 // ../common/src/util/file.ts
 var os = __toESM(require("os"));
 var path = __toESM(require("path"));
-var import_v457 = require("zod/v4");
-var FileTreeNodeSchema = import_v457.z.object({
-  name: import_v457.z.string(),
-  type: import_v457.z.enum(["file", "directory"]),
-  children: import_v457.z.lazy(() => import_v457.z.array(FileTreeNodeSchema).optional()),
-  filePath: import_v457.z.string()
+var import_v464 = require("zod/v4");
+var FileTreeNodeSchema = import_v464.z.object({
+  name: import_v464.z.string(),
+  type: import_v464.z.enum(["file", "directory"]),
+  children: import_v464.z.lazy(() => import_v464.z.array(FileTreeNodeSchema).optional()),
+  filePath: import_v464.z.string()
 });
-var FileVersionSchema = import_v457.z.object({
-  path: import_v457.z.string(),
-  content: import_v457.z.string()
+var FileVersionSchema = import_v464.z.object({
+  path: import_v464.z.string(),
+  content: import_v464.z.string()
 });
-var customToolDefinitionsSchema = import_v457.z.record(import_v457.z.string(), import_v457.z.object({
-  inputSchema: import_v457.z.custom(),
-  endsAgentStep: import_v457.z.boolean().optional().default(false),
-  description: import_v457.z.string().optional(),
-  exampleInputs: import_v457.z.record(import_v457.z.string(), import_v457.z.any()).array().optional()
+var customToolDefinitionsSchema = import_v464.z.record(import_v464.z.string(), import_v464.z.object({
+  inputSchema: import_v464.z.custom(),
+  endsAgentStep: import_v464.z.boolean().optional().default(false),
+  description: import_v464.z.string().optional(),
+  exampleInputs: import_v464.z.record(import_v464.z.string(), import_v464.z.any()).array().optional()
 })).default(() => ({}));
-var ProjectFileContextSchema = import_v457.z.object({
-  projectRoot: import_v457.z.string(),
-  cwd: import_v457.z.string(),
-  fileTree: import_v457.z.array(import_v457.z.custom()),
-  fileTokenScores: import_v457.z.record(import_v457.z.string(), import_v457.z.record(import_v457.z.string(), import_v457.z.number())),
-  tokenCallers: import_v457.z.record(import_v457.z.string(), import_v457.z.record(import_v457.z.string(), import_v457.z.array(import_v457.z.string()))).optional(),
-  knowledgeFiles: import_v457.z.record(import_v457.z.string(), import_v457.z.string()),
-  userKnowledgeFiles: import_v457.z.record(import_v457.z.string(), import_v457.z.string()).optional(),
-  agentTemplates: import_v457.z.record(import_v457.z.string(), import_v457.z.any()).default(() => ({})),
+var ProjectFileContextSchema = import_v464.z.object({
+  projectRoot: import_v464.z.string(),
+  cwd: import_v464.z.string(),
+  fileTree: import_v464.z.array(import_v464.z.custom()),
+  fileTokenScores: import_v464.z.record(import_v464.z.string(), import_v464.z.record(import_v464.z.string(), import_v464.z.number())),
+  tokenCallers: import_v464.z.record(import_v464.z.string(), import_v464.z.record(import_v464.z.string(), import_v464.z.array(import_v464.z.string()))).optional(),
+  knowledgeFiles: import_v464.z.record(import_v464.z.string(), import_v464.z.string()),
+  userKnowledgeFiles: import_v464.z.record(import_v464.z.string(), import_v464.z.string()).optional(),
+  agentTemplates: import_v464.z.record(import_v464.z.string(), import_v464.z.any()).default(() => ({})),
   customToolDefinitions: customToolDefinitionsSchema,
-  skills: import_v457.z.record(import_v457.z.string(), import_v457.z.any()).optional(),
-  gitChanges: import_v457.z.object({
-    status: import_v457.z.string(),
-    diff: import_v457.z.string(),
-    diffCached: import_v457.z.string(),
-    lastCommitMessages: import_v457.z.string()
+  skills: import_v464.z.record(import_v464.z.string(), import_v464.z.any()).optional(),
+  gitChanges: import_v464.z.object({
+    status: import_v464.z.string(),
+    diff: import_v464.z.string(),
+    diffCached: import_v464.z.string(),
+    lastCommitMessages: import_v464.z.string()
   }),
-  changesSinceLastChat: import_v457.z.record(import_v457.z.string(), import_v457.z.string()),
-  shellConfigFiles: import_v457.z.record(import_v457.z.string(), import_v457.z.string()),
-  systemInfo: import_v457.z.object({
-    platform: import_v457.z.string(),
-    shell: import_v457.z.string(),
-    nodeVersion: import_v457.z.string(),
-    arch: import_v457.z.string(),
-    homedir: import_v457.z.string(),
-    cpus: import_v457.z.number()
+  changesSinceLastChat: import_v464.z.record(import_v464.z.string(), import_v464.z.string()),
+  shellConfigFiles: import_v464.z.record(import_v464.z.string(), import_v464.z.string()),
+  systemInfo: import_v464.z.object({
+    platform: import_v464.z.string(),
+    shell: import_v464.z.string(),
+    nodeVersion: import_v464.z.string(),
+    arch: import_v464.z.string(),
+    homedir: import_v464.z.string(),
+    cpus: import_v464.z.number()
   })
 });
 var createMarkdownFileBlock = (filePath, content) => {
@@ -27425,8 +27714,8 @@ var import_lodash8 = __toESM(require_lodash());
 var import_assert = require("assert");
 
 // ../common/src/util/xml.ts
-function closeXml(toolName32) {
-  return `</${toolName32}>`;
+function closeXml(toolName39) {
+  return `</${toolName39}>`;
 }
 
 // ../packages/agent-runtime/src/util/messages.ts
@@ -28573,7 +28862,7 @@ var removeUndefinedProps = (obj) => {
 };
 
 // ../packages/agent-runtime/src/tools/handlers/tool/lookup-agent-info.ts
-var import_v458 = __toESM(require("zod/v4"));
+var import_v465 = __toESM(require("zod/v4"));
 var handleLookupAgentInfo = async (params2) => {
   const { toolCall, previousToolCallFinished } = params2;
   const { agentId } = toolCall.input;
@@ -28595,7 +28884,7 @@ var handleLookupAgentInfo = async (params2) => {
     displayName,
     model,
     includeMessageHistory,
-    inputSchema: inputSchema32,
+    inputSchema: inputSchema39,
     spawnerPrompt,
     outputMode,
     outputSchema: outputSchema3,
@@ -28615,8 +28904,8 @@ var handleLookupAgentInfo = async (params2) => {
           spawnableAgents,
           includeMessageHistory,
           spawnerPrompt,
-          ...inputSchema32 && {
-            inputSchema: inputSchemaToJSONSchema(inputSchema32)
+          ...inputSchema39 && {
+            inputSchema: inputSchemaToJSONSchema(inputSchema39)
           },
           outputMode,
           ...outputSchema3 && {
@@ -28629,17 +28918,17 @@ var handleLookupAgentInfo = async (params2) => {
 };
 var toJSONSchema = (schema) => {
   try {
-    const jsonSchema = import_v458.default.toJSONSchema(schema, { io: "input" });
+    const jsonSchema = import_v465.default.toJSONSchema(schema, { io: "input" });
     delete jsonSchema["$schema"];
     return jsonSchema;
   } catch {
     return { type: "object", description: "Schema unavailable" };
   }
 };
-var inputSchemaToJSONSchema = (inputSchema32) => {
+var inputSchemaToJSONSchema = (inputSchema39) => {
   return removeUndefinedProps({
-    prompt: inputSchema32.prompt ? toJSONSchema(inputSchema32.prompt) : undefined,
-    params: inputSchema32.params ? toJSONSchema(inputSchema32.params) : undefined
+    prompt: inputSchema39.prompt ? toJSONSchema(inputSchema39.prompt) : undefined,
+    params: inputSchema39.params ? toJSONSchema(inputSchema39.params) : undefined
   });
 };
 
@@ -29222,6 +29511,119 @@ var handleSkill = async (params2) => {
 // ../packages/agent-runtime/src/tools/handlers/tool/spawn-agent-inline.ts
 var import_lodash11 = __toESM(require_lodash());
 
+// ../common/src/utils/team-fs.ts
+var fs = __toESM(require("fs"));
+var path3 = __toESM(require("path"));
+var os2 = __toESM(require("os"));
+function getConfigRoot() {
+  return path3.join(os2.homedir(), ".config", "levelcode");
+}
+function getTeamsDir() {
+  return path3.join(getConfigRoot(), "teams");
+}
+function getTasksDir(teamName) {
+  return path3.join(getConfigRoot(), "tasks", teamName);
+}
+function getTeamDir(teamName) {
+  return path3.join(getTeamsDir(), teamName);
+}
+function getTeamConfigPath(teamName) {
+  return path3.join(getTeamDir(teamName), "config.json");
+}
+function getInboxesDir(teamName) {
+  return path3.join(getTeamDir(teamName), "inboxes");
+}
+function getInboxPath(teamName, agentName) {
+  return path3.join(getInboxesDir(teamName), `${agentName}.json`);
+}
+function getTaskPath(teamName, taskId) {
+  return path3.join(getTasksDir(teamName), `${taskId}.json`);
+}
+function createTeam(config) {
+  const teamDir = getTeamDir(config.name);
+  fs.mkdirSync(teamDir, { recursive: true });
+  fs.mkdirSync(getInboxesDir(config.name), { recursive: true });
+  fs.mkdirSync(getTasksDir(config.name), { recursive: true });
+  fs.writeFileSync(getTeamConfigPath(config.name), JSON.stringify(config, null, 2));
+}
+function loadTeamConfig(teamName) {
+  const configPath = getTeamConfigPath(teamName);
+  if (!fs.existsSync(configPath)) {
+    return null;
+  }
+  const raw = fs.readFileSync(configPath, "utf-8");
+  return JSON.parse(raw);
+}
+function saveTeamConfig(teamName, config) {
+  const configPath = getTeamConfigPath(teamName);
+  fs.mkdirSync(path3.dirname(configPath), { recursive: true });
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+}
+function deleteTeam(teamName) {
+  const teamDir = getTeamDir(teamName);
+  if (fs.existsSync(teamDir)) {
+    fs.rmSync(teamDir, { recursive: true, force: true });
+  }
+  const tasksDir = getTasksDir(teamName);
+  if (fs.existsSync(tasksDir)) {
+    fs.rmSync(tasksDir, { recursive: true, force: true });
+  }
+}
+function addTeamMember(teamName, member) {
+  const config = loadTeamConfig(teamName);
+  if (!config) {
+    throw new Error(`Team "${teamName}" not found`);
+  }
+  config.members.push(member);
+  saveTeamConfig(teamName, config);
+}
+function createTask(teamName, task) {
+  const tasksDir = getTasksDir(teamName);
+  fs.mkdirSync(tasksDir, { recursive: true });
+  fs.writeFileSync(getTaskPath(teamName, task.id), JSON.stringify(task, null, 2));
+}
+function updateTask(teamName, taskId, updates) {
+  const taskPath = getTaskPath(teamName, taskId);
+  if (!fs.existsSync(taskPath)) {
+    throw new Error(`Task "${taskId}" not found in team "${teamName}"`);
+  }
+  const raw = fs.readFileSync(taskPath, "utf-8");
+  const task = JSON.parse(raw);
+  const updated = { ...task, ...updates, updatedAt: Date.now() };
+  fs.writeFileSync(taskPath, JSON.stringify(updated, null, 2));
+}
+function listTasks(teamName) {
+  const tasksDir = getTasksDir(teamName);
+  if (!fs.existsSync(tasksDir)) {
+    return [];
+  }
+  const files = fs.readdirSync(tasksDir).filter((f) => f.endsWith(".json"));
+  return files.map((f) => {
+    const raw = fs.readFileSync(path3.join(tasksDir, f), "utf-8");
+    return JSON.parse(raw);
+  });
+}
+function getTask(teamName, taskId) {
+  const taskPath = getTaskPath(teamName, taskId);
+  if (!fs.existsSync(taskPath)) {
+    return null;
+  }
+  const raw = fs.readFileSync(taskPath, "utf-8");
+  return JSON.parse(raw);
+}
+function sendMessage(teamName, to, message) {
+  const inboxesDir = getInboxesDir(teamName);
+  fs.mkdirSync(inboxesDir, { recursive: true });
+  const inboxPath = getInboxPath(teamName, to);
+  let messages = [];
+  if (fs.existsSync(inboxPath)) {
+    const raw = fs.readFileSync(inboxPath, "utf-8");
+    messages = JSON.parse(raw);
+  }
+  messages.push(message);
+  fs.writeFileSync(inboxPath, JSON.stringify(messages, null, 2));
+}
+
 // ../packages/agent-runtime/src/tools/handlers/tool/spawn-agent-utils.ts
 function extractSubagentContextParams(params2) {
   return {
@@ -29360,15 +29762,15 @@ async function validateAndGetAgentTemplate(params2) {
   return { agentTemplate, agentType };
 }
 function validateAgentInput(agentTemplate, agentType, prompt2, params2) {
-  const { inputSchema: inputSchema32 } = agentTemplate;
-  if (inputSchema32.prompt) {
-    const result = inputSchema32.prompt.safeParse(prompt2 ?? "");
+  const { inputSchema: inputSchema39 } = agentTemplate;
+  if (inputSchema39.prompt) {
+    const result = inputSchema39.prompt.safeParse(prompt2 ?? "");
     if (!result.success) {
       throw new Error(`Invalid prompt for agent ${agentType}: ${JSON.stringify(result.error.issues, null, 2)}`);
     }
   }
-  if (inputSchema32.params) {
-    const result = inputSchema32.params.safeParse(params2 ?? {});
+  if (inputSchema39.params) {
+    const result = inputSchema39.params.safeParse(params2 ?? {});
     if (!result.success) {
       throw new Error(`Invalid params for agent ${agentType}: ${JSON.stringify(result.error.issues, null, 2)}`);
     }
@@ -29458,6 +29860,48 @@ async function executeSubagent(options) {
   }
   return result;
 }
+function registerAgentAsTeamMember(agentId, agentType, options, logger2) {
+  const { teamName, teamRole } = options;
+  const teamConfig = loadTeamConfig(teamName);
+  if (!teamConfig) {
+    logger2.debug({ teamName, agentId }, `Team "${teamName}" not found; skipping team registration`);
+    return null;
+  }
+  const role = teamRole || "mid-level-engineer";
+  const memberName = `${agentType}-${agentId}`;
+  const member = {
+    agentId,
+    name: memberName,
+    role,
+    agentType,
+    model: "",
+    joinedAt: Date.now(),
+    status: "active",
+    cwd: process.cwd()
+  };
+  try {
+    addTeamMember(teamName, member);
+  } catch (error) {
+    logger2.debug({ teamName, agentId, error }, `Failed to register agent as team member`);
+    return null;
+  }
+  return buildTeamContextPrompt(teamName, memberName, role, teamConfig.leadAgentId);
+}
+function buildTeamContextPrompt(teamName, agentName, role, leadAgentId) {
+  const tasksDir = getTasksDir(teamName);
+  return [
+    `
+# Team Context`,
+    `You are a member of team "${teamName}".`,
+    `Your name in this team: ${agentName}`,
+    `Your role: ${role}`,
+    `Team lead agent ID: ${leadAgentId}`,
+    `Team task directory: ${tasksDir}`,
+    `Use the team messaging tools (send_message, broadcast) to communicate with teammates.`,
+    `Use the task tools (task_create, task_update, task_list) to coordinate work.`
+  ].join(`
+`);
+}
 
 // ../packages/agent-runtime/src/tools/handlers/tool/spawn-agent-inline.ts
 var handleSpawnAgentInline = async (params2) => {
@@ -29543,7 +29987,13 @@ var handleSpawnAgents = async (params2) => {
   const { agents } = toolCall.input;
   const { logger: logger2 } = params2;
   await previousToolCallFinished;
-  const results = await Promise.allSettled(agents.map(async ({ agent_type: agentTypeStr, prompt: prompt2, params: spawnParams }) => {
+  const results = await Promise.allSettled(agents.map(async ({
+    agent_type: agentTypeStr,
+    prompt: prompt2,
+    params: spawnParams,
+    team_name: teamName,
+    team_role: teamRole
+  }) => {
     const { agentTemplate, agentType } = await validateAndGetAgentTemplate({
       ...params2,
       agentTypeStr,
@@ -29551,12 +30001,21 @@ var handleSpawnAgents = async (params2) => {
     });
     validateAgentInput(agentTemplate, agentType, prompt2, spawnParams);
     const subAgentState = createAgentState(agentType, agentTemplate, parentAgentState, {});
+    let effectivePrompt = prompt2 || "";
+    if (teamName) {
+      const teamContext = registerAgentAsTeamMember(subAgentState.agentId, agentType, { teamName, teamRole }, logger2);
+      if (teamContext) {
+        effectivePrompt = teamContext + `
+
+` + effectivePrompt;
+      }
+    }
     const contextParams = extractSubagentContextParams(params2);
     const result = await executeSubagent({
       ...contextParams,
       ancestorRunIds: parentAgentState.ancestorRunIds,
       userInputId: `${userInputId2}-${agentType}${subAgentState.agentId}`,
-      prompt: prompt2 || "",
+      prompt: effectivePrompt,
       spawnParams,
       agentTemplate,
       parentAgentState,
@@ -29659,15 +30118,15 @@ var handleStrReplace = async (params2) => {
     requestOptionalFile,
     writeToClient
   } = params2;
-  const { path: path3, replacements } = toolCall.input;
-  if (!fileProcessingState2.promisesByPath[path3]) {
-    fileProcessingState2.promisesByPath[path3] = [];
+  const { path: path4, replacements } = toolCall.input;
+  if (!fileProcessingState2.promisesByPath[path4]) {
+    fileProcessingState2.promisesByPath[path4] = [];
   }
-  const previousPromises = fileProcessingState2.promisesByPath[path3];
+  const previousPromises = fileProcessingState2.promisesByPath[path4];
   const previousEdit = previousPromises[previousPromises.length - 1];
-  const latestContentPromise = previousEdit ? previousEdit.then((maybeResult) => maybeResult && ("content" in maybeResult) ? maybeResult.content : requestOptionalFile({ ...params2, filePath: path3 })) : requestOptionalFile({ ...params2, filePath: path3 });
+  const latestContentPromise = previousEdit ? previousEdit.then((maybeResult) => maybeResult && ("content" in maybeResult) ? maybeResult.content : requestOptionalFile({ ...params2, filePath: path4 })) : requestOptionalFile({ ...params2, filePath: path4 });
   const newPromise = processStrReplace({
-    path: path3,
+    path: path4,
     replacements,
     initialContentPromise: latestContentPromise,
     logger: logger2
@@ -29675,14 +30134,14 @@ var handleStrReplace = async (params2) => {
     logger2.error(error, "Error processing str_replace block");
     return {
       tool: "str_replace",
-      path: path3,
+      path: path4,
       error: "Unknown error: Failed to process the str_replace block."
     };
   }).then((fileProcessingResult) => ({
     ...fileProcessingResult,
     toolCallId: toolCall.toolCallId
   }));
-  fileProcessingState2.promisesByPath[path3].push(newPromise);
+  fileProcessingState2.promisesByPath[path4].push(newPromise);
   fileProcessingState2.allPromises.push(newPromise);
   await previousToolCallFinished;
   const strReplaceResult = await newPromise;
@@ -29859,6 +30318,563 @@ var handleWriteTodos = async (params2) => {
   return { output: jsonToolResult({ message: "Todos written" }) };
 };
 
+// ../packages/agent-runtime/src/tools/handlers/tool/send-message.ts
+var fs2 = __toESM(require("fs"));
+function findCurrentTeamAndAgent(agentStepId2) {
+  const teamsDir = getTeamsDir();
+  if (!fs2.existsSync(teamsDir)) {
+    return null;
+  }
+  const entries = fs2.readdirSync(teamsDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const config = loadTeamConfig(entry.name);
+    if (!config) {
+      continue;
+    }
+    for (const member of config.members) {
+      if (member.agentId === `lead-${agentStepId2}` || member.agentId === agentStepId2) {
+        return { teamName: config.name, agentName: member.name, config };
+      }
+    }
+  }
+  return null;
+}
+function errorResult(message) {
+  return { output: jsonToolResult({ message }) };
+}
+var handleSendMessage = async (params2) => {
+  const { previousToolCallFinished, toolCall, agentStepId: agentStepId2 } = params2;
+  const { type, recipient, content, summary, request_id, approve } = toolCall.input;
+  await previousToolCallFinished;
+  const teamContext = findCurrentTeamAndAgent(agentStepId2);
+  if (!teamContext) {
+    return errorResult("No team found for the current agent context. Cannot send messages outside a team.");
+  }
+  const { teamName, agentName, config } = teamContext;
+  const timestamp = new Date().toISOString();
+  switch (type) {
+    case "message": {
+      if (!recipient) {
+        return errorResult('A "recipient" is required for type "message".');
+      }
+      if (!summary) {
+        return errorResult('A "summary" is required for type "message".');
+      }
+      const memberExists = config.members.some((m) => m.name === recipient);
+      if (!memberExists) {
+        return errorResult(`Recipient "${recipient}" is not a member of team "${teamName}".`);
+      }
+      const msg = {
+        type: "message",
+        from: agentName,
+        to: recipient,
+        text: content ?? "",
+        summary,
+        timestamp
+      };
+      sendMessage(teamName, recipient, msg);
+      return {
+        output: jsonToolResult({
+          message: `Message sent to "${recipient}" in team "${teamName}".`
+        })
+      };
+    }
+    case "broadcast": {
+      if (!summary) {
+        return errorResult('A "summary" is required for type "broadcast".');
+      }
+      const msg = {
+        type: "broadcast",
+        from: agentName,
+        text: content ?? "",
+        summary,
+        timestamp
+      };
+      const recipients = config.members.filter((m) => m.name !== agentName).map((m) => m.name);
+      for (const memberName of recipients) {
+        sendMessage(teamName, memberName, msg);
+      }
+      return {
+        output: jsonToolResult({
+          message: `Broadcast sent to ${recipients.length} teammate(s) in team "${teamName}".`
+        })
+      };
+    }
+    case "shutdown_request": {
+      if (!recipient) {
+        return errorResult('A "recipient" is required for type "shutdown_request".');
+      }
+      const memberExists = config.members.some((m) => m.name === recipient);
+      if (!memberExists) {
+        return errorResult(`Recipient "${recipient}" is not a member of team "${teamName}".`);
+      }
+      const msg = {
+        type: "shutdown_request",
+        requestId: generateCompactId(),
+        from: agentName,
+        reason: content,
+        timestamp
+      };
+      sendMessage(teamName, recipient, msg);
+      return {
+        output: jsonToolResult({
+          message: `Shutdown request sent to "${recipient}" (requestId: ${msg.requestId}).`
+        })
+      };
+    }
+    case "shutdown_response": {
+      if (!request_id) {
+        return errorResult('A "request_id" is required for type "shutdown_response".');
+      }
+      if (approve === undefined || approve === null) {
+        return errorResult('An "approve" boolean is required for type "shutdown_response".');
+      }
+      if (approve) {
+        const msg = {
+          type: "shutdown_approved",
+          requestId: request_id,
+          from: agentName,
+          timestamp
+        };
+        for (const member of config.members) {
+          if (member.name !== agentName) {
+            sendMessage(teamName, member.name, msg);
+          }
+        }
+        return {
+          output: jsonToolResult({
+            message: `Shutdown approved (requestId: ${request_id}). Agent will exit.`
+          })
+        };
+      } else {
+        const msg = {
+          type: "shutdown_rejected",
+          requestId: request_id,
+          from: agentName,
+          reason: content ?? "Shutdown rejected without a reason.",
+          timestamp
+        };
+        for (const member of config.members) {
+          if (member.name !== agentName) {
+            sendMessage(teamName, member.name, msg);
+          }
+        }
+        return {
+          output: jsonToolResult({
+            message: `Shutdown rejected (requestId: ${request_id}).`
+          })
+        };
+      }
+    }
+    case "plan_approval_response": {
+      if (!request_id) {
+        return errorResult('A "request_id" is required for type "plan_approval_response".');
+      }
+      if (!recipient) {
+        return errorResult('A "recipient" is required for type "plan_approval_response".');
+      }
+      if (approve === undefined || approve === null) {
+        return errorResult('An "approve" boolean is required for type "plan_approval_response".');
+      }
+      const memberExists = config.members.some((m) => m.name === recipient);
+      if (!memberExists) {
+        return errorResult(`Recipient "${recipient}" is not a member of team "${teamName}".`);
+      }
+      const msg = {
+        type: "plan_approval_response",
+        requestId: request_id,
+        approved: approve,
+        feedback: content,
+        timestamp
+      };
+      sendMessage(teamName, recipient, msg);
+      const action = approve ? "approved" : "rejected";
+      return {
+        output: jsonToolResult({
+          message: `Plan ${action} for "${recipient}" (requestId: ${request_id}).`
+        })
+      };
+    }
+    default: {
+      return errorResult(`Unknown message type: "${type}". Expected one of: message, broadcast, shutdown_request, shutdown_response, plan_approval_response.`);
+    }
+  }
+};
+
+// ../packages/agent-runtime/src/tools/handlers/tool/task-create.ts
+var fs3 = __toESM(require("fs"));
+function getActiveTeamName() {
+  const teamsDir = getTeamsDir();
+  if (!fs3.existsSync(teamsDir)) {
+    return null;
+  }
+  const entries = fs3.readdirSync(teamsDir, { withFileTypes: true });
+  const teamDirs = entries.filter((e) => e.isDirectory());
+  if (teamDirs.length === 0) {
+    return null;
+  }
+  return teamDirs[0].name;
+}
+var handleTaskCreate = async (params2) => {
+  const { previousToolCallFinished, toolCall } = params2;
+  const { subject, description: description38, activeForm, metadata } = toolCall.input;
+  await previousToolCallFinished;
+  const teamName = getActiveTeamName();
+  if (!teamName) {
+    return {
+      output: jsonToolResult({
+        error: "No active team found. Create a team first using TeamCreate."
+      })
+    };
+  }
+  const existingTasks = listTasks(teamName);
+  const maxId = existingTasks.reduce((max, t) => {
+    const num = parseInt(t.id, 10);
+    return isNaN(num) ? max : Math.max(max, num);
+  }, 0);
+  const taskId = String(maxId + 1);
+  const now = Date.now();
+  const task = {
+    id: taskId,
+    subject,
+    description: description38,
+    status: "pending",
+    blockedBy: [],
+    blocks: [],
+    phase: "planning",
+    activeForm,
+    createdAt: now,
+    updatedAt: now,
+    metadata
+  };
+  try {
+    createTask(teamName, task);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      output: jsonToolResult({
+        error: `Failed to create task: ${errorMessage}`
+      })
+    };
+  }
+  return {
+    output: jsonToolResult({
+      taskId,
+      subject
+    })
+  };
+};
+
+// ../packages/agent-runtime/src/tools/handlers/tool/task-get.ts
+var fs4 = __toESM(require("fs"));
+function getActiveTeamName2() {
+  const teamsDir = getTeamsDir();
+  if (!fs4.existsSync(teamsDir)) {
+    return null;
+  }
+  const entries = fs4.readdirSync(teamsDir, { withFileTypes: true });
+  const teamDirs = entries.filter((e) => e.isDirectory());
+  if (teamDirs.length === 0) {
+    return null;
+  }
+  return teamDirs[0].name;
+}
+var handleTaskGet = async (params2) => {
+  const { previousToolCallFinished, toolCall } = params2;
+  const { taskId } = toolCall.input;
+  await previousToolCallFinished;
+  const teamName = getActiveTeamName2();
+  if (!teamName) {
+    return {
+      output: jsonToolResult({
+        error: "No active team found. Create a team first using TeamCreate."
+      })
+    };
+  }
+  const task = getTask(teamName, taskId);
+  if (!task) {
+    return {
+      output: jsonToolResult({
+        error: `Task "${taskId}" not found.`
+      })
+    };
+  }
+  return {
+    output: jsonToolResult(task)
+  };
+};
+
+// ../packages/agent-runtime/src/tools/handlers/tool/task-list.ts
+var fs5 = __toESM(require("fs"));
+function getActiveTeamName3() {
+  const teamsDir = getTeamsDir();
+  if (!fs5.existsSync(teamsDir)) {
+    return null;
+  }
+  const entries = fs5.readdirSync(teamsDir, { withFileTypes: true });
+  const teamDirs = entries.filter((e) => e.isDirectory());
+  if (teamDirs.length === 0) {
+    return null;
+  }
+  return teamDirs[0].name;
+}
+var handleTaskList = async (params2) => {
+  const { previousToolCallFinished } = params2;
+  await previousToolCallFinished;
+  const teamName = getActiveTeamName3();
+  if (!teamName) {
+    return {
+      output: jsonToolResult({
+        error: "No active team found. Create a team first using TeamCreate.",
+        tasks: []
+      })
+    };
+  }
+  const tasks = listTasks(teamName);
+  const summary = tasks.map((t) => ({
+    id: t.id,
+    subject: t.subject,
+    status: t.status,
+    owner: t.owner ?? null,
+    blockedBy: t.blockedBy.filter((id) => {
+      const blocker = tasks.find((bt) => bt.id === id);
+      return blocker && blocker.status !== "completed";
+    })
+  }));
+  return {
+    output: jsonToolResult({ tasks: summary })
+  };
+};
+
+// ../packages/agent-runtime/src/tools/handlers/tool/task-update.ts
+var fs6 = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
+function getActiveTeamName4() {
+  const teamsDir = getTeamsDir();
+  if (!fs6.existsSync(teamsDir)) {
+    return null;
+  }
+  const entries = fs6.readdirSync(teamsDir, { withFileTypes: true });
+  const teamDirs = entries.filter((e) => e.isDirectory());
+  if (teamDirs.length === 0) {
+    return null;
+  }
+  return teamDirs[0].name;
+}
+var handleTaskUpdate = async (params2) => {
+  const { previousToolCallFinished, toolCall } = params2;
+  const {
+    taskId,
+    status,
+    subject,
+    description: description38,
+    activeForm,
+    owner,
+    addBlocks,
+    addBlockedBy,
+    metadata
+  } = toolCall.input;
+  await previousToolCallFinished;
+  const teamName = getActiveTeamName4();
+  if (!teamName) {
+    return {
+      output: jsonToolResult({
+        error: "No active team found. Create a team first using TeamCreate."
+      })
+    };
+  }
+  const existingTask = getTask(teamName, taskId);
+  if (!existingTask) {
+    return {
+      output: jsonToolResult({
+        error: `Task "${taskId}" not found.`
+      })
+    };
+  }
+  if (status === "deleted") {
+    const taskPath = path4.join(getTasksDir(teamName), `${taskId}.json`);
+    if (fs6.existsSync(taskPath)) {
+      fs6.unlinkSync(taskPath);
+    }
+    return {
+      output: jsonToolResult({
+        message: `Task "${taskId}" deleted.`
+      })
+    };
+  }
+  const updates = {};
+  if (status !== undefined)
+    updates.status = status;
+  if (subject !== undefined)
+    updates.subject = subject;
+  if (description38 !== undefined)
+    updates.description = description38;
+  if (activeForm !== undefined)
+    updates.activeForm = activeForm;
+  if (owner !== undefined)
+    updates.owner = owner;
+  if (addBlocks && addBlocks.length > 0) {
+    const currentBlocks = existingTask.blocks ?? [];
+    const newBlocks = [...new Set([...currentBlocks, ...addBlocks])];
+    updates.blocks = newBlocks;
+  }
+  if (addBlockedBy && addBlockedBy.length > 0) {
+    const currentBlockedBy = existingTask.blockedBy ?? [];
+    const newBlockedBy = [...new Set([...currentBlockedBy, ...addBlockedBy])];
+    updates.blockedBy = newBlockedBy;
+  }
+  if (metadata !== undefined) {
+    const currentMetadata = existingTask.metadata ?? {};
+    const mergedMetadata = { ...currentMetadata };
+    for (const [key, value] of Object.entries(metadata)) {
+      if (value === null) {
+        delete mergedMetadata[key];
+      } else {
+        mergedMetadata[key] = value;
+      }
+    }
+    updates.metadata = mergedMetadata;
+  }
+  try {
+    updateTask(teamName, taskId, updates);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      output: jsonToolResult({
+        error: `Failed to update task "${taskId}": ${errorMessage}`
+      })
+    };
+  }
+  const updatedTask = getTask(teamName, taskId);
+  return {
+    output: jsonToolResult(updatedTask)
+  };
+};
+
+// ../packages/agent-runtime/src/tools/handlers/tool/team-create.ts
+var handleTeamCreate = async (params2) => {
+  const { previousToolCallFinished, toolCall, agentStepId: agentStepId2 } = params2;
+  const { team_name, description: description38, agent_type } = toolCall.input;
+  await previousToolCallFinished;
+  const leadAgentId = `lead-${agentStepId2}`;
+  const now = Date.now();
+  const teamConfig = {
+    name: team_name,
+    description: description38 ?? "",
+    createdAt: now,
+    leadAgentId,
+    phase: "planning",
+    members: [
+      {
+        agentId: leadAgentId,
+        name: "team-lead",
+        role: "coordinator",
+        agentType: agent_type ?? "coordinator",
+        model: "",
+        joinedAt: now,
+        status: "active",
+        cwd: process.cwd()
+      }
+    ],
+    settings: {
+      maxMembers: 20,
+      autoAssign: true
+    }
+  };
+  try {
+    createTeam(teamConfig);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      output: jsonToolResult({
+        message: `Failed to create team "${team_name}": ${errorMessage}`
+      })
+    };
+  }
+  const teamFilePath = `${getTeamsDir()}/${team_name}/config.json`;
+  const taskDirPath = getTasksDir(team_name);
+  return {
+    output: jsonToolResult({
+      message: `Team "${team_name}" created successfully. Config: ${teamFilePath}, Tasks: ${taskDirPath}, Lead: ${leadAgentId}`
+    })
+  };
+};
+
+// ../packages/agent-runtime/src/tools/handlers/tool/team-delete.ts
+var fs7 = __toESM(require("fs"));
+function findCurrentTeam(agentStepId2) {
+  const teamsDir = getTeamsDir();
+  if (!fs7.existsSync(teamsDir)) {
+    return null;
+  }
+  const entries = fs7.readdirSync(teamsDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const config = loadTeamConfig(entry.name);
+    if (!config) {
+      continue;
+    }
+    if (config.leadAgentId === `lead-${agentStepId2}`) {
+      return config.name;
+    }
+    for (const member of config.members) {
+      if (member.agentId === `lead-${agentStepId2}` || member.agentId === agentStepId2) {
+        return config.name;
+      }
+    }
+  }
+  return null;
+}
+var handleTeamDelete = async (params2) => {
+  const { previousToolCallFinished, agentStepId: agentStepId2 } = params2;
+  await previousToolCallFinished;
+  const teamName = findCurrentTeam(agentStepId2);
+  if (!teamName) {
+    return {
+      output: jsonToolResult({
+        message: "No team found for the current agent context. Cannot delete."
+      })
+    };
+  }
+  const config = loadTeamConfig(teamName);
+  if (!config) {
+    return {
+      output: jsonToolResult({
+        message: `Team "${teamName}" config not found. It may have already been deleted.`
+      })
+    };
+  }
+  const activeNonLeadMembers = config.members.filter((m) => m.status === "active" && m.agentId !== config.leadAgentId);
+  if (activeNonLeadMembers.length > 0) {
+    const activeNames = activeNonLeadMembers.map((m) => m.name).join(", ");
+    return {
+      output: jsonToolResult({
+        message: `Cannot delete team "${teamName}": ${activeNonLeadMembers.length} active member(s) besides lead: ${activeNames}. Ensure all agents have completed their work before deleting the team.`
+      })
+    };
+  }
+  try {
+    deleteTeam(teamName);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      output: jsonToolResult({
+        message: `Failed to delete team "${teamName}": ${errorMessage}`
+      })
+    };
+  }
+  return {
+    output: jsonToolResult({
+      message: `Team "${teamName}" deleted successfully. All team and task directories have been removed.`
+    })
+  };
+};
+
 // ../packages/agent-runtime/src/tools/handlers/list.ts
 var levelcodeToolHandlers = {
   add_message: handleAddMessage,
@@ -29887,6 +30903,13 @@ var levelcodeToolHandlers = {
   str_replace: handleStrReplace,
   suggest_followups: handleSuggestFollowups,
   task_completed: handleTaskCompleted,
+  task_create: handleTaskCreate,
+  task_get: handleTaskGet,
+  task_list: handleTaskList,
+  task_update: handleTaskUpdate,
+  send_message: handleSendMessage,
+  team_create: handleTeamCreate,
+  team_delete: handleTeamDelete,
   think_deeply: handleThinkDeeply,
   update_subgoal: handleUpdateSubgoal,
   web_search: handleWebSearch,
@@ -29895,10 +30918,10 @@ var levelcodeToolHandlers = {
 };
 
 // ../common/src/tools/utils.ts
-function getToolCallString(toolName32, input, ...endsAgentStep32) {
-  const endsAgentStepValue = toolName32 in toolParams ? toolParams[toolName32].endsAgentStep : endsAgentStep32[0] ?? false;
+function getToolCallString(toolName39, input, ...endsAgentStep39) {
+  const endsAgentStepValue = toolName39 in toolParams ? toolParams[toolName39].endsAgentStep : endsAgentStep39[0] ?? false;
   return $getToolCallString({
-    toolName: toolName32,
+    toolName: toolName39,
     inputSchema: null,
     input,
     endsAgentStep: endsAgentStepValue
@@ -29926,7 +30949,7 @@ ${skillsXml}
 
 // ../packages/agent-runtime/src/tools/prompts.ts
 var import_lodash12 = __toESM(require_lodash());
-var import_v459 = __toESM(require("zod/v4"));
+var import_v466 = __toESM(require("zod/v4"));
 function ensureZodSchema(schema) {
   if (schema && typeof schema.safeParse === "function") {
     return schema;
@@ -29935,25 +30958,25 @@ function ensureZodSchema(schema) {
 }
 function ensureJsonSchemaCompatible2(schema) {
   try {
-    import_v459.default.toJSONSchema(schema, { io: "input" });
+    import_v466.default.toJSONSchema(schema, { io: "input" });
     return schema;
   } catch {
-    const fallback = import_v459.default.object({}).passthrough();
+    const fallback = import_v466.default.object({}).passthrough();
     return schema.description ? fallback.describe(schema.description) : fallback;
   }
 }
 function toJsonSchemaSafe(schema) {
   try {
-    return import_v459.default.toJSONSchema(schema, { io: "input" });
+    return import_v466.default.toJSONSchema(schema, { io: "input" });
   } catch {
     return { type: "object", properties: {} };
   }
 }
 function paramsSection(params2) {
-  const { schema, endsAgentStep: endsAgentStep32 } = params2;
+  const { schema, endsAgentStep: endsAgentStep39 } = params2;
   const safeSchema = ensureJsonSchemaCompatible2(schema);
-  const schemaWithEndsAgentStepParam = endsAgentStep32 ? safeSchema.and(import_v459.default.object({
-    [endsAgentStepParam]: import_v459.default.literal(endsAgentStep32).describe("Easp flag must be set to true")
+  const schemaWithEndsAgentStepParam = endsAgentStep39 ? safeSchema.and(import_v466.default.object({
+    [endsAgentStepParam]: import_v466.default.literal(endsAgentStep39).describe("Easp flag must be set to true")
   })) : safeSchema;
   const jsonSchema = toJsonSchemaSafe(schemaWithEndsAgentStepParam);
   delete jsonSchema.description;
@@ -29969,19 +30992,19 @@ function paramsSection(params2) {
 }
 function buildToolDescription(params2) {
   const {
-    toolName: toolName32,
+    toolName: toolName39,
     schema,
-    description: description31 = "",
-    endsAgentStep: endsAgentStep32,
+    description: description38 = "",
+    endsAgentStep: endsAgentStep39,
     exampleInputs = []
   } = params2;
-  const descriptionWithExamples = buildArray(description31, exampleInputs.length > 0 ? `${pluralize(exampleInputs.length, "Example")}:` : "", ...exampleInputs.map((example) => getToolCallString(toolName32, example, endsAgentStep32))).join(`
+  const descriptionWithExamples = buildArray(description38, exampleInputs.length > 0 ? `${pluralize(exampleInputs.length, "Example")}:` : "", ...exampleInputs.map((example) => getToolCallString(toolName39, example, endsAgentStep39))).join(`
 
 `);
   return buildArray([
-    `### ${toolName32}`,
+    `### ${toolName39}`,
     schema.description || "",
-    paramsSection({ schema, endsAgentStep: endsAgentStep32 }),
+    paramsSection({ schema, endsAgentStep: endsAgentStep39 }),
     descriptionWithExamples
   ]).join(`
 
@@ -30000,43 +31023,43 @@ async function getToolSet(params2) {
   const { toolNames: toolNames2, additionalToolDefinitions, agentTools, skills } = params2;
   const availableSkillsXml = formatAvailableSkillsXml(skills);
   const toolSet = {};
-  for (const toolName32 of toolNames2) {
-    if (toolName32 in toolParams) {
-      const toolDef = toolParams[toolName32];
-      if (toolName32 === "skill" && availableSkillsXml) {
-        let description31 = toolDef.description ?? "";
-        description31 = description31.replace(AVAILABLE_SKILLS_PLACEHOLDER, availableSkillsXml);
-        toolSet[toolName32] = {
+  for (const toolName39 of toolNames2) {
+    if (toolName39 in toolParams) {
+      const toolDef = toolParams[toolName39];
+      if (toolName39 === "skill" && availableSkillsXml) {
+        let description38 = toolDef.description ?? "";
+        description38 = description38.replace(AVAILABLE_SKILLS_PLACEHOLDER, availableSkillsXml);
+        toolSet[toolName39] = {
           ...toolDef,
-          description: description31
+          description: description38
         };
-      } else if (toolName32 === "skill") {
-        let description31 = toolDef.description ?? "";
-        description31 = description31.replace(AVAILABLE_SKILLS_PLACEHOLDER + `
+      } else if (toolName39 === "skill") {
+        let description38 = toolDef.description ?? "";
+        description38 = description38.replace(AVAILABLE_SKILLS_PLACEHOLDER + `
 
 `, "");
-        description31 = description31.replace(AVAILABLE_SKILLS_PLACEHOLDER, "");
-        toolSet[toolName32] = {
+        description38 = description38.replace(AVAILABLE_SKILLS_PLACEHOLDER, "");
+        toolSet[toolName39] = {
           ...toolDef,
-          description: description31
+          description: description38
         };
       } else {
-        toolSet[toolName32] = toolDef;
+        toolSet[toolName39] = toolDef;
       }
     }
   }
   const toolDefinitions = await additionalToolDefinitions();
-  for (const [toolName32, toolDefinition] of Object.entries(toolDefinitions)) {
+  for (const [toolName39, toolDefinition] of Object.entries(toolDefinitions)) {
     const clonedDef = import_lodash12.cloneDeep(toolDefinition);
     const zodSchema = ensureZodSchema(clonedDef.inputSchema);
     const safeSchema = ensureJsonSchemaCompatible2(zodSchema);
-    toolSet[toolName32] = {
+    toolSet[toolName39] = {
       ...clonedDef,
       inputSchema: safeSchema
     };
   }
-  for (const [toolName32, toolDefinition] of Object.entries(agentTools)) {
-    toolSet[toolName32] = toolDefinition;
+  for (const [toolName39, toolDefinition] of Object.entries(agentTools)) {
+    toolSet[toolName39] = toolDefinition;
   }
   return toolSet;
 }
@@ -30044,30 +31067,30 @@ async function getToolSet(params2) {
 // ../packages/agent-runtime/src/tools/tool-executor.ts
 function parseRawToolCall(params2) {
   const { rawToolCall } = params2;
-  const toolName32 = rawToolCall.toolName;
+  const toolName39 = rawToolCall.toolName;
   const processedParameters = rawToolCall.input;
-  const paramsSchema = toolParams[toolName32].inputSchema;
+  const paramsSchema = toolParams[toolName39].inputSchema;
   const result = paramsSchema.safeParse(processedParameters);
   if (!result.success) {
     return {
-      toolName: toolName32,
+      toolName: toolName39,
       toolCallId: rawToolCall.toolCallId,
       input: rawToolCall.input,
-      error: `Invalid parameters for ${toolName32}: ${JSON.stringify(result.error.issues, null, 2)}`
+      error: `Invalid parameters for ${toolName39}: ${JSON.stringify(result.error.issues, null, 2)}`
     };
   }
   if (endsAgentStepParam in result.data) {
     delete result.data[endsAgentStepParam];
   }
   return {
-    toolName: toolName32,
+    toolName: toolName39,
     input: result.data,
     toolCallId: rawToolCall.toolCallId
   };
 }
 async function executeToolCall(params2) {
   const {
-    toolName: toolName32,
+    toolName: toolName39,
     input,
     excludeToolFromMessageHistory = false,
     fromHandleSteps = false,
@@ -30086,7 +31109,7 @@ async function executeToolCall(params2) {
   const toolCallId = params2.toolCallId ?? generateCompactId();
   const toolCall = parseRawToolCall({
     rawToolCall: {
-      toolName: toolName32,
+      toolName: toolName39,
       toolCallId,
       input
     }
@@ -30094,7 +31117,7 @@ async function executeToolCall(params2) {
   if (toolCall.toolName && !agentTemplate.toolNames.includes(toolCall.toolName) && !fromHandleSteps) {
     onResponseChunk2({
       type: "error",
-      message: `Tool \`${toolName32}\` is not currently available. Make sure to only use tools provided at the start of the conversation AND that you most recently have permission to use.`
+      message: `Tool \`${toolName39}\` is not currently available. Make sure to only use tools provided at the start of the conversation AND that you most recently have permission to use.`
     });
     return previousToolCallFinished;
   }
@@ -30103,12 +31126,12 @@ async function executeToolCall(params2) {
       type: "error",
       message: toolCall.error
     });
-    logger2.debug({ toolCall, error: toolCall.error }, `${toolName32} error: ${toolCall.error}`);
+    logger2.debug({ toolCall, error: toolCall.error }, `${toolName39} error: ${toolCall.error}`);
     return previousToolCallFinished;
   }
-  const transformedInput = toolName32 === "spawn_agents" ? transformSpawnAgentsInput(input, agentTemplate.spawnableAgents) : input;
+  const transformedInput = toolName39 === "spawn_agents" ? transformSpawnAgentsInput(input, agentTemplate.spawnableAgents) : input;
   let effectiveInput = transformedInput;
-  if (toolName32 === "spawn_agents") {
+  if (toolName39 === "spawn_agents") {
     const agents = transformedInput.agents;
     if (Array.isArray(agents)) {
       const BASE_AGENTS = [
@@ -30170,7 +31193,7 @@ async function executeToolCall(params2) {
         if (validAgents.length === 0) {
           const errorMsg2 = `Failed to spawn agents: ${errors.join("; ")}`;
           onResponseChunk2({ type: "error", message: errorMsg2 });
-          logger2.debug({ toolName: toolName32, errors }, "All agents in spawn_agents are invalid, not streaming tool call");
+          logger2.debug({ toolName: toolName39, errors }, "All agents in spawn_agents are invalid, not streaming tool call");
           return previousToolCallFinished;
         }
         const errorMsg = `Some agents could not be spawned: ${errors.join("; ")}. Proceeding with valid agents only.`;
@@ -30182,15 +31205,15 @@ async function executeToolCall(params2) {
   onResponseChunk2({
     type: "tool_call",
     toolCallId,
-    toolName: toolName32,
+    toolName: toolName39,
     input: effectiveInput,
     agentId: agentState2.agentId,
     parentAgentId: agentState2.parentId,
     includeToolCall: !excludeToolFromMessageHistory
   });
   toolCalls2.push(toolCall);
-  const handler = levelcodeToolHandlers[toolName32];
-  const finalToolCall = toolName32 === "spawn_agents" ? { ...toolCall, input: effectiveInput } : toolCall;
+  const handler = levelcodeToolHandlers[toolName39];
+  const finalToolCall = toolName39 === "spawn_agents" ? { ...toolCall, input: effectiveInput } : toolCall;
   const toolResultPromise = handler({
     ...params2,
     toolCall: finalToolCall,
@@ -30211,7 +31234,7 @@ async function executeToolCall(params2) {
   return toolResultPromise.then(async ({ output, creditsUsed }) => {
     const toolResult2 = {
       role: "tool",
-      toolName: toolName32,
+      toolName: toolName39,
       toolCallId: toolCall.toolCallId,
       content: output
     };
@@ -30227,19 +31250,19 @@ async function executeToolCall(params2) {
     }
     if (creditsUsed) {
       onCostCalculated(creditsUsed);
-      logger2.debug({ credits: creditsUsed, totalCredits: agentState2.creditsUsed }, `Added ${creditsUsed} credits from ${toolName32} to agent state`);
+      logger2.debug({ credits: creditsUsed, totalCredits: agentState2.creditsUsed }, `Added ${creditsUsed} credits from ${toolName39} to agent state`);
     }
   });
 }
 function parseRawCustomToolCall(params2) {
   const { customToolDefs, rawToolCall, autoInsertEndStepParam = false } = params2;
-  const toolName32 = rawToolCall.toolName;
-  if (!(customToolDefs && (toolName32 in customToolDefs)) && !toolName32.includes(MCP_TOOL_SEPARATOR)) {
+  const toolName39 = rawToolCall.toolName;
+  if (!(customToolDefs && (toolName39 in customToolDefs)) && !toolName39.includes(MCP_TOOL_SEPARATOR)) {
     return {
-      toolName: toolName32,
+      toolName: toolName39,
       toolCallId: rawToolCall.toolCallId,
       input: rawToolCall.input,
-      error: `Tool ${toolName32} not found`
+      error: `Tool ${toolName39} not found`
     };
   }
   const processedParameters = {};
@@ -30247,18 +31270,18 @@ function parseRawCustomToolCall(params2) {
     processedParameters[param] = val;
   }
   if (autoInsertEndStepParam) {
-    processedParameters[endsAgentStepParam] = customToolDefs?.[toolName32]?.endsAgentStep;
+    processedParameters[endsAgentStepParam] = customToolDefs?.[toolName39]?.endsAgentStep;
   }
-  const rawSchema = customToolDefs?.[toolName32]?.inputSchema;
+  const rawSchema = customToolDefs?.[toolName39]?.inputSchema;
   if (rawSchema) {
     const paramsSchema = ensureZodSchema(rawSchema);
     const result = paramsSchema.safeParse(processedParameters);
     if (!result.success) {
       return {
-        toolName: toolName32,
+        toolName: toolName39,
         toolCallId: rawToolCall.toolCallId,
         input: rawToolCall.input,
-        error: `Invalid parameters for ${toolName32}: ${JSON.stringify(result.error.issues, null, 2)}`
+        error: `Invalid parameters for ${toolName39}: ${JSON.stringify(result.error.issues, null, 2)}`
       };
     }
   }
@@ -30267,14 +31290,14 @@ function parseRawCustomToolCall(params2) {
     delete input[endsAgentStepParam];
   }
   return {
-    toolName: toolName32,
+    toolName: toolName39,
     input,
     toolCallId: rawToolCall.toolCallId
   };
 }
 async function executeCustomToolCall(params2) {
   const {
-    toolName: toolName32,
+    toolName: toolName39,
     input,
     autoInsertEndStepParam = false,
     excludeToolFromMessageHistory = false,
@@ -30300,7 +31323,7 @@ async function executeCustomToolCall(params2) {
       writeTo: import_lodash13.cloneDeep(fileContext.customToolDefinitions)
     }),
     rawToolCall: {
-      toolName: toolName32,
+      toolName: toolName39,
       toolCallId: toolCallId ?? generateCompactId(),
       input
     },
@@ -30309,7 +31332,7 @@ async function executeCustomToolCall(params2) {
   if (toolCall.toolName && !agentTemplate.toolNames.includes(toolCall.toolName) && !fromHandleSteps && !(toolCall.toolName.includes(MCP_TOOL_SEPARATOR) && (toolCall.toolName.split(MCP_TOOL_SEPARATOR)[0] in agentTemplate.mcpServers))) {
     onResponseChunk2({
       type: "error",
-      message: `Tool \`${toolName32}\` is not currently available. Make sure to only use tools listed in the system instructions.`
+      message: `Tool \`${toolName39}\` is not currently available. Make sure to only use tools listed in the system instructions.`
     });
     return previousToolCallFinished;
   }
@@ -30318,13 +31341,13 @@ async function executeCustomToolCall(params2) {
       type: "error",
       message: toolCall.error
     });
-    logger2.debug({ toolCall, error: toolCall.error }, `${toolName32} error: ${toolCall.error}`);
+    logger2.debug({ toolCall, error: toolCall.error }, `${toolName39} error: ${toolCall.error}`);
     return previousToolCallFinished;
   }
   onResponseChunk2({
     type: "tool_call",
     toolCallId: toolCall.toolCallId,
-    toolName: toolName32,
+    toolName: toolName39,
     input: toolCall.input,
     ...agentState2?.parentId && { agentId: agentState2.agentId },
     ...excludeToolFromMessageHistory && { includeToolCall: false }
@@ -30334,10 +31357,10 @@ async function executeCustomToolCall(params2) {
     if (params2.signal.aborted) {
       return null;
     }
-    const toolName33 = toolCall.toolName.includes(MCP_TOOL_SEPARATOR) ? toolCall.toolName.split(MCP_TOOL_SEPARATOR).slice(1).join(MCP_TOOL_SEPARATOR) : toolCall.toolName;
+    const toolName40 = toolCall.toolName.includes(MCP_TOOL_SEPARATOR) ? toolCall.toolName.split(MCP_TOOL_SEPARATOR).slice(1).join(MCP_TOOL_SEPARATOR) : toolCall.toolName;
     const clientToolResult = await requestToolCall({
       userInputId: userInputId2,
-      toolName: toolName33,
+      toolName: toolName40,
       input: toolCall.input,
       mcpConfig: toolCall.toolName.includes(MCP_TOOL_SEPARATOR) ? agentTemplate.mcpServers[toolCall.toolName.split(MCP_TOOL_SEPARATOR)[0]] : undefined
     });
@@ -30348,11 +31371,11 @@ async function executeCustomToolCall(params2) {
     }
     const toolResult2 = {
       role: "tool",
-      toolName: toolName32,
+      toolName: toolName39,
       toolCallId: toolCall.toolCallId,
       content: result
     };
-    logger2.debug({ input, toolResult: toolResult2 }, `${toolName32} custom tool call & result (${toolResult2.toolCallId})`);
+    logger2.debug({ input, toolResult: toolResult2 }, `${toolName39} custom tool call & result (${toolResult2.toolCallId})`);
     if (result === undefined) {
       return;
     }
@@ -30370,14 +31393,14 @@ async function executeCustomToolCall(params2) {
   });
 }
 function tryTransformAgentToolCall(params2) {
-  const { toolName: toolName32, input, spawnableAgents } = params2;
+  const { toolName: toolName39, input, spawnableAgents } = params2;
   const agentShortNames = spawnableAgents.map(getAgentShortName);
-  if (!agentShortNames.includes(toolName32)) {
+  if (!agentShortNames.includes(toolName39)) {
     return null;
   }
-  const fullAgentType = spawnableAgents.find((agentType) => getAgentShortName(agentType) === toolName32);
+  const fullAgentType = spawnableAgents.find((agentType) => getAgentShortName(agentType) === toolName39);
   const agentEntry = {
-    agent_type: fullAgentType || toolName32
+    agent_type: fullAgentType || toolName39
   };
   if (typeof input.prompt === "string") {
     agentEntry.prompt = input.prompt;
@@ -30406,14 +31429,14 @@ function parseTextWithToolCalls(text) {
     const jsonContent = match[1].trim();
     try {
       const parsed = JSON.parse(jsonContent);
-      const toolName32 = parsed[toolNameParam];
-      if (typeof toolName32 === "string") {
+      const toolName39 = parsed[toolNameParam];
+      if (typeof toolName39 === "string") {
         const input = { ...parsed };
         delete input[toolNameParam];
         delete input["cb_easp"];
         segments.push({
           type: "tool_call",
-          toolName: toolName32,
+          toolName: toolName39,
           input
         });
       }
@@ -30785,7 +31808,7 @@ function isKnowledgeFile(filePath) {
 }
 
 // ../packages/agent-runtime/src/templates/strings.ts
-var import_v460 = require("zod/v4");
+var import_v467 = require("zod/v4");
 
 // ../packages/agent-runtime/src/templates/types.ts
 var placeholderNames = [
@@ -30866,10 +31889,10 @@ async function formatPrompt(params2) {
       ...Object.fromEntries(Object.entries(fileContext.knowledgeFiles).filter(([filePath]) => {
         const lowerPath = filePath.toLowerCase();
         return KNOWLEDGE_FILE_NAMES_LOWERCASE.includes(lowerPath);
-      }).map(([path4, content]) => [path4, content.trim()])),
+      }).map(([path6, content]) => [path6, content.trim()])),
       ...fileContext.userKnowledgeFiles
-    }).map(([path4, content]) => {
-      return `\`\`\`${path4}
+    }).map(([path6, content]) => {
+      return `\`\`\`${path6}
 ${content.trim()}
 \`\`\``;
     }).join(`
@@ -30949,7 +31972,7 @@ ${agentDescriptions.join(`
 `;
       addendum += "```json\n";
       try {
-        const jsonSchema = import_v460.z.toJSONSchema(outputSchema3, {
+        const jsonSchema = import_v467.z.toJSONSchema(outputSchema3, {
           io: "input"
         });
         delete jsonSchema["$schema"];
@@ -31030,14 +32053,14 @@ function parseToolCallContent(content) {
   }
   try {
     const parsed = JSON.parse(trimmed);
-    const toolName32 = parsed[toolNameParam];
-    if (typeof toolName32 !== "string") {
+    const toolName39 = parsed[toolNameParam];
+    if (typeof toolName39 !== "string") {
       return null;
     }
     const input = { ...parsed };
     delete input[toolNameParam];
     delete input["cb_easp"];
-    return { toolName: toolName32, input };
+    return { toolName: toolName39, input };
   } catch {
     return null;
   }
@@ -31072,13 +32095,13 @@ async function* processStreamWithTools(params2) {
   let autocompleted = false;
   const xmlParserState = createStreamParserState();
   function processToolCallObject(params3) {
-    const { toolName: toolName32, input, contents } = params3;
-    const processor = processors[toolName32] ?? defaultProcessor(toolName32);
+    const { toolName: toolName39, input, contents } = params3;
+    const processor = processors[toolName39] ?? defaultProcessor(toolName39);
     trackEvent2({
       event: "backend.tool_use" /* TOOL_USE */,
       userId: loggerOptions?.userId ?? "",
       properties: {
-        toolName: toolName32,
+        toolName: toolName39,
         contents,
         parsedParams: input,
         autocompleted,
@@ -31087,8 +32110,8 @@ async function* processStreamWithTools(params2) {
       },
       logger: logger2
     });
-    processor.onTagStart(toolName32, {});
-    processor.onTagEnd(toolName32, input);
+    processor.onTagStart(toolName39, {});
+    processor.onTagEnd(toolName39, input);
   }
   function flush() {
     if (buffer) {
@@ -31203,7 +32226,7 @@ async function processStream(params2) {
       return onResponseChunk2(chunk);
     };
   }
-  function createToolExecutionCallback(toolName32, isXmlMode) {
+  function createToolExecutionCallback(toolName39, isXmlMode) {
     const responseHandler = createResponseHandler(isXmlMode);
     const resultsArray = isXmlMode ? [] : toolResultsToAddAfterStream;
     return {
@@ -31213,9 +32236,9 @@ async function processStream(params2) {
           return;
         }
         const toolCallId = generateCompactId();
-        const isNativeTool = toolNames.includes(toolName32);
+        const isNativeTool = toolNames.includes(toolName39);
         const transformed = !isNativeTool ? tryTransformAgentToolCall({
-          toolName: toolName32,
+          toolName: toolName39,
           input,
           spawnableAgents: agentTemplate.spawnableAgents
         }) : null;
@@ -31224,7 +32247,7 @@ async function processStream(params2) {
         if (isNativeTool || transformed) {
           toolPromise = executeToolCall({
             ...params2,
-            toolName: transformed ? transformed.toolName : toolName32,
+            toolName: transformed ? transformed.toolName : toolName39,
             input: transformed ? transformed.input : input,
             fromHandleSteps: false,
             skipDirectResultPush: isXmlMode,
@@ -31241,7 +32264,7 @@ async function processStream(params2) {
         } else {
           toolPromise = executeCustomToolCall({
             ...params2,
-            toolName: toolName32,
+            toolName: toolName39,
             input,
             skipDirectResultPush: isXmlMode,
             fileProcessingState: fileProcessingState2,
@@ -31274,10 +32297,10 @@ async function processStream(params2) {
       ])
     ]),
     defaultProcessor: (name) => createToolExecutionCallback(name, false),
-    onError: (toolName32, error) => {
+    onError: (toolName39, error) => {
       const toolResult2 = {
         role: "tool",
-        toolName: toolName32,
+        toolName: toolName39,
         toolCallId: generateCompactId(),
         content: jsonToolResult({ errorMessage: error })
       };
@@ -31299,12 +32322,12 @@ async function processStream(params2) {
       }
       return onResponseChunk2(chunk);
     },
-    executeXmlToolCall: async ({ toolName: toolName32, input }) => {
+    executeXmlToolCall: async ({ toolName: toolName39, input }) => {
       if (signal.aborted) {
         return;
       }
-      const callback = createToolExecutionCallback(toolName32, true);
-      await callback.onTagEnd(toolName32, input);
+      const callback = createToolExecutionCallback(toolName39, true);
+      await callback.onTagEnd(toolName39, input);
     }
   });
   let messageId = null;
@@ -31422,7 +32445,7 @@ function getAgentOutput(agentState2, agentTemplate) {
 // ../packages/agent-runtime/src/run-agent-step.ts
 async function additionalToolDefinitions(params2) {
   const { agentTemplate, fileContext } = params2;
-  const defs = import_lodash16.cloneDeep(Object.fromEntries(Object.entries(fileContext.customToolDefinitions).filter(([toolName32]) => agentTemplate.toolNames.includes(toolName32))));
+  const defs = import_lodash16.cloneDeep(Object.fromEntries(Object.entries(fileContext.customToolDefinitions).filter(([toolName39]) => agentTemplate.toolNames.includes(toolName39))));
   return getMCPToolData({
     ...params2,
     toolNames: agentTemplate.toolNames,
@@ -33253,8 +34276,8 @@ class Client extends Protocol {
       }
     }
   }
-  getToolOutputValidator(toolName32) {
-    return this._cachedToolOutputValidators.get(toolName32);
+  getToolOutputValidator(toolName39) {
+    return this._cachedToolOutputValidators.get(toolName39);
   }
   async listTools(params2, options) {
     const result = await this.request({ method: "tools/list", params: params2 }, ListToolsResultSchema, options);
@@ -35226,7 +36249,7 @@ var getCiEnv = () => ({
 var ciEnv = getCiEnv();
 
 // src/impl/database.ts
-var import_v461 = __toESM(require("zod/v4"));
+var import_v468 = __toESM(require("zod/v4"));
 
 // src/constants.ts
 var LEVELCODE_BINARY = "levelcode";
@@ -35392,8 +36415,8 @@ var RECONNECTION_RETRY_DELAY_MS = 500;
 
 // src/impl/database.ts
 var userInfoCache = {};
-var agentsResponseSchema = import_v461.default.object({
-  version: import_v461.default.string(),
+var agentsResponseSchema = import_v468.default.object({
+  version: import_v468.default.string(),
   data: DynamicAgentTemplateSchema
 });
 async function fetchWithRetry(url, options, logger2) {
@@ -36132,30 +37155,30 @@ function loadApiKey({
   apiKey,
   environmentVariableName,
   apiKeyParameterName = "apiKey",
-  description: description31
+  description: description38
 }) {
   if (typeof apiKey === "string") {
     return apiKey;
   }
   if (apiKey != null) {
     throw new LoadAPIKeyError({
-      message: `${description31} API key must be a string.`
+      message: `${description38} API key must be a string.`
     });
   }
   if (typeof process === "undefined") {
     throw new LoadAPIKeyError({
-      message: `${description31} API key is missing. Pass it using the '${apiKeyParameterName}' parameter. Environment variables is not supported in this environment.`
+      message: `${description38} API key is missing. Pass it using the '${apiKeyParameterName}' parameter. Environment variables is not supported in this environment.`
     });
   }
   apiKey = process.env[environmentVariableName];
   if (apiKey == null) {
     throw new LoadAPIKeyError({
-      message: `${description31} API key is missing. Pass it using the '${apiKeyParameterName}' parameter or the ${environmentVariableName} environment variable.`
+      message: `${description38} API key is missing. Pass it using the '${apiKeyParameterName}' parameter or the ${environmentVariableName} environment variable.`
     });
   }
   if (typeof apiKey !== "string") {
     throw new LoadAPIKeyError({
-      message: `${description31} API key must be a string. The value of the ${environmentVariableName} environment variable is not a string.`
+      message: `${description38} API key must be a string. The value of the ${environmentVariableName} environment variable is not a string.`
     });
   }
   return apiKey;
@@ -36541,7 +37564,7 @@ function withoutTrailingSlash(url) {
 }
 
 // ../packages/internal/src/openai-compatible/chat/openai-compatible-chat-language-model.ts
-var import_v464 = require("zod/v4");
+var import_v471 = require("zod/v4");
 
 // ../packages/internal/src/openai-compatible/chat/convert-to-openai-compatible-chat-messages.ts
 function getOpenAIMetadata(message) {
@@ -36684,21 +37707,21 @@ function mapOpenAICompatibleFinishReason(finishReason) {
 }
 
 // ../packages/internal/src/openai-compatible/chat/openai-compatible-chat-options.ts
-var import_v462 = require("zod/v4");
-var openaiCompatibleProviderOptions = import_v462.z.object({
-  user: import_v462.z.string().optional(),
-  reasoningEffort: import_v462.z.string().optional(),
-  textVerbosity: import_v462.z.string().optional()
+var import_v469 = require("zod/v4");
+var openaiCompatibleProviderOptions = import_v469.z.object({
+  user: import_v469.z.string().optional(),
+  reasoningEffort: import_v469.z.string().optional(),
+  textVerbosity: import_v469.z.string().optional()
 });
 
 // ../packages/internal/src/openai-compatible/openai-compatible-error.ts
-var import_v463 = require("zod/v4");
-var openaiCompatibleErrorDataSchema = import_v463.z.object({
-  error: import_v463.z.object({
-    message: import_v463.z.string(),
-    type: import_v463.z.string().nullish(),
-    param: import_v463.z.any().nullish(),
-    code: import_v463.z.union([import_v463.z.string(), import_v463.z.number()]).nullish()
+var import_v470 = require("zod/v4");
+var openaiCompatibleErrorDataSchema = import_v470.z.object({
+  error: import_v470.z.object({
+    message: import_v470.z.string(),
+    type: import_v470.z.string().nullish(),
+    param: import_v470.z.any().nullish(),
+    code: import_v470.z.union([import_v470.z.string(), import_v470.z.number()]).nullish()
   })
 });
 var defaultOpenAICompatibleErrorStructure = {
@@ -37184,62 +38207,62 @@ class OpenAICompatibleChatLanguageModel {
     };
   }
 }
-var openaiCompatibleTokenUsageSchema = import_v464.z.object({
-  prompt_tokens: import_v464.z.number().nullish(),
-  completion_tokens: import_v464.z.number().nullish(),
-  total_tokens: import_v464.z.number().nullish(),
-  prompt_tokens_details: import_v464.z.object({
-    cached_tokens: import_v464.z.number().nullish()
+var openaiCompatibleTokenUsageSchema = import_v471.z.object({
+  prompt_tokens: import_v471.z.number().nullish(),
+  completion_tokens: import_v471.z.number().nullish(),
+  total_tokens: import_v471.z.number().nullish(),
+  prompt_tokens_details: import_v471.z.object({
+    cached_tokens: import_v471.z.number().nullish()
   }).nullish(),
-  completion_tokens_details: import_v464.z.object({
-    reasoning_tokens: import_v464.z.number().nullish(),
-    accepted_prediction_tokens: import_v464.z.number().nullish(),
-    rejected_prediction_tokens: import_v464.z.number().nullish()
+  completion_tokens_details: import_v471.z.object({
+    reasoning_tokens: import_v471.z.number().nullish(),
+    accepted_prediction_tokens: import_v471.z.number().nullish(),
+    rejected_prediction_tokens: import_v471.z.number().nullish()
   }).nullish()
 }).nullish();
-var OpenAICompatibleChatResponseSchema = import_v464.z.object({
-  id: import_v464.z.string().nullish(),
-  created: import_v464.z.number().nullish(),
-  model: import_v464.z.string().nullish(),
-  choices: import_v464.z.array(import_v464.z.object({
-    message: import_v464.z.object({
-      role: import_v464.z.literal("assistant").nullish(),
-      content: import_v464.z.string().nullish(),
-      reasoning_content: import_v464.z.string().nullish(),
-      reasoning: import_v464.z.string().nullish(),
-      tool_calls: import_v464.z.array(import_v464.z.object({
-        id: import_v464.z.string().nullish(),
-        function: import_v464.z.object({
-          name: import_v464.z.string(),
-          arguments: import_v464.z.string()
+var OpenAICompatibleChatResponseSchema = import_v471.z.object({
+  id: import_v471.z.string().nullish(),
+  created: import_v471.z.number().nullish(),
+  model: import_v471.z.string().nullish(),
+  choices: import_v471.z.array(import_v471.z.object({
+    message: import_v471.z.object({
+      role: import_v471.z.literal("assistant").nullish(),
+      content: import_v471.z.string().nullish(),
+      reasoning_content: import_v471.z.string().nullish(),
+      reasoning: import_v471.z.string().nullish(),
+      tool_calls: import_v471.z.array(import_v471.z.object({
+        id: import_v471.z.string().nullish(),
+        function: import_v471.z.object({
+          name: import_v471.z.string(),
+          arguments: import_v471.z.string()
         })
       })).nullish()
     }),
-    finish_reason: import_v464.z.string().nullish()
+    finish_reason: import_v471.z.string().nullish()
   })),
   usage: openaiCompatibleTokenUsageSchema
 });
-var createOpenAICompatibleChatChunkSchema = (errorSchema) => import_v464.z.union([
-  import_v464.z.object({
-    id: import_v464.z.string().nullish(),
-    created: import_v464.z.number().nullish(),
-    model: import_v464.z.string().nullish(),
-    choices: import_v464.z.array(import_v464.z.object({
-      delta: import_v464.z.object({
-        role: import_v464.z.enum(["assistant"]).nullish(),
-        content: import_v464.z.string().nullish(),
-        reasoning_content: import_v464.z.string().nullish(),
-        reasoning: import_v464.z.string().nullish(),
-        tool_calls: import_v464.z.array(import_v464.z.object({
-          index: import_v464.z.number(),
-          id: import_v464.z.string().nullish(),
-          function: import_v464.z.object({
-            name: import_v464.z.string().nullish(),
-            arguments: import_v464.z.string().nullish()
+var createOpenAICompatibleChatChunkSchema = (errorSchema) => import_v471.z.union([
+  import_v471.z.object({
+    id: import_v471.z.string().nullish(),
+    created: import_v471.z.number().nullish(),
+    model: import_v471.z.string().nullish(),
+    choices: import_v471.z.array(import_v471.z.object({
+      delta: import_v471.z.object({
+        role: import_v471.z.enum(["assistant"]).nullish(),
+        content: import_v471.z.string().nullish(),
+        reasoning_content: import_v471.z.string().nullish(),
+        reasoning: import_v471.z.string().nullish(),
+        tool_calls: import_v471.z.array(import_v471.z.object({
+          index: import_v471.z.number(),
+          id: import_v471.z.string().nullish(),
+          function: import_v471.z.object({
+            name: import_v471.z.string().nullish(),
+            arguments: import_v471.z.string().nullish()
           })
         })).nullish()
       }).nullish(),
-      finish_reason: import_v464.z.string().nullish()
+      finish_reason: import_v471.z.string().nullish()
     })),
     usage: openaiCompatibleTokenUsageSchema
   }),
@@ -37280,30 +38303,30 @@ function getFileUrl({
 }
 
 // ../packages/internal/src/openrouter-ai-sdk/schemas/reasoning-details.ts
-var import_v465 = require("zod/v4");
-var ReasoningDetailSummarySchema = import_v465.z.object({
-  type: import_v465.z.literal("reasoning.summary" /* Summary */),
-  summary: import_v465.z.string()
+var import_v472 = require("zod/v4");
+var ReasoningDetailSummarySchema = import_v472.z.object({
+  type: import_v472.z.literal("reasoning.summary" /* Summary */),
+  summary: import_v472.z.string()
 });
-var ReasoningDetailEncryptedSchema = import_v465.z.object({
-  type: import_v465.z.literal("reasoning.encrypted" /* Encrypted */),
-  data: import_v465.z.string()
+var ReasoningDetailEncryptedSchema = import_v472.z.object({
+  type: import_v472.z.literal("reasoning.encrypted" /* Encrypted */),
+  data: import_v472.z.string()
 });
-var ReasoningDetailTextSchema = import_v465.z.object({
-  type: import_v465.z.literal("reasoning.text" /* Text */),
-  text: import_v465.z.string().nullish(),
-  signature: import_v465.z.string().nullish()
+var ReasoningDetailTextSchema = import_v472.z.object({
+  type: import_v472.z.literal("reasoning.text" /* Text */),
+  text: import_v472.z.string().nullish(),
+  signature: import_v472.z.string().nullish()
 });
-var ReasoningDetailUnionSchema = import_v465.z.union([
+var ReasoningDetailUnionSchema = import_v472.z.union([
   ReasoningDetailSummarySchema,
   ReasoningDetailEncryptedSchema,
   ReasoningDetailTextSchema
 ]);
-var ReasoningDetailsWithUnknownSchema = import_v465.z.union([
+var ReasoningDetailsWithUnknownSchema = import_v472.z.union([
   ReasoningDetailUnionSchema,
-  import_v465.z.unknown().transform(() => null)
+  import_v472.z.unknown().transform(() => null)
 ]);
-var ReasoningDetailArraySchema = import_v465.z.array(ReasoningDetailsWithUnknownSchema).transform((d) => d.filter((d2) => !!d2));
+var ReasoningDetailArraySchema = import_v472.z.array(ReasoningDetailsWithUnknownSchema).transform((d) => d.filter((d2) => !!d2));
 
 // ../packages/internal/src/openrouter-ai-sdk/chat/convert-to-openrouter-chat-messages.ts
 function getCacheControl(providerMetadata) {
@@ -37460,15 +38483,15 @@ function getToolResultContent(input) {
 }
 
 // ../packages/internal/src/openrouter-ai-sdk/chat/get-tool-choice.ts
-var import_v466 = require("zod/v4");
-var ChatCompletionToolChoiceSchema = import_v466.z.union([
-  import_v466.z.literal("auto"),
-  import_v466.z.literal("none"),
-  import_v466.z.literal("required"),
-  import_v466.z.object({
-    type: import_v466.z.literal("function"),
-    function: import_v466.z.object({
-      name: import_v466.z.string()
+var import_v473 = require("zod/v4");
+var ChatCompletionToolChoiceSchema = import_v473.z.union([
+  import_v473.z.literal("auto"),
+  import_v473.z.literal("none"),
+  import_v473.z.literal("required"),
+  import_v473.z.object({
+    type: import_v473.z.literal("function"),
+    function: import_v473.z.object({
+      name: import_v473.z.string()
     })
   })
 ]);
@@ -37491,16 +38514,16 @@ function getChatCompletionToolChoice(toolChoice) {
 }
 
 // ../packages/internal/src/openrouter-ai-sdk/chat/schemas.ts
-var import_v468 = require("zod/v4");
+var import_v475 = require("zod/v4");
 
 // ../packages/internal/src/openrouter-ai-sdk/schemas/error-response.ts
-var import_v467 = require("zod/v4");
-var OpenRouterErrorResponseSchema = import_v467.z.object({
-  error: import_v467.z.object({
-    code: import_v467.z.union([import_v467.z.string(), import_v467.z.number()]).nullable().optional().default(null),
-    message: import_v467.z.string(),
-    type: import_v467.z.string().nullable().optional().default(null),
-    param: import_v467.z.any().nullable().optional().default(null)
+var import_v474 = require("zod/v4");
+var OpenRouterErrorResponseSchema = import_v474.z.object({
+  error: import_v474.z.object({
+    code: import_v474.z.union([import_v474.z.string(), import_v474.z.number()]).nullable().optional().default(null),
+    message: import_v474.z.string(),
+    type: import_v474.z.string().nullable().optional().default(null),
+    param: import_v474.z.any().nullable().optional().default(null)
   })
 });
 var openrouterFailedResponseHandler = createJsonErrorResponseHandler({
@@ -37509,106 +38532,106 @@ var openrouterFailedResponseHandler = createJsonErrorResponseHandler({
 });
 
 // ../packages/internal/src/openrouter-ai-sdk/chat/schemas.ts
-var OpenRouterChatCompletionBaseResponseSchema = import_v468.z.object({
-  id: import_v468.z.string().optional(),
-  model: import_v468.z.string().optional(),
-  provider: import_v468.z.string().optional(),
-  usage: import_v468.z.object({
-    prompt_tokens: import_v468.z.number(),
-    prompt_tokens_details: import_v468.z.object({
-      cached_tokens: import_v468.z.number()
+var OpenRouterChatCompletionBaseResponseSchema = import_v475.z.object({
+  id: import_v475.z.string().optional(),
+  model: import_v475.z.string().optional(),
+  provider: import_v475.z.string().optional(),
+  usage: import_v475.z.object({
+    prompt_tokens: import_v475.z.number(),
+    prompt_tokens_details: import_v475.z.object({
+      cached_tokens: import_v475.z.number()
     }).nullish(),
-    completion_tokens: import_v468.z.number(),
-    completion_tokens_details: import_v468.z.object({
-      reasoning_tokens: import_v468.z.number()
+    completion_tokens: import_v475.z.number(),
+    completion_tokens_details: import_v475.z.object({
+      reasoning_tokens: import_v475.z.number()
     }).nullish(),
-    total_tokens: import_v468.z.number(),
-    cost: import_v468.z.number().optional(),
-    cost_details: import_v468.z.object({
-      upstream_inference_cost: import_v468.z.number().nullish()
+    total_tokens: import_v475.z.number(),
+    cost: import_v475.z.number().optional(),
+    cost_details: import_v475.z.object({
+      upstream_inference_cost: import_v475.z.number().nullish()
     }).nullish()
   }).nullish()
 });
 var OpenRouterNonStreamChatCompletionResponseSchema = OpenRouterChatCompletionBaseResponseSchema.extend({
-  choices: import_v468.z.array(import_v468.z.object({
-    message: import_v468.z.object({
-      role: import_v468.z.literal("assistant"),
-      content: import_v468.z.string().nullable().optional(),
-      reasoning: import_v468.z.string().nullable().optional(),
+  choices: import_v475.z.array(import_v475.z.object({
+    message: import_v475.z.object({
+      role: import_v475.z.literal("assistant"),
+      content: import_v475.z.string().nullable().optional(),
+      reasoning: import_v475.z.string().nullable().optional(),
       reasoning_details: ReasoningDetailArraySchema.nullish(),
-      tool_calls: import_v468.z.array(import_v468.z.object({
-        id: import_v468.z.string().optional().nullable(),
-        type: import_v468.z.literal("function"),
-        function: import_v468.z.object({
-          name: import_v468.z.string(),
-          arguments: import_v468.z.string()
+      tool_calls: import_v475.z.array(import_v475.z.object({
+        id: import_v475.z.string().optional().nullable(),
+        type: import_v475.z.literal("function"),
+        function: import_v475.z.object({
+          name: import_v475.z.string(),
+          arguments: import_v475.z.string()
         })
       })).optional(),
-      annotations: import_v468.z.array(import_v468.z.object({
-        type: import_v468.z.enum(["url_citation"]),
-        url_citation: import_v468.z.object({
-          end_index: import_v468.z.number(),
-          start_index: import_v468.z.number(),
-          title: import_v468.z.string(),
-          url: import_v468.z.string(),
-          content: import_v468.z.string().optional()
+      annotations: import_v475.z.array(import_v475.z.object({
+        type: import_v475.z.enum(["url_citation"]),
+        url_citation: import_v475.z.object({
+          end_index: import_v475.z.number(),
+          start_index: import_v475.z.number(),
+          title: import_v475.z.string(),
+          url: import_v475.z.string(),
+          content: import_v475.z.string().optional()
         })
       })).nullish()
     }),
-    index: import_v468.z.number().nullish(),
-    logprobs: import_v468.z.object({
-      content: import_v468.z.array(import_v468.z.object({
-        token: import_v468.z.string(),
-        logprob: import_v468.z.number(),
-        top_logprobs: import_v468.z.array(import_v468.z.object({
-          token: import_v468.z.string(),
-          logprob: import_v468.z.number()
+    index: import_v475.z.number().nullish(),
+    logprobs: import_v475.z.object({
+      content: import_v475.z.array(import_v475.z.object({
+        token: import_v475.z.string(),
+        logprob: import_v475.z.number(),
+        top_logprobs: import_v475.z.array(import_v475.z.object({
+          token: import_v475.z.string(),
+          logprob: import_v475.z.number()
         }))
       })).nullable()
     }).nullable().optional(),
-    finish_reason: import_v468.z.string().optional().nullable()
+    finish_reason: import_v475.z.string().optional().nullable()
   }))
 });
-var OpenRouterStreamChatCompletionChunkSchema = import_v468.z.union([
+var OpenRouterStreamChatCompletionChunkSchema = import_v475.z.union([
   OpenRouterChatCompletionBaseResponseSchema.extend({
-    choices: import_v468.z.array(import_v468.z.object({
-      delta: import_v468.z.object({
-        role: import_v468.z.enum(["assistant"]).optional(),
-        content: import_v468.z.string().nullish(),
-        reasoning: import_v468.z.string().nullish().optional(),
+    choices: import_v475.z.array(import_v475.z.object({
+      delta: import_v475.z.object({
+        role: import_v475.z.enum(["assistant"]).optional(),
+        content: import_v475.z.string().nullish(),
+        reasoning: import_v475.z.string().nullish().optional(),
         reasoning_details: ReasoningDetailArraySchema.nullish(),
-        tool_calls: import_v468.z.array(import_v468.z.object({
-          index: import_v468.z.number().nullish(),
-          id: import_v468.z.string().nullish(),
-          type: import_v468.z.literal("function").optional(),
-          function: import_v468.z.object({
-            name: import_v468.z.string().nullish(),
-            arguments: import_v468.z.string().nullish()
+        tool_calls: import_v475.z.array(import_v475.z.object({
+          index: import_v475.z.number().nullish(),
+          id: import_v475.z.string().nullish(),
+          type: import_v475.z.literal("function").optional(),
+          function: import_v475.z.object({
+            name: import_v475.z.string().nullish(),
+            arguments: import_v475.z.string().nullish()
           })
         })).nullish(),
-        annotations: import_v468.z.array(import_v468.z.object({
-          type: import_v468.z.enum(["url_citation"]),
-          url_citation: import_v468.z.object({
-            end_index: import_v468.z.number(),
-            start_index: import_v468.z.number(),
-            title: import_v468.z.string(),
-            url: import_v468.z.string(),
-            content: import_v468.z.string().optional()
+        annotations: import_v475.z.array(import_v475.z.object({
+          type: import_v475.z.enum(["url_citation"]),
+          url_citation: import_v475.z.object({
+            end_index: import_v475.z.number(),
+            start_index: import_v475.z.number(),
+            title: import_v475.z.string(),
+            url: import_v475.z.string(),
+            content: import_v475.z.string().optional()
           })
         })).nullish()
       }).nullish(),
-      logprobs: import_v468.z.object({
-        content: import_v468.z.array(import_v468.z.object({
-          token: import_v468.z.string(),
-          logprob: import_v468.z.number(),
-          top_logprobs: import_v468.z.array(import_v468.z.object({
-            token: import_v468.z.string(),
-            logprob: import_v468.z.number()
+      logprobs: import_v475.z.object({
+        content: import_v475.z.array(import_v475.z.object({
+          token: import_v475.z.string(),
+          logprob: import_v475.z.number(),
+          top_logprobs: import_v475.z.array(import_v475.z.object({
+            token: import_v475.z.string(),
+            logprob: import_v475.z.number()
           }))
         })).nullable()
       }).nullish(),
-      finish_reason: import_v468.z.string().nullable().optional(),
-      index: import_v468.z.number().nullish()
+      finish_reason: import_v475.z.string().nullable().optional(),
+      index: import_v475.z.number().nullish()
     }))
   }),
   OpenRouterErrorResponseSchema
@@ -38309,34 +39332,34 @@ ${assistantMessage2}
 }
 
 // ../packages/internal/src/openrouter-ai-sdk/completion/schemas.ts
-var import_v469 = require("zod/v4");
-var OpenRouterCompletionChunkSchema = import_v469.z.union([
-  import_v469.z.object({
-    id: import_v469.z.string().optional(),
-    model: import_v469.z.string().optional(),
-    choices: import_v469.z.array(import_v469.z.object({
-      text: import_v469.z.string(),
-      reasoning: import_v469.z.string().nullish().optional(),
+var import_v476 = require("zod/v4");
+var OpenRouterCompletionChunkSchema = import_v476.z.union([
+  import_v476.z.object({
+    id: import_v476.z.string().optional(),
+    model: import_v476.z.string().optional(),
+    choices: import_v476.z.array(import_v476.z.object({
+      text: import_v476.z.string(),
+      reasoning: import_v476.z.string().nullish().optional(),
       reasoning_details: ReasoningDetailArraySchema.nullish(),
-      finish_reason: import_v469.z.string().nullish(),
-      index: import_v469.z.number().nullish(),
-      logprobs: import_v469.z.object({
-        tokens: import_v469.z.array(import_v469.z.string()),
-        token_logprobs: import_v469.z.array(import_v469.z.number()),
-        top_logprobs: import_v469.z.array(import_v469.z.record(import_v469.z.string(), import_v469.z.number())).nullable()
+      finish_reason: import_v476.z.string().nullish(),
+      index: import_v476.z.number().nullish(),
+      logprobs: import_v476.z.object({
+        tokens: import_v476.z.array(import_v476.z.string()),
+        token_logprobs: import_v476.z.array(import_v476.z.number()),
+        top_logprobs: import_v476.z.array(import_v476.z.record(import_v476.z.string(), import_v476.z.number())).nullable()
       }).nullable().optional()
     })),
-    usage: import_v469.z.object({
-      prompt_tokens: import_v469.z.number(),
-      prompt_tokens_details: import_v469.z.object({
-        cached_tokens: import_v469.z.number()
+    usage: import_v476.z.object({
+      prompt_tokens: import_v476.z.number(),
+      prompt_tokens_details: import_v476.z.object({
+        cached_tokens: import_v476.z.number()
       }).nullish(),
-      completion_tokens: import_v469.z.number(),
-      completion_tokens_details: import_v469.z.object({
-        reasoning_tokens: import_v469.z.number()
+      completion_tokens: import_v476.z.number(),
+      completion_tokens_details: import_v476.z.object({
+        reasoning_tokens: import_v476.z.number()
       }).nullish(),
-      total_tokens: import_v469.z.number(),
-      cost: import_v469.z.number().optional()
+      total_tokens: import_v476.z.number(),
+      cost: import_v476.z.number().optional()
     }).nullish()
   }),
   OpenRouterErrorResponseSchema
@@ -38578,7 +39601,7 @@ function createOpenRouter(options = {}) {
   });
   const createChatModel = (modelId, settings = {}) => new OpenRouterChatLanguageModel(modelId, settings, {
     provider: "openrouter.chat",
-    url: ({ path: path4 }) => `${baseURL}${path4}`,
+    url: ({ path: path6 }) => `${baseURL}${path6}`,
     headers: getHeaders,
     compatibility,
     fetch: options.fetch,
@@ -38586,7 +39609,7 @@ function createOpenRouter(options = {}) {
   });
   const createCompletionModel = (modelId, settings = {}) => new OpenRouterCompletionLanguageModel(modelId, settings, {
     provider: "openrouter.completion",
-    url: ({ path: path4 }) => `${baseURL}${path4}`,
+    url: ({ path: path6 }) => `${baseURL}${path6}`,
     headers: getHeaders,
     compatibility,
     fetch: options.fetch,
@@ -38617,25 +39640,25 @@ var import_node_path = __toESM(require("node:path"));
 var import_os = __toESM(require("os"));
 
 // ../common/src/util/credentials.ts
-var import_v470 = require("zod/v4");
-var userSchema = import_v470.z.object({
-  id: import_v470.z.string(),
-  email: import_v470.z.string(),
-  name: import_v470.z.string().nullable(),
-  authToken: import_v470.z.string(),
-  fingerprintId: import_v470.z.string(),
-  fingerprintHash: import_v470.z.string()
+var import_v477 = require("zod/v4");
+var userSchema = import_v477.z.object({
+  id: import_v477.z.string(),
+  email: import_v477.z.string(),
+  name: import_v477.z.string().nullable(),
+  authToken: import_v477.z.string(),
+  fingerprintId: import_v477.z.string(),
+  fingerprintHash: import_v477.z.string()
 });
 
 // src/credentials.ts
-var import_v471 = require("zod/v4");
-var claudeOAuthSchema = import_v471.z.object({
-  accessToken: import_v471.z.string(),
-  refreshToken: import_v471.z.string(),
-  expiresAt: import_v471.z.number(),
-  connectedAt: import_v471.z.number()
+var import_v478 = require("zod/v4");
+var claudeOAuthSchema = import_v478.z.object({
+  accessToken: import_v478.z.string(),
+  refreshToken: import_v478.z.string(),
+  expiresAt: import_v478.z.number(),
+  connectedAt: import_v478.z.number()
 });
-var credentialsFileSchema = import_v471.z.object({
+var credentialsFileSchema = import_v478.z.object({
   default: userSchema.optional(),
   claudeOAuth: claudeOAuthSchema.optional()
 });
@@ -38652,11 +39675,29 @@ var userFromJson = (json) => {
     return null;
   }
 };
+var getLegacyConfigDir = (clientEnv = env) => {
+  const envSuffix = clientEnv.NEXT_PUBLIC_CB_ENVIRONMENT && clientEnv.NEXT_PUBLIC_CB_ENVIRONMENT !== "prod" ? `-${clientEnv.NEXT_PUBLIC_CB_ENVIRONMENT}` : "";
+  return import_node_path.default.join(import_os.default.homedir(), ".config", `manicode${envSuffix}`);
+};
 var getConfigDir = (clientEnv = env) => {
   const envSuffix = clientEnv.NEXT_PUBLIC_CB_ENVIRONMENT && clientEnv.NEXT_PUBLIC_CB_ENVIRONMENT !== "prod" ? `-${clientEnv.NEXT_PUBLIC_CB_ENVIRONMENT}` : "";
   return import_node_path.default.join(import_os.default.homedir(), ".config", `levelcode${envSuffix}`);
 };
+var migrateFromLegacyConfigDir = (clientEnv = env) => {
+  const newDir = getConfigDir(clientEnv);
+  const newCredsPath = import_node_path.default.join(newDir, "credentials.json");
+  if (import_fs.default.existsSync(newCredsPath))
+    return;
+  const legacyCredsPath = import_node_path.default.join(getLegacyConfigDir(clientEnv), "credentials.json");
+  if (!import_fs.default.existsSync(legacyCredsPath))
+    return;
+  try {
+    ensureDirectoryExistsSync(newDir);
+    import_fs.default.copyFileSync(legacyCredsPath, newCredsPath);
+  } catch {}
+};
 var getCredentialsPath = (clientEnv = env) => {
+  migrateFromLegacyConfigDir(clientEnv);
   return import_node_path.default.join(getConfigDir(clientEnv), "credentials.json");
 };
 var getUserCredentials = (clientEnv = env) => {
@@ -39107,17 +40148,17 @@ async function* promptAiSdkStream(params2) {
     }),
     experimental_repairToolCall: async ({ toolCall, tools, error }) => {
       const { spawnableAgents = [], localAgentTemplates = {} } = params2;
-      const toolName32 = toolCall.toolName;
+      const toolName39 = toolCall.toolName;
       if (import_ai3.NoSuchToolError.isInstance(error) && "spawn_agents" in tools) {
-        const toolNameWithHyphens = toolName32.replace(/_/g, "-");
+        const toolNameWithHyphens = toolName39.replace(/_/g, "-");
         const matchingAgentId = spawnableAgents.find((agentId) => {
           const withoutVersion = agentId.split("@")[0];
           const parts = withoutVersion.split("/");
           const agentName = parts[parts.length - 1];
-          return agentName === toolName32 || agentName === toolNameWithHyphens || agentId === toolName32;
+          return agentName === toolName39 || agentName === toolNameWithHyphens || agentId === toolName39;
         });
         const isSpawnableAgent = matchingAgentId !== undefined;
-        const isLocalAgent = toolName32 in localAgentTemplates || toolNameWithHyphens in localAgentTemplates;
+        const isLocalAgent = toolName39 in localAgentTemplates || toolNameWithHyphens in localAgentTemplates;
         if (isSpawnableAgent || isLocalAgent) {
           const deepParseJson = (value) => {
             if (typeof value === "string") {
@@ -39141,7 +40182,7 @@ async function* promptAiSdkStream(params2) {
           } catch {}
           const prompt2 = typeof input.prompt === "string" ? input.prompt : undefined;
           const agentParams = Object.fromEntries(Object.entries(input).filter(([key, value]) => !(key === "prompt" && typeof value === "string")));
-          const correctedAgentType = matchingAgentId ?? (toolNameWithHyphens in localAgentTemplates ? toolNameWithHyphens : toolName32);
+          const correctedAgentType = matchingAgentId ?? (toolNameWithHyphens in localAgentTemplates ? toolNameWithHyphens : toolName39);
           const spawnAgentsInput = {
             agents: [
               {
@@ -39153,7 +40194,7 @@ async function* promptAiSdkStream(params2) {
               }
             ]
           };
-          logger2.info({ originalToolName: toolName32, transformedInput: spawnAgentsInput }, "Transformed agent tool call to spawn_agents");
+          logger2.info({ originalToolName: toolName39, transformedInput: spawnAgentsInput }, "Transformed agent tool call to spawn_agents");
           return {
             ...toolCall,
             toolName: "spawn_agents",
@@ -39162,7 +40203,7 @@ async function* promptAiSdkStream(params2) {
         }
       }
       logger2.info({
-        toolName: toolName32,
+        toolName: toolName39,
         errorType: error.name,
         error: error.message
       }, "Tool error - passing through for graceful error handling");
@@ -39444,38 +40485,38 @@ var noopLogger = {
 };
 
 // src/run-state.ts
-var os5 = __toESM(require("os"));
+var os6 = __toESM(require("os"));
 var import_path8 = __toESM(require("path"));
 
 // ../packages/code-map/src/parse.ts
-var fs4 = __toESM(require("fs"));
-var path8 = __toESM(require("path"));
+var fs11 = __toESM(require("fs"));
+var path10 = __toESM(require("path"));
 
 // ../packages/code-map/src/languages.ts
-var fs3 = __toESM(require("fs"));
-var path7 = __toESM(require("path"));
+var fs10 = __toESM(require("fs"));
+var path9 = __toESM(require("path"));
 var import_web_tree_sitter2 = require("web-tree-sitter");
 
 // ../packages/code-map/src/init-node.ts
-var fs2 = __toESM(require("fs"));
-var path6 = __toESM(require("path"));
+var fs9 = __toESM(require("fs"));
+var path8 = __toESM(require("path"));
 var import_web_tree_sitter = require("web-tree-sitter");
 async function initTreeSitterForNode() {
   await import_web_tree_sitter.Parser.init({
     locateFile: (name14, scriptDir) => {
       if (name14 === "tree-sitter.wasm") {
-        const fallback = path6.join(scriptDir, name14);
-        if (fs2.existsSync(fallback)) {
+        const fallback = path8.join(scriptDir, name14);
+        if (fs9.existsSync(fallback)) {
           return fallback;
         }
-        const pkgDir = path6.dirname(require.resolve("web-tree-sitter"));
-        const wasm = path6.join(pkgDir, "tree-sitter.wasm");
-        if (fs2.existsSync(wasm)) {
+        const pkgDir = path8.dirname(require.resolve("web-tree-sitter"));
+        const wasm = path8.join(pkgDir, "tree-sitter.wasm");
+        if (fs9.existsSync(wasm)) {
           return wasm;
         }
         throw new Error(`Internal error: web-tree-sitter/tree-sitter.wasm not found at ${wasm}. Ensure the file is included in your deployment bundle.`);
       }
-      return path6.join(scriptDir, name14);
+      return path8.join(scriptDir, name14);
     }
   });
 }
@@ -39815,23 +40856,23 @@ function getWasmDir() {
 function resolveWasmPath(wasmFileName) {
   const customWasmDirPath = getWasmDir();
   if (customWasmDirPath) {
-    return path7.join(customWasmDirPath, wasmFileName);
+    return path9.join(customWasmDirPath, wasmFileName);
   }
   const envWasmDir = process.env.LEVELCODE_WASM_DIR;
   if (envWasmDir) {
-    return path7.join(envWasmDir, wasmFileName);
+    return path9.join(envWasmDir, wasmFileName);
   }
   const moduleDir = (() => {
-    const dirname4 = getDirnameDynamically();
-    if (typeof dirname4 !== "undefined") {
-      return dirname4;
+    const dirname5 = getDirnameDynamically();
+    if (typeof dirname5 !== "undefined") {
+      return dirname5;
     }
     return process.cwd();
   })();
   const possiblePaths = [
-    path7.join(moduleDir, "..", "wasm", wasmFileName),
-    path7.join(moduleDir, "wasm", wasmFileName),
-    path7.join(process.cwd(), "dist", "wasm", wasmFileName)
+    path9.join(moduleDir, "..", "wasm", wasmFileName),
+    path9.join(moduleDir, "wasm", wasmFileName),
+    path9.join(process.cwd(), "dist", "wasm", wasmFileName)
   ];
   for (const wasmPath of possiblePaths) {
     try {
@@ -39875,7 +40916,7 @@ class UnifiedLanguageLoader {
   }
 }
 function findLanguageConfigByExtension(filePath) {
-  const ext = path7.extname(filePath);
+  const ext = path9.extname(filePath);
   return languageTable.find((c) => c.extensions.includes(ext));
 }
 async function createLanguageConfig(filePath, runtimeLoader) {
@@ -39889,7 +40930,7 @@ async function createLanguageConfig(filePath, runtimeLoader) {
       const lang = await runtimeLoader.loadLanguage(cfg.wasmFile);
       const parser = new import_web_tree_sitter2.Parser;
       parser.setLanguage(lang);
-      const queryContent = path7.isAbsolute(cfg.queryPathOrContent) ? fs3.readFileSync(cfg.queryPathOrContent, "utf8") : cfg.queryPathOrContent;
+      const queryContent = path9.isAbsolute(cfg.queryPathOrContent) ? fs10.readFileSync(cfg.queryPathOrContent, "utf8") : cfg.queryPathOrContent;
       cfg.language = lang;
       cfg.parser = parser;
       cfg.query = new import_web_tree_sitter2.Query(lang, queryContent);
@@ -39921,7 +40962,7 @@ async function getFileTokenScores(projectRoot, filePaths, readFile) {
   const externalCalls = {};
   const fileCallsMap = new Map;
   for (const filePath of filePaths) {
-    const fullPath = path8.join(projectRoot, filePath);
+    const fullPath = path10.join(projectRoot, filePath);
     const languageConfig = await getLanguageConfig(fullPath);
     if (languageConfig) {
       let parseResults;
@@ -39933,7 +40974,7 @@ async function getFileTokenScores(projectRoot, filePaths, readFile) {
       const { identifiers, calls, numLines } = parseResults;
       const tokenScoresForFile = {};
       tokenScores[filePath] = tokenScoresForFile;
-      const dirs = path8.dirname(fullPath).split(path8.sep);
+      const dirs = path10.dirname(fullPath).split(path10.sep);
       const depth = dirs.length;
       const tokenBaseScore = 0.8 ** depth * Math.sqrt(numLines / (identifiers.length + 1));
       for (const identifier of identifiers) {
@@ -39995,7 +41036,7 @@ async function getFileTokenScores(projectRoot, filePaths, readFile) {
     const endTime = Date.now();
     console.log(`Parsed ${filePaths.length} files in ${endTime - startTime2}ms`);
     try {
-      fs4.writeFileSync("../debug/debug-parse.json", JSON.stringify({
+      fs11.writeFileSync("../debug/debug-parse.json", JSON.stringify({
         tokenCallers,
         tokenScores,
         fileCallsMap,
@@ -40008,7 +41049,7 @@ async function getFileTokenScores(projectRoot, filePaths, readFile) {
 function parseTokens(filePath, languageConfig, readFile) {
   const { parser, query } = languageConfig;
   try {
-    const sourceCode = readFile ? readFile(filePath) : fs4.readFileSync(filePath, "utf8");
+    const sourceCode = readFile ? readFile(filePath) : fs11.readFileSync(filePath, "utf8");
     if (sourceCode === null) {
       return {
         numLines: 0,
@@ -40065,7 +41106,7 @@ function parseFile(parser, query, sourceCode) {
 
 // src/run-state.ts
 var import_lodash17 = __toESM(require_lodash());
-var import_v473 = __toESM(require("zod/v4"));
+var import_v480 = __toESM(require("zod/v4"));
 
 // src/agents/load-agents.ts
 var import_fs2 = __toESM(require("fs"));
@@ -40307,21 +41348,21 @@ function isValidSkillName(name14) {
 }
 
 // ../common/src/types/skill.ts
-var import_v472 = require("zod/v4");
-var SkillMetadataSchema = import_v472.z.record(import_v472.z.string(), import_v472.z.string());
-var SkillFrontmatterSchema = import_v472.z.object({
-  name: import_v472.z.string().min(1).max(SKILL_NAME_MAX_LENGTH).regex(SKILL_NAME_REGEX, "Name must be lowercase alphanumeric with single hyphen separators"),
-  description: import_v472.z.string().min(1).max(SKILL_DESCRIPTION_MAX_LENGTH),
-  license: import_v472.z.string().optional(),
+var import_v479 = require("zod/v4");
+var SkillMetadataSchema = import_v479.z.record(import_v479.z.string(), import_v479.z.string());
+var SkillFrontmatterSchema = import_v479.z.object({
+  name: import_v479.z.string().min(1).max(SKILL_NAME_MAX_LENGTH).regex(SKILL_NAME_REGEX, "Name must be lowercase alphanumeric with single hyphen separators"),
+  description: import_v479.z.string().min(1).max(SKILL_DESCRIPTION_MAX_LENGTH),
+  license: import_v479.z.string().optional(),
   metadata: SkillMetadataSchema.optional()
 });
-var SkillDefinitionSchema = import_v472.z.object({
-  name: import_v472.z.string(),
-  description: import_v472.z.string(),
-  license: import_v472.z.string().optional(),
+var SkillDefinitionSchema = import_v479.z.object({
+  name: import_v479.z.string(),
+  description: import_v479.z.string(),
+  license: import_v479.z.string().optional(),
   metadata: SkillMetadataSchema.optional(),
-  content: import_v472.z.string(),
-  filePath: import_v472.z.string()
+  content: import_v479.z.string(),
+  filePath: import_v479.z.string()
 });
 
 // src/skills/load-skills.ts
@@ -40461,7 +41502,7 @@ function processAgentDefinitions(agentDefinitions) {
 }
 function processCustomToolDefinitions(customToolDefinitions) {
   return Object.fromEntries(customToolDefinitions.map((toolDefinition) => {
-    const jsonSchema = import_v473.default.toJSONSchema(toolDefinition.inputSchema, {
+    const jsonSchema = import_v480.default.toJSONSchema(toolDefinition.inputSchema, {
       io: "input"
     });
     delete jsonSchema["$schema"];
@@ -40540,13 +41581,13 @@ async function getGitChanges(params2) {
   };
 }
 async function discoverProjectFiles(params2) {
-  const { cwd, fs: fs7, logger: logger2 } = params2;
-  const fileTree = await getProjectFileTree({ projectRoot: cwd, fs: fs7 });
+  const { cwd, fs: fs14, logger: logger2 } = params2;
+  const fileTree = await getProjectFileTree({ projectRoot: cwd, fs: fs14 });
   const filePaths = getAllFilePaths(fileTree);
   let error;
   const projectFilePromises = Object.fromEntries(filePaths.map((filePath) => [
     filePath,
-    fs7.readFile(import_path8.default.join(cwd, filePath), "utf8").catch((err) => {
+    fs14.readFile(import_path8.default.join(cwd, filePath), "utf8").catch((err) => {
       error = err;
       return "[ERROR_READING_FILE]";
     })
@@ -40561,12 +41602,12 @@ async function discoverProjectFiles(params2) {
   return projectFilesResolved;
 }
 async function loadUserKnowledgeFiles(params2) {
-  const { fs: fs7, logger: logger2 } = params2;
-  const homeDir = params2.homeDir ?? os5.homedir();
+  const { fs: fs14, logger: logger2 } = params2;
+  const homeDir = params2.homeDir ?? os6.homedir();
   const userKnowledgeFiles = {};
   let entries;
   try {
-    entries = await fs7.readdir(homeDir);
+    entries = await fs14.readdir(homeDir);
   } catch (error) {
     logger2.debug?.({ homeDir, error: getErrorObject(error) }, "Failed to read home directory");
     return userKnowledgeFiles;
@@ -40586,7 +41627,7 @@ async function loadUserKnowledgeFiles(params2) {
     if (actualFileName) {
       const filePath = import_path8.default.join(homeDir, actualFileName);
       try {
-        const content = await fs7.readFile(filePath, "utf8");
+        const content = await fs14.readFile(filePath, "utf8");
         const tildeKey = `~/${actualFileName}`;
         userKnowledgeFiles[tildeKey] = content;
         break;
@@ -40633,7 +41674,7 @@ async function initialSessionState(params2) {
     projectFiles,
     knowledgeFiles,
     userKnowledgeFiles: providedUserKnowledgeFiles,
-    fs: fs7,
+    fs: fs14,
     spawn: spawn2,
     logger: logger2
   } = params2;
@@ -40643,8 +41684,8 @@ async function initialSessionState(params2) {
   if (!customToolDefinitions) {
     customToolDefinitions = [];
   }
-  if (!fs7) {
-    fs7 = require("fs").promises;
+  if (!fs14) {
+    fs14 = require("fs").promises;
   }
   if (!spawn2) {
     const { spawn: nodeSpawn } = require("child_process");
@@ -40659,7 +41700,7 @@ async function initialSessionState(params2) {
     };
   }
   if (projectFiles === undefined && cwd) {
-    projectFiles = await discoverProjectFiles({ cwd, fs: fs7, logger: logger2 });
+    projectFiles = await discoverProjectFiles({ cwd, fs: fs14, logger: logger2 });
   }
   if (knowledgeFiles === undefined) {
     knowledgeFiles = projectFiles ? deriveKnowledgeFiles(projectFiles) : {};
@@ -40686,7 +41727,7 @@ async function initialSessionState(params2) {
     diffCached: "",
     lastCommitMessages: ""
   };
-  const homeKnowledgeFiles = await loadUserKnowledgeFiles({ fs: fs7, logger: logger2 });
+  const homeKnowledgeFiles = await loadUserKnowledgeFiles({ fs: fs14, logger: logger2 });
   const userKnowledgeFiles = {
     ...homeKnowledgeFiles,
     ...providedUserKnowledgeFiles
@@ -40711,8 +41752,8 @@ async function initialSessionState(params2) {
       shell: "bash",
       nodeVersion: process.version,
       arch: process.arch,
-      homedir: os5.homedir(),
-      cpus: os5.cpus().length ?? 1
+      homedir: os6.homedir(),
+      cpus: os6.cpus().length ?? 1
     }
   });
   if (maxAgentSteps) {
@@ -40728,7 +41769,7 @@ async function generateInitialRunState({
   agentDefinitions,
   customToolDefinitions,
   maxAgentSteps,
-  fs: fs7
+  fs: fs14
 }) {
   return {
     sessionState: await initialSessionState({
@@ -40739,7 +41780,7 @@ async function generateInitialRunState({
       agentDefinitions,
       customToolDefinitions,
       maxAgentSteps,
-      fs: fs7
+      fs: fs14
     }),
     output: {
       type: "error",
@@ -40825,19 +41866,19 @@ function buildFileTree(filePaths) {
   }
   const rootNodes = [];
   const processed = new Set;
-  for (const [path12, node] of Object.entries(tree)) {
-    if (processed.has(path12))
+  for (const [path14, node] of Object.entries(tree)) {
+    if (processed.has(path14))
       continue;
-    const parentPath = path12.substring(0, path12.lastIndexOf("/"));
+    const parentPath = path14.substring(0, path14.lastIndexOf("/"));
     if (parentPath && tree[parentPath]) {
       const parent = tree[parentPath];
-      if (parent.children && !parent.children.some((child) => child.filePath === path12)) {
+      if (parent.children && !parent.children.some((child) => child.filePath === path14)) {
         parent.children.push(node);
       }
     } else {
       rootNodes.push(node);
     }
-    processed.add(path12);
+    processed.add(path14);
   }
   function sortNodes(nodes) {
     nodes.sort((a, b) => {
@@ -40859,11 +41900,11 @@ function buildFileTree(filePaths) {
 // src/tools/change-file.ts
 var import_path9 = __toESM(require("path"));
 var import_diff4 = require("diff");
-var import_v474 = __toESM(require("zod/v4"));
-var FileChangeSchema2 = import_v474.default.object({
-  type: import_v474.default.enum(["patch", "file"]),
-  path: import_v474.default.string(),
-  content: import_v474.default.string()
+var import_v481 = __toESM(require("zod/v4"));
+var FileChangeSchema2 = import_v481.default.object({
+  type: import_v481.default.enum(["patch", "file"]),
+  path: import_v481.default.string(),
+  content: import_v481.default.string()
 });
 function containsUpwardTraversal(dirPath) {
   const normalized = import_path9.default.normalize(dirPath);
@@ -40874,7 +41915,7 @@ function containsPathTraversal(filePath) {
   return import_path9.default.isAbsolute(normalized) || normalized.startsWith("..");
 }
 async function changeFile(params2) {
-  const { parameters, cwd, fs: fs7 } = params2;
+  const { parameters, cwd, fs: fs14 } = params2;
   if (containsUpwardTraversal(cwd)) {
     throw new Error("cwd contains invalid path traversal");
   }
@@ -40887,7 +41928,7 @@ async function changeFile(params2) {
   const { created, modified, invalid, patchFailed } = await applyChanges({
     projectRoot: cwd,
     changes: [fileChange],
-    fs: fs7
+    fs: fs14
   });
   const results = [];
   for (const file of created) {
@@ -40926,7 +41967,7 @@ async function changeFile(params2) {
   return [{ type: "json", value: results[0] }];
 }
 async function applyChanges(params2) {
-  const { projectRoot, changes, fs: fs7 } = params2;
+  const { projectRoot, changes, fs: fs14 } = params2;
   const created = [];
   const modified = [];
   const patchFailed = [];
@@ -40935,21 +41976,21 @@ async function applyChanges(params2) {
     const { path: filePath, content, type } = change;
     try {
       const fullPath = import_path9.default.join(projectRoot, filePath);
-      const exists = await fileExists({ filePath: fullPath, fs: fs7 });
+      const exists = await fileExists({ filePath: fullPath, fs: fs14 });
       if (!exists) {
         const dirPath = import_path9.default.dirname(fullPath);
-        await fs7.mkdir(dirPath, { recursive: true });
+        await fs14.mkdir(dirPath, { recursive: true });
       }
       if (type === "file") {
-        await fs7.writeFile(fullPath, content);
+        await fs14.writeFile(fullPath, content);
       } else {
-        const oldContent = await fs7.readFile(fullPath, "utf-8");
+        const oldContent = await fs14.readFile(fullPath, "utf-8");
         const newContent = import_diff4.applyPatch(oldContent, content);
         if (newContent === false) {
           patchFailed.push(filePath);
           continue;
         }
-        await fs7.writeFile(fullPath, newContent);
+        await fs14.writeFile(fullPath, newContent);
       }
       if (exists) {
         modified.push(filePath);
@@ -40966,8 +42007,8 @@ async function applyChanges(params2) {
 
 // src/tools/code-search.ts
 var import_child_process = require("child_process");
-var fs7 = __toESM(require("fs"));
-var path13 = __toESM(require("path"));
+var fs14 = __toESM(require("fs"));
+var path15 = __toESM(require("path"));
 
 // ../common/src/util/format-code-search.ts
 function formatCodeSearchOutput(stdout) {
@@ -41065,13 +42106,13 @@ function getBundledRgPath(importMetaUrl, env2 = getSdkEnv()) {
     }
   }
   if (!vendorPath) {
-    const dirname6 = new Function(`try { return __dirname; } catch (e) { return undefined; }`)();
-    if (typeof dirname6 !== "undefined") {
-      const cjsPath = import_path10.join(dirname6, "..", "..", "vendor", "ripgrep", platformDir, binaryName);
+    const dirname7 = new Function(`try { return __dirname; } catch (e) { return undefined; }`)();
+    if (typeof dirname7 !== "undefined") {
+      const cjsPath = import_path10.join(dirname7, "..", "..", "vendor", "ripgrep", platformDir, binaryName);
       if (import_fs4.existsSync(cjsPath)) {
         vendorPath = cjsPath;
       }
-      const cjsPath2 = import_path10.join(dirname6, "vendor", "ripgrep", platformDir, binaryName);
+      const cjsPath2 = import_path10.join(dirname7, "vendor", "ripgrep", platformDir, binaryName);
       if (import_fs4.existsSync(cjsPath2)) {
         vendorPath = cjsPath2;
       }
@@ -41109,9 +42150,9 @@ function codeSearch({
 }) {
   return new Promise((resolve3) => {
     let isResolved = false;
-    const projectRoot = path13.resolve(projectPath);
-    const searchCwd = cwd ? path13.resolve(projectRoot, cwd) : projectRoot;
-    if (!searchCwd.startsWith(projectRoot + path13.sep) && searchCwd !== projectRoot) {
+    const projectRoot = path15.resolve(projectPath);
+    const searchCwd = cwd ? path15.resolve(projectRoot, cwd) : projectRoot;
+    if (!searchCwd.startsWith(projectRoot + path15.sep) && searchCwd !== projectRoot) {
       return resolve3([
         {
           type: "json",
@@ -41124,7 +42165,7 @@ function codeSearch({
     const flagsArray = (flags || "").split(" ").filter(Boolean).map((token) => token.replace(/^['"]|['"]$/g, ""));
     const existingHiddenDirs = INCLUDED_HIDDEN_DIRS.filter((dir) => {
       try {
-        return fs7.statSync(path13.join(searchCwd, dir)).isDirectory();
+        return fs14.statSync(path15.join(searchCwd, dir)).isDirectory();
       } catch {
         return false;
       }
@@ -41372,9 +42413,9 @@ ${truncatedFiles.join(`
 // src/tools/glob.ts
 var import_micromatch = __toESM(require("micromatch"));
 async function glob(params2) {
-  const { pattern, projectPath, cwd, fs: fs8 } = params2;
+  const { pattern, projectPath, cwd, fs: fs15 } = params2;
   try {
-    const fileTree = await getProjectFileTree({ projectRoot: projectPath, fs: fs8 });
+    const fileTree = await getProjectFileTree({ projectRoot: projectPath, fs: fs15 });
     const flattenedNodes = flattenTree(fileTree);
     let allFilePaths = flattenedNodes.filter((node) => node.type === "file").map((node) => node.filePath);
     if (cwd) {
@@ -41406,11 +42447,11 @@ async function glob(params2) {
 }
 
 // src/tools/list-directory.ts
-var path14 = __toESM(require("path"));
+var path16 = __toESM(require("path"));
 async function listDirectory(params2) {
-  const { directoryPath, projectPath, fs: fs8 } = params2;
+  const { directoryPath, projectPath, fs: fs15 } = params2;
   try {
-    const resolvedPath = path14.resolve(projectPath, directoryPath);
+    const resolvedPath = path16.resolve(projectPath, directoryPath);
     if (!resolvedPath.startsWith(projectPath)) {
       return [
         {
@@ -41421,7 +42462,7 @@ async function listDirectory(params2) {
         }
       ];
     }
-    const entries = await fs8.readdir(resolvedPath, {
+    const entries = await fs15.readdir(resolvedPath, {
       withFileTypes: true
     });
     const files = [];
@@ -41460,7 +42501,7 @@ async function listDirectory(params2) {
 var import_path11 = __toESM(require("path"));
 init_old_constants();
 async function getFiles(params2) {
-  const { filePaths, cwd, fs: fs8, fileFilter } = params2;
+  const { filePaths, cwd, fs: fs15, fileFilter } = params2;
   const hasCustomFilter = fileFilter !== undefined;
   const result = {};
   const MAX_FILE_SIZE = 1024 * 1024;
@@ -41484,7 +42525,7 @@ async function getFiles(params2) {
       const ignored = await isFileIgnored({
         filePath: relativePath,
         projectRoot: cwd,
-        fs: fs8
+        fs: fs15
       });
       if (ignored) {
         result[relativePath] = FILE_READ_STATUS.IGNORED;
@@ -41492,11 +42533,11 @@ async function getFiles(params2) {
       }
     }
     try {
-      const stats = await fs8.stat(fullPath);
+      const stats = await fs15.stat(fullPath);
       if (stats.size > MAX_FILE_SIZE) {
         result[relativePath] = FILE_READ_STATUS.TOO_LARGE + ` [${(stats.size / (1024 * 1024)).toFixed(2)}MB]`;
       } else {
-        const content = await fs8.readFile(fullPath, "utf8");
+        const content = await fs15.readFile(fullPath, "utf8");
         result[relativePath] = isExampleFile ? FILE_READ_STATUS.TEMPLATE + `
 ` + content : content;
       }
@@ -41513,9 +42554,9 @@ async function getFiles(params2) {
 
 // src/tools/run-terminal-command.ts
 var import_child_process2 = require("child_process");
-var fs8 = __toESM(require("fs"));
-var os6 = __toESM(require("os"));
-var path16 = __toESM(require("path"));
+var fs15 = __toESM(require("fs"));
+var os7 = __toESM(require("os"));
+var path18 = __toESM(require("path"));
 var COMMAND_OUTPUT_LIMIT = 50000;
 var GIT_BASH_COMMON_PATHS = [
   "C:\\Program Files\\Git\\bin\\bash.exe",
@@ -41528,30 +42569,30 @@ var WSL_BASH_PATH_PATTERNS = [
 ];
 function findWindowsBash(env2) {
   const customPath = env2.LEVELCODE_GIT_BASH_PATH;
-  if (customPath && fs8.existsSync(customPath)) {
+  if (customPath && fs15.existsSync(customPath)) {
     return customPath;
   }
   for (const commonPath of GIT_BASH_COMMON_PATHS) {
-    if (fs8.existsSync(commonPath)) {
+    if (fs15.existsSync(commonPath)) {
       return commonPath;
     }
   }
   const pathEnv = env2.PATH || env2.Path || "";
-  const pathDirs = pathEnv.split(path16.delimiter);
+  const pathDirs = pathEnv.split(path18.delimiter);
   const wslFallbackPaths = [];
   for (const dir of pathDirs) {
     const dirLower = dir.toLowerCase();
     const isWslPath = WSL_BASH_PATH_PATTERNS.some((pattern) => dirLower.includes(pattern));
-    const bashPath = path16.join(dir, "bash.exe");
-    if (fs8.existsSync(bashPath)) {
+    const bashPath = path18.join(dir, "bash.exe");
+    if (fs15.existsSync(bashPath)) {
       if (isWslPath) {
         wslFallbackPaths.push(bashPath);
       } else {
         return bashPath;
       }
     }
-    const bashPathNoExt = path16.join(dir, "bash");
-    if (fs8.existsSync(bashPathNoExt)) {
+    const bashPathNoExt = path18.join(dir, "bash");
+    if (fs15.existsSync(bashPathNoExt)) {
       if (isWslPath) {
         wslFallbackPaths.push(bashPathNoExt);
       } else {
@@ -41591,7 +42632,7 @@ function runTerminalCommand({
     throw new Error("BACKGROUND process_type not implemented");
   }
   return new Promise((resolve5, reject) => {
-    const isWindows = os6.platform() === "win32";
+    const isWindows = os7.platform() === "win32";
     const processEnv2 = {
       ...getSystemProcessEnv(),
       ...env2 ?? {}
@@ -41610,7 +42651,7 @@ function runTerminalCommand({
       shell = "bash";
       shellArgs = ["-c"];
     }
-    const resolvedCwd = path16.resolve(cwd);
+    const resolvedCwd = path18.resolve(cwd);
     const childProcess = import_child_process2.spawn(shell, [...shellArgs, command], {
       cwd: resolvedCwd,
       env: processEnv2,
@@ -41731,7 +42772,7 @@ async function runOnce({
   costMode
 }) {
   const fsSourceValue = typeof fsSource === "function" ? fsSource() : fsSource;
-  const fs9 = await fsSourceValue;
+  const fs16 = await fsSourceValue;
   let spawn4;
   if (spawnSource) {
     const spawnSourceValue = await spawnSource;
@@ -41765,7 +42806,7 @@ async function runOnce({
       customToolDefinitions,
       projectFiles,
       maxAgentSteps,
-      fs: fs9,
+      fs: fs16,
       spawn: spawn4,
       logger: logger2
     });
@@ -41850,13 +42891,13 @@ async function runOnce({
     logger: logger2,
     apiKey,
     handleStepsLogChunk: () => {},
-    requestToolCall: async ({ userInputId: userInputId2, toolName: toolName32, input, mcpConfig }) => {
+    requestToolCall: async ({ userInputId: userInputId2, toolName: toolName39, input, mcpConfig }) => {
       return handleToolCall({
         action: {
           type: "tool-call-request",
           requestId: crypto.randomUUID(),
           userInputId: userInputId2,
-          toolName: toolName32,
+          toolName: toolName39,
           input,
           timeout: undefined,
           mcpConfig
@@ -41864,7 +42905,7 @@ async function runOnce({
         overrides: overrideTools ?? {},
         customToolDefinitions: customToolDefinitions ? Object.fromEntries(customToolDefinitions.map((def) => [def.toolName, def])) : {},
         cwd,
-        fs: fs9,
+        fs: fs16,
         env: env2
       });
     },
@@ -41890,7 +42931,7 @@ async function runOnce({
       override: overrideTools?.read_files,
       fileFilter,
       cwd,
-      fs: fs9
+      fs: fs16
     }),
     requestOptionalFile: async ({ filePath }) => {
       const files = await readFiles({
@@ -41898,7 +42939,7 @@ async function runOnce({
         override: overrideTools?.read_files,
         fileFilter,
         cwd,
-        fs: fs9
+        fs: fs16
       });
       return toOptionalFile(files[filePath] ?? null);
     },
@@ -42004,9 +43045,9 @@ async function runOnce({
   });
   return promise;
 }
-function requireCwd(cwd, toolName32) {
+function requireCwd(cwd, toolName39) {
   if (!cwd) {
-    throw new Error(`cwd is required for the ${toolName32} tool. Please provide cwd in LevelCodeClientOptions or override the ${toolName32} tool.`);
+    throw new Error(`cwd is required for the ${toolName39} tool. Please provide cwd in LevelCodeClientOptions or override the ${toolName39} tool.`);
   }
   return cwd;
 }
@@ -42015,28 +43056,28 @@ async function readFiles({
   override,
   fileFilter,
   cwd,
-  fs: fs9
+  fs: fs16
 }) {
   if (override) {
     return await override({ filePaths });
   }
-  return getFiles({ filePaths, cwd: requireCwd(cwd, "read_files"), fs: fs9, fileFilter });
+  return getFiles({ filePaths, cwd: requireCwd(cwd, "read_files"), fs: fs16, fileFilter });
 }
 async function handleToolCall({
   action,
   overrides,
   customToolDefinitions,
   cwd,
-  fs: fs9,
+  fs: fs16,
   env: env2
 }) {
-  const toolName32 = action.toolName;
+  const toolName39 = action.toolName;
   const input = action.input;
   if (action.mcpConfig) {
     try {
       const mcpClientId = await getMCPClient(action.mcpConfig);
       const result2 = await callMCPTool(mcpClientId, {
-        name: toolName32,
+        name: toolName39,
         arguments: input
       });
       return { output: result2 };
@@ -42054,10 +43095,10 @@ async function handleToolCall({
     }
   }
   let result;
-  if (toolNames.includes(toolName32)) {
+  if (toolNames.includes(toolName39)) {
     clientToolCallSchema.parse(action);
   } else {
-    const customToolHandler = customToolDefinitions[toolName32];
+    const customToolHandler = customToolDefinitions[toolName39];
     if (!customToolHandler) {
       throw new Error(`Custom tool handler not found for user input ID ${action.userInputId}`);
     }
@@ -42066,46 +43107,46 @@ async function handleToolCall({
     };
   }
   try {
-    let override = overrides[toolName32];
-    if (!override && toolName32 === "str_replace") {
+    let override = overrides[toolName39];
+    if (!override && toolName39 === "str_replace") {
       override = overrides["write_file"];
     }
     if (override) {
       result = await override(input);
-    } else if (toolName32 === "end_turn") {
+    } else if (toolName39 === "end_turn") {
       result = [{ type: "json", value: { message: "Turn ended." } }];
-    } else if (toolName32 === "write_file" || toolName32 === "str_replace") {
+    } else if (toolName39 === "write_file" || toolName39 === "str_replace") {
       result = await changeFile({
         parameters: input,
-        cwd: requireCwd(cwd, toolName32),
-        fs: fs9
+        cwd: requireCwd(cwd, toolName39),
+        fs: fs16
       });
-    } else if (toolName32 === "run_terminal_command") {
+    } else if (toolName39 === "run_terminal_command") {
       const resolvedCwd = requireCwd(cwd, "run_terminal_command");
       result = await runTerminalCommand({
         ...input,
         cwd: import_path12.default.resolve(resolvedCwd, input.cwd ?? "."),
         env: env2
       });
-    } else if (toolName32 === "code_search") {
+    } else if (toolName39 === "code_search") {
       result = await codeSearch({
         projectPath: requireCwd(cwd, "code_search"),
         ...input
       });
-    } else if (toolName32 === "list_directory") {
+    } else if (toolName39 === "list_directory") {
       result = await listDirectory({
         directoryPath: input.path,
         projectPath: requireCwd(cwd, "list_directory"),
-        fs: fs9
+        fs: fs16
       });
-    } else if (toolName32 === "glob") {
+    } else if (toolName39 === "glob") {
       result = await glob({
         pattern: input.pattern,
         projectPath: requireCwd(cwd, "glob"),
         cwd: input.cwd,
-        fs: fs9
+        fs: fs16
       });
-    } else if (toolName32 === "run_file_change_hooks") {
+    } else if (toolName39 === "run_file_change_hooks") {
       result = [
         {
           type: "json",
@@ -42115,7 +43156,7 @@ async function handleToolCall({
         }
       ];
     } else {
-      throw new Error(`Tool not implemented in SDK. Please provide an override or modify your agent to not use this tool: ${toolName32}`);
+      throw new Error(`Tool not implemented in SDK. Please provide an override or modify your agent to not use this tool: ${toolName39}`);
     }
   } catch (error) {
     result = [
@@ -42296,18 +43337,18 @@ Provide a handleEvent function to handle this error.`);
 }
 // src/custom-tool.ts
 function getCustomToolDefinition({
-  toolName: toolName32,
-  inputSchema: inputSchema32,
-  description: description31,
-  endsAgentStep: endsAgentStep32 = true,
+  toolName: toolName39,
+  inputSchema: inputSchema39,
+  description: description38,
+  endsAgentStep: endsAgentStep39 = true,
   exampleInputs = [],
   execute
 }) {
   return {
-    toolName: toolName32,
-    inputSchema: inputSchema32,
-    description: description31,
-    endsAgentStep: endsAgentStep32,
+    toolName: toolName39,
+    inputSchema: inputSchema39,
+    description: description38,
+    endsAgentStep: endsAgentStep39,
     exampleInputs,
     execute: async (params2) => {
       return await execute(params2);
@@ -42345,9 +43386,9 @@ var import_fs5 = __toESM(require("fs"));
 var import_promises = __toESM(require("fs/promises"));
 var import_os4 = __toESM(require("os"));
 var import_path13 = __toESM(require("path"));
-var import_v475 = require("zod/v4");
-var mcpFileSchema = import_v475.z.object({
-  mcpServers: import_v475.z.record(import_v475.z.string(), mcpConfigSchema).default(() => ({}))
+var import_v482 = require("zod/v4");
+var mcpFileSchema = import_v482.z.object({
+  mcpServers: import_v482.z.record(import_v482.z.string(), mcpConfigSchema).default(() => ({}))
 });
 var envKey = "env";
 var processEnv2 = process[envKey];
@@ -42476,5 +43517,5 @@ function loadMCPConfigSync(options) {
   return mergedConfig;
 }
 
-//# debugId=099CD01FFE2E727364756E2164756E21
+//# debugId=532E2EE00FAB612B64756E2164756E21
 //# sourceMappingURL=index.cjs.map