@qwen-code/qwen-code 0.18.0-preview.2 → 0.18.0

package/chunks/{chunk-HGJPQK33.js → chunk-J5MDQKJL.js}

@@ -1,23 +1,27 @@
 // Force strict mode and setup for ESM
 "use strict";
 import {
-  getTasksDir
-} from "./chunk-XBFVXFB2.js";
+  INBOXES_DIR,
+  LEADER_NAME,
+  TASKS_DIR,
+  TEAMMATE_COLORS,
+  TEAMS_DIR,
+  TEAM_CONFIG_FILENAME
+} from "./chunk-LD2XBG6Z.js";
 import {
   atomicWriteJSON
-} from "./chunk-UAMOBVVW.js";
+} from "./chunk-B7HXHOHU.js";
 import {
-  createDebugLogger,
+  Storage,
   isNodeError
-} from "./chunk-JXAZUMDW.js";
+} from "./chunk-HR7SV7AY.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
 import {
   __commonJS,
   __name,
-  __require,
-  __toESM
+  __require
 } from "./chunk-J2S4EL5Y.js";
 
 // node_modules/graceful-fs/polyfills.js
@@ -88,7 +92,7 @@ var require_polyfills = __commonJS({
       }
       if (platform === "win32") {
         fs2.rename = typeof fs2.rename !== "function" ? fs2.rename : function(fs$rename) {
-          function rename2(from, to, cb) {
+          function rename(from, to, cb) {
             var start = Date.now();
             var backoff = 0;
             fs$rename(from, to, /* @__PURE__ */ __name(function CB(er) {
@@ -108,9 +112,9 @@ var require_polyfills = __commonJS({
               if (cb) cb(er);
             }, "CB"));
           }
-          __name(rename2, "rename");
-          if (Object.setPrototypeOf) Object.setPrototypeOf(rename2, fs$rename);
-          return rename2;
+          __name(rename, "rename");
+          if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
+          return rename;
         }(fs2.rename);
       }
       fs2.read = typeof fs2.read !== "function" ? fs2.read : function(fs$read) {
@@ -476,11 +480,11 @@ var require_graceful_fs = __commonJS({
       });
     }
     __name(publishQueue, "publishQueue");
-    var debug2 = noop;
+    var debug = noop;
     if (util.debuglog)
-      debug2 = util.debuglog("gfs4");
+      debug = util.debuglog("gfs4");
     else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ""))
-      debug2 = /* @__PURE__ */ __name(function() {
+      debug = /* @__PURE__ */ __name(function() {
         var m = util.format.apply(util, arguments);
         m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
         console.error(m);
@@ -517,7 +521,7 @@ var require_graceful_fs = __commonJS({
       }(fs2.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug2(fs2[gracefulQueue]);
+          debug(fs2[gracefulQueue]);
           __require("assert").equal(fs2[gracefulQueue].length, 0);
         });
       }
@@ -556,8 +560,8 @@ var require_graceful_fs = __commonJS({
       }
       __name(readFile2, "readFile");
       var fs$writeFile = fs3.writeFile;
-      fs3.writeFile = writeFile;
-      function writeFile(path2, data, options, cb) {
+      fs3.writeFile = writeFile2;
+      function writeFile2(path2, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
         return go$writeFile(path2, data, options, cb);
@@ -573,7 +577,7 @@ var require_graceful_fs = __commonJS({
         }
         __name(go$writeFile, "go$writeFile");
       }
-      __name(writeFile, "writeFile");
+      __name(writeFile2, "writeFile");
       var fs$appendFile = fs3.appendFile;
       if (fs$appendFile)
         fs3.appendFile = appendFile;
@@ -725,7 +729,7 @@ var require_graceful_fs = __commonJS({
       __name(ReadStream, "ReadStream");
       function ReadStream$open() {
         var that = this;
-        open2(that.path, that.flags, that.mode, function(err, fd) {
+        open(that.path, that.flags, that.mode, function(err, fd) {
           if (err) {
             if (that.autoClose)
               that.destroy();
@@ -747,7 +751,7 @@ var require_graceful_fs = __commonJS({
       __name(WriteStream, "WriteStream");
       function WriteStream$open() {
         var that = this;
-        open2(that.path, that.flags, that.mode, function(err, fd) {
+        open(that.path, that.flags, that.mode, function(err, fd) {
           if (err) {
             that.destroy();
             that.emit("error", err);
@@ -767,8 +771,8 @@ var require_graceful_fs = __commonJS({
       }
       __name(createWriteStream, "createWriteStream");
       var fs$open = fs3.open;
-      fs3.open = open2;
-      function open2(path2, flags, mode, cb) {
+      fs3.open = open;
+      function open(path2, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
         return go$open(path2, flags, mode, cb);
@@ -784,12 +788,12 @@ var require_graceful_fs = __commonJS({
         }
         __name(go$open, "go$open");
       }
-      __name(open2, "open");
+      __name(open, "open");
       return fs3;
     }
     __name(patch, "patch");
     function enqueue(elem) {
-      debug2("ENQUEUE", elem[0].name, elem[1]);
+      debug("ENQUEUE", elem[0].name, elem[1]);
       fs2[gracefulQueue].push(elem);
       retry();
     }
@@ -818,10 +822,10 @@ var require_graceful_fs = __commonJS({
       var startTime = elem[3];
       var lastTime = elem[4];
       if (startTime === void 0) {
-        debug2("RETRY", fn.name, args);
+        debug("RETRY", fn.name, args);
         fn.apply(null, args);
       } else if (Date.now() - startTime >= 6e4) {
-        debug2("TIMEOUT", fn.name, args);
+        debug("TIMEOUT", fn.name, args);
         var cb = args.pop();
         if (typeof cb === "function")
           cb.call(null, err);
@@ -830,7 +834,7 @@ var require_graceful_fs = __commonJS({
         var sinceStart = Math.max(lastTime - startTime, 1);
         var desiredDelay = Math.min(sinceStart * 1.2, 100);
         if (sinceAttempt >= desiredDelay) {
-          debug2("RETRY", fn.name, args);
+          debug("RETRY", fn.name, args);
           fn.apply(null, args.concat([startTime]));
         } else {
           fs2[gracefulQueue].push(elem);
@@ -1193,8 +1197,8 @@ var require_signal_exit = __commonJS({
           if (!processOk(globalThis.process)) {
             return;
           }
-          var listeners2 = process2.listeners(sig);
-          if (listeners2.length === emitter.count) {
+          var listeners = process2.listeners(sig);
+          if (listeners.length === emitter.count) {
             unload();
             emit("exit", null, sig);
             emit("afterexit", null, sig);
@@ -1639,32 +1643,32 @@ var require_proper_lockfile = __commonJS({
   "node_modules/proper-lockfile/index.js"(exports, module) {
     "use strict";
     init_esbuild_shims();
-    var lockfile2 = require_lockfile();
+    var lockfile = require_lockfile();
     var { toPromise, toSync, toSyncOptions } = require_adapter();
     async function lock(file, options) {
-      const release = await toPromise(lockfile2.lock)(file, options);
+      const release = await toPromise(lockfile.lock)(file, options);
       return toPromise(release);
     }
     __name(lock, "lock");
     function lockSync(file, options) {
-      const release = toSync(lockfile2.lock)(file, toSyncOptions(options));
+      const release = toSync(lockfile.lock)(file, toSyncOptions(options));
       return toSync(release);
     }
     __name(lockSync, "lockSync");
     function unlock(file, options) {
-      return toPromise(lockfile2.unlock)(file, options);
+      return toPromise(lockfile.unlock)(file, options);
     }
     __name(unlock, "unlock");
     function unlockSync(file, options) {
-      return toSync(lockfile2.unlock)(file, toSyncOptions(options));
+      return toSync(lockfile.unlock)(file, toSyncOptions(options));
     }
     __name(unlockSync, "unlockSync");
     function check(file, options) {
-      return toPromise(lockfile2.check)(file, options);
+      return toPromise(lockfile.check)(file, options);
     }
     __name(check, "check");
     function checkSync(file, options) {
-      return toSync(lockfile2.check)(file, toSyncOptions(options));
+      return toSync(lockfile.check)(file, toSyncOptions(options));
     }
     __name(checkSync, "checkSync");
     module.exports = lock;
@@ -1677,552 +1681,547 @@ var require_proper_lockfile = __commonJS({
   }
 });
 
-// packages/core/src/agents/team/tasks.ts
+// packages/core/src/agents/team/teamHelpers.ts
 init_esbuild_shims();
-var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
 import * as fs from "node:fs/promises";
-import { constants as fsConstants } from "node:fs";
 import * as path from "node:path";
-var debug = createDebugLogger("AGENTS_TEAM_TASKS");
-var MAX_METADATA_BYTES = 32768;
-var MAX_PARALLEL_TASK_READS = 16;
-function assertMetadataWithinLimit(metadata) {
-  if (!metadata) return;
-  const size = Buffer.byteLength(JSON.stringify(metadata), "utf-8");
-  if (size > MAX_METADATA_BYTES) {
+function getTeamsRootDir() {
+  return path.join(Storage.getGlobalQwenDir(), TEAMS_DIR);
+}
+__name(getTeamsRootDir, "getTeamsRootDir");
+function getTeamDir(teamName) {
+  return path.join(getTeamsRootDir(), teamName);
+}
+__name(getTeamDir, "getTeamDir");
+function getTeamFilePath(teamName) {
+  return path.join(getTeamDir(teamName), TEAM_CONFIG_FILENAME);
+}
+__name(getTeamFilePath, "getTeamFilePath");
+function getInboxesDir(teamName) {
+  return path.join(getTeamDir(teamName), INBOXES_DIR);
+}
+__name(getInboxesDir, "getInboxesDir");
+function getTasksDir(teamName) {
+  return path.join(Storage.getGlobalQwenDir(), TASKS_DIR, teamName);
+}
+__name(getTasksDir, "getTasksDir");
+function sanitizeName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+__name(sanitizeName, "sanitizeName");
+function formatAgentId(name, teamName) {
+  return `${sanitizeName(name)}@${sanitizeName(teamName)}`;
+}
+__name(formatAgentId, "formatAgentId");
+function generateUniqueTeammateName(baseName, existingMembers) {
+  const sanitized = sanitizeName(baseName);
+  if (!sanitized) {
     throw new Error(
-      `Task metadata is too large (${size} bytes; max ${MAX_METADATA_BYTES}). Trim the payload or store the bulk content elsewhere.`
+      `Teammate name "${baseName}" sanitizes to an empty string. Choose a name with at least one alphanumeric character.`
     );
   }
-}
-__name(assertMetadataWithinLimit, "assertMetadataWithinLimit");
-var LOCK_OPTIONS = {
-  retries: {
-    retries: 30,
-    minTimeout: 5,
-    maxTimeout: 100,
-    factor: 2
-  },
-  stale: 5e3,
-  onCompromised: /* @__PURE__ */ __name((err) => {
-    debug.warn("task lock compromised:", err?.message ?? err);
-  }, "onCompromised")
-};
-function assertValidTaskId(taskId) {
-  if (!/^[1-9]\d*$/.test(taskId)) {
+  if (sanitized === LEADER_NAME) {
     throw new Error(
-      `Invalid task ID "${taskId}". Task IDs must be positive integers.`
+      `"${LEADER_NAME}" is reserved for the team leader. Choose a different teammate name.`
     );
   }
-}
-__name(assertValidTaskId, "assertValidTaskId");
-function getTaskPath(teamName, taskId) {
-  assertValidTaskId(taskId);
-  return path.join(getTasksDir(teamName), `${taskId}.json`);
-}
-__name(getTaskPath, "getTaskPath");
-var listeners = /* @__PURE__ */ new Set();
-function onTasksUpdated(listener) {
-  listeners.add(listener);
-  return () => {
-    listeners.delete(listener);
-  };
-}
-__name(onTasksUpdated, "onTasksUpdated");
-function notifyTasksUpdated(teamName) {
-  for (const listener of listeners) {
-    try {
-      listener(teamName);
-    } catch (err) {
-      debug.warn(`task update listener failed: ${err}`);
-    }
+  const existingNames = new Set(existingMembers.map((m) => m.name));
+  if (existingNames.has(sanitized)) {
+    const existingList = [...existingNames].join(", ") || "<none>";
+    throw new Error(
+      `A teammate named "${sanitized}" already exists in this team (existing: ${existingList}). Choose a different name.`
+    );
   }
+  return sanitized;
 }
-__name(notifyTasksUpdated, "notifyTasksUpdated");
-async function createTask(teamName, opts) {
-  assertMetadataWithinLimit(opts.metadata);
-  const dir = getTasksDir(teamName);
-  await fs.mkdir(dir, { recursive: true });
-  const MAX_RETRIES = 15;
-  for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
-    const nextId = await getNextTaskId(dir);
-    const task = {
-      id: nextId,
-      subject: opts.subject,
-      description: opts.description,
-      activeForm: opts.activeForm,
-      owner: opts.owner,
-      status: "pending",
-      blocks: [],
-      blockedBy: [],
-      metadata: opts.metadata
-    };
-    const taskPath = path.join(dir, `${nextId}.json`);
-    try {
-      const handle = await fs.open(
-        taskPath,
-        fsConstants.O_WRONLY | fsConstants.O_CREAT | fsConstants.O_EXCL
-      );
-      await handle.close();
-    } catch (err) {
-      if (isNodeError(err) && err.code === "EEXIST") {
-        continue;
-      }
-      throw err;
-    }
-    try {
-      await atomicWriteJSON(taskPath, task);
-    } catch (err) {
-      await fs.unlink(taskPath).catch(() => {
-      });
-      throw err;
+__name(generateUniqueTeammateName, "generateUniqueTeammateName");
+function assignTeammateColor(existingMembers) {
+  const usedColors = new Set(
+    existingMembers.map((m) => m.color).filter((c) => c !== void 0)
+  );
+  for (const color of TEAMMATE_COLORS) {
+    if (!usedColors.has(color)) {
+      return color;
     }
-    notifyTasksUpdated(teamName);
-    return task;
   }
-  throw new Error(
-    `Failed to create task after ${MAX_RETRIES} attempts (ID contention).`
-  );
+  return TEAMMATE_COLORS[existingMembers.length % TEAMMATE_COLORS.length];
 }
-__name(createTask, "createTask");
-async function getTask(teamName, taskId) {
-  const taskPath = getTaskPath(teamName, taskId);
+__name(assignTeammateColor, "assignTeammateColor");
+function clearTeammateColors(members) {
+  return members.map((m) => {
+    const { color: _, ...rest } = m;
+    return rest;
+  });
+}
+__name(clearTeammateColors, "clearTeammateColors");
+function setMemberActive(members, agentId, isActive) {
+  return members.map((m) => m.agentId === agentId ? { ...m, isActive } : m);
+}
+__name(setMemberActive, "setMemberActive");
+function findMemberById(members, agentId) {
+  return members.find((m) => m.agentId === agentId);
+}
+__name(findMemberById, "findMemberById");
+function findMemberByName(members, name) {
+  const sanitized = sanitizeName(name);
+  return members.find((m) => m.name === sanitized);
+}
+__name(findMemberByName, "findMemberByName");
+function classifyShutdownResponse(message) {
+  const trimmed = message.trimStart();
+  if (/^shutdown_approved\b/i.test(trimmed)) return "shutdown_approved";
+  if (/^shutdown_rejected\b/i.test(trimmed)) return "shutdown_rejected";
+  return void 0;
+}
+__name(classifyShutdownResponse, "classifyShutdownResponse");
+async function readTeamFile(teamName) {
+  const filePath = getTeamFilePath(teamName);
   try {
-    const raw = await fs.readFile(taskPath, "utf-8");
+    const raw = await fs.readFile(filePath, "utf-8");
     return JSON.parse(raw);
   } catch (err) {
-    if (isNodeError(err) && err.code === "ENOENT") return void 0;
+    if (isNodeError(err) && err.code === "ENOENT") {
+      return void 0;
+    }
     throw err;
   }
 }
-__name(getTask, "getTask");
-var TaskOwnershipError = class extends Error {
-  constructor(taskId, callerName, actualOwner) {
-    super(
-      `Task #${taskId} is owned by "${actualOwner}". Only the leader or the owner can change status / owner / subject / description / blocks.`
-    );
-    this.taskId = taskId;
-    this.callerName = callerName;
-    this.actualOwner = actualOwner;
-    this.name = "TaskOwnershipError";
-  }
-  static {
-    __name(this, "TaskOwnershipError");
-  }
-};
-async function updateTask(teamName, taskId, updates, opts) {
-  const taskPath = getTaskPath(teamName, taskId);
-  let release;
+__name(readTeamFile, "readTeamFile");
+async function writeTeamFile(teamName, teamFile) {
+  const filePath = getTeamFilePath(teamName);
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await atomicWriteJSON(filePath, teamFile);
+}
+__name(writeTeamFile, "writeTeamFile");
+async function createTeamFile(teamName, teamFile) {
+  const filePath = getTeamFilePath(teamName);
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, JSON.stringify(teamFile, null, 2) + "\n", {
+    encoding: "utf-8",
+    flag: "wx"
+  });
+}
+__name(createTeamFile, "createTeamFile");
+function isPidAlive(pid) {
   try {
-    release = await import_proper_lockfile.default.lock(taskPath, LOCK_OPTIONS);
+    process.kill(pid, 0);
+    return true;
   } catch (err) {
-    if (isNodeError(err) && err.code === "ENOENT") return void 0;
-    throw err;
-  }
-  try {
-    let raw;
-    try {
-      raw = await fs.readFile(taskPath, "utf-8");
-    } catch (err) {
-      if (isNodeError(err) && err.code === "ENOENT") return void 0;
-      throw err;
-    }
-    const task = JSON.parse(raw);
-    if (opts?.callerName !== void 0) {
-      const restrictsOwnership = updates.status !== void 0 || updates.owner !== void 0 || updates.subject !== void 0 || updates.description !== void 0 || (updates.addBlocks?.length ?? 0) > 0 || (updates.addBlockedBy?.length ?? 0) > 0;
-      if (restrictsOwnership && task.owner && task.owner !== opts.callerName) {
-        throw new TaskOwnershipError(taskId, opts.callerName, task.owner);
-      }
-    }
-    if (updates.addBlocks?.length) {
-      const blockSet = new Set(task.blocks);
-      for (const id of updates.addBlocks) blockSet.add(id);
-      task.blocks = Array.from(blockSet);
-    }
-    if (updates.addBlockedBy?.length) {
-      const blockedBySet = new Set(task.blockedBy);
-      for (const id of updates.addBlockedBy) blockedBySet.add(id);
-      task.blockedBy = Array.from(blockedBySet);
-    }
-    if (updates.status !== void 0) {
-      task.status = updates.status;
-      if (updates.status === "completed" && task.blocks.length > 0) {
-        await unblockDependents(teamName, taskId, task.blocks);
-      }
-    }
-    if (updates.owner !== void 0) {
-      task.owner = updates.owner ? updates.owner : void 0;
-    }
-    if (updates.subject !== void 0) {
-      task.subject = updates.subject;
-    }
-    if (updates.description !== void 0) {
-      task.description = updates.description;
-    }
-    if (updates.activeForm !== void 0) {
-      task.activeForm = updates.activeForm ?? void 0;
-    }
-    if (updates.metadata !== void 0) {
-      task.metadata = task.metadata ?? {};
-      for (const [key, value] of Object.entries(updates.metadata)) {
-        if (key === "__proto__" || key === "constructor" || key === "prototype") {
-          continue;
-        }
-        if (value === null) {
-          delete task.metadata[key];
-        } else {
-          task.metadata[key] = value;
-        }
-      }
-      if (Object.keys(task.metadata).length === 0) {
-        task.metadata = void 0;
-      }
-      assertMetadataWithinLimit(task.metadata);
-    }
-    await atomicWriteJSON(taskPath, task);
-    notifyTasksUpdated(teamName);
-    return task;
-  } finally {
-    await release?.();
+    return isNodeError(err) && err.code === "EPERM";
   }
 }
-__name(updateTask, "updateTask");
-async function deleteTask(teamName, taskId, opts) {
-  const taskPath = getTaskPath(teamName, taskId);
-  let release;
+__name(isPidAlive, "isPidAlive");
+async function tryReclaimStaleTeam(teamName) {
+  let existing;
   try {
-    release = await import_proper_lockfile.default.lock(taskPath, LOCK_OPTIONS);
-  } catch (err) {
-    if (isNodeError(err) && err.code === "ENOENT") return false;
-    throw err;
+    existing = await readTeamFile(teamName);
+  } catch {
+    return false;
   }
-  let dependentIds = /* @__PURE__ */ new Set();
-  try {
-    let task;
-    try {
-      const raw = await fs.readFile(taskPath, "utf-8");
-      task = JSON.parse(raw);
-    } catch (err) {
-      if (isNodeError(err) && err.code === "ENOENT") return false;
-      throw err;
-    }
-    if (opts?.callerName !== void 0 && task.owner && task.owner !== opts.callerName) {
-      throw new TaskOwnershipError(taskId, opts.callerName, task.owner);
-    }
-    dependentIds = /* @__PURE__ */ new Set([...task.blocks, ...task.blockedBy]);
-    dependentIds.delete(taskId);
-    try {
-      await fs.unlink(taskPath);
-    } catch (err) {
-      if (isNodeError(err) && err.code === "ENOENT") return false;
-      throw err;
-    }
-  } finally {
-    await release();
+  if (!existing) {
+    await deleteTeamDirs(teamName);
+    return true;
   }
-  const results = await Promise.allSettled(
-    Array.from(dependentIds).map(
-      (depId) => removeEdgesReferencing(teamName, depId, taskId)
-    )
-  );
-  for (const r of results) {
-    if (r.status === "rejected") {
-      debug.warn(`deleteTask(${taskId}): edge cleanup failed: ${r.reason}`);
-    }
+  if (typeof existing.leadPid !== "number" || existing.leadPid <= 0) {
+    return false;
+  }
+  if (existing.leadPid !== process.pid && isPidAlive(existing.leadPid)) {
+    return false;
   }
-  notifyTasksUpdated(teamName);
+  await deleteTeamDirs(teamName);
   return true;
 }
-__name(deleteTask, "deleteTask");
-async function removeEdgesReferencing(teamName, targetId, referencedId) {
-  const depPath = getTaskPath(teamName, targetId);
-  let release;
-  try {
-    release = await import_proper_lockfile.default.lock(depPath, LOCK_OPTIONS);
-  } catch (err) {
-    if (isNodeError(err) && err.code === "ENOENT") return;
-    throw err;
-  }
-  try {
-    const raw = await fs.readFile(depPath, "utf-8");
-    const task = JSON.parse(raw);
-    const beforeBlocks = task.blocks.length;
-    const beforeBlockedBy = task.blockedBy.length;
-    task.blocks = task.blocks.filter((id) => id !== referencedId);
-    task.blockedBy = task.blockedBy.filter((id) => id !== referencedId);
-    if (task.blocks.length === beforeBlocks && task.blockedBy.length === beforeBlockedBy) {
-      return;
-    }
-    await atomicWriteJSON(depPath, task);
-  } catch (err) {
-    if (isNodeError(err) && err.code === "ENOENT") return;
-    throw err;
-  } finally {
-    await release?.();
-  }
+__name(tryReclaimStaleTeam, "tryReclaimStaleTeam");
+async function deleteTeamDirs(teamName) {
+  const teamDir = getTeamDir(teamName);
+  const tasksDir = getTasksDir(teamName);
+  await Promise.allSettled([
+    fs.rm(teamDir, { recursive: true, force: true }),
+    fs.rm(tasksDir, { recursive: true, force: true })
+  ]);
 }
-__name(removeEdgesReferencing, "removeEdgesReferencing");
-async function listTasks(teamName, filters) {
-  const dir = getTasksDir(teamName);
-  let entries;
+__name(deleteTeamDirs, "deleteTeamDirs");
+async function listTeamNames() {
+  const teamsRoot = getTeamsRootDir();
   try {
-    entries = await fs.readdir(dir);
-  } catch (err) {
-    if (isNodeError(err) && err.code === "ENOENT") return [];
-    const errMsg = err instanceof Error ? err.message : String(err);
-    debug.warn(`Failed to list tasks dir ${dir}: ${errMsg}`);
-    throw err instanceof Error ? err : new Error(errMsg);
+    const entries = await fs.readdir(teamsRoot, {
+      withFileTypes: true
+    });
+    return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return [];
   }
-  const jsonEntries = entries.filter((e) => e.endsWith(".json"));
-  const reads = [];
-  for (let i = 0; i < jsonEntries.length; i += MAX_PARALLEL_TASK_READS) {
-    const batch = jsonEntries.slice(i, i + MAX_PARALLEL_TASK_READS);
-    const batchReads = await Promise.all(
-      batch.map(async (entry) => {
-        const filePath = path.join(dir, entry);
-        let raw;
-        try {
-          raw = await fs.readFile(filePath, "utf-8");
-        } catch (err) {
-          if (isNodeError(err) && err.code === "ENOENT") return void 0;
-          const errMsg = err instanceof Error ? err.message : String(err);
-          debug.warn(`Failed to read task file ${filePath}: ${errMsg}`);
-          return void 0;
-        }
-        if (raw.trim() === "") {
-          return void 0;
-        }
-        try {
-          return JSON.parse(raw);
-        } catch (err) {
-          const errMsg = err instanceof Error ? err.message : String(err);
-          debug.warn(`Quarantining corrupt task file ${filePath}: ${errMsg}`);
-          const quarantined = `${filePath}.corrupt-${Date.now()}`;
-          try {
-            await fs.rename(filePath, quarantined);
-          } catch (renameErr) {
-            const renameMsg = renameErr instanceof Error ? renameErr.message : String(renameErr);
-            debug.warn(`Failed to quarantine ${filePath}: ${renameMsg}`);
-          }
-          return void 0;
-        }
-      })
-    );
-    reads.push(...batchReads);
+}
+__name(listTeamNames, "listTeamNames");
+
+// node_modules/async-mutex/index.mjs
+init_esbuild_shims();
+var E_TIMEOUT = new Error("timeout while waiting for mutex to become available");
+var E_ALREADY_LOCKED = new Error("mutex already locked");
+var E_CANCELED = new Error("request for lock canceled");
+var __awaiter$2 = function(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
   }
-  const tasks = reads.filter((t) => t !== void 0);
-  tasks.sort((a, b) => Number(a.id) - Number(b.id));
-  if (!filters) return tasks;
-  return tasks.filter((t) => {
-    if (filters.status !== void 0 && t.status !== filters.status) {
-      return false;
+  __name(adopt, "adopt");
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
     }
-    if (filters.owner !== void 0 && t.owner !== filters.owner) {
-      return false;
+    __name(fulfilled, "fulfilled");
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
     }
-    if (filters.blockedBy !== void 0 && !t.blockedBy.includes(filters.blockedBy)) {
-      return false;
+    __name(rejected, "rejected");
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
     }
-    return true;
+    __name(step, "step");
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
-}
-__name(listTasks, "listTasks");
-async function resetTaskList(teamName) {
-  const dir = getTasksDir(teamName);
-  await fs.rm(dir, { recursive: true, force: true });
-  notifyTasksUpdated(teamName);
-}
-__name(resetTaskList, "resetTaskList");
-async function unblockDependents(teamName, completedId, dependentIds) {
-  const results = await Promise.allSettled(
-    dependentIds.map(async (depId) => {
-      const depPath = getTaskPath(teamName, depId);
-      let release;
-      try {
-        release = await import_proper_lockfile.default.lock(depPath, LOCK_OPTIONS);
-      } catch (err) {
-        if (isNodeError(err) && err.code === "ENOENT") return;
-        throw err;
+};
+var Semaphore = class {
+  static {
+    __name(this, "Semaphore");
+  }
+  constructor(_value, _cancelError = E_CANCELED) {
+    this._value = _value;
+    this._cancelError = _cancelError;
+    this._queue = [];
+    this._weightedWaiters = [];
+  }
+  acquire(weight = 1, priority = 0) {
+    if (weight <= 0)
+      throw new Error(`invalid weight ${weight}: must be positive`);
+    return new Promise((resolve, reject) => {
+      const task = { resolve, reject, weight, priority };
+      const i = findIndexFromEnd(this._queue, (other) => priority <= other.priority);
+      if (i === -1 && weight <= this._value) {
+        this._dispatchItem(task);
+      } else {
+        this._queue.splice(i + 1, 0, task);
       }
+    });
+  }
+  runExclusive(callback_1) {
+    return __awaiter$2(this, arguments, void 0, function* (callback, weight = 1, priority = 0) {
+      const [value, release] = yield this.acquire(weight, priority);
       try {
-        const raw = await fs.readFile(depPath, "utf-8");
-        const task = JSON.parse(raw);
-        const before = task.blockedBy.length;
-        task.blockedBy = task.blockedBy.filter((id) => id !== completedId);
-        if (task.blockedBy.length === before) return;
-        await atomicWriteJSON(depPath, task);
+        return yield callback(value);
       } finally {
-        await release?.();
+        release();
       }
-    })
-  );
-  for (const r of results) {
-    if (r.status === "rejected") {
-      debug.warn(`unblockDependents(${completedId}): ${r.reason}`);
+    });
+  }
+  waitForUnlock(weight = 1, priority = 0) {
+    if (weight <= 0)
+      throw new Error(`invalid weight ${weight}: must be positive`);
+    if (this._couldLockImmediately(weight, priority)) {
+      return Promise.resolve();
+    } else {
+      return new Promise((resolve) => {
+        if (!this._weightedWaiters[weight - 1])
+          this._weightedWaiters[weight - 1] = [];
+        insertSorted(this._weightedWaiters[weight - 1], { resolve, priority });
+      });
     }
   }
-  notifyTasksUpdated(teamName);
-}
-__name(unblockDependents, "unblockDependents");
-async function blockTask(teamName, fromId, toId) {
-  await updateTask(teamName, fromId, { addBlocks: [toId] });
-  await updateTask(teamName, toId, { addBlockedBy: [fromId] });
-}
-__name(blockTask, "blockTask");
-async function claimTask(teamName, taskId, agentId, opts) {
-  if (opts?.checkAgentBusy) {
-    const busy = await isAgentBusy(teamName, agentId);
-    if (busy) return void 0;
+  isLocked() {
+    return this._value <= 0;
   }
-  const taskPath = getTaskPath(teamName, taskId);
-  let release;
-  try {
-    release = await import_proper_lockfile.default.lock(taskPath, LOCK_OPTIONS);
-  } catch (err) {
-    if (isNodeError(err) && err.code === "ENOENT") return void 0;
-    throw err;
+  getValue() {
+    return this._value;
   }
-  try {
-    let raw;
-    try {
-      raw = await fs.readFile(taskPath, "utf-8");
-    } catch (err) {
-      if (isNodeError(err) && err.code === "ENOENT") return void 0;
-      throw err;
-    }
-    const task = JSON.parse(raw);
-    if (task.status !== "pending") return void 0;
-    if (task.owner) return void 0;
-    task.owner = opts?.ownerName ?? agentId;
-    task.status = "in_progress";
-    await atomicWriteJSON(taskPath, task);
-    notifyTasksUpdated(teamName);
-    return task;
-  } finally {
-    await release?.();
+  setValue(value) {
+    this._value = value;
+    this._dispatchQueue();
   }
-}
-__name(claimTask, "claimTask");
-async function isAgentBusy(teamName, agentId) {
-  const inProgress = await listTasks(teamName, {
-    status: "in_progress"
-  });
-  const bareName = agentId.split("@")[0];
-  return inProgress.some((t) => t.owner === agentId || t.owner === bareName);
-}
-__name(isAgentBusy, "isAgentBusy");
-async function releaseOwnedTask(teamName, taskId, expectedOwner) {
-  const taskPath = getTaskPath(teamName, taskId);
-  let release;
-  try {
-    release = await import_proper_lockfile.default.lock(taskPath, LOCK_OPTIONS);
-  } catch (err) {
-    if (isNodeError(err) && err.code === "ENOENT") return false;
-    throw err;
+  release(weight = 1) {
+    if (weight <= 0)
+      throw new Error(`invalid weight ${weight}: must be positive`);
+    this._value += weight;
+    this._dispatchQueue();
   }
-  try {
-    let raw;
-    try {
-      raw = await fs.readFile(taskPath, "utf-8");
-    } catch (err) {
-      if (isNodeError(err) && err.code === "ENOENT") return false;
-      throw err;
+  cancel() {
+    this._queue.forEach((entry) => entry.reject(this._cancelError));
+    this._queue = [];
+  }
+  _dispatchQueue() {
+    this._drainUnlockWaiters();
+    while (this._queue.length > 0 && this._queue[0].weight <= this._value) {
+      this._dispatchItem(this._queue.shift());
+      this._drainUnlockWaiters();
     }
-    const task = JSON.parse(raw);
-    if (task.status !== "in_progress") return false;
-    if (task.owner !== expectedOwner) return false;
-    task.owner = void 0;
-    task.status = "pending";
-    await atomicWriteJSON(taskPath, task);
-    return true;
-  } finally {
-    await release?.();
   }
-}
-__name(releaseOwnedTask, "releaseOwnedTask");
-async function unassignTeammateTasks(teamName, agentId) {
-  const bareName = agentId.split("@")[0];
-  const inProgress = await listTasks(teamName, {
-    status: "in_progress"
-  });
-  const owned = inProgress.filter(
-    (task) => task.owner === agentId || task.owner === bareName
-  );
-  const results = await Promise.allSettled(
-    owned.map((task) => releaseOwnedTask(teamName, task.id, task.owner))
-  );
-  const failed = results.filter((r) => r.status === "rejected");
-  if (failed.length > 0) {
-    debug.warn(
-      `unassignTeammateTasks: ${failed.length}/${owned.length} task(s) failed to unassign for ${agentId}`
-    );
+  _dispatchItem(item) {
+    const previousValue = this._value;
+    this._value -= item.weight;
+    item.resolve([previousValue, this._newReleaser(item.weight)]);
   }
-  const released = results.filter(
-    (r) => r.status === "fulfilled" && r.value === true
-  ).length;
-  if (released > 0) {
-    notifyTasksUpdated(teamName);
+  _newReleaser(weight) {
+    let called = false;
+    return () => {
+      if (called)
+        return;
+      called = true;
+      this.release(weight);
+    };
   }
-  return released;
+  _drainUnlockWaiters() {
+    if (this._queue.length === 0) {
+      for (let weight = this._value; weight > 0; weight--) {
+        const waiters = this._weightedWaiters[weight - 1];
+        if (!waiters)
+          continue;
+        waiters.forEach((waiter) => waiter.resolve());
+        this._weightedWaiters[weight - 1] = [];
+      }
+    } else {
+      const queuedPriority = this._queue[0].priority;
+      for (let weight = this._value; weight > 0; weight--) {
+        const waiters = this._weightedWaiters[weight - 1];
+        if (!waiters)
+          continue;
+        const i = waiters.findIndex((waiter) => waiter.priority <= queuedPriority);
+        (i === -1 ? waiters : waiters.splice(0, i)).forEach((waiter) => waiter.resolve());
+      }
+    }
+  }
+  _couldLockImmediately(weight, priority) {
+    return (this._queue.length === 0 || this._queue[0].priority < priority) && weight <= this._value;
+  }
+};
+function insertSorted(a, v) {
+  const i = findIndexFromEnd(a, (other) => v.priority <= other.priority);
+  a.splice(i + 1, 0, v);
 }
-__name(unassignTeammateTasks, "unassignTeammateTasks");
-async function getAgentStatuses(teamName) {
-  const tasks = await listTasks(teamName);
-  const statuses = /* @__PURE__ */ new Map();
-  for (const task of tasks) {
-    if (!task.owner) continue;
-    const entry = statuses.get(task.owner) ?? {
-      inProgress: 0,
-      completed: 0
-    };
-    if (task.status === "in_progress") {
-      entry.inProgress++;
-    } else if (task.status === "completed") {
-      entry.completed++;
+__name(insertSorted, "insertSorted");
+function findIndexFromEnd(a, predicate) {
+  for (let i = a.length - 1; i >= 0; i--) {
+    if (predicate(a[i])) {
+      return i;
     }
-    statuses.set(task.owner, entry);
   }
-  return statuses;
+  return -1;
 }
-__name(getAgentStatuses, "getAgentStatuses");
-async function getNextTaskId(dir) {
-  let entries;
-  try {
-    entries = await fs.readdir(dir);
-  } catch {
-    return "1";
+__name(findIndexFromEnd, "findIndexFromEnd");
+var __awaiter$1 = function(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
   }
-  let maxId = 0;
-  for (const entry of entries) {
-    if (!entry.endsWith(".json")) continue;
-    const num = parseInt(entry.replace(".json", ""), 10);
-    if (!isNaN(num) && num > maxId) {
-      maxId = num;
+  __name(adopt, "adopt");
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
     }
+    __name(fulfilled, "fulfilled");
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    __name(rejected, "rejected");
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    __name(step, "step");
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+var Mutex = class {
+  static {
+    __name(this, "Mutex");
+  }
+  constructor(cancelError) {
+    this._semaphore = new Semaphore(1, cancelError);
   }
-  return String(maxId + 1);
+  acquire() {
+    return __awaiter$1(this, arguments, void 0, function* (priority = 0) {
+      const [, releaser] = yield this._semaphore.acquire(1, priority);
+      return releaser;
+    });
+  }
+  runExclusive(callback, priority = 0) {
+    return this._semaphore.runExclusive(() => callback(), 1, priority);
+  }
+  isLocked() {
+    return this._semaphore.isLocked();
+  }
+  waitForUnlock(priority = 0) {
+    return this._semaphore.waitForUnlock(1, priority);
+  }
+  release() {
+    if (this._semaphore.isLocked())
+      this._semaphore.release();
+  }
+  cancel() {
+    return this._semaphore.cancel();
+  }
+};
+var __awaiter = function(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  __name(adopt, "adopt");
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    __name(fulfilled, "fulfilled");
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    __name(rejected, "rejected");
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    __name(step, "step");
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+function withTimeout(sync, timeout, timeoutError = E_TIMEOUT) {
+  return {
+    acquire: /* @__PURE__ */ __name((weightOrPriority, priority) => {
+      let weight;
+      if (isSemaphore(sync)) {
+        weight = weightOrPriority;
+      } else {
+        weight = void 0;
+        priority = weightOrPriority;
+      }
+      if (weight !== void 0 && weight <= 0) {
+        throw new Error(`invalid weight ${weight}: must be positive`);
+      }
+      return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+        let isTimeout = false;
+        const handle = setTimeout(() => {
+          isTimeout = true;
+          reject(timeoutError);
+        }, timeout);
+        try {
+          const ticket = yield isSemaphore(sync) ? sync.acquire(weight, priority) : sync.acquire(priority);
+          if (isTimeout) {
+            const release = Array.isArray(ticket) ? ticket[1] : ticket;
+            release();
+          } else {
+            clearTimeout(handle);
+            resolve(ticket);
+          }
+        } catch (e) {
+          if (!isTimeout) {
+            clearTimeout(handle);
+            reject(e);
+          }
+        }
+      }));
+    }, "acquire"),
+    runExclusive(callback, weight, priority) {
+      return __awaiter(this, void 0, void 0, function* () {
+        let release = /* @__PURE__ */ __name(() => void 0, "release");
+        try {
+          const ticket = yield this.acquire(weight, priority);
+          if (Array.isArray(ticket)) {
+            release = ticket[1];
+            return yield callback(ticket[0]);
+          } else {
+            release = ticket;
+            return yield callback();
+          }
+        } finally {
+          release();
+        }
+      });
+    },
+    release(weight) {
+      sync.release(weight);
+    },
+    cancel() {
+      return sync.cancel();
+    },
+    waitForUnlock: /* @__PURE__ */ __name((weightOrPriority, priority) => {
+      let weight;
+      if (isSemaphore(sync)) {
+        weight = weightOrPriority;
+      } else {
+        weight = void 0;
+        priority = weightOrPriority;
+      }
+      if (weight !== void 0 && weight <= 0) {
+        throw new Error(`invalid weight ${weight}: must be positive`);
+      }
+      return new Promise((resolve, reject) => {
+        const handle = setTimeout(() => reject(timeoutError), timeout);
+        (isSemaphore(sync) ? sync.waitForUnlock(weight, priority) : sync.waitForUnlock(priority)).then(() => {
+          clearTimeout(handle);
+          resolve();
+        });
+      });
+    }, "waitForUnlock"),
+    isLocked: /* @__PURE__ */ __name(() => sync.isLocked(), "isLocked"),
+    getValue: /* @__PURE__ */ __name(() => sync.getValue(), "getValue"),
+    setValue: /* @__PURE__ */ __name((value) => sync.setValue(value), "setValue")
+  };
+}
+__name(withTimeout, "withTimeout");
+function isSemaphore(sync) {
+  return sync.getValue !== void 0;
 }
-__name(getNextTaskId, "getNextTaskId");
+__name(isSemaphore, "isSemaphore");
 
 export {
+  E_TIMEOUT,
+  Mutex,
+  withTimeout,
+  getTeamsRootDir,
+  getTeamDir,
+  getTeamFilePath,
+  getInboxesDir,
+  getTasksDir,
+  sanitizeName,
+  formatAgentId,
+  generateUniqueTeammateName,
+  assignTeammateColor,
+  clearTeammateColors,
+  setMemberActive,
+  findMemberById,
+  findMemberByName,
+  classifyShutdownResponse,
+  readTeamFile,
+  writeTeamFile,
+  createTeamFile,
+  tryReclaimStaleTeam,
+  deleteTeamDirs,
+  listTeamNames,
   require_graceful_fs,
-  require_proper_lockfile,
-  assertValidTaskId,
-  getTaskPath,
-  onTasksUpdated,
-  notifyTasksUpdated,
-  createTask,
-  getTask,
-  TaskOwnershipError,
-  updateTask,
-  deleteTask,
-  listTasks,
-  resetTaskList,
-  blockTask,
-  claimTask,
-  releaseOwnedTask,
-  unassignTeammateTasks,
-  getAgentStatuses
+  require_proper_lockfile
 };
 /**
  * @license