@qwen-code/qwen-code 0.21.0 → 0.21.1-nightly.20260731.702932cc7

package/chunks/{chunk-ACY3A37B.js → chunk-25VHI5T7.js}

@@ -2,20 +2,23 @@
 "use strict";
 import {
   mapSkillConfigToStatus
-} from "./chunk-2W3OOD4W.js";
+} from "./chunk-L55JWS76.js";
 import {
   STATUS_SCHEMA_VERSION
-} from "./chunk-VIA5XA4U.js";
+} from "./chunk-A5UODYG3.js";
+import {
+  resolveSkillSettings
+} from "./chunk-Z4X5MTRT.js";
 import {
   loadSettings
-} from "./chunk-TEHGS6UP.js";
+} from "./chunk-A5T5W7PR.js";
 import {
   writeStderrLine
 } from "./chunk-OWAK7LMW.js";
 import {
   SkillManager,
   isSafeModeEnv
-} from "./chunk-PHOF65IG.js";
+} from "./chunk-FRXG4ARO.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -25,17 +28,18 @@ import {
 
 // packages/cli/src/serve/workspace-skills-status.ts
 init_esbuild_shims();
-function createWorkspaceSkillsStatusProvider() {
+function createWorkspaceSkillsStatusProvider(options = {}) {
   const managers = /* @__PURE__ */ new Map();
   const provider = /* @__PURE__ */ __name((workspaceCwd) => buildWorkspaceSkillsStatus(
     workspaceCwd,
-    managers
+    managers,
+    options.workspaceTrusted ?? true
   ), "provider");
   provider.invalidate = (workspaceCwd) => managers.delete(workspaceCwd);
   return provider;
 }
 __name(createWorkspaceSkillsStatusProvider, "createWorkspaceSkillsStatusProvider");
-async function buildWorkspaceSkillsStatus(workspaceCwd, managers) {
+async function buildWorkspaceSkillsStatus(workspaceCwd, managers, workspaceTrusted) {
   try {
     let skillManager = managers.get(workspaceCwd);
     if (!skillManager) {
@@ -43,7 +47,7 @@ async function buildWorkspaceSkillsStatus(workspaceCwd, managers) {
         // Honor the safe-mode env the same way `Config` does when no explicit
         // flag is passed, so an operator running in safe mode gets the same
         // bundled-only listing the child would produce.
-        isSafeMode: /* @__PURE__ */ __name(() => isSafeModeEnv(), "isSafeMode"),
+        isSafeMode: /* @__PURE__ */ __name(() => !workspaceTrusted || isSafeModeEnv(), "isSafeMode"),
         // Bare mode is the interactive `--bare` CLI flag; the daemon never runs
         // bare, so it is always off here.
         getBareMode: /* @__PURE__ */ __name(() => false, "getBareMode"),
@@ -55,13 +59,22 @@ async function buildWorkspaceSkillsStatus(workspaceCwd, managers) {
       skillManager = new SkillManager(shim);
       managers.set(workspaceCwd, skillManager);
     }
-    const disabled = readDisabledSkillNames(workspaceCwd);
+    const disablements = resolveSkillSettings(
+      loadSettings(workspaceCwd, {
+        consumeCorruptionEnvVars: false,
+        skipLoadEnvironment: !workspaceTrusted,
+        skipWorkspaceSettings: !workspaceTrusted,
+        workspaceTrusted
+      })
+    ).disablements;
     const skills = await skillManager.listSkills();
     return {
       v: STATUS_SCHEMA_VERSION,
       workspaceCwd,
       initialized: true,
-      skills: skills.map((skill) => mapSkillConfigToStatus(skill, disabled))
+      skills: skills.map(
+        (skill) => mapSkillConfigToStatus(skill, disablements)
+      )
     };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -84,14 +97,6 @@ async function buildWorkspaceSkillsStatus(workspaceCwd, managers) {
   }
 }
 __name(buildWorkspaceSkillsStatus, "buildWorkspaceSkillsStatus");
-function readDisabledSkillNames(workspaceCwd) {
-  const raw = loadSettings(workspaceCwd, false).merged.skills?.disabled;
-  if (!Array.isArray(raw)) return /* @__PURE__ */ new Set();
-  return new Set(
-    raw.filter((name) => typeof name === "string").map((name) => name.trim().toLowerCase()).filter(Boolean)
-  );
-}
-__name(readDisabledSkillNames, "readDisabledSkillNames");
 
 export {
   createWorkspaceSkillsStatusProvider

package/chunks/{chunk-MZAXJAUM.js → chunk-26JK4RPD.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   AuthType
-} from "./chunk-IKCX4CCL.js";
+} from "./chunk-DKPJUF5F.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-6GMVPFB2.js → chunk-2IIJTXYF.js}

@@ -14440,6 +14440,20 @@ var cleanupYogaNode = /* @__PURE__ */ __name((node) => {
   node?.unsetMeasureFunc();
   node?.freeRecursive();
 }, "cleanupYogaNode");
+var clearStaticNodeIfContained = /* @__PURE__ */ __name((removeNode) => {
+  const staticNode = currentRootNode?.staticNode;
+  if (!staticNode) {
+    return;
+  }
+  let current = staticNode;
+  while (current) {
+    if (current === removeNode) {
+      currentRootNode.staticNode = void 0;
+      return;
+    }
+    current = current.parentNode;
+  }
+}, "clearStaticNodeIfContained");
 var currentUpdatePriority = import_constants.NoEventPriority;
 var currentRootNode;
 async function loadPackageJson() {
@@ -14594,11 +14608,10 @@ var reconciler_default = (0, import_react_reconciler.default)({
   appendChildToContainer: appendChildNode,
   insertInContainerBefore: insertBeforeNode,
   removeChildFromContainer(node, removeNode) {
+    clearStaticNodeIfContained(removeNode);
     removeChildNode(node, removeNode);
     cleanupYogaNode(removeNode.yogaNode);
-    if (removeNode.internal_static && currentRootNode?.staticNode === removeNode) {
-      currentRootNode.staticNode = void 0;
-    }
+    removeNode.yogaNode = void 0;
   },
   commitUpdate(node, _type, oldProps, newProps) {
     if (currentRootNode && node.internal_static) {
@@ -14634,11 +14647,10 @@ var reconciler_default = (0, import_react_reconciler.default)({
     setTextNodeValue(node, newText);
   },
   removeChild(node, removeNode) {
+    clearStaticNodeIfContained(removeNode);
     removeChildNode(node, removeNode);
     cleanupYogaNode(removeNode.yogaNode);
-    if (removeNode.internal_static && currentRootNode?.staticNode === removeNode) {
-      currentRootNode.staticNode = void 0;
-    }
+    removeNode.yogaNode = void 0;
   },
   setCurrentUpdatePriority(newPriority) {
     currentUpdatePriority = newPriority;
@@ -16452,11 +16464,11 @@ init_esbuild_shims();
 var showCursorEscape = "\x1B[?25h";
 var hideCursorEscape = "\x1B[?25l";
 var cursorPositionChanged = /* @__PURE__ */ __name((a, b) => a?.x !== b?.x || a?.y !== b?.y, "cursorPositionChanged");
-var buildCursorSuffix = /* @__PURE__ */ __name((visibleLineCount2, cursorPosition) => {
+var buildCursorSuffix = /* @__PURE__ */ __name((visibleLineCount2, cursorPosition, hasTrailingNewline = true) => {
   if (!cursorPosition) {
     return "";
   }
-  const moveUp = visibleLineCount2 - cursorPosition.y;
+  const moveUp = (hasTrailingNewline ? visibleLineCount2 : visibleLineCount2 - 1) - cursorPosition.y;
   return (moveUp > 0 ? base_exports.cursorUp(moveUp) : "") + base_exports.cursorTo(cursorPosition.x) + showCursorEscape;
 }, "buildCursorSuffix");
 var buildReturnToBottom = /* @__PURE__ */ __name((previousLineCount, previousCursorPosition) => {
@@ -16469,7 +16481,7 @@ var buildReturnToBottom = /* @__PURE__ */ __name((previousLineCount, previousCur
 var buildCursorOnlySequence = /* @__PURE__ */ __name((input) => {
   const hidePrefix = input.cursorWasShown ? hideCursorEscape : "";
   const returnToBottom = buildReturnToBottom(input.previousLineCount, input.previousCursorPosition);
-  const cursorSuffix = buildCursorSuffix(input.visibleLineCount, input.cursorPosition);
+  const cursorSuffix = buildCursorSuffix(input.visibleLineCount, input.cursorPosition, input.hasTrailingNewline);
   return hidePrefix + returnToBottom + cursorSuffix;
 }, "buildCursorOnlySequence");
 var buildReturnToBottomPrefix = /* @__PURE__ */ __name((cursorWasShown, previousLineCount, previousCursorPosition) => {
@@ -16538,6 +16550,7 @@ var createStandard = /* @__PURE__ */ __name((stream, { showCursor = false } = {}
   let cursorDirty = false;
   let previousCursorPosition;
   let cursorWasShown = false;
+  let previousHasTrailingNewline = true;
   const getActiveCursor = /* @__PURE__ */ __name(() => cursorDirty ? cursorPosition : void 0, "getActiveCursor");
   const hasChanges = /* @__PURE__ */ __name((str, activeCursor) => {
     const cursorChanged = cursorPositionChanged(activeCursor, previousCursorPosition);
@@ -16556,20 +16569,23 @@ var createStandard = /* @__PURE__ */ __name((stream, { showCursor = false } = {}
     }
     const lines = str.split("\n");
     const visibleCount = visibleLineCount(lines, str);
-    const cursorSuffix = buildCursorSuffix(visibleCount, activeCursor);
+    const hasTrailingNewline = str.endsWith("\n");
+    const cursorSuffix = buildCursorSuffix(visibleCount, activeCursor, hasTrailingNewline);
     if (str === previousOutput && cursorChanged) {
       stream.write(buildCursorOnlySequence({
         cursorWasShown,
         previousLineCount,
         previousCursorPosition,
         visibleLineCount: visibleCount,
-        cursorPosition: activeCursor
+        cursorPosition: activeCursor,
+        hasTrailingNewline: previousHasTrailingNewline
       }));
     } else {
       previousOutput = str;
       const returnPrefix = buildReturnToBottomPrefix(cursorWasShown, previousLineCount, previousCursorPosition);
       stream.write(returnPrefix + base_exports.eraseLines(previousLineCount) + str + cursorSuffix);
       previousLineCount = lines.length;
+      previousHasTrailingNewline = hasTrailingNewline;
     }
     previousCursorPosition = activeCursor ? { ...activeCursor } : void 0;
     cursorWasShown = activeCursor !== void 0;
@@ -16582,12 +16598,14 @@ var createStandard = /* @__PURE__ */ __name((stream, { showCursor = false } = {}
     previousLineCount = 0;
     previousCursorPosition = void 0;
     cursorWasShown = false;
+    previousHasTrailingNewline = true;
   };
   render2.done = () => {
     previousOutput = "";
     previousLineCount = 0;
     previousCursorPosition = void 0;
     cursorWasShown = false;
+    previousHasTrailingNewline = true;
     if (!showCursor) {
       cli_cursor_default.show(stream);
       hasHiddenCursor = false;
@@ -16598,6 +16616,7 @@ var createStandard = /* @__PURE__ */ __name((stream, { showCursor = false } = {}
     previousLineCount = 0;
     previousCursorPosition = void 0;
     cursorWasShown = false;
+    previousHasTrailingNewline = true;
   };
   render2.sync = (str) => {
     const activeCursor = cursorDirty ? cursorPosition : void 0;
@@ -16605,11 +16624,12 @@ var createStandard = /* @__PURE__ */ __name((stream, { showCursor = false } = {}
     const lines = str.split("\n");
     previousOutput = str;
     previousLineCount = lines.length;
+    previousHasTrailingNewline = str.endsWith("\n");
     if (!activeCursor && cursorWasShown) {
       stream.write(hideCursorEscape);
     }
     if (activeCursor) {
-      stream.write(buildCursorSuffix(visibleLineCount(lines, str), activeCursor));
+      stream.write(buildCursorSuffix(visibleLineCount(lines, str), activeCursor, previousHasTrailingNewline));
     }
     previousCursorPosition = activeCursor ? { ...activeCursor } : void 0;
     cursorWasShown = activeCursor !== void 0;
@@ -16630,6 +16650,7 @@ var createIncremental = /* @__PURE__ */ __name((stream, { showCursor = false } =
   let cursorDirty = false;
   let previousCursorPosition;
   let cursorWasShown = false;
+  let previousHasTrailingNewline = true;
   const getActiveCursor = /* @__PURE__ */ __name(() => cursorDirty ? cursorPosition : void 0, "getActiveCursor");
   const hasChanges = /* @__PURE__ */ __name((str, activeCursor) => {
     const cursorChanged = cursorPositionChanged(activeCursor, previousCursorPosition);
@@ -16655,7 +16676,8 @@ var createIncremental = /* @__PURE__ */ __name((stream, { showCursor = false } =
         previousLineCount: previousLines.length,
         previousCursorPosition,
         visibleLineCount: visibleCount,
-        cursorPosition: activeCursor
+        cursorPosition: activeCursor,
+        hasTrailingNewline: previousHasTrailingNewline
       }));
       previousCursorPosition = activeCursor ? { ...activeCursor } : void 0;
       cursorWasShown = activeCursor !== void 0;
@@ -16663,12 +16685,13 @@ var createIncremental = /* @__PURE__ */ __name((stream, { showCursor = false } =
     }
     const returnPrefix = buildReturnToBottomPrefix(cursorWasShown, previousLines.length, previousCursorPosition);
     if (str === "\n" || previousOutput.length === 0) {
-      const cursorSuffix2 = buildCursorSuffix(visibleCount, activeCursor);
+      const cursorSuffix2 = buildCursorSuffix(visibleCount, activeCursor, str.endsWith("\n"));
       stream.write(returnPrefix + base_exports.eraseLines(previousLines.length) + str + cursorSuffix2);
       cursorWasShown = activeCursor !== void 0;
       previousCursorPosition = activeCursor ? { ...activeCursor } : void 0;
       previousOutput = str;
       previousLines = nextLines;
+      previousHasTrailingNewline = str.endsWith("\n");
       return true;
     }
     const hasTrailingNewline = str.endsWith("\n");
@@ -16693,13 +16716,14 @@ var createIncremental = /* @__PURE__ */ __name((stream, { showCursor = false } =
       // has no trailing newline (fullscreen mode).
       (isLastLine && !hasTrailingNewline ? "" : "\n"));
     }
-    const cursorSuffix = buildCursorSuffix(visibleCount, activeCursor);
+    const cursorSuffix = buildCursorSuffix(visibleCount, activeCursor, hasTrailingNewline);
     buffer.push(cursorSuffix);
     stream.write(buffer.join(""));
     cursorWasShown = activeCursor !== void 0;
     previousCursorPosition = activeCursor ? { ...activeCursor } : void 0;
     previousOutput = str;
     previousLines = nextLines;
+    previousHasTrailingNewline = hasTrailingNewline;
     return true;
   }, "render");
   render2.clear = () => {
@@ -16709,12 +16733,14 @@ var createIncremental = /* @__PURE__ */ __name((stream, { showCursor = false } =
     previousLines = [];
     previousCursorPosition = void 0;
     cursorWasShown = false;
+    previousHasTrailingNewline = true;
   };
   render2.done = () => {
     previousOutput = "";
     previousLines = [];
     previousCursorPosition = void 0;
     cursorWasShown = false;
+    previousHasTrailingNewline = true;
     if (!showCursor) {
       cli_cursor_default.show(stream);
       hasHiddenCursor = false;
@@ -16725,6 +16751,7 @@ var createIncremental = /* @__PURE__ */ __name((stream, { showCursor = false } =
     previousLines = [];
     previousCursorPosition = void 0;
     cursorWasShown = false;
+    previousHasTrailingNewline = true;
   };
   render2.sync = (str) => {
     const activeCursor = cursorDirty ? cursorPosition : void 0;
@@ -16732,11 +16759,12 @@ var createIncremental = /* @__PURE__ */ __name((stream, { showCursor = false } =
     const lines = str.split("\n");
     previousOutput = str;
     previousLines = lines;
+    previousHasTrailingNewline = str.endsWith("\n");
     if (!activeCursor && cursorWasShown) {
       stream.write(hideCursorEscape);
     }
     if (activeCursor) {
-      stream.write(buildCursorSuffix(visibleLineCount(lines, str), activeCursor));
+      stream.write(buildCursorSuffix(visibleLineCount(lines, str), activeCursor, previousHasTrailingNewline));
     }
     previousCursorPosition = activeCursor ? { ...activeCursor } : void 0;
     cursorWasShown = activeCursor !== void 0;
@@ -18485,6 +18513,7 @@ var Ink = class {
     return this.nextRenderCommit.promise;
   }
   renderInteractiveFrame(output, outputHeight, staticOutput) {
+    this.log.setCursorPosition(this.cursorPosition);
     const hasStaticOutput = staticOutput !== "";
     const isTty = this.options.stdout.isTTY;
     const viewportRows = isTty ? getWindowSize(this.options.stdout).rows : 24;

package/chunks/{chunk-BPJSQIJX.js → chunk-2J3OJGTL.js}

@@ -83,8 +83,6 @@ var InvalidStreamError = class extends Error {
 
 export {
   createOpenAIReasoningThoughtPart,
-  isOpenAIReasoningThoughtPart,
-  parseThought,
   getThoughtSummary,
   InvalidStreamError
 };

package/chunks/{chunk-2X55UKQE.js → chunk-2JZR3B4A.js}

@@ -2,16 +2,16 @@
 "use strict";
 import {
   useKeypress
-} from "./chunk-LQIW3YFY.js";
+} from "./chunk-YJFPRUWX.js";
 import {
   require_react
 } from "./chunk-5QWWOFGG.js";
 import {
   t
-} from "./chunk-LKEJ26GS.js";
+} from "./chunk-B3TA3IF5.js";
 import {
   APPROVAL_MODES
-} from "./chunk-L26JL52R.js";
+} from "./chunk-CBBP4BMC.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-7JURR4JT.js → chunk-2OQUICDM.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   MissingCliEntryError
-} from "./chunk-VIA5XA4U.js";
+} from "./chunk-A5UODYG3.js";
 import {
   redactLogCredentials
 } from "./chunk-M5GB774H.js";
@@ -125,6 +125,144 @@ function callHook(hook, value) {
 }
 __name(callHook, "callHook");
 
+// packages/acp-bridge/src/process-registry.ts
+init_esbuild_shims();
+var TERM_GRACE_MS = 5e3;
+var EXIT_DEADLINE_MS = 1e4;
+var ProcessRegistry = class {
+  static {
+    __name(this, "ProcessRegistry");
+  }
+  reservations = /* @__PURE__ */ new Set();
+  children = /* @__PURE__ */ new Set();
+  draining = false;
+  shutdownPromise;
+  reserve() {
+    if (this.draining) {
+      throw new Error("ACP process registry is draining");
+    }
+    const token = Symbol("acp-child");
+    this.reservations.add(token);
+    let settled = false;
+    return {
+      attach: /* @__PURE__ */ __name((child) => {
+        if (settled || !this.reservations.delete(token)) {
+          throw new Error("ACP process reservation is no longer active");
+        }
+        settled = true;
+        const tracked = new TrackedChild(child, () => {
+          this.children.delete(tracked);
+        });
+        this.children.add(tracked);
+        if (this.draining) void tracked.terminate().catch(() => {
+        });
+        return tracked;
+      }, "attach"),
+      cancel: /* @__PURE__ */ __name(() => {
+        if (settled) return;
+        settled = true;
+        this.reservations.delete(token);
+      }, "cancel")
+    };
+  }
+  shutdown() {
+    if (this.shutdownPromise) return this.shutdownPromise;
+    this.draining = true;
+    this.shutdownPromise = Promise.allSettled(
+      [...this.children].map((child) => child.terminate())
+    ).then((results) => {
+      const failures = results.flatMap(
+        (result) => result.status === "rejected" ? [result.reason] : []
+      );
+      if (failures.length > 0) {
+        throw new AggregateError(failures, "ACP child process shutdown failed");
+      }
+    });
+    return this.shutdownPromise;
+  }
+  killAllSync() {
+    this.draining = true;
+    for (const child of this.children) child.killSync();
+  }
+  get activeProcessCount() {
+    return this.children.size;
+  }
+};
+var TrackedChild = class {
+  constructor(child, onExit) {
+    this.child = child;
+    this.onExit = onExit;
+    this.exited = new Promise((resolve) => {
+      const finish = /* @__PURE__ */ __name((info) => {
+        if (this.exitedSettled) return;
+        this.exitedSettled = true;
+        this.onExit();
+        resolve(info);
+      }, "finish");
+      child.once("exit", (exitCode, signalCode) => {
+        finish({ exitCode, signalCode });
+      });
+      child.once("spawn", () => {
+        this.spawnConfirmed = true;
+      });
+      child.once("error", () => {
+        if (!this.spawnConfirmed) finish(void 0);
+      });
+    });
+  }
+  static {
+    __name(this, "TrackedChild");
+  }
+  exited;
+  exitedSettled = false;
+  spawnConfirmed = false;
+  terminatePromise;
+  terminate() {
+    this.terminatePromise ??= this.terminateOnce();
+    return this.terminatePromise;
+  }
+  killSync() {
+    if (this.exitedSettled) return;
+    try {
+      this.child.kill("SIGKILL");
+    } catch {
+    }
+  }
+  async terminateOnce() {
+    if (this.exitedSettled) return;
+    try {
+      this.child.kill("SIGTERM");
+    } catch {
+      if (this.exitedSettled) return;
+    }
+    let hardKillTimer;
+    let deadlineTimer;
+    const deadline = new Promise((_, reject) => {
+      hardKillTimer = setTimeout(() => this.killSync(), TERM_GRACE_MS);
+      hardKillTimer.unref();
+      deadlineTimer = setTimeout(() => {
+        reject(
+          new Error(
+            `ACP child pid=${this.child.pid ?? "unknown"} did not exit within ${EXIT_DEADLINE_MS}ms`
+          )
+        );
+      }, EXIT_DEADLINE_MS);
+      deadlineTimer.unref();
+    });
+    try {
+      const exitInfo = await Promise.race([this.exited, deadline]);
+      if (exitInfo && (exitInfo.exitCode !== 0 || exitInfo.signalCode !== null)) {
+        throw new Error(
+          `ACP child pid=${this.child.pid ?? "unknown"} exited uncleanly during shutdown (code=${exitInfo.exitCode ?? "none"}, signal=${exitInfo.signalCode ?? "none"})`
+        );
+      }
+    } finally {
+      if (hardKillTimer) clearTimeout(hardKillTimer);
+      if (deadlineTimer) clearTimeout(deadlineTimer);
+    }
+  }
+};
+
 // packages/acp-bridge/src/spawnChannel.ts
 var cachedMemoryArgs;
 function getAcpMemoryArgs() {
@@ -178,6 +316,7 @@ function createStderrForwarder(opts) {
 }
 __name(createStderrForwarder, "createStderrForwarder");
 function createSpawnChannelFactory(options = {}) {
+  const processRegistry = options.processRegistry ?? new ProcessRegistry();
   return async (workspaceCwd, childEnvOverrides) => {
     const sourceEnv = options.sourceEnv ?? process.env;
     const cliEntry = sourceEnv["QWEN_CLI_ENTRY"] || process.argv[1];
@@ -194,21 +333,29 @@ function createSpawnChannelFactory(options = {}) {
     const execArgs = process.execArgv.filter(
       (a) => !/^--inspect(-brk)?($|=)/.test(a)
     );
-    const child = spawn(
-      process.execPath,
-      [
-        ...execArgs,
-        ...memoryArgs,
-        cliEntry,
-        "--acp",
-        ...options.extraArgs ?? []
-      ],
-      {
-        cwd: workspaceCwd,
-        stdio: ["pipe", "pipe", "pipe"],
-        env: childEnv
-      }
-    );
+    const reservation = processRegistry.reserve();
+    let child;
+    try {
+      child = spawn(
+        process.execPath,
+        [
+          ...execArgs,
+          ...memoryArgs,
+          cliEntry,
+          "--acp",
+          ...options.extraArgs ?? []
+        ],
+        {
+          cwd: workspaceCwd,
+          stdio: ["pipe", "pipe", "pipe"],
+          env: childEnv
+        }
+      );
+    } catch (error) {
+      reservation.cancel();
+      throw error;
+    }
+    const trackedChild = reservation.attach(child);
     if (child.stderr) {
       const prefix = `[serve pid=${child.pid} cwd=${workspaceCwd}] `;
       const forwarder = createStderrForwarder({
@@ -221,21 +368,8 @@ function createSpawnChannelFactory(options = {}) {
       child.stderr.on("error", () => {
       });
     }
-    const exited = new Promise((resolve) => {
-      let resolved = false;
-      const finish = /* @__PURE__ */ __name((info) => {
-        if (resolved) return;
-        resolved = true;
-        resolve(info);
-      }, "finish");
-      child.once(
-        "exit",
-        (code, signal) => finish({ exitCode: code, signalCode: signal })
-      );
-      child.once("error", () => finish(void 0));
-    });
     if (!child.stdin || !child.stdout) {
-      child.kill("SIGKILL");
+      trackedChild.killSync();
       throw new Error(
         "Spawned ACP child has no stdin/stdout \u2014 cannot establish NDJSON channel."
       );
@@ -245,22 +379,14 @@ function createSpawnChannelFactory(options = {}) {
     const stream = ndJsonStream(writable, readable, options.pipeHooks);
     return {
       stream,
-      kill: /* @__PURE__ */ __name(() => killChild(child), "kill"),
-      killSync: /* @__PURE__ */ __name(() => {
-        if (child.exitCode === null && child.signalCode === null) {
-          try {
-            child.kill("SIGKILL");
-          } catch {
-          }
-        }
-      }, "killSync"),
-      exited
+      kill: /* @__PURE__ */ __name(() => trackedChild.terminate(), "kill"),
+      killSync: /* @__PURE__ */ __name(() => trackedChild.killSync(), "killSync"),
+      exited: trackedChild.exited
     };
   };
 }
 __name(createSpawnChannelFactory, "createSpawnChannelFactory");
 var defaultSpawnChannelFactory = createSpawnChannelFactory();
-var KILL_HARD_DEADLINE_MS = 1e4;
 var SCRUBBED_CHILD_ENV_KEYS = /* @__PURE__ */ new Set([
   "QWEN_SERVER_TOKEN",
   "QWEN_CODE_SIMPLE"
@@ -283,46 +409,6 @@ function scrubChildEnv(source, scrubbed, overrides) {
   return childEnv;
 }
 __name(scrubChildEnv, "scrubChildEnv");
-function killChild(child) {
-  return new Promise((resolve) => {
-    if (child.exitCode !== null || child.signalCode !== null) {
-      resolve();
-      return;
-    }
-    let resolved = false;
-    const finish = /* @__PURE__ */ __name(() => {
-      if (resolved) return;
-      resolved = true;
-      child.removeListener("exit", finish);
-      resolve();
-    }, "finish");
-    child.once("exit", finish);
-    try {
-      child.kill("SIGTERM");
-    } catch {
-      finish();
-      return;
-    }
-    setTimeout(() => {
-      if (!resolved && child.exitCode === null && child.signalCode === null) {
-        try {
-          child.kill("SIGKILL");
-        } catch {
-        }
-      }
-    }, 5e3).unref();
-    setTimeout(() => {
-      if (!resolved) {
-        process.stderr.write(
-          `qwen serve: killChild hard deadline (${KILL_HARD_DEADLINE_MS}ms) reached; child pid=${child.pid} still alive (uninterruptible sleep?) \u2014 abandoning. Operator should check for zombie qwen --acp processes holding workspace resources.
-`
-        );
-        finish();
-      }
-    }, KILL_HARD_DEADLINE_MS).unref();
-  });
-}
-__name(killChild, "killChild");
 
 export {
   ndJsonStream,