@qwen-code/qwen-code 0.19.9 → 0.19.10-nightly.20260716.506ce0a1a

package/chunks/chunk-SJSI7PXU.js

@@ -0,0 +1,59 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  runExitCleanup
+} from "./chunk-HUEWOHKV.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/utils/processUtils.ts
+init_esbuild_shims();
+var RELAUNCH_EXIT_CODE = 42;
+var UPDATE_RELAUNCH_EXIT_CODE = 43;
+var UPDATE_COMPLETE_EXIT_CODE = 44;
+var SKIP_UPDATE_CHECK_ENV_VAR = "QWEN_CODE_SKIP_UPDATE_CHECK_ONCE";
+var CUSTOM_SANDBOX_IMAGE_ENV_VAR = "QWEN_CODE_CUSTOM_SANDBOX_IMAGE";
+var HOST_UPDATE_RELAUNCH_ENV_VAR = "QWEN_CODE_HOST_UPDATE_RELAUNCH";
+var UPDATE_ON_EXIT_MESSAGE = "qwen-code:update-on-exit";
+async function relaunchApp() {
+  await runExitCleanup();
+  process.exit(RELAUNCH_EXIT_CODE);
+}
+__name(relaunchApp, "relaunchApp");
+async function relaunchForUpdate() {
+  await runExitCleanup();
+  process.exit(UPDATE_RELAUNCH_EXIT_CODE);
+}
+__name(relaunchForUpdate, "relaunchForUpdate");
+function requestUpdateOnExit() {
+  if (!process.send) return false;
+  try {
+    process.send({ type: UPDATE_ON_EXIT_MESSAGE });
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(requestUpdateOnExit, "requestUpdateOnExit");
+
+export {
+  RELAUNCH_EXIT_CODE,
+  UPDATE_RELAUNCH_EXIT_CODE,
+  UPDATE_COMPLETE_EXIT_CODE,
+  SKIP_UPDATE_CHECK_ENV_VAR,
+  CUSTOM_SANDBOX_IMAGE_ENV_VAR,
+  HOST_UPDATE_RELAUNCH_ENV_VAR,
+  UPDATE_ON_EXIT_MESSAGE,
+  relaunchApp,
+  relaunchForUpdate,
+  requestUpdateOnExit
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-HVY356M2.js → chunk-SMGBWLNU.js}

@@ -5,17 +5,17 @@ import {
   Text,
   require_jsx_runtime,
   theme
-} from "./chunk-CNEIYWSA.js";
+} from "./chunk-OVIV236K.js";
 import {
   require_react
 } from "./chunk-HTHUX2T5.js";
 import {
   stringWidth,
   toCodePoints
-} from "./chunk-Q6I5QHMH.js";
+} from "./chunk-MFNKBXYH.js";
 import {
   createDebugLogger
-} from "./chunk-J4TSQ5EQ.js";
+} from "./chunk-7NFB7LBQ.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-CEA3E3JB.js → chunk-SPJQO2CE.js}

@@ -5,11 +5,11 @@ import {
 } from "./chunk-VGC4I5JJ.js";
 import {
   atomicWriteJSON
-} from "./chunk-ZLXQN2QS.js";
+} from "./chunk-WIEO4CWB.js";
 import {
   Storage,
   getProjectHash
-} from "./chunk-J4TSQ5EQ.js";
+} from "./chunk-7NFB7LBQ.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-CC2ITGCF.js → chunk-STZQCNN3.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   SessionNotFoundError
-} from "./chunk-IAVB3HM3.js";
+} from "./chunk-L4Y55KIS.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -38,6 +38,12 @@ function createWorkspaceSessionOwnerIndex() {
     register,
     remove,
     getWorkspaceCwds: /* @__PURE__ */ __name((sessionId) => [...bySessionId.get(sessionId) ?? []], "getWorkspaceCwds"),
