@levelcode/sdk 0.2.4 → 0.2.5

package/dist/index.mjs

@@ -7271,8 +7271,8 @@ var require_uri_all = __commonJS((exports2, module) => {
           wsComponents.secure = undefined;
         }
         if (wsComponents.resourceName) {
-          var _wsComponents$resourc = wsComponents.resourceName.split("?"), _wsComponents$resourc2 = slicedToArray(_wsComponents$resourc, 2), path7 = _wsComponents$resourc2[0], query = _wsComponents$resourc2[1];
-          wsComponents.path = path7 && path7 !== "/" ? path7 : undefined;
+          var _wsComponents$resourc = wsComponents.resourceName.split("?"), _wsComponents$resourc2 = slicedToArray(_wsComponents$resourc, 2), path8 = _wsComponents$resourc2[0], query = _wsComponents$resourc2[1];
+          wsComponents.path = path8 && path8 !== "/" ? path8 : undefined;
           wsComponents.query = query;
           wsComponents.resourceName = undefined;
         }
@@ -7665,12 +7665,12 @@ var require_util = __commonJS((exports2, module) => {
     return "'" + escapeQuotes(str) + "'";
   }
   function getPathExpr(currentPath, expr, jsonPointers, isNumber2) {
-    var path7 = jsonPointers ? "'/' + " + expr + (isNumber2 ? "" : ".replace(/~/g, '~0').replace(/\\//g, '~1')") : isNumber2 ? "'[' + " + expr + " + ']'" : "'[\\'' + " + expr + " + '\\']'";
-    return joinPaths(currentPath, path7);
+    var path8 = jsonPointers ? "'/' + " + expr + (isNumber2 ? "" : ".replace(/~/g, '~0').replace(/\\//g, '~1')") : isNumber2 ? "'[' + " + expr + " + ']'" : "'[\\'' + " + expr + " + '\\']'";
+    return joinPaths(currentPath, path8);
   }
   function getPath(currentPath, prop, jsonPointers) {
-    var path7 = jsonPointers ? toQuotedString("/" + escapeJsonPointer(prop)) : toQuotedString(getProperty(prop));
-    return joinPaths(currentPath, path7);
+    var path8 = jsonPointers ? toQuotedString("/" + escapeJsonPointer(prop)) : toQuotedString(getProperty(prop));
+    return joinPaths(currentPath, path8);
   }
   var JSON_POINTER = /^\/(?:[^~]|~0|~1)*$/;
   var RELATIVE_JSON_POINTER = /^([0-9]+)(#|\/(?:[^~]|~0|~1)*)?$/;
@@ -12636,7 +12636,7 @@ var require_windows = __commonJS((exports2, module) => {
   module.exports = isexe;
   isexe.sync = sync;
   var fs7 = __require("fs");
-  function checkPathExt(path7, options) {
+  function checkPathExt(path8, options) {
     var pathext = options.pathExt !== undefined ? options.pathExt : process.env.PATHEXT;
     if (!pathext) {
       return true;
@@ -12647,25 +12647,25 @@ var require_windows = __commonJS((exports2, module) => {
     }
     for (var i = 0;i < pathext.length; i++) {
       var p = pathext[i].toLowerCase();
-      if (p && path7.substr(-p.length).toLowerCase() === p) {
+      if (p && path8.substr(-p.length).toLowerCase() === p) {
         return true;
       }
     }
     return false;
   }
-  function checkStat(stat, path7, options) {
+  function checkStat(stat, path8, options) {
     if (!stat.isSymbolicLink() && !stat.isFile()) {
       return false;
     }
-    return checkPathExt(path7, options);
+    return checkPathExt(path8, options);
   }
-  function isexe(path7, options, cb) {
-    fs7.stat(path7, function(er, stat) {
-      cb(er, er ? false : checkStat(stat, path7, options));
+  function isexe(path8, options, cb) {
+    fs7.stat(path8, function(er, stat) {
+      cb(er, er ? false : checkStat(stat, path8, options));
     });
   }
-  function sync(path7, options) {
-    return checkStat(fs7.statSync(path7), path7, options);
+  function sync(path8, options) {
+    return checkStat(fs7.statSync(path8), path8, options);
   }
 });
 
@@ -12674,13 +12674,13 @@ var require_mode = __commonJS((exports2, module) => {
   module.exports = isexe;
   isexe.sync = sync;
   var fs7 = __require("fs");
-  function isexe(path7, options, cb) {
-    fs7.stat(path7, function(er, stat) {
+  function isexe(path8, options, cb) {
+    fs7.stat(path8, function(er, stat) {
       cb(er, er ? false : checkStat(stat, options));
     });
   }
-  function sync(path7, options) {
-    return checkStat(fs7.statSync(path7), options);
+  function sync(path8, options) {
+    return checkStat(fs7.statSync(path8), options);
   }
   function checkStat(stat, options) {
     return stat.isFile() && checkMode(stat, options);
@@ -12711,7 +12711,7 @@ var require_isexe = __commonJS((exports2, module) => {
   }
   module.exports = isexe;
   isexe.sync = sync;
-  function isexe(path7, options, cb) {
+  function isexe(path8, options, cb) {
     if (typeof options === "function") {
       cb = options;
       options = {};
@@ -12721,7 +12721,7 @@ var require_isexe = __commonJS((exports2, module) => {
         throw new TypeError("callback not provided");
       }
       return new Promise(function(resolve3, reject) {
-        isexe(path7, options || {}, function(er, is) {
+        isexe(path8, options || {}, function(er, is) {
           if (er) {
             reject(er);
           } else {
@@ -12730,7 +12730,7 @@ var require_isexe = __commonJS((exports2, module) => {
         });
       });
     }
-    core(path7, options || {}, function(er, is) {
+    core(path8, options || {}, function(er, is) {
       if (er) {
         if (er.code === "EACCES" || options && options.ignoreErrors) {
           er = null;
@@ -12740,9 +12740,9 @@ var require_isexe = __commonJS((exports2, module) => {
       cb(er, is);
     });
   }
-  function sync(path7, options) {
+  function sync(path8, options) {
     try {
-      return core.sync(path7, options || {});
+      return core.sync(path8, options || {});
     } catch (er) {
       if (options && options.ignoreErrors || er.code === "EACCES") {
         return false;
@@ -12756,7 +12756,7 @@ var require_isexe = __commonJS((exports2, module) => {
 // ../node_modules/which/which.js
 var require_which = __commonJS((exports2, module) => {
   var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
-  var path7 = __require("path");
+  var path8 = __require("path");
   var COLON = isWindows ? ";" : ":";
   var isexe = require_isexe();
   var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
@@ -12792,7 +12792,7 @@ var require_which = __commonJS((exports2, module) => {
         return opt.all && found.length ? resolve3(found) : reject(getNotFoundError(cmd));
       const ppRaw = pathEnv[i];
       const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-      const pCmd = path7.join(pathPart, cmd);
+      const pCmd = path8.join(pathPart, cmd);
       const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
       resolve3(subStep(p, i, 0));
     });
@@ -12819,7 +12819,7 @@ var require_which = __commonJS((exports2, module) => {
     for (let i = 0;i < pathEnv.length; i++) {
       const ppRaw = pathEnv[i];
       const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-      const pCmd = path7.join(pathPart, cmd);
+      const pCmd = path8.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];
@@ -12860,7 +12860,7 @@ var require_path_key = __commonJS((exports2, module) => {
 
 // ../node_modules/cross-spawn/lib/util/resolveCommand.js
 var require_resolveCommand = __commonJS((exports2, module) => {
-  var path7 = __require("path");
+  var path8 = __require("path");
   var which = require_which();
   var getPathKey = require_path_key();
   function resolveCommandAttempt(parsed, withoutPathExt) {
@@ -12877,7 +12877,7 @@ var require_resolveCommand = __commonJS((exports2, module) => {
     try {
       resolved = which.sync(parsed.command, {
         path: env2[getPathKey({ env: env2 })],
-        pathExt: withoutPathExt ? path7.delimiter : undefined
+        pathExt: withoutPathExt ? path8.delimiter : undefined
       });
     } catch (e) {} finally {
       if (shouldSwitchCwd) {
@@ -12885,7 +12885,7 @@ var require_resolveCommand = __commonJS((exports2, module) => {
       }
     }
     if (resolved) {
-      resolved = path7.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+      resolved = path8.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
     }
     return resolved;
   }
@@ -12930,8 +12930,8 @@ var require_shebang_command = __commonJS((exports2, module) => {
     if (!match) {
       return null;
     }
-    const [path7, argument] = match[0].replace(/#! ?/, "").split(" ");
-    const binary = path7.split("/").pop();
+    const [path8, argument] = match[0].replace(/#! ?/, "").split(" ");
+    const binary = path8.split("/").pop();
     if (binary === "env") {
       return argument;
     }
@@ -12959,7 +12959,7 @@ var require_readShebang = __commonJS((exports2, module) => {
 
 // ../node_modules/cross-spawn/lib/parse.js
 var require_parse = __commonJS((exports2, module) => {
-  var path7 = __require("path");
+  var path8 = __require("path");
   var resolveCommand = require_resolveCommand();
   var escape = require_escape();
   var readShebang = require_readShebang();
@@ -12984,7 +12984,7 @@ var require_parse = __commonJS((exports2, module) => {
     const needsShell = !isExecutableRegExp.test(commandFile);
     if (parsed.options.forceShell || needsShell) {
       const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
-      parsed.command = path7.normalize(parsed.command);
+      parsed.command = path8.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(" ");
@@ -13088,7 +13088,7 @@ var require_cross_spawn = __commonJS((exports2, module) => {
 });
 
 // src/run.ts
-import path20 from "path";
+import path21 from "path";
 
 // ../common/src/env-schema.ts
 import z from "zod/v4";
@@ -17361,6 +17361,13 @@ function loadTeamConfig(teamName) {
   }
   return result.data;
 }
+async function saveTeamConfig(teamName, config) {
+  const configPath = getTeamConfigPath(teamName);
+  await withLock(configPath, () => {
+    fs2.mkdirSync(path2.dirname(configPath), { recursive: true });
+    fs2.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  });
+}
 function deleteTeam(teamName) {
   const teamDir = getTeamDir(teamName);
   if (fs2.existsSync(teamDir)) {
@@ -21571,18 +21578,165 @@ function getMinimumPhaseForTool(toolName39) {
 var import_lodash13 = __toESM(require_lodash(), 1);
 
 // ../packages/agent-runtime/src/team-context.ts
+import * as fs4 from "fs";
+
+// ../common/src/utils/team-discovery.ts
 import * as fs3 from "fs";
+import * as path3 from "path";
+import * as os2 from "os";
+function getLastActiveTeamPath() {
+  return path3.join(os2.homedir(), ".config", "levelcode", "teams", ".last-active-team");
+}
+function setLastActiveTeam(teamName) {
+  try {
+    const filePath = getLastActiveTeamPath();
+    fs3.mkdirSync(path3.dirname(filePath), { recursive: true });
+    fs3.writeFileSync(filePath, teamName, "utf-8");
+  } catch {}
+}
+function getLastActiveTeam() {
+  try {
+    const filePath = getLastActiveTeamPath();
+    if (!fs3.existsSync(filePath)) {
+      return null;
+    }
+    const name = fs3.readFileSync(filePath, "utf-8").trim();
+    return name || null;
+  } catch {
+    return null;
+  }
+}
+function readTeamEntries() {
+  let teamsDir;
+  try {
+    teamsDir = getTeamsDir();
+  } catch {
+    return [];
+  }
+  if (!fs3.existsSync(teamsDir)) {
+    return [];
+  }
+  try {
+    return fs3.readdirSync(teamsDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+}
+function safeLoadTeamConfig(teamName) {
+  try {
+    const config = loadTeamConfig(teamName);
+    if (!config || !Array.isArray(config.members)) {
+      return null;
+    }
+    return config;
+  } catch {
+    return null;
+  }
+}
+function loadAllTeamConfigs() {
+  const entries = readTeamEntries();
+  const results = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const config = safeLoadTeamConfig(entry.name);
+    if (config) {
+      results.push({ teamName: config.name, config });
+    }
+  }
+  return results;
+}
+function findCurrentTeam(agentId) {
+  const allTeams = loadAllTeamConfigs();
+  for (const { teamName, config } of allTeams) {
+    if (config.leadAgentId === `lead-${agentId}`) {
+      return { teamName, config };
+    }
+    for (const member of config.members) {
+      if (member.agentId === `lead-${agentId}` || member.agentId === agentId) {
+        return { teamName, config };
+      }
+    }
+  }
+  if (allTeams.length === 1) {
+    return allTeams[0];
+  }
+  const lastActive = getLastActiveTeam();
+  if (lastActive) {
+    const match = allTeams.find((t) => t.teamName === lastActive);
+    if (match) {
+      return match;
+    }
+  }
+  return null;
+}
+function findCurrentTeamAndAgent(agentId) {
+  const allTeams = loadAllTeamConfigs();
+  for (const { teamName, config } of allTeams) {
+    for (const member of config.members) {
+      if (member.agentId === `lead-${agentId}` || member.agentId === agentId) {
+        return { teamName, agentName: member.name, config };
+      }
+    }
+  }
+  let resolved = null;
+  if (allTeams.length === 1) {
+    resolved = allTeams[0];
+  } else {
+    const lastActive = getLastActiveTeam();
+    if (lastActive) {
+      resolved = allTeams.find((t) => t.teamName === lastActive) ?? null;
+    }
+  }
+  if (resolved) {
+    const leadMember = resolved.config.members.find((m) => m.agentId === resolved.config.leadAgentId);
+    const agentName = leadMember?.name ?? "team-lead";
+    return { teamName: resolved.teamName, agentName, config: resolved.config };
+  }
+  return null;
+}
+function findTeamByName(name) {
+  try {
+    validateTeamName(name);
+  } catch {
+    return null;
+  }
+  return safeLoadTeamConfig(name);
+}
+function listAllTeams() {
+  const entries = readTeamEntries();
+  const results = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const config = safeLoadTeamConfig(entry.name);
+    if (!config) {
+      continue;
+    }
+    results.push({
+      name: config.name,
+      phase: config.phase,
+      memberCount: config.members.length
+    });
+  }
+  return results;
+}
+
+// ../packages/agent-runtime/src/team-context.ts
 function findTeamContext(agentIdentifier) {
   const teamsDir = getTeamsDir();
-  if (!fs3.existsSync(teamsDir)) {
+  if (!fs4.existsSync(teamsDir)) {
     return null;
   }
   let entries;
   try {
-    entries = fs3.readdirSync(teamsDir, { withFileTypes: true });
+    entries = fs4.readdirSync(teamsDir, { withFileTypes: true });
   } catch {
     return null;
   }
+  const allTeams = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) {
       continue;
@@ -21591,12 +21745,30 @@ function findTeamContext(agentIdentifier) {
     if (!config) {
       continue;
     }
+    allTeams.push({ teamName: config.name, config });
+  }
+  for (const { teamName, config } of allTeams) {
     for (const member of config.members) {
       if (member.agentId === agentIdentifier || member.agentId === `lead-${agentIdentifier}`) {
-        return { teamName: config.name, agentName: member.name, config };
+        return { teamName, agentName: member.name, config };
       }
     }
   }
+  function resolveFromTeam(team) {
+    const leadMember = team.config.members.find((m) => m.agentId === team.config.leadAgentId);
+    const agentName = leadMember?.name ?? "team-lead";
+    return { teamName: team.teamName, agentName, config: team.config };
+  }
+  if (allTeams.length === 1) {
+    return resolveFromTeam(allTeams[0]);
+  }
+  const lastActive = getLastActiveTeam();
+  if (lastActive) {
+    const match = allTeams.find((t) => t.teamName === lastActive);
+    if (match) {
+      return resolveFromTeam(match);
+    }
+  }
   return null;
 }
 
@@ -24551,8 +24723,8 @@ var import_lodash4 = __toESM(require_lodash(), 1);
 init_model_config();
 
 // ../common/src/util/file.ts
-import * as os2 from "os";
-import * as path3 from "path";
+import * as os3 from "os";
+import * as path4 from "path";
 import { z as z71 } from "zod/v4";
 var FileTreeNodeSchema = z71.object({
   name: z71.string(),
@@ -24630,9 +24802,9 @@ function printFileTree(nodes, depth = 0) {
   }
   return result;
 }
-function printFileTreeWithTokens(nodes, fileTokenScores, path4 = []) {
+function printFileTreeWithTokens(nodes, fileTokenScores, path5 = []) {
   let result = "";
-  const depth = path4.length;
+  const depth = path5.length;
   const indentToken = " ";
   const indentation = indentToken.repeat(depth);
   const indentationWithFile = indentToken.repeat(depth + 1);
@@ -24641,8 +24813,8 @@ function printFileTreeWithTokens(nodes, fileTokenScores, path4 = []) {
       continue;
     }
     result += `${indentation}${node.name}${node.type === "directory" ? "/" : ""}`;
-    path4.push(node.name);
-    const filePath = path4.join("/");
+    path5.push(node.name);
+    const filePath = path5.join("/");
     const tokenScores = fileTokenScores[filePath];
     if (node.type === "file" && tokenScores) {
       const tokens = Object.keys(tokenScores);
@@ -24654,16 +24826,16 @@ ${indentationWithFile}${tokens.join(" ")}`;
     result += `
 `;
     if (node.type === "directory" && node.children) {
-      result += printFileTreeWithTokens(node.children, fileTokenScores, path4);
+      result += printFileTreeWithTokens(node.children, fileTokenScores, path5);
     }
-    path4.pop();
+    path5.pop();
   }
   return result;
 }
 async function fileExists(params2) {
-  const { filePath, fs: fs4 } = params2;
+  const { filePath, fs: fs5 } = params2;
   try {
-    await fs4.stat(filePath);
+    await fs5.stat(filePath);
     return true;
   } catch {
     return false;
@@ -24674,19 +24846,19 @@ var cleanMarkdownCodeBlock = (content) => {
   return cleanResponse;
 };
 function isSubdir(fromPath, toPath) {
-  const resolvedFrom = path3.resolve(fromPath);
-  const resolvedTo = path3.resolve(toPath);
+  const resolvedFrom = path4.resolve(fromPath);
+  const resolvedTo = path4.resolve(toPath);
   if (process.platform === "win32") {
-    const fromDrive = path3.parse(resolvedFrom).root.toLowerCase();
-    const toDrive = path3.parse(resolvedTo).root.toLowerCase();
+    const fromDrive = path4.parse(resolvedFrom).root.toLowerCase();
+    const toDrive = path4.parse(resolvedTo).root.toLowerCase();
     if (fromDrive !== toDrive) {
       return false;
     }
   }
-  return !path3.relative(resolvedFrom, resolvedTo).startsWith("..");
+  return !path4.relative(resolvedFrom, resolvedTo).startsWith("..");
 }
 function isValidProjectRoot(dir) {
-  return !isSubdir(dir, os2.homedir());
+  return !isSubdir(dir, os3.homedir());
 }
 
 // ../packages/agent-runtime/src/process-file-block.ts
@@ -30013,7 +30185,7 @@ function countTokensJson(text) {
 // ../packages/agent-runtime/src/process-file-block.ts
 async function processFileBlock(params2) {
   const {
-    path: path4,
+    path: path5,
     initialContentPromise,
     newContent,
     messages,
@@ -30028,28 +30200,28 @@ async function processFileBlock(params2) {
   const initialContent = await initialContentPromise;
   if (initialContent === null) {
     let cleanContent = cleanMarkdownCodeBlock(newContent);
-    if (hasLazyEdit(cleanContent) && !path4.endsWith(".md")) {
-      logger2.debug({ path: path4, newContent }, `processFileBlock: New file contained a lazy edit for ${path4}. Aborting.`);
+    if (hasLazyEdit(cleanContent) && !path5.endsWith(".md")) {
+      logger2.debug({ path: path5, newContent }, `processFileBlock: New file contained a lazy edit for ${path5}. Aborting.`);
       return promptSuccess({
         tool: "write_file",
-        path: path4,
+        path: path5,
         error: "You created a new file with a placeholder comment like `// ... existing code ...` (or equivalent for other languages). Are you sure you have the file path right? You probably meant to modify an existing file instead of providing a path to a new file."
       });
     }
-    logger2.debug({ path: path4, cleanContent }, `processFileBlock: Created new file ${path4}`);
+    logger2.debug({ path: path5, cleanContent }, `processFileBlock: Created new file ${path5}`);
     return promptSuccess({
       tool: "write_file",
-      path: path4,
+      path: path5,
       content: cleanContent,
       patch: undefined,
-      messages: [`Created new file ${path4}`]
+      messages: [`Created new file ${path5}`]
     });
   }
   if (newContent === initialContent) {
-    logger2.info({ newContent }, `processFileBlock: New was same as old, skipping ${path4}`);
+    logger2.info({ newContent }, `processFileBlock: New was same as old, skipping ${path5}`);
     return promptSuccess({
       tool: "write_file",
-      path: path4,
+      path: path5,
       error: "The new content was the same as the old content, skipping."
     });
   }
@@ -30070,7 +30242,7 @@ async function processFileBlock(params2) {
       ...params2,
       oldContent: normalizedInitialContent,
       editSnippet: normalizedEditSnippet,
-      filePath: path4
+      filePath: path5
     });
     if (largeFileResult.aborted) {
       return promptAborted(largeFileResult.reason);
@@ -30079,7 +30251,7 @@ async function processFileBlock(params2) {
     if (!largeFileContent) {
       return promptSuccess({
         tool: "write_file",
-        path: path4,
+        path: path5,
         error: "Failed to apply the write file change to this large file. You should try using the str_replace tool instead for large files."
       });
     }
@@ -30089,12 +30261,12 @@ async function processFileBlock(params2) {
       ...params2,
       initialContent: normalizedInitialContent,
       editSnippet: normalizedEditSnippet,
-      filePath: path4,
+      filePath: path5,
       userMessage: lastUserPrompt
     });
     const shouldAddPlaceholders = await shouldAddFilePlaceholders({
       ...params2,
-      filePath: path4,
+      filePath: path5,
       oldContent: normalizedInitialContent,
       rewrittenNewContent: updatedContent,
       messageHistory: messages
@@ -30108,12 +30280,12 @@ ${placeholderComment}`;
         ...params2,
         initialContent: normalizedInitialContent,
         editSnippet: updatedEditSnippet,
-        filePath: path4,
+        filePath: path5,
         userMessage: lastUserPrompt
       });
     }
   }
-  let patch = createPatch(path4, normalizedInitialContent, updatedContent);
+  let patch = createPatch(path5, normalizedInitialContent, updatedContent);
   const lines = patch.split(`
 `);
   const hunkStartIndex = lines.findIndex((line) => line.startsWith("@@"));
@@ -30123,34 +30295,34 @@ ${placeholderComment}`;
   } else {
     editMessages.push("The new content was the same as the old content, skipping.");
     logger2.debug({
-      path: path4,
+      path: path5,
       initialContent,
       changes: newContent,
       patch,
       editMessages
-    }, `processFileBlock: No change to ${path4}`);
+    }, `processFileBlock: No change to ${path5}`);
     return promptSuccess({
       tool: "write_file",
-      path: path4,
+      path: path5,
       error: editMessages.join(`
 
 `)
     });
   }
   logger2.debug({
-    path: path4,
+    path: path5,
     editSnippet: newContent,
     updatedContent,
     patch,
     editMessages
-  }, `processFileBlock: Updated file ${path4}`);
+  }, `processFileBlock: Updated file ${path5}`);
   const patchOriginalLineEndings = patch.replaceAll(`
 `, lineEnding);
   const updatedContentOriginalLineEndings = updatedContent.replaceAll(`
 `, lineEnding);
   return promptSuccess({
     tool: "write_file",
-    path: path4,
+    path: path5,
     content: updatedContentOriginalLineEndings,
     patch: patchOriginalLineEndings,
     messages: editMessages
@@ -30267,21 +30439,21 @@ var handleWriteFile = async (params2) => {
     requestOptionalFile,
     writeToClient
   } = params2;
-  const { path: path4, instructions, content } = toolCall.input;
+  const { path: path5, instructions, content } = toolCall.input;
   const fileProcessingPromisesByPath = fileProcessingState2.promisesByPath;
   const fileProcessingPromises = fileProcessingState2.allPromises;
-  if (!fileProcessingPromisesByPath[path4]) {
-    fileProcessingPromisesByPath[path4] = [];
+  if (!fileProcessingPromisesByPath[path5]) {
+    fileProcessingPromisesByPath[path5] = [];
   }
-  const previousPromises = fileProcessingPromisesByPath[path4];
+  const previousPromises = fileProcessingPromisesByPath[path5];
   const previousEdit = previousPromises[previousPromises.length - 1];
-  const latestContentPromise = previousEdit ? previousEdit.then((maybeResult) => maybeResult && ("content" in maybeResult) ? maybeResult.content : requestOptionalFile({ ...params2, filePath: path4 })) : requestOptionalFile({ ...params2, filePath: path4 });
+  const latestContentPromise = previousEdit ? previousEdit.then((maybeResult) => maybeResult && ("content" in maybeResult) ? maybeResult.content : requestOptionalFile({ ...params2, filePath: path5 })) : requestOptionalFile({ ...params2, filePath: path5 });
   const fileContentWithoutStartNewline = content.startsWith(`
 `) ? content.slice(1) : content;
-  logger2.debug({ path: path4, content }, `write_file ${path4}`);
+  logger2.debug({ path: path5, content }, `write_file ${path5}`);
   const newPromise = processFileBlock({
     ...params2,
-    path: path4,
+    path: path5,
     instructions,
     initialContentPromise: latestContentPromise,
     newContent: fileContentWithoutStartNewline,
@@ -30303,14 +30475,14 @@ var handleWriteFile = async (params2) => {
     logger2.error(error, "Error processing write_file block");
     return {
       tool: "write_file",
-      path: path4,
+      path: path5,
       error: `Error: Failed to process the write_file block. ${typeof error === "string" ? error : error.msg}`
     };
   }).then(async (fileProcessingResult) => ({
     ...fileProcessingResult,
     toolCallId: toolCall.toolCallId
   }));
-  fileProcessingPromisesByPath[path4].push(newPromise);
+  fileProcessingPromisesByPath[path5].push(newPromise);
   fileProcessingPromises.push(newPromise);
   await previousToolCallFinished;
   return {
@@ -30340,12 +30512,12 @@ async function postStreamProcessing(toolCall, fileProcessingState2, writeToClien
     if (errors.length > 1) {
       throw new Error(`Internal error: Unexpected number of matching errors for ${JSON.stringify(toolCall)}, found ${errors.length}, expected 1`);
     }
-    const { path: path5, error } = errors[0];
+    const { path: path6, error } = errors[0];
     return [
       {
         type: "json",
         value: {
-          file: path5,
+          file: path6,
           errorMessage: error
         }
       }
@@ -30355,11 +30527,11 @@ async function postStreamProcessing(toolCall, fileProcessingState2, writeToClien
   if (changes.length !== 1) {
     throw new Error(`Internal error: Unexpected number of matching changes for ${JSON.stringify(toolCall)}, found ${changes.length}, expected 1`);
   }
-  const { patch, content, path: path4 } = changes[0];
+  const { patch, content, path: path5 } = changes[0];
   const clientToolCall = {
     toolCallId: toolCall.toolCallId,
     toolName: toolCall.tool,
-    input: patch ? { type: "patch", path: path4, content: patch } : { type: "file", path: path4, content }
+    input: patch ? { type: "patch", path: path5, content: patch } : { type: "file", path: path5, content }
   };
   return await requestClientToolCall(clientToolCall);
 }
@@ -30374,19 +30546,19 @@ var handleCreatePlan = async (params2) => {
     requestClientToolCall,
     writeToClient
   } = params2;
-  const { path: path4, plan } = toolCall.input;
+  const { path: path5, plan } = toolCall.input;
   logger2.debug({
-    path: path4,
+    path: path5,
     plan
   }, "Create plan");
   const change = {
     tool: "create_plan",
-    path: path4,
+    path: path5,
     content: plan,
     messages: [],
     toolCallId: toolCall.toolCallId
   };
-  fileProcessingState2.promisesByPath[path4].push(Promise.resolve(change));
+  fileProcessingState2.promisesByPath[path5].push(Promise.resolve(change));
   fileProcessingState2.allPromises.push(Promise.resolve(change));
   await previousToolCallFinished;
   return {
@@ -30403,12 +30575,12 @@ var handleEndTurn = async (params2) => {
 
 // ../packages/agent-runtime/src/find-files/request-files-prompt.ts
 init_old_constants();
-import { dirname as dirname4, isAbsolute, normalize } from "path";
+import { dirname as dirname5, isAbsolute, normalize } from "path";
 
 // ../common/src/project-file-tree.ts
 var import_lodash5 = __toESM(require_lodash(), 1);
 init_paths();
-import path4 from "path";
+import path5 from "path";
 import * as ignore from "ignore";
 function logFileTreeError(operation, filePath, error) {
   if (!process.env.DEBUG && !process.env.LEVELCODE_DEBUG) {
@@ -30422,7 +30594,7 @@ function logFileTreeError(operation, filePath, error) {
 var DEFAULT_MAX_FILES = 1e4;
 async function getProjectFileTree(params2) {
   const withDefaults = { maxFiles: DEFAULT_MAX_FILES, ...params2 };
-  const { projectRoot, fs: fs4 } = withDefaults;
+  const { projectRoot, fs: fs5 } = withDefaults;
   let { maxFiles } = withDefaults;
   const _start = Date.now();
   const defaultIgnore = ignore.default();
@@ -30434,7 +30606,7 @@ async function getProjectFileTree(params2) {
     maxFiles = 0;
   }
   const root = {
-    name: path4.basename(projectRoot),
+    name: path5.basename(projectRoot),
     type: "directory",
     children: [],
     filePath: ""
@@ -30452,20 +30624,20 @@ async function getProjectFileTree(params2) {
     const parsedIgnore = await parseGitignore({
       fullDirPath: fullPath,
       projectRoot,
-      fs: fs4
+      fs: fs5
     });
     const mergedIgnore = ignore.default().add(currentIgnore).add(parsedIgnore);
     try {
-      const files = await fs4.readdir(fullPath);
+      const files = await fs5.readdir(fullPath);
       for (const file of files) {
         if (totalFiles >= maxFiles)
           break;
-        const filePath = path4.join(fullPath, file);
-        const relativeFilePath = path4.relative(projectRoot, filePath);
+        const filePath = path5.join(fullPath, file);
+        const relativeFilePath = path5.relative(projectRoot, filePath);
         if (mergedIgnore.ignores(relativeFilePath))
           continue;
         try {
-          const stats = await fs4.stat(filePath);
+          const stats = await fs5.stat(filePath);
           if (stats.isDirectory()) {
             const childNode = {
               name: file,
@@ -30527,21 +30699,21 @@ function rebaseGitignorePattern(rawPattern, relativeDirPath) {
   return isNegated ? `!${rebased}` : rebased;
 }
 async function parseGitignore(params2) {
-  const { fullDirPath, projectRoot, fs: fs4 } = params2;
+  const { fullDirPath, projectRoot, fs: fs5 } = params2;
   const ig = ignore.default();
-  const relativeDirPath = path4.relative(projectRoot, fullDirPath);
+  const relativeDirPath = path5.relative(projectRoot, fullDirPath);
   const ignoreFiles = [
-    path4.join(fullDirPath, ".gitignore"),
-    path4.join(fullDirPath, ".levelcodeignore"),
-    path4.join(fullDirPath, ".manicodeignore")
+    path5.join(fullDirPath, ".gitignore"),
+    path5.join(fullDirPath, ".levelcodeignore"),
+    path5.join(fullDirPath, ".manicodeignore")
   ];
   for (const ignoreFilePath of ignoreFiles) {
-    const ignoreFileExists = await fileExists({ filePath: ignoreFilePath, fs: fs4 });
+    const ignoreFileExists = await fileExists({ filePath: ignoreFilePath, fs: fs5 });
     if (!ignoreFileExists)
       continue;
     let ignoreContent;
     try {
-      ignoreContent = await fs4.readFile(ignoreFilePath, "utf8");
+      ignoreContent = await fs5.readFile(ignoreFilePath, "utf8");
     } catch (error) {
       logFileTreeError("fs.readFile (ignore file)", ignoreFilePath, error);
       continue;
@@ -30561,9 +30733,9 @@ async function parseGitignore(params2) {
 function getAllFilePaths(nodes, basePath = "") {
   return nodes.flatMap((node) => {
     if (node.type === "file") {
-      return [path4.join(basePath, node.name)];
+      return [path5.join(basePath, node.name)];
     }
-    return getAllFilePaths(node.children || [], path4.join(basePath, node.name));
+    return getAllFilePaths(node.children || [], path5.join(basePath, node.name));
   });
 }
 function flattenTree(nodes) {
@@ -30578,18 +30750,18 @@ function getLastReadFilePaths(flattenedNodes, count) {
   return import_lodash5.sortBy(flattenedNodes.filter((node) => node.lastReadTime), "lastReadTime").reverse().slice(0, count).map((node) => node.filePath);
 }
 async function isFileIgnored(params2) {
-  const { filePath, projectRoot, fs: fs4 } = params2;
+  const { filePath, projectRoot, fs: fs5 } = params2;
   const defaultIgnore = ignore.default();
   for (const pattern of DEFAULT_IGNORED_PATHS) {
     defaultIgnore.add(pattern);
   }
-  const relativeFilePath = path4.relative(projectRoot, path4.join(projectRoot, filePath));
-  const dirPath = path4.dirname(path4.join(projectRoot, filePath));
+  const relativeFilePath = path5.relative(projectRoot, path5.join(projectRoot, filePath));
+  const dirPath = path5.dirname(path5.join(projectRoot, filePath));
   const mergedIgnore = ignore.default().add(defaultIgnore);
   let currentDir = dirPath;
   while (currentDir.startsWith(projectRoot)) {
-    mergedIgnore.add(await parseGitignore({ fullDirPath: currentDir, projectRoot, fs: fs4 }));
-    currentDir = path4.dirname(currentDir);
+    mergedIgnore.add(await parseGitignore({ fullDirPath: currentDir, projectRoot, fs: fs5 }));
+    currentDir = path5.dirname(currentDir);
   }
   return mergedIgnore.ignores(relativeFilePath);
 }
@@ -30999,11 +31171,11 @@ function getExampleFileList(params2) {
   const selectedFiles = new Set;
   const selectedDirectories = new Set;
   for (const filePath of randomFilePaths) {
-    if (selectedFiles.has(filePath) || selectedDirectories.has(dirname4(filePath))) {
+    if (selectedFiles.has(filePath) || selectedDirectories.has(dirname5(filePath))) {
       continue;
     }
     selectedFiles.add(filePath);
-    selectedDirectories.add(dirname4(filePath));
+    selectedDirectories.add(dirname5(filePath));
   }
   return import_lodash8.uniq([...selectedFiles, ...randomFilePaths]).slice(0, count);
 }
@@ -31130,9 +31302,9 @@ async function getFileReadingUpdates(params2) {
   const { requestFiles, requestedFiles } = params2;
   const allFilePaths = import_lodash9.uniq(requestedFiles);
   const loadedFiles = await requestFiles({ filePaths: allFilePaths });
-  const addedFiles = allFilePaths.filter((path5) => loadedFiles[path5] != null && loadedFiles[path5] !== undefined).map((path5) => ({
-    path: path5,
-    content: loadedFiles[path5]
+  const addedFiles = allFilePaths.filter((path6) => loadedFiles[path6] != null && loadedFiles[path6] !== undefined).map((path6) => ({
+    path: path6,
+    content: loadedFiles[path6]
   }));
   return addedFiles;
 }
@@ -31546,7 +31718,7 @@ ${systemInfo.platform === "win32" ? windowsNote + `
 Shell: ${systemInfo.shell}
 
 <user_shell_config_files>
-${Object.entries(shellConfigFiles).map(([path5, content]) => createMarkdownFileBlock(path5, content)).join(`
+${Object.entries(shellConfigFiles).map(([path6, content]) => createMarkdownFileBlock(path6, content)).join(`
 `)}
 ${closeXml("user_shell_config_files")}
 
@@ -31826,12 +31998,12 @@ function normalizeLineEndings(params2) {
 `);
 }
 async function processStrReplace(params2) {
-  const { path: path5, replacements, initialContentPromise, logger: logger2 } = params2;
+  const { path: path6, replacements, initialContentPromise, logger: logger2 } = params2;
   const initialContent = await initialContentPromise;
   if (initialContent === null) {
     return {
       tool: "str_replace",
-      path: path5,
+      path: path6,
       error: "The file does not exist, skipping. Please use the write_file tool to create the file."
     };
   }
@@ -31871,19 +32043,19 @@ async function processStrReplace(params2) {
 `, lineEnding);
   if (initialContent === currentContent) {
     logger2.debug({
-      path: path5,
+      path: path6,
       initialContent
-    }, `processStrReplace: No change to ${path5}`);
+    }, `processStrReplace: No change to ${path6}`);
     messages.push("No change to the file");
     return {
       tool: "str_replace",
-      path: path5,
+      path: path6,
       error: messages.join(`
 
 `)
     };
   }
-  let patch = createPatch2(path5, initialContent, currentContent);
+  let patch = createPatch2(path6, initialContent, currentContent);
   const lines = patch.split(`
 `);
   const hunkStartIndex = lines.findIndex((line) => line.startsWith("@@"));
@@ -31893,14 +32065,14 @@ async function processStrReplace(params2) {
   }
   const finalPatch = patch;
   logger2.debug({
-    path: path5,
+    path: path6,
     newContent: currentContent,
     patch: finalPatch,
     messages
-  }, `processStrReplace: Updated file ${path5}`);
+  }, `processStrReplace: Updated file ${path6}`);
   return {
     tool: "str_replace",
-    path: path5,
+    path: path6,
     content: currentContent,
     patch: finalPatch,
     messages
@@ -31972,17 +32144,17 @@ var handleProposeStrReplace = async (params2) => {
     runId,
     requestOptionalFile
   } = params2;
-  const { path: path5, replacements } = toolCall.input;
+  const { path: path6, replacements } = toolCall.input;
   const getProposedOrDiskContent = async () => {
-    const proposedContent = getProposedContent(runId, path5);
+    const proposedContent = getProposedContent(runId, path6);
     if (proposedContent !== undefined) {
       return proposedContent;
     }
-    return requestOptionalFile({ ...params2, filePath: path5 });
+    return requestOptionalFile({ ...params2, filePath: path6 });
   };
   const latestContentPromise = getProposedOrDiskContent();
   const strReplaceResultPromise = processStrReplace({
-    path: path5,
+    path: path6,
     replacements,
     initialContentPromise: latestContentPromise,
     logger: logger2
@@ -31990,11 +32162,11 @@ var handleProposeStrReplace = async (params2) => {
     logger2.error(error, "Error processing propose_str_replace");
     return {
       tool: "str_replace",
-      path: path5,
+      path: path6,
       error: "Unknown error: Failed to process the propose_str_replace."
     };
   });
-  setProposedContent(runId, path5, strReplaceResultPromise.then((result) => ("content" in result) ? result.content : null));
+  setProposedContent(runId, path6, strReplaceResultPromise.then((result) => ("content" in result) ? result.content : null));
   await previousToolCallFinished;
   const strReplaceResult = await strReplaceResultPromise;
   if ("error" in strReplaceResult) {
@@ -32003,7 +32175,7 @@ var handleProposeStrReplace = async (params2) => {
         {
           type: "json",
           value: {
-            file: path5,
+            file: path6,
             errorMessage: strReplaceResult.error
           }
         }
@@ -32018,7 +32190,7 @@ var handleProposeStrReplace = async (params2) => {
       {
         type: "json",
         value: {
-          file: path5,
+          file: path6,
           message,
           unifiedDiff: strReplaceResult.patch
         }
@@ -32037,21 +32209,21 @@ var handleProposeWriteFile = async (params2) => {
     runId,
     requestOptionalFile
   } = params2;
-  const { path: path5, content } = toolCall.input;
+  const { path: path6, content } = toolCall.input;
   const getProposedOrDiskContent = async () => {
-    const proposedContent = getProposedContent(runId, path5);
+    const proposedContent = getProposedContent(runId, path6);
     if (proposedContent !== undefined) {
       return proposedContent;
     }
-    return requestOptionalFile({ ...params2, filePath: path5 });
+    return requestOptionalFile({ ...params2, filePath: path6 });
   };
   const initialContent = await getProposedOrDiskContent();
   const newContent = content.startsWith(`
 `) ? content.slice(1) : content;
-  setProposedContent(runId, path5, Promise.resolve(newContent));
+  setProposedContent(runId, path6, Promise.resolve(newContent));
   await previousToolCallFinished;
   const oldContent = initialContent ?? "";
-  let patch = createPatch3(path5, oldContent, newContent);
+  let patch = createPatch3(path6, oldContent, newContent);
   const lines = patch.split(`
 `);
   const hunkStartIndex = lines.findIndex((line) => line.startsWith("@@"));
@@ -32060,13 +32232,13 @@ var handleProposeWriteFile = async (params2) => {
 `);
   }
   const isNewFile = initialContent === null;
-  const message = isNewFile ? `Proposed new file ${path5}` : `Proposed changes to ${path5}`;
+  const message = isNewFile ? `Proposed new file ${path6}` : `Proposed changes to ${path6}`;
   return {
     output: [
       {
         type: "json",
         value: {
-          file: path5,
+          file: path6,
           message,
           unifiedDiff: patch
         }
@@ -33202,15 +33374,15 @@ var handleStrReplace = async (params2) => {
     requestOptionalFile,
     writeToClient
   } = params2;
-  const { path: path5, replacements } = toolCall.input;
-  if (!fileProcessingState2.promisesByPath[path5]) {
-    fileProcessingState2.promisesByPath[path5] = [];
+  const { path: path6, replacements } = toolCall.input;
+  if (!fileProcessingState2.promisesByPath[path6]) {
+    fileProcessingState2.promisesByPath[path6] = [];
   }
-  const previousPromises = fileProcessingState2.promisesByPath[path5];
+  const previousPromises = fileProcessingState2.promisesByPath[path6];
   const previousEdit = previousPromises[previousPromises.length - 1];
-  const latestContentPromise = previousEdit ? previousEdit.then((maybeResult) => maybeResult && ("content" in maybeResult) ? maybeResult.content : requestOptionalFile({ ...params2, filePath: path5 })) : requestOptionalFile({ ...params2, filePath: path5 });
+  const latestContentPromise = previousEdit ? previousEdit.then((maybeResult) => maybeResult && ("content" in maybeResult) ? maybeResult.content : requestOptionalFile({ ...params2, filePath: path6 })) : requestOptionalFile({ ...params2, filePath: path6 });
   const newPromise = processStrReplace({
-    path: path5,
+    path: path6,
     replacements,
     initialContentPromise: latestContentPromise,
     logger: logger2
@@ -33218,14 +33390,14 @@ var handleStrReplace = async (params2) => {
     logger2.error(error, "Error processing str_replace block");
     return {
       tool: "str_replace",
-      path: path5,
+      path: path6,
       error: "Unknown error: Failed to process the str_replace block."
     };
   }).then((fileProcessingResult) => ({
     ...fileProcessingResult,
     toolCallId: toolCall.toolCallId
   }));
-  fileProcessingState2.promisesByPath[path5].push(newPromise);
+  fileProcessingState2.promisesByPath[path6].push(newPromise);
   fileProcessingState2.allPromises.push(newPromise);
   await previousToolCallFinished;
   const strReplaceResult = await newPromise;
@@ -33248,7 +33420,7 @@ var handleSuggestFollowups = async (params2) => {
 };
 
 // ../packages/agent-runtime/src/tools/handlers/tool/task-completed.ts
-import * as fs4 from "fs";
+import * as fs5 from "fs";
 
 // ../common/src/utils/team-hook-emitter.ts
 var listeners = new Set;
@@ -33305,10 +33477,10 @@ function emitTaskCompleted(params2) {
 // ../packages/agent-runtime/src/tools/handlers/tool/task-completed.ts
 function getActiveTeamName() {
   const teamsDir = getTeamsDir();
-  if (!fs4.existsSync(teamsDir)) {
+  if (!fs5.existsSync(teamsDir)) {
     return null;
   }
-  const entries = fs4.readdirSync(teamsDir, { withFileTypes: true });
+  const entries = fs5.readdirSync(teamsDir, { withFileTypes: true });
   const teamDirs = entries.filter((e) => e.isDirectory());
   if (teamDirs.length === 0) {
     return null;
@@ -33571,102 +33743,6 @@ var handleWriteTodos = async (params2) => {
   return { output: jsonToolResult({ message: "Todos written" }) };
 };
 
-// ../common/src/utils/team-discovery.ts
-import * as fs5 from "fs";
-function readTeamEntries() {
-  let teamsDir;
-  try {
-    teamsDir = getTeamsDir();
-  } catch {
-    return [];
-  }
-  if (!fs5.existsSync(teamsDir)) {
-    return [];
-  }
-  try {
-    return fs5.readdirSync(teamsDir, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-}
-function safeLoadTeamConfig(teamName) {
-  try {
-    const config = loadTeamConfig(teamName);
-    if (!config || !Array.isArray(config.members)) {
-      return null;
-    }
-    return config;
-  } catch {
-    return null;
-  }
-}
-function findCurrentTeam(agentId) {
-  const entries = readTeamEntries();
-  for (const entry of entries) {
-    if (!entry.isDirectory()) {
-      continue;
-    }
-    const config = safeLoadTeamConfig(entry.name);
-    if (!config) {
-      continue;
-    }
-    if (config.leadAgentId === `lead-${agentId}`) {
-      return { teamName: config.name, config };
-    }
-    for (const member of config.members) {
-      if (member.agentId === `lead-${agentId}` || member.agentId === agentId) {
-        return { teamName: config.name, config };
-      }
-    }
-  }
-  return null;
-}
-function findCurrentTeamAndAgent(agentId) {
-  const entries = readTeamEntries();
-  for (const entry of entries) {
-    if (!entry.isDirectory()) {
-      continue;
-    }
-    const config = safeLoadTeamConfig(entry.name);
-    if (!config) {
-      continue;
-    }
-    for (const member of config.members) {
-      if (member.agentId === `lead-${agentId}` || member.agentId === agentId) {
-        return { teamName: config.name, agentName: member.name, config };
-      }
-    }
-  }
-  return null;
-}
-function findTeamByName(name) {
-  try {
-    validateTeamName(name);
-  } catch {
-    return null;
-  }
-  return safeLoadTeamConfig(name);
-}
-function listAllTeams() {
-  const entries = readTeamEntries();
-  const results = [];
-  for (const entry of entries) {
-    if (!entry.isDirectory()) {
-      continue;
-    }
-    const config = safeLoadTeamConfig(entry.name);
-    if (!config) {
-      continue;
-    }
-    results.push({
-      name: config.name,
-      phase: config.phase,
-      memberCount: config.members.length
-    });
-  }
-  return results;
-}
-
 // ../packages/agent-runtime/src/tools/handlers/tool/send-message.ts
 function errorResult(message) {
   return { output: jsonToolResult({ message }) };
@@ -34050,7 +34126,7 @@ var handleTaskList = async (params2) => {
 
 // ../packages/agent-runtime/src/tools/handlers/tool/task-update.ts
 import * as fs6 from "fs";
-import * as path5 from "path";
+import * as path6 from "path";
 var VALID_STATUSES = ["pending", "in_progress", "completed", "blocked", "deleted"];
 function errorResult4(message) {
   return { output: jsonToolResult({ error: message }) };
@@ -34101,7 +34177,7 @@ var handleTaskUpdate = async (params2) => {
   }
   if (status === "deleted") {
     try {
-      const taskPath = path5.join(getTasksDir(teamName), `${taskId}.json`);
+      const taskPath = path6.join(getTasksDir(teamName), `${taskId}.json`);
       if (fs6.existsSync(taskPath)) {
         fs6.unlinkSync(taskPath);
       }
@@ -34239,6 +34315,7 @@ var handleTeamCreate = async (params2) => {
     const errorMessage = error instanceof Error ? error.message : String(error);
     return errorResult5(`Failed to create team "${team_name}": ${errorMessage}`);
   }
+  setLastActiveTeam(team_name);
   trackTeamCreated({ trackEvent: trackEvent2, userId: userId ?? "", logger: logger2 }, team_name, teamConfig.members.length);
   let teamFilePath;
   let taskDirPath;
@@ -35224,8 +35301,72 @@ async function executeSegmentsArray(segments, params2) {
   return toolResults2;
 }
 
+// ../packages/agent-runtime/src/team-lifecycle.ts
+var registry = new Map;
+async function updateAgentStatus(teamName, agentId, status, logger2) {
+  const teamMap = registry.get(teamName);
+  if (teamMap) {
+    const entry = teamMap.get(agentId);
+    if (entry) {
+      entry.status = status;
+    }
+  }
+  const config = loadTeamConfig(teamName);
+  if (!config) {
+    logger2.debug({ teamName, agentId, status }, "updateAgentStatus: team config not found");
+    return;
+  }
+  const memberIndex = config.members.findIndex((m) => m.agentId === agentId);
+  if (memberIndex === -1) {
+    logger2.debug({ teamName, agentId, status }, "updateAgentStatus: member not found in team config");
+    return;
+  }
+  config.members[memberIndex].status = status;
+  await saveTeamConfig(teamName, config);
+  logger2.debug({ teamName, agentId, status }, `updateAgentStatus: set status to "${status}"`);
+}
+async function markAgentIdle(params2) {
+  const { teamName, agentId, agentName, lastTaskId, trackEvent: trackEvent2, userId, logger: logger2 } = params2;
+  await updateAgentStatus(teamName, agentId, "idle", logger2);
+  const config = loadTeamConfig(teamName);
+  if (config) {
+    const member = config.members.find((m) => m.agentId === agentId);
+    if (member) {
+      member.currentTaskId = undefined;
+      await saveTeamConfig(teamName, config);
+    }
+  }
+  emitTeammateIdle({
+    agentName,
+    teamName,
+    lastTaskId,
+    trackEvent: trackEvent2,
+    userId,
+    logger: logger2
+  });
+  if (config) {
+    const leadMember = config.members.find((m) => m.agentId === config.leadAgentId);
+    const leadName = leadMember?.name ?? "team-lead";
+    const notification = {
+      type: "idle_notification",
+      from: agentName,
+      timestamp: new Date().toISOString(),
+      summary: lastTaskId ? `Completed task ${lastTaskId}, now idle` : "Agent is idle and ready for work",
+      completedTaskId: lastTaskId
+    };
+    await sendMessage(teamName, leadName, notification);
+    logger2.debug({ teamName, agentName, leadName, lastTaskId }, "markAgentIdle: sent idle notification to team lead");
+  }
+}
+async function checkIdleAfterTurn(params2) {
+  const { producedOutput, ...rest } = params2;
+  if (!producedOutput) {
+    await markAgentIdle(rest);
+  }
+}
+
 // ../common/src/constants/knowledge.ts
-import path6 from "path";
+import path7 from "path";
 var PRIMARY_KNOWLEDGE_FILE_NAME = "knowledge.md";
 var KNOWLEDGE_FILE_NAMES = [
   PRIMARY_KNOWLEDGE_FILE_NAME,
@@ -35234,7 +35375,7 @@ var KNOWLEDGE_FILE_NAMES = [
 ];
 var KNOWLEDGE_FILE_NAMES_LOWERCASE = KNOWLEDGE_FILE_NAMES.map((name) => name.toLowerCase());
 function isKnowledgeFile(filePath) {
-  const fileName = path6.basename(filePath).toLowerCase();
+  const fileName = path7.basename(filePath).toLowerCase();
   if (KNOWLEDGE_FILE_NAMES_LOWERCASE.includes(fileName)) {
     return true;
   }
@@ -35326,10 +35467,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(([path7, content]) => [path7, content.trim()])),
+      }).map(([path8, content]) => [path8, content.trim()])),
       ...fileContext.userKnowledgeFiles
-    }).map(([path7, content]) => {
-      return `\`\`\`${path7}
+    }).map(([path8, content]) => {
+      return `\`\`\`${path8}
 ${content.trim()}
 \`\`\``;
     }).join(`
@@ -36417,6 +36558,69 @@ async function loopAgentSteps(params2) {
       currentPrompt = undefined;
       currentParams = undefined;
     }
+    const postLoopTeamContext = findTeamContext(userInputId2);
+    if (postLoopTeamContext && !signal.aborted) {
+      try {
+        await checkIdleAfterTurn({
+          teamName: postLoopTeamContext.teamName,
+          agentId: currentAgentState.agentId,
+          agentName: postLoopTeamContext.agentName,
+          producedOutput: totalSteps > 0,
+          trackEvent: params2.trackEvent,
+          userId: userId ?? "",
+          logger: logger2
+        });
+      } catch (idleErr) {
+        logger2.debug({ error: idleErr }, "checkIdleAfterTurn failed (non-fatal)");
+      }
+    }
+    if (postLoopTeamContext && !signal.aborted) {
+      try {
+        await new Promise((resolve3) => setTimeout(resolve3, 2000));
+        if (!signal.aborted) {
+          const wakeInbox = drainInbox({
+            teamName: postLoopTeamContext.teamName,
+            agentName: postLoopTeamContext.agentName,
+            logger: logger2
+          });
+          if (wakeInbox.formattedContent) {
+            logger2.debug({
+              teamName: postLoopTeamContext.teamName,
+              agentName: postLoopTeamContext.agentName,
+              messageCount: wakeInbox.messages.length
+            }, "Post-loop wake: new messages detected, running one more step");
+            currentAgentState.messageHistory = [
+              ...currentAgentState.messageHistory,
+              userMessage(withSystemTags(wakeInbox.formattedContent))
+            ];
+            currentAgentState.stepsRemaining = Math.max(currentAgentState.stepsRemaining, 1);
+            const wakeStep = await runAgentStep({
+              ...params2,
+              agentState: currentAgentState,
+              agentTemplate,
+              prompt: undefined,
+              runId,
+              spawnParams: undefined,
+              system,
+              tools,
+              additionalToolDefinitions: async () => {
+                if (!cachedAdditionalToolDefinitions) {
+                  cachedAdditionalToolDefinitions = await additionalToolDefinitions({
+                    ...params2,
+                    agentTemplate
+                  });
+                }
+                return cachedAdditionalToolDefinitions;
+              }
+            });
+            totalSteps++;
+            currentAgentState = wakeStep.agentState;
+          }
+        }
+      } catch (wakeErr) {
+        logger2.debug({ error: wakeErr }, "Post-loop wake check failed (non-fatal)");
+      }
+    }
     if (clearUserPromptMessagesAfterResponse) {
       currentAgentState.messageHistory = expireMessages(currentAgentState.messageHistory, "userPrompt");
     }
@@ -40240,7 +40444,7 @@ import {
 } from "ai";
 
 // src/impl/model-provider.ts
-import path8 from "path";
+import path9 from "path";
 import { createAnthropic } from "@ai-sdk/anthropic";
 
 // ../node_modules/@ai-sdk/provider/dist/index.mjs
@@ -43093,7 +43297,7 @@ function createOpenRouter(options = {}) {
   });
   const createChatModel = (modelId, settings = {}) => new OpenRouterChatLanguageModel(modelId, settings, {
     provider: "openrouter.chat",
-    url: ({ path: path7 }) => `${baseURL}${path7}`,
+    url: ({ path: path8 }) => `${baseURL}${path8}`,
     headers: getHeaders,
     compatibility,
     fetch: options.fetch,
@@ -43101,7 +43305,7 @@ function createOpenRouter(options = {}) {
   });
   const createCompletionModel = (modelId, settings = {}) => new OpenRouterCompletionLanguageModel(modelId, settings, {
     provider: "openrouter.completion",
-    url: ({ path: path7 }) => `${baseURL}${path7}`,
+    url: ({ path: path8 }) => `${baseURL}${path8}`,
     headers: getHeaders,
     compatibility,
     fetch: options.fetch,
@@ -43128,8 +43332,8 @@ var openrouter = createOpenRouter({
 
 // src/credentials.ts
 import fs7 from "fs";
-import path7 from "node:path";
-import os3 from "os";
+import path8 from "node:path";
+import os4 from "os";
 
 // ../common/src/util/credentials.ts
 import { z as z86 } from "zod/v4";
@@ -43169,18 +43373,18 @@ var userFromJson = (json) => {
 };
 var getLegacyConfigDir = (clientEnv = env) => {
   const envSuffix = clientEnv.NEXT_PUBLIC_CB_ENVIRONMENT && clientEnv.NEXT_PUBLIC_CB_ENVIRONMENT !== "prod" ? `-${clientEnv.NEXT_PUBLIC_CB_ENVIRONMENT}` : "";
-  return path7.join(os3.homedir(), ".config", `manicode${envSuffix}`);
+  return path8.join(os4.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 path7.join(os3.homedir(), ".config", `levelcode${envSuffix}`);
+  return path8.join(os4.homedir(), ".config", `levelcode${envSuffix}`);
 };
 var migrateFromLegacyConfigDir = (clientEnv = env) => {
   const newDir = getConfigDir(clientEnv);
-  const newCredsPath = path7.join(newDir, "credentials.json");
+  const newCredsPath = path8.join(newDir, "credentials.json");
   if (fs7.existsSync(newCredsPath))
     return;
-  const legacyCredsPath = path7.join(getLegacyConfigDir(clientEnv), "credentials.json");
+  const legacyCredsPath = path8.join(getLegacyConfigDir(clientEnv), "credentials.json");
   if (!fs7.existsSync(legacyCredsPath))
     return;
   try {
@@ -43190,7 +43394,7 @@ var migrateFromLegacyConfigDir = (clientEnv = env) => {
 };
 var getCredentialsPath = (clientEnv = env) => {
   migrateFromLegacyConfigDir(clientEnv);
-  return path7.join(getConfigDir(clientEnv), "credentials.json");
+  return path8.join(getConfigDir(clientEnv), "credentials.json");
 };
 var getUserCredentials = (clientEnv = env) => {
   const credentialsPath = getCredentialsPath(clientEnv);
@@ -43468,7 +43672,7 @@ function createLevelCodeBackendModel(apiKey, model) {
   const openrouterApiKey = getByokOpenrouterApiKeyFromEnv();
   return new OpenAICompatibleChatLanguageModel(model, {
     provider: "levelcode",
-    url: ({ path: endpoint }) => new URL(path8.join("/api/v1", endpoint), WEBSITE_URL).toString(),
+    url: ({ path: endpoint }) => new URL(path9.join("/api/v1", endpoint), WEBSITE_URL).toString(),
     headers: () => ({
       Authorization: `Bearer ${apiKey}`,
       "user-agent": `ai-sdk/openai-compatible/${VERSION2}/levelcode`,
@@ -43977,38 +44181,38 @@ var noopLogger = {
 };
 
 // src/run-state.ts
-import * as os6 from "os";
-import path14 from "path";
+import * as os7 from "os";
+import path15 from "path";
 
 // ../packages/code-map/src/parse.ts
 import * as fs10 from "fs";
-import * as path11 from "path";
+import * as path12 from "path";
 
 // ../packages/code-map/src/languages.ts
 import * as fs9 from "fs";
-import * as path10 from "path";
+import * as path11 from "path";
 import { Language, Parser as Parser2, Query } from "web-tree-sitter";
 
 // ../packages/code-map/src/init-node.ts
 import * as fs8 from "fs";
-import * as path9 from "path";
+import * as path10 from "path";
 import { Parser } from "web-tree-sitter";
 async function initTreeSitterForNode() {
   await Parser.init({
     locateFile: (name14, scriptDir) => {
       if (name14 === "tree-sitter.wasm") {
-        const fallback = path9.join(scriptDir, name14);
+        const fallback = path10.join(scriptDir, name14);
         if (fs8.existsSync(fallback)) {
           return fallback;
         }
-        const pkgDir = path9.dirname(__require.resolve("web-tree-sitter"));
-        const wasm = path9.join(pkgDir, "tree-sitter.wasm");
+        const pkgDir = path10.dirname(__require.resolve("web-tree-sitter"));
+        const wasm = path10.join(pkgDir, "tree-sitter.wasm");
         if (fs8.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 path9.join(scriptDir, name14);
+      return path10.join(scriptDir, name14);
     }
   });
 }
@@ -44348,23 +44552,23 @@ function getWasmDir() {
 function resolveWasmPath(wasmFileName) {
   const customWasmDirPath = getWasmDir();
   if (customWasmDirPath) {
-    return path10.join(customWasmDirPath, wasmFileName);
+    return path11.join(customWasmDirPath, wasmFileName);
   }
   const envWasmDir = process.env.LEVELCODE_WASM_DIR;
   if (envWasmDir) {
-    return path10.join(envWasmDir, wasmFileName);
+    return path11.join(envWasmDir, wasmFileName);
   }
   const moduleDir = (() => {
-    const dirname6 = getDirnameDynamically();
-    if (typeof dirname6 !== "undefined") {
-      return dirname6;
+    const dirname7 = getDirnameDynamically();
+    if (typeof dirname7 !== "undefined") {
+      return dirname7;
     }
     return process.cwd();
   })();
   const possiblePaths = [
-    path10.join(moduleDir, "..", "wasm", wasmFileName),
-    path10.join(moduleDir, "wasm", wasmFileName),
-    path10.join(process.cwd(), "dist", "wasm", wasmFileName)
+    path11.join(moduleDir, "..", "wasm", wasmFileName),
+    path11.join(moduleDir, "wasm", wasmFileName),
+    path11.join(process.cwd(), "dist", "wasm", wasmFileName)
   ];
   for (const wasmPath of possiblePaths) {
     try {
@@ -44408,7 +44612,7 @@ class UnifiedLanguageLoader {
   }
 }
 function findLanguageConfigByExtension(filePath) {
-  const ext = path10.extname(filePath);
+  const ext = path11.extname(filePath);
   return languageTable.find((c) => c.extensions.includes(ext));
 }
 async function createLanguageConfig(filePath, runtimeLoader) {
@@ -44422,7 +44626,7 @@ async function createLanguageConfig(filePath, runtimeLoader) {
       const lang = await runtimeLoader.loadLanguage(cfg.wasmFile);
       const parser = new Parser2;
       parser.setLanguage(lang);
-      const queryContent = path10.isAbsolute(cfg.queryPathOrContent) ? fs9.readFileSync(cfg.queryPathOrContent, "utf8") : cfg.queryPathOrContent;
+      const queryContent = path11.isAbsolute(cfg.queryPathOrContent) ? fs9.readFileSync(cfg.queryPathOrContent, "utf8") : cfg.queryPathOrContent;
       cfg.language = lang;
       cfg.parser = parser;
       cfg.query = new Query(lang, queryContent);
@@ -44454,7 +44658,7 @@ async function getFileTokenScores(projectRoot, filePaths, readFile) {
   const externalCalls = {};
   const fileCallsMap = new Map;
   for (const filePath of filePaths) {
-    const fullPath = path11.join(projectRoot, filePath);
+    const fullPath = path12.join(projectRoot, filePath);
     const languageConfig = await getLanguageConfig(fullPath);
     if (languageConfig) {
       let parseResults;
@@ -44466,7 +44670,7 @@ async function getFileTokenScores(projectRoot, filePaths, readFile) {
       const { identifiers, calls, numLines } = parseResults;
       const tokenScoresForFile = {};
       tokenScores[filePath] = tokenScoresForFile;
-      const dirs = path11.dirname(fullPath).split(path11.sep);
+      const dirs = path12.dirname(fullPath).split(path12.sep);
       const depth = dirs.length;
       const tokenBaseScore = 0.8 ** depth * Math.sqrt(numLines / (identifiers.length + 1));
       for (const identifier of identifiers) {
@@ -44602,8 +44806,8 @@ import z89 from "zod/v4";
 
 // src/agents/load-agents.ts
 import fs11 from "fs";
-import os4 from "os";
-import path12 from "path";
+import os5 from "os";
+import path13 from "path";
 import { pathToFileURL } from "url";
 
 // src/validate-agents.ts
@@ -44716,12 +44920,12 @@ var getAllAgentFiles = (dir) => {
   try {
     const entries = fs11.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path12.join(dir, entry.name);
+      const fullPath = path13.join(dir, entry.name);
       if (entry.isDirectory()) {
         files.push(...getAllAgentFiles(fullPath));
         continue;
       }
-      const extension = path12.extname(entry.name).toLowerCase();
+      const extension = path13.extname(entry.name).toLowerCase();
       const isAgentFile = entry.isFile() && agentFileExtensions.has(extension) && !entry.name.endsWith(".d.ts") && !entry.name.endsWith(".test.ts");
       if (isAgentFile) {
         files.push(fullPath);
@@ -44731,9 +44935,9 @@ var getAllAgentFiles = (dir) => {
   return files;
 };
 var getDefaultAgentDirs = () => {
-  const cwdAgents = path12.join(process.cwd(), ".agents");
-  const parentAgents = path12.join(process.cwd(), "..", ".agents");
-  const homeAgents = path12.join(os4.homedir(), ".agents");
+  const cwdAgents = path13.join(process.cwd(), ".agents");
+  const parentAgents = path13.join(process.cwd(), "..", ".agents");
+  const homeAgents = path13.join(os5.homedir(), ".agents");
   return [cwdAgents, parentAgents, homeAgents];
 };
 async function loadLocalAgents({
@@ -44823,8 +45027,8 @@ async function importAgentModule(fullPath) {
 
 // src/skills/load-skills.ts
 import fs12 from "fs";
-import os5 from "os";
-import path13 from "path";
+import os6 from "os";
+import path14 from "path";
 
 // ../common/src/constants/skills.ts
 var SKILLS_DIR_NAME = "skills";
@@ -44874,7 +45078,7 @@ function parseFrontmatter(content) {
   }
 }
 function loadSkillFromFile(skillDir, skillFilePath, verbose) {
-  const dirName = path13.basename(skillDir);
+  const dirName = path14.basename(skillDir);
   let content;
   try {
     content = fs12.readFileSync(skillFilePath, "utf8");
@@ -44923,7 +45127,7 @@ function discoverSkillsFromDirectory(skillsDir, verbose) {
     return skills;
   }
   for (const entry of entries) {
-    const skillDir = path13.join(skillsDir, entry);
+    const skillDir = path14.join(skillsDir, entry);
     try {
       const stat = fs12.statSync(skillDir);
       if (!stat.isDirectory())
@@ -44937,7 +45141,7 @@ function discoverSkillsFromDirectory(skillsDir, verbose) {
       }
       continue;
     }
-    const skillFilePath = path13.join(skillDir, SKILL_FILE_NAME);
+    const skillFilePath = path14.join(skillDir, SKILL_FILE_NAME);
     try {
       fs12.statSync(skillFilePath);
     } catch {
@@ -44951,12 +45155,12 @@ function discoverSkillsFromDirectory(skillsDir, verbose) {
   return skills;
 }
 function getDefaultSkillsDirs(cwd) {
-  const home = os5.homedir();
+  const home = os6.homedir();
   return [
-    path13.join(home, ".claude", SKILLS_DIR_NAME),
-    path13.join(home, ".agents", SKILLS_DIR_NAME),
-    path13.join(cwd, ".claude", SKILLS_DIR_NAME),
-    path13.join(cwd, ".agents", SKILLS_DIR_NAME)
+    path14.join(home, ".claude", SKILLS_DIR_NAME),
+    path14.join(home, ".agents", SKILLS_DIR_NAME),
+    path14.join(cwd, ".claude", SKILLS_DIR_NAME),
+    path14.join(cwd, ".agents", SKILLS_DIR_NAME)
   ];
 }
 async function loadSkills(options = {}) {
@@ -45079,7 +45283,7 @@ async function discoverProjectFiles(params2) {
   let error;
   const projectFilePromises = Object.fromEntries(filePaths.map((filePath) => [
     filePath,
-    fs13.readFile(path14.join(cwd, filePath), "utf8").catch((err) => {
+    fs13.readFile(path15.join(cwd, filePath), "utf8").catch((err) => {
       error = err;
       return "[ERROR_READING_FILE]";
     })
@@ -45095,7 +45299,7 @@ async function discoverProjectFiles(params2) {
 }
 async function loadUserKnowledgeFiles(params2) {
   const { fs: fs13, logger: logger2 } = params2;
-  const homeDir = params2.homeDir ?? os6.homedir();
+  const homeDir = params2.homeDir ?? os7.homedir();
   const userKnowledgeFiles = {};
   let entries;
   try {
@@ -45117,7 +45321,7 @@ async function loadUserKnowledgeFiles(params2) {
   for (const priorityName of KNOWLEDGE_FILE_NAMES_LOWERCASE) {
     const actualFileName = candidates.get(priorityName);
     if (actualFileName) {
-      const filePath = path14.join(homeDir, actualFileName);
+      const filePath = path15.join(homeDir, actualFileName);
       try {
         const content = await fs13.readFile(filePath, "utf8");
         const tildeKey = `~/${actualFileName}`;
@@ -45134,7 +45338,7 @@ function selectKnowledgeFilePaths(allFilePaths) {
   const knowledgeCandidates = allFilePaths.filter(isKnowledgeFile);
   const byDirectory = new Map;
   for (const filePath of knowledgeCandidates) {
-    const dir = path14.dirname(filePath);
+    const dir = path15.dirname(filePath);
     if (!byDirectory.has(dir)) {
       byDirectory.set(dir, []);
     }
@@ -45244,8 +45448,8 @@ async function initialSessionState(params2) {
       shell: "bash",
       nodeVersion: process.version,
       arch: process.arch,
-      homedir: os6.homedir(),
-      cpus: os6.cpus().length ?? 1
+      homedir: os7.homedir(),
+      cpus: os7.cpus().length ?? 1
     }
   });
   if (maxAgentSteps) {
@@ -45358,19 +45562,19 @@ function buildFileTree(filePaths) {
   }
   const rootNodes = [];
   const processed = new Set;
-  for (const [path15, node] of Object.entries(tree)) {
-    if (processed.has(path15))
+  for (const [path16, node] of Object.entries(tree)) {
+    if (processed.has(path16))
       continue;
-    const parentPath = path15.substring(0, path15.lastIndexOf("/"));
+    const parentPath = path16.substring(0, path16.lastIndexOf("/"));
     if (parentPath && tree[parentPath]) {
       const parent = tree[parentPath];
-      if (parent.children && !parent.children.some((child) => child.filePath === path15)) {
+      if (parent.children && !parent.children.some((child) => child.filePath === path16)) {
         parent.children.push(node);
       }
     } else {
       rootNodes.push(node);
     }
-    processed.add(path15);
+    processed.add(path16);
   }
   function sortNodes(nodes) {
     nodes.sort((a, b) => {
@@ -45390,7 +45594,7 @@ function buildFileTree(filePaths) {
 }
 
 // src/tools/change-file.ts
-import path15 from "path";
+import path16 from "path";
 import { applyPatch } from "diff";
 import z90 from "zod/v4";
 var FileChangeSchema2 = z90.object({
@@ -45399,12 +45603,12 @@ var FileChangeSchema2 = z90.object({
   content: z90.string()
 });
 function containsUpwardTraversal(dirPath) {
-  const normalized = path15.normalize(dirPath);
+  const normalized = path16.normalize(dirPath);
   return normalized.includes("..");
 }
 function containsPathTraversal(filePath) {
-  const normalized = path15.normalize(filePath);
-  return path15.isAbsolute(normalized) || normalized.startsWith("..");
+  const normalized = path16.normalize(filePath);
+  return path16.isAbsolute(normalized) || normalized.startsWith("..");
 }
 async function changeFile(params2) {
   const { parameters, cwd, fs: fs13 } = params2;
@@ -45467,10 +45671,10 @@ async function applyChanges(params2) {
   for (const change of changes) {
     const { path: filePath, content, type } = change;
     try {
-      const fullPath = path15.join(projectRoot, filePath);
+      const fullPath = path16.join(projectRoot, filePath);
       const exists = await fileExists({ filePath: fullPath, fs: fs13 });
       if (!exists) {
-        const dirPath = path15.dirname(fullPath);
+        const dirPath = path16.dirname(fullPath);
         await fs13.mkdir(dirPath, { recursive: true });
       }
       if (type === "file") {
@@ -45500,7 +45704,7 @@ async function applyChanges(params2) {
 // src/tools/code-search.ts
 import { spawn as spawn2 } from "child_process";
 import * as fs13 from "fs";
-import * as path16 from "path";
+import * as path17 from "path";
 
 // ../common/src/util/format-code-search.ts
 function formatCodeSearchOutput(stdout) {
@@ -45560,7 +45764,7 @@ function formatCodeSearchOutput(stdout) {
 
 // src/native/ripgrep.ts
 import { existsSync as existsSync7 } from "fs";
-import { join as join6, dirname as dirname7 } from "path";
+import { join as join7, dirname as dirname8 } from "path";
 import { fileURLToPath } from "url";
 function getBundledRgPath(importMetaUrl, env2 = getSdkEnv()) {
   if (env2.LEVELCODE_RG_PATH) {
@@ -45587,24 +45791,24 @@ function getBundledRgPath(importMetaUrl, env2 = getSdkEnv()) {
   const metaUrl = importMetaUrl || import.meta.url;
   if (metaUrl) {
     const currentFile = fileURLToPath(metaUrl);
-    const currentDir = dirname7(currentFile);
-    const devPath = join6(currentDir, "..", "..", "vendor", "ripgrep", platformDir, binaryName);
+    const currentDir = dirname8(currentFile);
+    const devPath = join7(currentDir, "..", "..", "vendor", "ripgrep", platformDir, binaryName);
     if (existsSync7(devPath)) {
       vendorPath = devPath;
     }
-    const distPath = join6(currentDir, "vendor", "ripgrep", platformDir, binaryName);
+    const distPath = join7(currentDir, "vendor", "ripgrep", platformDir, binaryName);
     if (existsSync7(distPath)) {
       vendorPath = distPath;
     }
   }
   if (!vendorPath) {
-    const dirname8 = new Function(`try { return __dirname; } catch (e) { return undefined; }`)();
-    if (typeof dirname8 !== "undefined") {
-      const cjsPath = join6(dirname8, "..", "..", "vendor", "ripgrep", platformDir, binaryName);
+    const dirname9 = new Function(`try { return __dirname; } catch (e) { return undefined; }`)();
+    if (typeof dirname9 !== "undefined") {
+      const cjsPath = join7(dirname9, "..", "..", "vendor", "ripgrep", platformDir, binaryName);
       if (existsSync7(cjsPath)) {
         vendorPath = cjsPath;
       }
-      const cjsPath2 = join6(dirname8, "vendor", "ripgrep", platformDir, binaryName);
+      const cjsPath2 = join7(dirname9, "vendor", "ripgrep", platformDir, binaryName);
       if (existsSync7(cjsPath2)) {
         vendorPath = cjsPath2;
       }
@@ -45613,7 +45817,7 @@ function getBundledRgPath(importMetaUrl, env2 = getSdkEnv()) {
   if (vendorPath && existsSync7(vendorPath)) {
     return vendorPath;
   }
-  const distVendorPath = join6(process.cwd(), "node_modules", "@levelcode", "sdk", "dist", "vendor", "ripgrep", platformDir, binaryName);
+  const distVendorPath = join7(process.cwd(), "node_modules", "@levelcode", "sdk", "dist", "vendor", "ripgrep", platformDir, binaryName);
   if (existsSync7(distVendorPath)) {
     return distVendorPath;
   }
@@ -45642,9 +45846,9 @@ function codeSearch({
 }) {
   return new Promise((resolve4) => {
     let isResolved = false;
-    const projectRoot = path16.resolve(projectPath);
-    const searchCwd = cwd ? path16.resolve(projectRoot, cwd) : projectRoot;
-    if (!searchCwd.startsWith(projectRoot + path16.sep) && searchCwd !== projectRoot) {
+    const projectRoot = path17.resolve(projectPath);
+    const searchCwd = cwd ? path17.resolve(projectRoot, cwd) : projectRoot;
+    if (!searchCwd.startsWith(projectRoot + path17.sep) && searchCwd !== projectRoot) {
       return resolve4([
         {
           type: "json",
@@ -45657,7 +45861,7 @@ function codeSearch({
     const flagsArray = (flags || "").split(" ").filter(Boolean).map((token) => token.replace(/^['"]|['"]$/g, ""));
     const existingHiddenDirs = INCLUDED_HIDDEN_DIRS.filter((dir) => {
       try {
-        return fs13.statSync(path16.join(searchCwd, dir)).isDirectory();
+        return fs13.statSync(path17.join(searchCwd, dir)).isDirectory();
       } catch {
         return false;
       }
@@ -45939,11 +46143,11 @@ async function glob(params2) {
 }
 
 // src/tools/list-directory.ts
-import * as path17 from "path";
+import * as path18 from "path";
 async function listDirectory(params2) {
   const { directoryPath, projectPath, fs: fs14 } = params2;
   try {
-    const resolvedPath = path17.resolve(projectPath, directoryPath);
+    const resolvedPath = path18.resolve(projectPath, directoryPath);
     if (!resolvedPath.startsWith(projectPath)) {
       return [
         {
@@ -45991,7 +46195,7 @@ async function listDirectory(params2) {
 
 // src/tools/read-files.ts
 init_old_constants();
-import path18, { isAbsolute as isAbsolute3 } from "path";
+import path19, { isAbsolute as isAbsolute3 } from "path";
 async function getFiles(params2) {
   const { filePaths, cwd, fs: fs14, fileFilter } = params2;
   const hasCustomFilter = fileFilter !== undefined;
@@ -46001,8 +46205,8 @@ async function getFiles(params2) {
     if (!filePath) {
       continue;
     }
-    const relativePath = filePath.startsWith(cwd) ? path18.relative(cwd, filePath) : filePath;
-    const fullPath = path18.join(cwd, relativePath);
+    const relativePath = filePath.startsWith(cwd) ? path19.relative(cwd, filePath) : filePath;
+    const fullPath = path19.join(cwd, relativePath);
     if (isAbsolute3(relativePath) || !fullPath.startsWith(cwd)) {
       result[relativePath] = FILE_READ_STATUS.OUTSIDE_PROJECT;
       continue;
@@ -46047,8 +46251,8 @@ async function getFiles(params2) {
 // src/tools/run-terminal-command.ts
 import { spawn as spawn3 } from "child_process";
 import * as fs14 from "fs";
-import * as os7 from "os";
-import * as path19 from "path";
+import * as os8 from "os";
+import * as path20 from "path";
 var COMMAND_OUTPUT_LIMIT = 50000;
 var GIT_BASH_COMMON_PATHS = [
   "C:\\Program Files\\Git\\bin\\bash.exe",
@@ -46070,12 +46274,12 @@ function findWindowsBash(env2) {
     }
   }
   const pathEnv = env2.PATH || env2.Path || "";
-  const pathDirs = pathEnv.split(path19.delimiter);
+  const pathDirs = pathEnv.split(path20.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 = path19.join(dir, "bash.exe");
+    const bashPath = path20.join(dir, "bash.exe");
     if (fs14.existsSync(bashPath)) {
       if (isWslPath) {
         wslFallbackPaths.push(bashPath);
@@ -46083,7 +46287,7 @@ function findWindowsBash(env2) {
         return bashPath;
       }
     }
-    const bashPathNoExt = path19.join(dir, "bash");
+    const bashPathNoExt = path20.join(dir, "bash");
     if (fs14.existsSync(bashPathNoExt)) {
       if (isWslPath) {
         wslFallbackPaths.push(bashPathNoExt);
@@ -46124,7 +46328,7 @@ function runTerminalCommand({
     throw new Error("BACKGROUND process_type not implemented");
   }
   return new Promise((resolve6, reject) => {
-    const isWindows = os7.platform() === "win32";
+    const isWindows = os8.platform() === "win32";
     const processEnv2 = {
       ...getSystemProcessEnv(),
       ...env2 ?? {}
@@ -46143,7 +46347,7 @@ function runTerminalCommand({
       shell = "bash";
       shellArgs = ["-c"];
     }
-    const resolvedCwd = path19.resolve(cwd);
+    const resolvedCwd = path20.resolve(cwd);
     const childProcess = spawn3(shell, [...shellArgs, command], {
       cwd: resolvedCwd,
       env: processEnv2,
@@ -46617,7 +46821,7 @@ async function handleToolCall({
       const resolvedCwd = requireCwd(cwd, "run_terminal_command");
       result = await runTerminalCommand({
         ...input,
-        cwd: path20.resolve(resolvedCwd, input.cwd ?? "."),
+        cwd: path21.resolve(resolvedCwd, input.cwd ?? "."),
         env: env2
       });
     } else if (toolName39 === "code_search") {
@@ -47119,8 +47323,8 @@ var ToolHelpers = {
 // src/agents/load-mcp-config.ts
 import fs15 from "fs";
 import fsPromises from "fs/promises";
-import os8 from "os";
-import path21 from "path";
+import os9 from "os";
+import path22 from "path";
 import { z as z91 } from "zod/v4";
 var mcpFileSchema = z91.object({
   mcpServers: z91.record(z91.string(), mcpConfigSchema).default(() => ({}))
@@ -47154,9 +47358,9 @@ function resolveMcpConfigEnv(config) {
 }
 var MCP_CONFIG_FILE_NAME = "mcp.json";
 var getDefaultMcpConfigDirs = () => {
-  const cwdAgents = path21.join(process.cwd(), ".agents");
-  const parentAgents = path21.join(process.cwd(), "..", ".agents");
-  const homeAgents = path21.join(os8.homedir(), ".agents");
+  const cwdAgents = path22.join(process.cwd(), ".agents");
+  const parentAgents = path22.join(process.cwd(), "..", ".agents");
+  const homeAgents = path22.join(os9.homedir(), ".agents");
   return [cwdAgents, parentAgents, homeAgents];
 };
 async function loadMCPConfig(options) {
@@ -47167,7 +47371,7 @@ async function loadMCPConfig(options) {
   };
   const mcpConfigDirs = getDefaultMcpConfigDirs();
   for (const dir of mcpConfigDirs) {
-    const configPath = path21.join(dir, MCP_CONFIG_FILE_NAME);
+    const configPath = path22.join(dir, MCP_CONFIG_FILE_NAME);
     try {
       try {
         await fsPromises.access(configPath);
@@ -47214,7 +47418,7 @@ function loadMCPConfigSync(options) {
   };
   const mcpConfigDirs = getDefaultMcpConfigDirs();
   for (const dir of mcpConfigDirs) {
-    const configPath = path21.join(dir, MCP_CONFIG_FILE_NAME);
+    const configPath = path22.join(dir, MCP_CONFIG_FILE_NAME);
     try {
       if (!fs15.existsSync(configPath)) {
         continue;
@@ -47322,5 +47526,5 @@ export {
   IS_DEV
 };
 
-//# debugId=34FE3B00F8D969AB64756E2164756E21
+//# debugId=714311A46A611DD564756E2164756E21
 //# sourceMappingURL=index.mjs.map