@qwen-code/qwen-code 0.24.2 → 0.24.3

package/chunks/chunk-2SENA3WV.js

@@ -0,0 +1,2808 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  isInternalSecretEnvVar,
+  sanitizeChildEnv
+} from "./chunk-ELYIK7SN.js";
+import {
+  stripAnsi
+} from "./chunk-TWPJO254.js";
+import {
+  promptIdContext
+} from "./chunk-O6GEWCJA.js";
+import {
+  formatMemoryUsage
+} from "./chunk-CHEIIBT3.js";
+import {
+  resolveBundleDir
+} from "./chunk-ACHCT36C.js";
+import {
+  getShellConfiguration
+} from "./chunk-I3K2QRZ5.js";
+import {
+  getCurrentAgentId
+} from "./chunk-6GI7NAZS.js";
+import {
+  getCachedEncodingForBuffer
+} from "./chunk-NXRQI7RF.js";
+import {
+  isBinary
+} from "./chunk-5R36APDE.js";
+import {
+  createDebugLogger,
+  formatTraceparent,
+  getSessionModel,
+  getSessionModelIdentity,
+  getSessionProjectDir,
+  getTraceContext,
+  isShellTracePropagationEnabled,
+  isSubpath,
+  realpathNearestExisting,
+  sessionIdContext
+} from "./chunk-GYAL5QAR.js";
+import {
+  getErrorMessage
+} from "./chunk-S34QJ6IR.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/sandbox/bwrap-execution.ts
+init_esbuild_shims();
+import { existsSync, mkdirSync, realpathSync, statSync as statSync2 } from "node:fs";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import os3 from "node:os";
+import path2 from "node:path";
+import { fileURLToPath } from "node:url";
+
+// packages/core/src/services/shellExecutionService.ts
+init_esbuild_shims();
+
+// packages/core/src/utils/getPty.ts
+init_esbuild_shims();
+var loadPty = /* @__PURE__ */ __name(async () => {
+  if ("bun" in process.versions) {
+    return {
+      impl: null,
+      loadError: "the PTY backend is disabled under the Bun runtime; use the Node runtime"
+    };
+  }
+  try {
+    const lydell = "@lydell/node-pty";
+    const module = await import(lydell);
+    return { impl: { module, name: "lydell-node-pty" }, loadError: null };
+  } catch (lydellError) {
+    try {
+      const nodePty = "node-pty";
+      const module = await import(nodePty);
+      return { impl: { module, name: "node-pty" }, loadError: null };
+    } catch (nodePtyError) {
+      return {
+        impl: null,
+        loadError: [lydellError, nodePtyError].map((error) => getErrorMessage(error)).join("; ")
+      };
+    }
+  }
+}, "loadPty");
+var getPty = /* @__PURE__ */ __name(async () => (await loadPty()).impl, "getPty");
+
+// packages/core/src/services/shellExecutionService.ts
+import { spawn as cpSpawn, spawnSync } from "node:child_process";
+import { TextDecoder } from "node:util";
+import os2 from "node:os";
+import path from "node:path";
+
+// packages/core/src/utils/load-xterm-headless.ts
+init_esbuild_shims();
+var xtermHeadlessModulePromise;
+function isXtermHeadlessModule(candidate) {
+  return candidate !== void 0 && "Terminal" in candidate && typeof candidate.Terminal === "function";
+}
+__name(isXtermHeadlessModule, "isXtermHeadlessModule");
+function loadXtermHeadless() {
+  xtermHeadlessModulePromise ??= import("./xterm-headless-OSLAQIKV.js").then((module) => {
+    const imported = module;
+    const candidate = isXtermHeadlessModule(imported) ? imported : "default" in imported ? imported.default : void 0;
+    if (!isXtermHeadlessModule(candidate)) {
+      throw new Error("@xterm/headless module does not match the expected API");
+    }
+    return candidate;
+  });
+  return xtermHeadlessModulePromise;
+}
+__name(loadXtermHeadless, "loadXtermHeadless");
+
+// packages/core/src/utils/terminalSerializer.ts
+init_esbuild_shims();
+var canMergeAnsiTokens = /* @__PURE__ */ __name((left, right) => left.bold === right.bold && left.italic === right.italic && left.underline === right.underline && left.dim === right.dim && left.inverse === right.inverse && left.fg === right.fg && left.bg === right.bg, "canMergeAnsiTokens");
+var appendAnsiLineTokens = /* @__PURE__ */ __name((target, source) => {
+  for (const token of source) {
+    const previous = target[target.length - 1];
+    if (previous && canMergeAnsiTokens(previous, token)) {
+      previous.text += token.text;
+    } else {
+      target.push({ ...token });
+    }
+  }
+}, "appendAnsiLineTokens");
+function serializeTerminalToText(terminal) {
+  const buffer = terminal.buffer.active;
+  const lines = [];
+  for (let i = 0; i < buffer.length; i++) {
+    const line = buffer.getLine(i);
+    const lineContent = line ? line.translateToString(true) : "";
+    if (line?.isWrapped && lines.length > 0) {
+      lines[lines.length - 1] += lineContent;
+      continue;
+    }
+    lines.push(lineContent);
+  }
+  return lines.join("\n").trimEnd();
+}
+__name(serializeTerminalToText, "serializeTerminalToText");
+var Cell = class {
+  static {
+    __name(this, "Cell");
+  }
+  cell;
+  x;
+  y;
+  cursorX;
+  cursorY;
+  attributes = 0;
+  fg = 0;
+  bg = 0;
+  fgColorMode = 0 /* DEFAULT */;
+  bgColorMode = 0 /* DEFAULT */;
+  constructor(cell, x, y, cursorX, cursorY) {
+    this.cell = cell;
+    this.x = x;
+    this.y = y;
+    this.cursorX = cursorX;
+    this.cursorY = cursorY;
+    if (!cell) {
+      return;
+    }
+    if (cell.isInverse()) {
+      this.attributes += 1 /* inverse */;
+    }
+    if (cell.isBold()) {
+      this.attributes += 2 /* bold */;
+    }
+    if (cell.isItalic()) {
+      this.attributes += 4 /* italic */;
+    }
+    if (cell.isUnderline()) {
+      this.attributes += 8 /* underline */;
+    }
+    if (cell.isDim()) {
+      this.attributes += 16 /* dim */;
+    }
+    if (cell.isFgRGB()) {
+      this.fgColorMode = 2 /* RGB */;
+    } else if (cell.isFgPalette()) {
+      this.fgColorMode = 1 /* PALETTE */;
+    } else {
+      this.fgColorMode = 0 /* DEFAULT */;
+    }
+    if (cell.isBgRGB()) {
+      this.bgColorMode = 2 /* RGB */;
+    } else if (cell.isBgPalette()) {
+      this.bgColorMode = 1 /* PALETTE */;
+    } else {
+      this.bgColorMode = 0 /* DEFAULT */;
+    }
+    if (this.fgColorMode === 0 /* DEFAULT */) {
+      this.fg = -1;
+    } else {
+      this.fg = cell.getFgColor();
+    }
+    if (this.bgColorMode === 0 /* DEFAULT */) {
+      this.bg = -1;
+    } else {
+      this.bg = cell.getBgColor();
+    }
+  }
+  isCursor() {
+    return this.x === this.cursorX && this.y === this.cursorY;
+  }
+  getChars() {
+    return this.cell?.getChars() || " ";
+  }
+  isAttribute(attribute) {
+    return (this.attributes & attribute) !== 0;
+  }
+  equals(other) {
+    return this.attributes === other.attributes && this.fg === other.fg && this.bg === other.bg && this.fgColorMode === other.fgColorMode && this.bgColorMode === other.bgColorMode && this.isCursor() === other.isCursor();
+  }
+};
+function serializeTerminalToObject(terminal, scrollOffset = 0, options = {}) {
+  const buffer = terminal.buffer.active;
+  const defaultFg = "";
+  const defaultBg = "";
+  const clampedOffset = Math.max(0, Math.min(scrollOffset, buffer.viewportY));
+  const startRow = buffer.viewportY - clampedOffset;
+  const cursorX = clampedOffset === 0 ? buffer.cursorX : -1;
+  const cursorY = clampedOffset === 0 ? buffer.cursorY : -1;
+  const result = [];
+  for (let y = 0; y < terminal.rows; y++) {
+    const line = buffer.getLine(startRow + y);
+    const currentLine = [];
+    if (!line) {
+      result.push(currentLine);
+      continue;
+    }
+    let lastCell = new Cell(null, -1, -1, cursorX, cursorY);
+    let currentText = "";
+    for (let x = 0; x < terminal.cols; x++) {
+      const cellData = line.getCell(x);
+      const cell = new Cell(cellData || null, x, y, cursorX, cursorY);
+      if (x > 0 && !cell.equals(lastCell)) {
+        if (currentText) {
+          const token = {
+            text: currentText,
+            bold: lastCell.isAttribute(2 /* bold */),
+            italic: lastCell.isAttribute(4 /* italic */),
+            underline: lastCell.isAttribute(8 /* underline */),
+            dim: lastCell.isAttribute(16 /* dim */),
+            inverse: lastCell.isAttribute(1 /* inverse */) || lastCell.isCursor(),
+            fg: convertColorToHex(lastCell.fg, lastCell.fgColorMode, defaultFg),
+            bg: convertColorToHex(lastCell.bg, lastCell.bgColorMode, defaultBg)
+          };
+          currentLine.push(token);
+        }
+        currentText = "";
+      }
+      currentText += cell.getChars();
+      lastCell = cell;
+    }
+    if (currentText) {
+      const token = {
+        text: currentText,
+        bold: lastCell.isAttribute(2 /* bold */),
+        italic: lastCell.isAttribute(4 /* italic */),
+        underline: lastCell.isAttribute(8 /* underline */),
+        dim: lastCell.isAttribute(16 /* dim */),
+        inverse: lastCell.isAttribute(1 /* inverse */) || lastCell.isCursor(),
+        fg: convertColorToHex(lastCell.fg, lastCell.fgColorMode, defaultFg),
+        bg: convertColorToHex(lastCell.bg, lastCell.bgColorMode, defaultBg)
+      };
+      currentLine.push(token);
+    }
+    if (options.unwrapWrappedLines && line.isWrapped && result.length > 0) {
+      appendAnsiLineTokens(result[result.length - 1], currentLine);
+    } else {
+      result.push(currentLine);
+    }
+  }
+  return result;
+}
+__name(serializeTerminalToObject, "serializeTerminalToObject");
+var ANSI_COLORS = [
+  "#000000",
+  "#800000",
+  "#008000",
+  "#808000",
+  "#000080",
+  "#800080",
+  "#008080",
+  "#c0c0c0",
+  "#808080",
+  "#ff0000",
+  "#00ff00",
+  "#ffff00",
+  "#0000ff",
+  "#ff00ff",
+  "#00ffff",
+  "#ffffff",
+  "#000000",
+  "#00005f",
+  "#000087",
+  "#0000af",
+  "#0000d7",
+  "#0000ff",
+  "#005f00",
+  "#005f5f",
+  "#005f87",
+  "#005faf",
+  "#005fd7",
+  "#005fff",
+  "#008700",
+  "#00875f",
+  "#008787",
+  "#0087af",
+  "#0087d7",
+  "#0087ff",
+  "#00af00",
+  "#00af5f",
+  "#00af87",
+  "#00afaf",
+  "#00afd7",
+  "#00afff",
+  "#00d700",
+  "#00d75f",
+  "#00d787",
+  "#00d7af",
+  "#00d7d7",
+  "#00d7ff",
+  "#00ff00",
+  "#00ff5f",
+  "#00ff87",
+  "#00ffaf",
+  "#00ffd7",
+  "#00ffff",
+  "#5f0000",
+  "#5f005f",
+  "#5f0087",
+  "#5f00af",
+  "#5f00d7",
+  "#5f00ff",
+  "#5f5f00",
+  "#5f5f5f",
+  "#5f5f87",
+  "#5f5faf",
+  "#5f5fd7",
+  "#5f5fff",
+  "#5f8700",
+  "#5f875f",
+  "#5f8787",
+  "#5f87af",
+  "#5f87d7",
+  "#5f87ff",
+  "#5faf00",
+  "#5faf5f",
+  "#5faf87",
+  "#5fafaf",
+  "#5fafd7",
+  "#5fafff",
+  "#5fd700",
+  "#5fd75f",
+  "#5fd787",
+  "#5fd7af",
+  "#5fd7d7",
+  "#5fd7ff",
+  "#5fff00",
+  "#5fff5f",
+  "#5fff87",
+  "#5fffaf",
+  "#5fffd7",
+  "#5fffff",
+  "#870000",
+  "#87005f",
+  "#870087",
+  "#8700af",
+  "#8700d7",
+  "#8700ff",
+  "#875f00",
+  "#875f5f",
+  "#875f87",
+  "#875faf",
+  "#875fd7",
+  "#875fff",
+  "#878700",
+  "#87875f",
+  "#878787",
+  "#8787af",
+  "#8787d7",
+  "#8787ff",
+  "#87af00",
+  "#87af5f",
+  "#87af87",
+  "#87afaf",
+  "#87afd7",
+  "#87afff",
+  "#87d700",
+  "#87d75f",
+  "#87d787",
+  "#87d7af",
+  "#87d7d7",
+  "#87d7ff",
+  "#87ff00",
+  "#87ff5f",
+  "#87ff87",
+  "#87ffaf",
+  "#87ffd7",
+  "#87ffff",
+  "#af0000",
+  "#af005f",
+  "#af0087",
+  "#af00af",
+  "#af00d7",
+  "#af00ff",
+  "#af5f00",
+  "#af5f5f",
+  "#af5f87",
+  "#af5faf",
+  "#af5fd7",
+  "#af5fff",
+  "#af8700",
+  "#af875f",
+  "#af8787",
+  "#af87af",
+  "#af87d7",
+  "#af87ff",
+  "#afaf00",
+  "#afaf5f",
+  "#afaf87",
+  "#afafaf",
+  "#afafd7",
+  "#afafff",
+  "#afd700",
+  "#afd75f",
+  "#afd787",
+  "#afd7af",
+  "#afd7d7",
+  "#afd7ff",
+  "#afff00",
+  "#afff5f",
+  "#afff87",
+  "#afffaf",
+  "#afffd7",
+  "#afffff",
+  "#d70000",
+  "#d7005f",
+  "#d70087",
+  "#d700af",
+  "#d700d7",
+  "#d700ff",
+  "#d75f00",
+  "#d75f5f",
+  "#d75f87",
+  "#d75faf",
+  "#d75fd7",
+  "#d75fff",
+  "#d78700",
+  "#d7875f",
+  "#d78787",
+  "#d787af",
+  "#d787d7",
+  "#d787ff",
+  "#d7af00",
+  "#d7af5f",
+  "#d7af87",
+  "#d7afaf",
+  "#d7afd7",
+  "#d7afff",
+  "#d7d700",
+  "#d7d75f",
+  "#d7d787",
+  "#d7d7af",
+  "#d7d7d7",
+  "#d7d7ff",
+  "#d7ff00",
+  "#d7ff5f",
+  "#d7ff87",
+  "#d7ffaf",
+  "#d7ffd7",
+  "#d7ffff",
+  "#ff0000",
+  "#ff005f",
+  "#ff0087",
+  "#ff00af",
+  "#ff00d7",
+  "#ff00ff",
+  "#ff5f00",
+  "#ff5f5f",
+  "#ff5f87",
+  "#ff5faf",
+  "#ff5fd7",
+  "#ff5fff",
+  "#ff8700",
+  "#ff875f",
+  "#ff8787",
+  "#ff87af",
+  "#ff87d7",
+  "#ff87ff",
+  "#ffaf00",
+  "#ffaf5f",
+  "#ffaf87",
+  "#ffafaf",
+  "#ffafd7",
+  "#ffafff",
+  "#ffd700",
+  "#ffd75f",
+  "#ffd787",
+  "#ffd7af",
+  "#ffd7d7",
+  "#ffd7ff",
+  "#ffff00",
+  "#ffff5f",
+  "#ffff87",
+  "#ffffaf",
+  "#ffffd7",
+  "#ffffff",
+  "#080808",
+  "#121212",
+  "#1c1c1c",
+  "#262626",
+  "#303030",
+  "#3a3a3a",
+  "#444444",
+  "#4e4e4e",
+  "#585858",
+  "#626262",
+  "#6c6c6c",
+  "#767676",
+  "#808080",
+  "#8a8a8a",
+  "#949494",
+  "#9e9e9e",
+  "#a8a8a8",
+  "#b2b2b2",
+  "#bcbcbc",
+  "#c6c6c6",
+  "#d0d0d0",
+  "#dadada",
+  "#e4e4e4",
+  "#eeeeee"
+];
+function convertColorToHex(color, colorMode, defaultColor) {
+  if (colorMode === 2 /* RGB */) {
+    const r = color >> 16 & 255;
+    const g = color >> 8 & 255;
+    const b = color & 255;
+    return `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${b.toString(16).padStart(2, "0")}`;
+  }
+  if (colorMode === 1 /* PALETTE */) {
+    return ANSI_COLORS[color] || defaultColor;
+  }
+  return defaultColor;
+}
+__name(convertColorToHex, "convertColorToHex");
+
+// packages/core/src/utils/windowsPath.ts
+init_esbuild_shims();
+var WINDOWS_PATH_DELIMITER = ";";
+var cachedWindowsPathFingerprint;
+var cachedMergedWindowsPath;
+function mergeWindowsPathValues(env, pathKeys) {
+  const mergedEntries = [];
+  const seenEntries = /* @__PURE__ */ new Set();
+  for (const key of pathKeys) {
+    const value = env[key];
+    if (value === void 0) {
+      continue;
+    }
+    for (const entry of value.split(WINDOWS_PATH_DELIMITER)) {
+      if (seenEntries.has(entry)) {
+        continue;
+      }
+      seenEntries.add(entry);
+      mergedEntries.push(entry);
+    }
+  }
+  return mergedEntries.length > 0 ? mergedEntries.join(WINDOWS_PATH_DELIMITER) : void 0;
+}
+__name(mergeWindowsPathValues, "mergeWindowsPathValues");
+function getWindowsPathFingerprint(env, pathKeys) {
+  return pathKeys.map((key) => `${key}=${env[key] ?? ""}`).join("\0");
+}
+__name(getWindowsPathFingerprint, "getWindowsPathFingerprint");
+function sortPathKeys(pathKeys) {
+  return [...pathKeys].sort((left, right) => {
+    if (left === "PATH") {
+      return -1;
+    }
+    if (right === "PATH") {
+      return 1;
+    }
+    return left.localeCompare(right);
+  });
+}
+__name(sortPathKeys, "sortPathKeys");
+function normalizePathEnvForWindows(env) {
+  if (process.platform !== "win32") {
+    return env;
+  }
+  const normalized = { ...env };
+  const pathKeys = Object.keys(normalized).filter(
+    (key) => key.toLowerCase() === "path"
+  );
+  if (pathKeys.length === 0) {
+    return normalized;
+  }
+  const orderedPathKeys = sortPathKeys(pathKeys);
+  const fingerprint = getWindowsPathFingerprint(normalized, orderedPathKeys);
+  const canonicalValue = fingerprint === cachedWindowsPathFingerprint ? cachedMergedWindowsPath : mergeWindowsPathValues(normalized, orderedPathKeys);
+  if (fingerprint !== cachedWindowsPathFingerprint) {
+    cachedWindowsPathFingerprint = fingerprint;
+    cachedMergedWindowsPath = canonicalValue;
+  }
+  for (const key of pathKeys) {
+    if (key !== "PATH") {
+      delete normalized[key];
+    }
+  }
+  if (canonicalValue !== void 0) {
+    normalized["PATH"] = canonicalValue;
+  }
+  return normalized;
+}
+__name(normalizePathEnvForWindows, "normalizePathEnvForWindows");
+
+// packages/core/src/services/shellContextEnv.ts
+init_esbuild_shims();
+import {
+  accessSync,
+  closeSync,
+  constants,
+  openSync,
+  readSync,
+  statSync
+} from "node:fs";
+var SCRIPT_ENTRY_RE = /\.(?:mjs|cjs|js|mts|cts|ts|tsx|jsx)$/i;
+var unusableCache = /* @__PURE__ */ new Map();
+function isUnusableScriptEntry(path3) {
+  const cached = unusableCache.get(path3);
+  if (cached !== void 0) return cached;
+  let unusable;
+  try {
+    if (!statSync(path3).isFile()) {
+      unusable = true;
+    } else {
+      accessSync(path3, constants.X_OK);
+      const fd = openSync(path3, "r");
+      try {
+        const head = Buffer.alloc(2);
+        const read = readSync(fd, head, 0, 2, 0);
+        const shebang = read === 2 && head.toString("utf8") === "#!";
+        unusable = shebang ? false : SCRIPT_ENTRY_RE.test(path3);
+      } finally {
+        closeSync(fd);
+      }
+    }
+  } catch {
+    unusable = true;
+  }
+  unusableCache.set(path3, unusable);
+  return unusable;
+}
+__name(isUnusableScriptEntry, "isUnusableScriptEntry");
+function identityDescribes(identity, model) {
+  const head = /^(.*)@[0-9a-f]{8}$/.exec(identity)?.[1] ?? identity;
+  return head === model;
+}
+__name(identityDescribes, "identityDescribes");
+function getShellContextEnvVars() {
+  const env = {};
+  const sessionId = sessionIdContext.getStore() ?? process.env["QWEN_CODE_SESSION_ID"];
+  if (sessionId) {
+    env["QWEN_CODE_SESSION_ID"] = sessionId;
+  }
+  const projectDir = (sessionId ? getSessionProjectDir(sessionId) : void 0) ?? process.env["QWEN_CODE_PROJECT_DIR"];
+  if (projectDir) {
+    env["QWEN_CODE_PROJECT_DIR"] = projectDir;
+  }
+  const cliEntry = process.env["QWEN_CODE_CLI"];
+  if (cliEntry) {
+    env["QWEN_CODE_CLI"] = isUnusableScriptEntry(cliEntry) ? "" : cliEntry;
+  }
+  const model = (sessionId ? getSessionModel(sessionId) : void 0) ?? process.env["QWEN_CODE_MODEL"];
+  if (model) {
+    env["QWEN_CODE_MODEL"] = model;
+  }
+  const globalIdentity = process.env["QWEN_CODE_MODEL_IDENTITY"];
+  const modelIdentity = (sessionId ? getSessionModelIdentity(sessionId) : void 0) ?? (globalIdentity && model && identityDescribes(globalIdentity, model) ? globalIdentity : void 0);
+  env["QWEN_CODE_MODEL_IDENTITY"] = modelIdentity ?? "";
+  const agentId = getCurrentAgentId();
+  env["QWEN_CODE_AGENT_ID"] = agentId ?? "";
+  const promptId = promptIdContext.getStore();
+  env["QWEN_CODE_PROMPT_ID"] = promptId ?? "";
+  if (isShellTracePropagationEnabled()) {
+    const ctx = getTraceContext();
+    env["TRACEPARENT"] = ctx ? formatTraceparent(ctx) : "";
+    env["TRACESTATE"] = "";
+  }
+  return env;
+}
+__name(getShellContextEnvVars, "getShellContextEnvVars");
+
+// packages/core/src/services/conpty-host.ts
+init_esbuild_shims();
+import os from "node:os";
+var debugLogger = createDebugLogger("CONPTY_HOST");
+var releasedHosts = /* @__PURE__ */ new WeakSet();
+var asPtyObject = /* @__PURE__ */ __name((ptyProcess) => typeof ptyProcess === "object" && ptyProcess !== null ? ptyProcess : void 0, "asPtyObject");
+var noteConPtyHostReleased = /* @__PURE__ */ __name((ptyProcess) => {
+  const key = asPtyObject(ptyProcess);
+  if (key) {
+    releasedHosts.add(key);
+  }
+}, "noteConPtyHostReleased");
+var disposeConoutWorker = /* @__PURE__ */ __name((ptyProcess) => {
+  if (os.platform() !== "win32") {
+    return;
+  }
+  const agent = ptyProcess?._agent;
+  if (!agent) {
+    return;
+  }
+  try {
+    agent._conoutSocketWorker?.dispose?.();
+  } catch (e) {
+    debugLogger.warn(
+      `disposeConoutWorker: conout worker dispose threw: ${e instanceof Error ? e.message : String(e)}`
+    );
+  }
+}, "disposeConoutWorker");
+var releaseConPtyHost = /* @__PURE__ */ __name((ptyProcess) => {
+  if (os.platform() !== "win32") {
+    return;
+  }
+  const key = asPtyObject(ptyProcess);
+  if (!key) {
+    return;
+  }
+  const agent = ptyProcess?._agent;
+  if (releasedHosts.has(key)) {
+    if (agent?._useConptyDll) {
+      disposeConoutWorker(ptyProcess);
+    }
+    return;
+  }
+  releasedHosts.add(key);
+  const ptyId = agent?._pty;
+  const nativeKill = agent?._ptyNative?.kill;
+  if (!agent) {
+    debugLogger.warn(
+      "releaseConPtyHost: no node-pty agent; nothing released (see #11303)"
+    );
+    return;
+  }
+  if (typeof nativeKill === "function" && typeof ptyId === "number") {
+    try {
+      nativeKill.call(agent._ptyNative, ptyId, agent._useConptyDll ?? false);
+    } catch (e) {
+      debugLogger.warn(
+        `releaseConPtyHost: the native pty kill threw: ${e instanceof Error ? e.message : String(e)}`
+      );
+    }
+  } else {
+    debugLogger.warn(
+      "releaseConPtyHost: native pty shape changed; skipping the pseudo-console close (see #11303)"
+    );
+  }
+  try {
+    agent._conoutSocketWorker?.dispose?.();
+  } catch (e) {
+    debugLogger.warn(
+      `releaseConPtyHost: conout worker dispose threw: ${e instanceof Error ? e.message : String(e)}`
+    );
+  }
+}, "releaseConPtyHost");
+
+// packages/core/src/utils/shell-pager-env.ts
+init_esbuild_shims();
+function getDefaultShellPager(platform = process.platform) {
+  return platform === "win32" ? void 0 : "cat";
+}
+__name(getDefaultShellPager, "getDefaultShellPager");
+function getShellPagerEnv(pager, options = {}) {
+  const effectivePager = pager ?? getDefaultShellPager(options.platform);
+  if (!effectivePager) {
+    return {
+      PAGER: "",
+      ...options.includeGitPager ? { GIT_PAGER: "" } : {}
+    };
+  }
+  return {
+    PAGER: effectivePager,
+    ...options.includeGitPager ? { GIT_PAGER: effectivePager } : {}
+  };
+}
+__name(getShellPagerEnv, "getShellPagerEnv");
+
+// packages/core/src/services/shellExecutionService.ts
+var debugLogger2 = createDebugLogger("SHELL_EXECUTION");
+var DEFAULT_MAX_BUFFERED_OUTPUT_BYTES = 64 * 1024 * 1024;
+var MAX_BUFFERED_OUTPUT_BYTES_CEILING = 256 * 1024 * 1024;
+var SIGKILL_TIMEOUT_MS = 200;
+var POST_EXIT_STREAM_DRAIN_MS = 1e3;
+var MAX_LIVE_TERMINAL_SCROLLBACK_LINES = 200;
+var PROMOTE_DRAIN_TIMEOUT_MS = 200;
+function getShellAbortReasonKind(reason) {
+  if (reason !== null && typeof reason === "object") {
+    try {
+      if (Object.prototype.hasOwnProperty.call(reason, "kind")) {
+        const kind = reason.kind;
+        if (kind === "background" || kind === "cancel") return kind;
+      }
+    } catch {
+    }
+  }
+  return "cancel";
+}
+__name(getShellAbortReasonKind, "getShellAbortReasonKind");
+var CHCP = `${process.env["SystemRoot"] || "C:\\Windows"}\\System32\\chcp.com`;
+function applyUtf8Prefix(command, shell) {
+  if (os2.platform() !== "win32") return command;
+  switch (shell) {
+    case "powershell":
+      return "[Console]::OutputEncoding=[System.Text.Encoding]::UTF8;" + command;
+    case "cmd":
+      return `${CHCP} 65001 >nul 2>nul & ${command}`;
+    case "bash":
+      return command;
+    default: {
+      const _exhaustive = shell;
+      return _exhaustive;
+    }
+  }
+}
+__name(applyUtf8Prefix, "applyUtf8Prefix");
+function isSignalTermination(signal) {
+  return signal !== null && signal !== 0;
+}
+__name(isSignalTermination, "isSignalTermination");
+function launchCommand(input) {
+  if (typeof input !== "string") {
+    return {
+      executable: input.executable,
+      args: [...input.args],
+      shell: void 0
+    };
+  }
+  const { executable, argsPrefix, shell } = getShellConfiguration();
+  return {
+    executable,
+    args: [...argsPrefix, applyUtf8Prefix(input, shell)],
+    shell
+  };
+}
+__name(launchCommand, "launchCommand");
+function createPreSpawnAbortedHandle() {
+  return {
+    pid: void 0,
+    result: Promise.resolve({
+      rawOutput: Buffer.alloc(0),
+      output: "",
+      exitCode: null,
+      signal: null,
+      error: null,
+      aborted: true,
+      pid: void 0,
+      executionMethod: "none"
+    })
+  };
+}
+__name(createPreSpawnAbortedHandle, "createPreSpawnAbortedHandle");
+function getMaxBufferedOutputBytes(config) {
+  const configured = config.maxBufferedOutputBytes;
+  const floored = typeof configured === "number" && Number.isFinite(configured) ? Math.floor(configured) : 0;
+  return floored > 0 ? Math.min(floored, MAX_BUFFERED_OUTPUT_BYTES_CEILING) : DEFAULT_MAX_BUFFERED_OUTPUT_BYTES;
+}
+__name(getMaxBufferedOutputBytes, "getMaxBufferedOutputBytes");
+function decodeBufferedOutput(finalBuffer) {
+  const fallbackEncoding = getCachedEncodingForBuffer(finalBuffer);
+  return new TextDecoder(fallbackEncoding).decode(finalBuffer);
+}
+__name(decodeBufferedOutput, "decodeBufferedOutput");
+function appendOutputCaptureLimitNotice(output, didExceedLimit, totalBytesReceived, maxBufferedOutputBytes) {
+  if (!didExceedLimit) {
+    return output;
+  }
+  const notice = `[Output exceeded the maximum captured size of ${formatMemoryUsage(maxBufferedOutputBytes)}; captured the first ${formatMemoryUsage(maxBufferedOutputBytes)} of ${formatMemoryUsage(totalBytesReceived)} and discarded the rest to avoid constructing an oversized JavaScript string.]`;
+  return output ? `${output}
+
+${notice}` : notice;
+}
+__name(appendOutputCaptureLimitNotice, "appendOutputCaptureLimitNotice");
+var getErrnoCode = /* @__PURE__ */ __name((error) => {
+  if (!error || typeof error !== "object" || !("code" in error)) {
+    return void 0;
+  }
+  const code = error.code;
+  return typeof code === "string" ? code : void 0;
+}, "getErrnoCode");
+var getErrorMessage2 = /* @__PURE__ */ __name((error) => error instanceof Error ? error.message : String(error), "getErrorMessage");
+var isExpectedPtyReadExitError = /* @__PURE__ */ __name((error) => {
+  const code = getErrnoCode(error);
+  if (code === "EIO" || code === "EAGAIN") {
+    return true;
+  }
+  const message = getErrorMessage2(error);
+  return message.includes("read EIO") || message.includes("EAGAIN");
+}, "isExpectedPtyReadExitError");
+var isExpectedPtyExitRaceError = /* @__PURE__ */ __name((error) => {
+  const code = getErrnoCode(error);
+  if (code === "ESRCH" || code === "EBADF") {
+    return true;
+  }
+  const message = getErrorMessage2(error);
+  return message.includes("ioctl(2) failed, EBADF") || message.includes("Cannot resize a pty that has already exited");
+}, "isExpectedPtyExitRaceError");
+var replayTerminalOutput = /* @__PURE__ */ __name(async (output, cols, rows, Terminal) => {
+  const replayTerminal = new Terminal({
+    allowProposedApi: true,
+    cols,
+    rows,
+    scrollback: 1e4,
+    convertEol: true,
+    // This headless terminal only captures output, so suppress parser diagnostics.
+    logLevel: "off"
+  });
+  try {
+    await new Promise((resolve) => {
+      replayTerminal.write(output, () => resolve());
+    });
+    return serializeTerminalToText(replayTerminal);
+  } finally {
+    replayTerminal.dispose();
+  }
+}, "replayTerminalOutput");
+var getLastNonEmptyAnsiLineIndex = /* @__PURE__ */ __name((output) => {
+  for (let i = output.length - 1; i >= 0; i--) {
+    const line = output[i];
+    if (line.map((segment) => segment.text).join("").trim().length > 0) {
+      return i;
+    }
+  }
+  return -1;
+}, "getLastNonEmptyAnsiLineIndex");
+var trimTrailingEmptyAnsiLines = /* @__PURE__ */ __name((output) => output.slice(0, getLastNonEmptyAnsiLineIndex(output) + 1), "trimTrailingEmptyAnsiLines");
+var areAnsiOutputsEqual = /* @__PURE__ */ __name((left, right) => {
+  if (!left || left.length !== right.length) {
+    return false;
+  }
+  return left.every((leftLine, lineIndex) => {
+    const rightLine = right[lineIndex];
+    if (leftLine.length !== rightLine.length) {
+      return false;
+    }
+    return leftLine.every((leftToken, tokenIndex) => {
+      const rightToken = rightLine[tokenIndex];
+      return leftToken.text === rightToken.text && leftToken.bold === rightToken.bold && leftToken.italic === rightToken.italic && leftToken.underline === rightToken.underline && leftToken.dim === rightToken.dim && leftToken.inverse === rightToken.inverse && leftToken.fg === rightToken.fg && leftToken.bg === rightToken.bg;
+    });
+  });
+}, "areAnsiOutputsEqual");
+var createPlainAnsiLine = /* @__PURE__ */ __name((text) => [
+  {
+    text,
+    bold: false,
+    italic: false,
+    underline: false,
+    dim: false,
+    inverse: false,
+    fg: "",
+    bg: ""
+  }
+], "createPlainAnsiLine");
+var serializePlainViewportToAnsiOutput = /* @__PURE__ */ __name((terminal, unwrapWrappedLines = false) => {
+  const buffer = terminal.buffer.active;
+  const lines = [];
+  for (let y = 0; y < terminal.rows; y++) {
+    const line = buffer.getLine(buffer.viewportY + y);
+    const lineContent = line ? line.translateToString(true) : "";
+    if (unwrapWrappedLines && line?.isWrapped && lines.length > 0) {
+      lines[lines.length - 1][0].text += lineContent;
+    } else {
+      lines.push(createPlainAnsiLine(lineContent));
+    }
+  }
+  return lines;
+}, "serializePlainViewportToAnsiOutput");
+var WINDOWS_TASKKILL = `${process.env["SystemRoot"] || "C:\\Windows"}\\System32\\taskkill.exe`;
+var WINDOWS_TASKKILL_OPTIONS = { windowsHide: true };
+var windowsKillPid = /* @__PURE__ */ __name((pid, tree) => {
+  try {
+    const args = tree ? ["/f", "/t", "/pid", pid.toString()] : ["/f", "/pid", pid.toString()];
+    const killer = cpSpawn(WINDOWS_TASKKILL, args, WINDOWS_TASKKILL_OPTIONS);
+    killer.on("error", (e) => {
+      debugLogger2.warn(
+        `windowsKillPid: taskkill failed to launch for pid ${pid}: ${e.message}`
+      );
+    });
+    killer.on("exit", (code, signal) => {
+      if (code !== 0 || signal) {
+        debugLogger2.warn(
+          `windowsKillPid: taskkill exited non-zero for pid ${pid}: ${signal ? `signal ${signal}` : `exit ${code}`}`
+        );
+      }
+    });
+  } catch (e) {
+    debugLogger2.warn(
+      `windowsKillPid: taskkill spawn threw for pid ${pid}: ${e instanceof Error ? e.message : String(e)}`
+    );
+  }
+}, "windowsKillPid");
+var windowsStrategy = {
+  killPty: /* @__PURE__ */ __name((pid, pty) => {
+    try {
+      spawnSync(
+        WINDOWS_TASKKILL,
+        ["/f", "/t", "/pid", pid.toString()],
+        WINDOWS_TASKKILL_OPTIONS
+      );
+    } catch {
+    }
+    try {
+      pty.ptyProcess.kill();
+    } catch {
+    }
+    noteConPtyHostReleased(pty.ptyProcess);
+  }, "killPty"),
+  killChildProcesses: /* @__PURE__ */ __name((pids) => {
+    if (pids.size > 0) {
+      try {
+        const args = ["/f", "/t"];
+        for (const pid of pids) {
+          args.push("/pid", pid.toString());
+        }
+        spawnSync(WINDOWS_TASKKILL, args, WINDOWS_TASKKILL_OPTIONS);
+      } catch {
+      }
+    }
+  }, "killChildProcesses")
+};
+var posixStrategy = {
+  killPty: /* @__PURE__ */ __name((pid, _pty) => {
+    process.kill(-pid, "SIGKILL");
+  }, "killPty"),
+  killChildProcesses: /* @__PURE__ */ __name((pids) => {
+    for (const pid of pids) {
+      try {
+        process.kill(-pid, "SIGKILL");
+      } catch {
+      }
+    }
+  }, "killChildProcesses")
+};
+var getCleanupStrategy = /* @__PURE__ */ __name(() => os2.platform() === "win32" ? windowsStrategy : posixStrategy, "getCleanupStrategy");
+var ShellExecutionService = class _ShellExecutionService {
+  static {
+    __name(this, "ShellExecutionService");
+  }
+  static activePtys = /* @__PURE__ */ new Map();
+  static activeChildProcesses = /* @__PURE__ */ new Set();
+  static cleanup() {
+    const strategy = getCleanupStrategy();
+    for (const [pid, pty] of this.activePtys) {
+      try {
+        strategy.killPty(pid, pty);
+      } catch {
+      }
+      try {
+        pty.headlessTerminal.dispose();
+      } catch {
+      }
+    }
+    strategy.killChildProcesses(this.activeChildProcesses);
+  }
+  static {
+    process.on("exit", () => {
+      _ShellExecutionService.cleanup();
+    });
+  }
+  /**
+   * Executes a shell command using `node-pty`, capturing all output and lifecycle events.
+   *
+   * @param commandToExecute The exact command string to run.
+   * @param cwd The working directory to execute the command in.
+   * @param onOutputEvent A callback for streaming structured events about the execution, including data chunks and status updates.
+   * @param abortSignal An AbortSignal to terminate the process and its children.
+   * @returns An object containing the process ID (pid) and a promise that
+   *          resolves with the complete execution result.
+   */
+  static async execute(commandToExecute, cwd, onOutputEvent, abortSignal, shouldUseNodePty, shellExecutionConfig, options = {}) {
+    return this.executeInternal(
+      commandToExecute,
+      cwd,
+      onOutputEvent,
+      abortSignal,
+      shouldUseNodePty,
+      shellExecutionConfig,
+      options
+    );
+  }
+  static async executeLaunch(launch, onOutputEvent, abortSignal, shouldUseNodePty, shellExecutionConfig, options = {}) {
+    const snapshot = {
+      executable: launch.executable,
+      args: [...launch.args],
+      cwd: launch.cwd,
+      env: { ...launch.env },
+      stdin: Buffer.isBuffer(launch.stdin) ? Buffer.from(launch.stdin) : launch.stdin
+    };
+    if (!path.isAbsolute(snapshot.executable) || !path.isAbsolute(snapshot.cwd)) {
+      throw new Error("Process executable and cwd must be absolute.");
+    }
+    if ([
+      snapshot.executable,
+      snapshot.cwd,
+      ...snapshot.args,
+      ...Object.values(snapshot.env)
+    ].some((value) => value.includes("\0")) || Object.keys(snapshot.env).some(
+      (key) => !key || key.includes("=") || key.includes("\0")
+    )) {
+      throw new Error("Invalid process launch argument or environment.");
+    }
+    if (shouldUseNodePty && snapshot.stdin !== void 0) {
+      throw new Error("Process stdin requires pipe execution.");
+    }
+    if (shouldUseNodePty && !snapshot.env["TERM"]) {
+      throw new Error(
+        "PTY launch requires an explicit TERM environment value."
+      );
+    }
+    if (shouldUseNodePty && os2.platform() !== "win32" && snapshot.env["PWD"] !== snapshot.cwd) {
+      throw new Error("PTY launch requires PWD to match cwd.");
+    }
+    return this.executeInternal(
+      snapshot,
+      snapshot.cwd,
+      onOutputEvent,
+      abortSignal,
+      shouldUseNodePty,
+      shellExecutionConfig,
+      options
+    );
+  }
+  static async executeInternal(commandToExecute, cwd, onOutputEvent, abortSignal, shouldUseNodePty, shellExecutionConfig, options) {
+    if (abortSignal.aborted) {
+      return createPreSpawnAbortedHandle();
+    }
+    if (shouldUseNodePty) {
+      let removeAbortListener;
+      const ptyResult = Promise.resolve(getPty()).then(
+        (value) => ({ kind: "resolved", value }),
+        (error) => ({ kind: "rejected", error })
+      );
+      const aborted = new Promise((resolve) => {
+        const onAbort = /* @__PURE__ */ __name(() => resolve({ kind: "aborted" }), "onAbort");
+        abortSignal.addEventListener("abort", onAbort, { once: true });
+        removeAbortListener = /* @__PURE__ */ __name(() => abortSignal.removeEventListener("abort", onAbort), "removeAbortListener");
+        if (abortSignal.aborted) onAbort();
+      });
+      const ptyOutcome = await Promise.race([ptyResult, aborted]);
+      removeAbortListener?.();
+      if (ptyOutcome.kind === "aborted") {
+        return createPreSpawnAbortedHandle();
+      }
+      if (ptyOutcome.kind === "rejected") {
+        throw ptyOutcome.error;
+      }
+      if (abortSignal.aborted) {
+        return createPreSpawnAbortedHandle();
+      }
+      const ptyInfo = ptyOutcome.value;
+      if (ptyInfo) {
+        try {
+          const { Terminal } = await loadXtermHeadless();
+          if (abortSignal.aborted) {
+            return createPreSpawnAbortedHandle();
+          }
+          return this.executeWithPty(
+            commandToExecute,
+            cwd,
+            onOutputEvent,
+            abortSignal,
+            shellExecutionConfig,
+            ptyInfo,
+            Terminal,
+            options.postPromote
+          );
+        } catch (_e) {
+        }
+      }
+    }
+    if (abortSignal.aborted) return createPreSpawnAbortedHandle();
+    return this.childProcessFallback(
+      commandToExecute,
+      cwd,
+      onOutputEvent,
+      abortSignal,
+      options.streamStdout ?? false,
+      getMaxBufferedOutputBytes(shellExecutionConfig),
+      shellExecutionConfig.pager,
+      options.postPromote,
+      shellExecutionConfig.streamBufferedOutput
+    );
+  }
+  static childProcessFallback(commandToExecute, cwd, onOutputEvent, abortSignal, streamStdout, maxBufferedOutputBytes, pager, postPromote, streamBufferedOutput = false) {
+    try {
+      const isWindows = os2.platform() === "win32";
+      const launch = typeof commandToExecute === "string" ? void 0 : commandToExecute;
+      const {
+        executable,
+        args: shellArgs,
+        shell
+      } = launchCommand(commandToExecute);
+      const child = cpSpawn(executable, shellArgs, {
+        cwd,
+        stdio: [
+          launch?.stdin === void 0 ? "ignore" : "pipe",
+          "pipe",
+          "pipe"
+        ],
+        windowsVerbatimArguments: isWindows && shell === "cmd",
+        detached: !isWindows,
+        windowsHide: isWindows,
+        env: launch ? { ...launch.env } : {
+          ...normalizePathEnvForWindows(sanitizeChildEnv(process.env)),
+          QWEN_CODE: "1",
+          TERM: "xterm-256color",
+          ...getShellPagerEnv(pager, {
+            includeGitPager: false,
+            platform: os2.platform()
+          }),
+          ...getShellContextEnvVars()
+        }
+      });
+      const result = new Promise((resolve) => {
+        let stdoutDecoder = null;
+        let stderrDecoder = null;
+        let stdout = "";
+        let stderr = "";
+        let stdoutPreview = "";
+        let stderrPreview = "";
+        const outputChunks = [];
+        const sniffChunks = [];
+        let error = null;
+        let stdinError = null;
+        let exited = false;
+        let settled = false;
+        let recordedExit = null;
+        let drainTimer = null;
+        let isStreamingRawContent = true;
+        const MAX_SNIFF_SIZE = 4096;
+        let sniffedBytes = 0;
+        let capturedOutputBytes = 0;
+        let totalOutputBytes = 0;
+        let outputCaptureLimitExceeded = false;
+        let outputCaptureLimitWarningEmitted = false;
+        const markOutputCaptureLimitExceeded = /* @__PURE__ */ __name(() => {
+          outputCaptureLimitExceeded = true;
+          if (outputCaptureLimitWarningEmitted) {
+            return;
+          }
+          outputCaptureLimitWarningEmitted = true;
+          debugLogger2.warn(
+            `Shell output capture exceeded maxBufferedOutputBytes (${maxBufferedOutputBytes} bytes). Total bytes: ${totalOutputBytes}. Discarding excess.`
+          );
+        }, "markOutputCaptureLimitExceeded");
+        const captureOutputData = /* @__PURE__ */ __name((data) => {
+          if (capturedOutputBytes >= maxBufferedOutputBytes) {
+            markOutputCaptureLimitExceeded();
+            return null;
+          }
+          const remainingBytes = maxBufferedOutputBytes - capturedOutputBytes;
+          const captured = data.length > remainingBytes ? data.subarray(0, remainingBytes) : data;
+          if (captured.length > 0) {
+            outputChunks.push(captured);
+            capturedOutputBytes += captured.length;
+          }
+          if (captured.length < data.length) {
+            markOutputCaptureLimitExceeded();
+          }
+          return captured.length > 0 ? captured : null;
+        }, "captureOutputData");
+        const handleOutput = /* @__PURE__ */ __name((data, stream) => {
+          if (!stdoutDecoder || !stderrDecoder) {
+            const encoding = getCachedEncodingForBuffer(data);
+            try {
+              stdoutDecoder = new TextDecoder(encoding);
+              stderrDecoder = new TextDecoder(encoding);
+            } catch {
+              stdoutDecoder = new TextDecoder("utf-8");
+              stderrDecoder = new TextDecoder("utf-8");
+            }
+          }
+          if (isStreamingRawContent && sniffedBytes < MAX_SNIFF_SIZE) {
+            const sniffSlice = data.subarray(
+              0,
+              Math.min(data.length, MAX_SNIFF_SIZE - sniffedBytes)
+            );
+            if (sniffSlice.length > 0) {
+              sniffChunks.push(sniffSlice);
+              sniffedBytes += sniffSlice.length;
+            }
+            const sniffBuffer = Buffer.concat(sniffChunks);
+            if (isBinary(sniffBuffer)) {
+              isStreamingRawContent = false;
+              if (streamStdout) {
+                onOutputEvent({ type: "binary_detected" });
+                sniffChunks.length = 0;
+              }
+            } else if (streamStdout && sniffedBytes >= MAX_SNIFF_SIZE) {
+              sniffChunks.length = 0;
+            }
+          }
+          totalOutputBytes += data.length;
+          const capturedData = captureOutputData(data);
+          if (!isStreamingRawContent) {
+            return;
+          }
+          const decoder = stream === "stdout" ? stdoutDecoder : stderrDecoder;
+          if (streamStdout) {
+            const decodedChunk2 = decoder.decode(data, { stream: true });
+            onOutputEvent({ type: "data", chunk: decodedChunk2, stream });
+            return;
+          }
+          if (!capturedData) {
+            return;
+          }
+          const decodedChunk = decoder.decode(capturedData, { stream: true });
+          if (stream === "stdout") {
+            stdout += decodedChunk;
+          } else {
+            stderr += decodedChunk;
+          }
+          if (streamBufferedOutput) {
+            if (stream === "stdout") {
+              stdoutPreview = (stdoutPreview + decodedChunk.slice(-65536)).slice(-65536);
+            } else {
+              stderrPreview = (stderrPreview + decodedChunk.slice(-65536)).slice(-65536);
+            }
+            const separator = stdoutPreview.endsWith("\n") ? "" : "\n";
+            const snapshot = stdoutPreview + (stderrPreview ? (stdoutPreview ? separator : "") + stderrPreview : "");
+            onOutputEvent({
+              type: "data",
+              chunk: stripAnsi(snapshot).slice(-65536)
+            });
+          }
+        }, "handleOutput");
+        const handleExit = /* @__PURE__ */ __name((code, signal) => {
+          if (settled) return;
+          settled = true;
+          if (drainTimer) {
+            clearTimeout(drainTimer);
+            drainTimer = null;
+          }
+          const { finalBuffer } = cleanup();
+          const separator = stdout.endsWith("\n") ? "" : "\n";
+          const combinedOutput = stdout + (stderr ? (stdout ? separator : "") + stderr : "");
+          const finalStrippedOutput = stripAnsi(combinedOutput).trim();
+          const boundedOutput = appendOutputCaptureLimitNotice(
+            finalStrippedOutput,
+            outputCaptureLimitExceeded,
+            totalOutputBytes,
+            maxBufferedOutputBytes
+          );
+          if (isStreamingRawContent) {
+            if (!streamStdout && boundedOutput) {
+              onOutputEvent({ type: "data", chunk: boundedOutput });
+            }
+          } else {
+            onOutputEvent({ type: "binary_detected" });
+          }
+          resolve({
+            rawOutput: finalBuffer,
+            output: boundedOutput,
+            exitCode: code,
+            signal: signal ? os2.constants.signals[signal] : null,
+            error: error ?? (code === null && signal === null ? stdinError : null),
+            aborted: abortSignal.aborted,
+            pid: void 0,
+            executionMethod: "child_process"
+          });
+        }, "handleExit");
+        const stdoutHandler = /* @__PURE__ */ __name((data) => handleOutput(data, "stdout"), "stdoutHandler");
+        const stderrHandler = /* @__PURE__ */ __name((data) => handleOutput(data, "stderr"), "stderrHandler");
+        const errorHandler = /* @__PURE__ */ __name((err) => {
+          error = err;
+          handleExit(1, null);
+        }, "errorHandler");
+        const exitHandler = /* @__PURE__ */ __name((code, signal) => {
+          if (child.pid) {
+            this.activeChildProcesses.delete(child.pid);
+          }
+          if (!streamStdout) {
+            handleExit(code, signal);
+            return;
+          }
+          if (recordedExit) return;
+          recordedExit = { code, signal };
+          exited = true;
+          drainTimer = setTimeout(() => {
+            drainTimer = null;
+            const recorded = recordedExit;
+            if (recorded) handleExit(recorded.code, recorded.signal);
+          }, POST_EXIT_STREAM_DRAIN_MS);
+          drainTimer.unref?.();
+        }, "exitHandler");
+        const closeHandler = /* @__PURE__ */ __name((code, signal) => {
+          const recorded = recordedExit ?? { code, signal };
+          handleExit(recorded.code, recorded.signal);
+        }, "closeHandler");
+        child.stdout?.on("data", stdoutHandler);
+        child.stderr?.on("data", stderrHandler);
+        child.on("error", errorHandler);
+        const detachServiceListeners = /* @__PURE__ */ __name(() => {
+          child.stdout?.off("data", stdoutHandler);
+          child.stderr?.off("data", stderrHandler);
+          child.off("error", errorHandler);
+          child.off("exit", exitHandler);
+          child.off("close", closeHandler);
+        }, "detachServiceListeners");
+        const performBackgroundPromote = /* @__PURE__ */ __name(() => {
+          if (!child.pid || exited) return;
+          if (child.exitCode !== null || child.signalCode !== null) {
+            debugLogger2.debug(
+              `Background-promote requested for pid ${child.pid} but child is already terminal (exitCode=${child.exitCode}, signalCode=${child.signalCode}); falling through to the normal exit-handled resolution.`
+            );
+            return;
+          }
+          if (streamStdout) {
+            debugLogger2.warn(
+              "Background-promote on a streamStdout=true child_process: snapshot accumulators were never populated (output went through onOutputEvent), so result.output will be empty. Caller should fall back to rawOutput, or assemble its own snapshot from the data events it received."
+            );
+          }
+          this.activeChildProcesses.delete(child.pid);
+          detachServiceListeners();
+          const {
+            stdout: snapStdout,
+            stderr: snapStderr,
+            finalBuffer
+          } = cleanup();
+          const separator = snapStdout.endsWith("\n") ? "" : "\n";
+          const combined = snapStdout + (snapStderr ? (snapStdout ? separator : "") + snapStderr : "");
+          const boundedOutput = appendOutputCaptureLimitNotice(
+            stripAnsi(combined).trim(),
+            outputCaptureLimitExceeded,
+            totalOutputBytes,
+            maxBufferedOutputBytes
+          );
+          const detectedEncoding = stdoutDecoder?.encoding ?? "utf-8";
+          const safeDecoder = /* @__PURE__ */ __name((encoding) => {
+            try {
+              return new TextDecoder(encoding, { fatal: false });
+            } catch {
+              return new TextDecoder("utf-8", { fatal: false });
+            }
+          }, "safeDecoder");
+          const postPromoteStdoutDecoder = postPromote?.onData ? safeDecoder(detectedEncoding) : null;
+          const postPromoteStderrDecoder = postPromote?.onData ? safeDecoder(detectedEncoding) : null;
+          let postPromoteStdoutHandler = null;
+          let postPromoteStderrHandler = null;
+          if (postPromote?.onData) {
+            const onPostData = postPromote.onData;
+            const safeData = /* @__PURE__ */ __name((decoder) => (chunk) => {
+              try {
+                onPostData({
+                  type: "data",
+                  chunk: decoder.decode(chunk, { stream: true })
+                });
+              } catch (cbErr) {
+                debugLogger2.warn(
+                  `postPromote.onData threw: ${cbErr instanceof Error ? cbErr.message : String(cbErr)}`
+                );
+              }
+            }, "safeData");
+            try {
+              if (postPromoteStdoutDecoder) {
+                postPromoteStdoutHandler = safeData(postPromoteStdoutDecoder);
+                child.stdout?.on("data", postPromoteStdoutHandler);
+              }
+              if (postPromoteStderrDecoder) {
+                postPromoteStderrHandler = safeData(postPromoteStderrDecoder);
+                child.stderr?.on("data", postPromoteStderrHandler);
+              }
+            } catch (e) {
+              debugLogger2.warn(
+                `re-attaching post-promote data listeners threw: ${e instanceof Error ? e.message : String(e)}`
+              );
+            }
+          } else if (postPromote) {
+            try {
+              child.stdout?.resume();
+              child.stderr?.resume();
+            } catch (e) {
+              debugLogger2.warn(
+                `post-promote stdout/stderr resume() threw: ${e instanceof Error ? e.message : String(e)}`
+              );
+            }
+          }
+          let postPromoteSettleFired = false;
+          const flushPostPromoteDecoders = /* @__PURE__ */ __name(() => {
+            if (!postPromote?.onData) return;
+            try {
+              if (postPromoteStdoutDecoder) {
+                const trailing = postPromoteStdoutDecoder.decode();
+                if (trailing) {
+                  postPromote.onData({
+                    type: "data",
+                    chunk: trailing
+                  });
+                }
+              }
+              if (postPromoteStderrDecoder) {
+                const trailing = postPromoteStderrDecoder.decode();
+                if (trailing) {
+                  postPromote.onData({
+                    type: "data",
+                    chunk: trailing
+                  });
+                }
+              }
+            } catch (flushErr) {
+              debugLogger2.warn(
+                `post-promote decoder flush threw: ${flushErr instanceof Error ? flushErr.message : String(flushErr)}`
+              );
+            }
+          }, "flushPostPromoteDecoders");
+          const firePostSettle = /* @__PURE__ */ __name((info) => {
+            if (postPromoteSettleFired) return;
+            postPromoteSettleFired = true;
+            flushPostPromoteDecoders();
+            if (postPromoteStdoutHandler) {
+              child.stdout?.off("data", postPromoteStdoutHandler);
+              postPromoteStdoutHandler = null;
+            }
+            if (postPromoteStderrHandler) {
+              child.stderr?.off("data", postPromoteStderrHandler);
+              postPromoteStderrHandler = null;
+            }
+            if (!postPromote?.onSettle) return;
+            try {
+              postPromote.onSettle(info);
+            } catch (cbErr) {
+              debugLogger2.warn(
+                `postPromote.onSettle threw: ${cbErr instanceof Error ? cbErr.message : String(cbErr)}`
+              );
+            }
+          }, "firePostSettle");
+          if (postPromote) {
+            try {
+              child.once(
+                "close",
+                (exitCode, signalCode) => {
+                  firePostSettle({
+                    exitCode,
+                    signal: signalCode,
+                    endTime: Date.now()
+                  });
+                }
+              );
+              child.once("error", (err) => {
+                firePostSettle({
+                  exitCode: null,
+                  signal: null,
+                  error: err,
+                  endTime: Date.now()
+                });
+              });
+            } catch (e) {
+              debugLogger2.warn(
+                `re-attaching post-promote exit/error listeners threw: ${e instanceof Error ? e.message : String(e)}`
+              );
+            }
+          }
+          resolve({
+            rawOutput: finalBuffer,
+            output: boundedOutput,
+            exitCode: null,
+            signal: null,
+            error: null,
+            // `aborted: false` (despite the abort signal having fired) is
+            // intentional — this is the result-shape decision settled in
+            // #3831 design question 7 (raised by @tanzhenxin in the PR-1
+            // review). The flag answers "should the caller emit cancel /
+            // timeout copy?" not "did the abort signal fire?" — and a
+            // promoted shell did NOT cancel (the child kept running), so
+            // existing `if (result.aborted)` branches in callers (e.g.
+            // `tools/shell.ts`) fall through naturally to the success-shape
+            // arm where we then check `result.promoted`. Without this,
+            // every consumer would have to remember to check `promoted`
+            // before `aborted` to avoid emitting "cancelled" copy for a
+            // process that's still running.
+            aborted: false,
+            promoted: true,
+            pid: child.pid,
+            executionMethod: "child_process"
+          });
+        }, "performBackgroundPromote");
+        const performCancelKill = /* @__PURE__ */ __name(async () => {
+          if (!child.pid || exited) return;
+          if (isWindows) {
+            const killer = cpSpawn(
+              WINDOWS_TASKKILL,
+              ["/f", "/t", "/pid", child.pid.toString()],
+              WINDOWS_TASKKILL_OPTIONS
+            );
+            const killChildFallback = /* @__PURE__ */ __name((why) => {
+              debugLogger2.warn(
+                `performCancelKill (child_process): taskkill ${why} for pid ${child.pid}; falling back to child.kill`
+              );
+              if (!exited) {
+                try {
+                  child.kill("SIGKILL");
+                } catch {
+                }
+              }
+            }, "killChildFallback");
+            killer.on(
+              "error",
+              (e) => killChildFallback(`failed to launch (${e.message})`)
+            );
+            killer.on("exit", (code) => {
+              if (code !== 0) killChildFallback(`exited ${code}`);
+            });
+          } else {
+            try {
+              process.kill(-child.pid, "SIGTERM");
+              await new Promise((res) => setTimeout(res, SIGKILL_TIMEOUT_MS));
+              if (!exited) {
+                process.kill(-child.pid, "SIGKILL");
+              }
+            } catch (_e) {
+              if (!exited) child.kill("SIGKILL");
+            }
+          }
+        }, "performCancelKill");
+        const abortHandler = /* @__PURE__ */ __name(async () => {
+          const kind = getShellAbortReasonKind(abortSignal.reason);
+          switch (kind) {
+            case "background":
+              performBackgroundPromote();
+              return;
+            case "cancel":
+              await performCancelKill();
+              return;
+            default: {
+              const _exhaustive = kind;
+              await performCancelKill();
+              return _exhaustive;
+            }
+          }
+        }, "abortHandler");
+        abortSignal.addEventListener("abort", abortHandler, { once: true });
+        if (child.pid) {
+          this.activeChildProcesses.add(child.pid);
+        }
+        child.on("exit", exitHandler);
+        if (streamStdout) {
+          child.once("close", closeHandler);
+        }
+        if (launch?.stdin !== void 0 && child.stdin) {
+          child.stdin.on("error", (err) => {
+            stdinError = err;
+            debugLogger2.warn(
+              `stdin transport error for pid ${child.pid}: ${err.message}`
+            );
+          });
+          child.stdin.end(launch.stdin);
+        }
+        function cleanup() {
+          exited = true;
+          abortSignal.removeEventListener("abort", abortHandler);
+          if (stdoutDecoder) {
+            const remaining = stdoutDecoder.decode();
+            if (remaining) {
+              if (streamStdout) {
+                if (isStreamingRawContent)
+                  onOutputEvent({
+                    type: "data",
+                    chunk: remaining,
+                    stream: "stdout"
+                  });
+              } else stdout += remaining;
+            }
+          }
+          if (stderrDecoder) {
+            const remaining = stderrDecoder.decode();
+            if (remaining) {
+              if (streamStdout) {
+                if (isStreamingRawContent)
+                  onOutputEvent({
+                    type: "data",
+                    chunk: remaining,
+                    stream: "stderr"
+                  });
+              } else stderr += remaining;
+            }
+          }
+          const finalBuffer = Buffer.concat(outputChunks);
+          return { stdout, stderr, finalBuffer };
+        }
+        __name(cleanup, "cleanup");
+      });
+      return { pid: child.pid, result };
+    } catch (e) {
+      const error = e;
+      return {
+        pid: void 0,
+        result: Promise.resolve({
+          error,
+          rawOutput: Buffer.from(""),
+          output: "",
+          exitCode: 1,
+          signal: null,
+          aborted: false,
+          pid: void 0,
+          executionMethod: "none"
+        })
+      };
+    }
+  }
+  static executeWithPty(commandToExecute, cwd, onOutputEvent, abortSignal, shellExecutionConfig, ptyInfo, Terminal, postPromote) {
+    if (!ptyInfo) {
+      throw new Error("PTY implementation not found");
+    }
+    const useBundledConpty = os2.platform() === "win32";
+    let ptySpawned = false;
+    try {
+      const cols = shellExecutionConfig.terminalWidth ?? 80;
+      const rows = shellExecutionConfig.terminalHeight ?? 30;
+      const launch = typeof commandToExecute === "string" ? void 0 : commandToExecute;
+      const {
+        executable,
+        args: launchArgs,
+        shell
+      } = launchCommand(commandToExecute);
+      const args = os2.platform() === "win32" && shell === "cmd" ? launchArgs.join(" ") : launchArgs;
+      const ptyProcess = ptyInfo.module.spawn(executable, args, {
+        cwd,
+        name: launch?.env["TERM"] ?? "xterm",
+        cols,
+        rows,
+        env: launch ? { ...launch.env } : {
+          ...normalizePathEnvForWindows(sanitizeChildEnv(process.env)),
+          QWEN_CODE: "1",
+          TERM: "xterm-256color",
+          ...getShellPagerEnv(shellExecutionConfig.pager, {
+            includeGitPager: true,
+            platform: os2.platform()
+          }),
+          ...getShellContextEnvVars()
+        },
+        handleFlowControl: true,
+        // Windows: with the inbox ConPTY backend a natural shell exit orphans
+        // the `conhost.exe --headless` that backend spawned — the native exit
+        // watcher erases the pty baton before JS can reach ClosePseudoConsole
+        // (microsoft/node-pty#965), so hosts accumulate until the CLI exits.
+        // The bundled backend calls ConptyReleasePseudoConsole after spawn,
+        // releasing the reference that otherwise keeps its host alive after
+        // the last client exits. Windows verification must count both
+        // `conhost.exe` and `OpenConsole.exe` (or all attributable children),
+        // because the bundled backend normally launches `OpenConsole.exe`. Off
+        // Windows the option is inert: `useConptyDll` appears nowhere in the
+        // POSIX prebuilds.
+        useConptyDll: useBundledConpty
+      });
+      ptySpawned = true;
+      const result = new Promise((resolve) => {
+        const headlessTerminal = new Terminal({
+          allowProposedApi: true,
+          cols,
+          rows,
+          scrollback: MAX_LIVE_TERMINAL_SCROLLBACK_LINES,
+          // This headless terminal only captures output, so suppress parser diagnostics.
+          logLevel: "off"
+        });
+        headlessTerminal.scrollToTop();
+        const queryResponseDisposable = useBundledConpty ? headlessTerminal.onData((data) => {
+          try {
+            ptyProcess.write(data);
+          } catch (e) {
+            debugLogger2.warn(
+              `writing terminal query reply to PTY threw: ${e instanceof Error ? e.message : String(e)}`
+            );
+          }
+        }) : null;
+        this.activePtys.set(ptyProcess.pid, { ptyProcess, headlessTerminal });
+        let processingChain = Promise.resolve();
+        let decoder = null;
+        let outputComparison = null;
+        const outputChunks = [];
+        const sniffChunks = [];
+        const error = null;
+        let exited = false;
+        let cancelKillDispatched = false;
+        let isStreamingRawContent = true;
+        const MAX_SNIFF_SIZE = 4096;
+        let sniffedBytes = 0;
+        let totalBytesReceived = 0;
+        const maxBufferedOutputBytes = getMaxBufferedOutputBytes(shellExecutionConfig);
+        let capturedOutputBytes = 0;
+        let outputCaptureLimitExceeded = false;
+        let outputCaptureLimitWarningEmitted = false;
+        let isWriting = false;
+        let hasStartedOutput = false;
+        let renderTimeout = null;
+        let listenersDetached = false;
+        const RENDER_THROTTLE_MS = 100;
+        const markOutputCaptureLimitExceeded = /* @__PURE__ */ __name(() => {
+          outputCaptureLimitExceeded = true;
+          if (outputCaptureLimitWarningEmitted) {
+            return;
+          }
+          outputCaptureLimitWarningEmitted = true;
+          debugLogger2.warn(
+            `Shell output capture exceeded maxBufferedOutputBytes (${maxBufferedOutputBytes} bytes). Total bytes: ${totalBytesReceived}. Discarding excess.`
+          );
+        }, "markOutputCaptureLimitExceeded");
+        const renderFn = /* @__PURE__ */ __name(() => {
+          if (!isStreamingRawContent || listenersDetached) {
+            return;
+          }
+          if (!shellExecutionConfig.disableDynamicLineTrimming) {
+            if (!hasStartedOutput) {
+              const bufferText = serializeTerminalToText(headlessTerminal);
+              if (bufferText.trim().length === 0) {
+                return;
+              }
+              hasStartedOutput = true;
+            }
+          }
+          let newOutput;
+          let newOutputComparison;
+          if (shellExecutionConfig.showColor) {
+            newOutput = serializeTerminalToObject(headlessTerminal);
+            newOutputComparison = serializeTerminalToObject(
+              headlessTerminal,
+              0,
+              { unwrapWrappedLines: true }
+            );
+          } else {
+            newOutput = serializePlainViewportToAnsiOutput(headlessTerminal);
+            newOutputComparison = serializePlainViewportToAnsiOutput(
+              headlessTerminal,
+              true
+            );
+          }
+          const trimmedOutput = trimTrailingEmptyAnsiLines(newOutput);
+          const trimmedOutputComparison = trimTrailingEmptyAnsiLines(newOutputComparison);
+          const finalOutput = shellExecutionConfig.disableDynamicLineTrimming ? newOutput : trimmedOutput;
+          const finalOutputComparison = shellExecutionConfig.disableDynamicLineTrimming ? newOutputComparison : trimmedOutputComparison;
+          if (!areAnsiOutputsEqual(outputComparison, finalOutputComparison)) {
+            outputComparison = finalOutputComparison;
+            onOutputEvent({
+              type: "data",
+              chunk: finalOutput
+            });
+          }
+        }, "renderFn");
+        let pendingTrailingRender = false;
+        const render = /* @__PURE__ */ __name((finalRender = false) => {
+          if (finalRender) {
+            if (renderTimeout) {
+              clearTimeout(renderTimeout);
+              renderTimeout = null;
+            }
+            renderFn();
+            return;
+          }
+          if (!renderTimeout) {
+            renderFn();
+            renderTimeout = setTimeout(() => {
+              renderTimeout = null;
+              if (pendingTrailingRender) {
+                pendingTrailingRender = false;
+                render();
+              }
+            }, RENDER_THROTTLE_MS);
+          } else {
+            pendingTrailingRender = true;
+          }
+        }, "render");
+        headlessTerminal.onScroll(() => {
+          if (!isWriting) {
+            render();
+          }
+        });
+        const ensureDecoder = /* @__PURE__ */ __name((data) => {
+          if (decoder) {
+            return;
+          }
+          const encoding = getCachedEncodingForBuffer(data);
+          try {
+            decoder = new TextDecoder(encoding);
+          } catch {
+            decoder = new TextDecoder("utf-8");
+          }
+        }, "ensureDecoder");
+        const captureOutputData = /* @__PURE__ */ __name((data) => {
+          if (capturedOutputBytes >= maxBufferedOutputBytes) {
+            markOutputCaptureLimitExceeded();
+            return;
+          }
+          const remainingBytes = maxBufferedOutputBytes - capturedOutputBytes;
+          const captured = data.length > remainingBytes ? data.subarray(0, remainingBytes) : data;
+          if (captured.length > 0) {
+            outputChunks.push(captured);
+            capturedOutputBytes += captured.length;
+          }
+          if (captured.length < data.length) {
+            markOutputCaptureLimitExceeded();
+          }
+        }, "captureOutputData");
+        const handleOutput = /* @__PURE__ */ __name((data) => {
+          ensureDecoder(data);
+          totalBytesReceived += data.length;
+          captureOutputData(data);
+          const bytesReceived = totalBytesReceived;
+          processingChain = processingChain.then(
+            () => new Promise((resolve2) => {
+              if (isStreamingRawContent && sniffedBytes < MAX_SNIFF_SIZE) {
+                const sniffSlice = data.subarray(
+                  0,
+                  Math.min(data.length, MAX_SNIFF_SIZE - sniffedBytes)
+                );
+                if (sniffSlice.length > 0) {
+                  sniffChunks.push(sniffSlice);
+                  sniffedBytes += sniffSlice.length;
+                }
+                const sniffBuffer = Buffer.concat(sniffChunks);
+                if (isBinary(sniffBuffer)) {
+                  isStreamingRawContent = false;
+                  if (!listenersDetached) {
+                    onOutputEvent({ type: "binary_detected" });
+                  }
+                }
+              }
+              if (isStreamingRawContent) {
+                const decodedChunk = decoder.decode(data, { stream: true });
+                isWriting = true;
+                headlessTerminal.write(decodedChunk, () => {
+                  render();
+                  isWriting = false;
+                  resolve2();
+                });
+              } else {
+                if (!listenersDetached) {
+                  onOutputEvent({
+                    type: "binary_progress",
+                    bytesReceived
+                  });
+                }
+                resolve2();
+              }
+            })
+          );
+        }, "handleOutput");
+        const dataDisposable = ptyProcess.onData((data) => {
+          const bufferData = Buffer.from(data, "utf-8");
+          handleOutput(bufferData);
+        });
+        const ptyErrorHandler = /* @__PURE__ */ __name((err) => {
+          if (isExpectedPtyReadExitError(err)) {
+            return;
+          }
+          throw err;
+        }, "ptyErrorHandler");
+        ptyProcess.on("error", ptyErrorHandler);
+        const disposeForegroundPtyResources = /* @__PURE__ */ __name(() => {
+          listenersDetached = true;
+          if (renderTimeout) {
+            clearTimeout(renderTimeout);
+            renderTimeout = null;
+          }
+          try {
+            dataDisposable.dispose();
+          } catch (e) {
+            debugLogger2.warn(
+              `dataDisposable.dispose() threw during PTY cleanup: ${e instanceof Error ? e.message : String(e)}`
+            );
+          }
+          try {
+            exitDisposable.dispose();
+          } catch (e) {
+            debugLogger2.warn(
+              `exitDisposable.dispose() threw during PTY cleanup: ${e instanceof Error ? e.message : String(e)}`
+            );
+          }
+          try {
+            ptyProcess.removeListener("error", ptyErrorHandler);
+          } catch (e) {
+            debugLogger2.warn(
+              `ptyProcess.removeListener('error') threw during PTY cleanup: ${e instanceof Error ? e.message : String(e)}`
+            );
+          }
+          try {
+            queryResponseDisposable?.dispose();
+          } catch (e) {
+            debugLogger2.warn(
+              `queryResponseDisposable.dispose() threw during PTY cleanup: ${e instanceof Error ? e.message : String(e)}`
+            );
+          }
+          try {
+            headlessTerminal.dispose();
+          } catch (e) {
+            debugLogger2.warn(
+              `headlessTerminal.dispose() threw during PTY cleanup: ${e instanceof Error ? e.message : String(e)}`
+            );
+          }
+          if (os2.platform() === "win32" && _ShellExecutionService.isPtyActive(ptyProcess.pid)) {
+            windowsKillPid(ptyProcess.pid, cancelKillDispatched);
+          }
+          releaseConPtyHost(ptyProcess);
+          this.activePtys.delete(ptyProcess.pid);
+        }, "disposeForegroundPtyResources");
+        const exitDisposable = ptyProcess.onExit(
+          ({ exitCode, signal }) => {
+            exited = true;
+            abortSignal.removeEventListener("abort", abortHandler);
+            const finalize = /* @__PURE__ */ __name(async () => {
+              const finalBuffer = Buffer.concat(outputChunks);
+              let fullOutput = "";
+              try {
+                try {
+                  render(true);
+                } catch (e) {
+                  debugLogger2.warn(
+                    `Final PTY render threw during cleanup: ${e instanceof Error ? e.message : String(e)}`
+                  );
+                }
+                try {
+                  if (isStreamingRawContent) {
+                    const finalEncoding = getCachedEncodingForBuffer(finalBuffer);
+                    const decodedOutput = new TextDecoder(finalEncoding).decode(
+                      finalBuffer
+                    );
+                    fullOutput = await replayTerminalOutput(
+                      decodedOutput,
+                      cols,
+                      rows,
+                      Terminal
+                    );
+                  } else {
+                    fullOutput = serializeTerminalToText(headlessTerminal);
+                  }
+                } catch {
+                  try {
+                    fullOutput = decodeBufferedOutput(finalBuffer);
+                  } catch {
+                  }
+                }
+                fullOutput = appendOutputCaptureLimitNotice(
+                  fullOutput,
+                  outputCaptureLimitExceeded,
+                  totalBytesReceived,
+                  maxBufferedOutputBytes
+                );
+                resolve({
+                  rawOutput: finalBuffer,
+                  output: fullOutput,
+                  exitCode,
+                  signal: signal === 0 ? null : signal ?? null,
+                  error,
+                  aborted: abortSignal.aborted,
+                  pid: ptyProcess.pid,
+                  executionMethod: ptyInfo?.name ?? "node-pty"
+                });
+              } finally {
+                disposeForegroundPtyResources();
+              }
+            }, "finalize");
+            const flushChain = /* @__PURE__ */ __name(() => processingChain.then(() => {
+            }), "flushChain");
+            const deadline = new Promise(
+              (res) => setTimeout(res, SIGKILL_TIMEOUT_MS)
+            );
+            const drain = /* @__PURE__ */ __name(() => new Promise((res) => setImmediate(res)).then(flushChain), "drain");
+            void Promise.race([
+              flushChain().then(drain).then(drain),
+              deadline
+            ]).then(() => {
+              void finalize();
+            });
+          }
+        );
+        const performBackgroundPromote = /* @__PURE__ */ __name(async () => {
+          if (!ptyProcess.pid || exited) return;
+          if (!_ShellExecutionService.isPtyActive(ptyProcess.pid)) {
+            debugLogger2.debug(
+              `Background-promote requested for PTY pid ${ptyProcess.pid} but the process is no longer alive (process.kill(pid, 0) failed); falling through to normal exit-handled resolution.`
+            );
+            return;
+          }
+          exited = true;
+          listenersDetached = true;
+          abortSignal.removeEventListener("abort", abortHandler);
+          try {
+            dataDisposable.dispose();
+          } catch (e) {
+            debugLogger2.warn(
+              `dataDisposable.dispose() threw during background-promote: ${e instanceof Error ? e.message : String(e)}`
+            );
+          }
+          try {
+            exitDisposable.dispose();
+          } catch (e) {
+            debugLogger2.warn(
+              `exitDisposable.dispose() threw during background-promote: ${e instanceof Error ? e.message : String(e)}`
+            );
+          }
+          try {
+            ptyProcess.removeListener("error", ptyErrorHandler);
+          } catch (e) {
+            debugLogger2.warn(
+              `ptyProcess.removeListener('error') threw during background-promote: ${e instanceof Error ? e.message : String(e)}`
+            );
+          }
+          if (renderTimeout) {
+            clearTimeout(renderTimeout);
+            renderTimeout = null;
+          }
+          this.activePtys.delete(ptyProcess.pid);
+          let postPromoteSettleFired = false;
+          let postPromoteDataDisposable = null;
+          let postPromoteExitDisposable = null;
+          let postPromoteErrorListener = null;
+          const disposePostPromoteListeners = /* @__PURE__ */ __name(() => {
+            if (postPromoteDataDisposable) {
+              try {
+                postPromoteDataDisposable.dispose();
+              } catch (e) {
+                debugLogger2.warn(
+                  `disposing post-promote data listener threw: ${e instanceof Error ? e.message : String(e)}`
+                );
+              }
+              postPromoteDataDisposable = null;
+            }
+            if (postPromoteExitDisposable) {
+              try {
+                postPromoteExitDisposable.dispose();
+              } catch (e) {
+                debugLogger2.warn(
+                  `disposing post-promote exit listener threw: ${e instanceof Error ? e.message : String(e)}`
+                );
+              }
+              postPromoteExitDisposable = null;
+            }
+            if (postPromoteErrorListener) {
+              try {
+                ptyProcess.removeListener("error", postPromoteErrorListener);
+              } catch (e) {
+                debugLogger2.warn(
+                  `removing post-promote error listener threw: ${e instanceof Error ? e.message : String(e)}`
+                );
+              }
+              postPromoteErrorListener = null;
+            }
+          }, "disposePostPromoteListeners");
+          const firePostSettle = /* @__PURE__ */ __name((info) => {
+            if (postPromoteSettleFired) return;
+            postPromoteSettleFired = true;
+            disposePostPromoteListeners();
+            if (os2.platform() === "win32" && _ShellExecutionService.isPtyActive(ptyProcess.pid)) {
+              windowsKillPid(ptyProcess.pid, false);
+            }
+            releaseConPtyHost(ptyProcess);
+            if (!postPromote?.onSettle) return;
+            try {
+              postPromote.onSettle(info);
+            } catch (cbErr) {
+              debugLogger2.warn(
+                `postPromote.onSettle threw: ${cbErr instanceof Error ? cbErr.message : String(cbErr)}`
+              );
+            }
+          }, "firePostSettle");
+          if (postPromote?.onData) {
+            const onPostData = postPromote.onData;
+            try {
+              postPromoteDataDisposable = ptyProcess.onData((data) => {
+                try {
+                  onPostData({ type: "data", chunk: data });
+                } catch (cbErr) {
+                  debugLogger2.warn(
+                    `postPromote.onData threw: ${cbErr instanceof Error ? cbErr.message : String(cbErr)}`
+                  );
+                }
+              });
+            } catch (e) {
+              debugLogger2.warn(
+                `re-attaching post-promote data listener threw: ${e instanceof Error ? e.message : String(e)}`
+              );
+            }
+          }
+          try {
+            postPromoteExitDisposable = ptyProcess.onExit(
+              ({ exitCode, signal }) => {
+                firePostSettle({
+                  exitCode,
+                  signal: signal === 0 ? null : signal ?? null,
+                  endTime: Date.now()
+                });
+              }
+            );
+          } catch (e) {
+            debugLogger2.warn(
+              `re-attaching post-promote exit listener threw: ${e instanceof Error ? e.message : String(e)}`
+            );
+          }
+          try {
+            postPromoteErrorListener = /* @__PURE__ */ __name((err) => {
+              if (isExpectedPtyReadExitError(err)) {
+                return;
+              }
+              firePostSettle({
+                error: err,
+                exitCode: null,
+                signal: null,
+                endTime: Date.now()
+              });
+            }, "postPromoteErrorListener");
+            ptyProcess.on("error", postPromoteErrorListener);
+          } catch (e) {
+            debugLogger2.warn(
+              `re-attaching post-promote error listener threw: ${e instanceof Error ? e.message : String(e)}`
+            );
+          }
+          const TIMEOUT_SENTINEL = Symbol("drain-timeout");
+          const drain = /* @__PURE__ */ __name(() => new Promise((res) => setImmediate(res)).then(
+            () => processingChain
+          ), "drain");
+          const winner = await Promise.race([
+            processingChain.then(drain).then(drain).catch(() => void 0),
+            new Promise(
+              (res) => setTimeout(() => res(TIMEOUT_SENTINEL), PROMOTE_DRAIN_TIMEOUT_MS)
+            )
+          ]);
+          if (winner === TIMEOUT_SENTINEL) {
+            debugLogger2.warn(
+              `Background-promote drain hit the ${PROMOTE_DRAIN_TIMEOUT_MS}ms timeout before processingChain settled. The output snapshot may be missing the very last batch of bytes the PTY emitted before promote (rawOutput in the result still has the bounded captured buffer the caller can re-render).`
+            );
+          }
+          const finalBuffer = Buffer.concat(outputChunks);
+          let snapshot = "";
+          try {
+            if (isStreamingRawContent) {
+              const finalEncoding = getCachedEncodingForBuffer(finalBuffer);
+              const decodedOutput = new TextDecoder(finalEncoding).decode(
+                finalBuffer
+              );
+              snapshot = await replayTerminalOutput(
+                decodedOutput,
+                cols,
+                rows,
+                Terminal
+              );
+            } else {
+              snapshot = serializeTerminalToText(headlessTerminal) ?? "";
+            }
+          } catch (serErr) {
+            debugLogger2.warn(
+              `Background-promote snapshot replay failed: ${serErr instanceof Error ? serErr.message : String(serErr)}. Falling back to bounded raw buffer decode; if that also fails, output stays empty.`
+            );
+            try {
+              snapshot = decodeBufferedOutput(finalBuffer);
+            } catch {
+            }
+          }
+          snapshot = appendOutputCaptureLimitNotice(
+            snapshot,
+            outputCaptureLimitExceeded,
+            totalBytesReceived,
+            maxBufferedOutputBytes
+          );
+          try {
+            resolve({
+              rawOutput: finalBuffer,
+              output: snapshot,
+              exitCode: null,
+              signal: null,
+              error,
+              // See childProcessFallback for the full rationale — promoted
+              // results are NOT user-cancellations, so callers' `if
+              // (result.aborted)` branches must NOT trigger.
+              aborted: false,
+              promoted: true,
+              pid: ptyProcess.pid,
+              executionMethod: ptyInfo?.name ?? "node-pty"
+            });
+          } finally {
+            try {
+              queryResponseDisposable?.dispose();
+            } catch (e) {
+              debugLogger2.warn(
+                `queryResponseDisposable.dispose() threw during background-promote cleanup: ${e instanceof Error ? e.message : String(e)}`
+              );
+            }
+            try {
+              headlessTerminal.dispose();
+            } catch (e) {
+              debugLogger2.warn(
+                `headlessTerminal.dispose() threw during background-promote cleanup: ${e instanceof Error ? e.message : String(e)}`
+              );
+            }
+          }
+        }, "performBackgroundPromote");
+        const performCancelKill = /* @__PURE__ */ __name(async () => {
+          if (!ptyProcess.pid || exited) return;
+          cancelKillDispatched = true;
+          if (os2.platform() === "win32") {
+            try {
+              const r = spawnSync(
+                WINDOWS_TASKKILL,
+                ["/f", "/t", "/pid", ptyProcess.pid.toString()],
+                WINDOWS_TASKKILL_OPTIONS
+              );
+              if (r.error || typeof r.status === "number" && r.status !== 0) {
+                debugLogger2.warn(
+                  `performCancelKill: taskkill failed for pid ${ptyProcess.pid}: ${r.error?.message ?? `exit ${r.status}`}`
+                );
+              }
+            } catch (e) {
+              debugLogger2.warn(
+                `performCancelKill: taskkill spawn threw for pid ${ptyProcess.pid}: ${e instanceof Error ? e.message : String(e)}`
+              );
+            }
+            try {
+              ptyProcess.kill();
+              if (ptyProcess._isReady !== false) {
+                noteConPtyHostReleased(ptyProcess);
+              }
+            } catch {
+            }
+          } else {
+            try {
+              process.kill(-ptyProcess.pid, "SIGTERM");
+              await new Promise((res) => setTimeout(res, SIGKILL_TIMEOUT_MS));
+              if (!exited) {
+                process.kill(-ptyProcess.pid, "SIGKILL");
+              }
+            } catch (_e) {
+              if (!exited) {
+                ptyProcess.kill();
+              }
+            }
+          }
+        }, "performCancelKill");
+        const abortHandler = /* @__PURE__ */ __name(async () => {
+          const kind = getShellAbortReasonKind(abortSignal.reason);
+          switch (kind) {
+            case "background":
+              await performBackgroundPromote();
+              return;
+            case "cancel":
+              await performCancelKill();
+              return;
+            default: {
+              const _exhaustive = kind;
+              await performCancelKill();
+              return _exhaustive;
+            }
+          }
+        }, "abortHandler");
+        abortSignal.addEventListener("abort", abortHandler, { once: true });
+      });
+      return {
+        pid: ptyProcess.pid,
+        result: result.catch((error) => {
+          try {
+            if (os2.platform() === "win32") ptyProcess.kill();
+            else process.kill(-ptyProcess.pid, "SIGKILL");
+          } catch {
+          }
+          this.activePtys.get(ptyProcess.pid)?.headlessTerminal.dispose();
+          this.activePtys.delete(ptyProcess.pid);
+          throw error;
+        })
+      };
+    } catch (e) {
+      const error = e;
+      if (!ptySpawned && useBundledConpty) {
+        debugLogger2.warn(
+          `Windows PTY spawn failed, falling back to child_process: ${error instanceof Error ? error.message : String(e)}`
+        );
+        throw e;
+      }
+      if (!ptySpawned && error.message.includes("posix_spawnp failed")) {
+        onOutputEvent({
+          type: "data",
+          chunk: "[WARNING] PTY execution failed, falling back to child_process. This may be due to sandbox restrictions.\n"
+        });
+        throw e;
+      } else {
+        return {
+          pid: void 0,
+          result: Promise.resolve({
+            error,
+            rawOutput: Buffer.from(""),
+            output: "",
+            exitCode: 1,
+            signal: null,
+            aborted: false,
+            pid: void 0,
+            executionMethod: "none"
+          })
+        };
+      }
+    }
+  }
+  /**
+   * Writes a string to the pseudo-terminal (PTY) of a running process.
+   *
+   * @param pid The process ID of the target PTY.
+   * @param input The string to write to the terminal.
+   */
+  static writeToPty(pid, input) {
+    if (!this.isPtyActive(pid)) {
+      return;
+    }
+    const activePty = this.activePtys.get(pid);
+    if (activePty) {
+      activePty.ptyProcess.write(input);
+    }
+  }
+  static isPtyActive(pid) {
+    try {
+      return process.kill(pid, 0);
+    } catch (_) {
+      return false;
+    }
+  }
+  /**
+   * Resizes the pseudo-terminal (PTY) of a running process.
+   *
+   * @param pid The process ID of the target PTY.
+   * @param cols The new number of columns.
+   * @param rows The new number of rows.
+   */
+  static resizePty(pid, cols, rows) {
+    if (!this.isPtyActive(pid)) {
+      return;
+    }
+    const activePty = this.activePtys.get(pid);
+    if (activePty) {
+      try {
+        activePty.ptyProcess.resize(cols, rows);
+        activePty.headlessTerminal.resize(cols, rows);
+      } catch (e) {
+        if (isExpectedPtyExitRaceError(e)) {
+        } else {
+          throw e;
+        }
+      }
+    }
+  }
+  /**
+   * Scrolls the pseudo-terminal (PTY) of a running process.
+   *
+   * @param pid The process ID of the target PTY.
+   * @param lines The number of lines to scroll.
+   */
+  static scrollPty(pid, lines) {
+    if (!this.isPtyActive(pid)) {
+      return;
+    }
+    const activePty = this.activePtys.get(pid);
+    if (activePty) {
+      try {
+        activePty.headlessTerminal.scrollLines(lines);
+        if (activePty.headlessTerminal.buffer.active.viewportY < 0) {
+          activePty.headlessTerminal.scrollToTop();
+        }
+      } catch (e) {
+        if (isExpectedPtyExitRaceError(e)) {
+        } else {
+          throw e;
+        }
+      }
+    }
+  }
+};
+
+// packages/core/src/sandbox/bwrap-status.ts
+init_esbuild_shims();
+var MAX_STATUS_BYTES = 16 * 1024;
+function sandboxStatusError(status) {
+  if (status.state === "unconfirmed") {
+    if (status.payloadExitObserved === false) {
+      return new Error(
+        "Sandbox payload did not run: setup failed before execution (bubblewrap or the payload binary may be missing)."
+      );
+    }
+    return new Error(
+      "Sandbox execution status could not be confirmed. The command may have run; do not automatically retry it."
+    );
+  }
+  if (status.state === "interrupted") {
+    return new Error("Sandbox execution was interrupted.");
+  }
+  return void 0;
+}
+__name(sandboxStatusError, "sandboxStatusError");
+
+// packages/core/src/sandbox/bwrap-execution.ts
+var debugLogger3 = createDebugLogger("BWRAP_EXECUTION");
+function sandboxAsset(name) {
+  const sibling = path2.join(
+    path2.dirname(fileURLToPath(import.meta.url)),
+    `${name}.js`
+  );
+  const bundled = path2.join(
+    resolveBundleDir(import.meta.url),
+    name === "bwrap-relay" ? "sandboxBwrapRelay.js" : "sandboxFileWorker.js"
+  );
+  const asset = existsSync(sibling) ? sibling : bundled;
+  if (!existsSync(asset))
+    throw new Error(
+      "Sandbox assets are missing. Run the build and bundle first."
+    );
+  return realpathSync(asset);
+}
+__name(sandboxAsset, "sandboxAsset");
+var overlaps = /* @__PURE__ */ __name((a, b) => isSubpath(a, b) || isSubpath(b, a), "overlaps");
+var directory = /* @__PURE__ */ __name((value) => {
+  if (!path2.isAbsolute(value))
+    throw new Error("Sandbox paths must be absolute.");
+  const resolved = realpathSync(value);
+  if (!statSync2(resolved).isDirectory())
+    throw new Error("Expected sandbox directory.");
+  return resolved;
+}, "directory");
+async function executeBwrap(policy, payload, onOutput, signal, usePty = false, config = {}, options = {}) {
+  if (process.platform !== "linux")
+    throw new Error("bwrap execution requires Linux.");
+  if (!["read-only", "workspace-write"].includes(policy.filesystem) || !["open", "closed"].includes(policy.network)) {
+    throw new Error("Unsupported sandbox policy.");
+  }
+  if (!path2.isAbsolute(payload.executable) || !path2.isAbsolute(payload.cwd))
+    throw new Error("Payload paths must be absolute.");
+  if (usePty && payload.stdin !== void 0)
+    throw new Error("Process stdin requires pipe execution.");
+  const workspace = directory(policy.workspace);
+  const state = directory(policy.state);
+  const relay = sandboxAsset("bwrap-relay");
+  const node = realpathSync(process.execPath);
+  const requestedBwrap = policy.bwrapPath ?? "/usr/bin/bwrap";
+  if (!path2.isAbsolute(requestedBwrap))
+    throw new Error("bwrap path must be absolute.");
+  const bwrap = existsSync(requestedBwrap) ? realpathSync(requestedBwrap) : requestedBwrap;
+  const protectedRoots = [
+    directory(policy.installation),
+    state,
+    path2.dirname(relay),
+    path2.dirname(node),
+    path2.dirname(bwrap),
+    ...[
+      "/proc",
+      "/dev",
+      "/sys",
+      "/etc",
+      "/usr",
+      "/bin",
+      "/sbin",
+      "/lib",
+      "/lib64"
+    ].filter(existsSync).map((value) => realpathSync(value))
+  ];
+  const checkWritable = /* @__PURE__ */ __name((root) => {
+    if (isSubpath(root, realpathSync(os3.homedir())) || protectedRoots.some((protectedRoot) => overlaps(root, protectedRoot))) {
+      throw new Error("Writable directory overlaps a protected root.");
+    }
+  }, "checkWritable");
+  checkWritable(workspace);
+  const maskedPaths = (policy.maskedPaths ?? []).map((value) => {
+    if (!path2.isAbsolute(value))
+      throw new Error("Sandbox mask paths must be absolute.");
+    const resolved = realpathNearestExisting(value);
+    if (resolved === workspace || !isSubpath(workspace, resolved))
+      throw new Error("Sandbox mask paths must remain inside the workspace.");
+    return resolved;
+  });
+  const cwd = directory(payload.cwd);
+  if (!isSubpath(workspace, cwd))
+    throw new Error("Payload cwd must be inside the workspace.");
+  const executable = payload.executable;
+  const args = [...payload.args];
+  const env = Object.fromEntries(
+    Object.entries(payload.env).filter(([key]) => !isInternalSecretEnvVar(key))
+  );
+  const stdin = Buffer.isBuffer(payload.stdin) ? Buffer.from(payload.stdin) : payload.stdin;
+  const filesystem = policy.filesystem;
+  const network = policy.network;
+  const control = await mkdtemp(path2.join(state, "sandbox-control-"));
+  let scratch;
+  const cleanup = /* @__PURE__ */ __name(async () => {
+    const results = await Promise.allSettled([
+      rm(control, { recursive: true, force: true }),
+      ...scratch ? [rm(scratch, { recursive: true, force: true })] : []
+    ]);
+    for (const result of results) {
+      if (result.status === "rejected")
+        debugLogger3.warn(
+          "Sandbox temporary directory cleanup failed",
+          result.reason
+        );
+    }
+  }, "cleanup");
+  try {
+    const requestedScratchRoot = os3.tmpdir();
+    const scratchRoot = path2.isAbsolute(requestedScratchRoot) && existsSync(requestedScratchRoot) ? realpathSync(requestedScratchRoot) : realpathSync("/tmp");
+    if (isSubpath(workspace, scratchRoot) || protectedRoots.some(
+      (protectedRoot) => isSubpath(protectedRoot, scratchRoot)
+    ))
+      throw new Error(
+        `Temporary root ${scratchRoot} overlaps the workspace or a protected root.`
+      );
+    scratch = await mkdtemp(path2.join(scratchRoot, "qwen-sandbox-"));
+    scratch = directory(scratch);
+    checkWritable(scratch);
+    if (overlaps(workspace, scratch))
+      throw new Error("Workspace and scratch must be disjoint.");
+    const payloadEnv = {
+      ...env,
+      PWD: cwd,
+      TMPDIR: scratch,
+      TMP: scratch,
+      TEMP: scratch,
+      TERM: env["TERM"] || "xterm-256color"
+    };
+    for (const [key, value] of Object.entries(payloadEnv)) {
+      if (!key || key.includes("=") || key.includes("\0") || value.includes("\0"))
+        throw new Error("Invalid payload environment.");
+    }
+    const payloadEnvPath = path2.join(control, "payload-env.json");
+    await writeFile(payloadEnvPath, JSON.stringify(payloadEnv), {
+      encoding: "utf8",
+      flag: "wx",
+      mode: 384
+    });
+    const bwrapArgs = [
+      "--ro-bind",
+      "/",
+      "/",
+      "--unshare-pid",
+      "--proc",
+      "/proc",
+      "--dev",
+      "/dev",
+      "--die-with-parent"
+    ];
+    bwrapArgs.push("--bind", scratch, scratch);
+    if (filesystem === "workspace-write")
+      bwrapArgs.push("--bind", workspace, workspace);
+    for (const maskedPath of maskedPaths) {
+      if (!existsSync(maskedPath)) {
+        if (filesystem === "read-only") continue;
+        mkdirSync(maskedPath, { recursive: true });
+      }
+      if (!statSync2(maskedPath).isDirectory())
+        throw new Error("Sandbox mask paths must be directories.");
+      bwrapArgs.push("--tmpfs", maskedPath);
+    }
+    if (network === "closed") bwrapArgs.push("--unshare-net");
+    bwrapArgs.push("--chdir", cwd, "--", executable, ...args);
+    const statusPath = path2.join(control, "status.json");
+    let complete;
+    const settled = new Promise((resolve) => {
+      complete = resolve;
+    });
+    let finalizing;
+    const finalize = /* @__PURE__ */ __name((info) => finalizing ??= (async () => {
+      let status = { state: "unconfirmed" };
+      let receiptExisted = false;
+      let receiptParsed = false;
+      if (info.aborted || isSignalTermination(info.signal))
+        status = { state: "interrupted" };
+      else {
+        try {
+          const text = await readFile(statusPath, "utf8");
+          receiptExisted = true;
+          const record = JSON.parse(text);
+          receiptParsed = true;
+          if (!info.error && record["state"] === "confirmed" && record["exitCode"] === info.exitCode && typeof record["exitCode"] === "number" && Number.isInteger(record["exitCode"]) && record["exitCode"] >= 0 && record["exitCode"] <= 255)
+            status = { state: "confirmed", exitCode: record["exitCode"] };
+          else if (record["state"] === "interrupted")
+            status = { state: "interrupted" };
+          else {
+            const attested = record["payloadExitObserved"];
+            status = {
+              state: "unconfirmed",
+              ...typeof attested === "boolean" ? { payloadExitObserved: attested } : {}
+            };
+          }
+        } catch {
+        }
+      }
+      const attestedNoExec = receiptExisted && receiptParsed && status.state === "unconfirmed" && status.payloadExitObserved === false;
+      const relayDiedBeforeSpawn = !receiptExisted;
+      const retain = status.state === "unconfirmed" && !attestedNoExec && !relayDiedBeforeSpawn;
+      if (retain) {
+        debugLogger3.warn(
+          "Sandbox termination is unconfirmed; retaining temporary directories",
+          { control, scratch }
+        );
+      } else {
+        await cleanup();
+      }
+      complete(status);
+      return status;
+    })(), "finalize");
+    const handle = await ShellExecutionService.executeLaunch(
+      {
+        executable: node,
+        args: [
+          relay,
+          String(process.pid),
+          statusPath,
+          payloadEnvPath,
+          bwrap,
+          ...bwrapArgs
+        ],
+        cwd,
+        env: {
+          PATH: "/usr/bin:/bin",
+          LANG: "C.UTF-8",
+          TERM: env["TERM"] || "xterm-256color",
+          PWD: cwd
+        },
+        stdin
+      },
+      onOutput,
+      signal,
+      usePty,
+      config,
+      {
+        ...options,
+        postPromote: {
+          onData: options.postPromote?.onData,
+          onSettle: /* @__PURE__ */ __name((info) => {
+            void finalize(info).then((status) => {
+              const error = info.error ?? sandboxStatusError(status);
+              options.postPromote?.onSettle?.({ ...info, error });
+            }).catch((settleError) => {
+              debugLogger3.warn(
+                `post-promote settle chain failed: ${settleError instanceof Error ? settleError.message : String(settleError)}`
+              );
+            });
+          }, "onSettle")
+        }
+      }
+    );
+    return {
+      pid: handle.pid,
+      settled,
+      result: handle.result.then(
+        async (result) => {
+          const sandboxStatus = result.promoted ? { state: "running" } : await finalize(result);
+          return {
+            ...result,
+            error: result.error ?? sandboxStatusError(sandboxStatus) ?? null,
+            sandboxStatus
+          };
+        },
+        async (error) => {
+          await finalize({ signal: null, exitCode: null, error });
+          throw error;
+        }
+      )
+    };
+  } catch (error) {
+    await cleanup();
+    throw error;
+  }
+}
+__name(executeBwrap, "executeBwrap");
+
+export {
+  loadPty,
+  loadXtermHeadless,
+  normalizePathEnvForWindows,
+  isUnusableScriptEntry,
+  getShellContextEnvVars,
+  noteConPtyHostReleased,
+  disposeConoutWorker,
+  releaseConPtyHost,
+  getShellPagerEnv,
+  getShellAbortReasonKind,
+  isSignalTermination,
+  ShellExecutionService,
+  sandboxAsset,
+  executeBwrap
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */