@qwen-code/qwen-code 0.21.7 → 0.21.8

package/chunks/chunk-NGYI5EF5.js

@@ -0,0 +1,244 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/commands/channel/channel-registry.ts
+init_esbuild_shims();
+var registry = /* @__PURE__ */ new Map();
+var builtinsPromise = null;
+var UNSAFE_OBJECT_KEYS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype"
+]);
+var FIELD_KINDS = /* @__PURE__ */ new Set([
+  "string",
+  "secret",
+  "boolean",
+  "number",
+  "enum",
+  "string-list",
+  "record",
+  "object"
+]);
+function assertManagementFields(fields, parentPath, nested = false) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const field of fields) {
+    const path = parentPath ? `${parentPath}.${field.key}` : field.key;
+    if (typeof field.key !== "string" || field.key.length === 0) {
+      throw new Error(
+        `Channel field "${path}" must declare a non-empty string key.`
+      );
+    }
+    if (seen.has(field.key)) {
+      throw new Error(`Channel field "${path}" is declared more than once.`);
+    }
+    seen.add(field.key);
+    assertManagementField(field, path, nested);
+  }
+}
+__name(assertManagementFields, "assertManagementFields");
+function assertManagementField(field, path, nested) {
+  if (!FIELD_KINDS.has(field.kind)) {
+    throw new Error(
+      `Channel field "${path}" declares an unknown kind "${field.kind}".`
+    );
+  }
+  if (UNSAFE_OBJECT_KEYS.has(field.key)) {
+    throw new Error(`Channel field "${path}" cannot use a reserved key.`);
+  }
+  if (!nested && field.key === "type") {
+    throw new Error(
+      `Channel field "${path}" cannot use the reserved key "type".`
+    );
+  }
+  if (typeof field.label !== "string" || field.label.length === 0) {
+    throw new Error(`Channel field "${path}" must declare a string label.`);
+  }
+  if (field.description !== void 0 && typeof field.description !== "string") {
+    throw new Error(
+      `Channel field "${path}" must declare a string description.`
+    );
+  }
+  if (field.default !== void 0 && typeof field.default !== "string") {
+    throw new Error(`Channel field "${path}" must declare a string default.`);
+  }
+  const envResolvable = Boolean(field.envResolvable);
+  const required = Boolean(field.required);
+  if (field.kind === "secret" && nested) {
+    throw new Error(`Channel field "${path}" cannot declare a nested secret.`);
+  }
+  if (envResolvable && (nested || field.kind !== "string" && field.kind !== "secret")) {
+    throw new Error(
+      `Channel field "${path}" cannot resolve environment references.`
+    );
+  }
+  const exclusiveMinimum = field.exclusiveMinimum;
+  if (exclusiveMinimum !== void 0) {
+    if (field.kind !== "number") {
+      throw new Error(
+        `Channel field "${path}" can only declare exclusiveMinimum on number fields.`
+      );
+    }
+    if (typeof exclusiveMinimum !== "number" || !Number.isFinite(exclusiveMinimum)) {
+      throw new Error(
+        `Channel field "${path}" must declare a finite exclusiveMinimum.`
+      );
+    }
+  }
+  if (field.kind === "enum") {
+    if (!Array.isArray(field.options) || field.options.length === 0) {
+      throw new Error(
+        `Channel field "${path}" must declare at least one option.`
+      );
+    }
+    if (field.options.some(
+      (option) => typeof option?.value !== "string" || option.value.length === 0
+    )) {
+      throw new Error(
+        `Channel field "${path}" must declare non-empty string option values.`
+      );
+    }
+    if (new Set(field.options.map((option) => option.value)).size !== field.options.length) {
+      throw new Error(
+        `Channel field "${path}" declares duplicate option values.`
+      );
+    }
+    if (field.default !== void 0 && !field.options.some((option) => option.value === field.default)) {
+      throw new Error(
+        `Channel field "${path}" declares a default that is not one of its options.`
+      );
+    }
+  }
+  if (field.kind !== "object") return;
+  if (required) {
+    throw new Error(`Channel field "${path}" cannot be a required object.`);
+  }
+  if (!Array.isArray(field.properties)) {
+    throw new Error(`Channel field "${path}" must declare a properties array.`);
+  }
+  if (field.properties.length === 0) {
+    throw new Error(
+      `Channel field "${path}" must declare at least one property.`
+    );
+  }
+  assertManagementFields(field.properties, path, true);
+}
+__name(assertManagementField, "assertManagementField");
+function assertManagementDescriptor(plugin) {
+  const management = plugin.management;
+  if (management === void 0) return;
+  if (management.validateConfig !== void 0 && (typeof management.validateConfig !== "function" || management.validateConfig.constructor.name === "AsyncFunction")) {
+    throw new Error(
+      "Channel management metadata must declare validateConfig as a synchronous function."
+    );
+  }
+  if (!Array.isArray(management.fields)) {
+    throw new Error("Channel management metadata must declare a fields array.");
+  }
+  assertManagementFields(management.fields);
+}
+__name(assertManagementDescriptor, "assertManagementDescriptor");
+function ensureBuiltins() {
+  if (!builtinsPromise) {
+    builtinsPromise = (async () => {
+      const labelled = [
+        { name: "telegram", promise: import("./dist-IRL7WA5Z.js") },
+        { name: "weixin", promise: import("./dist-RCH3I7SS.js") },
+        { name: "dingtalk", promise: import("./dist-HIACTZEK.js") },
+        { name: "wecom", promise: import("./dist-KVISB2O2.js") },
+        { name: "feishu", promise: import("./dist-EEEQGCZA.js") },
+        { name: "qqbot", promise: import("./dist-MKX5OSFF.js") },
+        { name: "github", promise: import("./dist-MBF3I5MX.js") },
+        { name: "gitlab", promise: import("./dist-TUSWNE2I.js") }
+      ];
+      const results = await Promise.allSettled(labelled.map((l) => l.promise));
+      for (let i = 0; i < results.length; i++) {
+        const result = results[i];
+        if (result.status === "fulfilled") {
+          registerWithManagementValidation(
+            result.value.plugin,
+            labelled[i].name
+          );
+        } else {
+          process.stderr.write(
+            `[channel-registry] Failed to load "${labelled[i].name}" channel: ${result.reason}
+`
+          );
+        }
+      }
+    })();
+  }
+  return builtinsPromise;
+}
+__name(ensureBuiltins, "ensureBuiltins");
+function registerPlugin(plugin) {
+  if (registry.has(plugin.channelType)) {
+    throw new Error(
+      `Channel type "${plugin.channelType}" is already registered.`
+    );
+  }
+  registerWithManagementValidation(plugin, plugin.channelType);
+}
+__name(registerPlugin, "registerPlugin");
+function registerWithManagementValidation(plugin, label) {
+  try {
+    assertManagementDescriptor(plugin);
+  } catch (error) {
+    process.stderr.write(
+      `[channel-registry] Invalid management metadata in "${label}" channel: ${error instanceof Error ? error.message : String(error)}
+`
+    );
+    const stripped = Object.assign(
+      Object.create(
+        Object.getPrototypeOf(plugin) ?? Object.prototype
+      ),
+      plugin
+    );
+    Object.defineProperty(stripped, "management", {
+      value: void 0,
+      writable: true,
+      enumerable: true,
+      configurable: true
+    });
+    registry.set(plugin.channelType, stripped);
+    return;
+  }
+  registry.set(plugin.channelType, plugin);
+}
+__name(registerWithManagementValidation, "registerWithManagementValidation");
+async function getPlugin(channelType) {
+  await ensureBuiltins();
+  return registry.get(channelType);
+}
+__name(getPlugin, "getPlugin");
+async function supportedTypes() {
+  await ensureBuiltins();
+  return [...registry.keys()];
+}
+__name(supportedTypes, "supportedTypes");
+async function supportedChannelCatalog() {
+  await ensureBuiltins();
+  return [...registry.values()].map(
+    ({ channelType, displayName, management }) => ({
+      type: channelType,
+      displayName,
+      manageable: management !== void 0,
+      fields: management?.fields ?? []
+    })
+  );
+}
+__name(supportedChannelCatalog, "supportedChannelCatalog");
+
+export {
+  UNSAFE_OBJECT_KEYS,
+  registerPlugin,
+  getPlugin,
+  supportedTypes,
+  supportedChannelCatalog
+};

