@qwen-code/qwen-code 0.23.0 → 0.23.1-preview.1

package/chunks/{chunk-JUARRUMA.js → chunk-UEZOXZNI.js}

@@ -2,14 +2,17 @@
 "use strict";
 import {
   MAX_FRAME_BYTES,
+  MAX_SOCKET_PATH_BYTES,
+  SOCKET_DIR_NAME,
   isLocalIpcPath,
   parsePeerAuthLine,
   parsePeerFrame,
-  resolvePeerSocketPath
-} from "./chunk-4UANMABT.js";
+  probePeerSocketVerdict,
+  resolvePeerSocketCandidates
+} from "./chunk-HFTB354P.js";
 import {
   scanForSecrets
-} from "./chunk-UKYXYWI2.js";
+} from "./chunk-BUQN5LTI.js";
 import {
   BudgetExhaustedError,
   CoreToolScheduler,
@@ -47,6 +50,7 @@ import {
   getPty,
   getTimeRangeBounds,
   isAllowedMemoryPath,
+  isClearedMediaPlaceholder,
   isPoolable,
   listDescendantPids,
   listExistingSkillDirNames,
@@ -70,7 +74,7 @@ import {
   stripToolResultImages,
   toolResultBoundaryArtifact,
   toolResultPartDiagnosticValues
-} from "./chunk-4F7GQGXB.js";
+} from "./chunk-I72PHOKL.js";
 import {
   hasVerifiableInode,
   openNoFollow
@@ -80,36 +84,46 @@ import {
 } from "./chunk-TWPJO254.js";
 import {
   projectUserTranscriptForDisplay
-} from "./chunk-EFTPIZIC.js";
+} from "./chunk-FDOGGKAA.js";
+import {
+  resolveBundleDir
+} from "./chunk-PZV2FASB.js";
 import {
   glob,
   globSync
 } from "./chunk-QJNDUTOL.js";
-import {
-  getProjectSkillsRoot
-} from "./chunk-H43PSPYS.js";
-import {
-  resolveBundleDir
-} from "./chunk-VYIUNFEA.js";
 import {
   escapeJsonTagCharacters
 } from "./chunk-CHEIIBT3.js";
+import {
+  isPidAlive
+} from "./chunk-BF3RUIVP.js";
+import {
+  getProjectSkillsRoot,
+  parse
+} from "./chunk-R355CUNQ.js";
 import {
   require_proper_lockfile
 } from "./chunk-MLXTMF7H.js";
+import {
+  BUILT_IN_OUTPUT_STYLES,
+  getBuiltInOutputStyle
+} from "./chunk-GXZHYPHZ.js";
 import {
   fetchWithPolicy
-} from "./chunk-KFN2IZYR.js";
+} from "./chunk-UKADFFL2.js";
 import {
   COMBINED_PASS_TOLERANCE_FACTOR,
   TOOL_OUTPUT_TRUNCATED_PREFIX,
   TRUNCATION_FALLBACK_ENVELOPE_SLACK,
   addMCPStatusChangeListener,
-  getInvocationContext,
   removeMCPStatusChangeListener,
   runSideQuery,
   updateMCPServerStatus
-} from "./chunk-GH2S4GD5.js";
+} from "./chunk-P5LDR7FI.js";
+import {
+  getInvocationContext
+} from "./chunk-5ETULJLP.js";
 import {
   E_TIMEOUT,
   Mutex,
@@ -122,38 +136,46 @@ import {
   detectFileType,
   getCurrentMemoryFilename,
   isCacheableReadResult,
+  isWithinRoot,
   processSingleFileContent
-} from "./chunk-DYTW3QVG.js";
+} from "./chunk-J6MB5ZHZ.js";
 import {
   getAutoMemoryRoot,
   getUserAutoMemoryRoot
-} from "./chunk-HT5S5TRQ.js";
+} from "./chunk-EDIDYZBT.js";
 import {
   atomicWriteFile
-} from "./chunk-KHP66DFN.js";
+} from "./chunk-XFFRI3WM.js";
+import {
+  isBinary,
+  normalizeContent,
+  stripAnsiAndControl,
+  stripHtmlComments
+} from "./chunk-7VEYUF3N.js";
 import {
   getFolderStructure,
   getStartupContextLength,
   isSystemReminderContent,
   stripSystemReminderBlocks
-} from "./chunk-G7HBEEX7.js";
+} from "./chunk-D6PIMKY3.js";
 import {
   getQwenIgnoreFileNames,
   require_ignore
-} from "./chunk-ODZF64DM.js";
+} from "./chunk-IZ2U57NY.js";
 import {
   ToolNames,
   canonicalToolName
-} from "./chunk-7JMGTOH7.js";
+} from "./chunk-RPBMP6BN.js";
 import {
   PATH_ARG_KEYS,
+  QWEN_DIR,
   Storage,
   createDebugLogger,
   getErrorMessage,
   isAbortError,
   tildeifyPath,
   unescapePath
-} from "./chunk-EAHOJF6V.js";
+} from "./chunk-ZAFYHRVY.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -172,8 +194,8 @@ var require_utils = __commonJS({
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.normalizePath = exports.isRootDirectory = exports.convertSlashes = exports.cleanPath = void 0;
     var path_1 = __require("path");