+    removeWorkspace: /* @__PURE__ */ __name((workspaceCwd) => {
+      for (const [sessionId, owners] of bySessionId) {
+        owners.delete(workspaceCwd);
+        if (owners.size === 0) bySessionId.delete(sessionId);
+      }
+    }, "removeWorkspace"),
     handleBridgeSessionLifecycle: /* @__PURE__ */ __name((event) => {
       if (event.type === "registered") {
         register(event.sessionId, event.workspaceCwd);
@@ -81,11 +87,15 @@ function createWorkspaceRegistry(inputRuntimes, options = {}) {
     byId.set(runtime.workspaceId, runtime);
   }
   const runtimes = [...inputRuntimes];
+  const states = new WeakMap(
+    inputRuntimes.map((runtime) => [runtime, "active"])
+  );
   const primary = primaryRuntimes[0];
   const sessionOwnerIndex = options.sessionOwnerIndex;
   const scanLiveOwners = /* @__PURE__ */ __name((sessionId) => {
     const matches = [];
     for (const runtime of runtimes) {
+      if (states.get(runtime) !== "active") continue;
       try {
         runtime.bridge.getSessionSummary(sessionId);
         matches.push(runtime);
@@ -107,10 +117,24 @@ function createWorkspaceRegistry(inputRuntimes, options = {}) {
     primary,
     // Return a frozen snapshot: `runtimes` is mutable internally (see `add`),
     // but callers must not be able to push/splice into the registry's state.
-    list: /* @__PURE__ */ __name(() => Object.freeze([...runtimes]), "list"),
-    getByWorkspaceCwd: /* @__PURE__ */ __name((workspaceCwd) => byCwd.get(workspaceCwd), "getByWorkspaceCwd"),
-    getByWorkspaceId: /* @__PURE__ */ __name((workspaceId) => byId.get(workspaceId), "getByWorkspaceId"),
-    resolveWorkspaceCwd: /* @__PURE__ */ __name((workspaceCwd) => workspaceCwd === void 0 ? primary : byCwd.get(workspaceCwd), "resolveWorkspaceCwd"),
+    list: /* @__PURE__ */ __name(() => Object.freeze(
+      runtimes.filter((runtime) => states.get(runtime) === "active")
+    ), "list"),
+    listManaged: /* @__PURE__ */ __name(() => Object.freeze([...runtimes]), "listManaged"),
+    getByWorkspaceCwd: /* @__PURE__ */ __name((workspaceCwd) => {
+      const runtime = byCwd.get(workspaceCwd);
+      return runtime && states.get(runtime) === "active" ? runtime : void 0;
+    }, "getByWorkspaceCwd"),
+    getByWorkspaceId: /* @__PURE__ */ __name((workspaceId) => {
+      const runtime = byId.get(workspaceId);
+      return runtime && states.get(runtime) === "active" ? runtime : void 0;
+    }, "getByWorkspaceId"),
+    getManagedByWorkspaceCwd: /* @__PURE__ */ __name((workspaceCwd) => byCwd.get(workspaceCwd), "getManagedByWorkspaceCwd"),
+    getManagedByWorkspaceId: /* @__PURE__ */ __name((workspaceId) => byId.get(workspaceId), "getManagedByWorkspaceId"),
+    resolveWorkspaceCwd: /* @__PURE__ */ __name((workspaceCwd) => workspaceCwd === void 0 ? primary : (() => {
+      const runtime = byCwd.get(workspaceCwd);
+      return runtime && states.get(runtime) === "active" ? runtime : void 0;
+    })(), "resolveWorkspaceCwd"),
     add: /* @__PURE__ */ __name((runtime) => {
       if (byCwd.has(runtime.workspaceCwd)) {
         throw new Error(
@@ -125,17 +149,36 @@ function createWorkspaceRegistry(inputRuntimes, options = {}) {
       byCwd.set(runtime.workspaceCwd, runtime);
       byId.set(runtime.workspaceId, runtime);
       runtimes.push(runtime);
+      states.set(runtime, "active");
     }, "add"),
+    beginDrain: /* @__PURE__ */ __name((runtime) => {
+      if (runtime.primary || states.get(runtime) !== "active") return false;
+      states.set(runtime, "draining");
+      return true;
+    }, "beginDrain"),
+    cancelDrain: /* @__PURE__ */ __name((runtime) => {
+      if (states.get(runtime) === "draining") states.set(runtime, "active");
+    }, "cancelDrain"),
+    completeDrain: /* @__PURE__ */ __name((runtime) => {
+      if (runtime.primary || states.get(runtime) !== "draining") return;
+      states.set(runtime, "removed");
+      byCwd.delete(runtime.workspaceCwd);
+      byId.delete(runtime.workspaceId);
+      const index = runtimes.indexOf(runtime);
+      if (index >= 0) runtimes.splice(index, 1);
+      sessionOwnerIndex?.removeWorkspace(runtime.workspaceCwd);
+    }, "completeDrain"),
     resolveLiveSessionOwner: /* @__PURE__ */ __name((sessionId) => {
       const indexedCwds = sessionOwnerIndex?.getWorkspaceCwds(sessionId) ?? [];
       if (indexedCwds.length > 0) {
         const matches = [];
         for (const workspaceCwd of indexedCwds) {
           const runtime = byCwd.get(workspaceCwd);
-          if (!runtime) {
+          if (!runtime || states.get(runtime) === "removed") {
             sessionOwnerIndex?.remove(sessionId, workspaceCwd);
             continue;
           }
+          if (states.get(runtime) !== "active") continue;
           try {
             runtime.bridge.getSessionSummary(sessionId);
             matches.push(runtime);

package/chunks/{chunk-HPDUL5MF.js → chunk-T2ZDAER2.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   t
-} from "./chunk-YAUFFXDS.js";
+} from "./chunk-7GM2RWCR.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-XUOOWUZS.js → chunk-T3TQ3ACP.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   BaseJsonOutputAdapter
-} from "./chunk-B4G2WOFA.js";
+} from "./chunk-Q5MKHNIR.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-4C5BQ2D2.js → chunk-TIKDHS6V.js}

@@ -10,22 +10,24 @@ import {
   getLanguageNameFromLocale,
   getLanguageSettingsOptions,
   t
-} from "./chunk-YAUFFXDS.js";
+} from "./chunk-7GM2RWCR.js";
 import {
   getHomeEnvFallbackVars,
   loadEnvironment,
   preResolveHomeEnvOverrides
-} from "./chunk-SCGXUJBT.js";
+} from "./chunk-6LI3L22E.js";
 import {
   CONSOLIDATED_DISABLE_KEYS,
   V1_INDICATOR_KEYS,
   V1_TO_V2_MIGRATION_MAP,
   V1_TO_V2_PRESERVE_DISABLE_MAP,
   V2_CONTAINER_KEYS,
-  getSystemDefaultsPath,
-  getSystemSettingsPath,
   resolveEnvVarsInObject
-} from "./chunk-3BTRNWWD.js";
+} from "./chunk-GOXKNSDZ.js";
+import {
+  getSystemDefaultsPath,
+  getSystemSettingsPath
+} from "./chunk-IDS7MSUP.js";
 import {
   ENV_CORRUPTED_PATH,
   ENV_WAS_RECOVERED
@@ -33,10 +35,10 @@ import {
 import {
   isWorkspaceTrusted,
   updateSettingsFilePreservingFormat
-} from "./chunk-HKMAENAO.js";
+} from "./chunk-QDTGDM2T.js";
 import {
   require_strip_json_comments
-} from "./chunk-RDJSGHZE.js";
+} from "./chunk-ALGGS7UH.js";
 import {
   DEFAULT_MAX_SUBAGENT_DEPTH,
   DEFAULT_MAX_TOOL_CALLS_PER_TURN,
@@ -46,20 +48,20 @@ import {
   DEFAULT_TRUNCATE_TOOL_OUTPUT_LINES,
   DEFAULT_TRUNCATE_TOOL_OUTPUT_THRESHOLD,
   stripRuntimeSnapshotPrefix
-} from "./chunk-NVYTCB5Z.js";
+} from "./chunk-SA6QVLWI.js";
 import {
   DEFAULT_QWEN_CUSTOM_IGNORE_FILE_NAMES
-} from "./chunk-4QLQE5WJ.js";
+} from "./chunk-L5U3ELZX.js";
 import {
   DEFAULT_SENSITIVE_SPAN_ATTRIBUTE_MAX_LENGTH,
   SENSITIVE_SPAN_ATTRIBUTE_MAX_LENGTH_LIMIT
-} from "./chunk-3VAGG5T5.js";
+} from "./chunk-YYBZUIPL.js";
 import {
   FatalConfigError,
   Storage,
   createDebugLogger,
   getErrorMessage
-} from "./chunk-J4TSQ5EQ.js";
+} from "./chunk-7NFB7LBQ.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -100,6 +102,18 @@ function getPersistScopeForModelSelection(settings) {
   return getModelProvidersOwnerScope(settings) ?? "User" /* User */;
 }
 __name(getPersistScopeForModelSelection, "getPersistScopeForModelSelection");
+function getWritableScopes(settings) {
+  return settings.isTrusted ? ["Workspace" /* Workspace */, "User" /* User */] : ["User" /* User */];
+}
+__name(getWritableScopes, "getWritableScopes");
+function getOwnKeyScope(settings, key) {
+  for (const scope of getWritableScopes(settings)) {
+    const obj = settings.forScope(scope).settings;
+    if (Object.prototype.hasOwnProperty.call(obj, key)) return scope;
+  }
+  return void 0;
+}
+__name(getOwnKeyScope, "getOwnKeyScope");
 
 // packages/cli/src/config/settingsSchema.ts
 init_esbuild_shims();
@@ -486,6 +500,19 @@ var SETTINGS_SCHEMA = {
         description: "Play terminal bell sound when response completes or needs approval.",
         showInDialog: true
       },
+      notificationMode: {
+        type: "enum",
+        label: "Notification Mode",
+        category: "General",
+        requiresRestart: false,
+        default: "all",
+        description: 'Which unfocused-terminal events fire a bell/OS notification. "all" fires on every tool approval prompt AND on task completion (current behavior). "task-complete" suppresses the per-approval notification and only fires when a long task returns to idle. Requires `terminalBell` to be enabled; otherwise no notifications fire regardless of mode.',
+        showInDialog: true,
+        options: [
+          { value: "all", label: "All (approvals + task completion)" },
+          { value: "task-complete", label: "Task completion only" }
+        ]
+      },
       preventSystemSleep: {
         type: "boolean",
         label: "Prevent System Sleep While Running",
@@ -1173,12 +1200,12 @@ var SETTINGS_SCHEMA = {
         ]
       },
       maxSessionTurns: {
-        type: "number",
+        type: "integer",
         label: "Max Session Turns",
         category: "Model",
         requiresRestart: false,
         default: -1,
-        description: "Maximum number of user/model/tool turns to keep in a session. -1 means unlimited.",
+        description: "Maximum number of user/model/tool turns to keep in a session. Must be an integer; -1 means unlimited.",
         showInDialog: false
       },
       maxWallTimeSeconds: {
@@ -1254,7 +1281,7 @@ var SETTINGS_SCHEMA = {
         showInDialog: false
       },
       maxToolCallsPerTurn: {
-        type: "number",
+        type: "integer",
         label: "Max Tool Calls Per Turn",
         category: "Model",
         requiresRestart: false,
@@ -1603,7 +1630,7 @@ var SETTINGS_SCHEMA = {
         label: "Enable Auto Skill",
         category: "Memory",
         requiresRestart: false,
-        default: true,
+        default: false,
         description: "Enable background review for reusable project skills after tool-heavy sessions.",
         showInDialog: false
       },
@@ -1955,6 +1982,28 @@ var SETTINGS_SCHEMA = {
             default: false,
             description: "Show color in shell output.",
             showInDialog: false
+          },
+          defaultTimeoutMs: {
+            type: "integer",
+            minimum: 0,
+            maximum: 6e5,
+            label: "Default Command Timeout (ms)",
+            category: "Tools",
+            requiresRestart: true,
+            default: void 0,
+            description: "Default timeout, in milliseconds, for foreground shell commands started by the agent. A per-call timeout on the shell tool overrides this. When unset, foreground commands time out after 120000 ms (2 minutes). Set to 0 to disable the timeout.",
+            showInDialog: false
+          },
+          heartbeatIntervalMs: {
+            type: "integer",
+            minimum: 0,
+            maximum: 6e5,
+            label: "Silent Command Heartbeat Interval (ms)",
+            category: "Tools",
+            requiresRestart: true,
+            default: void 0,
+            description: "Interval, in milliseconds, between liveness heartbeats emitted while a foreground shell command produces no output. Heartbeats are forwarded to ACP clients and stream-json consumers so they can tell a silent command from a dead session. When unset, heartbeats fire every 10000 ms (10 seconds). Set to 0 to disable heartbeats.",
+            showInDialog: false
           }
         }
       },
@@ -2013,7 +2062,7 @@ var SETTINGS_SCHEMA = {
         label: "Tool Approval Mode",
         category: "Tools",
         requiresRestart: false,
-        default: "default" /* DEFAULT */,
+        default: "auto" /* AUTO */,
         description: "Approval mode for tool usage. Controls how tools are approved before execution.",
         showInDialog: true,
         options: [
@@ -2407,9 +2456,29 @@ var SETTINGS_SCHEMA = {
     category: "Advanced",
     requiresRestart: false,
     default: {},
-    description: "Settings for multi-agent collaboration features (Arena, Team, Swarm).",
+    description: "Settings for built-in agents and multi-agent collaboration features (Arena, Team, Swarm).",
     showInDialog: false,
     properties: {
+      builtin: {
+        type: "object",
+        label: "Built-in Agents",
+        category: "Advanced",
+        requiresRestart: true,
+        default: {},
+        description: "Settings for built-in subagents.",
+        showInDialog: false,
+        properties: {
+          exploreModel: {
+            type: "string",
+            label: "Explore Model",
+            category: "Model",
+            requiresRestart: true,
+            default: "inherit",
+            description: 'Model selector for the built-in Explore subagent. Use "inherit" for the main session model, "fast" for fastModel, a model ID, or an authType:model-id selector. Custom same-name agents are unaffected.',
+            showInDialog: false
+          }
+        }
+      },
       maxParallelAgents: {
         type: "number",
         label: "Max Parallel Agents",
@@ -2573,6 +2642,17 @@ var SETTINGS_SCHEMA = {
         mergeStrategy: "concat" /* CONCAT */,
         items: HOOK_DEFINITION_ITEMS
       },
+      MessageDisplay: {
+        type: "array",
+        label: "Message Display Hooks",
+        category: "Advanced",
+        requiresRestart: false,
+        default: [],
+        description: "Hooks that execute repeatedly as the assistant reply streams, before the After Agent (Stop) hooks fire.",
+        showInDialog: false,
+        mergeStrategy: "concat" /* CONCAT */,
+        items: HOOK_DEFINITION_ITEMS
+      },
       Notification: {
         type: "array",
         label: "Notification Hooks",
@@ -4658,7 +4738,10 @@ function saveSettings(settingsFile, updates = settingsFile.originalSettings, rep
 __name(saveSettings, "saveSettings");
 
 export {
+  getModelProvidersOwnerScope,
   getPersistScopeForModelSelection,
+  getWritableScopes,
+  getOwnKeyScope,
   TOGGLE_TYPES,
   OUTPUT_LANGUAGE_AUTO,
   isAutoLanguage,

package/chunks/chunk-TV6K2FB4.js

@@ -0,0 +1,224 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  INBOXES_DIR,
+  LEADER_NAME,
+  TASKS_DIR,
+  TEAMMATE_COLORS,
+  TEAMS_DIR,
+  TEAM_CONFIG_FILENAME
+} from "./chunk-CPBF7KYF.js";
+import {
+  atomicWriteJSON
+} from "./chunk-WIEO4CWB.js";
+import {
+  Storage,
+  isNodeError
+} from "./chunk-7NFB7LBQ.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/agents/team/teamHelpers.ts
+init_esbuild_shims();
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+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(
+      `Teammate name "${baseName}" sanitizes to an empty string. Choose a name with at least one alphanumeric character.`
+    );
+  }
+  if (sanitized === LEADER_NAME) {
+    throw new Error(
+      `"${LEADER_NAME}" is reserved for the team leader. Choose a different teammate name.`
+    );
+  }
+  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(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;
+    }
+  }
+  return TEAMMATE_COLORS[existingMembers.length % TEAMMATE_COLORS.length];
+}
+__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(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch (err) {
+    if (isNodeError(err) && err.code === "ENOENT") {
+      return void 0;
+    }
+    throw err;
+  }
+}
+__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 {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return isNodeError(err) && err.code === "EPERM";
+  }
+}
+__name(isPidAlive, "isPidAlive");
+async function tryReclaimStaleTeam(teamName) {
+  let existing;
+  try {
+    existing = await readTeamFile(teamName);
+  } catch {
+    return false;
+  }
+  if (!existing) {
+    await deleteTeamDirs(teamName);
+    return true;
+  }
+  if (typeof existing.leadPid !== "number" || existing.leadPid <= 0) {
+    return false;
+  }
+  if (existing.leadPid !== process.pid && isPidAlive(existing.leadPid)) {
+    return false;
+  }
+  await deleteTeamDirs(teamName);
+  return true;
+}
+__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(deleteTeamDirs, "deleteTeamDirs");
+async function listTeamNames() {
+  const teamsRoot = getTeamsRootDir();
+  try {
+    const entries = await fs.readdir(teamsRoot, {
+      withFileTypes: true
+    });
+    return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+__name(listTeamNames, "listTeamNames");
+
+export {
+  getTeamsRootDir,
+  getTeamDir,
+  getTeamFilePath,
+  getInboxesDir,
+  getTasksDir,
+  sanitizeName,
+  formatAgentId,
+  generateUniqueTeammateName,
+  assignTeammateColor,
+  clearTeammateColors,
+  setMemberActive,
+  findMemberById,
+  findMemberByName,
+  classifyShutdownResponse,
+  readTeamFile,
+  writeTeamFile,
+  createTeamFile,
+  tryReclaimStaleTeam,
+  deleteTeamDirs,
+  listTeamNames
+};
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-5XUCZNSY.js → chunk-TYLOFD2U.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   createDebugLogger
-} from "./chunk-J4TSQ5EQ.js";
+} from "./chunk-7NFB7LBQ.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";