package/chunks/{chunk-ALGGS7UH.js → chunk-NPQ5ZKRP.js}

@@ -1,5 +1,9 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  getPathComparisonVariants,
+  isWithinRoot
+} from "./chunk-MR3PXB6E.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -81,6 +85,83 @@ var require_strip_json_comments = __commonJS({
   }
 });
 
+// packages/cli/src/config/trust-precedence.ts
+init_esbuild_shims();
+import * as path from "node:path";
+function pathDepth(value) {
+  const root = path.parse(value).root;
+  const relative2 = path.relative(root, value);
+  return relative2 === "" ? 0 : relative2.split(path.sep).filter(Boolean).length;
+}
+__name(pathDepth, "pathDepth");
+function matchingDepth(rule, locationVariants) {
+  let deepestMatch = -1;
+  for (const locationVariant of locationVariants) {
+    for (const ruleVariant of rule.variants) {
+      if (isWithinRoot(locationVariant, ruleVariant)) {
+        deepestMatch = Math.max(deepestMatch, pathDepth(ruleVariant));
+      }
+    }
+  }
+  return deepestMatch;
+}
+__name(matchingDepth, "matchingDepth");
+function buildTrustPrecedenceRules(rules) {
+  const result = [];
+  for (const rule of rules) {
+    let level;
+    let rulePath = rule.path;
+    switch (rule.trustLevel) {
+      case "TRUST_FOLDER":
+        level = "trusted";
+        break;
+      case "TRUST_PARENT":
+        level = "trusted";
+        rulePath = path.dirname(rule.path);
+        break;
+      case "DO_NOT_TRUST":
+        level = "untrusted";
+        break;
+      default:
+        continue;
+    }
+    result.push({
+      level,
+      variants: getPathComparisonVariants(rulePath),
+      payload: rule.trustLevel
+    });
+  }
+  return result;
+}
+__name(buildTrustPrecedenceRules, "buildTrustPrecedenceRules");
+function resolveTrustRule(rules, locationVariants) {
+  let winner;
+  let winnerDepth = -1;
+  for (const rule of rules) {
+    const depth = matchingDepth(rule, locationVariants);
+    if (depth < 0) continue;
+    if (depth > winnerDepth || depth === winnerDepth && rule.level === "untrusted" && winner?.level !== "untrusted") {
+      winner = rule;
+      winnerDepth = depth;
+    }
+  }
+  return winner;
+}
+__name(resolveTrustRule, "resolveTrustRule");
+function resolveTrustDecision(rules, locationVariants) {
+  const winner = resolveTrustRule(rules, locationVariants);
+  return winner?.level === "trusted" ? true : winner?.level === "untrusted" ? false : void 0;
+}
+__name(resolveTrustDecision, "resolveTrustDecision");
+
 export {
-  require_strip_json_comments
+  require_strip_json_comments,
+  buildTrustPrecedenceRules,
+  resolveTrustRule,
+  resolveTrustDecision
 };
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-HQB2KUAN.js → chunk-NPUXXRJI.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   runExitCleanup
-} from "./chunk-EORNAQDT.js";
+} from "./chunk-6TR7CFXH.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-QETYKPMG.js → chunk-NVRDQFCX.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   getEffectiveSupportedModes
-} from "./chunk-RNVQB725.js";
+} from "./chunk-XHD7CRP2.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-PQBHU2IA.js → chunk-OHKJVAKG.js}

@@ -21,23 +21,23 @@ import {
   getLanguageNameFromLocale,
   getLanguageSettingsOptions,
   t
-} from "./chunk-DBOFL3LQ.js";
+} from "./chunk-PG62DFWD.js";
 import {
   getHomeEnvFallbackVars,
   loadEnvironment,
   preResolveHomeEnvOverrides
-} from "./chunk-VOARQPTA.js";
+} from "./chunk-B52AWKBB.js";
 import {
   ENV_CORRUPTED_PATH,
   ENV_WAS_RECOVERED
-} from "./chunk-6PEXNQTX.js";
+} from "./chunk-UA5H3DS2.js";
 import {
   isWorkspaceTrusted,
   updateSettingsFilePreservingFormat
-} from "./chunk-6XU3PH66.js";
+} from "./chunk-HA3SAB64.js";
 import {
   require_strip_json_comments
-} from "./chunk-ALGGS7UH.js";
+} from "./chunk-NPQ5ZKRP.js";
 import {
   DEFAULT_MAX_SUBAGENT_DEPTH,
   DEFAULT_MAX_TOOL_CALLS_PER_TURN,
@@ -46,10 +46,10 @@ import {
   DEFAULT_TOOL_RESULTS_TOTAL_CHARS_THRESHOLD,
   DEFAULT_TRUNCATE_TOOL_OUTPUT_LINES,
   DEFAULT_TRUNCATE_TOOL_OUTPUT_THRESHOLD
-} from "./chunk-Y7E5LNLO.js";
+} from "./chunk-GXSNGY5M.js";
 import {
   stripRuntimeSnapshotPrefix
-} from "./chunk-RMH5OWLD.js";
+} from "./chunk-VXZ5HAOV.js";
 import {
   DEFAULT_QWEN_CUSTOM_IGNORE_FILE_NAMES
 } from "./chunk-EQL65XGA.js";
@@ -1352,7 +1352,7 @@ var SETTINGS_SCHEMA = {
         category: "Model",
         requiresRestart: false,
         default: true,
-        description: "Skip the opt-in streaming loop-detection heuristics (content/thought repetition, read-file and action stagnation, global-duplicate and alternating tool-call patterns). Defaults to true to avoid false-positive interruptions; set to false to re-enable them as an unattended-run guardrail. A minimal always-on guard (consecutive identical tool calls plus a per-turn tool-call cap, see model.maxToolCallsPerTurn) still runs regardless of this setting.",
+        description: "Skip the opt-in streaming loop-detection heuristics (content/thought repetition, read-file and action stagnation, global-duplicate and alternating tool-call patterns). Defaults to true to avoid false-positive interruptions; set to false to re-enable them as an unattended-run guardrail. Daemon/ACP sessions run none of the other detectors; setting this to false also enables a global-duplicate tool-call halt there. Core-client sessions keep a minimal always-on guard regardless of this setting (consecutive identical tool calls, shell inspection-command stagnation, and a per-turn tool-call cap, see model.maxToolCallsPerTurn); daemon/ACP sessions keep the per-turn tool-call cap and an invalid-tool-params stagnation guard.",
         showInDialog: false
       },
       maxToolCallsPerTurn: {
@@ -1361,7 +1361,7 @@ var SETTINGS_SCHEMA = {
         category: "Model",
         requiresRestart: false,
         default: DEFAULT_MAX_TOOL_CALLS_PER_TURN,
-        description: "Per-turn tool-call cap (one model turn plus its tool-result continuations; blocking Stop-hook continuations such as /goal iterations start a fresh budget). When set explicitly, this value is a hard cap: the turn halts on the next tool call after it is reached (the released behavior). When left unset (default 100), the cap is adaptive: once the turn exceeds 100 it halts only when the model keeps repeating the same call (a stuck loop); a productive turn (diverse calls) continues up to a hard backstop of 1000, which always halts. The adaptive default applies to both the interactive TUI and non-interactive (-p / JSON / stream-JSON) core-client runs; the daemon/ACP path always treats the value as a hard cap. An always-on circuit breaker against runaway turns, independent of model.skipLoopDetection. Set to 0 or a negative value to disable the cap.",
+        description: "Per-turn tool-call cap (one model turn plus its tool-result continuations; blocking Stop-hook continuations such as /goal iterations start a fresh budget). When set explicitly, this value is a hard cap: the turn halts on the next tool call after it is reached (the released behavior). When left unset (default 100), the cap is adaptive: once the turn exceeds 100 it halts only when the model keeps repeating the same call (a stuck loop); a productive turn (diverse calls) continues up to a hard backstop of 1000, which always halts. The adaptive default applies to the interactive TUI, non-interactive (-p / JSON / stream-JSON) core-client runs, and daemon/ACP sessions alike. Daemon/ACP sessions evaluate the cap once per tool batch, before execution: a batch that would cross an explicit cap or the hard backstop is skipped whole, so a turn never executes past either (it can halt up to one batch short), while the adaptive soft cap is exceeded by design, up to the backstop. They also have no in-session disable. An always-on circuit breaker against runaway turns, independent of model.skipLoopDetection. Set to 0 or a negative value to disable the cap.",
         showInDialog: false
       },
       skipStartupContext: {
@@ -1448,7 +1448,7 @@ var SETTINGS_SCHEMA = {
             category: "Generation Configuration",
             requiresRestart: false,
             default: true,
-            description: "Enable cache control for DashScope providers.",
+            description: "Enable provider prompt-cache controls.",
             parentKey: "generationConfig",
             showInDialog: false
           },

package/chunks/{chunk-CYR3HI5X.js → chunk-OQTXYMKW.js}

@@ -6,7 +6,7 @@ import {
 import {
   getPlanRequiredTeammatePreApprovalMessage,
   isPlanRequiredTeammateAwaitingApproval
-} from "./chunk-BVWVWGLE.js";
+} from "./chunk-WAUGQKUU.js";
 import {
   resolveActiveTeamName
 } from "./chunk-S6LOFUVP.js";
@@ -15,7 +15,7 @@ import {
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-IC4Z6LX6.js";
+} from "./chunk-PYQADEFD.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-DBOFL3LQ.js → chunk-PG62DFWD.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   resolveBundleDir
-} from "./chunk-Y7E5LNLO.js";
+} from "./chunk-GXSNGY5M.js";
 import {
   Storage
 } from "./chunk-OIVKILPI.js";
@@ -272,15 +272,15 @@ var MUST_TRANSLATE_KEYS = [
 
 // import("./locales/**/*.js") in packages/cli/src/i18n/index.ts
 var globImport_locales_js = __glob({
-  "./locales/ca.js": () => import("./ca-NYKNH222.js"),
-  "./locales/de.js": () => import("./de-VL76CPLV.js"),
-  "./locales/en.js": () => import("./en-IRJ2WN5T.js"),
-  "./locales/fr.js": () => import("./fr-GK3HQYVB.js"),
-  "./locales/ja.js": () => import("./ja-3FA46IKD.js"),
-  "./locales/pt.js": () => import("./pt-3AOBKPIJ.js"),
-  "./locales/ru.js": () => import("./ru-VJRAMC4W.js"),
-  "./locales/zh-TW.js": () => import("./zh-TW-Y4RGI3P7.js"),
-  "./locales/zh.js": () => import("./zh-ARWDLDLR.js")
+  "./locales/ca.js": () => import("./ca-ZLKAB4K3.js"),
+  "./locales/de.js": () => import("./de-LIW4XVLN.js"),
+  "./locales/en.js": () => import("./en-SY5GTIGX.js"),
+  "./locales/fr.js": () => import("./fr-RQFO7U4P.js"),
+  "./locales/ja.js": () => import("./ja-KOZKHJHZ.js"),
+  "./locales/pt.js": () => import("./pt-U6AOCTMF.js"),
+  "./locales/ru.js": () => import("./ru-CMX4UMYP.js"),
+  "./locales/zh-TW.js": () => import("./zh-TW-KI66MHQY.js"),
+  "./locales/zh.js": () => import("./zh-AGL2FVBI.js")
 });
 
 // packages/cli/src/i18n/index.ts

package/chunks/{chunk-2VSTGY6M.js → chunk-PJRW65JO.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   MAX_TERMINAL_IMAGE_BYTES
-} from "./chunk-IC4Z6LX6.js";
+} from "./chunk-PYQADEFD.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-33ACCIIY.js → chunk-PLFATELK.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-M6HMMKVG.js";
 import {
   isInternalPromptId
-} from "./chunk-2U3WZGZG.js";
+} from "./chunk-3PY4LPJF.js";
 import {
   createDebugLogger
 } from "./chunk-OIVKILPI.js";

package/chunks/{chunk-IC4Z6LX6.js → chunk-PYQADEFD.js}

@@ -15686,6 +15686,10 @@ var ToolNamesMigration = {
   task: ToolNames.AGENT
   // Legacy name from agent tool (renamed from task)
 };