-    function cleanPath(path19) {
-      let normalized2 = (0, path_1.normalize)(path19);
+    function cleanPath(path20) {
+      let normalized2 = (0, path_1.normalize)(path20);
       if (normalized2.length > 1 && normalized2[normalized2.length - 1] === path_1.sep)
         normalized2 = normalized2.substring(0, normalized2.length - 1);
       return normalized2;
@@ -181,28 +203,28 @@ var require_utils = __commonJS({
     __name(cleanPath, "cleanPath");
     exports.cleanPath = cleanPath;
     var SLASHES_REGEX = /[\\/]/g;
-    function convertSlashes(path19, separator) {
-      return path19.replace(SLASHES_REGEX, separator);
+    function convertSlashes(path20, separator) {
+      return path20.replace(SLASHES_REGEX, separator);
     }
     __name(convertSlashes, "convertSlashes");
     exports.convertSlashes = convertSlashes;
     var WINDOWS_ROOT_DIR_REGEX = /^[a-z]:[\\/]$/i;
-    function isRootDirectory(path19) {
-      return path19 === "/" || WINDOWS_ROOT_DIR_REGEX.test(path19);
+    function isRootDirectory(path20) {
+      return path20 === "/" || WINDOWS_ROOT_DIR_REGEX.test(path20);
     }
     __name(isRootDirectory, "isRootDirectory");
     exports.isRootDirectory = isRootDirectory;
-    function normalizePath2(path19, options) {
+    function normalizePath2(path20, options) {
       const { resolvePaths, normalizePath: normalizePath3, pathSeparator } = options;
-      const pathNeedsCleaning = process.platform === "win32" && path19.includes("/") || path19.startsWith(".");
+      const pathNeedsCleaning = process.platform === "win32" && path20.includes("/") || path20.startsWith(".");
       if (resolvePaths)
-        path19 = (0, path_1.resolve)(path19);
+        path20 = (0, path_1.resolve)(path20);
       if (normalizePath3 || pathNeedsCleaning)
-        path19 = cleanPath(path19);
-      if (path19 === ".")
+        path20 = cleanPath(path20);
+      if (path20 === ".")
         return "";
-      const needsSeperator = path19[path19.length - 1] !== pathSeparator;
-      return convertSlashes(needsSeperator ? path19 + pathSeparator : path19, pathSeparator);
+      const needsSeperator = path20[path20.length - 1] !== pathSeparator;
+      return convertSlashes(needsSeperator ? path20 + pathSeparator : path20, pathSeparator);
     }
     __name(normalizePath2, "normalizePath");
     exports.normalizePath = normalizePath2;
@@ -277,9 +299,9 @@ var require_push_directory = __commonJS({
       paths.push(directoryPath || ".");
     }, "pushDirectory");
     var pushDirectoryFilter = /* @__PURE__ */ __name((directoryPath, paths, filters) => {
-      const path19 = directoryPath || ".";
-      if (filters.every((filter2) => filter2(path19, true))) {
-        paths.push(path19);
+      const path20 = directoryPath || ".";
+      if (filters.every((filter2) => filter2(path20, true))) {
+        paths.push(path20);
       }
     }, "pushDirectoryFilter");
     var empty = /* @__PURE__ */ __name(() => {
@@ -390,31 +412,31 @@ var require_resolve_symlink = __commonJS({
     exports.build = void 0;
     var fs_1 = __importDefault(__require("fs"));
     var path_1 = __require("path");
-    var resolveSymlinksAsync = /* @__PURE__ */ __name(function(path19, state, callback) {
+    var resolveSymlinksAsync = /* @__PURE__ */ __name(function(path20, state, callback) {
       const { queue, options: { suppressErrors } } = state;
       queue.enqueue();
-      fs_1.default.realpath(path19, (error, resolvedPath) => {
+      fs_1.default.realpath(path20, (error, resolvedPath) => {
         if (error)
           return queue.dequeue(suppressErrors ? null : error, state);
-        fs_1.default.stat(resolvedPath, (error2, stat4) => {
+        fs_1.default.stat(resolvedPath, (error2, stat5) => {
           if (error2)
             return queue.dequeue(suppressErrors ? null : error2, state);
-          if (stat4.isDirectory() && isRecursive(path19, resolvedPath, state))
+          if (stat5.isDirectory() && isRecursive(path20, resolvedPath, state))
             return queue.dequeue(null, state);
-          callback(stat4, resolvedPath);
+          callback(stat5, resolvedPath);
           queue.dequeue(null, state);
         });
       });
     }, "resolveSymlinksAsync");
-    var resolveSymlinks = /* @__PURE__ */ __name(function(path19, state, callback) {
+    var resolveSymlinks = /* @__PURE__ */ __name(function(path20, state, callback) {
       const { queue, options: { suppressErrors } } = state;
       queue.enqueue();
       try {
-        const resolvedPath = fs_1.default.realpathSync(path19);
-        const stat4 = fs_1.default.statSync(resolvedPath);
-        if (stat4.isDirectory() && isRecursive(path19, resolvedPath, state))
+        const resolvedPath = fs_1.default.realpathSync(path20);
+        const stat5 = fs_1.default.statSync(resolvedPath);
+        if (stat5.isDirectory() && isRecursive(path20, resolvedPath, state))
           return;
-        callback(stat4, resolvedPath);
+        callback(stat5, resolvedPath);
       } catch (e) {
         if (!suppressErrors)
           throw e;
@@ -427,10 +449,10 @@ var require_resolve_symlink = __commonJS({
     }
     __name(build, "build");
     exports.build = build;
-    function isRecursive(path19, resolved, state) {
+    function isRecursive(path20, resolved, state) {
       if (state.options.useRealPaths)
         return isRecursiveUsingRealPaths(resolved, state);
-      let parent = (0, path_1.dirname)(path19);
+      let parent = (0, path_1.dirname)(path20);
       let depth = 1;
       while (parent !== state.root && depth < 2) {
         const resolvedPath = state.symlinks.get(parent);
@@ -440,7 +462,7 @@ var require_resolve_symlink = __commonJS({
         else
           parent = (0, path_1.dirname)(parent);
       }
-      state.symlinks.set(path19, resolved);
+      state.symlinks.set(path20, resolved);
       return depth > 1;
     }
     __name(isRecursive, "isRecursive");
@@ -726,21 +748,21 @@ var require_walker = __commonJS({
             const filename = this.joinPath(entry.name, directoryPath);
             this.pushFile(filename, files, this.state.counts, filters);
           } else if (entry.isDirectory()) {
-            let path19 = joinPath.joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
-            if (exclude && exclude(entry.name, path19))
+            let path20 = joinPath.joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
+            if (exclude && exclude(entry.name, path20))
               continue;
-            this.pushDirectory(path19, paths, filters);
-            this.walkDirectory(this.state, path19, path19, depth - 1, this.walk);
+            this.pushDirectory(path20, paths, filters);
+            this.walkDirectory(this.state, path20, path20, depth - 1, this.walk);
           } else if (this.resolveSymlink && entry.isSymbolicLink()) {
-            let path19 = joinPath.joinPathWithBasePath(entry.name, directoryPath);
-            this.resolveSymlink(path19, this.state, (stat4, resolvedPath) => {
-              if (stat4.isDirectory()) {
+            let path20 = joinPath.joinPathWithBasePath(entry.name, directoryPath);
+            this.resolveSymlink(path20, this.state, (stat5, resolvedPath) => {
+              if (stat5.isDirectory()) {
                 resolvedPath = (0, utils_1.normalizePath)(resolvedPath, this.state.options);
-                if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path19 + pathSeparator))
+                if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path20 + pathSeparator))
                   return;
-                this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path19 + pathSeparator, depth - 1, this.walk);
+                this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path20 + pathSeparator, depth - 1, this.walk);
               } else {
-                resolvedPath = useRealPaths ? resolvedPath : path19;
+                resolvedPath = useRealPaths ? resolvedPath : path20;
                 const filename = (0, path_1.basename)(resolvedPath);
                 const directoryPath2 = (0, utils_1.normalizePath)((0, path_1.dirname)(resolvedPath), this.state.options);
                 resolvedPath = this.joinPath(filename, directoryPath2);
@@ -765,11 +787,11 @@ var require_async = __commonJS({
     exports.callback = exports.promise = void 0;
     var walker_1 = require_walker();
     function promise(root, options) {
-      return new Promise((resolve5, reject) => {
+      return new Promise((resolve6, reject) => {
         callback(root, options, (err, output) => {
           if (err)
             return reject(err);
-          resolve5(output);
+          resolve6(output);
         });
       });
     }
@@ -967,7 +989,7 @@ var require_builder = __commonJS({
           isMatch = globFn(patterns, ...options);
           this.globCache[patterns.join("\0")] = isMatch;
         }
-        this.options.filters.push((path19) => isMatch(path19));
+        this.options.filters.push((path20) => isMatch(path20));
         return this;
       }
     };
@@ -1047,7 +1069,7 @@ var JsonFormatter = class {
 // packages/core/src/core/nonInteractiveToolExecutor.ts
 init_esbuild_shims();
 async function executeToolCall(config, toolCallRequest, abortSignal, options = {}) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     new CoreToolScheduler({
       config,
       chatRecordingService: options.recordToolResult === false ? void 0 : config.getChatRecordingService(),
@@ -1056,7 +1078,7 @@ async function executeToolCall(config, toolCallRequest, abortSignal, options = {
         if (options.onAllToolCallsComplete) {
           await options.onAllToolCallsComplete(completedToolCalls);
         }
-        resolve5(completedToolCalls[0].response);
+        resolve6(completedToolCalls[0].response);
       }, "onAllToolCallsComplete"),
       onToolCallsUpdate: options.onToolCallsUpdate,
       onToolResultFullTurnModel: options.onToolResultFullTurnModel,
@@ -2550,7 +2572,7 @@ var McpTransportPool = class {
         spawnWait.then(() => {
           if (inflightTimer) clearTimeout(inflightTimer);
         }),
-        new Promise((resolve5) => {
+        new Promise((resolve6) => {
           inflightTimer = setTimeout(
             () => {
               const stuckIds = [...this.spawnInFlight.keys()];
@@ -2559,7 +2581,7 @@ var McpTransportPool = class {
                   ", "
                 )}. Proceeding with drain.`
               );
-              resolve5();
+              resolve6();
             },
             Math.max(0, deadline - Date.now())
           );
@@ -2585,8 +2607,8 @@ var McpTransportPool = class {
       Promise.all(shutdownPromises).then(() => {
         if (drainTimer) clearTimeout(drainTimer);
       }),
-      new Promise((resolve5) => {
-        drainTimer = setTimeout(() => resolve5(), remaining);
+      new Promise((resolve6) => {
+        drainTimer = setTimeout(() => resolve6(), remaining);
         drainTimer.unref?.();
       })
     ]);
@@ -4572,6 +4594,552 @@ function takeRecentDialog(history, windowSize) {
 }
 __name(takeRecentDialog, "takeRecentDialog");
 
+// packages/core/src/ipc/uds-inbox.ts
+init_esbuild_shims();
+import { randomBytes, timingSafeEqual } from "node:crypto";
+import * as fsSync from "node:fs";
+import * as fs from "node:fs/promises";
+import * as net from "node:net";
+import * as path from "node:path";
+var debugLogger6 = createDebugLogger("PEER_IPC");
+var SOCKET_DIR_MODE = 448;
+var SOCKET_MODE = 384;
+var EMPTY_FALLBACK_DIR_GRACE_MS = 6e4;
+var SWEEP_BATCH_SIZE = 16;
+var MAX_PEER_CONNECTIONS = 64;
+var LINE_DEADLINE_MS = 3e4;
+var lastStartFailure = null;
+function getLastPeerInboxFailure() {
+  return lastStartFailure;
+}
+__name(getLastPeerInboxFailure, "getLastPeerInboxFailure");
+function describePeerInboxFailure(failure) {
+  const where = path.dirname(failure.socketPath);
+  const attempts = failure.attempts > 1 ? ` Tried ${failure.attempts} candidate paths.` : "";
+  switch (failure.cause) {
+    case "non_local":
+      return `the socket path "${failure.socketPath}" is not an absolute local path. ${failure.hint}${attempts}`;
+    case "unsupported_platform":
+      return `cross-session messaging is not available on this platform. ${failure.hint}${attempts}`;
+    case "not_directory":
+      return `"${where}" could not be created or is not a plain directory (${failure.detail}). ${failure.hint}${attempts}`;
+    case "foreign_owner":
+      return `"${where}" belongs to another user. ${failure.hint}${attempts}`;
+    case "permission":
+      return `this user cannot create or lock down "${where}" (${failure.detail}). ${failure.hint}${attempts}`;
+    case "missing_ancestor":
+      return `a parent of "${where}" does not exist. ${failure.hint}${attempts}`;
+    case "path_too_long":
+      return `"${failure.socketPath}" is longer than the ${MAX_SOCKET_PATH_BYTES}-byte socket path limit. ${failure.hint}${attempts}`;
+    case "sibling_too_long":
+      return `the socket path "${failure.socketPath}" is in use or could not be verified free, and the alternative name needed to work around it would exceed the ${MAX_SOCKET_PATH_BYTES}-byte socket path limit. ${failure.hint}${attempts}`;
+    case "bind_failed":
+      return `the socket could not be bound at "${failure.socketPath}" (${failure.detail}). ${failure.hint}${attempts}`;
+    case "chmod_failed":
+      return `the socket at "${failure.socketPath}" could not be restricted to this user (${failure.detail}). ${failure.hint}${attempts}`;
+    default:
+      return `${failure.detail} (at "${failure.socketPath}"). ${failure.hint}${attempts}`;
+  }
+}
+__name(describePeerInboxFailure, "describePeerInboxFailure");
+var HINT_RUNTIME_DIR = "Set XDG_RUNTIME_DIR (or TMPDIR) to a directory you own, then restart.";
+var InboxSetupError = class extends Error {
+  constructor(failureCause, message, hint = HINT_RUNTIME_DIR) {
+    super(message);
+    this.failureCause = failureCause;
+    this.hint = hint;
+    this.name = "InboxSetupError";
+  }
+  static {
+    __name(this, "InboxSetupError");
+  }
+};
+function classify(error, socketPath) {
+  if (error instanceof InboxSetupError) {
+    return {
+      cause: error.failureCause,
+      socketPath,
+      detail: error.message,
+      hint: error.hint,
+      attempts: 1
+    };
+  }
+  const code = error?.code;
+  const detail = describe(error);
+  const base = { socketPath, detail, attempts: 1 };
+  switch (code) {
+    case "EACCES":
+    case "EPERM":
+    case "EROFS":
+      return { ...base, cause: "permission", hint: HINT_RUNTIME_DIR };
+    case "ENOENT":
+      return { ...base, cause: "missing_ancestor", hint: HINT_RUNTIME_DIR };
+    // mkdir(recursive) reports a file in the way as EEXIST, not ENOTDIR.
+    case "EEXIST":
+    case "ENOTDIR":
+    case "ELOOP":
+      return {
+        ...base,
+        cause: "not_directory",
+        hint: "Remove it, or set XDG_RUNTIME_DIR to a directory you own, then restart."
+      };
+    case "ENAMETOOLONG":
+      return {
+        ...base,
+        cause: "path_too_long",
+        hint: "Set XDG_RUNTIME_DIR or TMPDIR to a shorter directory, then restart."
+      };
+    default:
+      return { ...base, cause: "unknown", hint: HINT_RUNTIME_DIR };
+  }
+}
+__name(classify, "classify");
+async function classifyMkdirFailure(error, socketPath, socketDir) {
+  if (error?.code === "ENOENT") {
+    try {
+      await fs.lstat(path.dirname(socketDir));
+      return classify(
+        new InboxSetupError("permission", describe(error)),
+        socketPath
+      );
+    } catch {
+    }
+  }
+  return classify(error, socketPath);
+}
+__name(classifyMkdirFailure, "classifyMkdirFailure");
+var SOCKET_FILENAME = /^\d+(-[0-9a-f]{8})?\.sock$/;
+function pidOfSocketFilename(name) {
+  if (!SOCKET_FILENAME.test(name)) return null;
+  const pid = Number.parseInt(name.split(/[-.]/)[0], 10);
+  return Number.isInteger(pid) && pid > 0 ? pid : null;
+}
+__name(pidOfSocketFilename, "pidOfSocketFilename");
+function siblingOverflowFailure(socketPath) {
+  return classify(
+    new InboxSetupError(
+      "sibling_too_long",
+      `${socketPath} is in use or could not be verified free and a sibling name would exceed sun_path`,
+      "Set XDG_RUNTIME_DIR or TMPDIR to a shorter directory, then restart."
+    ),
+    socketPath
+  );
+}
+__name(siblingOverflowFailure, "siblingOverflowFailure");
+function siblingSocketPath(socketPath) {
+  const dir = path.dirname(socketPath);
+  const base = path.basename(socketPath, ".sock").split("-")[0];
+  const sibling = path.join(
+    dir,
+    `${base}-${randomBytes(4).toString("hex")}.sock`
+  );
+  return Buffer.byteLength(sibling) <= MAX_SOCKET_PATH_BYTES ? sibling : null;
+}
+__name(siblingSocketPath, "siblingSocketPath");
+var NONCE_DIRNAME = new RegExp(`^${SOCKET_DIR_NAME}-[0-9a-f]{16}$`);
+function createLineReader(onLine, onOverflow) {
+  let buffer = "";
+  return (chunk) => {
+    buffer += chunk;
+    let newline = buffer.indexOf("\n");
+    while (newline !== -1) {
+      const line = buffer.slice(0, newline);
+      buffer = buffer.slice(newline + 1);
+      if (line.trim().length > 0) onLine(line);
+      newline = buffer.indexOf("\n");
+    }
+    if (buffer.length > MAX_FRAME_BYTES) {
+      buffer = "";
+      onOverflow();
+    }
+  };
+}
+__name(createLineReader, "createLineReader");
+async function sweepOrphanSockets(dir, selfSocketPath) {
+  let entries;
+  try {
+    entries = await fs.readdir(dir);
+  } catch {
+    return 0;
+  }
+  let swept = 0;
+  for (let offset = 0; offset < entries.length; offset += SWEEP_BATCH_SIZE) {
+    await Promise.all(
+      entries.slice(offset, offset + SWEEP_BATCH_SIZE).map(async (name) => {
+        const pid = pidOfSocketFilename(name);
+        if (pid === null) return;
+        const fullPath = path.join(dir, name);
+        if (fullPath === selfSocketPath) return;
+        if (isPidAlive(pid)) return;
+        if (await probePeerSocketVerdict(fullPath) !== "dead") return;
+        if (isPidAlive(pid)) return;
+        try {
+          await fs.unlink(fullPath);
+          swept += 1;
+        } catch {
+        }
+      })
+    );
+  }
+  if (swept > 0) {
+    debugLogger6.debug(`swept ${swept} orphaned peer socket(s) from ${dir}`);
+  }
+  return swept;
+}
+__name(sweepOrphanSockets, "sweepOrphanSockets");
+async function sweepOrphanSocketDirs(parent, selfDir) {
+  let entries;
+  try {
+    entries = await fs.readdir(parent);
+  } catch {
+    return 0;
+  }
+  const uid = typeof process.getuid === "function" ? process.getuid() : null;
+  let swept = 0;
+  for (let offset = 0; offset < entries.length; offset += SWEEP_BATCH_SIZE) {
+    await Promise.all(
+      entries.slice(offset, offset + SWEEP_BATCH_SIZE).map(async (name) => {
+        if (!NONCE_DIRNAME.test(name)) return;
+        const dir = path.join(parent, name);
+        if (dir === selfDir) return;
+        try {
+          const stat5 = await fs.lstat(dir);
+          if (!stat5.isDirectory()) return;
+          if (uid !== null && stat5.uid !== uid) return;
+          const files = await fs.readdir(dir);
+          if (files.length === 0 && Date.now() - stat5.mtimeMs < EMPTY_FALLBACK_DIR_GRACE_MS) {
+            return;
+          }
+          for (const file of files) {
+            const pid = pidOfSocketFilename(file);
+            if (pid === null || isPidAlive(pid)) return;
+            if (await probePeerSocketVerdict(path.join(dir, file)) !== "dead")
+              return;
+          }
+          for (const file of files) {
+            const pid = pidOfSocketFilename(file);
+            if (pid === null || isPidAlive(pid)) return;
+          }
+          for (const file of files) await fs.unlink(path.join(dir, file));
+          await fs.rmdir(dir);
+          swept += 1;
+        } catch {
+        }
+      })
+    );
+  }
+  if (swept > 0) {
+    debugLogger6.debug(
+      `swept ${swept} orphaned peer socket director${swept === 1 ? "y" : "ies"} from ${parent}`
+    );
+  }
+  return swept;
+}
+__name(sweepOrphanSocketDirs, "sweepOrphanSocketDirs");
+function sweepAround(socketPath) {
+  const dir = path.dirname(socketPath);
+  const base = path.basename(dir);
+  if (base === SOCKET_DIR_NAME) return sweepOrphanSockets(dir, socketPath);
+  if (NONCE_DIRNAME.test(base)) {
+    return sweepOrphanSocketDirs(path.dirname(dir), dir);
+  }
+  return Promise.resolve(0);
+}
+__name(sweepAround, "sweepAround");
+async function startPeerInbox(options) {
+  const candidates = options.socketPath !== void 0 ? [options.socketPath] : resolvePeerSocketCandidates();
+  let failure = null;
+  for (const [index, candidate] of candidates.entries()) {
+    const result = await bindAt(
+      candidate,
+      options,
+      options.socketPath === void 0
+    );
+    if ("inbox" in result) {
+      lastStartFailure = null;
+      if (index > 0) {
+        debugLogger6.warn(
+          `peer inbox bound at fallback path ${candidate} after ${index} unusable candidate(s)`
+        );
+      }
+      for (const sweepCandidate of candidates) {
+        void sweepAround(sweepCandidate).catch(() => {
+        });
+      }
+      return result.inbox;
+    }
+    const attempt = { ...result.failure, attempts: index + 1 };
+    debugLogger6.warn(
+      `peer inbox could not bind at ${candidate} (${attempt.cause}): ${attempt.detail}`
+    );
+    if (attempt.cause === "unsupported_platform") {
+      failure = { ...attempt, attempts: 1 };
+      break;
+    }
+    if (failure === null) {
+      failure = attempt;
+    } else {
+      failure.attempts = index + 1;
+    }
+  }
+  if (failure) {
+    lastStartFailure = failure;
+    debugLogger6.error(
+      `cross-session messaging is OFF for this session: ${describePeerInboxFailure(failure)}`
+    );
+  }
+  return null;
+}
+__name(startPeerInbox, "startPeerInbox");
+async function bindAt(requestedPath, options, automaticPath) {
+  let socketPath = requestedPath;
+  if (!isLocalIpcPath(socketPath)) {
+    const unsupportedPlatform = automaticPath && process.platform === "win32";
+    return {
+      failure: classify(
+        new InboxSetupError(
+          unsupportedPlatform ? "unsupported_platform" : "non_local",
+          unsupportedPlatform ? "automatic peer inbox paths are not supported on Windows" : `refusing to bind a non-local IPC path: ${socketPath}`,
+          unsupportedPlatform ? "Disable cross-session messaging for this session." : "Use an absolute local path."
+        ),
+        requestedPath
+      )
+    };
+  }
+  if (Buffer.byteLength(socketPath) > MAX_SOCKET_PATH_BYTES) {
+    return {
+      failure: classify(
+        Object.assign(new Error(`${socketPath} exceeds sun_path`), {
+          code: "ENAMETOOLONG"
+        }),
+        requestedPath
+      )
+    };
+  }
+  const socketDir = path.dirname(socketPath);
+  const dropDirIfEmpty = /* @__PURE__ */ __name(async () => {
+    await fs.rmdir(socketDir).catch(() => {
+    });
+  }, "dropDirIfEmpty");
+  const dir = socketDir;
+  try {
+    await fs.mkdir(dir, { recursive: true, mode: SOCKET_DIR_MODE });
+  } catch (error) {
+    await dropDirIfEmpty();
+    return {
+      failure: await classifyMkdirFailure(error, requestedPath, socketDir)
+    };
+  }
+  try {
+    const dirStat = await fs.lstat(dir);
+    const uid = typeof process.getuid === "function" ? process.getuid() : null;
+    if (!dirStat.isDirectory()) {
+      throw new InboxSetupError(
+        "not_directory",
+        `${dir} is not a directory`,
+        "Remove it, or set XDG_RUNTIME_DIR to a directory you own, then restart."
+      );
+    }
+    if (uid !== null && dirStat.uid !== uid) {
+      throw new InboxSetupError(
+        "foreign_owner",
+        `${dir} belongs to uid ${dirStat.uid}, not ${uid}`
+      );
+    }
+    await fs.chmod(dir, SOCKET_DIR_MODE);
+  } catch (error) {
+    await dropDirIfEmpty();
+    return { failure: classify(error, requestedPath) };
+  }
+  if (await probePeerSocketVerdict(socketPath) !== "dead") {
+    const sibling = siblingSocketPath(socketPath);
+    if (sibling === null) {
+      await dropDirIfEmpty();
+      return { failure: siblingOverflowFailure(requestedPath) };
+    }
+    debugLogger6.debug(
+      `${socketPath} is in use or could not be verified free; binding at ${sibling}`
+    );
+    socketPath = sibling;
+  }
+  try {
+    await fs.unlink(socketPath);
+  } catch {
+  }
+  const connections = /* @__PURE__ */ new Set();
+  const lineDeadlineMs = options.lineDeadlineMs ?? LINE_DEADLINE_MS;
+  const server = net.createServer({ allowHalfOpen: true }, (socket) => {
+    connections.add(socket);
+    socket.setEncoding("utf8");
+    socket.unref();
+    let deadline = null;
+    const arm = /* @__PURE__ */ __name(() => {
+      if (deadline) clearTimeout(deadline);
+      deadline = setTimeout(() => {
+        deadline = null;
+        debugLogger6.debug(
+          `closing a peer connection that sent no complete line within ${lineDeadlineMs} ms`
+        );
+        socket.destroy();
+      }, lineDeadlineMs);
+      deadline.unref();
+    }, "arm");
+    arm();
+    let authed = options.requiredToken === void 0;
+    let auth;
+    let refused = false;
+    const read2 = createLineReader(
+      (line) => {
+        if (refused) return;
+        if (!authed) {
+          arm();
+          const presented = parsePeerAuthLine(line);
+          if (presented !== null) {
+            auth = authKindOf(options, presented);
+          }
+          if (auth !== void 0) {
+            authed = true;
+            return;
+          }
+          debugLogger6.debug(
+            "dropping a connection whose first line did not authenticate: no valid auth line, or token mismatch"
+          );
+          refused = true;
+          socket.destroy();
+          return;
+        }
+        const frame = parsePeerFrame(line);
+        if (frame === null) {
+          debugLogger6.debug(
+            `dropping unparseable frame: ${line.slice(0, 200)}`
+          );
+          return;
+        }
+        arm();
+        try {
+          options.onFrame(frame, auth);
+        } catch (error) {
+          debugLogger6.error(`onFrame threw: ${describe(error)}`);
+        }
+      },
+      () => {
+        debugLogger6.error(
+          "peer sent more than 1 MiB without a newline; dropping the connection"
+        );
+        socket.destroy();
+      }
+    );
+    socket.on("data", read2);
+    socket.on("end", () => {
+      socket.end();
+    });
+    socket.on("error", (error) => {
+      debugLogger6.debug(`peer connection error: ${error.message}`);
+    });
+    socket.on("close", () => {
+      if (deadline) clearTimeout(deadline);
+      deadline = null;
+      connections.delete(socket);
+    });
+  });
+  server.maxConnections = MAX_PEER_CONNECTIONS;
+  server.on("error", (error) => {
+    debugLogger6.error(`peer inbox server error: ${describe(error)}`);
+  });
+  const listenAt = /* @__PURE__ */ __name((target) => new Promise((resolve6, reject) => {
+    server.once("error", reject);
+    server.listen(target, () => {
+      server.removeListener("error", reject);
+      resolve6();
+    });
+  }), "listenAt");
+  try {
+    await listenAt(socketPath);
+  } catch (error) {
+    const sibling = error?.code === "EADDRINUSE" ? siblingSocketPath(socketPath) : null;
+    if (error?.code === "EADDRINUSE" && sibling === null) {
+      await dropDirIfEmpty();
+      return { failure: siblingOverflowFailure(requestedPath) };
+    }
+    let raced = error;
+    if (sibling !== null) {
+      try {
+        await listenAt(sibling);
+        socketPath = sibling;
+        raced = null;
+      } catch (retryError) {
+        raced = retryError;
+      }
+    }
+    if (raced !== null) {
+      await dropDirIfEmpty();
+      const classified = classify(raced, requestedPath);
+      return {
+        failure: classified.cause === "unknown" ? {
+          ...classified,
+          cause: "bind_failed",
+          hint: "If another process holds the path, restart after it exits; otherwise set XDG_RUNTIME_DIR to a directory you own."
+        } : classified
+      };
+    }
+  }
+  try {
+    await fs.chmod(socketPath, SOCKET_MODE);
+  } catch (error) {
+    server.close();
+    try {
+      fsSync.unlinkSync(socketPath);
+    } catch {
+    }
+    await dropDirIfEmpty();
+    return {
+      failure: {
+        ...classify(error, requestedPath),
+        cause: "chmod_failed"
+      }
+    };
+  }
+  server.unref();
+  debugLogger6.debug(`peer inbox listening: ${socketPath}`);
+  let closed = false;
+  return {
+    inbox: {
+      socketPath,
+      async close() {
+        if (closed) return;
+        closed = true;
+        for (const socket of connections) socket.destroy();
+        connections.clear();
+        await new Promise((resolve6) => server.close(() => resolve6()));
+        try {
+          await fs.unlink(socketPath);
+        } catch {
+        }
+        debugLogger6.debug(`peer inbox closed: ${socketPath}`);
+      }
+    }
+  };
+}
+__name(bindAt, "bindAt");
+function tokenMatches(expected, presented) {
+  const a = Buffer.from(expected);
+  const b = Buffer.from(presented);
+  return a.length === b.length && timingSafeEqual(a, b);
+}
+__name(tokenMatches, "tokenMatches");
+function authKindOf(options, presented) {
+  const peer = options.requiredToken !== void 0 && tokenMatches(options.requiredToken, presented);
+  const child = options.childToken !== void 0 && tokenMatches(options.childToken, presented);
+  if (peer) return "peer";
+  if (child) return "child";
+  return void 0;
+}
+__name(authKindOf, "authKindOf");
+function describe(error) {
+  return error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+}
+__name(describe, "describe");
+
 // packages/core/src/services/web-terminal-registry.ts
 init_esbuild_shims();
 import { spawnSync } from "node:child_process";
@@ -4909,8 +5477,8 @@ var WebTerminalRegistry = class {
 
 // packages/core/src/memory/remember.ts
 init_esbuild_shims();
-import path from "node:path";
-var debugLogger6 = createDebugLogger("AUTO_MEMORY_REMEMBER");
+import path2 from "node:path";
+var debugLogger7 = createDebugLogger("AUTO_MEMORY_REMEMBER");
 function buildManagedRememberPrompt(fact, projectRoot, options = {}) {
   const trimmed = fact.trim();
   const projectDir = projectRoot ? getAutoMemoryRoot(projectRoot) : void 0;
@@ -5085,20 +5653,20 @@ async function runManagedRememberByAgent(params) {
       ],
       abortSignal: params.abortSignal,
       suppressChatRecording: true,
-      completeAfterFirstSuccessfulWrite: /* @__PURE__ */ __name((filePath) => path.basename(filePath) !== "MEMORY.md", "completeAfterFirstSuccessfulWrite")
+      completeAfterFirstSuccessfulWrite: /* @__PURE__ */ __name((filePath) => path2.basename(filePath) !== "MEMORY.md", "completeAfterFirstSuccessfulWrite")
     });
   } catch (err) {
     await Promise.all([
       ...params.scope !== "user" ? [rebuildManagedAutoMemoryIndex(params.projectRoot)] : [],
       ...params.scope !== "project" ? [rebuildUserAutoMemoryIndex()] : []
     ]).catch((rebuildErr) => {
-      debugLogger6.error("Memory index rebuild failed:", rebuildErr);
+      debugLogger7.error("Memory index rebuild failed:", rebuildErr);
     });
     throw err;
   }
   const filesWritten = result.filesWritten ?? [];
   const entryFilesWritten = filesWritten.filter(
-    (filePath) => path.basename(filePath) !== "MEMORY.md"
+    (filePath) => path2.basename(filePath) !== "MEMORY.md"
   );
   const { writtenScopes, escapeError } = (() => {
     const scopes = [];
@@ -5118,33 +5686,33 @@ async function runManagedRememberByAgent(params) {
   const rebuildWrittenScopes = /* @__PURE__ */ __name(() => Promise.all([
     writtenScopes.includes("project") ? rebuildManagedAutoMemoryIndex(params.projectRoot) : Promise.resolve(),
     writtenScopes.includes("user") ? params.scope === "user" ? rebuildUserAutoMemoryIndex() : rebuildUserAutoMemoryIndex().catch((err) => {
-      debugLogger6.error("User memory index rebuild failed:", err);
+      debugLogger7.error("User memory index rebuild failed:", err);
     }) : Promise.resolve()
   ]), "rebuildWrittenScopes");
   if (escapeError !== void 0) {
     if (result.status === "completed") {
       await rebuildWrittenScopes().catch((err) => {
-        debugLogger6.error("Memory index rebuild failed:", err);
+        debugLogger7.error("Memory index rebuild failed:", err);
       });
       throw escapeError;
     }
-    debugLogger6.error("Remember write audit failed:", escapeError);
+    debugLogger7.error("Remember write audit failed:", escapeError);
   }
   if (result.status === "failed" || result.status === "cancelled") {
     await rebuildWrittenScopes().catch((err) => {
-      debugLogger6.error("Memory index rebuild failed:", err);
+      debugLogger7.error("Memory index rebuild failed:", err);
     });
     throw new Error(
       result.terminateReason || (result.status === "failed" ? "Remember agent failed" : "Remember agent cancelled")
     );
   }
   if (entryFilesWritten.length === 0) {
-    debugLogger6.warn("Remember agent completed without writing memory.", {
+    debugLogger7.warn("Remember agent completed without writing memory.", {
       filesTouched: result.filesTouched,
       finalTextLength: result.finalText?.length ?? 0
     });
     await rebuildWrittenScopes().catch((err) => {
-      debugLogger6.error("Memory index rebuild failed:", err);
+      debugLogger7.error("Memory index rebuild failed:", err);
     });
     throw Object.assign(new Error("Remember agent did not update any memory"), {
       code: "remember_no_update"
@@ -5156,7 +5724,7 @@ async function runManagedRememberByAgent(params) {
   );
   if (params.scope && touchedScopes.some((scope) => scope !== params.scope)) {
     await rebuildWrittenScopes().catch((err) => {
-      debugLogger6.error("Memory index rebuild failed:", err);
+      debugLogger7.error("Memory index rebuild failed:", err);
     });
     throw Object.assign(
       new Error(
@@ -5251,19 +5819,19 @@ ${tickText}`,
 
 // packages/core/src/skills/bundled/loop/loop-tick-resolver.ts
 init_esbuild_shims();
-import * as path3 from "node:path";
+import * as path4 from "node:path";
 
 // packages/core/src/skills/bundled/loop/loop-task-file.ts
 init_esbuild_shims();
-import * as fs from "node:fs/promises";
-import * as path2 from "node:path";
-var debugLogger7 = createDebugLogger("LOOP_TASK_FILE");
+import * as fs2 from "node:fs/promises";
+import * as path3 from "node:path";
+var debugLogger8 = createDebugLogger("LOOP_TASK_FILE");
 var LOOP_TASK_FILE_MAX_BYTES = 25e3;
 var moduleRealDirCache = /* @__PURE__ */ new Map();
 function resolveRealDir(dir, cache) {
   let real = cache.get(dir);
   if (real === void 0) {
-    real = fs.realpath(dir);
+    real = fs2.realpath(dir);
     real.catch(() => cache.delete(dir));
     cache.set(dir, real);
   }
@@ -5274,19 +5842,19 @@ function isWithin(root, real) {
   if (real === root) {
     return true;
   }
-  const prefix = root.endsWith(path2.sep) ? root : root + path2.sep;
+  const prefix = root.endsWith(path3.sep) ? root : root + path3.sep;
   return real.startsWith(prefix);
 }
 __name(isWithin, "isWithin");
 async function readBoundedTaskFile(filePath) {
-  const handle = await fs.open(filePath, "r");
+  const handle = await fs2.open(filePath, "r");
   try {
-    const stat4 = await handle.stat();
-    if (!stat4.isFile()) {
+    const stat5 = await handle.stat();
+    if (!stat5.isFile()) {
       return null;
     }
     const cap = LOOP_TASK_FILE_MAX_BYTES + 1;
-    const allocSize = Math.min(cap, stat4.size + 1);
+    const allocSize = Math.min(cap, stat5.size + 1);
     const buffer = Buffer.alloc(allocSize);
     let total = 0;
     while (total < allocSize) {
@@ -5306,7 +5874,7 @@ async function readBoundedTaskFile(filePath) {
     try {
       await handle.close();
     } catch (closeErr) {
-      debugLogger7.debug("failed to close loop.md handle", { closeErr });
+      debugLogger8.debug("failed to close loop.md handle", { closeErr });
     }
   }
 }
@@ -5314,47 +5882,47 @@ __name(readBoundedTaskFile, "readBoundedTaskFile");
 async function readLoopTaskFile({
   projectRoot,
   homeDir,
-  homeQwenDir = path2.join(homeDir, ".qwen"),
+  homeQwenDir = path3.join(homeDir, ".qwen"),
   allowProjectFile = false,
   realDirCache = moduleRealDirCache
 }) {
   if (!allowProjectFile) {
-    debugLogger7.debug("skipping project loop.md: folder is untrusted");
+    debugLogger8.debug("skipping project loop.md: folder is untrusted");
   }
   const candidates = [
     ...allowProjectFile ? [
       {
         source: "project",
-        path: path2.join(projectRoot, ".qwen", "loop.md")
+        path: path3.join(projectRoot, ".qwen", "loop.md")
       }
     ] : [],
-    { source: "home", path: path2.join(homeQwenDir, "loop.md") }
+    { source: "home", path: path3.join(homeQwenDir, "loop.md") }
   ];
   for (const { source, path: filePath } of candidates) {
     let buffer;
     try {
       if (source === "project") {
-        const projectStat = await fs.lstat(filePath);
+        const projectStat = await fs2.lstat(filePath);
         if (projectStat.isSymbolicLink()) {
-          debugLogger7.debug("skipping symlinked project loop.md", { filePath });
+          debugLogger8.debug("skipping symlinked project loop.md", { filePath });
           continue;
         }
         if (!projectStat.isFile()) {
-          debugLogger7.debug("skipping non-regular project loop.md", {
+          debugLogger8.debug("skipping non-regular project loop.md", {
             filePath
           });
           continue;
         }
         if (projectStat.nlink > 1) {
-          debugLogger7.debug("skipping hard-linked project loop.md", {
+          debugLogger8.debug("skipping hard-linked project loop.md", {
             filePath
           });
           continue;
         }
         const realRoot = await resolveRealDir(projectRoot, realDirCache);
-        const real = await fs.realpath(filePath);
+        const real = await fs2.realpath(filePath);
         if (!isWithin(realRoot, real)) {
-          debugLogger7.debug(
+          debugLogger8.debug(
             "skipping project loop.md that escapes the workspace",
             {
               filePath,
@@ -5365,19 +5933,19 @@ async function readLoopTaskFile({
         }
         buffer = await readBoundedTaskFile(real);
       } else {
-        const homeStat = await fs.stat(filePath);
+        const homeStat = await fs2.stat(filePath);
         if (!homeStat.isFile()) {
-          debugLogger7.debug("skipping non-regular home loop.md", { filePath });
+          debugLogger8.debug("skipping non-regular home loop.md", { filePath });
           continue;
         }
         if (homeStat.nlink > 1) {
-          debugLogger7.debug("skipping hard-linked home loop.md", { filePath });
+          debugLogger8.debug("skipping hard-linked home loop.md", { filePath });
           continue;
         }
         const realHome = await resolveRealDir(homeDir, realDirCache);
-        const real = await fs.realpath(filePath);
+        const real = await fs2.realpath(filePath);
         if (!isWithin(realHome, real)) {
-          debugLogger7.debug(
+          debugLogger8.debug(
             "skipping home loop.md that escapes the home directory",
             { filePath, resolved: real }
           );
@@ -5396,7 +5964,7 @@ async function readLoopTaskFile({
       continue;
     }
     if (buffer.toString("utf8").trim().length === 0) {
-      debugLogger7.debug("skipping whitespace-only loop.md", {
+      debugLogger8.debug("skipping whitespace-only loop.md", {
         source,
         filePath
       });
@@ -5431,7 +5999,7 @@ async function readLoopTaskFile({
     } else {
       content = buffer.toString("utf8");
     }
-    debugLogger7.debug("read loop.md", {
+    debugLogger8.debug("read loop.md", {
       source,
       bytes: buffer.byteLength,
       truncated
@@ -5570,8 +6138,8 @@ ${tickText}`,
    *   - any other out-of-$HOME dir → a generic placeholder, never the path.
    * The real absolute path stays in LOCAL debug logs only. */
   homeLoopLabel() {
-    const homeQwenDir = this.deps.homeQwenDir ?? path3.join(this.deps.homeDir, ".qwen");
-    const homeLoopPath = path3.join(homeQwenDir, "loop.md");
+    const homeQwenDir = this.deps.homeQwenDir ?? path4.join(this.deps.homeDir, ".qwen");
+    const homeLoopPath = path4.join(homeQwenDir, "loop.md");
     const tildeified = tildeifyPath(homeLoopPath);
     if (tildeified !== homeLoopPath) {
       return tildeified.replace(/\\/g, "/");
@@ -6012,9 +6580,9 @@ function encodeInsightProgressMessage(stage, progress, detail) {
   return JSON.stringify(payload);
 }
 __name(encodeInsightProgressMessage, "encodeInsightProgressMessage");
-function encodeInsightReadyMessage(path19) {
+function encodeInsightReadyMessage(path20) {
   const payload = {
-    insight_ready: { path: path19 }
+    insight_ready: { path: path20 }
   };
   return JSON.stringify(payload);
 }
@@ -6029,8 +6597,8 @@ __name(encodeInsightErrorMessage, "encodeInsightErrorMessage");
 
 // packages/core/src/core/logger.ts
 init_esbuild_shims();
-import path4 from "node:path";
-import { promises as fs2 } from "node:fs";
+import path5 from "node:path";
+import { promises as fs3 } from "node:fs";
 var LOG_FILE_NAME = "logs.json";
 function encodeTagName(str) {
   return encodeURIComponent(str);
@@ -6083,7 +6651,7 @@ var Logger = class {
       throw new Error("Log file path not set during read attempt.");
     }
     try {
-      const fileContent = await fs2.readFile(this.logFilePath, "utf-8");
+      const fileContent = await fs3.readFile(this.logFilePath, "utf-8");
       const parsedLogs = JSON.parse(fileContent);
       if (!Array.isArray(parsedLogs)) {
         this.debugLogger.debug(
@@ -6119,7 +6687,7 @@ var Logger = class {
     if (!this.logFilePath) return;
     const backupPath = `${this.logFilePath}.${reason}.${Date.now()}.bak`;
     try {
-      await fs2.rename(this.logFilePath, backupPath);
+      await fs3.rename(this.logFilePath, backupPath);
       this.debugLogger.debug(`Backed up corrupted log file to ${backupPath}`);
     } catch (_backupError) {
     }
@@ -6129,12 +6697,12 @@ var Logger = class {
       return;
     }
     this.qwenDir = this.storage.getProjectTempDir();
-    this.logFilePath = path4.join(this.qwenDir, LOG_FILE_NAME);
+    this.logFilePath = path5.join(this.qwenDir, LOG_FILE_NAME);
     try {
-      await fs2.mkdir(this.qwenDir, { recursive: true });
+      await fs3.mkdir(this.qwenDir, { recursive: true });
       let fileExisted = true;
       try {
-        await fs2.access(this.logFilePath);
+        await fs3.access(this.logFilePath);
       } catch (_e) {
         fileExisted = false;
       }
@@ -6358,12 +6926,12 @@ var Logger = class {
       throw new Error("Checkpoint file path not set.");
     }
     const encodedTag = encodeTagName(tag);
-    return path4.join(this.qwenDir, `checkpoint-${encodedTag}.json`);
+    return path5.join(this.qwenDir, `checkpoint-${encodedTag}.json`);
   }
   async _getCheckpointPath(tag) {
     const newPath = this._checkpointPath(tag);
     try {
-      await fs2.access(newPath);
+      await fs3.access(newPath);
       return newPath;
     } catch (error) {
       const nodeError = error;
@@ -6371,9 +6939,9 @@ var Logger = class {
         throw error;
       }
     }
-    const oldPath = path4.join(this.qwenDir, `checkpoint-${tag}.json`);
+    const oldPath = path5.join(this.qwenDir, `checkpoint-${tag}.json`);
     try {
-      await fs2.access(oldPath);
+      await fs3.access(oldPath);
       return oldPath;
     } catch (error) {
       const nodeError = error;
@@ -6390,9 +6958,9 @@ var Logger = class {
       );
       return;
     }
-    const path19 = this._checkpointPath(tag);
+    const path20 = this._checkpointPath(tag);
     try {
-      await atomicWriteFile(path19, JSON.stringify(conversation, null, 2), {
+      await atomicWriteFile(path20, JSON.stringify(conversation, null, 2), {
         encoding: "utf-8"
       });
     } catch (error) {
@@ -6406,13 +6974,13 @@ var Logger = class {
       );
       return [];
     }
-    const path19 = await this._getCheckpointPath(tag);
+    const path20 = await this._getCheckpointPath(tag);
     try {
-      const fileContent = await fs2.readFile(path19, "utf-8");
+      const fileContent = await fs3.readFile(path20, "utf-8");
       const parsedContent = JSON.parse(fileContent);
       if (!Array.isArray(parsedContent)) {
         this.debugLogger.warn(
-          `Checkpoint file at ${path19} is not a valid JSON array. Returning empty checkpoint.`
+          `Checkpoint file at ${path20} is not a valid JSON array. Returning empty checkpoint.`
         );
         return [];
       }
@@ -6423,7 +6991,7 @@ var Logger = class {
         return [];
       }
       this.debugLogger.error(
-        `Failed to read or parse checkpoint file ${path19}:`,
+        `Failed to read or parse checkpoint file ${path20}:`,
         error
       );
       return [];
@@ -6439,7 +7007,7 @@ var Logger = class {
     let deletedSomething = false;
     const newPath = this._checkpointPath(tag);
     try {
-      await fs2.unlink(newPath);
+      await fs3.unlink(newPath);
       deletedSomething = true;
     } catch (error) {
       const nodeError = error;
@@ -6451,10 +7019,10 @@ var Logger = class {
         throw error;
       }
     }
-    const oldPath = path4.join(this.qwenDir, `checkpoint-${tag}.json`);
+    const oldPath = path5.join(this.qwenDir, `checkpoint-${tag}.json`);
     if (newPath !== oldPath) {
       try {
-        await fs2.unlink(oldPath);
+        await fs3.unlink(oldPath);
         deletedSomething = true;
       } catch (error) {
         const nodeError = error;
@@ -6478,34 +7046,330 @@ var Logger = class {
     let filePath;
     try {
       filePath = await this._getCheckpointPath(tag);
-      await fs2.access(filePath);
+      await fs3.access(filePath);
       return true;
     } catch (error) {
       const nodeError = error;
       if (nodeError.code === "ENOENT") {
         return false;
       }
-      this.debugLogger.error(
-        `Failed to check checkpoint existence for ${filePath ?? `path for tag "${tag}"`}:`,
-        error
+      this.debugLogger.error(
+        `Failed to check checkpoint existence for ${filePath ?? `path for tag "${tag}"`}:`,
+        error
+      );
+      throw error;
+    }
+  }
+  close() {
+    this.initialized = false;
+    this.logFilePath = void 0;
+    this.logs = [];
+    this.lastLoggedUserEntry = null;
+    this.writeQueue = Promise.resolve();
+    this.sessionId = void 0;
+    this.messageId = 0;
+  }
+};
+
+// packages/core/src/core/output-style-files.ts
+init_esbuild_shims();
+import * as fs4 from "fs/promises";
+import * as os from "os";
+import * as path6 from "path";
+var debugLogger9 = createDebugLogger("OUTPUT_STYLE_FILES");
+var OUTPUT_STYLES_DIR_NAME = "output-styles";
+var MAX_OUTPUT_STYLE_FILE_BYTES = 25e3;
+var MAX_OUTPUT_STYLE_NAME_LENGTH = 64;
+var MAX_DERIVED_DESCRIPTION_LENGTH = 120;
+var KNOWN_FRONTMATTER_KEYS = /* @__PURE__ */ new Set([
+  "name",
+  "description",
+  "keep-coding-instructions"
+]);
+var FRONTMATTER_FENCE = /^---[ \t]*\n([\s\S]*?)\n?---[ \t]*(?:\n|$)([\s\S]*)$/;
+function isFrontmatterBlock(block) {
+  let sawKey = false;
+  for (const line of block.split("\n")) {
+    const trimmed = line.trimStart();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+    if (/^\s/.test(line)) {
+      if (!sawKey) {
+        return false;
+      }
+      continue;
+    }
+    const key = /^([A-Za-z0-9_-]+):(?:\s|$)/.exec(line)?.[1];
+    if (!key || !KNOWN_FRONTMATTER_KEYS.has(key)) {
+      return false;
+    }
+    sawKey = true;
+  }
+  return sawKey || !block.trim();
+}
+__name(isFrontmatterBlock, "isFrontmatterBlock");
+function parseOutputStyleFile(content, filePath, source) {
+  const normalized2 = normalizeContent(content);
+  const fence = FRONTMATTER_FENCE.exec(normalized2);
+  const match = fence && isFrontmatterBlock(fence[1]) ? fence : null;
+  const frontmatter = match ? parse(match[1]) : {};
+  const body = stripHtmlComments(match ? match[2] : normalized2).trim();
+  const fallbackName = path6.basename(filePath).replace(/\.md$/i, "").trim();
+  const name = validateOutputStyleName(
+    typeof frontmatter["name"] === "string" ? frontmatter["name"].trim() : fallbackName
+  );
+  if (!body) {
+    throw new Error("the file has no prompt body");
+  }
+  const declaredDescription = sanitizeDescription(
+    typeof frontmatter["description"] === "string" ? frontmatter["description"] : ""
+  );
+  const description = declaredDescription || sanitizeDescription(deriveDescription(body)) || `Custom ${name} output style`;
+  const keepCodingInstructions = resolveKeepCodingInstructions(
+    frontmatter,
+    name,
+    filePath
+  );
+  const unknownKeys = Object.keys(frontmatter).filter(
+    (key) => !KNOWN_FRONTMATTER_KEYS.has(key)
+  );
+  if (unknownKeys.length > 0) {
+    debugLogger9.warn(
+      `Output style ${filePath}: ignoring unknown frontmatter keys ${unknownKeys.join(", ")}`
+    );
+  }
+  return { name, source, description, keepCodingInstructions, prompt: body };
+}
+__name(parseOutputStyleFile, "parseOutputStyleFile");
+function resolveKeepCodingInstructions(frontmatter, name, filePath) {
+  if (!("keep-coding-instructions" in frontmatter)) {
+    return getBuiltInOutputStyle(name)?.keepCodingInstructions ?? false;
+  }
+  const raw = frontmatter["keep-coding-instructions"];
+  const spelling = typeof raw === "string" ? raw.trim().toLowerCase() : raw;
+  if (spelling === true || spelling === "true") {
+    return true;
+  }
+  if (spelling !== false && spelling !== "false") {
+    debugLogger9.warn(
+      `Output style ${filePath}: keep-coding-instructions value ${JSON.stringify(raw)} is not true or false; treating it as false`
+    );
+  }
+  return false;
+}
+__name(resolveKeepCodingInstructions, "resolveKeepCodingInstructions");
+function sanitizeDescription(description) {
+  const flattened = stripAnsiAndControl(description).replace(new RegExp("\\p{Cf}", "gu"), "").replace(/\s+/gu, " ").trim();
+  return flattened.length > MAX_DERIVED_DESCRIPTION_LENGTH ? flattened.slice(0, MAX_DERIVED_DESCRIPTION_LENGTH) : flattened;
+}
+__name(sanitizeDescription, "sanitizeDescription");
+function validateOutputStyleName(name) {
+  if (!name) {
+    throw new Error("the style name is empty");
+  }
+  if (name.length > MAX_OUTPUT_STYLE_NAME_LENGTH) {
+    throw new Error(
+      `the style name is longer than ${MAX_OUTPUT_STYLE_NAME_LENGTH} characters`
+    );
+  }
+  if (/[\p{Cc}\p{Cf}]/u.test(name)) {
+    throw new Error("the style name contains control characters");
+  }
+  if (name.toLowerCase() === "default") {
+    throw new Error('"default" is reserved for the built-in default style');
+  }
+  return name;
+}
+__name(validateOutputStyleName, "validateOutputStyleName");
+function deriveDescription(body) {
+  let inFence = false;
+  for (const rawLine of body.split("\n")) {
+    const trimmed = rawLine.trim();
+    if (trimmed.startsWith("```") || trimmed.startsWith("~~~")) {
+      inFence = !inFence;
+      continue;
+    }
+    if (inFence) {
+      continue;
+    }
+    const line = trimmed.replace(/^(?:#{1,6}\s+|[-*+]\s+|>\s*|\d+[.)]\s+)/, "").replace(/[*_`]/g, "").trim();
+    if (!line) {
+      continue;
+    }
+    return line.length > MAX_DERIVED_DESCRIPTION_LENGTH ? `${line.slice(0, MAX_DERIVED_DESCRIPTION_LENGTH - 1)}\u2026` : line;
+  }
+  return "";
+}
+__name(deriveDescription, "deriveDescription");
+async function resolveStyleFileToRead(filePath, source, confineTo) {
+  const stat5 = source === "project" ? await fs4.lstat(filePath) : await fs4.stat(filePath);
+  if (source === "project" && stat5.isSymbolicLink()) {
+    debugLogger9.warn(`Skipping output style ${filePath}: it is a symlink`);
+    return null;
+  }
+  if (!stat5.isFile()) {
+    return null;
+  }
+  if (stat5.nlink > 1) {
+    debugLogger9.warn(`Skipping output style ${filePath}: it is a hard link`);
+    return null;
+  }
+  const realPath = await fs4.realpath(filePath);
+  const realRoot = await fs4.realpath(confineTo);
+  if (realPath !== realRoot && !isWithinRoot(realPath, realRoot)) {
+    debugLogger9.warn(
+      `Skipping output style ${filePath}: it resolves outside ${realRoot}`
+    );
+    return null;
+  }
+  return realPath;
+}
+__name(resolveStyleFileToRead, "resolveStyleFileToRead");
+async function readBoundedStyleFile(readPath) {
+  const handle = await fs4.open(readPath, "r");
+  try {
+    const cap = MAX_OUTPUT_STYLE_FILE_BYTES + 1;
+    const buffer = Buffer.alloc(cap);
+    let total = 0;
+    while (total < cap) {
+      const { bytesRead } = await handle.read(
+        buffer,
+        total,
+        cap - total,
+        total
+      );
+      if (bytesRead === 0) {
+        break;
+      }
+      total += bytesRead;
+    }
+    return buffer.subarray(0, total);
+  } finally {
+    await handle.close();
+  }
+}
+__name(readBoundedStyleFile, "readBoundedStyleFile");
+async function loadOutputStylesFromDir(dir, source, confineTo) {
+  let entries;
+  try {
+    entries = await fs4.readdir(dir);
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      debugLogger9.warn(`Cannot read output styles directory ${dir}:`, error);
+    }
+    return [];
+  }
+  const styles = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of entries.filter((e) => /\.md$/i.test(e)).sort()) {
+    const filePath = path6.join(dir, entry);
+    try {
+      const readPath = await resolveStyleFileToRead(
+        filePath,
+        source,
+        confineTo
+      );
+      if (!readPath) {
+        continue;
+      }
+      const buffer = await readBoundedStyleFile(readPath);
+      if (buffer.byteLength > MAX_OUTPUT_STYLE_FILE_BYTES) {
+        debugLogger9.warn(
+          `Skipping output style ${filePath}: larger than ${MAX_OUTPUT_STYLE_FILE_BYTES} bytes`
+        );
+        continue;
+      }
+      if (isBinary(buffer)) {
+        debugLogger9.warn(
+          `Skipping output style ${filePath}: it is not UTF-8 text`
+        );
+        continue;
+      }
+      const style = parseOutputStyleFile(
+        buffer.toString("utf8"),
+        filePath,
+        source
+      );
+      const key = style.name.toLowerCase();
+      if (seen.has(key)) {
+        debugLogger9.warn(
+          `Skipping output style ${filePath}: another file in ${dir} already defines "${style.name}"`
+        );
+        continue;
+      }
+      seen.add(key);
+      styles.push(style);
+    } catch (error) {
+      debugLogger9.warn(
+        `Skipping output style ${filePath}: ${error instanceof Error ? error.message : String(error)}`
       );
-      throw error;
     }
   }
-  close() {
-    this.initialized = false;
-    this.logFilePath = void 0;
-    this.logs = [];
-    this.lastLoggedUserEntry = null;
-    this.writeQueue = Promise.resolve();
-    this.sessionId = void 0;
-    this.messageId = 0;
+  return styles;
+}
+__name(loadOutputStylesFromDir, "loadOutputStylesFromDir");
+function getUserOutputStylesDir() {
+  return path6.join(Storage.getGlobalQwenDir(), OUTPUT_STYLES_DIR_NAME);
+}
+__name(getUserOutputStylesDir, "getUserOutputStylesDir");
+function getUserOutputStylesRoot() {
+  const envDir = process.env["QWEN_HOME"];
+  if (envDir) {
+    return Storage.getGlobalQwenDir();
+  }
+  return os.homedir() || path6.dirname(Storage.getGlobalQwenDir());
+}
+__name(getUserOutputStylesRoot, "getUserOutputStylesRoot");
+function getProjectOutputStylesDir(projectRoot) {
+  return path6.join(projectRoot, QWEN_DIR, OUTPUT_STYLES_DIR_NAME);
+}
+__name(getProjectOutputStylesDir, "getProjectOutputStylesDir");
+async function loadOutputStyleCatalog(options = {}) {
+  const projectRoot = options.projectRoot;
+  const includeProject = projectRoot !== void 0 && path6.resolve(getProjectOutputStylesDir(projectRoot)) !== path6.resolve(getUserOutputStylesDir());
+  const [projectStyles, userStyles] = await Promise.all([
+    includeProject ? loadOutputStylesFromDir(
+      getProjectOutputStylesDir(projectRoot),
+      "project",
+      projectRoot
+    ) : Promise.resolve([]),
+    loadOutputStylesFromDir(
+      getUserOutputStylesDir(),
+      "user",
+      getUserOutputStylesRoot()
+    )
+  ]);
+  const winners = /* @__PURE__ */ new Map();
+  for (const style of [
+    ...projectStyles,
+    ...userStyles,
+    ...BUILT_IN_OUTPUT_STYLES
+  ]) {
+    const key = style.name.toLowerCase();
+    const winner = winners.get(key);
+    if (winner) {
+      debugLogger9.debug(
+        `Output style "${style.name}" (${style.source}) is shadowed by the ${winner.source} style of the same name`
+      );
+      continue;
+    }
+    winners.set(key, style);
   }
-};
+  return [...BUILT_IN_OUTPUT_STYLES, ...userStyles, ...projectStyles].filter(
+    (style) => winners.get(style.name.toLowerCase()) === style
+  );
+}
+__name(loadOutputStyleCatalog, "loadOutputStyleCatalog");
+function findOutputStyle(styles, name) {
+  const wanted = name.trim().toLowerCase();
+  return styles.find((style) => style.name.toLowerCase() === wanted);
+}
+__name(findOutputStyle, "findOutputStyle");
 
 // packages/core/src/tools/client-mcp-registrar.ts
 init_esbuild_shims();
-var debugLogger8 = createDebugLogger("CLIENT_MCP_REGISTRAR");
+var debugLogger10 = createDebugLogger("CLIENT_MCP_REGISTRAR");
 var CLIENT_MCP_MESSAGE_TIMEOUT_MS = 3e4;
 var ClientMcpRegistrar = class {
   static {
@@ -6528,7 +7392,7 @@ var ClientMcpRegistrar = class {
    */
   registerServer(serverName) {
     this.servers.add(serverName);
-    debugLogger8.debug(`Registered client MCP server '${serverName}'`);
+    debugLogger10.debug(`Registered client MCP server '${serverName}'`);
   }
   /**
    * Drop a server name and reject any in-flight requests targeting it. Returns
@@ -6541,7 +7405,7 @@ var ClientMcpRegistrar = class {
       new Error(`client MCP server '${serverName}' was unregistered`)
     );
     if (existed) {
-      debugLogger8.debug(`Unregistered client MCP server '${serverName}'`);
+      debugLogger10.debug(`Unregistered client MCP server '${serverName}'`);
     }
     return existed;
   }
@@ -6601,7 +7465,7 @@ var ClientMcpRegistrar = class {
       }
       return Promise.resolve(ack);
     }
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id);
         reject(
@@ -6611,7 +7475,7 @@ var ClientMcpRegistrar = class {
         );
       }, this.messageTimeoutMs);
       timer.unref?.();
-      this.pending.set(id, { resolve: resolve5, reject, timer, server: serverName });
+      this.pending.set(id, { resolve: resolve6, reject, timer, server: serverName });
       let sendResult;
       try {
         sendResult = this.sendFrame({
@@ -6641,7 +7505,7 @@ var ClientMcpRegistrar = class {
   resolveMessage(id, payload) {
     const pending = this.pending.get(id);
     if (!pending) {
-      debugLogger8.debug(`Dropping mcp_message with unknown id '${id}'`);
+      debugLogger10.debug(`Dropping mcp_message with unknown id '${id}'`);
       return false;
     }
     this.pending.delete(id);
@@ -6692,15 +7556,50 @@ function isWsl(env2) {
 }
 __name(isWsl, "isWsl");
 
-// packages/core/src/services/tool-write-origin.ts
+// packages/core/src/services/api-user-prompt.ts
 init_esbuild_shims();
-var TOOL_WRITE_ORIGINS = [
-  "write_file",
-  "edit",
-  "notebook_edit",
-  "shell_sed_edit"
-];
-var TOOL_WRITE_ORIGIN_SET = new Set(TOOL_WRITE_ORIGINS);
+function isApiUserPrompt(content, options) {
+  if (content.role !== "user") return false;
+  if (!content.parts || content.parts.length === 0) return false;
+  if (content.parts.some((part) => "functionResponse" in part)) return false;
+  if (isSystemReminderContent(content)) return false;
+  const excludeTextPart = options?.excludeTextPart;
+  if (excludeTextPart && content.parts.some(
+    (part) => "text" in part && typeof part.text === "string" && excludeTextPart(part.text)
+  )) {
+    return false;
+  }
+  return content.parts.some((part) => {
+    if (!("text" in part) || !part.text) return false;
+    return !(options?.excludeClearedMediaPlaceholders && isClearedMediaPlaceholder(part.text));
+  });
+}
+__name(isApiUserPrompt, "isApiUserPrompt");
+function findApiRewindCutPoint(apiHistory, turnIndex, options) {
+  const startIndex = getStartupContextLength(apiHistory, {
+    includeCompressed: true
+  });
+  if (turnIndex <= 0) return startIndex;
+  let seen = 0;
+  for (let index = startIndex; index < apiHistory.length; index++) {
+    if (!isApiUserPrompt(apiHistory[index], options)) continue;
+    if (seen === turnIndex) return index;
+    seen += 1;
+  }
+  return -1;
+}
+__name(findApiRewindCutPoint, "findApiRewindCutPoint");
+function countApiUserPrompts(apiHistory, options) {
+  const startIndex = getStartupContextLength(apiHistory, {
+    includeCompressed: true
+  });
+  let count = 0;
+  for (let index = startIndex; index < apiHistory.length; index++) {
+    if (isApiUserPrompt(apiHistory[index], options)) count += 1;
+  }
+  return count;
+}
+__name(countApiUserPrompts, "countApiUserPrompts");
 
 // packages/core/src/services/session-reference-service.ts
 init_esbuild_shims();
@@ -6821,207 +7720,12 @@ ${body}`;
   }
 };
 
-// packages/core/src/ipc/uds-inbox.ts
-init_esbuild_shims();
-import { timingSafeEqual } from "node:crypto";
-import * as fsSync from "node:fs";
-import * as fs3 from "node:fs/promises";
-import * as net from "node:net";
-import * as path5 from "node:path";
-var debugLogger9 = createDebugLogger("PEER_IPC");
-var SOCKET_DIR_MODE = 448;
-var SOCKET_MODE = 384;
-var MAX_PEER_CONNECTIONS = 64;
-var CONNECTION_IDLE_TIMEOUT_MS = 3e4;
-function createLineReader(onLine, onOverflow) {
-  let buffer = "";
-  return (chunk) => {
-    buffer += chunk;
-    let newline = buffer.indexOf("\n");
-    while (newline !== -1) {
-      const line = buffer.slice(0, newline);
-      buffer = buffer.slice(newline + 1);
-      if (line.trim().length > 0) onLine(line);
-      newline = buffer.indexOf("\n");
-    }
-    if (buffer.length > MAX_FRAME_BYTES) {
-      buffer = "";
-      onOverflow();
-    }
-  };
-}
-__name(createLineReader, "createLineReader");
-async function startPeerInbox(options) {
-  const socketPath = options.socketPath ?? resolvePeerSocketPath();
-  if (!isLocalIpcPath(socketPath)) {
-    debugLogger9.error(`refusing to bind a non-local IPC path: ${socketPath}`);
-    return null;
-  }
-  try {
-    const dir = path5.dirname(socketPath);
-    await fs3.mkdir(dir, { recursive: true, mode: SOCKET_DIR_MODE });
-    const dirStat = await fs3.lstat(dir);
-    const uid = typeof process.getuid === "function" ? process.getuid() : null;
-    if (!dirStat.isDirectory()) {
-      throw new Error(`${dir} is not a directory`);
-    }
-    if (uid !== null && dirStat.uid !== uid) {
-      throw new Error(`${dir} belongs to uid ${dirStat.uid}, not ${uid}`);
-    }
-    await fs3.chmod(dir, SOCKET_DIR_MODE);
-  } catch (error) {
-    debugLogger9.error(`peer inbox directory unusable: ${describe(error)}`);
-    return null;
-  }
-  try {
-    await fs3.unlink(socketPath);
-  } catch {
-  }
-  const connections = /* @__PURE__ */ new Set();
-  const server = net.createServer({ allowHalfOpen: true }, (socket) => {
-    connections.add(socket);
-    socket.setEncoding("utf8");
-    socket.unref();
-    socket.setTimeout(CONNECTION_IDLE_TIMEOUT_MS, () => {
-      debugLogger9.debug("dropping an idle peer connection");
-      socket.destroy();
-    });
-    let authed = options.requiredToken === void 0;
-    let auth;
-    let refused = false;
-    const read2 = createLineReader(
-      (line) => {
-        if (refused) return;
-        if (!authed) {
-          const presented = parsePeerAuthLine(line);
-          if (presented !== null) {
-            auth = authKindOf(options, presented);
-          }
-          if (auth !== void 0) {
-            authed = true;
-            return;
-          }
-          debugLogger9.debug(
-            "dropping a connection whose first line did not authenticate: no valid auth line, or token mismatch"
-          );
-          refused = true;
-          socket.destroy();
-          return;
-        }
-        const frame = parsePeerFrame(line);
-        if (frame === null) {
-          debugLogger9.debug(
-            `dropping unparseable frame: ${line.slice(0, 200)}`
-          );
-          return;
-        }
-        try {
-          options.onFrame(frame, auth);
-        } catch (error) {
-          debugLogger9.error(`onFrame threw: ${describe(error)}`);
-        }
-      },
-      () => {
-        debugLogger9.error(
-          "peer sent more than 1 MiB without a newline; dropping the connection"
-        );
-        socket.destroy();
-      }
-    );
-    socket.on("data", read2);
-    socket.on("end", () => {
-      socket.end();
-    });
-    socket.on("error", (error) => {
-      debugLogger9.debug(`peer connection error: ${error.message}`);
-    });
-    socket.on("close", () => {
-      connections.delete(socket);
-    });
-  });
-  server.maxConnections = MAX_PEER_CONNECTIONS;
-  server.on("error", (error) => {
-    debugLogger9.error(`peer inbox server error: ${describe(error)}`);
-  });
-  try {
-    await new Promise((resolve5, reject) => {
-      server.once("error", reject);
-      server.listen(socketPath, () => {
-        server.removeListener("error", reject);
-        resolve5();
-      });
-    });
-  } catch (error) {
-    const code = error?.code;
-    if (code === "ENAMETOOLONG") {
-      debugLogger9.error(
-        `peer inbox socket path is too long to bind (${Buffer.byteLength(
-          socketPath
-        )} bytes): ${socketPath}. Set XDG_RUNTIME_DIR or TMPDIR to a shorter directory.`
-      );
-    } else {
-      debugLogger9.error(`peer inbox failed to bind: ${describe(error)}`);
-    }
-    return null;
-  }
-  try {
-    await fs3.chmod(socketPath, SOCKET_MODE);
-  } catch (error) {
-    debugLogger9.error(
-      `peer inbox socket could not be restricted to 0600, refusing to listen: ${describe(error)}`
-    );
-    server.close();
-    try {
-      fsSync.unlinkSync(socketPath);
-    } catch {
-    }
-    return null;
-  }
-  server.unref();
-  debugLogger9.debug(`peer inbox listening: ${socketPath}`);
-  let closed = false;
-  return {
-    socketPath,
-    async close() {
-      if (closed) return;
-      closed = true;
-      for (const socket of connections) socket.destroy();
-      connections.clear();
-      await new Promise((resolve5) => server.close(() => resolve5()));
-      try {
-        await fs3.unlink(socketPath);
-      } catch {
-      }
-      debugLogger9.debug(`peer inbox closed: ${socketPath}`);
-    }
-  };
-}
-__name(startPeerInbox, "startPeerInbox");
-function tokenMatches(expected, presented) {
-  const a = Buffer.from(expected);
-  const b = Buffer.from(presented);
-  return a.length === b.length && timingSafeEqual(a, b);
-}
-__name(tokenMatches, "tokenMatches");
-function authKindOf(options, presented) {
-  const peer = options.requiredToken !== void 0 && tokenMatches(options.requiredToken, presented);
-  const child = options.childToken !== void 0 && tokenMatches(options.childToken, presented);
-  if (peer) return "peer";
-  if (child) return "child";
-  return void 0;
-}
-__name(authKindOf, "authKindOf");
-function describe(error) {
-  return error instanceof Error ? `${error.name}: ${error.message}` : String(error);
-}
-__name(describe, "describe");
-
 // packages/core/src/utils/conversation-branches.ts
 init_esbuild_shims();
 
 // packages/core/src/services/toolUseSummary.ts
 init_esbuild_shims();
-var debugLogger10 = createDebugLogger("TOOL_USE_SUMMARY");
+var debugLogger11 = createDebugLogger("TOOL_USE_SUMMARY");
 var TOOL_USE_SUMMARY_SYSTEM_PROMPT = `Write a short summary label describing what these tool calls accomplished. It appears as a single-line row in a mobile app and truncates around 30 characters, so think git-commit-subject, not sentence.
 
 Keep the verb in past tense and the most distinctive noun. Drop articles, connectors, and long location context first.
@@ -7042,7 +7746,7 @@ async function generateToolUseSummary(params) {
   }
   const model = config.getFastModel();
   if (!model) {
-    debugLogger10.debug("No fast model configured \u2014 skipping summary generation");
+    debugLogger11.debug("No fast model configured \u2014 skipping summary generation");
     return null;
   }
   if (signal.aborted) {
@@ -7065,7 +7769,7 @@ ${toolSummaries}
 
 Label:`;
     if (!config.getLlmClient()) {
-      debugLogger10.debug("No gemini client available \u2014 skipping");
+      debugLogger11.debug("No gemini client available \u2014 skipping");
       return null;
     }
     const result = await runSideQuery(config, {
@@ -7084,19 +7788,19 @@ Label:`;
     });
     if (signal.aborted) return null;
     if (!result.text) {
-      debugLogger10.debug("Summary generation returned empty result");
+      debugLogger11.debug("Summary generation returned empty result");
       return null;
     }
     const cleaned = cleanSummary(result.text);
     if (!cleaned) {
-      debugLogger10.debug(`Summary cleaned to empty: raw="${result.text}"`);
+      debugLogger11.debug(`Summary cleaned to empty: raw="${result.text}"`);
       return null;
     }
-    debugLogger10.debug(`Summary generated: "${cleaned}"`);
+    debugLogger11.debug(`Summary generated: "${cleaned}"`);
     return cleaned;
   } catch (err) {
     if (signal.aborted) return null;
-    debugLogger10.warn(
+    debugLogger11.warn(
       `Summary generation failed: ${err instanceof Error ? err.message : String(err)}`
     );
     return null;
@@ -7170,7 +7874,7 @@ __name(cleanSummary, "cleanSummary");
 
 // packages/core/src/services/usage-dashboard-service.ts
 init_esbuild_shims();
-var debugLogger11 = createDebugLogger("USAGE_DASHBOARD");
+var debugLogger12 = createDebugLogger("USAGE_DASHBOARD");
 var DEFAULT_HEATMAP_DAYS = 183;
 var MAX_DAILY_DAYS = 92;
 var MS_PER_DAY = 24 * 60 * 60 * 1e3;
@@ -7295,7 +7999,7 @@ function buildUsageDashboard(records, options = {}) {
   );
   const daily = buildDaily(records, dailyStart, now);
   const heatmap = buildHeatmap(records, now - heatmapDays * MS_PER_DAY, now);
-  debugLogger11.debug(
+  debugLogger12.debug(
     `built dashboard range=${range} records=${records.length} models=${models.length} skills=${skills.length} dailyPoints=${daily.length}`
   );
   return {
@@ -7625,13 +8329,13 @@ __name(serializeChannelMemoryDocument, "serializeChannelMemoryDocument");
 // packages/core/src/memory/channel-memory.ts
 init_esbuild_shims();
 var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
-import { createHash as createHash4, randomBytes } from "node:crypto";
-import * as fs4 from "node:fs/promises";
-import * as path6 from "node:path";
+import { createHash as createHash4, randomBytes as randomBytes2 } from "node:crypto";
+import * as fs5 from "node:fs/promises";
+import * as path7 from "node:path";
 var CHANNEL_MEMORY_FILE_NAME = "CHANNEL.json";
 var LEGACY_CHANNEL_MEMORY_FILE_NAME = "CHANNEL.md";
 var MAX_CHANNEL_MEMORY_BYTES = 1024 * 1024;
-var debugLogger12 = createDebugLogger("CHANNEL_MEMORY");
+var debugLogger13 = createDebugLogger("CHANNEL_MEMORY");
 var pendingMutations = /* @__PURE__ */ new Map();
 var LOCK_OPTIONS = {
   realpath: false,
@@ -7644,7 +8348,7 @@ var LOCK_OPTIONS = {
   },
   stale: 5e3,
   onCompromised: /* @__PURE__ */ __name((err) => {
-    debugLogger12.warn("channel memory lock compromised:", err);
+    debugLogger13.warn("channel memory lock compromised:", err);
   }, "onCompromised")
 };
 function isMissingFile(error) {
@@ -7667,11 +8371,11 @@ async function releaseLock(release) {
 __name(releaseLock, "releaseLock");
 async function cleanupLegacyAfterCommit(legacyPath, expectedBytes) {
   try {
-    const currentBytes = await fs4.readFile(legacyPath);
+    const currentBytes = await fs5.readFile(legacyPath);
     if (legacyHash(currentBytes) !== legacyHash(expectedBytes) || !currentBytes.equals(expectedBytes)) {
       return;
     }
-    await fs4.unlink(legacyPath);
+    await fs5.unlink(legacyPath);
   } catch {
   }
 }
@@ -7687,7 +8391,7 @@ function hashedThreadPath(target) {
 }
 __name(hashedThreadPath, "hashedThreadPath");
 function getChannelMemoryDirectory(target) {
-  return path6.join(
+  return path7.join(
     Storage.getGlobalQwenDir(),
     "channels",
     "memory",
@@ -7697,11 +8401,11 @@ function getChannelMemoryDirectory(target) {
 }
 __name(getChannelMemoryDirectory, "getChannelMemoryDirectory");
 function getChannelMemoryFilePath(target) {
-  return path6.join(getChannelMemoryDirectory(target), CHANNEL_MEMORY_FILE_NAME);
+  return path7.join(getChannelMemoryDirectory(target), CHANNEL_MEMORY_FILE_NAME);
 }
 __name(getChannelMemoryFilePath, "getChannelMemoryFilePath");
 function getLegacyChannelMemoryFilePath(target) {
-  return path6.join(
+  return path7.join(
     getChannelMemoryDirectory(target),
     LEGACY_CHANNEL_MEMORY_FILE_NAME
   );
@@ -7711,8 +8415,8 @@ async function serializeMutation(directory, task) {
   const previous = pendingMutations.get(directory) ?? Promise.resolve();
   let resolveCurrent = /* @__PURE__ */ __name(() => {
   }, "resolveCurrent");
-  const current = new Promise((resolve5) => {
-    resolveCurrent = resolve5;
+  const current = new Promise((resolve6) => {
+    resolveCurrent = resolve6;
   });
   const queued = previous.then(
     () => current,
@@ -7733,7 +8437,7 @@ async function serializeMutation(directory, task) {
 __name(serializeMutation, "serializeMutation");
 async function readFileIfExists(filePath) {
   try {
-    return await fs4.readFile(filePath);
+    return await fs5.readFile(filePath);
   } catch (error) {
     if (isMissingFile(error)) {
       return void 0;
@@ -7796,21 +8500,21 @@ async function loadChannelMemory(target) {
 }
 __name(loadChannelMemory, "loadChannelMemory");
 async function writeChannelMemory(filePath, serialized) {
-  const tempPath = `${filePath}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
+  const tempPath = `${filePath}.${process.pid}.${randomBytes2(6).toString("hex")}.tmp`;
   let committed = false;
   try {
-    const handle = await fs4.open(tempPath, "wx", 384);
+    const handle = await fs5.open(tempPath, "wx", 384);
     try {
       await handle.writeFile(serialized, "utf8");
       await handle.sync();
     } finally {
       await handle.close();
     }
-    await fs4.rename(tempPath, filePath);
+    await fs5.rename(tempPath, filePath);
     committed = true;
   } finally {
     if (!committed) {
-      await fs4.unlink(tempPath).catch((error) => {
+      await fs5.unlink(tempPath).catch((error) => {
         if (!isMissingFile(error)) {
           throw error;
         }
@@ -7821,12 +8525,12 @@ async function writeChannelMemory(filePath, serialized) {
 __name(writeChannelMemory, "writeChannelMemory");
 async function mutateChannelMemory(target, apply) {
   const filePath = getChannelMemoryFilePath(target);
-  const directory = path6.dirname(filePath);
+  const directory = path7.dirname(filePath);
   const legacyPath = getLegacyChannelMemoryFilePath(target);
   return serializeMutation(directory, async () => {
-    await fs4.mkdir(directory, { recursive: true });
-    const lockPath = path6.join(directory, ".channel-memory.lock");
-    const lockHandle = await fs4.open(lockPath, "a", 384);
+    await fs5.mkdir(directory, { recursive: true });
+    const lockPath = path7.join(directory, ".channel-memory.lock");
+    const lockHandle = await fs5.open(lockPath, "a", 384);
     await lockHandle.close();
     const release = await import_proper_lockfile.default.lock(lockPath, LOCK_OPTIONS);
     let releaseLegacy;
@@ -7865,7 +8569,7 @@ async function listChannelMemoryEntries(target) {
 __name(listChannelMemoryEntries, "listChannelMemoryEntries");
 async function getFileRevision(filePath) {
   try {
-    const stats = await fs4.stat(filePath, { bigint: true });
+    const stats = await fs5.stat(filePath, { bigint: true });
     return [
       stats.dev,
       stats.ino,
@@ -7918,7 +8622,7 @@ async function addChannelMemoryEntries(target, texts, createdBy) {
       }
       let randomHex;
       do {
-        randomHex = randomBytes(6).toString("hex");
+        randomHex = randomBytes2(6).toString("hex");
       } while (ids.has(`m-${randomHex}`));
       const entry = createChannelMemoryEntry({
         text,
@@ -8205,8 +8909,8 @@ __name(buildLearnVideoSkillRequest, "buildLearnVideoSkillRequest");
 
 // packages/core/src/memory/writeContextFile.ts
 init_esbuild_shims();
-import { promises as fs5 } from "node:fs";
-import * as path7 from "node:path";
+import { promises as fs6 } from "node:fs";
+import * as path8 from "node:path";
 var fileLocks = /* @__PURE__ */ new Map();
 var FILE_LOCK_TIMEOUT_MS = 3e4;
 function getFileLock(filePath) {
@@ -8234,7 +8938,7 @@ var WorkspaceMemoryWriteTimeoutError = class extends Error {
   }
 };
 async function writeWorkspaceContextFile(options) {
-  if (!path7.isAbsolute(options.projectRoot)) {
+  if (!path8.isAbsolute(options.projectRoot)) {
     throw new Error(
       `writeWorkspaceContextFile: projectRoot must be absolute, got "${options.projectRoot}"`
     );
@@ -8260,10 +8964,10 @@ async function runWrite(filePath, options) {
     return { filePath, bytesWritten: 0, changed: false };
   }
   options.assertCanCommit?.();
-  await fs5.mkdir(path7.dirname(filePath), { recursive: true });
+  await fs6.mkdir(path8.dirname(filePath), { recursive: true });
   if (options.mode === "replace") {
     options.assertCanCommit?.();
-    await fs5.writeFile(filePath, options.content, {
+    await fs6.writeFile(filePath, options.content, {
       encoding: "utf8",
       mode: 420
     });
@@ -8275,7 +8979,7 @@ async function runWrite(filePath, options) {
   }
   const next = await composeAppendedContent(filePath, options.content);
   options.assertCanCommit?.();
-  await fs5.writeFile(filePath, next, { encoding: "utf8", mode: 420 });
+  await fs6.writeFile(filePath, next, { encoding: "utf8", mode: 420 });
   return {
     filePath,
     bytesWritten: Buffer.byteLength(next, "utf8"),
@@ -8286,9 +8990,9 @@ __name(runWrite, "runWrite");
 function resolveContextFilePath(scope, projectRoot) {
   const filename = getCurrentMemoryFilename();
   if (scope === "workspace") {
-    return path7.join(projectRoot, filename);
+    return path8.join(projectRoot, filename);
   }
-  return path7.join(Storage.getGlobalQwenDir(), filename);
+  return path8.join(Storage.getGlobalQwenDir(), filename);
 }
 __name(resolveContextFilePath, "resolveContextFilePath");
 var MAX_EXISTING_FILE_BYTES = 16 * 1024 * 1024;
@@ -8312,15 +9016,15 @@ var WorkspaceMemoryFileTooLargeError = class extends Error {
 async function composeAppendedContent(filePath, newContent) {
   let existing = "";
   try {
-    const stat4 = await fs5.stat(filePath);
-    if (stat4.size > MAX_EXISTING_FILE_BYTES) {
+    const stat5 = await fs6.stat(filePath);
+    if (stat5.size > MAX_EXISTING_FILE_BYTES) {
       throw new WorkspaceMemoryFileTooLargeError(
         filePath,
-        stat4.size,
+        stat5.size,
         MAX_EXISTING_FILE_BYTES
       );
     }
-    existing = await fs5.readFile(filePath, "utf8");
+    existing = await fs6.readFile(filePath, "utf8");
   } catch (err) {
     if (err instanceof WorkspaceMemoryFileTooLargeError) throw err;
     if (!isEnoent(err)) throw err;
@@ -8399,9 +9103,9 @@ __name(trimNewlines, "trimNewlines");
 init_esbuild_shims();
 import * as child_process from "node:child_process";
 import * as process2 from "node:process";
-import * as path8 from "node:path";
-import * as fs6 from "node:fs";
-import * as os from "node:os";
+import * as path9 from "node:path";
+import * as fs7 from "node:fs";
+import * as os2 from "node:os";
 function getVsCodeCommand(platform2 = process2.platform) {
   return platform2 === "win32" ? "code.cmd" : "code";
 }
@@ -8424,27 +9128,27 @@ async function findVsCodeCommand(platform2 = process2.platform) {
   } catch {
   }
   const locations = [];
-  const homeDir = os.homedir();
+  const homeDir = os2.homedir();
   if (platform2 === "darwin") {
     locations.push(
       "/Applications/Visual Studio Code.app/Contents/Resources/app/bin/code",
-      path8.join(homeDir, "Library/Application Support/Code/bin/code")
+      path9.join(homeDir, "Library/Application Support/Code/bin/code")
     );
   } else if (platform2 === "linux") {
     locations.push(
       "/usr/share/code/bin/code",
       "/snap/bin/code",
-      path8.join(homeDir, ".local/share/code/bin/code")
+      path9.join(homeDir, ".local/share/code/bin/code")
     );
   } else if (platform2 === "win32") {
     locations.push(
-      path8.join(
+      path9.join(
         process2.env["ProgramFiles"] || "C:\\Program Files",
         "Microsoft VS Code",
         "bin",
         "code.cmd"
       ),
-      path8.join(
+      path9.join(
         homeDir,
         "AppData",
         "Local",
@@ -8456,7 +9160,7 @@ async function findVsCodeCommand(platform2 = process2.platform) {
     );
   }
   for (const location of locations) {
-    if (fs6.existsSync(location)) {
+    if (fs7.existsSync(location)) {
       return location;
     }
   }
@@ -8623,10 +9327,10 @@ __name(lspServerConfigHash, "lspServerConfigHash");
 
 // packages/core/src/lsp/LspConfigLoader.ts
 init_esbuild_shims();
-import * as fs7 from "node:fs";
-import * as path9 from "path";
+import * as fs8 from "node:fs";
+import * as path10 from "path";
 import { pathToFileURL } from "url";
-var debugLogger13 = createDebugLogger("LSP");
+var debugLogger14 = createDebugLogger("LSP");
 var MAX_TCP_PORT = 65535;
 var LspConfigLoader = class {
   constructor(workspaceRoot) {
@@ -8640,25 +9344,25 @@ var LspConfigLoader = class {
    * Supports basic format: { "language": { "command": "...", "extensionToLanguage": {...} } }
    */
   async loadUserConfigs() {
-    const lspConfigPath = path9.join(this.workspaceRoot, ".lsp.json");
-    if (!fs7.existsSync(lspConfigPath)) {
+    const lspConfigPath = path10.join(this.workspaceRoot, ".lsp.json");
+    if (!fs8.existsSync(lspConfigPath)) {
       return [];
     }
     try {
-      const configContent = fs7.readFileSync(lspConfigPath, "utf-8");
+      const configContent = fs8.readFileSync(lspConfigPath, "utf-8");
       const data = JSON.parse(configContent);
       return this.parseConfigSource(data, lspConfigPath, {
         forceTrustRequired: true
       });
     } catch (error) {
-      debugLogger13.warn("Failed to load user .lsp.json config:", error);
+      debugLogger14.warn("Failed to load user .lsp.json config:", error);
       return [];
     }
   }
   async loadUserConfigsStrict() {
-    const lspConfigPath = path9.join(this.workspaceRoot, ".lsp.json");
+    const lspConfigPath = path10.join(this.workspaceRoot, ".lsp.json");
     try {
-      const configContent = fs7.readFileSync(lspConfigPath, "utf-8");
+      const configContent = fs8.readFileSync(lspConfigPath, "utf-8");
       const data = JSON.parse(configContent);
       return this.parseUserConfigSourceStrict(data, lspConfigPath);
     } catch (error) {
@@ -8687,14 +9391,14 @@ var LspConfigLoader = class {
           extension.path,
           lspServers
         );
-        if (!fs7.existsSync(configPath)) {
-          debugLogger13.warn(
+        if (!fs8.existsSync(configPath)) {
+          debugLogger14.warn(
             `LSP config not found for ${originBase}: ${configPath}`
           );
           continue;
         }
         try {
-          const configContent = fs7.readFileSync(configPath, "utf-8");
+          const configContent = fs8.readFileSync(configPath, "utf-8");
           const data = JSON.parse(configContent);
           const hydrated = this.hydrateExtensionLspConfig(data, extension.path);
           configs.push(
@@ -8704,7 +9408,7 @@ var LspConfigLoader = class {
             )
           );
         } catch (error) {
-          debugLogger13.warn(
+          debugLogger14.warn(
             `Failed to load extension LSP config from ${configPath}:`,
             error
           );
@@ -8718,7 +9422,7 @@ var LspConfigLoader = class {
           ...this.parseConfigSource(hydrated, `${originBase} (lspServers)`)
         );
       } else {
-        debugLogger13.warn(
+        debugLogger14.warn(
           `LSP config for ${originBase} must be an object or a JSON file path.`
         );
       }
@@ -8824,15 +9528,15 @@ var LspConfigLoader = class {
     return { ok: true, configs };
   }
   resolveExtensionConfigPath(extensionPath, configPath) {
-    return path9.isAbsolute(configPath) ? path9.resolve(configPath) : path9.resolve(extensionPath, configPath);
+    return path10.isAbsolute(configPath) ? path10.resolve(configPath) : path10.resolve(extensionPath, configPath);
   }
   hydrateExtensionLspConfig(source, extensionPath) {
     return recursivelyHydrateStrings(source, {
       extensionPath,
       CLAUDE_PLUGIN_ROOT: extensionPath,
       workspacePath: this.workspaceRoot,
-      "/": path9.sep,
-      pathSeparator: path9.sep
+      "/": path10.sep,
+      pathSeparator: path10.sep
     });
   }
   buildServerConfig(name, languages, spec, origin, options = {}) {
@@ -8856,13 +9560,13 @@ var LspConfigLoader = class {
     const trustRequired = options.forceTrustRequired ? true : typeof spec["trustRequired"] === "boolean" ? spec["trustRequired"] : true;
     const socket = this.normalizeSocketOptions(spec);
     if (transport === "stdio" && !command) {
-      debugLogger13.warn(
+      debugLogger14.warn(
         `LSP config error in ${origin}: ${name} missing command`
       );
       return null;
     }
     if (transport !== "stdio" && !socket) {
-      debugLogger13.warn(
+      debugLogger14.warn(
         `LSP config error in ${origin}: ${name} missing socket info`
       );
       return null;
@@ -8999,12 +9703,12 @@ var LspConfigLoader = class {
     if (typeof value !== "string" || value.trim() === "") {
       return this.workspaceRoot;
     }
-    const resolved = path9.isAbsolute(value) ? path9.resolve(value) : path9.resolve(this.workspaceRoot, value);
-    const root = path9.resolve(this.workspaceRoot);
-    if (resolved === root || resolved.startsWith(root + path9.sep)) {
+    const resolved = path10.isAbsolute(value) ? path10.resolve(value) : path10.resolve(this.workspaceRoot, value);
+    const root = path10.resolve(this.workspaceRoot);
+    if (resolved === root || resolved.startsWith(root + path10.sep)) {
       return resolved;
     }
-    debugLogger13.warn(
+    debugLogger14.warn(
       `LSP workspaceFolder must be within ${this.workspaceRoot}; using workspace root instead.`
     );
     return this.workspaceRoot;
@@ -9016,7 +9720,7 @@ init_esbuild_shims();
 import * as cp from "node:child_process";
 import * as net2 from "node:net";
 import { StringDecoder } from "node:string_decoder";
-var debugLogger14 = createDebugLogger("LSP");
+var debugLogger15 = createDebugLogger("LSP");
 var MAX_STDERR_TAIL_BYTES = 8192;
 function trimTail(value, maxBytes) {
   const buffer = Buffer.from(value, "utf8");
@@ -9081,7 +9785,7 @@ var JsonRpcConnection = class {
     try {
       this.disposer?.();
     } catch (error) {
-      debugLogger14.warn("LSP disposer failed:", error);
+      debugLogger15.warn("LSP disposer failed:", error);
     }
   }
   sendRequest(method, params) {
@@ -9095,12 +9799,12 @@ var JsonRpcConnection = class {
       method,
       params
     };
-    const requestPromise = new Promise((resolve5, reject) => {
+    const requestPromise = new Promise((resolve6, reject) => {
       const timer = setTimeout(() => {
         this.pendingRequests.delete(id);
         reject(new Error(`LSP request timeout: ${method}`));
       }, DEFAULT_LSP_REQUEST_TIMEOUT_MS);
-      this.pendingRequests.set(id, { resolve: resolve5, reject, timer });
+      this.pendingRequests.set(id, { resolve: resolve6, reject, timer });
     });
     this.writeMessage(payload);
     return requestPromise;
@@ -9208,7 +9912,7 @@ var JsonRpcConnection = class {
     try {
       this.writer(header + json);
     } catch (error) {
-      debugLogger14.warn("LSP write failed:", error);
+      debugLogger15.warn("LSP write failed:", error);
       this.end();
     }
   }
@@ -9228,7 +9932,7 @@ var LspConnectionFactory = class _LspConnectionFactory {
    * 创建基于 stdio 的 LSP 连接
    */
   static async createStdioConnection(command, args, options, timeoutMs = 1e4) {
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       const spawnOptions = {
         stdio: "pipe",
         ...options
@@ -9267,14 +9971,14 @@ var LspConnectionFactory = class _LspConnectionFactory {
           );
         });
         processInstance.stderr?.on("error", (err) => {
-          debugLogger14.warn(`LSP stderr stream error for ${command}:`, err);
+          debugLogger15.warn(`LSP stderr stream error for ${command}:`, err);
         });
         const connection = new JsonRpcConnection(
           (payload) => processInstance.stdin?.write(payload),
           () => processInstance.stdin?.end()
         );
         processInstance.stdin.on("error", (err) => {
-          debugLogger14.warn(`LSP stdin stream error for ${command}:`, err);
+          debugLogger15.warn(`LSP stdin stream error for ${command}:`, err);
           connection.end();
         });
         connection.listen(processInstance.stdout);
@@ -9287,7 +9991,7 @@ var LspConnectionFactory = class _LspConnectionFactory {
           recordProcessExit(code, signal);
           connection.end();
         });
-        resolve5({
+        resolve6({
           connection,
           process: processInstance,
           processDiagnostics
@@ -9308,7 +10012,7 @@ var LspConnectionFactory = class _LspConnectionFactory {
    * 创建基于 socket 的 LSP 连接（支持 TCP 或 unix socket）
    */
   static async createSocketConnection(options, timeoutMs = 1e4) {
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       let socketOptions;
       if (options.path) {
         socketOptions = { path: options.path };
@@ -9342,7 +10046,7 @@ var LspConnectionFactory = class _LspConnectionFactory {
         connection.listen(socket);
         socket.once("close", () => connection.end());
         socket.once("error", () => connection.end());
-        resolve5({
+        resolve6({
           connection,
           socket
         });
@@ -9357,7 +10061,7 @@ var LspConnectionFactory = class _LspConnectionFactory {
       try {
         await lspConnection.connection.shutdown();
       } catch (e) {
-        debugLogger14.warn("LSP shutdown failed:", e);
+        debugLogger15.warn("LSP shutdown failed:", e);
       } finally {
         lspConnection.connection.end();
       }
@@ -10032,10 +10736,10 @@ ${value}
 // packages/core/src/lsp/LspServerManager.ts
 init_esbuild_shims();
 import { spawn as spawn2 } from "node:child_process";
-import * as fs8 from "node:fs";
-import * as path10 from "path";
+import * as fs9 from "node:fs";
+import * as path11 from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
-var debugLogger15 = createDebugLogger("LSP");
+var debugLogger16 = createDebugLogger("LSP");
 var SECURITY_SENSITIVE_ENV_KEYS = /* @__PURE__ */ new Set([
   "DYLD_INSERT_LIBRARIES",
   "DYLD_LIBRARY_PATH",
@@ -10072,7 +10776,7 @@ var LspServerManager = class {
       });
       this.serverConfigHashes.set(config.name, lspServerConfigHash(config));
     }
-    debugLogger15.info(
+    debugLogger16.info(
       `Prepared ${configs.length} LSP server config(s): ${formatServerNames(
         configs.map((config) => config.name)
       )}`
@@ -10081,7 +10785,7 @@ var LspServerManager = class {
   /** Drops all prepared handles without attempting process shutdown. */
   clearServerHandles() {
     if (this.serverHandles.size > 0) {
-      debugLogger15.info(
+      debugLogger16.info(
         `Clearing ${this.serverHandles.size} LSP server handle(s): ${formatServerNames(
           Array.from(this.serverHandles.keys())
         )}`
@@ -10142,7 +10846,7 @@ var LspServerManager = class {
    * before their handles are deleted or replaced.
    */
   async doReconcileServerConfigs(configs) {
-    debugLogger15.info(
+    debugLogger16.info(
       `Reconciling LSP server configs: desired=${formatServerNames(
         configs.map((config) => config.name)
       )}`
@@ -10214,7 +10918,7 @@ var LspServerManager = class {
         result.added.push(name);
       }
     }
-    debugLogger15.info(
+    debugLogger16.info(
       `LSP reconcile result: added=${formatServerNames(
         result.added
       )}, removed=${formatServerNames(
@@ -10249,7 +10953,7 @@ var LspServerManager = class {
     const uri = pathToFileURL2(tsFile).toString();
     const languageId = tsFile.endsWith(".tsx") ? "typescriptreact" : tsFile.endsWith(".jsx") ? "javascriptreact" : tsFile.endsWith(".js") ? "javascript" : "typescript";
     try {
-      const text = fs8.readFileSync(tsFile, "utf-8");
+      const text = fs9.readFileSync(tsFile, "utf-8");
       handle.connection.send({
         jsonrpc: "2.0",
         method: "textDocument/didOpen",
@@ -10263,12 +10967,12 @@ var LspServerManager = class {
         }
       });
       await new Promise(
-        (resolve5) => setTimeout(resolve5, DEFAULT_LSP_WARMUP_DELAY_MS)
+        (resolve6) => setTimeout(resolve6, DEFAULT_LSP_WARMUP_DELAY_MS)
       );
       handle.warmedUp = true;
       return uri;
     } catch (error) {
-      debugLogger15.warn("TypeScript server warm-up failed:", error);
+      debugLogger16.warn("TypeScript server warm-up failed:", error);
       return void 0;
     }
   }
@@ -10315,7 +11019,7 @@ var LspServerManager = class {
   async doStartServer(name, handle) {
     const workspaceTrusted = this.config.isTrustedFolder();
     if ((this.requireTrustedWorkspace || handle.config.trustRequired) && !workspaceTrusted) {
-      debugLogger15.warn(
+      debugLogger16.warn(
         `LSP server ${name} requires trusted workspace, skipping startup`
       );
       handle.status = "FAILED";
@@ -10328,7 +11032,7 @@ var LspServerManager = class {
       workspaceTrusted
     );
     if (!trusted) {
-      debugLogger15.warn(
+      debugLogger16.warn(
         `Workspace trust check failed, not starting LSP server ${name}`
       );
       handle.status = "FAILED";
@@ -10338,7 +11042,7 @@ var LspServerManager = class {
     if (handle.config.command) {
       const commandCwd = handle.config.workspaceFolder ?? this.workspaceRoot;
       if (!this.isPathSafe(handle.config.command, this.workspaceRoot, commandCwd)) {
-        debugLogger15.warn(
+        debugLogger16.warn(
           `LSP server ${name} command path is unsafe: ${handle.config.command}`
         );
         handle.status = "FAILED";
@@ -10350,7 +11054,7 @@ var LspServerManager = class {
         handle.config.env,
         commandCwd
       )) {
-        debugLogger15.warn(
+        debugLogger16.warn(
           `LSP server ${name} command not found: ${handle.config.command}`
         );
         handle.status = "FAILED";
@@ -10365,7 +11069,7 @@ var LspServerManager = class {
       handle.processDiagnostics = void 0;
       handle.warmedUp = false;
       handle.status = "IN_PROGRESS";
-      debugLogger15.info(
+      debugLogger16.info(
         `Starting LSP server ${name}: command=${handle.config.command ?? "<none>"}, transport=${handle.config.transport}, languages=${formatServerNames(
           handle.config.languages
         )}`
@@ -10390,7 +11094,7 @@ var LspServerManager = class {
       }
       handle.status = "READY";
       this.attachRestartHandler(name, handle);
-      debugLogger15.info(`LSP server ${name} started successfully`);
+      debugLogger16.info(`LSP server ${name} started successfully`);
     } catch (error) {
       handle.status = "FAILED";
       handle.error = error;
@@ -10404,21 +11108,21 @@ var LspServerManager = class {
       }
       await this.releaseServerResources(name, handle, false);
       if (handle.processDiagnostics) {
-        debugLogger15.error(
+        debugLogger16.error(
           `LSP server ${name} process diagnostics:`,
           handle.processDiagnostics
         );
       }
       handle.connection = void 0;
       handle.process = void 0;
-      debugLogger15.error(`LSP server ${name} failed to start:`, error);
+      debugLogger16.error(`LSP server ${name} failed to start:`, error);
     }
   }
   /**
    * Stops a server and resets runtime-only handle state.
    */
   async stopServer(name, handle) {
-    debugLogger15.info(`Stopping LSP server ${name}`);
+    debugLogger16.info(`Stopping LSP server ${name}`);
     handle.stopRequested = true;
     handle.startupAbortController?.abort();
     if (handle.startingPromise) {
@@ -10431,7 +11135,7 @@ var LspServerManager = class {
     handle.status = "NOT_STARTED";
     handle.warmedUp = false;
     handle.restartAttempts = 0;
-    debugLogger15.info(`LSP server ${name} stopped`);
+    debugLogger16.info(`LSP server ${name} stopped`);
   }
   async abortAndWaitForStartup(handle) {
     if (!handle.startingPromise) {
@@ -10455,14 +11159,14 @@ var LspServerManager = class {
           handle.connection.end();
         }
       } catch (error) {
-        debugLogger15.error(`Error closing LSP server ${name}:`, error);
+        debugLogger16.error(`Error closing LSP server ${name}:`, error);
       }
     }
     if (handle.process && handle.process.exitCode === null) {
       try {
         handle.process.kill();
       } catch (error) {
-        debugLogger15.warn(`Error killing LSP server ${name} process:`, error);
+        debugLogger16.warn(`Error killing LSP server ${name} process:`, error);
       }
     }
   }
@@ -10482,8 +11186,8 @@ var LspServerManager = class {
       try {
         await Promise.race([
           shutdownPromise,
-          new Promise((resolve5) => {
-            timerId = setTimeout(resolve5, timeout);
+          new Promise((resolve6) => {
+            timerId = setTimeout(resolve6, timeout);
             if (typeof timerId === "object" && timerId !== null && "unref" in timerId) {
               timerId.unref();
             }
@@ -10508,7 +11212,7 @@ var LspServerManager = class {
       }
       handle.processExitedUnexpectedly = true;
       if (!handle.config.restartOnCrash) {
-        debugLogger15.warn(
+        debugLogger16.warn(
           `LSP server ${name} exited but restartOnCrash is disabled`
         );
         handle.status = "FAILED";
@@ -10517,7 +11221,7 @@ var LspServerManager = class {
       }
       const maxRestarts = handle.config.maxRestarts ?? DEFAULT_LSP_MAX_RESTARTS;
       if (maxRestarts <= 0) {
-        debugLogger15.warn(
+        debugLogger16.warn(
           `LSP server ${name} exited but maxRestarts is ${maxRestarts}`
         );
         handle.status = "FAILED";
@@ -10526,7 +11230,7 @@ var LspServerManager = class {
       }
       const attempts = handle.restartAttempts ?? 0;
       if (attempts >= maxRestarts) {
-        debugLogger15.warn(
+        debugLogger16.warn(
           `LSP server ${name} reached max restart attempts (${maxRestarts}), stopping restarts`
         );
         handle.status = "FAILED";
@@ -10534,7 +11238,7 @@ var LspServerManager = class {
         return;
       }
       handle.restartAttempts = attempts + 1;
-      debugLogger15.warn(
+      debugLogger16.warn(
         `LSP server ${name} exited (code ${code ?? "unknown"}), restarting (${handle.restartAttempts}/${maxRestarts})`
       );
       this.enqueueCrashRestart(name, handle);
@@ -10582,7 +11286,7 @@ var LspServerManager = class {
     const next = this.reconcileQueue.then(restart, restart);
     this.reconcileQueue = next.catch(() => void 0);
     void next.catch((error) => {
-      debugLogger15.warn(`LSP server ${name} crash restart failed:`, error);
+      debugLogger16.warn(`LSP server ${name} crash restart failed:`, error);
     });
   }
   resetHandle(handle) {
@@ -10590,14 +11294,14 @@ var LspServerManager = class {
       try {
         handle.connection.end();
       } catch (error) {
-        debugLogger15.warn("Error closing LSP connection during reset:", error);
+        debugLogger16.warn("Error closing LSP connection during reset:", error);
       }
     }
     if (handle.process && handle.process.exitCode === null) {
       try {
         handle.process.kill();
       } catch (error) {
-        debugLogger15.warn("Error killing LSP process during reset:", error);
+        debugLogger16.warn("Error killing LSP process during reset:", error);
       }
     }
     handle.connection = void 0;
@@ -10616,7 +11320,7 @@ var LspServerManager = class {
     const filteredEnv = {};
     for (const [key, value] of Object.entries(env2)) {
       if (SECURITY_SENSITIVE_ENV_KEYS.has(key.toUpperCase())) {
-        debugLogger15.warn(
+        debugLogger16.warn(
           `Ignoring security-sensitive LSP server env override: ${key}`
         );
         continue;
@@ -10642,7 +11346,7 @@ var LspServerManager = class {
     for (const [key, value] of Object.entries(env2)) {
       const normalizedKey = key.toUpperCase();
       if (normalizedKey === "PATH" || SECURITY_SENSITIVE_ENV_KEYS.has(normalizedKey)) {
-        debugLogger15.warn(
+        debugLogger16.warn(
           `Ignoring security-sensitive LSP command probe env override: ${key}`
         );
         continue;
@@ -10686,11 +11390,11 @@ var LspServerManager = class {
   }
   async delayWithAbort(delayMs, signal) {
     if (!signal) {
-      await new Promise((resolve5) => setTimeout(resolve5, delayMs));
+      await new Promise((resolve6) => setTimeout(resolve6, delayMs));
       return;
     }
     this.throwIfStartupAborted(signal);
-    await new Promise((resolve5, reject) => {
+    await new Promise((resolve6, reject) => {
       const onAbort = /* @__PURE__ */ __name(() => {
         clearTimeout(timerId);
         signal.removeEventListener("abort", onAbort);
@@ -10698,7 +11402,7 @@ var LspServerManager = class {
       }, "onAbort");
       const timerId = setTimeout(() => {
         signal.removeEventListener("abort", onAbort);
-        resolve5();
+        resolve6();
       }, delayMs);
       signal.addEventListener("abort", onAbort, { once: true });
     });
@@ -10867,7 +11571,7 @@ var LspServerManager = class {
    */
   async waitForSocketProcessSpawn(process3, signal) {
     this.throwIfStartupAborted(signal);
-    await new Promise((resolve5, reject) => {
+    await new Promise((resolve6, reject) => {
       let settled = false;
       const cleanup = /* @__PURE__ */ __name(() => {
         process3.off("spawn", onSpawn);
@@ -10882,7 +11586,7 @@ var LspServerManager = class {
         cleanup();
         complete();
       }, "settle");
-      const onSpawn = /* @__PURE__ */ __name(() => settle(resolve5), "onSpawn");
+      const onSpawn = /* @__PURE__ */ __name(() => settle(resolve6), "onSpawn");
       const onError = /* @__PURE__ */ __name((error) => settle(
         () => reject(new Error(`Failed to spawn LSP server: ${error.message}`))
       ), "onError");
@@ -10891,7 +11595,7 @@ var LspServerManager = class {
           try {
             process3.kill();
           } catch (error) {
-            debugLogger15.warn(
+            debugLogger16.warn(
               "Error killing aborted LSP socket process:",
               error
             );
@@ -10936,7 +11640,7 @@ var LspServerManager = class {
   async initializeLspServer(connection, config) {
     const workspaceFolderPath = config.workspaceFolder ?? this.workspaceRoot;
     const workspaceFolder = {
-      name: path10.basename(workspaceFolderPath) || workspaceFolderPath,
+      name: path11.basename(workspaceFolderPath) || workspaceFolderPath,
       uri: config.rootUri
     };
     const initializeParams = {
@@ -10998,7 +11702,7 @@ var LspServerManager = class {
    * @returns true if the command can be spawned, false if not found
    */
   async commandExists(command, env2, cwd) {
-    return new Promise((resolve5) => {
+    return new Promise((resolve6) => {
       let settled = false;
       const settle = /* @__PURE__ */ __name((value) => {
         if (settled) {
@@ -11006,7 +11710,7 @@ var LspServerManager = class {
         }
         settled = true;
         clearTimeout(timerId);
-        resolve5(value);
+        resolve6(value);
       }, "settle");
       const child = spawn2(command, ["--version"], {
         stdio: ["ignore", "ignore", "ignore"],
@@ -11041,16 +11745,16 @@ var LspServerManager = class {
    * - Relative paths that escape the workspace (e.g. "../../bin/evil")
    */
   isPathSafe(command, workspacePath, cwd) {
-    if (!command.includes(path10.sep) && !command.includes("/")) {
+    if (!command.includes(path11.sep) && !command.includes("/")) {
       return true;
     }
-    if (path10.isAbsolute(command)) {
+    if (path11.isAbsolute(command)) {
       return true;
     }
-    const resolvedWorkspacePath = path10.resolve(workspacePath);
-    const basePath = cwd ? path10.resolve(cwd) : resolvedWorkspacePath;
-    const resolvedPath = path10.resolve(basePath, command);
-    return resolvedPath.startsWith(resolvedWorkspacePath + path10.sep) || resolvedPath === resolvedWorkspacePath;
+    const resolvedWorkspacePath = path11.resolve(workspacePath);
+    const basePath = cwd ? path11.resolve(cwd) : resolvedWorkspacePath;
+    const resolvedPath = path11.resolve(basePath, command);
+    return resolvedPath.startsWith(resolvedWorkspacePath + path11.sep) || resolvedPath === resolvedWorkspacePath;
   }
   /**
    * Check whether the workspace trust level allows starting an LSP server.
@@ -11064,12 +11768,12 @@ var LspServerManager = class {
       return true;
     }
     if (this.requireTrustedWorkspace || serverConfig.trustRequired) {
-      debugLogger15.warn(
+      debugLogger16.warn(
         `Workspace not trusted, skipping LSP server ${serverName} (${serverConfig.command ?? serverConfig.transport})`
       );
       return false;
     }
-    debugLogger15.info(
+    debugLogger16.info(
       `Untrusted workspace, but LSP server ${serverName} has trustRequired=false, attempting cautious startup`
     );
     return true;
@@ -11310,11 +12014,11 @@ var NativeLspClient = class {
 
 // packages/core/src/lsp/NativeLspService.ts
 init_esbuild_shims();
-import * as path11 from "path";
+import * as path12 from "path";
 import { fileURLToPath, pathToFileURL as pathToFileURL3 } from "url";
-import * as fs9 from "node:fs";
+import * as fs10 from "node:fs";
 import { promises as fsp } from "node:fs";
-var debugLogger16 = createDebugLogger("LSP");
+var debugLogger17 = createDebugLogger("LSP");
 var LANGUAGE_ID_TO_EXTENSIONS = {
   typescript: ["ts", "tsx"],
   typescriptreact: ["tsx"],
@@ -11372,7 +12076,7 @@ var NativeLspService = class {
     const workspaceTrusted = this.config.isTrustedFolder();
     this.serverManager.clearServerHandles();
     if (this.requireTrustedWorkspace && !workspaceTrusted) {
-      debugLogger16.warn(
+      debugLogger17.warn(
         "Workspace is not trusted, skipping LSP server discovery"
       );
       return;
@@ -11390,7 +12094,7 @@ var NativeLspService = class {
       serverConfigs,
       workspaceTrusted
     );
-    debugLogger16.info(
+    debugLogger17.info(
       `Discovered ${admitted.length} LSP server config(s): ${formatServerNames2(
         admitted.map((config) => config.name)
       )}, skipped=${formatServerNames2(skipped.map((server) => server.name))}`
@@ -11425,7 +12129,7 @@ var NativeLspService = class {
   async doReinitialize(signal) {
     this.throwIfReinitializeAborted(signal);
     const workspaceTrusted = this.config.isTrustedFolder();
-    debugLogger16.info(
+    debugLogger17.info(
       `Reinitializing LSP servers: workspaceRoot=${this.workspaceRoot}, trusted=${workspaceTrusted}`
     );
     if (this.requireTrustedWorkspace && !workspaceTrusted) {
@@ -11444,7 +12148,7 @@ var NativeLspService = class {
         },
         skipped: []
       };
-      debugLogger16.info(
+      debugLogger17.info(
         `LSP reinitialize result: added=<none>, removed=${formatServerNames2(
           removed
         )}, restarted=<none>, unchanged=<none>, failed=<none>, skipped=<none>`
@@ -11486,7 +12190,7 @@ var NativeLspService = class {
       signal
     );
     this.throwIfReinitializeAborted(signal);
-    debugLogger16.info(
+    debugLogger17.info(
       `LSP reinitialize result: added=${formatServerNames2(
         reconcile.added
       )}, removed=${formatServerNames2(
@@ -11506,7 +12210,7 @@ var NativeLspService = class {
     const skipped = [];
     for (const config of configs) {
       if (!workspaceTrusted && config.trustRequired) {
-        debugLogger16.warn(
+        debugLogger17.warn(
           `LSP server ${config.name} requires trusted workspace, skipping`
         );
         skipped.push({ name: config.name, reason: "server_trust_required" });
@@ -11551,7 +12255,7 @@ var NativeLspService = class {
         try {
           openedAny = this.sendDocumentOpen(name, handle, uri) || openedAny;
         } catch (error) {
-          debugLogger16.warn(
+          debugLogger17.warn(
             `Failed to replay document ${uri} for LSP server ${name}:`,
             error
           );
@@ -11680,14 +12384,14 @@ var NativeLspService = class {
     try {
       filePath = fileURLToPath(uri);
     } catch (error) {
-      debugLogger16.warn(`Failed to resolve file path for ${uri}:`, error);
+      debugLogger17.warn(`Failed to resolve file path for ${uri}:`, error);
       return false;
     }
     let text;
     try {
-      text = fs9.readFileSync(filePath, "utf-8");
+      text = fs10.readFileSync(filePath, "utf-8");
     } catch (error) {
-      debugLogger16.warn(
+      debugLogger17.warn(
         `Failed to read file for LSP didOpen: ${filePath}`,
         error
       );
@@ -11725,7 +12429,7 @@ var NativeLspService = class {
     this.openedDocuments.set(serverName, openedForServer);
   }
   resolveLanguageId(filePath, handle) {
-    const ext = path11.extname(filePath).slice(1).toLowerCase();
+    const ext = path12.extname(filePath).slice(1).toLowerCase();
     if (ext && handle.config.extensionToLanguage) {
       const mapping = handle.config.extensionToLanguage;
       return mapping[ext] ?? mapping["." + ext];
@@ -11853,11 +12557,11 @@ var NativeLspService = class {
   }
   async delay(ms, signal) {
     if (!signal) {
-      await new Promise((resolve5) => setTimeout(resolve5, ms));
+      await new Promise((resolve6) => setTimeout(resolve6, ms));
       return;
     }
     this.throwIfReinitializeAborted(signal);
-    await new Promise((resolve5, reject) => {
+    await new Promise((resolve6, reject) => {
       const onAbort = /* @__PURE__ */ __name(() => {
         clearTimeout(timer);
         signal.removeEventListener("abort", onAbort);
@@ -11865,7 +12569,7 @@ var NativeLspService = class {
       }, "onAbort");
       const timer = setTimeout(() => {
         signal.removeEventListener("abort", onAbort);
-        resolve5();
+        resolve6();
       }, ms);
       signal.addEventListener("abort", onAbort, { once: true });
     });
@@ -11915,7 +12619,7 @@ var NativeLspService = class {
           }
         }
       } catch (error) {
-        debugLogger16.warn(
+        debugLogger17.warn(
           `LSP workspace/symbol failed for ${serverName}:`,
           error
         );
@@ -11966,7 +12670,7 @@ var NativeLspService = class {
           return definitions.slice(0, limit);
         }
       } catch (error) {
-        debugLogger16.warn(
+        debugLogger17.warn(
           `LSP textDocument/definition failed for ${name}:`,
           error
         );
@@ -12020,7 +12724,7 @@ var NativeLspService = class {
           return refs.slice(0, limit);
         }
       } catch (error) {
-        debugLogger16.warn(
+        debugLogger17.warn(
           `LSP textDocument/references failed for ${name}:`,
           error
         );
@@ -12061,7 +12765,7 @@ var NativeLspService = class {
           return normalized2;
         }
       } catch (error) {
-        debugLogger16.warn(`LSP textDocument/hover failed for ${name}:`, error);
+        debugLogger17.warn(`LSP textDocument/hover failed for ${name}:`, error);
       }
     }
     return null;
@@ -12121,7 +12825,7 @@ var NativeLspService = class {
           return symbols.slice(0, limit);
         }
       } catch (error) {
-        debugLogger16.warn(
+        debugLogger17.warn(
           `LSP textDocument/documentSymbol failed for ${name}:`,
           error
         );
@@ -12175,7 +12879,7 @@ var NativeLspService = class {
           return implementations.slice(0, limit);
         }
       } catch (error) {
-        debugLogger16.warn(
+        debugLogger17.warn(
           `LSP textDocument/implementation failed for ${name}:`,
           error
         );
@@ -12229,7 +12933,7 @@ var NativeLspService = class {
           return items.slice(0, limit);
         }
       } catch (error) {
-        debugLogger16.warn(
+        debugLogger17.warn(
           `LSP textDocument/prepareCallHierarchy failed for ${name}:`,
           error
         );
@@ -12269,7 +12973,7 @@ var NativeLspService = class {
           return calls.slice(0, limit);
         }
       } catch (error) {
-        debugLogger16.warn(
+        debugLogger17.warn(
           `LSP callHierarchy/incomingCalls failed for ${name}:`,
           error
         );
@@ -12309,7 +13013,7 @@ var NativeLspService = class {
           return calls.slice(0, limit);
         }
       } catch (error) {
-        debugLogger16.warn(
+        debugLogger17.warn(
           `LSP callHierarchy/outgoingCalls failed for ${name}:`,
           error
         );
@@ -12349,7 +13053,7 @@ var NativeLspService = class {
           }
         }
       } catch (error) {
-        debugLogger16.warn(
+        debugLogger17.warn(
           `LSP textDocument/diagnostic failed for ${name}:`,
           error
         );
@@ -12391,7 +13095,7 @@ var NativeLspService = class {
           }
         }
       } catch (error) {
-        debugLogger16.warn(`LSP workspace/diagnostic failed for ${name}:`, error);
+        debugLogger17.warn(`LSP workspace/diagnostic failed for ${name}:`, error);
       }
       if (results.length >= limit) {
         break;
@@ -12441,7 +13145,7 @@ var NativeLspService = class {
           return actions.slice(0, limit);
         }
       } catch (error) {
-        debugLogger16.warn(
+        debugLogger17.warn(
           `LSP textDocument/codeAction failed for ${name}:`,
           error
         );
@@ -12469,7 +13173,7 @@ var NativeLspService = class {
       }
       return true;
     } catch (error) {
-      debugLogger16.error("Failed to apply workspace edit:", error);
+      debugLogger17.error("Failed to apply workspace edit:", error);
       return false;
     }
   }
@@ -12478,8 +13182,8 @@ var NativeLspService = class {
    */
   async applyTextEdits(uri, edits) {
     let filePath = uri.startsWith("file://") ? fileURLToPath(uri) : uri;
-    if (!path11.isAbsolute(filePath)) {
-      filePath = path11.resolve(this.workspaceRoot, filePath);
+    if (!path12.isAbsolute(filePath)) {
+      filePath = path12.resolve(this.workspaceRoot, filePath);
     }
     if (!this.workspaceContext.isPathWithinWorkspace(filePath)) {
       throw new Error(`Refusing to apply edits outside workspace: ${filePath}`);
@@ -12514,7 +13218,7 @@ var NativeLspService = class {
       lines.splice(startLine, endLine - startLine + 1, ...newLines);
     }
     try {
-      await fsp.access(filePath, fs9.constants.W_OK);
+      await fsp.access(filePath, fs10.constants.W_OK);
     } catch (err) {
       if (err?.code !== "ENOENT") {
         throw err;
@@ -12732,7 +13436,7 @@ __name(createFollowupController, "createFollowupController");
 
 // packages/core/src/followup/suggestionGenerator.ts
 init_esbuild_shims();
-var debugLogger17 = createDebugLogger("FOLLOWUP");
+var debugLogger18 = createDebugLogger("FOLLOWUP");
 var SUGGESTION_PROMPT = `[SUGGESTION MODE: Suggest what the user might naturally type next.]
 
 FIRST: Read the LAST FEW LINES of the assistant's most recent message -- that's where
@@ -12794,7 +13498,7 @@ async function generatePromptSuggestion(config, conversationHistory, abortSignal
     const cacheSafe = options?.enableCacheSharing ? getCacheSafeParams(sessionId) : null;
     const modelOverride = options?.model;
     const cacheSharingState = cacheSafe ? "true" : cacheSafeSessionId ? "session_mismatch" : "false";
-    debugLogger17.debug(
+    debugLogger18.debug(
       `Generating suggestion: cacheSharing=${cacheSharingState}, model=${modelOverride || "(default)"}`
     );
     const raw = cacheSafe ? await generateViaForkedQuery(
@@ -12810,23 +13514,23 @@ async function generatePromptSuggestion(config, conversationHistory, abortSignal
     );
     const suggestion = typeof raw === "string" ? raw.trim() : null;
     if (!suggestion) {
-      debugLogger17.debug("Suggestion generation returned empty result");
+      debugLogger18.debug("Suggestion generation returned empty result");
       return { suggestion: null, filterReason: "empty" };
     }
     const filterReason = getFilterReason(suggestion);
     if (filterReason) {
-      debugLogger17.debug(
+      debugLogger18.debug(
         `Suggestion filtered: reason=${filterReason}, text="${suggestion}"`
       );
       return { suggestion: null, filterReason };
     }
-    debugLogger17.debug(`Suggestion accepted: "${suggestion}"`);
+    debugLogger18.debug(`Suggestion accepted: "${suggestion}"`);
     return { suggestion };
   } catch (error) {
     if (abortSignal.aborted) {
       return { suggestion: null };
     }
-    debugLogger17.warn("Suggestion generation failed:", error);
+    debugLogger18.warn("Suggestion generation failed:", error);
     return { suggestion: null, filterReason: "error" };
   }
 }
@@ -12980,7 +13684,7 @@ __name(getFilterReason, "getFilterReason");
 init_esbuild_shims();
 import { mkdir as mkdir3, copyFile, rm } from "node:fs/promises";
 import { existsSync as existsSync3 } from "node:fs";
-import { join as join7, dirname as dirname4, relative, isAbsolute as isAbsolute5 } from "node:path";
+import { join as join9, dirname as dirname5, relative, isAbsolute as isAbsolute5 } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 var OverlayFs = class {
@@ -12988,7 +13692,7 @@ var OverlayFs = class {
   constructor(realCwd) {
     this.realCwd = realCwd;
     const id = randomUUID().slice(0, 8);
-    this.overlayDir = join7(
+    this.overlayDir = join9(
       tmpdir(),
       "qwen-speculation",
       String(process.pid),
@@ -13027,9 +13731,9 @@ var OverlayFs = class {
     if (this.writtenFiles.has(rel)) {
       return this.writtenFiles.get(rel);
     }
-    const overlayPath = join7(this.overlayDir, rel);
-    await mkdir3(dirname4(overlayPath), { recursive: true });
-    const originalPath = join7(this.realCwd, rel);
+    const overlayPath = join9(this.overlayDir, rel);
+    await mkdir3(dirname5(overlayPath), { recursive: true });
+    const originalPath = join9(this.realCwd, rel);
     if (existsSync3(originalPath)) {
       try {
         await copyFile(originalPath, overlayPath);
@@ -13052,9 +13756,9 @@ var OverlayFs = class {
   async applyToReal() {
     const applied = [];
     for (const [rel, overlayPath] of this.writtenFiles) {
-      const realPath = join7(this.realCwd, rel);
+      const realPath = join9(this.realCwd, rel);
       try {
-        await mkdir3(dirname4(realPath), { recursive: true });
+        await mkdir3(dirname5(realPath), { recursive: true });
         await copyFile(overlayPath, realPath);
         applied.push(realPath);
       } catch {
@@ -13076,7 +13780,7 @@ var OverlayFs = class {
    * Returns null if the path is outside cwd.
    */
   toRelative(inputPath) {
-    const abs = isAbsolute5(inputPath) ? inputPath : join7(this.realCwd, inputPath);
+    const abs = isAbsolute5(inputPath) ? inputPath : join9(this.realCwd, inputPath);
     const rel = relative(this.realCwd, abs);
     if (isAbsolute5(rel) || rel.startsWith("..")) {
       return null;
@@ -13165,7 +13869,7 @@ __name(rewritePathArgs, "rewritePathArgs");
 
 // packages/core/src/followup/speculation.ts
 init_esbuild_shims();
-var debugLogger18 = createDebugLogger("SPECULATION");
+var debugLogger19 = createDebugLogger("SPECULATION");
 var MAX_SPECULATION_TURNS = 20;
 var MAX_SPECULATION_MESSAGES = 100;
 function observeSpeculationProducer(params) {
@@ -13413,7 +14117,7 @@ async function runSpeculativeLoop(config, state, cacheSafe, modelOverride) {
               break;
             }
             if (!guardDecision.allowed) {
-              debugLogger18.debug(
+              debugLogger19.debug(
                 `Speculative guard denial: ${guardDecision.reason}`
               );
               hitBoundary = true;
@@ -13651,20 +14355,20 @@ __name(generatePipelinedSuggestion, "generatePipelinedSuggestion");
 // packages/core/src/utils/filesearch/fileSearch.ts
 init_esbuild_shims();
 var import_picomatch3 = __toESM(require_picomatch(), 1);
-import path15 from "node:path";
+import path16 from "node:path";
 
 // packages/core/src/utils/filesearch/ignore.ts
 init_esbuild_shims();
 var import_ignore = __toESM(require_ignore(), 1);
 var import_picomatch = __toESM(require_picomatch(), 1);
-import fs10 from "node:fs";
-import path12 from "node:path";
+import fs11 from "node:fs";
+import path13 from "node:path";
 var hasFileExtension = (0, import_picomatch.default)("**/*[*.]*");
-var debugLogger19 = createDebugLogger("FILE_SEARCH_IGNORE");
+var debugLogger20 = createDebugLogger("FILE_SEARCH_IGNORE");
 function loadIgnoreRules(options) {
   const ignorer = new Ignore();
   if (options.useGitignore) {
-    const gitignorePath = path12.join(options.projectRoot, ".gitignore");
+    const gitignorePath = path13.join(options.projectRoot, ".gitignore");
     const gitignoreContent = readIgnoreFile(gitignorePath);
     if (gitignoreContent !== void 0) {
       ignorer.add(gitignoreContent);
@@ -13674,7 +14378,7 @@ function loadIgnoreRules(options) {
     for (const ignoreFileName of getQwenIgnoreFileNames(
       options.customIgnoreFiles
     )) {
-      const qwenignorePath = path12.join(options.projectRoot, ignoreFileName);
+      const qwenignorePath = path13.join(options.projectRoot, ignoreFileName);
       const qwenignoreContent = readIgnoreFile(qwenignorePath);
       if (qwenignoreContent !== void 0) {
         ignorer.addSource(qwenignoreContent);
@@ -13695,11 +14399,11 @@ function loadIgnoreRules(options) {
 __name(loadIgnoreRules, "loadIgnoreRules");
 function readIgnoreFile(filePath) {
   try {
-    return fs10.readFileSync(filePath, "utf8");
+    return fs11.readFileSync(filePath, "utf8");
   } catch (_error) {
     const error = _error;
     if (error.code !== "ENOENT") {
-      debugLogger19.warn(`Failed to read ${filePath}: ${error.message}`);
+      debugLogger20.warn(`Failed to read ${filePath}: ${error.message}`);
     }
     return void 0;
   }
@@ -13848,8 +14552,8 @@ __name(hasGlobSyntax, "hasGlobSyntax");
 // packages/core/src/utils/filesearch/crawler.ts
 init_esbuild_shims();
 var import_fdir = __toESM(require_dist(), 1);
-import path13 from "node:path";
-import fs11 from "node:fs";
+import path14 from "node:path";
+import fs12 from "node:fs";
 import { spawn as spawn3 } from "node:child_process";
 
 // packages/core/src/utils/filesearch/crawlCache.ts
@@ -13934,7 +14638,7 @@ var write = /* @__PURE__ */ __name((key, results, ttlMs) => {
 
 // packages/core/src/utils/filesearch/crawler.ts
 function toPosixPath(p) {
-  return p.split(path13.sep).join(path13.posix.sep);
+  return p.split(path14.sep).join(path14.posix.sep);
 }
 __name(toPosixPath, "toPosixPath");
 function normalizeGitPath(p, stripTrailingSlash = false) {
@@ -14030,7 +14734,7 @@ function redactArgsForLog(args) {
     if (/^[A-Za-z]:[\\/]/.test(t) || t.startsWith("/") && t.length > 1) {
       return "<abs-path>";
     }
-    if (t.includes(path13.sep) && t.length > 32) {
+    if (t.includes(path14.sep) && t.length > 32) {
       return "<path>";
     }
     return t;
@@ -14061,7 +14765,7 @@ function withSafeGitConfig(args) {
 }
 __name(withSafeGitConfig, "withSafeGitConfig");
 function canonicalStatePath(p) {
-  return toPosixPath(path13.resolve(p));
+  return toPosixPath(path14.resolve(p));
 }
 __name(canonicalStatePath, "canonicalStatePath");
 function getStateKey(options) {
@@ -14106,28 +14810,28 @@ function resolveGitDir(crawlDirectory) {
   }
   let current = crawlDirectory;
   while (current) {
-    const gitPath = path13.join(current, ".git");
+    const gitPath = path14.join(current, ".git");
     try {
-      const stat4 = fs11.statSync(gitPath);
-      if (stat4.isDirectory()) {
+      const stat5 = fs12.statSync(gitPath);
+      if (stat5.isDirectory()) {
         pathCacheSet(resolveGitDirCache, cacheKey, gitPath);
         return gitPath;
       }
-      if (stat4.isFile()) {
-        const contents = fs11.readFileSync(gitPath, "utf8").trim();
+      if (stat5.isFile()) {
+        const contents = fs12.readFileSync(gitPath, "utf8").trim();
         const match = contents.match(/^gitdir:\s*(.+)$/i);
         if (!match) {
           pathCacheSet(resolveGitDirCache, cacheKey, null);
           return null;
         }
         const resolvedGitDir = match[1].trim();
-        let resolvedAbs = path13.isAbsolute(resolvedGitDir) ? path13.resolve(resolvedGitDir) : path13.resolve(current, resolvedGitDir);
+        let resolvedAbs = path14.isAbsolute(resolvedGitDir) ? path14.resolve(resolvedGitDir) : path14.resolve(current, resolvedGitDir);
         try {
-          resolvedAbs = fs11.realpathSync(resolvedAbs);
+          resolvedAbs = fs12.realpathSync(resolvedAbs);
           try {
-            fs11.statSync(path13.join(resolvedAbs, "HEAD"));
+            fs12.statSync(path14.join(resolvedAbs, "HEAD"));
           } catch {
-            fs11.statSync(path13.join(resolvedAbs, "index"));
+            fs12.statSync(path14.join(resolvedAbs, "index"));
           }
         } catch {
           pathCacheSet(resolveGitDirCache, cacheKey, null);
@@ -14143,7 +14847,7 @@ function resolveGitDir(crawlDirectory) {
         return null;
       }
     }
-    const parent = path13.dirname(current);
+    const parent = path14.dirname(current);
     if (parent === current) {
       break;
     }
@@ -14159,8 +14863,8 @@ function getGitRootMtime(crawlDirectory) {
     if (!gitDir) {
       return null;
     }
-    const indexPath = path13.join(gitDir, "index");
-    const indexStat = fs11.statSync(indexPath);
+    const indexPath = path14.join(gitDir, "index");
+    const indexStat = fs12.statSync(indexPath);
     return indexStat.mtimeMs;
   } catch {
   }
@@ -14216,7 +14920,7 @@ function computeLinesFingerprint(lines) {
 __name(computeLinesFingerprint, "computeLinesFingerprint");
 function runCommand(command, args, cwd, timeoutMs = 2e4, options) {
   const collectLines = options?.collectLines !== false;
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     const lines = [];
     let settled = false;
     let timedOut = false;
@@ -14228,7 +14932,7 @@ function runCommand(command, args, cwd, timeoutMs = 2e4, options) {
         return;
       }
       settled = true;
-      resolve5({ success, lines: resultLines });
+      resolve6({ success, lines: resultLines });
     }, "finalize");
     let stderrBuf = "";
     let child;
@@ -14396,19 +15100,19 @@ function normalizePath(p) {
 }
 __name(normalizePath, "normalizePath");
 function getPosixRelative(from, to) {
-  const fromResolved = path13.resolve(from);
-  const toResolved = path13.resolve(to);
+  const fromResolved = path14.resolve(from);
+  const toResolved = path14.resolve(to);
   let fromAbs = fromResolved;
   let toAbs = toResolved;
   try {
-    fromAbs = fs11.realpathSync(fromResolved);
+    fromAbs = fs12.realpathSync(fromResolved);
   } catch {
   }
   try {
-    toAbs = fs11.realpathSync(toResolved);
+    toAbs = fs12.realpathSync(toResolved);
   } catch {
   }
-  const relative2 = path13.relative(fromAbs, toAbs);
+  const relative2 = path14.relative(fromAbs, toAbs);
   const posixRel = toPosixPath(relative2);
   return posixRel === "" ? "." : posixRel;
 }
@@ -14417,18 +15121,18 @@ function isValidIgnorePath(relativePath) {
   if (!relativePath || relativePath === ".") {
     return false;
   }
-  if (path13.posix.isAbsolute(relativePath)) {
+  if (path14.posix.isAbsolute(relativePath)) {
     return false;
   }
   return relativePath !== ".." && !relativePath.startsWith("../") && !relativePath.includes("/../");
 }
 __name(isValidIgnorePath, "isValidIgnorePath");
 function toFdirExcludeRelativePath(crawlDirectory, dirPath) {
-  const base = path13.resolve(crawlDirectory);
-  const absoluteCandidate = path13.isAbsolute(dirPath) ? dirPath : path13.join(base, dirPath);
-  let rel = path13.relative(base, absoluteCandidate);
+  const base = path14.resolve(crawlDirectory);
+  const absoluteCandidate = path14.isAbsolute(dirPath) ? dirPath : path14.join(base, dirPath);
+  let rel = path14.relative(base, absoluteCandidate);
   rel = toPosixPath(rel);
-  if (!rel || rel.startsWith("..") || path13.posix.isAbsolute(rel)) {
+  if (!rel || rel.startsWith("..") || path14.posix.isAbsolute(rel)) {
     return null;
   }
   return isValidIgnorePath(rel) ? rel : null;
@@ -14518,7 +15222,7 @@ __name(isUnderIgnoredDirectory, "isUnderIgnoredDirectory");
 var YIELD_INTERVAL = 1e3;
 async function maybeYield(index) {
   if (index > 0 && index % YIELD_INTERVAL === 0) {
-    await new Promise((resolve5) => setImmediate(resolve5));
+    await new Promise((resolve6) => setImmediate(resolve6));
   }
 }
 __name(maybeYield, "maybeYield");
@@ -14635,16 +15339,16 @@ function posixPathUnderGitRoot(normalizedFile, relativeToGitRoot, relativeToCraw
   if (relativeToGitRoot && relativeToGitRoot !== ".") {
     const rest = sliceAfterGitPathspecPrefix(nf, normGitRoot);
     if (rest !== null) {
-      return path13.posix.join(normCrawlDir, rest);
+      return path14.posix.join(normCrawlDir, rest);
     }
     if (equalsRepoRelativeCaseAware(nf, normGitRoot)) {
       const base = nf.replace(/\/+$/, "");
       return `${base}/`;
     }
     const nfFile = nf.replace(/\/+$/, "");
-    return path13.posix.join(normCrawlDir, nfFile);
+    return path14.posix.join(normCrawlDir, nfFile);
   }
-  return path13.posix.join(normCrawlDir, nf.replace(/\/+$/, ""));
+  return path14.posix.join(normCrawlDir, nf.replace(/\/+$/, ""));
 }
 __name(posixPathUnderGitRoot, "posixPathUnderGitRoot");
 async function crawlWithGitLsFiles(stateKey, crawlDirectory, cwd, options, workingTreePrefetch) {
@@ -14721,13 +15425,13 @@ async function crawlWithGitLsFiles(stateKey, crawlDirectory, cwd, options, worki
     if (deletedSet.has(normalizedFile)) {
       return true;
     }
-    let stat4;
+    let stat5;
     try {
-      stat4 = fs11.lstatSync(path13.join(gitRoot, ...normalizedFile.split("/")));
+      stat5 = fs12.lstatSync(path14.join(gitRoot, ...normalizedFile.split("/")));
     } catch {
       return true;
     }
-    if (stat4.isDirectory()) {
+    if (stat5.isDirectory()) {
       return true;
     }
     if (relativeToGitRoot && relativeToGitRoot !== "." && normalizedFile === relativeToGitRoot) {
@@ -14825,7 +15529,7 @@ function collectDirectoryRows(options) {
   const dirFilter = options.ignore.getDirectoryFilter();
   const rows = [];
   const visit = /* @__PURE__ */ __name((dir, relativePath, depth) => {
-    const cwdRelative = relativePath === "" ? relativeToCrawlDir : path13.posix.join(relativeToCrawlDir, relativePath);
+    const cwdRelative = relativePath === "" ? relativeToCrawlDir : path14.posix.join(relativeToCrawlDir, relativePath);
     if (cwdRelative !== ".") {
       const row = cwdRelative.endsWith("/") ? cwdRelative : `${cwdRelative}/`;
       if (!isValidIgnorePath(row.slice(0, -1)) || dirFilter(row)) {
@@ -14838,7 +15542,7 @@ function collectDirectoryRows(options) {
     }
     let entries;
     try {
-      entries = fs11.readdirSync(dir, { withFileTypes: true });
+      entries = fs12.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -14846,8 +15550,8 @@ function collectDirectoryRows(options) {
       if (!entry.isDirectory()) {
         continue;
       }
-      const childRelative = relativePath ? path13.posix.join(relativePath, entry.name) : entry.name;
-      visit(path13.join(dir, entry.name), childRelative, depth + 1);
+      const childRelative = relativePath ? path14.posix.join(relativePath, entry.name) : entry.name;
+      visit(path14.join(dir, entry.name), childRelative, depth + 1);
     }
   }, "visit");
   visit(options.crawlDirectory, "", 0);
@@ -14885,7 +15589,7 @@ async function crawlWithRipgrep(stateKey, crawlDirectory, cwd, options) {
       return false;
     }
     const normalizedFile = normalizePath(file);
-    const fullPath = path13.posix.join(relativeToCrawlDir, normalizedFile);
+    const fullPath = path14.posix.join(relativeToCrawlDir, normalizedFile);
     if (!shouldIncludeFile(fullPath, dirFilter, fileFilter)) {
       return true;
     }
@@ -14944,7 +15648,7 @@ async function crawlWithFdir(options) {
       return dirFilter(`${relativePath}/`);
     }).filter((filePath, isDirectory) => {
       if (isDirectory) return true;
-      const cwdRelative = path13.posix.join(relativeToCrawlDir, filePath);
+      const cwdRelative = path14.posix.join(relativeToCrawlDir, filePath);
       if (!isValidIgnorePath(cwdRelative)) {
         return false;
       }
@@ -14957,7 +15661,7 @@ async function crawlWithFdir(options) {
   } catch {
     return [];
   }
-  const mapped = results.filter((p) => p.length > 0 && p !== ".").map((p) => path13.posix.join(relativeToCrawlDir, p));
+  const mapped = results.filter((p) => p.length > 0 && p !== ".").map((p) => path14.posix.join(relativeToCrawlDir, p));
   if (relativeToCrawlDir !== ".") {
     const rootDir = relativeToCrawlDir.endsWith("/") ? relativeToCrawlDir : `${relativeToCrawlDir}/`;
     if (!mapped.includes(rootDir)) {
@@ -15084,8 +15788,8 @@ __name(applyMaxFilesLimit, "applyMaxFilesLimit");
 
 // packages/core/src/utils/filesearch/fzfWorkerHandle.ts
 init_esbuild_shims();
-import fs12 from "node:fs";
-import path14 from "node:path";
+import fs13 from "node:fs";
+import path15 from "node:path";
 import { Worker } from "node:worker_threads";
 
 // node_modules/fzf/dist/fzf.es.js
@@ -15952,7 +16656,7 @@ function basicMatch(query) {
 __name(basicMatch, "basicMatch");
 var isNode = typeof __require !== "undefined" && typeof window === "undefined";
 function asyncMatcher(token, len, iter2, onFinish) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     const INCREMENT = 1e3;
     let i = 0, end = Math.min(INCREMENT, len);
     const step = /* @__PURE__ */ __name(() => {
@@ -15965,7 +16669,7 @@ function asyncMatcher(token, len, iter2, onFinish) {
         end = Math.min(end + INCREMENT, len);
         isNode ? setImmediate(step) : setTimeout(step);
       } else {
-        resolve5(onFinish());
+        resolve6(onFinish());
       }
     }, "step");
     step();
@@ -16137,11 +16841,11 @@ var inProcessTransport = {
 var resolvedWorkerPath;
 function getWorkerScriptPath() {
   if (resolvedWorkerPath !== void 0) return resolvedWorkerPath;
-  const candidate = path14.join(
+  const candidate = path15.join(
     resolveBundleDir(import.meta.url),
     "fzfWorker.js"
   );
-  resolvedWorkerPath = fs12.existsSync(candidate) ? candidate : null;
+  resolvedWorkerPath = fs13.existsSync(candidate) ? candidate : null;
   return resolvedWorkerPath;
 }
 __name(getWorkerScriptPath, "getWorkerScriptPath");
@@ -16237,12 +16941,12 @@ var workerTransport = {
         }
         await readyPromise;
         const reqId = nextReqId++;
-        return new Promise((resolve5, reject) => {
+        return new Promise((resolve6, reject) => {
           if (readyState === "disposed" || readyState === "failed") {
             reject(new Error(`fzf worker not available (${readyState})`));
             return;
           }
-          pending.set(reqId, { resolve: resolve5, reject });
+          pending.set(reqId, { resolve: resolve6, reject });
           try {
             worker.postMessage({ type: "find", reqId, pattern, limit });
           } catch (err) {
@@ -16337,7 +17041,7 @@ async function filter(allPaths, pattern, signal) {
   const results = [];
   for (const [i, p] of allPaths.entries()) {
     if (i % 1e3 === 0) {
-      await new Promise((resolve5) => setImmediate(resolve5));
+      await new Promise((resolve6) => setImmediate(resolve6));
       if (signal?.aborted) {
         throw new AbortError();
       }
@@ -16416,7 +17120,7 @@ var RecursiveFileSearch = class {
     const results = [];
     for (const [i, candidate] of filteredCandidates.entries()) {
       if (i % 1e3 === 0) {
-        await new Promise((resolve5) => setImmediate(resolve5));
+        await new Promise((resolve6) => setImmediate(resolve6));
         if (options.signal?.aborted) {
           throw new AbortError();
         }
@@ -16458,9 +17162,9 @@ var DirectoryFileSearch = class {
       throw new Error("Engine not initialized. Call initialize() first.");
     }
     pattern = pattern || "*";
-    const dir = pattern.endsWith("/") ? pattern : path15.dirname(pattern);
-    const crawlDirectory = path15.join(this.options.projectRoot, dir);
-    const listingProjectRoot = path15.resolve(crawlDirectory) === path15.resolve(this.options.projectRoot);
+    const dir = pattern.endsWith("/") ? pattern : path16.dirname(pattern);
+    const crawlDirectory = path16.join(this.options.projectRoot, dir);
+    const listingProjectRoot = path16.resolve(crawlDirectory) === path16.resolve(this.options.projectRoot);
     const results = await crawl({
       crawlDirectory,
       cwd: this.options.projectRoot,
@@ -16541,13 +17245,13 @@ __name(analyzeToolResultRetention, "analyzeToolResultRetention");
 
 // packages/core/src/utils/pathReader.ts
 init_esbuild_shims();
-import { promises as fs13 } from "node:fs";
-import path16 from "node:path";
+import { promises as fs14 } from "node:fs";
+import path17 from "node:path";
 async function readPathFromWorkspace(pathStr, config) {
   const workspace = config.getWorkspaceContext();
   const fileService = config.getFileService();
   let absolutePath = null;
-  if (path16.isAbsolute(pathStr)) {
+  if (path17.isAbsolute(pathStr)) {
     if (!workspace.isPathWithinWorkspace(pathStr)) {
       throw new Error(
         `Absolute path is outside of the allowed workspace: ${pathStr}`
@@ -16557,9 +17261,9 @@ async function readPathFromWorkspace(pathStr, config) {
   } else {
     const searchDirs = workspace.getDirectories();
     for (const dir of searchDirs) {
-      const potentialPath = path16.resolve(dir, pathStr);
+      const potentialPath = path17.resolve(dir, pathStr);
       try {
-        await fs13.access(potentialPath);
+        await fs14.access(potentialPath);
         absolutePath = potentialPath;
         break;
       } catch {
@@ -16569,7 +17273,7 @@ async function readPathFromWorkspace(pathStr, config) {
   if (!absolutePath) {
     throw new Error(`Path not found in workspace: ${pathStr}`);
   }
-  const stats = await fs13.stat(absolutePath);
+  const stats = await fs14.stat(absolutePath);
   if (stats.isDirectory()) {
     const allParts = [];
     allParts.push({
@@ -16585,7 +17289,7 @@ async function readPathFromWorkspace(pathStr, config) {
       absolute: true
     });
     const relativeFiles = files.map(
-      (p) => path16.relative(config.getTargetDir(), p)
+      (p) => path17.relative(config.getTargetDir(), p)
     );
     const filteringOptions = config.getFileFilteringOptions();
     const filteredFiles = fileService.filterFiles(relativeFiles, {
@@ -16593,10 +17297,10 @@ async function readPathFromWorkspace(pathStr, config) {
       respectQwenIgnore: filteringOptions.respectQwenIgnore
     });
     const finalFiles = filteredFiles.map(
-      (p) => path16.resolve(config.getTargetDir(), p)
+      (p) => path17.resolve(config.getTargetDir(), p)
     );
     for (const filePath of finalFiles) {
-      const relativePathForDisplay = path16.relative(absolutePath, filePath);
+      const relativePathForDisplay = path17.relative(absolutePath, filePath);
       allParts.push({ text: `--- ${relativePathForDisplay} ---
 ` });
       const result = await processSingleFileContent(filePath, config, {
@@ -16612,7 +17316,7 @@ async function readPathFromWorkspace(pathStr, config) {
     allParts.push({ text: `--- End of content for directory: ${pathStr} ---` });
     return allParts;
   } else {
-    const relativePath = path16.relative(config.getTargetDir(), absolutePath);
+    const relativePath = path17.relative(config.getTargetDir(), absolutePath);
     const singleFileFilteringOptions = config.getFileFilteringOptions();
     const filtered = fileService.filterFiles([relativePath], {
       respectGitIgnore: singleFileFilteringOptions.respectGitIgnore,
@@ -16631,25 +17335,25 @@ __name(readPathFromWorkspace, "readPathFromWorkspace");
 
 // packages/core/src/utils/projectSummary.ts
 init_esbuild_shims();
-import * as fs14 from "fs/promises";
-import * as path17 from "path";
+import * as fs15 from "fs/promises";
+import * as path18 from "path";
 var PROJECT_SUMMARY_FILENAME = "PROJECT_SUMMARY.md";
 var WELCOME_BACK_STATE_FILENAME = "welcome-back-state.json";
 function getProjectSummaryPath() {
-  return path17.join(process.cwd(), ".qwen", PROJECT_SUMMARY_FILENAME);
+  return path18.join(process.cwd(), ".qwen", PROJECT_SUMMARY_FILENAME);
 }
 __name(getProjectSummaryPath, "getProjectSummaryPath");
 function getWelcomeBackStatePath() {
-  return path17.join(process.cwd(), ".qwen", WELCOME_BACK_STATE_FILENAME);
+  return path18.join(process.cwd(), ".qwen", WELCOME_BACK_STATE_FILENAME);
 }
 __name(getWelcomeBackStatePath, "getWelcomeBackStatePath");
-function buildSummaryFingerprint(stat4) {
-  return `${stat4.mtimeMs}:${stat4.size}`;
+function buildSummaryFingerprint(stat5) {
+  return `${stat5.mtimeMs}:${stat5.size}`;
 }
 __name(buildSummaryFingerprint, "buildSummaryFingerprint");
 async function getWelcomeBackState() {
   try {
-    const raw = await fs14.readFile(getWelcomeBackStatePath(), "utf-8");
+    const raw = await fs15.readFile(getWelcomeBackStatePath(), "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.version !== 1 || parsed.lastChoice !== "restart" || typeof parsed.summaryFingerprint !== "string") {
       return null;
@@ -16665,7 +17369,7 @@ async function getWelcomeBackState() {
 __name(getWelcomeBackState, "getWelcomeBackState");
 async function saveWelcomeBackRestartChoice(summaryFingerprint) {
   const statePath = getWelcomeBackStatePath();
-  await fs14.mkdir(path17.dirname(statePath), { recursive: true });
+  await fs15.mkdir(path18.dirname(statePath), { recursive: true });
   const state = {
     version: 1,
     lastChoice: "restart",
@@ -16678,7 +17382,7 @@ async function saveWelcomeBackRestartChoice(summaryFingerprint) {
 __name(saveWelcomeBackRestartChoice, "saveWelcomeBackRestartChoice");
 async function clearWelcomeBackState() {
   try {
-    await fs14.rm(getWelcomeBackStatePath(), { force: true });
+    await fs15.rm(getWelcomeBackStatePath(), { force: true });
   } catch {
   }
 }
@@ -16686,15 +17390,15 @@ __name(clearWelcomeBackState, "clearWelcomeBackState");
 async function getProjectSummaryInfo() {
   const summaryPath = getProjectSummaryPath();
   try {
-    await fs14.access(summaryPath);
+    await fs15.access(summaryPath);
   } catch {
     return {
       hasHistory: false
     };
   }
   try {
-    const summaryStat = await fs14.stat(summaryPath);
-    const content = await fs14.readFile(summaryPath, "utf-8");
+    const summaryStat = await fs15.stat(summaryPath);
+    const content = await fs15.readFile(summaryPath, "utf-8");
     const summaryFingerprint = buildSummaryFingerprint(summaryStat);
     const timestampMatch = content.match(/\*\*Update time\*\*: (.+)/);
     const timestamp = timestampMatch ? timestampMatch[1] : (/* @__PURE__ */ new Date()).toISOString();
@@ -16762,9 +17466,9 @@ __name(getProjectSummaryInfo, "getProjectSummaryInfo");
 
 // packages/core/src/tools/readManyFiles.ts
 init_esbuild_shims();
-import * as fs15 from "node:fs";
-import * as os2 from "node:os";
-import * as path18 from "node:path";
+import * as fs16 from "node:fs";
+import * as os3 from "node:os";
+import * as path19 from "node:path";
 var DEFAULT_OUTPUT_HEADER = "\n--- Content from referenced files ---";
 var DEFAULT_OUTPUT_TERMINATOR = "\n--- End of content ---";
 var SNAPSHOT_MAX_SIZE_BYTES = 100 * 1024 * 1024;
@@ -16784,7 +17488,7 @@ async function readManyFiles(config, options) {
     for (const rawPattern of inputPatterns) {
       signal?.throwIfAborted();
       const normalizedPattern = rawPattern.replace(/\\/g, "/");
-      const fullPath = path18.resolve(projectRoot, normalizedPattern);
+      const fullPath = path19.resolve(projectRoot, normalizedPattern);
       const displayPath = displayPaths?.get(fullPath) ?? fullPath;
       const validatedIdentity = validatedPathIdentities?.get(fullPath);
       if (validatedPathIdentities && !validatedIdentity) continue;
@@ -16803,7 +17507,7 @@ async function readManyFiles(config, options) {
       if (validatedIdentity && !await matchesValidatedPathIdentity(fullPath, validatedIdentity)) {
         continue;
       }
-      const stats = fs15.existsSync(fullPath) ? fs15.statSync(fullPath) : null;
+      const stats = fs16.existsSync(fullPath) ? fs16.statSync(fullPath) : null;
       if (stats?.isDirectory()) {
         const { contentParts: dirParts, info } = await readDirectory(
           config,
@@ -16923,9 +17627,9 @@ async function readValidatedTextFileContent(config, filePath, expected, preserve
 __name(readValidatedTextFileContent, "readValidatedTextFileContent");
 async function matchesValidatedPathIdentity(filePath, expected) {
   try {
-    const canonicalPath = await fs15.promises.realpath(filePath);
+    const canonicalPath = await fs16.promises.realpath(filePath);
     if (canonicalPath !== filePath) return false;
-    const stats = await fs15.promises.stat(canonicalPath);
+    const stats = await fs16.promises.stat(canonicalPath);
     return statsMatchValidatedIdentity(stats, expected);
   } catch {
     return false;
@@ -16954,13 +17658,13 @@ async function snapshotValidatedFile(filePath, expected, signal) {
       if (stats.size > SNAPSHOT_MAX_SIZE_BYTES) {
         return void 0;
       }
-      snapshotDir = await fs15.promises.mkdtemp(
-        path18.join(os2.tmpdir(), "qwen-validated-read-")
+      snapshotDir = await fs16.promises.mkdtemp(
+        path19.join(os3.tmpdir(), "qwen-validated-read-")
       );
-      const snapshotPath = path18.join(snapshotDir, path18.basename(filePath));
-      const target = await fs15.promises.open(
+      const snapshotPath = path19.join(snapshotDir, path19.basename(filePath));
+      const target = await fs16.promises.open(
         snapshotPath,
-        fs15.constants.O_WRONLY | fs15.constants.O_CREAT | fs15.constants.O_EXCL,
+        fs16.constants.O_WRONLY | fs16.constants.O_CREAT | fs16.constants.O_EXCL,
         384
       );
       try {
@@ -17001,7 +17705,7 @@ async function snapshotValidatedFile(filePath, expected, signal) {
       result = {
         filePath: snapshotPath,
         stats,
-        cleanup: /* @__PURE__ */ __name(() => fs15.promises.rm(snapshotDir, { recursive: true, force: true }), "cleanup")
+        cleanup: /* @__PURE__ */ __name(() => fs16.promises.rm(snapshotDir, { recursive: true, force: true }), "cleanup")
       };
       return result;
     } finally {
@@ -17013,7 +17717,7 @@ async function snapshotValidatedFile(filePath, expected, signal) {
     return void 0;
   } finally {
     if (snapshotDir && !result) {
-      await fs15.promises.rm(snapshotDir, { recursive: true, force: true });
+      await fs16.promises.rm(snapshotDir, { recursive: true, force: true });
     }
   }
 }
@@ -17165,6 +17869,8 @@ export {
   encodeInsightErrorMessage,
   Logger,
   executeToolCall,
+  loadOutputStyleCatalog,
+  findOutputStyle,
   TURN_INTERRUPTION_HISTORY_TAIL_COUNT,
   detectTurnInterruption,
   buildSessionRecoveryPlan,
@@ -17194,9 +17900,14 @@ export {
   findProviderByCredentials,
   getAllProviderBaseUrls,
   applyProviderInstallPlan,
+  isApiUserPrompt,
+  findApiRewindCutPoint,
+  countApiUserPrompts,
   IMAGE_CAPABILITY,
   generateSessionRecap,
   SessionReferenceService,
+  getLastPeerInboxFailure,
+  describePeerInboxFailure,
   startPeerInbox,
   WebTerminalRegistry,
   generateToolUseSummary,
@@ -17284,12 +17995,12 @@ export {
  */
 /**
  * @license
- * Copyright 2025 Qwen
+ * Copyright 2026 Qwen
  * SPDX-License-Identifier: Apache-2.0
  */
 /**
  * @license
- * Copyright 2026 Qwen
+ * Copyright 2025 Qwen
  * SPDX-License-Identifier: Apache-2.0
  */
 /**
@@ -17300,7 +18011,8 @@ export {
  * Shared Follow-up Suggestions State Logic
  *
  * Framework-agnostic state management for prompt suggestions,
- * shared between CLI (Ink) and WebUI (React) hooks.
+ * used by the CLI (Ink) follow-up hook; Web Shell's daemon followup hook
+ * maintains its own copy.
  */
 /**
  * @license