+function canonicalToolName(toolName) {
+  return ToolNamesMigration[toolName] ?? toolName;
+}
+__name(canonicalToolName, "canonicalToolName");
 var ToolDisplayNamesMigration = {
   SearchFiles: ToolDisplayNames.GREP,
   // Old display name for Grep
@@ -15718,6 +15722,7 @@ export {
   ToolNames,
   ToolDisplayNames,
   ToolNamesMigration,
+  canonicalToolName,
   ToolDisplayNamesMigration
 };
 /**

package/chunks/{chunk-MAJS7AT4.js → chunk-QGHSP65Z.js}

@@ -16,7 +16,7 @@ import {
   MODIFIER_SHIFT_BIT,
   MODIFIER_SUPER_BIT,
   clipboardHasImage
-} from "./chunk-YHEEE624.js";
+} from "./chunk-EN2TKTFH.js";
 import {
   noteInteraction
 } from "./chunk-KW7NOTN6.js";
@@ -33,7 +33,7 @@ import {
 import {
   KittySequenceOverflowEvent,
   logKittySequenceOverflow
-} from "./chunk-2U3WZGZG.js";
+} from "./chunk-3PY4LPJF.js";
 import {
   createDebugLogger
 } from "./chunk-OIVKILPI.js";

package/chunks/{chunk-OHJLEW5J.js → chunk-QQWD7LZV.js}

@@ -5,21 +5,21 @@ import {
 } from "./chunk-57OAHC2Y.js";
 import {
   loadSettings
-} from "./chunk-PQBHU2IA.js";
+} from "./chunk-OHKJVAKG.js";
 import {
   getCurrentLanguage,
   t
-} from "./chunk-DBOFL3LQ.js";
+} from "./chunk-PG62DFWD.js";
 import {
   isWorkspaceTrusted
-} from "./chunk-6XU3PH66.js";
+} from "./chunk-HA3SAB64.js";
 import {
   ExtensionManager,
   getExtensionDescription,
   getExtensionDisplayName,
   redactUrlCredentials,
   require_prompts
-} from "./chunk-Y7E5LNLO.js";
+} from "./chunk-GXSNGY5M.js";
 import {
   stripAnsi
 } from "./chunk-TWPJO254.js";

package/chunks/{chunk-ZXU5UHMI.js → chunk-QXVSWG66.js}

@@ -2,11 +2,11 @@
 "use strict";
 import {
   resolveChannelCwd
-} from "./chunk-VWOVHOTT.js";
+} from "./chunk-KJZ26VBX.js";
 import {
   getPlugin,
   supportedTypes
-} from "./chunk-IUFV6FYU.js";
+} from "./chunk-NGYI5EF5.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-E33LOKRA.js → chunk-RPWVIXDB.js}

@@ -190,6 +190,21 @@ var ProcessRegistry = class {
   get activeProcessCount() {
     return this.children.size;
   }
+  /**
+   * Children this registry has committed to: attached ones plus reservations
+   * that have not attached yet. Larger than {@link activeProcessCount}, and
+   * the right figure for admission — `reserve()` inserts its token
+   * synchronously before `spawn()`, so two racing spawns each see the other
+   * here, while neither is visible in `activeProcessCount` until its child is
+   * attached.
+   *
+   * A child leaves this count when it *exits*, not when `terminate()` starts,
+   * so a channel swap is counted twice while the old process is still winding
+   * down. That is deliberate: its memory is still resident.
+   */
+  get committedProcessCount() {
+    return this.children.size + this.reservations.size;
+  }
 };
 var TrackedChild = class {
   constructor(child, onExit) {
@@ -332,13 +347,15 @@ function createSpawnChannelFactory(options = {}) {
       childEnvOverrides
     );
     childEnv["QWEN_CODE_NO_RELAUNCH"] = "true";
-    const memoryArgs = getAcpMemoryArgs();
+    childEnv["QWEN_CODE_SERVE"] = "1";
     const execArgs = process.execArgv.filter(
       (a) => !/^--inspect(-brk)?($|=)/.test(a)
     );
     const reservation = processRegistry.reserve();
     let child;
     try {
+      options.childHeapPolicy?.decide(processRegistry.committedProcessCount);
+      const memoryArgs = getAcpMemoryArgs();
       child = spawn(
         process.execPath,
         [

package/chunks/{chunk-TYKC75AX.js → chunk-S3Y3GBFD.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-NLREQJFK.js";
 import {
   formatMemoryUsage
-} from "./chunk-Y7E5LNLO.js";
+} from "./chunk-GXSNGY5M.js";
 import {
   detectRuntime,
   redactProxyCredentials

package/chunks/{chunk-7UFKAV7Y.js → chunk-S6HYI3MF.js}

@@ -2,10 +2,10 @@
 "use strict";
 import {
   MAX_INLINE_IMAGE_ENCODED_LENGTH
-} from "./chunk-2VSTGY6M.js";
+} from "./chunk-PJRW65JO.js";
 import {
   MAX_TERMINAL_IMAGE_BYTES
-} from "./chunk-IC4Z6LX6.js";
+} from "./chunk-PYQADEFD.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";