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

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

@@ -4,12 +4,13 @@ import {
   MAX_FRAME_BYTES,
   MAX_SOCKET_PATH_BYTES,
   SOCKET_DIR_NAME,
+  flattenPeerLabel,
   isLocalIpcPath,
   parsePeerAuthLine,
   parsePeerFrame,
   probePeerSocketVerdict,
   resolvePeerSocketCandidates
-} from "./chunk-HFTB354P.js";
+} from "./chunk-5Z4FCEPY.js";
 import {
   scanForSecrets
 } from "./chunk-BUQN5LTI.js";
@@ -74,7 +75,7 @@ import {
   stripToolResultImages,
   toolResultBoundaryArtifact,
   toolResultPartDiagnosticValues
-} from "./chunk-I72PHOKL.js";
+} from "./chunk-PDUMGZ2P.js";
 import {
   hasVerifiableInode,
   openNoFollow
@@ -87,7 +88,7 @@ import {
 } from "./chunk-FDOGGKAA.js";
 import {
   resolveBundleDir
-} from "./chunk-PZV2FASB.js";
+} from "./chunk-TRWQQBVH.js";
 import {
   glob,
   globSync
@@ -101,17 +102,17 @@ import {
 import {
   getProjectSkillsRoot,
   parse
-} from "./chunk-R355CUNQ.js";
+} from "./chunk-CLKE4IY3.js";
 import {
   require_proper_lockfile
 } from "./chunk-MLXTMF7H.js";
 import {
   BUILT_IN_OUTPUT_STYLES,
   getBuiltInOutputStyle
-} from "./chunk-GXZHYPHZ.js";
+} from "./chunk-3LPJ776W.js";
 import {
   fetchWithPolicy
-} from "./chunk-UKADFFL2.js";
+} from "./chunk-OFVAS4AR.js";
 import {
   COMBINED_PASS_TOLERANCE_FACTOR,
   TOOL_OUTPUT_TRUNCATED_PREFIX,
@@ -120,7 +121,7 @@ import {
   removeMCPStatusChangeListener,
   runSideQuery,
   updateMCPServerStatus
-} from "./chunk-P5LDR7FI.js";
+} from "./chunk-6QV7Z74P.js";
 import {
   getInvocationContext
 } from "./chunk-5ETULJLP.js";
@@ -144,7 +145,8 @@ import {
   getUserAutoMemoryRoot
 } from "./chunk-EDIDYZBT.js";
 import {
-  atomicWriteFile
+  atomicWriteFile,
+  atomicWriteJSON
 } from "./chunk-XFFRI3WM.js";
 import {
   isBinary,
@@ -157,7 +159,7 @@ import {
   getStartupContextLength,
   isSystemReminderContent,
   stripSystemReminderBlocks
-} from "./chunk-D6PIMKY3.js";
+} from "./chunk-4VY3ITHR.js";
 import {
   getQwenIgnoreFileNames,
   require_ignore
@@ -165,7 +167,7 @@ import {
 import {
   ToolNames,
   canonicalToolName
-} from "./chunk-RPBMP6BN.js";
+} from "./chunk-MWIO7MF6.js";
 import {
   PATH_ARG_KEYS,
   QWEN_DIR,
@@ -173,6 +175,7 @@ import {
   createDebugLogger,
   getErrorMessage,
   isAbortError,
+  isNodeError,
   tildeifyPath,
   unescapePath
 } from "./chunk-ZAFYHRVY.js";
@@ -194,8 +197,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(path20) {
-      let normalized2 = (0, path_1.normalize)(path20);
+    function cleanPath(path21) {
+      let normalized2 = (0, path_1.normalize)(path21);
       if (normalized2.length > 1 && normalized2[normalized2.length - 1] === path_1.sep)
         normalized2 = normalized2.substring(0, normalized2.length - 1);
       return normalized2;
@@ -203,28 +206,28 @@ var require_utils = __commonJS({
     __name(cleanPath, "cleanPath");
     exports.cleanPath = cleanPath;
     var SLASHES_REGEX = /[\\/]/g;
-    function convertSlashes(path20, separator) {
-      return path20.replace(SLASHES_REGEX, separator);
+    function convertSlashes(path21, separator) {
+      return path21.replace(SLASHES_REGEX, separator);
     }
     __name(convertSlashes, "convertSlashes");
     exports.convertSlashes = convertSlashes;
     var WINDOWS_ROOT_DIR_REGEX = /^[a-z]:[\\/]$/i;
-    function isRootDirectory(path20) {
-      return path20 === "/" || WINDOWS_ROOT_DIR_REGEX.test(path20);
+    function isRootDirectory(path21) {
+      return path21 === "/" || WINDOWS_ROOT_DIR_REGEX.test(path21);
     }
     __name(isRootDirectory, "isRootDirectory");
     exports.isRootDirectory = isRootDirectory;
-    function normalizePath2(path20, options) {
+    function normalizePath2(path21, options) {
       const { resolvePaths, normalizePath: normalizePath3, pathSeparator } = options;
-      const pathNeedsCleaning = process.platform === "win32" && path20.includes("/") || path20.startsWith(".");
+      const pathNeedsCleaning = process.platform === "win32" && path21.includes("/") || path21.startsWith(".");
       if (resolvePaths)
-        path20 = (0, path_1.resolve)(path20);
+        path21 = (0, path_1.resolve)(path21);
       if (normalizePath3 || pathNeedsCleaning)
-        path20 = cleanPath(path20);
-      if (path20 === ".")
+        path21 = cleanPath(path21);
+      if (path21 === ".")
         return "";
-      const needsSeperator = path20[path20.length - 1] !== pathSeparator;
-      return convertSlashes(needsSeperator ? path20 + pathSeparator : path20, pathSeparator);
+      const needsSeperator = path21[path21.length - 1] !== pathSeparator;
+      return convertSlashes(needsSeperator ? path21 + pathSeparator : path21, pathSeparator);
     }
     __name(normalizePath2, "normalizePath");
     exports.normalizePath = normalizePath2;
@@ -299,9 +302,9 @@ var require_push_directory = __commonJS({
       paths.push(directoryPath || ".");
     }, "pushDirectory");
     var pushDirectoryFilter = /* @__PURE__ */ __name((directoryPath, paths, filters) => {
-      const path20 = directoryPath || ".";
-      if (filters.every((filter2) => filter2(path20, true))) {
-        paths.push(path20);
+      const path21 = directoryPath || ".";
+      if (filters.every((filter2) => filter2(path21, true))) {
+        paths.push(path21);
       }
     }, "pushDirectoryFilter");
     var empty = /* @__PURE__ */ __name(() => {
@@ -412,29 +415,29 @@ 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(path20, state, callback) {
+    var resolveSymlinksAsync = /* @__PURE__ */ __name(function(path21, state, callback) {
       const { queue, options: { suppressErrors } } = state;
       queue.enqueue();
-      fs_1.default.realpath(path20, (error, resolvedPath) => {
+      fs_1.default.realpath(path21, (error, resolvedPath) => {
         if (error)
           return queue.dequeue(suppressErrors ? null : error, state);
         fs_1.default.stat(resolvedPath, (error2, stat5) => {
           if (error2)
             return queue.dequeue(suppressErrors ? null : error2, state);
-          if (stat5.isDirectory() && isRecursive(path20, resolvedPath, state))
+          if (stat5.isDirectory() && isRecursive(path21, resolvedPath, state))
             return queue.dequeue(null, state);
           callback(stat5, resolvedPath);
           queue.dequeue(null, state);
         });
       });
     }, "resolveSymlinksAsync");
-    var resolveSymlinks = /* @__PURE__ */ __name(function(path20, state, callback) {
+    var resolveSymlinks = /* @__PURE__ */ __name(function(path21, state, callback) {
       const { queue, options: { suppressErrors } } = state;
       queue.enqueue();
       try {
-        const resolvedPath = fs_1.default.realpathSync(path20);
+        const resolvedPath = fs_1.default.realpathSync(path21);
         const stat5 = fs_1.default.statSync(resolvedPath);
-        if (stat5.isDirectory() && isRecursive(path20, resolvedPath, state))
+        if (stat5.isDirectory() && isRecursive(path21, resolvedPath, state))
           return;
         callback(stat5, resolvedPath);
       } catch (e) {
@@ -449,10 +452,10 @@ var require_resolve_symlink = __commonJS({
     }
     __name(build, "build");
     exports.build = build;
-    function isRecursive(path20, resolved, state) {
+    function isRecursive(path21, resolved, state) {
       if (state.options.useRealPaths)
         return isRecursiveUsingRealPaths(resolved, state);
-      let parent = (0, path_1.dirname)(path20);
+      let parent = (0, path_1.dirname)(path21);
       let depth = 1;
       while (parent !== state.root && depth < 2) {
         const resolvedPath = state.symlinks.get(parent);
@@ -462,7 +465,7 @@ var require_resolve_symlink = __commonJS({
         else
           parent = (0, path_1.dirname)(parent);
       }
-      state.symlinks.set(path20, resolved);
+      state.symlinks.set(path21, resolved);
       return depth > 1;
     }
     __name(isRecursive, "isRecursive");
@@ -748,21 +751,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 path20 = joinPath.joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
-            if (exclude && exclude(entry.name, path20))
+            let path21 = joinPath.joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
+            if (exclude && exclude(entry.name, path21))
               continue;
-            this.pushDirectory(path20, paths, filters);
-            this.walkDirectory(this.state, path20, path20, depth - 1, this.walk);
+            this.pushDirectory(path21, paths, filters);
+            this.walkDirectory(this.state, path21, path21, depth - 1, this.walk);
           } else if (this.resolveSymlink && entry.isSymbolicLink()) {
-            let path20 = joinPath.joinPathWithBasePath(entry.name, directoryPath);
-            this.resolveSymlink(path20, this.state, (stat5, resolvedPath) => {
+            let path21 = joinPath.joinPathWithBasePath(entry.name, directoryPath);
+            this.resolveSymlink(path21, this.state, (stat5, resolvedPath) => {
               if (stat5.isDirectory()) {
                 resolvedPath = (0, utils_1.normalizePath)(resolvedPath, this.state.options);
-                if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path20 + pathSeparator))
+                if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path21 + pathSeparator))
                   return;
-                this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path20 + pathSeparator, depth - 1, this.walk);
+                this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path21 + pathSeparator, depth - 1, this.walk);
               } else {
-                resolvedPath = useRealPaths ? resolvedPath : path20;
+                resolvedPath = useRealPaths ? resolvedPath : path21;
                 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);
@@ -787,11 +790,11 @@ var require_async = __commonJS({
     exports.callback = exports.promise = void 0;
     var walker_1 = require_walker();
     function promise(root, options) {
-      return new Promise((resolve6, reject) => {
+      return new Promise((resolve7, reject) => {
         callback(root, options, (err, output) => {
           if (err)
             return reject(err);
-          resolve6(output);
+          resolve7(output);
         });
       });
     }
@@ -989,7 +992,7 @@ var require_builder = __commonJS({
           isMatch = globFn(patterns, ...options);
           this.globCache[patterns.join("\0")] = isMatch;
         }
-        this.options.filters.push((path20) => isMatch(path20));
+        this.options.filters.push((path21) => isMatch(path21));
         return this;
       }
     };
@@ -1069,7 +1072,7 @@ var JsonFormatter = class {
 // packages/core/src/core/nonInteractiveToolExecutor.ts
 init_esbuild_shims();
 async function executeToolCall(config, toolCallRequest, abortSignal, options = {}) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     new CoreToolScheduler({
       config,
       chatRecordingService: options.recordToolResult === false ? void 0 : config.getChatRecordingService(),
@@ -1078,7 +1081,7 @@ async function executeToolCall(config, toolCallRequest, abortSignal, options = {
         if (options.onAllToolCallsComplete) {
           await options.onAllToolCallsComplete(completedToolCalls);
         }
-        resolve6(completedToolCalls[0].response);
+        resolve7(completedToolCalls[0].response);
       }, "onAllToolCallsComplete"),
       onToolCallsUpdate: options.onToolCallsUpdate,
       onToolResultFullTurnModel: options.onToolResultFullTurnModel,
@@ -2572,7 +2575,7 @@ var McpTransportPool = class {
         spawnWait.then(() => {
           if (inflightTimer) clearTimeout(inflightTimer);
         }),
-        new Promise((resolve6) => {
+        new Promise((resolve7) => {
           inflightTimer = setTimeout(
             () => {
               const stuckIds = [...this.spawnInFlight.keys()];
@@ -2581,7 +2584,7 @@ var McpTransportPool = class {
                   ", "
                 )}. Proceeding with drain.`
               );
-              resolve6();
+              resolve7();
             },
             Math.max(0, deadline - Date.now())
           );
@@ -2607,8 +2610,8 @@ var McpTransportPool = class {
       Promise.all(shutdownPromises).then(() => {
         if (drainTimer) clearTimeout(drainTimer);
       }),
-      new Promise((resolve6) => {
-        drainTimer = setTimeout(() => resolve6(), remaining);
+      new Promise((resolve7) => {
+        drainTimer = setTimeout(() => resolve7(), remaining);
         drainTimer.unref?.();
       })
     ]);
@@ -3290,6 +3293,7 @@ function specToModelConfig(spec, prefix, baseUrl, envKey) {
     id: spec.id,
     name: prefix ? `[${prefix}] ${spec.id}` : spec.id,
     ...spec.description ? { description: spec.description } : {},
+    ...spec.capabilities ? { capabilities: spec.capabilities } : {},
     baseUrl,
     envKey,
     ...spec.supportsImageGeneration ? { supportsImageGeneration: true } : {},
@@ -3324,11 +3328,16 @@ function buildModelConfigs(config, inputs) {
       (spec) => specToModelConfig(spec, prefix, inputs.baseUrl, envKey)
     );
   } else if (config.models && config.modelsEditable) {
-    const specMap = new Map(config.models.map((s) => [s.id, s]));
+    const specMap = new Map(config.models.map((s) => [s.id.toLowerCase(), s]));
     models = inputs.modelIds.map((id) => {
-      const spec = specMap.get(id);
+      const spec = specMap.get(id.toLowerCase());
       if (spec) {
-        return specToModelConfig(spec, prefix, inputs.baseUrl, envKey);
+        return specToModelConfig(
+          { ...spec, id },
+          prefix,
+          inputs.baseUrl,
+          envKey
+        );
       }
       const genConfig = buildAdvancedGenerationConfig(inputs.advancedConfig);
       return {
@@ -3838,7 +3847,14 @@ var deepseekProvider = {
     {
       id: "deepseek-v4-pro",
       contextWindowSize: 1e6,
-      enableThinking: true
+      capabilities: {
+        reasoning: {
+          thinking: true,
+          efforts: ["high", "max"],
+          defaultEffort: "high",
+          disableField: "thinking"
+        }
+      }
     },
     { id: "deepseek-v4-flash", contextWindowSize: 1e6 }
   ],
@@ -4986,7 +5002,30 @@ async function bindAt(requestedPath, options, automaticPath) {
     }, "arm");
     arm();
     let authed = options.requiredToken === void 0;
-    let auth;
+    let credential;
+    let controllerToken;
+    let controllerDeadline = null;
+    const armControllerRevalidation = /* @__PURE__ */ __name(() => {
+      if (controllerDeadline) clearTimeout(controllerDeadline);
+      controllerDeadline = setTimeout(() => {
+        controllerDeadline = null;
+        if (refused || credential?.kind !== "controller" || controllerToken === void 0) {
+          return;
+        }
+        const controller = resolveController(options, controllerToken);
+        if (!controller) {
+          debugLogger6.debug(
+            "dropping a controller connection whose grant was revoked"
+          );
+          refused = true;
+          socket.destroy();
+          return;
+        }
+        credential = { kind: "controller", controller };
+        armControllerRevalidation();
+      }, lineDeadlineMs);
+      controllerDeadline.unref();
+    }, "armControllerRevalidation");
     let refused = false;
     const read2 = createLineReader(
       (line) => {
@@ -4995,10 +5034,14 @@ async function bindAt(requestedPath, options, automaticPath) {
           arm();
           const presented = parsePeerAuthLine(line);
           if (presented !== null) {
-            auth = authKindOf(options, presented);
+            credential = authKindOf(options, presented);
           }
-          if (auth !== void 0) {
+          if (credential !== void 0) {
             authed = true;
+            if (credential.kind === "controller") {
+              controllerToken = presented ?? void 0;
+              armControllerRevalidation();
+            }
             return;
           }
           debugLogger6.debug(
@@ -5017,7 +5060,7 @@ async function bindAt(requestedPath, options, automaticPath) {
         }
         arm();
         try {
-          options.onFrame(frame, auth);
+          options.onFrame(frame, credential?.kind, credential?.controller);
         } catch (error) {
           debugLogger6.error(`onFrame threw: ${describe(error)}`);
         }
@@ -5039,6 +5082,8 @@ async function bindAt(requestedPath, options, automaticPath) {
     socket.on("close", () => {
       if (deadline) clearTimeout(deadline);
       deadline = null;
+      if (controllerDeadline) clearTimeout(controllerDeadline);
+      controllerDeadline = null;
       connections.delete(socket);
     });
   });
@@ -5046,11 +5091,11 @@ async function bindAt(requestedPath, options, automaticPath) {
   server.on("error", (error) => {
     debugLogger6.error(`peer inbox server error: ${describe(error)}`);
   });
-  const listenAt = /* @__PURE__ */ __name((target) => new Promise((resolve6, reject) => {
+  const listenAt = /* @__PURE__ */ __name((target) => new Promise((resolve7, reject) => {
     server.once("error", reject);
     server.listen(target, () => {
       server.removeListener("error", reject);
-      resolve6();
+      resolve7();
     });
   }), "listenAt");
   try {
@@ -5110,7 +5155,7 @@ async function bindAt(requestedPath, options, automaticPath) {
         closed = true;
         for (const socket of connections) socket.destroy();
         connections.clear();
-        await new Promise((resolve6) => server.close(() => resolve6()));
+        await new Promise((resolve7) => server.close(() => resolve7()));
         try {
           await fs.unlink(socketPath);
         } catch {
@@ -5130,11 +5175,26 @@ __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";
+  const controller = resolveController(options, presented);
+  if (peer) return { kind: "peer" };
+  if (child) return { kind: "child" };
+  if (controller) return { kind: "controller", controller };
   return void 0;
 }
 __name(authKindOf, "authKindOf");
+function resolveController(options, presented) {
+  try {
+    return options.resolveController?.(presented);
+  } catch (error) {
+    debugLogger6.debug(
+      `controller resolver threw (treating the token as unknown): ${describe(
+        error
+      )}`
+    );
+    return void 0;
+  }
+}
+__name(resolveController, "resolveController");
 function describe(error) {
   return error instanceof Error ? `${error.name}: ${error.message}` : String(error);
 }
@@ -6580,9 +6640,9 @@ function encodeInsightProgressMessage(stage, progress, detail) {
   return JSON.stringify(payload);
 }
 __name(encodeInsightProgressMessage, "encodeInsightProgressMessage");
-function encodeInsightReadyMessage(path20) {
+function encodeInsightReadyMessage(path21) {
   const payload = {
-    insight_ready: { path: path20 }
+    insight_ready: { path: path21 }
   };
   return JSON.stringify(payload);
 }
@@ -6958,9 +7018,9 @@ var Logger = class {
       );
       return;
     }
-    const path20 = this._checkpointPath(tag);
+    const path21 = this._checkpointPath(tag);
     try {
-      await atomicWriteFile(path20, JSON.stringify(conversation, null, 2), {
+      await atomicWriteFile(path21, JSON.stringify(conversation, null, 2), {
         encoding: "utf-8"
       });
     } catch (error) {
@@ -6974,13 +7034,13 @@ var Logger = class {
       );
       return [];
     }
-    const path20 = await this._getCheckpointPath(tag);
+    const path21 = await this._getCheckpointPath(tag);
     try {
-      const fileContent = await fs3.readFile(path20, "utf-8");
+      const fileContent = await fs3.readFile(path21, "utf-8");
       const parsedContent = JSON.parse(fileContent);
       if (!Array.isArray(parsedContent)) {
         this.debugLogger.warn(
-          `Checkpoint file at ${path20} is not a valid JSON array. Returning empty checkpoint.`
+          `Checkpoint file at ${path21} is not a valid JSON array. Returning empty checkpoint.`
         );
         return [];
       }
@@ -6991,7 +7051,7 @@ var Logger = class {
         return [];
       }
       this.debugLogger.error(
-        `Failed to read or parse checkpoint file ${path20}:`,
+        `Failed to read or parse checkpoint file ${path21}:`,
         error
       );
       return [];
@@ -7465,7 +7525,7 @@ var ClientMcpRegistrar = class {
       }
       return Promise.resolve(ack);
     }
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve7, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id);
         reject(
@@ -7475,7 +7535,7 @@ var ClientMcpRegistrar = class {
         );
       }, this.messageTimeoutMs);
       timer.unref?.();
-      this.pending.set(id, { resolve: resolve6, reject, timer, server: serverName });
+      this.pending.set(id, { resolve: resolve7, reject, timer, server: serverName });
       let sendResult;
       try {
         sendResult = this.sendFrame({
@@ -7720,12 +7780,377 @@ ${body}`;
   }
 };
 
+// packages/core/src/ipc/peer-controllers.ts
+init_esbuild_shims();
+var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
+import { createHash as createHash3, randomBytes as randomBytes2, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
+import * as fsSync2 from "node:fs";
+import * as fs5 from "node:fs/promises";
+import * as path7 from "node:path";
+var debugLogger11 = createDebugLogger("PEER_CONTROLLERS");
+var PEER_CONTROLLER_SCHEMA_VERSION = 1;
+var CONTROLLER_TOKEN_PREFIX = "qpc_";
+var CONTROLLER_TOKEN_BYTES = 32;
+var MAX_PRESENTED_TOKEN_CHARS = 256;
+var MAX_CONTROLLER_LABEL_CHARS = 40;
+var MAX_CONTROLLERS = 32;
+var MAX_REGISTRY_BYTES = 64 * 1024;
+var REGISTRY_FILE_MODE = 384;
+var REGISTRY_DIRECTORY_MODE = 448;
+var LOCK_OPTIONS = {
+  realpath: false,
+  stale: 5e3,
+  retries: {
+    retries: 10,
+    minTimeout: 5,
+    maxTimeout: 100,
+    factor: 2,
+    randomize: true
+  },
+  onCompromised: /* @__PURE__ */ __name((error) => {
+    debugLogger11.debug(
+      `controller registry lock compromised: ${describe2(error)}`
+    );
+  }, "onCompromised")
+};
+var CONTROLLER_ID_RE = /^c_[0-9a-f]{8}$/;
+var TOKEN_HASH_RE = /^[0-9a-f]{64}$/;
+var PeerControllerError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "PeerControllerError";
+  }
+  static {
+    __name(this, "PeerControllerError");
+  }
+};
+var defaultRegistryPath;
+function getPeerControllerRegistryPath() {
+  defaultRegistryPath ??= path7.resolve(
+    Storage.getGlobalQwenDir(),
+    "peer-controllers.json"
+  );
+  return defaultRegistryPath;
+}
+__name(getPeerControllerRegistryPath, "getPeerControllerRegistryPath");
+function hashControllerToken(token) {
+  return createHash3("sha256").update(token, "utf8").digest("hex");
+}
+__name(hashControllerToken, "hashControllerToken");
+function mintControllerToken() {
+  return CONTROLLER_TOKEN_PREFIX + randomBytes2(CONTROLLER_TOKEN_BYTES).toString("hex");
+}
+__name(mintControllerToken, "mintControllerToken");
+function emptyRegistry() {
+  return { schemaVersion: PEER_CONTROLLER_SCHEMA_VERSION, controllers: [] };
+}
+__name(emptyRegistry, "emptyRegistry");
+function describe2(error) {
+  return error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+}
+__name(describe2, "describe");
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isRecord, "isRecord");
+function toValidRecord(value) {
+  if (!isRecord(value)) return null;
+  const { id, label, tokenHash, createdAt } = value;
+  if (typeof id !== "string" || !CONTROLLER_ID_RE.test(id)) return null;
+  if (typeof tokenHash !== "string" || !TOKEN_HASH_RE.test(tokenHash)) {
+    return null;
+  }
+  if (typeof label !== "string") return null;
+  const flattened = flattenPeerLabel(label);
+  if (flattened.length === 0 || flattened.length > MAX_CONTROLLER_LABEL_CHARS) {
+    return null;
+  }
+  if (typeof createdAt !== "number" || !Number.isFinite(createdAt)) return null;
+  return { id, label: flattened, tokenHash, createdAt };
+}
+__name(toValidRecord, "toValidRecord");
+function readPeerControllerRegistrySync(filePath = getPeerControllerRegistryPath()) {
+  let raw;
+  try {
+    const stats = fsSync2.lstatSync(filePath);
+    if (!stats.isFile()) {
+      debugLogger11.debug(
+        `ignoring the controller registry at ${filePath}: not a regular file`
+      );
+      return emptyRegistry();
+    }
+    if (stats.size > MAX_REGISTRY_BYTES) {
+      debugLogger11.debug(
+        `ignoring the controller registry at ${filePath}: ${stats.size} bytes exceeds the ${MAX_REGISTRY_BYTES}-byte cap`
+      );
+      return emptyRegistry();
+    }
+    raw = fsSync2.readFileSync(filePath, "utf8");
+  } catch (error) {
+    if (!isNodeError(error) || error.code !== "ENOENT") {
+      debugLogger11.debug(
+        `could not read the controller registry at ${filePath}: ${describe2(error)}`
+      );
+    }
+    return emptyRegistry();
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    debugLogger11.debug(
+      `the controller registry at ${filePath} is not JSON: ${describe2(error)}`
+    );
+    return emptyRegistry();
+  }
+  if (!isRecord(parsed)) return emptyRegistry();
+  if (parsed["schemaVersion"] !== PEER_CONTROLLER_SCHEMA_VERSION) {
+    debugLogger11.debug(
+      `ignoring the controller registry at ${filePath}: unsupported schemaVersion ${String(
+        parsed["schemaVersion"]
+      )}`
+    );
+    return emptyRegistry();
+  }
+  const controllers = parsed["controllers"];
+  if (!Array.isArray(controllers)) return emptyRegistry();
+  const valid = [];
+  for (const entry of controllers) {
+    const record = toValidRecord(entry);
+    if (record === null) {
+      debugLogger11.debug(
+        `skipping a malformed entry in the controller registry at ${filePath}`
+      );
+      continue;
+    }
+    valid.push(record);
+  }
+  return { schemaVersion: PEER_CONTROLLER_SCHEMA_VERSION, controllers: valid };
+}
+__name(readPeerControllerRegistrySync, "readPeerControllerRegistrySync");
+function matchControllerToken(registry, presented) {
+  if (!isPresentableControllerToken(presented)) return void 0;
+  const presentedHash = Buffer.from(hashControllerToken(presented), "hex");
+  let matched;
+  for (const record of registry.controllers) {
+    const candidate = Buffer.from(record.tokenHash, "hex");
+    if (candidate.length === presentedHash.length && timingSafeEqual2(candidate, presentedHash)) {
+      matched = { id: record.id, label: record.label };
+    }
+  }
+  return matched;
+}
+__name(matchControllerToken, "matchControllerToken");
+function isPresentableControllerToken(presented) {
+  return presented.length <= MAX_PRESENTED_TOKEN_CHARS && presented.startsWith(CONTROLLER_TOKEN_PREFIX);
+}
+__name(isPresentableControllerToken, "isPresentableControllerToken");
+function resolveControllerToken(presented, filePath) {
+  if (!isPresentableControllerToken(presented)) return void 0;
+  return matchControllerToken(
+    readPeerControllerRegistrySync(filePath),
+    presented
+  );
+}
+__name(resolveControllerToken, "resolveControllerToken");
+async function assertWritablePath(filePath) {
+  try {
+    const stats = await fs5.lstat(filePath);
+    if (!stats.isFile()) {
+      throw new PeerControllerError(
+        `${filePath} is not a regular file; move it aside first.`,
+        "unsafe-path"
+      );
+    }
+  } catch (error) {
+    if (error instanceof PeerControllerError) throw error;
+    if (isNodeError(error) && error.code === "ENOENT") return;
+    throw error;
+  }
+}
+__name(assertWritablePath, "assertWritablePath");
+async function writeRegistry(filePath, registry) {
+  await assertWritablePath(filePath);
+  await atomicWriteJSON(filePath, registry, {
+    mode: REGISTRY_FILE_MODE,
+    // The file holds credentials-in-effect: an over-permissive copy
+    // restored from a backup must be healed, not preserved.
+    forceMode: true,
+    noFollow: true
+  });
+}
+__name(writeRegistry, "writeRegistry");
+function invalidRegistry(filePath, reason, readOnly = false) {
+  return new PeerControllerError(
+    readOnly ? `Cannot read ${filePath}: ${reason}. Repair it, or move it aside to revoke every grant.` : `Refusing to modify ${filePath}: ${reason}. Move it aside or repair it first.`,
+    "invalid-registry"
+  );
+}
+__name(invalidRegistry, "invalidRegistry");
+function readPeerControllerRegistryStrictSync(filePath, options = {}) {
+  let raw;
+  try {
+    const stats = fsSync2.lstatSync(filePath);
+    if (!stats.isFile()) {
+      if (stats.isSymbolicLink()) {
+        throw new PeerControllerError(
+          `${filePath} is not a regular file; move it aside first.`,
+          "unsafe-path"
+        );
+      }
+      throw invalidRegistry(
+        filePath,
+        "it is not a regular file",
+        options.readOnly
+      );
+    }
+    if (stats.size > MAX_REGISTRY_BYTES) {
+      throw invalidRegistry(
+        filePath,
+        `it exceeds the ${MAX_REGISTRY_BYTES}-byte limit`,
+        options.readOnly
+      );
+    }
+    raw = fsSync2.readFileSync(filePath, "utf8");
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") return emptyRegistry();
+    throw error;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw invalidRegistry(filePath, "it is not valid JSON", options.readOnly);
+  }
+  if (!isRecord(parsed) || parsed["schemaVersion"] !== PEER_CONTROLLER_SCHEMA_VERSION || !Array.isArray(parsed["controllers"])) {
+    throw invalidRegistry(
+      filePath,
+      "it has an unsupported shape or version",
+      options.readOnly
+    );
+  }
+  const controllers = [];
+  for (const entry of parsed["controllers"]) {
+    const record = toValidRecord(entry);
+    if (record === null) {
+      if (options.skipMalformedEntries) continue;
+      throw invalidRegistry(
+        filePath,
+        "it contains a malformed controller",
+        options.readOnly
+      );
+    }
+    controllers.push(record);
+  }
+  return { schemaVersion: PEER_CONTROLLER_SCHEMA_VERSION, controllers };
+}
+__name(readPeerControllerRegistryStrictSync, "readPeerControllerRegistryStrictSync");
+async function withRegistryLock(filePath, mutate) {
+  const directory = path7.dirname(filePath);
+  await fs5.mkdir(directory, {
+    recursive: true,
+    mode: REGISTRY_DIRECTORY_MODE
+  });
+  const lockPath = path7.join(
+    await fs5.realpath(directory),
+    path7.basename(filePath)
+  );
+  const release = await import_proper_lockfile.default.lock(lockPath, LOCK_OPTIONS);
+  try {
+    return await mutate();
+  } finally {
+    try {
+      await release();
+    } catch {
+    }
+  }
+}
+__name(withRegistryLock, "withRegistryLock");
+async function listPeerControllers(filePath = getPeerControllerRegistryPath()) {
+  return readPeerControllerRegistryStrictSync(filePath, {
+    skipMalformedEntries: true,
+    readOnly: true
+  }).controllers;
+}
+__name(listPeerControllers, "listPeerControllers");
+async function addPeerController(label, filePath = getPeerControllerRegistryPath()) {
+  const flattened = flattenPeerLabel(label);
+  if (flattened.length === 0) {
+    throw new PeerControllerError(
+      "A controller needs a label: something you will recognize when you come to revoke it.",
+      "invalid-label"
+    );
+  }
+  if (flattened.length > MAX_CONTROLLER_LABEL_CHARS) {
+    throw new PeerControllerError(
+      `A controller label may be at most ${MAX_CONTROLLER_LABEL_CHARS} characters.`,
+      "invalid-label"
+    );
+  }
+  return withRegistryLock(filePath, async () => {
+    const registry = readPeerControllerRegistryStrictSync(filePath);
+    if (registry.controllers.some(
+      (record2) => record2.label.toLowerCase() === flattened.toLowerCase()
+    )) {
+      throw new PeerControllerError(
+        `A controller called "${flattened}" already exists. Labels are how you tell them apart when revoking, so pick another.`,
+        "duplicate-label"
+      );
+    }
+    if (registry.controllers.length >= MAX_CONTROLLERS) {
+      throw new PeerControllerError(
+        `This Qwen home already holds ${MAX_CONTROLLERS} controllers. Revoke one before adding another.`,
+        "too-many"
+      );
+    }
+    const token = mintControllerToken();
+    const taken = new Set(registry.controllers.map((record2) => record2.id));
+    let id = `c_${randomBytes2(4).toString("hex")}`;
+    while (taken.has(id)) {
+      id = `c_${randomBytes2(4).toString("hex")}`;
+    }
+    const record = {
+      id,
+      label: flattened,
+      tokenHash: hashControllerToken(token),
+      createdAt: Date.now()
+    };
+    await writeRegistry(filePath, {
+      schemaVersion: PEER_CONTROLLER_SCHEMA_VERSION,
+      controllers: [...registry.controllers, record]
+    });
+    return { record, token };
+  });
+}
+__name(addPeerController, "addPeerController");
+async function removePeerController(id, filePath = getPeerControllerRegistryPath()) {
+  return withRegistryLock(filePath, async () => {
+    const registry = readPeerControllerRegistryStrictSync(filePath, {
+      skipMalformedEntries: true
+    });
+    const needle = id.trim().toLowerCase();
+    const removed = registry.controllers.find(
+      (record) => record.id.toLowerCase() === needle
+    );
+    if (!removed) return null;
+    await writeRegistry(filePath, {
+      schemaVersion: PEER_CONTROLLER_SCHEMA_VERSION,
+      controllers: registry.controllers.filter(
+        (record) => record.tokenHash !== removed.tokenHash
+      )
+    });
+    return removed;
+  });
+}
+__name(removePeerController, "removePeerController");
+
 // packages/core/src/utils/conversation-branches.ts
 init_esbuild_shims();
 
 // packages/core/src/services/toolUseSummary.ts
 init_esbuild_shims();
-var debugLogger11 = createDebugLogger("TOOL_USE_SUMMARY");
+var debugLogger12 = 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.
@@ -7746,7 +8171,7 @@ async function generateToolUseSummary(params) {
   }
   const model = config.getFastModel();
   if (!model) {
-    debugLogger11.debug("No fast model configured \u2014 skipping summary generation");
+    debugLogger12.debug("No fast model configured \u2014 skipping summary generation");
     return null;
   }
   if (signal.aborted) {
@@ -7769,7 +8194,7 @@ ${toolSummaries}
 
 Label:`;
     if (!config.getLlmClient()) {
-      debugLogger11.debug("No gemini client available \u2014 skipping");
+      debugLogger12.debug("No gemini client available \u2014 skipping");
       return null;
     }
     const result = await runSideQuery(config, {
@@ -7788,19 +8213,19 @@ Label:`;
     });
     if (signal.aborted) return null;
     if (!result.text) {
-      debugLogger11.debug("Summary generation returned empty result");
+      debugLogger12.debug("Summary generation returned empty result");
       return null;
     }
     const cleaned = cleanSummary(result.text);
     if (!cleaned) {
-      debugLogger11.debug(`Summary cleaned to empty: raw="${result.text}"`);
+      debugLogger12.debug(`Summary cleaned to empty: raw="${result.text}"`);
       return null;
     }
-    debugLogger11.debug(`Summary generated: "${cleaned}"`);
+    debugLogger12.debug(`Summary generated: "${cleaned}"`);
     return cleaned;
   } catch (err) {
     if (signal.aborted) return null;
-    debugLogger11.warn(
+    debugLogger12.warn(
       `Summary generation failed: ${err instanceof Error ? err.message : String(err)}`
     );
     return null;
@@ -7874,7 +8299,7 @@ __name(cleanSummary, "cleanSummary");
 
 // packages/core/src/services/usage-dashboard-service.ts
 init_esbuild_shims();
-var debugLogger12 = createDebugLogger("USAGE_DASHBOARD");
+var debugLogger13 = createDebugLogger("USAGE_DASHBOARD");
 var DEFAULT_HEATMAP_DAYS = 183;
 var MAX_DAILY_DAYS = 92;
 var MS_PER_DAY = 24 * 60 * 60 * 1e3;
@@ -7999,7 +8424,7 @@ function buildUsageDashboard(records, options = {}) {
   );
   const daily = buildDaily(records, dailyStart, now);
   const heatmap = buildHeatmap(records, now - heatmapDays * MS_PER_DAY, now);
-  debugLogger12.debug(
+  debugLogger13.debug(
     `built dashboard range=${range} records=${records.length} models=${models.length} skills=${skills.length} dailyPoints=${daily.length}`
   );
   return {
@@ -8021,16 +8446,16 @@ __name(loadUsageDashboard, "loadUsageDashboard");
 
 // packages/core/src/memory/channel-memory-document.ts
 init_esbuild_shims();
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 var CHANNEL_MEMORY_DOCUMENT_VERSION = 1;
 var MAX_CHANNEL_MEMORY_ENTRIES = 500;
 var MAX_CHANNEL_MEMORY_ENTRIES_PER_REQUEST = 10;
 var MAX_CHANNEL_MEMORY_ENTRY_CODE_POINTS = 2e3;
 var CHANNEL_MEMORY_ID_RE = /^m-[a-f0-9]{12}$/u;
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-__name(isRecord, "isRecord");
+__name(isRecord2, "isRecord");
 function invalidDocument(message = "Invalid channel memory document") {
   return new Error(message);
 }
@@ -8043,7 +8468,7 @@ function validateKeys(value, allowedKeys, message) {
 }
 __name(validateKeys, "validateKeys");
 function validateEntry(value) {
-  if (!isRecord(value)) {
+  if (!isRecord2(value)) {
     throw invalidDocument("Invalid channel memory entry");
   }
   validateKeys(
@@ -8068,7 +8493,7 @@ function validateEntry(value) {
 }
 __name(validateEntry, "validateEntry");
 function parseDocumentValue(value) {
-  if (!isRecord(value)) {
+  if (!isRecord2(value)) {
     throw invalidDocument();
   }
   validateKeys(value, ["version", "migration", "entries"]);
@@ -8095,7 +8520,7 @@ function parseDocumentValue(value) {
   });
   let migration;
   if ("migration" in value) {
-    if (!isRecord(value["migration"]) || typeof value["migration"]["legacySha256"] !== "string" || !/^[a-f0-9]{64}$/u.test(value["migration"]["legacySha256"])) {
+    if (!isRecord2(value["migration"]) || typeof value["migration"]["legacySha256"] !== "string" || !/^[a-f0-9]{64}$/u.test(value["migration"]["legacySha256"])) {
       throw invalidDocument();
     }
     validateKeys(value["migration"], ["legacySha256"]);
@@ -8281,7 +8706,7 @@ function parseLegacyChannelMemory(raw) {
       continue;
     }
     normalizedTexts.add(normalizedText);
-    const digest = createHash3("sha256").update(`${normalizedText}\0${sourceLineIndex}`).digest("hex");
+    const digest = createHash4("sha256").update(`${normalizedText}\0${sourceLineIndex}`).digest("hex");
     const id = `m-${digest.slice(0, 12)}`;
     if (ids.has(id)) {
       throw new Error("Channel memory legacy ID collision");
@@ -8295,7 +8720,7 @@ function parseLegacyChannelMemory(raw) {
   return {
     version: 1,
     migration: {
-      legacySha256: createHash3("sha256").update(raw).digest("hex")
+      legacySha256: createHash4("sha256").update(raw).digest("hex")
     },
     entries
   };
@@ -8328,16 +8753,16 @@ __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 as randomBytes2 } from "node:crypto";
-import * as fs5 from "node:fs/promises";
-import * as path7 from "node:path";
+var import_proper_lockfile2 = __toESM(require_proper_lockfile(), 1);
+import { createHash as createHash5, randomBytes as randomBytes3 } from "node:crypto";
+import * as fs6 from "node:fs/promises";
+import * as path8 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 debugLogger13 = createDebugLogger("CHANNEL_MEMORY");
+var debugLogger14 = createDebugLogger("CHANNEL_MEMORY");
 var pendingMutations = /* @__PURE__ */ new Map();
-var LOCK_OPTIONS = {
+var LOCK_OPTIONS2 = {
   realpath: false,
   retries: {
     retries: 12,
@@ -8348,7 +8773,7 @@ var LOCK_OPTIONS = {
   },
   stale: 5e3,
   onCompromised: /* @__PURE__ */ __name((err) => {
-    debugLogger13.warn("channel memory lock compromised:", err);
+    debugLogger14.warn("channel memory lock compromised:", err);
   }, "onCompromised")
 };
 function isMissingFile(error) {
@@ -8371,27 +8796,27 @@ async function releaseLock(release) {
 __name(releaseLock, "releaseLock");
 async function cleanupLegacyAfterCommit(legacyPath, expectedBytes) {
   try {
-    const currentBytes = await fs5.readFile(legacyPath);
+    const currentBytes = await fs6.readFile(legacyPath);
     if (legacyHash(currentBytes) !== legacyHash(expectedBytes) || !currentBytes.equals(expectedBytes)) {
       return;
     }
-    await fs5.unlink(legacyPath);
+    await fs6.unlink(legacyPath);
   } catch {
   }
 }
 __name(cleanupLegacyAfterCommit, "cleanupLegacyAfterCommit");
 function safeChannelName(channelName) {
   const slug = channelName.replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 20) || "_";
-  const hash = createHash4("sha256").update(channelName).digest("hex").slice(0, 16);
+  const hash = createHash5("sha256").update(channelName).digest("hex").slice(0, 16);
   return `${slug}-${hash}`;
 }
 __name(safeChannelName, "safeChannelName");
 function hashedThreadPath(target) {
-  return createHash4("sha256").update(target.chatId).update("\0").update(target.threadId ?? "").digest("hex").slice(0, 32);
+  return createHash5("sha256").update(target.chatId).update("\0").update(target.threadId ?? "").digest("hex").slice(0, 32);
 }
 __name(hashedThreadPath, "hashedThreadPath");
 function getChannelMemoryDirectory(target) {
-  return path7.join(
+  return path8.join(
     Storage.getGlobalQwenDir(),
     "channels",
     "memory",
@@ -8401,11 +8826,11 @@ function getChannelMemoryDirectory(target) {
 }
 __name(getChannelMemoryDirectory, "getChannelMemoryDirectory");
 function getChannelMemoryFilePath(target) {
-  return path7.join(getChannelMemoryDirectory(target), CHANNEL_MEMORY_FILE_NAME);
+  return path8.join(getChannelMemoryDirectory(target), CHANNEL_MEMORY_FILE_NAME);
 }
 __name(getChannelMemoryFilePath, "getChannelMemoryFilePath");
 function getLegacyChannelMemoryFilePath(target) {
-  return path7.join(
+  return path8.join(
     getChannelMemoryDirectory(target),
     LEGACY_CHANNEL_MEMORY_FILE_NAME
   );
@@ -8415,8 +8840,8 @@ async function serializeMutation(directory, task) {
   const previous = pendingMutations.get(directory) ?? Promise.resolve();
   let resolveCurrent = /* @__PURE__ */ __name(() => {
   }, "resolveCurrent");
-  const current = new Promise((resolve6) => {
-    resolveCurrent = resolve6;
+  const current = new Promise((resolve7) => {
+    resolveCurrent = resolve7;
   });
   const queued = previous.then(
     () => current,
@@ -8437,7 +8862,7 @@ async function serializeMutation(directory, task) {
 __name(serializeMutation, "serializeMutation");
 async function readFileIfExists(filePath) {
   try {
-    return await fs5.readFile(filePath);
+    return await fs6.readFile(filePath);
   } catch (error) {
     if (isMissingFile(error)) {
       return void 0;
@@ -8447,12 +8872,12 @@ async function readFileIfExists(filePath) {
 }
 __name(readFileIfExists, "readFileIfExists");
 function legacyHash(legacyBytes) {
-  return createHash4("sha256").update(legacyBytes).digest("hex");
+  return createHash5("sha256").update(legacyBytes).digest("hex");
 }
 __name(legacyHash, "legacyHash");
 async function lockLegacyIfExists(legacyPath) {
   try {
-    return await import_proper_lockfile.default.lock(legacyPath, LOCK_OPTIONS);
+    return await import_proper_lockfile2.default.lock(legacyPath, LOCK_OPTIONS2);
   } catch (error) {
     if (isMissingFile(error)) {
       return void 0;
@@ -8500,21 +8925,21 @@ async function loadChannelMemory(target) {
 }
 __name(loadChannelMemory, "loadChannelMemory");
 async function writeChannelMemory(filePath, serialized) {
-  const tempPath = `${filePath}.${process.pid}.${randomBytes2(6).toString("hex")}.tmp`;
+  const tempPath = `${filePath}.${process.pid}.${randomBytes3(6).toString("hex")}.tmp`;
   let committed = false;
   try {
-    const handle = await fs5.open(tempPath, "wx", 384);
+    const handle = await fs6.open(tempPath, "wx", 384);
     try {
       await handle.writeFile(serialized, "utf8");
       await handle.sync();
     } finally {
       await handle.close();
     }
-    await fs5.rename(tempPath, filePath);
+    await fs6.rename(tempPath, filePath);
     committed = true;
   } finally {
     if (!committed) {
-      await fs5.unlink(tempPath).catch((error) => {
+      await fs6.unlink(tempPath).catch((error) => {
         if (!isMissingFile(error)) {
           throw error;
         }
@@ -8525,14 +8950,14 @@ async function writeChannelMemory(filePath, serialized) {
 __name(writeChannelMemory, "writeChannelMemory");
 async function mutateChannelMemory(target, apply) {
   const filePath = getChannelMemoryFilePath(target);
-  const directory = path7.dirname(filePath);
+  const directory = path8.dirname(filePath);
   const legacyPath = getLegacyChannelMemoryFilePath(target);
   return serializeMutation(directory, async () => {
-    await fs5.mkdir(directory, { recursive: true });
-    const lockPath = path7.join(directory, ".channel-memory.lock");
-    const lockHandle = await fs5.open(lockPath, "a", 384);
+    await fs6.mkdir(directory, { recursive: true });
+    const lockPath = path8.join(directory, ".channel-memory.lock");
+    const lockHandle = await fs6.open(lockPath, "a", 384);
     await lockHandle.close();
-    const release = await import_proper_lockfile.default.lock(lockPath, LOCK_OPTIONS);
+    const release = await import_proper_lockfile2.default.lock(lockPath, LOCK_OPTIONS2);
     let releaseLegacy;
     try {
       releaseLegacy = await lockLegacyIfExists(legacyPath);
@@ -8569,7 +8994,7 @@ async function listChannelMemoryEntries(target) {
 __name(listChannelMemoryEntries, "listChannelMemoryEntries");
 async function getFileRevision(filePath) {
   try {
-    const stats = await fs5.stat(filePath, { bigint: true });
+    const stats = await fs6.stat(filePath, { bigint: true });
     return [
       stats.dev,
       stats.ino,
@@ -8590,7 +9015,7 @@ async function getChannelMemoryRevision(target) {
     getFileRevision(getChannelMemoryFilePath(target)),
     getFileRevision(getLegacyChannelMemoryFilePath(target))
   ]);
-  return createHash4("sha256").update(canonical).update("\0").update(legacy).digest("hex");
+  return createHash5("sha256").update(canonical).update("\0").update(legacy).digest("hex");
 }
 __name(getChannelMemoryRevision, "getChannelMemoryRevision");
 async function addChannelMemoryEntries(target, texts, createdBy) {
@@ -8622,7 +9047,7 @@ async function addChannelMemoryEntries(target, texts, createdBy) {
       }
       let randomHex;
       do {
-        randomHex = randomBytes2(6).toString("hex");
+        randomHex = randomBytes3(6).toString("hex");
       } while (ids.has(`m-${randomHex}`));
       const entry = createChannelMemoryEntry({
         text,
@@ -8909,8 +9334,8 @@ __name(buildLearnVideoSkillRequest, "buildLearnVideoSkillRequest");
 
 // packages/core/src/memory/writeContextFile.ts
 init_esbuild_shims();
-import { promises as fs6 } from "node:fs";
-import * as path8 from "node:path";
+import { promises as fs7 } from "node:fs";
+import * as path9 from "node:path";
 var fileLocks = /* @__PURE__ */ new Map();
 var FILE_LOCK_TIMEOUT_MS = 3e4;
 function getFileLock(filePath) {
@@ -8938,7 +9363,7 @@ var WorkspaceMemoryWriteTimeoutError = class extends Error {
   }
 };
 async function writeWorkspaceContextFile(options) {
-  if (!path8.isAbsolute(options.projectRoot)) {
+  if (!path9.isAbsolute(options.projectRoot)) {
     throw new Error(
       `writeWorkspaceContextFile: projectRoot must be absolute, got "${options.projectRoot}"`
     );
@@ -8964,10 +9389,10 @@ async function runWrite(filePath, options) {
     return { filePath, bytesWritten: 0, changed: false };
   }
   options.assertCanCommit?.();
-  await fs6.mkdir(path8.dirname(filePath), { recursive: true });
+  await fs7.mkdir(path9.dirname(filePath), { recursive: true });
   if (options.mode === "replace") {
     options.assertCanCommit?.();
-    await fs6.writeFile(filePath, options.content, {
+    await fs7.writeFile(filePath, options.content, {
       encoding: "utf8",
       mode: 420
     });
@@ -8979,7 +9404,7 @@ async function runWrite(filePath, options) {
   }
   const next = await composeAppendedContent(filePath, options.content);
   options.assertCanCommit?.();
-  await fs6.writeFile(filePath, next, { encoding: "utf8", mode: 420 });
+  await fs7.writeFile(filePath, next, { encoding: "utf8", mode: 420 });
   return {
     filePath,
     bytesWritten: Buffer.byteLength(next, "utf8"),
@@ -8990,9 +9415,9 @@ __name(runWrite, "runWrite");
 function resolveContextFilePath(scope, projectRoot) {
   const filename = getCurrentMemoryFilename();
   if (scope === "workspace") {
-    return path8.join(projectRoot, filename);
+    return path9.join(projectRoot, filename);
   }
-  return path8.join(Storage.getGlobalQwenDir(), filename);
+  return path9.join(Storage.getGlobalQwenDir(), filename);
 }
 __name(resolveContextFilePath, "resolveContextFilePath");
 var MAX_EXISTING_FILE_BYTES = 16 * 1024 * 1024;
@@ -9016,7 +9441,7 @@ var WorkspaceMemoryFileTooLargeError = class extends Error {
 async function composeAppendedContent(filePath, newContent) {
   let existing = "";
   try {
-    const stat5 = await fs6.stat(filePath);
+    const stat5 = await fs7.stat(filePath);
     if (stat5.size > MAX_EXISTING_FILE_BYTES) {
       throw new WorkspaceMemoryFileTooLargeError(
         filePath,
@@ -9024,7 +9449,7 @@ async function composeAppendedContent(filePath, newContent) {
         MAX_EXISTING_FILE_BYTES
       );
     }
-    existing = await fs6.readFile(filePath, "utf8");
+    existing = await fs7.readFile(filePath, "utf8");
   } catch (err) {
     if (err instanceof WorkspaceMemoryFileTooLargeError) throw err;
     if (!isEnoent(err)) throw err;
@@ -9103,8 +9528,8 @@ __name(trimNewlines, "trimNewlines");
 init_esbuild_shims();
 import * as child_process from "node:child_process";
 import * as process2 from "node:process";
-import * as path9 from "node:path";
-import * as fs7 from "node:fs";
+import * as path10 from "node:path";
+import * as fs8 from "node:fs";
 import * as os2 from "node:os";
 function getVsCodeCommand(platform2 = process2.platform) {
   return platform2 === "win32" ? "code.cmd" : "code";
@@ -9132,23 +9557,23 @@ async function findVsCodeCommand(platform2 = process2.platform) {
   if (platform2 === "darwin") {
     locations.push(
       "/Applications/Visual Studio Code.app/Contents/Resources/app/bin/code",
-      path9.join(homeDir, "Library/Application Support/Code/bin/code")
+      path10.join(homeDir, "Library/Application Support/Code/bin/code")
     );
   } else if (platform2 === "linux") {
     locations.push(
       "/usr/share/code/bin/code",
       "/snap/bin/code",
-      path9.join(homeDir, ".local/share/code/bin/code")
+      path10.join(homeDir, ".local/share/code/bin/code")
     );
   } else if (platform2 === "win32") {
     locations.push(
-      path9.join(
+      path10.join(
         process2.env["ProgramFiles"] || "C:\\Program Files",
         "Microsoft VS Code",
         "bin",
         "code.cmd"
       ),
-      path9.join(
+      path10.join(
         homeDir,
         "AppData",
         "Local",
@@ -9160,7 +9585,7 @@ async function findVsCodeCommand(platform2 = process2.platform) {
     );
   }
   for (const location of locations) {
-    if (fs7.existsSync(location)) {
+    if (fs8.existsSync(location)) {
       return location;
     }
   }
@@ -9285,7 +9710,7 @@ var CODE_ACTION_KIND_LABELS = {
 
 // packages/core/src/lsp/configHash.ts
 init_esbuild_shims();
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 function sortJsonValue(value) {
   if (Array.isArray(value)) {
     return value.map(sortJsonValue);
@@ -9321,16 +9746,16 @@ function lspServerConfigHash(config) {
     socket: config.socket
   };
   const stableConfig = sortJsonValue(hashInput);
-  return createHash5("sha256").update(JSON.stringify(stableConfig)).digest("hex");
+  return createHash6("sha256").update(JSON.stringify(stableConfig)).digest("hex");
 }
 __name(lspServerConfigHash, "lspServerConfigHash");
 
 // packages/core/src/lsp/LspConfigLoader.ts
 init_esbuild_shims();
-import * as fs8 from "node:fs";
-import * as path10 from "path";
+import * as fs9 from "node:fs";
+import * as path11 from "path";
 import { pathToFileURL } from "url";
-var debugLogger14 = createDebugLogger("LSP");
+var debugLogger15 = createDebugLogger("LSP");
 var MAX_TCP_PORT = 65535;
 var LspConfigLoader = class {
   constructor(workspaceRoot) {
@@ -9344,25 +9769,25 @@ var LspConfigLoader = class {
    * Supports basic format: { "language": { "command": "...", "extensionToLanguage": {...} } }
    */
   async loadUserConfigs() {
-    const lspConfigPath = path10.join(this.workspaceRoot, ".lsp.json");
-    if (!fs8.existsSync(lspConfigPath)) {
+    const lspConfigPath = path11.join(this.workspaceRoot, ".lsp.json");
+    if (!fs9.existsSync(lspConfigPath)) {
       return [];
     }
     try {
-      const configContent = fs8.readFileSync(lspConfigPath, "utf-8");
+      const configContent = fs9.readFileSync(lspConfigPath, "utf-8");
       const data = JSON.parse(configContent);
       return this.parseConfigSource(data, lspConfigPath, {
         forceTrustRequired: true
       });
     } catch (error) {
-      debugLogger14.warn("Failed to load user .lsp.json config:", error);
+      debugLogger15.warn("Failed to load user .lsp.json config:", error);
       return [];
     }
   }
   async loadUserConfigsStrict() {
-    const lspConfigPath = path10.join(this.workspaceRoot, ".lsp.json");
+    const lspConfigPath = path11.join(this.workspaceRoot, ".lsp.json");
     try {
-      const configContent = fs8.readFileSync(lspConfigPath, "utf-8");
+      const configContent = fs9.readFileSync(lspConfigPath, "utf-8");
       const data = JSON.parse(configContent);
       return this.parseUserConfigSourceStrict(data, lspConfigPath);
     } catch (error) {
@@ -9391,14 +9816,14 @@ var LspConfigLoader = class {
           extension.path,
           lspServers
         );
-        if (!fs8.existsSync(configPath)) {
-          debugLogger14.warn(
+        if (!fs9.existsSync(configPath)) {
+          debugLogger15.warn(
             `LSP config not found for ${originBase}: ${configPath}`
           );
           continue;
         }
         try {
-          const configContent = fs8.readFileSync(configPath, "utf-8");
+          const configContent = fs9.readFileSync(configPath, "utf-8");
           const data = JSON.parse(configContent);
           const hydrated = this.hydrateExtensionLspConfig(data, extension.path);
           configs.push(
@@ -9408,7 +9833,7 @@ var LspConfigLoader = class {
             )
           );
         } catch (error) {
-          debugLogger14.warn(
+          debugLogger15.warn(
             `Failed to load extension LSP config from ${configPath}:`,
             error
           );
@@ -9422,7 +9847,7 @@ var LspConfigLoader = class {
           ...this.parseConfigSource(hydrated, `${originBase} (lspServers)`)
         );
       } else {
-        debugLogger14.warn(
+        debugLogger15.warn(
           `LSP config for ${originBase} must be an object or a JSON file path.`
         );
       }
@@ -9528,15 +9953,15 @@ var LspConfigLoader = class {
     return { ok: true, configs };
   }
   resolveExtensionConfigPath(extensionPath, configPath) {
-    return path10.isAbsolute(configPath) ? path10.resolve(configPath) : path10.resolve(extensionPath, configPath);
+    return path11.isAbsolute(configPath) ? path11.resolve(configPath) : path11.resolve(extensionPath, configPath);
   }
   hydrateExtensionLspConfig(source, extensionPath) {
     return recursivelyHydrateStrings(source, {
       extensionPath,
       CLAUDE_PLUGIN_ROOT: extensionPath,
       workspacePath: this.workspaceRoot,
-      "/": path10.sep,
-      pathSeparator: path10.sep
+      "/": path11.sep,
+      pathSeparator: path11.sep
     });
   }
   buildServerConfig(name, languages, spec, origin, options = {}) {
@@ -9560,13 +9985,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) {
-      debugLogger14.warn(
+      debugLogger15.warn(
         `LSP config error in ${origin}: ${name} missing command`
       );
       return null;
     }
     if (transport !== "stdio" && !socket) {
-      debugLogger14.warn(
+      debugLogger15.warn(
         `LSP config error in ${origin}: ${name} missing socket info`
       );
       return null;
@@ -9703,12 +10128,12 @@ var LspConfigLoader = class {
     if (typeof value !== "string" || value.trim() === "") {
       return this.workspaceRoot;
     }
-    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)) {
+    const resolved = path11.isAbsolute(value) ? path11.resolve(value) : path11.resolve(this.workspaceRoot, value);
+    const root = path11.resolve(this.workspaceRoot);
+    if (resolved === root || resolved.startsWith(root + path11.sep)) {
       return resolved;
     }
-    debugLogger14.warn(
+    debugLogger15.warn(
       `LSP workspaceFolder must be within ${this.workspaceRoot}; using workspace root instead.`
     );
     return this.workspaceRoot;
@@ -9720,7 +10145,7 @@ init_esbuild_shims();
 import * as cp from "node:child_process";
 import * as net2 from "node:net";
 import { StringDecoder } from "node:string_decoder";
-var debugLogger15 = createDebugLogger("LSP");
+var debugLogger16 = createDebugLogger("LSP");
 var MAX_STDERR_TAIL_BYTES = 8192;
 function trimTail(value, maxBytes) {
   const buffer = Buffer.from(value, "utf8");
@@ -9785,7 +10210,7 @@ var JsonRpcConnection = class {
     try {
       this.disposer?.();
     } catch (error) {
-      debugLogger15.warn("LSP disposer failed:", error);
+      debugLogger16.warn("LSP disposer failed:", error);
     }
   }
   sendRequest(method, params) {
@@ -9799,12 +10224,12 @@ var JsonRpcConnection = class {
       method,
       params
     };
-    const requestPromise = new Promise((resolve6, reject) => {
+    const requestPromise = new Promise((resolve7, 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: resolve6, reject, timer });
+      this.pendingRequests.set(id, { resolve: resolve7, reject, timer });
     });
     this.writeMessage(payload);
     return requestPromise;
@@ -9912,7 +10337,7 @@ var JsonRpcConnection = class {
     try {
       this.writer(header + json);
     } catch (error) {
-      debugLogger15.warn("LSP write failed:", error);
+      debugLogger16.warn("LSP write failed:", error);
       this.end();
     }
   }
@@ -9932,7 +10357,7 @@ var LspConnectionFactory = class _LspConnectionFactory {
    * 创建基于 stdio 的 LSP 连接
    */
   static async createStdioConnection(command, args, options, timeoutMs = 1e4) {
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve7, reject) => {
       const spawnOptions = {
         stdio: "pipe",
         ...options
@@ -9971,14 +10396,14 @@ var LspConnectionFactory = class _LspConnectionFactory {
           );
         });
         processInstance.stderr?.on("error", (err) => {
-          debugLogger15.warn(`LSP stderr stream error for ${command}:`, err);
+          debugLogger16.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) => {
-          debugLogger15.warn(`LSP stdin stream error for ${command}:`, err);
+          debugLogger16.warn(`LSP stdin stream error for ${command}:`, err);
           connection.end();
         });
         connection.listen(processInstance.stdout);
@@ -9991,7 +10416,7 @@ var LspConnectionFactory = class _LspConnectionFactory {
           recordProcessExit(code, signal);
           connection.end();
         });
-        resolve6({
+        resolve7({
           connection,
           process: processInstance,
           processDiagnostics
@@ -10012,7 +10437,7 @@ var LspConnectionFactory = class _LspConnectionFactory {
    * 创建基于 socket 的 LSP 连接（支持 TCP 或 unix socket）
    */
   static async createSocketConnection(options, timeoutMs = 1e4) {
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve7, reject) => {
       let socketOptions;
       if (options.path) {
         socketOptions = { path: options.path };
@@ -10046,7 +10471,7 @@ var LspConnectionFactory = class _LspConnectionFactory {
         connection.listen(socket);
         socket.once("close", () => connection.end());
         socket.once("error", () => connection.end());
-        resolve6({
+        resolve7({
           connection,
           socket
         });
@@ -10061,7 +10486,7 @@ var LspConnectionFactory = class _LspConnectionFactory {
       try {
         await lspConnection.connection.shutdown();
       } catch (e) {
-        debugLogger15.warn("LSP shutdown failed:", e);
+        debugLogger16.warn("LSP shutdown failed:", e);
       } finally {
         lspConnection.connection.end();
       }
@@ -10736,10 +11161,10 @@ ${value}
 // packages/core/src/lsp/LspServerManager.ts
 init_esbuild_shims();
 import { spawn as spawn2 } from "node:child_process";
-import * as fs9 from "node:fs";
-import * as path11 from "path";
+import * as fs10 from "node:fs";
+import * as path12 from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
-var debugLogger16 = createDebugLogger("LSP");
+var debugLogger17 = createDebugLogger("LSP");
 var SECURITY_SENSITIVE_ENV_KEYS = /* @__PURE__ */ new Set([
   "DYLD_INSERT_LIBRARIES",
   "DYLD_LIBRARY_PATH",
@@ -10776,7 +11201,7 @@ var LspServerManager = class {
       });
       this.serverConfigHashes.set(config.name, lspServerConfigHash(config));
     }
-    debugLogger16.info(
+    debugLogger17.info(
       `Prepared ${configs.length} LSP server config(s): ${formatServerNames(
         configs.map((config) => config.name)
       )}`
@@ -10785,7 +11210,7 @@ var LspServerManager = class {
   /** Drops all prepared handles without attempting process shutdown. */
   clearServerHandles() {
     if (this.serverHandles.size > 0) {
-      debugLogger16.info(
+      debugLogger17.info(
         `Clearing ${this.serverHandles.size} LSP server handle(s): ${formatServerNames(
           Array.from(this.serverHandles.keys())
         )}`
@@ -10846,7 +11271,7 @@ var LspServerManager = class {
    * before their handles are deleted or replaced.
    */
   async doReconcileServerConfigs(configs) {
-    debugLogger16.info(
+    debugLogger17.info(
       `Reconciling LSP server configs: desired=${formatServerNames(
         configs.map((config) => config.name)
       )}`
@@ -10918,7 +11343,7 @@ var LspServerManager = class {
         result.added.push(name);
       }
     }
-    debugLogger16.info(
+    debugLogger17.info(
       `LSP reconcile result: added=${formatServerNames(
         result.added
       )}, removed=${formatServerNames(
@@ -10953,7 +11378,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 = fs9.readFileSync(tsFile, "utf-8");
+      const text = fs10.readFileSync(tsFile, "utf-8");
       handle.connection.send({
         jsonrpc: "2.0",
         method: "textDocument/didOpen",
@@ -10967,12 +11392,12 @@ var LspServerManager = class {
         }
       });
       await new Promise(
-        (resolve6) => setTimeout(resolve6, DEFAULT_LSP_WARMUP_DELAY_MS)
+        (resolve7) => setTimeout(resolve7, DEFAULT_LSP_WARMUP_DELAY_MS)
       );
       handle.warmedUp = true;
       return uri;
     } catch (error) {
-      debugLogger16.warn("TypeScript server warm-up failed:", error);
+      debugLogger17.warn("TypeScript server warm-up failed:", error);
       return void 0;
     }
   }
@@ -11019,7 +11444,7 @@ var LspServerManager = class {
   async doStartServer(name, handle) {
     const workspaceTrusted = this.config.isTrustedFolder();
     if ((this.requireTrustedWorkspace || handle.config.trustRequired) && !workspaceTrusted) {
-      debugLogger16.warn(
+      debugLogger17.warn(
         `LSP server ${name} requires trusted workspace, skipping startup`
       );
       handle.status = "FAILED";
@@ -11032,7 +11457,7 @@ var LspServerManager = class {
       workspaceTrusted
     );
     if (!trusted) {
-      debugLogger16.warn(
+      debugLogger17.warn(
         `Workspace trust check failed, not starting LSP server ${name}`
       );
       handle.status = "FAILED";
@@ -11042,7 +11467,7 @@ var LspServerManager = class {
     if (handle.config.command) {
       const commandCwd = handle.config.workspaceFolder ?? this.workspaceRoot;
       if (!this.isPathSafe(handle.config.command, this.workspaceRoot, commandCwd)) {
-        debugLogger16.warn(
+        debugLogger17.warn(
           `LSP server ${name} command path is unsafe: ${handle.config.command}`
         );
         handle.status = "FAILED";
@@ -11054,7 +11479,7 @@ var LspServerManager = class {
         handle.config.env,
         commandCwd
       )) {
-        debugLogger16.warn(
+        debugLogger17.warn(
           `LSP server ${name} command not found: ${handle.config.command}`
         );
         handle.status = "FAILED";
@@ -11069,7 +11494,7 @@ var LspServerManager = class {
       handle.processDiagnostics = void 0;
       handle.warmedUp = false;
       handle.status = "IN_PROGRESS";
-      debugLogger16.info(
+      debugLogger17.info(
         `Starting LSP server ${name}: command=${handle.config.command ?? "<none>"}, transport=${handle.config.transport}, languages=${formatServerNames(
           handle.config.languages
         )}`
@@ -11094,7 +11519,7 @@ var LspServerManager = class {
       }
       handle.status = "READY";
       this.attachRestartHandler(name, handle);
-      debugLogger16.info(`LSP server ${name} started successfully`);
+      debugLogger17.info(`LSP server ${name} started successfully`);
     } catch (error) {
       handle.status = "FAILED";
       handle.error = error;
@@ -11108,21 +11533,21 @@ var LspServerManager = class {
       }
       await this.releaseServerResources(name, handle, false);
       if (handle.processDiagnostics) {
-        debugLogger16.error(
+        debugLogger17.error(
           `LSP server ${name} process diagnostics:`,
           handle.processDiagnostics
         );
       }
       handle.connection = void 0;
       handle.process = void 0;
-      debugLogger16.error(`LSP server ${name} failed to start:`, error);
+      debugLogger17.error(`LSP server ${name} failed to start:`, error);
     }
   }
   /**
    * Stops a server and resets runtime-only handle state.
    */
   async stopServer(name, handle) {
-    debugLogger16.info(`Stopping LSP server ${name}`);
+    debugLogger17.info(`Stopping LSP server ${name}`);
     handle.stopRequested = true;
     handle.startupAbortController?.abort();
     if (handle.startingPromise) {
@@ -11135,7 +11560,7 @@ var LspServerManager = class {
     handle.status = "NOT_STARTED";
     handle.warmedUp = false;
     handle.restartAttempts = 0;
-    debugLogger16.info(`LSP server ${name} stopped`);
+    debugLogger17.info(`LSP server ${name} stopped`);
   }
   async abortAndWaitForStartup(handle) {
     if (!handle.startingPromise) {
@@ -11159,14 +11584,14 @@ var LspServerManager = class {
           handle.connection.end();
         }
       } catch (error) {
-        debugLogger16.error(`Error closing LSP server ${name}:`, error);
+        debugLogger17.error(`Error closing LSP server ${name}:`, error);
       }
     }
     if (handle.process && handle.process.exitCode === null) {
       try {
         handle.process.kill();
       } catch (error) {
-        debugLogger16.warn(`Error killing LSP server ${name} process:`, error);
+        debugLogger17.warn(`Error killing LSP server ${name} process:`, error);
       }
     }
   }
@@ -11186,8 +11611,8 @@ var LspServerManager = class {
       try {
         await Promise.race([
           shutdownPromise,
-          new Promise((resolve6) => {
-            timerId = setTimeout(resolve6, timeout);
+          new Promise((resolve7) => {
+            timerId = setTimeout(resolve7, timeout);
             if (typeof timerId === "object" && timerId !== null && "unref" in timerId) {
               timerId.unref();
             }
@@ -11212,7 +11637,7 @@ var LspServerManager = class {
       }
       handle.processExitedUnexpectedly = true;
       if (!handle.config.restartOnCrash) {
-        debugLogger16.warn(
+        debugLogger17.warn(
           `LSP server ${name} exited but restartOnCrash is disabled`
         );
         handle.status = "FAILED";
@@ -11221,7 +11646,7 @@ var LspServerManager = class {
       }
       const maxRestarts = handle.config.maxRestarts ?? DEFAULT_LSP_MAX_RESTARTS;
       if (maxRestarts <= 0) {
-        debugLogger16.warn(
+        debugLogger17.warn(
           `LSP server ${name} exited but maxRestarts is ${maxRestarts}`
         );
         handle.status = "FAILED";
@@ -11230,7 +11655,7 @@ var LspServerManager = class {
       }
       const attempts = handle.restartAttempts ?? 0;
       if (attempts >= maxRestarts) {
-        debugLogger16.warn(
+        debugLogger17.warn(
           `LSP server ${name} reached max restart attempts (${maxRestarts}), stopping restarts`
         );
         handle.status = "FAILED";
@@ -11238,7 +11663,7 @@ var LspServerManager = class {
         return;
       }
       handle.restartAttempts = attempts + 1;
-      debugLogger16.warn(
+      debugLogger17.warn(
         `LSP server ${name} exited (code ${code ?? "unknown"}), restarting (${handle.restartAttempts}/${maxRestarts})`
       );
       this.enqueueCrashRestart(name, handle);
@@ -11286,7 +11711,7 @@ var LspServerManager = class {
     const next = this.reconcileQueue.then(restart, restart);
     this.reconcileQueue = next.catch(() => void 0);
     void next.catch((error) => {
-      debugLogger16.warn(`LSP server ${name} crash restart failed:`, error);
+      debugLogger17.warn(`LSP server ${name} crash restart failed:`, error);
     });
   }
   resetHandle(handle) {
@@ -11294,14 +11719,14 @@ var LspServerManager = class {
       try {
         handle.connection.end();
       } catch (error) {
-        debugLogger16.warn("Error closing LSP connection during reset:", error);
+        debugLogger17.warn("Error closing LSP connection during reset:", error);
       }
     }
     if (handle.process && handle.process.exitCode === null) {
       try {
         handle.process.kill();
       } catch (error) {
-        debugLogger16.warn("Error killing LSP process during reset:", error);
+        debugLogger17.warn("Error killing LSP process during reset:", error);
       }
     }
     handle.connection = void 0;
@@ -11320,7 +11745,7 @@ var LspServerManager = class {
     const filteredEnv = {};
     for (const [key, value] of Object.entries(env2)) {
       if (SECURITY_SENSITIVE_ENV_KEYS.has(key.toUpperCase())) {
-        debugLogger16.warn(
+        debugLogger17.warn(
           `Ignoring security-sensitive LSP server env override: ${key}`
         );
         continue;
@@ -11346,7 +11771,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)) {
-        debugLogger16.warn(
+        debugLogger17.warn(
           `Ignoring security-sensitive LSP command probe env override: ${key}`
         );
         continue;
@@ -11390,11 +11815,11 @@ var LspServerManager = class {
   }
   async delayWithAbort(delayMs, signal) {
     if (!signal) {
-      await new Promise((resolve6) => setTimeout(resolve6, delayMs));
+      await new Promise((resolve7) => setTimeout(resolve7, delayMs));
       return;
     }
     this.throwIfStartupAborted(signal);
-    await new Promise((resolve6, reject) => {
+    await new Promise((resolve7, reject) => {
       const onAbort = /* @__PURE__ */ __name(() => {
         clearTimeout(timerId);
         signal.removeEventListener("abort", onAbort);
@@ -11402,7 +11827,7 @@ var LspServerManager = class {
       }, "onAbort");
       const timerId = setTimeout(() => {
         signal.removeEventListener("abort", onAbort);
-        resolve6();
+        resolve7();
       }, delayMs);
       signal.addEventListener("abort", onAbort, { once: true });
     });
@@ -11571,7 +11996,7 @@ var LspServerManager = class {
    */
   async waitForSocketProcessSpawn(process3, signal) {
     this.throwIfStartupAborted(signal);
-    await new Promise((resolve6, reject) => {
+    await new Promise((resolve7, reject) => {
       let settled = false;
       const cleanup = /* @__PURE__ */ __name(() => {
         process3.off("spawn", onSpawn);
@@ -11586,7 +12011,7 @@ var LspServerManager = class {
         cleanup();
         complete();
       }, "settle");
-      const onSpawn = /* @__PURE__ */ __name(() => settle(resolve6), "onSpawn");
+      const onSpawn = /* @__PURE__ */ __name(() => settle(resolve7), "onSpawn");
       const onError = /* @__PURE__ */ __name((error) => settle(
         () => reject(new Error(`Failed to spawn LSP server: ${error.message}`))
       ), "onError");
@@ -11595,7 +12020,7 @@ var LspServerManager = class {
           try {
             process3.kill();
           } catch (error) {
-            debugLogger16.warn(
+            debugLogger17.warn(
               "Error killing aborted LSP socket process:",
               error
             );
@@ -11640,7 +12065,7 @@ var LspServerManager = class {
   async initializeLspServer(connection, config) {
     const workspaceFolderPath = config.workspaceFolder ?? this.workspaceRoot;
     const workspaceFolder = {
-      name: path11.basename(workspaceFolderPath) || workspaceFolderPath,
+      name: path12.basename(workspaceFolderPath) || workspaceFolderPath,
       uri: config.rootUri
     };
     const initializeParams = {
@@ -11702,7 +12127,7 @@ var LspServerManager = class {
    * @returns true if the command can be spawned, false if not found
    */
   async commandExists(command, env2, cwd) {
-    return new Promise((resolve6) => {
+    return new Promise((resolve7) => {
       let settled = false;
       const settle = /* @__PURE__ */ __name((value) => {
         if (settled) {
@@ -11710,7 +12135,7 @@ var LspServerManager = class {
         }
         settled = true;
         clearTimeout(timerId);
-        resolve6(value);
+        resolve7(value);
       }, "settle");
       const child = spawn2(command, ["--version"], {
         stdio: ["ignore", "ignore", "ignore"],
@@ -11745,16 +12170,16 @@ var LspServerManager = class {
    * - Relative paths that escape the workspace (e.g. "../../bin/evil")
    */
   isPathSafe(command, workspacePath, cwd) {
-    if (!command.includes(path11.sep) && !command.includes("/")) {
+    if (!command.includes(path12.sep) && !command.includes("/")) {
       return true;
     }
-    if (path11.isAbsolute(command)) {
+    if (path12.isAbsolute(command)) {
       return true;
     }
-    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;
+    const resolvedWorkspacePath = path12.resolve(workspacePath);
+    const basePath = cwd ? path12.resolve(cwd) : resolvedWorkspacePath;
+    const resolvedPath = path12.resolve(basePath, command);
+    return resolvedPath.startsWith(resolvedWorkspacePath + path12.sep) || resolvedPath === resolvedWorkspacePath;
   }
   /**
    * Check whether the workspace trust level allows starting an LSP server.
@@ -11768,12 +12193,12 @@ var LspServerManager = class {
       return true;
     }
     if (this.requireTrustedWorkspace || serverConfig.trustRequired) {
-      debugLogger16.warn(
+      debugLogger17.warn(
         `Workspace not trusted, skipping LSP server ${serverName} (${serverConfig.command ?? serverConfig.transport})`
       );
       return false;
     }
-    debugLogger16.info(
+    debugLogger17.info(
       `Untrusted workspace, but LSP server ${serverName} has trustRequired=false, attempting cautious startup`
     );
     return true;
@@ -12014,11 +12439,11 @@ var NativeLspClient = class {
 
 // packages/core/src/lsp/NativeLspService.ts
 init_esbuild_shims();
-import * as path12 from "path";
+import * as path13 from "path";
 import { fileURLToPath, pathToFileURL as pathToFileURL3 } from "url";
-import * as fs10 from "node:fs";
+import * as fs11 from "node:fs";
 import { promises as fsp } from "node:fs";
-var debugLogger17 = createDebugLogger("LSP");
+var debugLogger18 = createDebugLogger("LSP");
 var LANGUAGE_ID_TO_EXTENSIONS = {
   typescript: ["ts", "tsx"],
   typescriptreact: ["tsx"],
@@ -12076,7 +12501,7 @@ var NativeLspService = class {
     const workspaceTrusted = this.config.isTrustedFolder();
     this.serverManager.clearServerHandles();
     if (this.requireTrustedWorkspace && !workspaceTrusted) {
-      debugLogger17.warn(
+      debugLogger18.warn(
         "Workspace is not trusted, skipping LSP server discovery"
       );
       return;
@@ -12094,7 +12519,7 @@ var NativeLspService = class {
       serverConfigs,
       workspaceTrusted
     );
-    debugLogger17.info(
+    debugLogger18.info(
       `Discovered ${admitted.length} LSP server config(s): ${formatServerNames2(
         admitted.map((config) => config.name)
       )}, skipped=${formatServerNames2(skipped.map((server) => server.name))}`
@@ -12129,7 +12554,7 @@ var NativeLspService = class {
   async doReinitialize(signal) {
     this.throwIfReinitializeAborted(signal);
     const workspaceTrusted = this.config.isTrustedFolder();
-    debugLogger17.info(
+    debugLogger18.info(
       `Reinitializing LSP servers: workspaceRoot=${this.workspaceRoot}, trusted=${workspaceTrusted}`
     );
     if (this.requireTrustedWorkspace && !workspaceTrusted) {
@@ -12148,7 +12573,7 @@ var NativeLspService = class {
         },
         skipped: []
       };
-      debugLogger17.info(
+      debugLogger18.info(
         `LSP reinitialize result: added=<none>, removed=${formatServerNames2(
           removed
         )}, restarted=<none>, unchanged=<none>, failed=<none>, skipped=<none>`
@@ -12190,7 +12615,7 @@ var NativeLspService = class {
       signal
     );
     this.throwIfReinitializeAborted(signal);
-    debugLogger17.info(
+    debugLogger18.info(
       `LSP reinitialize result: added=${formatServerNames2(
         reconcile.added
       )}, removed=${formatServerNames2(
@@ -12210,7 +12635,7 @@ var NativeLspService = class {
     const skipped = [];
     for (const config of configs) {
       if (!workspaceTrusted && config.trustRequired) {
-        debugLogger17.warn(
+        debugLogger18.warn(
           `LSP server ${config.name} requires trusted workspace, skipping`
         );
         skipped.push({ name: config.name, reason: "server_trust_required" });
@@ -12255,7 +12680,7 @@ var NativeLspService = class {
         try {
           openedAny = this.sendDocumentOpen(name, handle, uri) || openedAny;
         } catch (error) {
-          debugLogger17.warn(
+          debugLogger18.warn(
             `Failed to replay document ${uri} for LSP server ${name}:`,
             error
           );
@@ -12384,14 +12809,14 @@ var NativeLspService = class {
     try {
       filePath = fileURLToPath(uri);
     } catch (error) {
-      debugLogger17.warn(`Failed to resolve file path for ${uri}:`, error);
+      debugLogger18.warn(`Failed to resolve file path for ${uri}:`, error);
       return false;
     }
     let text;
     try {
-      text = fs10.readFileSync(filePath, "utf-8");
+      text = fs11.readFileSync(filePath, "utf-8");
     } catch (error) {
-      debugLogger17.warn(
+      debugLogger18.warn(
         `Failed to read file for LSP didOpen: ${filePath}`,
         error
       );
@@ -12429,7 +12854,7 @@ var NativeLspService = class {
     this.openedDocuments.set(serverName, openedForServer);
   }
   resolveLanguageId(filePath, handle) {
-    const ext = path12.extname(filePath).slice(1).toLowerCase();
+    const ext = path13.extname(filePath).slice(1).toLowerCase();
     if (ext && handle.config.extensionToLanguage) {
       const mapping = handle.config.extensionToLanguage;
       return mapping[ext] ?? mapping["." + ext];
@@ -12557,11 +12982,11 @@ var NativeLspService = class {
   }
   async delay(ms, signal) {
     if (!signal) {
-      await new Promise((resolve6) => setTimeout(resolve6, ms));
+      await new Promise((resolve7) => setTimeout(resolve7, ms));
       return;
     }
     this.throwIfReinitializeAborted(signal);
-    await new Promise((resolve6, reject) => {
+    await new Promise((resolve7, reject) => {
       const onAbort = /* @__PURE__ */ __name(() => {
         clearTimeout(timer);
         signal.removeEventListener("abort", onAbort);
@@ -12569,7 +12994,7 @@ var NativeLspService = class {
       }, "onAbort");
       const timer = setTimeout(() => {
         signal.removeEventListener("abort", onAbort);
-        resolve6();
+        resolve7();
       }, ms);
       signal.addEventListener("abort", onAbort, { once: true });
     });
@@ -12619,7 +13044,7 @@ var NativeLspService = class {
           }
         }
       } catch (error) {
-        debugLogger17.warn(
+        debugLogger18.warn(
           `LSP workspace/symbol failed for ${serverName}:`,
           error
         );
@@ -12670,7 +13095,7 @@ var NativeLspService = class {
           return definitions.slice(0, limit);
         }
       } catch (error) {
-        debugLogger17.warn(
+        debugLogger18.warn(
           `LSP textDocument/definition failed for ${name}:`,
           error
         );
@@ -12724,7 +13149,7 @@ var NativeLspService = class {
           return refs.slice(0, limit);
         }
       } catch (error) {
-        debugLogger17.warn(
+        debugLogger18.warn(
           `LSP textDocument/references failed for ${name}:`,
           error
         );
@@ -12765,7 +13190,7 @@ var NativeLspService = class {
           return normalized2;
         }
       } catch (error) {
-        debugLogger17.warn(`LSP textDocument/hover failed for ${name}:`, error);
+        debugLogger18.warn(`LSP textDocument/hover failed for ${name}:`, error);
       }
     }
     return null;
@@ -12825,7 +13250,7 @@ var NativeLspService = class {
           return symbols.slice(0, limit);
         }
       } catch (error) {
-        debugLogger17.warn(
+        debugLogger18.warn(
           `LSP textDocument/documentSymbol failed for ${name}:`,
           error
         );
@@ -12879,7 +13304,7 @@ var NativeLspService = class {
           return implementations.slice(0, limit);
         }
       } catch (error) {
-        debugLogger17.warn(
+        debugLogger18.warn(
           `LSP textDocument/implementation failed for ${name}:`,
           error
         );
@@ -12933,7 +13358,7 @@ var NativeLspService = class {
           return items.slice(0, limit);
         }
       } catch (error) {
-        debugLogger17.warn(
+        debugLogger18.warn(
           `LSP textDocument/prepareCallHierarchy failed for ${name}:`,
           error
         );
@@ -12973,7 +13398,7 @@ var NativeLspService = class {
           return calls.slice(0, limit);
         }
       } catch (error) {
-        debugLogger17.warn(
+        debugLogger18.warn(
           `LSP callHierarchy/incomingCalls failed for ${name}:`,
           error
         );
@@ -13013,7 +13438,7 @@ var NativeLspService = class {
           return calls.slice(0, limit);
         }
       } catch (error) {
-        debugLogger17.warn(
+        debugLogger18.warn(
           `LSP callHierarchy/outgoingCalls failed for ${name}:`,
           error
         );
@@ -13053,7 +13478,7 @@ var NativeLspService = class {
           }
         }
       } catch (error) {
-        debugLogger17.warn(
+        debugLogger18.warn(
           `LSP textDocument/diagnostic failed for ${name}:`,
           error
         );
@@ -13095,7 +13520,7 @@ var NativeLspService = class {
           }
         }
       } catch (error) {
-        debugLogger17.warn(`LSP workspace/diagnostic failed for ${name}:`, error);
+        debugLogger18.warn(`LSP workspace/diagnostic failed for ${name}:`, error);
       }
       if (results.length >= limit) {
         break;
@@ -13145,7 +13570,7 @@ var NativeLspService = class {
           return actions.slice(0, limit);
         }
       } catch (error) {
-        debugLogger17.warn(
+        debugLogger18.warn(
           `LSP textDocument/codeAction failed for ${name}:`,
           error
         );
@@ -13173,7 +13598,7 @@ var NativeLspService = class {
       }
       return true;
     } catch (error) {
-      debugLogger17.error("Failed to apply workspace edit:", error);
+      debugLogger18.error("Failed to apply workspace edit:", error);
       return false;
     }
   }
@@ -13182,8 +13607,8 @@ var NativeLspService = class {
    */
   async applyTextEdits(uri, edits) {
     let filePath = uri.startsWith("file://") ? fileURLToPath(uri) : uri;
-    if (!path12.isAbsolute(filePath)) {
-      filePath = path12.resolve(this.workspaceRoot, filePath);
+    if (!path13.isAbsolute(filePath)) {
+      filePath = path13.resolve(this.workspaceRoot, filePath);
     }
     if (!this.workspaceContext.isPathWithinWorkspace(filePath)) {
       throw new Error(`Refusing to apply edits outside workspace: ${filePath}`);
@@ -13218,7 +13643,7 @@ var NativeLspService = class {
       lines.splice(startLine, endLine - startLine + 1, ...newLines);
     }
     try {
-      await fsp.access(filePath, fs10.constants.W_OK);
+      await fsp.access(filePath, fs11.constants.W_OK);
     } catch (err) {
       if (err?.code !== "ENOENT") {
         throw err;
@@ -13436,7 +13861,7 @@ __name(createFollowupController, "createFollowupController");
 
 // packages/core/src/followup/suggestionGenerator.ts
 init_esbuild_shims();
-var debugLogger18 = createDebugLogger("FOLLOWUP");
+var debugLogger19 = 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
@@ -13498,7 +13923,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";
-    debugLogger18.debug(
+    debugLogger19.debug(
       `Generating suggestion: cacheSharing=${cacheSharingState}, model=${modelOverride || "(default)"}`
     );
     const raw = cacheSafe ? await generateViaForkedQuery(
@@ -13514,23 +13939,23 @@ async function generatePromptSuggestion(config, conversationHistory, abortSignal
     );
     const suggestion = typeof raw === "string" ? raw.trim() : null;
     if (!suggestion) {
-      debugLogger18.debug("Suggestion generation returned empty result");
+      debugLogger19.debug("Suggestion generation returned empty result");
       return { suggestion: null, filterReason: "empty" };
     }
     const filterReason = getFilterReason(suggestion);
     if (filterReason) {
-      debugLogger18.debug(
+      debugLogger19.debug(
         `Suggestion filtered: reason=${filterReason}, text="${suggestion}"`
       );
       return { suggestion: null, filterReason };
     }
-    debugLogger18.debug(`Suggestion accepted: "${suggestion}"`);
+    debugLogger19.debug(`Suggestion accepted: "${suggestion}"`);
     return { suggestion };
   } catch (error) {
     if (abortSignal.aborted) {
       return { suggestion: null };
     }
-    debugLogger18.warn("Suggestion generation failed:", error);
+    debugLogger19.warn("Suggestion generation failed:", error);
     return { suggestion: null, filterReason: "error" };
   }
 }
@@ -13682,9 +14107,9 @@ __name(getFilterReason, "getFilterReason");
 
 // packages/core/src/followup/overlayFs.ts
 init_esbuild_shims();
-import { mkdir as mkdir3, copyFile, rm } from "node:fs/promises";
+import { mkdir as mkdir4, copyFile, rm } from "node:fs/promises";
 import { existsSync as existsSync3 } from "node:fs";
-import { join as join9, dirname as dirname5, relative, isAbsolute as isAbsolute5 } from "node:path";
+import { join as join10, dirname as dirname6, relative, isAbsolute as isAbsolute5 } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 var OverlayFs = class {
@@ -13692,7 +14117,7 @@ var OverlayFs = class {
   constructor(realCwd) {
     this.realCwd = realCwd;
     const id = randomUUID().slice(0, 8);
-    this.overlayDir = join9(
+    this.overlayDir = join10(
       tmpdir(),
       "qwen-speculation",
       String(process.pid),
@@ -13731,9 +14156,9 @@ var OverlayFs = class {
     if (this.writtenFiles.has(rel)) {
       return this.writtenFiles.get(rel);
     }
-    const overlayPath = join9(this.overlayDir, rel);
-    await mkdir3(dirname5(overlayPath), { recursive: true });
-    const originalPath = join9(this.realCwd, rel);
+    const overlayPath = join10(this.overlayDir, rel);
+    await mkdir4(dirname6(overlayPath), { recursive: true });
+    const originalPath = join10(this.realCwd, rel);
     if (existsSync3(originalPath)) {
       try {
         await copyFile(originalPath, overlayPath);
@@ -13756,9 +14181,9 @@ var OverlayFs = class {
   async applyToReal() {
     const applied = [];
     for (const [rel, overlayPath] of this.writtenFiles) {
-      const realPath = join9(this.realCwd, rel);
+      const realPath = join10(this.realCwd, rel);
       try {
-        await mkdir3(dirname5(realPath), { recursive: true });
+        await mkdir4(dirname6(realPath), { recursive: true });
         await copyFile(overlayPath, realPath);
         applied.push(realPath);
       } catch {
@@ -13780,7 +14205,7 @@ var OverlayFs = class {
    * Returns null if the path is outside cwd.
    */
   toRelative(inputPath) {
-    const abs = isAbsolute5(inputPath) ? inputPath : join9(this.realCwd, inputPath);
+    const abs = isAbsolute5(inputPath) ? inputPath : join10(this.realCwd, inputPath);
     const rel = relative(this.realCwd, abs);
     if (isAbsolute5(rel) || rel.startsWith("..")) {
       return null;
@@ -13869,7 +14294,7 @@ __name(rewritePathArgs, "rewritePathArgs");
 
 // packages/core/src/followup/speculation.ts
 init_esbuild_shims();
-var debugLogger19 = createDebugLogger("SPECULATION");
+var debugLogger20 = createDebugLogger("SPECULATION");
 var MAX_SPECULATION_TURNS = 20;
 var MAX_SPECULATION_MESSAGES = 100;
 function observeSpeculationProducer(params) {
@@ -14117,7 +14542,7 @@ async function runSpeculativeLoop(config, state, cacheSafe, modelOverride) {
               break;
             }
             if (!guardDecision.allowed) {
-              debugLogger19.debug(
+              debugLogger20.debug(
                 `Speculative guard denial: ${guardDecision.reason}`
               );
               hitBoundary = true;
@@ -14355,20 +14780,20 @@ __name(generatePipelinedSuggestion, "generatePipelinedSuggestion");
 // packages/core/src/utils/filesearch/fileSearch.ts
 init_esbuild_shims();
 var import_picomatch3 = __toESM(require_picomatch(), 1);
-import path16 from "node:path";
+import path17 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 fs11 from "node:fs";
-import path13 from "node:path";
+import fs12 from "node:fs";
+import path14 from "node:path";
 var hasFileExtension = (0, import_picomatch.default)("**/*[*.]*");
-var debugLogger20 = createDebugLogger("FILE_SEARCH_IGNORE");
+var debugLogger21 = createDebugLogger("FILE_SEARCH_IGNORE");
 function loadIgnoreRules(options) {
   const ignorer = new Ignore();
   if (options.useGitignore) {
-    const gitignorePath = path13.join(options.projectRoot, ".gitignore");
+    const gitignorePath = path14.join(options.projectRoot, ".gitignore");
     const gitignoreContent = readIgnoreFile(gitignorePath);
     if (gitignoreContent !== void 0) {
       ignorer.add(gitignoreContent);
@@ -14378,7 +14803,7 @@ function loadIgnoreRules(options) {
     for (const ignoreFileName of getQwenIgnoreFileNames(
       options.customIgnoreFiles
     )) {
-      const qwenignorePath = path13.join(options.projectRoot, ignoreFileName);
+      const qwenignorePath = path14.join(options.projectRoot, ignoreFileName);
       const qwenignoreContent = readIgnoreFile(qwenignorePath);
       if (qwenignoreContent !== void 0) {
         ignorer.addSource(qwenignoreContent);
@@ -14399,11 +14824,11 @@ function loadIgnoreRules(options) {
 __name(loadIgnoreRules, "loadIgnoreRules");
 function readIgnoreFile(filePath) {
   try {
-    return fs11.readFileSync(filePath, "utf8");
+    return fs12.readFileSync(filePath, "utf8");
   } catch (_error) {
     const error = _error;
     if (error.code !== "ENOENT") {
-      debugLogger20.warn(`Failed to read ${filePath}: ${error.message}`);
+      debugLogger21.warn(`Failed to read ${filePath}: ${error.message}`);
     }
     return void 0;
   }
@@ -14552,8 +14977,8 @@ __name(hasGlobSyntax, "hasGlobSyntax");
 // packages/core/src/utils/filesearch/crawler.ts
 init_esbuild_shims();
 var import_fdir = __toESM(require_dist(), 1);
-import path14 from "node:path";
-import fs12 from "node:fs";
+import path15 from "node:path";
+import fs13 from "node:fs";
 import { spawn as spawn3 } from "node:child_process";
 
 // packages/core/src/utils/filesearch/crawlCache.ts
@@ -14638,7 +15063,7 @@ var write = /* @__PURE__ */ __name((key, results, ttlMs) => {
 
 // packages/core/src/utils/filesearch/crawler.ts
 function toPosixPath(p) {
-  return p.split(path14.sep).join(path14.posix.sep);
+  return p.split(path15.sep).join(path15.posix.sep);
 }
 __name(toPosixPath, "toPosixPath");
 function normalizeGitPath(p, stripTrailingSlash = false) {
@@ -14734,7 +15159,7 @@ function redactArgsForLog(args) {
     if (/^[A-Za-z]:[\\/]/.test(t) || t.startsWith("/") && t.length > 1) {
       return "<abs-path>";
     }
-    if (t.includes(path14.sep) && t.length > 32) {
+    if (t.includes(path15.sep) && t.length > 32) {
       return "<path>";
     }
     return t;
@@ -14765,7 +15190,7 @@ function withSafeGitConfig(args) {
 }
 __name(withSafeGitConfig, "withSafeGitConfig");
 function canonicalStatePath(p) {
-  return toPosixPath(path14.resolve(p));
+  return toPosixPath(path15.resolve(p));
 }
 __name(canonicalStatePath, "canonicalStatePath");
 function getStateKey(options) {
@@ -14810,28 +15235,28 @@ function resolveGitDir(crawlDirectory) {
   }
   let current = crawlDirectory;
   while (current) {
-    const gitPath = path14.join(current, ".git");
+    const gitPath = path15.join(current, ".git");
     try {
-      const stat5 = fs12.statSync(gitPath);
+      const stat5 = fs13.statSync(gitPath);
       if (stat5.isDirectory()) {
         pathCacheSet(resolveGitDirCache, cacheKey, gitPath);
         return gitPath;
       }
       if (stat5.isFile()) {
-        const contents = fs12.readFileSync(gitPath, "utf8").trim();
+        const contents = fs13.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 = path14.isAbsolute(resolvedGitDir) ? path14.resolve(resolvedGitDir) : path14.resolve(current, resolvedGitDir);
+        let resolvedAbs = path15.isAbsolute(resolvedGitDir) ? path15.resolve(resolvedGitDir) : path15.resolve(current, resolvedGitDir);
         try {
-          resolvedAbs = fs12.realpathSync(resolvedAbs);
+          resolvedAbs = fs13.realpathSync(resolvedAbs);
           try {
-            fs12.statSync(path14.join(resolvedAbs, "HEAD"));
+            fs13.statSync(path15.join(resolvedAbs, "HEAD"));
           } catch {
-            fs12.statSync(path14.join(resolvedAbs, "index"));
+            fs13.statSync(path15.join(resolvedAbs, "index"));
           }
         } catch {
           pathCacheSet(resolveGitDirCache, cacheKey, null);
@@ -14847,7 +15272,7 @@ function resolveGitDir(crawlDirectory) {
         return null;
       }
     }
-    const parent = path14.dirname(current);
+    const parent = path15.dirname(current);
     if (parent === current) {
       break;
     }
@@ -14863,8 +15288,8 @@ function getGitRootMtime(crawlDirectory) {
     if (!gitDir) {
       return null;
     }
-    const indexPath = path14.join(gitDir, "index");
-    const indexStat = fs12.statSync(indexPath);
+    const indexPath = path15.join(gitDir, "index");
+    const indexStat = fs13.statSync(indexPath);
     return indexStat.mtimeMs;
   } catch {
   }
@@ -14920,7 +15345,7 @@ function computeLinesFingerprint(lines) {
 __name(computeLinesFingerprint, "computeLinesFingerprint");
 function runCommand(command, args, cwd, timeoutMs = 2e4, options) {
   const collectLines = options?.collectLines !== false;
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const lines = [];
     let settled = false;
     let timedOut = false;
@@ -14932,7 +15357,7 @@ function runCommand(command, args, cwd, timeoutMs = 2e4, options) {
         return;
       }
       settled = true;
-      resolve6({ success, lines: resultLines });
+      resolve7({ success, lines: resultLines });
     }, "finalize");
     let stderrBuf = "";
     let child;
@@ -15100,19 +15525,19 @@ function normalizePath(p) {
 }
 __name(normalizePath, "normalizePath");
 function getPosixRelative(from, to) {
-  const fromResolved = path14.resolve(from);
-  const toResolved = path14.resolve(to);
+  const fromResolved = path15.resolve(from);
+  const toResolved = path15.resolve(to);
   let fromAbs = fromResolved;
   let toAbs = toResolved;
   try {
-    fromAbs = fs12.realpathSync(fromResolved);
+    fromAbs = fs13.realpathSync(fromResolved);
   } catch {
   }
   try {
-    toAbs = fs12.realpathSync(toResolved);
+    toAbs = fs13.realpathSync(toResolved);
   } catch {
   }
-  const relative2 = path14.relative(fromAbs, toAbs);
+  const relative2 = path15.relative(fromAbs, toAbs);
   const posixRel = toPosixPath(relative2);
   return posixRel === "" ? "." : posixRel;
 }
@@ -15121,18 +15546,18 @@ function isValidIgnorePath(relativePath) {
   if (!relativePath || relativePath === ".") {
     return false;
   }
-  if (path14.posix.isAbsolute(relativePath)) {
+  if (path15.posix.isAbsolute(relativePath)) {
     return false;
   }
   return relativePath !== ".." && !relativePath.startsWith("../") && !relativePath.includes("/../");
 }
 __name(isValidIgnorePath, "isValidIgnorePath");
 function toFdirExcludeRelativePath(crawlDirectory, dirPath) {
-  const base = path14.resolve(crawlDirectory);
-  const absoluteCandidate = path14.isAbsolute(dirPath) ? dirPath : path14.join(base, dirPath);
-  let rel = path14.relative(base, absoluteCandidate);
+  const base = path15.resolve(crawlDirectory);
+  const absoluteCandidate = path15.isAbsolute(dirPath) ? dirPath : path15.join(base, dirPath);
+  let rel = path15.relative(base, absoluteCandidate);
   rel = toPosixPath(rel);
-  if (!rel || rel.startsWith("..") || path14.posix.isAbsolute(rel)) {
+  if (!rel || rel.startsWith("..") || path15.posix.isAbsolute(rel)) {
     return null;
   }
   return isValidIgnorePath(rel) ? rel : null;
@@ -15222,7 +15647,7 @@ __name(isUnderIgnoredDirectory, "isUnderIgnoredDirectory");
 var YIELD_INTERVAL = 1e3;
 async function maybeYield(index) {
   if (index > 0 && index % YIELD_INTERVAL === 0) {
-    await new Promise((resolve6) => setImmediate(resolve6));
+    await new Promise((resolve7) => setImmediate(resolve7));
   }
 }
 __name(maybeYield, "maybeYield");
@@ -15339,16 +15764,16 @@ function posixPathUnderGitRoot(normalizedFile, relativeToGitRoot, relativeToCraw
   if (relativeToGitRoot && relativeToGitRoot !== ".") {
     const rest = sliceAfterGitPathspecPrefix(nf, normGitRoot);
     if (rest !== null) {
-      return path14.posix.join(normCrawlDir, rest);
+      return path15.posix.join(normCrawlDir, rest);
     }
     if (equalsRepoRelativeCaseAware(nf, normGitRoot)) {
       const base = nf.replace(/\/+$/, "");
       return `${base}/`;
     }
     const nfFile = nf.replace(/\/+$/, "");
-    return path14.posix.join(normCrawlDir, nfFile);
+    return path15.posix.join(normCrawlDir, nfFile);
   }
-  return path14.posix.join(normCrawlDir, nf.replace(/\/+$/, ""));
+  return path15.posix.join(normCrawlDir, nf.replace(/\/+$/, ""));
 }
 __name(posixPathUnderGitRoot, "posixPathUnderGitRoot");
 async function crawlWithGitLsFiles(stateKey, crawlDirectory, cwd, options, workingTreePrefetch) {
@@ -15427,7 +15852,7 @@ async function crawlWithGitLsFiles(stateKey, crawlDirectory, cwd, options, worki
     }
     let stat5;
     try {
-      stat5 = fs12.lstatSync(path14.join(gitRoot, ...normalizedFile.split("/")));
+      stat5 = fs13.lstatSync(path15.join(gitRoot, ...normalizedFile.split("/")));
     } catch {
       return true;
     }
@@ -15529,7 +15954,7 @@ function collectDirectoryRows(options) {
   const dirFilter = options.ignore.getDirectoryFilter();
   const rows = [];
   const visit = /* @__PURE__ */ __name((dir, relativePath, depth) => {
-    const cwdRelative = relativePath === "" ? relativeToCrawlDir : path14.posix.join(relativeToCrawlDir, relativePath);
+    const cwdRelative = relativePath === "" ? relativeToCrawlDir : path15.posix.join(relativeToCrawlDir, relativePath);
     if (cwdRelative !== ".") {
       const row = cwdRelative.endsWith("/") ? cwdRelative : `${cwdRelative}/`;
       if (!isValidIgnorePath(row.slice(0, -1)) || dirFilter(row)) {
@@ -15542,7 +15967,7 @@ function collectDirectoryRows(options) {
     }
     let entries;
     try {
-      entries = fs12.readdirSync(dir, { withFileTypes: true });
+      entries = fs13.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -15550,8 +15975,8 @@ function collectDirectoryRows(options) {
       if (!entry.isDirectory()) {
         continue;
       }
-      const childRelative = relativePath ? path14.posix.join(relativePath, entry.name) : entry.name;
-      visit(path14.join(dir, entry.name), childRelative, depth + 1);
+      const childRelative = relativePath ? path15.posix.join(relativePath, entry.name) : entry.name;
+      visit(path15.join(dir, entry.name), childRelative, depth + 1);
     }
   }, "visit");
   visit(options.crawlDirectory, "", 0);
@@ -15589,7 +16014,7 @@ async function crawlWithRipgrep(stateKey, crawlDirectory, cwd, options) {
       return false;
     }
     const normalizedFile = normalizePath(file);
-    const fullPath = path14.posix.join(relativeToCrawlDir, normalizedFile);
+    const fullPath = path15.posix.join(relativeToCrawlDir, normalizedFile);
     if (!shouldIncludeFile(fullPath, dirFilter, fileFilter)) {
       return true;
     }
@@ -15648,7 +16073,7 @@ async function crawlWithFdir(options) {
       return dirFilter(`${relativePath}/`);
     }).filter((filePath, isDirectory) => {
       if (isDirectory) return true;
-      const cwdRelative = path14.posix.join(relativeToCrawlDir, filePath);
+      const cwdRelative = path15.posix.join(relativeToCrawlDir, filePath);
       if (!isValidIgnorePath(cwdRelative)) {
         return false;
       }
@@ -15661,7 +16086,7 @@ async function crawlWithFdir(options) {
   } catch {
     return [];
   }
-  const mapped = results.filter((p) => p.length > 0 && p !== ".").map((p) => path14.posix.join(relativeToCrawlDir, p));
+  const mapped = results.filter((p) => p.length > 0 && p !== ".").map((p) => path15.posix.join(relativeToCrawlDir, p));
   if (relativeToCrawlDir !== ".") {
     const rootDir = relativeToCrawlDir.endsWith("/") ? relativeToCrawlDir : `${relativeToCrawlDir}/`;
     if (!mapped.includes(rootDir)) {
@@ -15788,8 +16213,8 @@ __name(applyMaxFilesLimit, "applyMaxFilesLimit");
 
 // packages/core/src/utils/filesearch/fzfWorkerHandle.ts
 init_esbuild_shims();
-import fs13 from "node:fs";
-import path15 from "node:path";
+import fs14 from "node:fs";
+import path16 from "node:path";
 import { Worker } from "node:worker_threads";
 
 // node_modules/fzf/dist/fzf.es.js
@@ -16656,7 +17081,7 @@ function basicMatch(query) {
 __name(basicMatch, "basicMatch");
 var isNode = typeof __require !== "undefined" && typeof window === "undefined";
 function asyncMatcher(token, len, iter2, onFinish) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const INCREMENT = 1e3;
     let i = 0, end = Math.min(INCREMENT, len);
     const step = /* @__PURE__ */ __name(() => {
@@ -16669,7 +17094,7 @@ function asyncMatcher(token, len, iter2, onFinish) {
         end = Math.min(end + INCREMENT, len);
         isNode ? setImmediate(step) : setTimeout(step);
       } else {
-        resolve6(onFinish());
+        resolve7(onFinish());
       }
     }, "step");
     step();
@@ -16841,11 +17266,11 @@ var inProcessTransport = {
 var resolvedWorkerPath;
 function getWorkerScriptPath() {
   if (resolvedWorkerPath !== void 0) return resolvedWorkerPath;
-  const candidate = path15.join(
+  const candidate = path16.join(
     resolveBundleDir(import.meta.url),
     "fzfWorker.js"
   );
-  resolvedWorkerPath = fs13.existsSync(candidate) ? candidate : null;
+  resolvedWorkerPath = fs14.existsSync(candidate) ? candidate : null;
   return resolvedWorkerPath;
 }
 __name(getWorkerScriptPath, "getWorkerScriptPath");
@@ -16941,12 +17366,12 @@ var workerTransport = {
         }
         await readyPromise;
         const reqId = nextReqId++;
-        return new Promise((resolve6, reject) => {
+        return new Promise((resolve7, reject) => {
           if (readyState === "disposed" || readyState === "failed") {
             reject(new Error(`fzf worker not available (${readyState})`));
             return;
           }
-          pending.set(reqId, { resolve: resolve6, reject });
+          pending.set(reqId, { resolve: resolve7, reject });
           try {
             worker.postMessage({ type: "find", reqId, pattern, limit });
           } catch (err) {
@@ -17041,7 +17466,7 @@ async function filter(allPaths, pattern, signal) {
   const results = [];
   for (const [i, p] of allPaths.entries()) {
     if (i % 1e3 === 0) {
-      await new Promise((resolve6) => setImmediate(resolve6));
+      await new Promise((resolve7) => setImmediate(resolve7));
       if (signal?.aborted) {
         throw new AbortError();
       }
@@ -17120,7 +17545,7 @@ var RecursiveFileSearch = class {
     const results = [];
     for (const [i, candidate] of filteredCandidates.entries()) {
       if (i % 1e3 === 0) {
-        await new Promise((resolve6) => setImmediate(resolve6));
+        await new Promise((resolve7) => setImmediate(resolve7));
         if (options.signal?.aborted) {
           throw new AbortError();
         }
@@ -17162,9 +17587,9 @@ var DirectoryFileSearch = class {
       throw new Error("Engine not initialized. Call initialize() first.");
     }
     pattern = pattern || "*";
-    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 dir = pattern.endsWith("/") ? pattern : path17.dirname(pattern);
+    const crawlDirectory = path17.join(this.options.projectRoot, dir);
+    const listingProjectRoot = path17.resolve(crawlDirectory) === path17.resolve(this.options.projectRoot);
     const results = await crawl({
       crawlDirectory,
       cwd: this.options.projectRoot,
@@ -17245,13 +17670,13 @@ __name(analyzeToolResultRetention, "analyzeToolResultRetention");
 
 // packages/core/src/utils/pathReader.ts
 init_esbuild_shims();
-import { promises as fs14 } from "node:fs";
-import path17 from "node:path";
+import { promises as fs15 } from "node:fs";
+import path18 from "node:path";
 async function readPathFromWorkspace(pathStr, config) {
   const workspace = config.getWorkspaceContext();
   const fileService = config.getFileService();
   let absolutePath = null;
-  if (path17.isAbsolute(pathStr)) {
+  if (path18.isAbsolute(pathStr)) {
     if (!workspace.isPathWithinWorkspace(pathStr)) {
       throw new Error(
         `Absolute path is outside of the allowed workspace: ${pathStr}`
@@ -17261,9 +17686,9 @@ async function readPathFromWorkspace(pathStr, config) {
   } else {
     const searchDirs = workspace.getDirectories();
     for (const dir of searchDirs) {
-      const potentialPath = path17.resolve(dir, pathStr);
+      const potentialPath = path18.resolve(dir, pathStr);
       try {
-        await fs14.access(potentialPath);
+        await fs15.access(potentialPath);
         absolutePath = potentialPath;
         break;
       } catch {
@@ -17273,7 +17698,7 @@ async function readPathFromWorkspace(pathStr, config) {
   if (!absolutePath) {
     throw new Error(`Path not found in workspace: ${pathStr}`);
   }
-  const stats = await fs14.stat(absolutePath);
+  const stats = await fs15.stat(absolutePath);
   if (stats.isDirectory()) {
     const allParts = [];
     allParts.push({
@@ -17289,7 +17714,7 @@ async function readPathFromWorkspace(pathStr, config) {
       absolute: true
     });
     const relativeFiles = files.map(
-      (p) => path17.relative(config.getTargetDir(), p)
+      (p) => path18.relative(config.getTargetDir(), p)
     );
     const filteringOptions = config.getFileFilteringOptions();
     const filteredFiles = fileService.filterFiles(relativeFiles, {
@@ -17297,10 +17722,10 @@ async function readPathFromWorkspace(pathStr, config) {
       respectQwenIgnore: filteringOptions.respectQwenIgnore
     });
     const finalFiles = filteredFiles.map(
-      (p) => path17.resolve(config.getTargetDir(), p)
+      (p) => path18.resolve(config.getTargetDir(), p)
     );
     for (const filePath of finalFiles) {
-      const relativePathForDisplay = path17.relative(absolutePath, filePath);
+      const relativePathForDisplay = path18.relative(absolutePath, filePath);
       allParts.push({ text: `--- ${relativePathForDisplay} ---
 ` });
       const result = await processSingleFileContent(filePath, config, {
@@ -17316,7 +17741,7 @@ async function readPathFromWorkspace(pathStr, config) {
     allParts.push({ text: `--- End of content for directory: ${pathStr} ---` });
     return allParts;
   } else {
-    const relativePath = path17.relative(config.getTargetDir(), absolutePath);
+    const relativePath = path18.relative(config.getTargetDir(), absolutePath);
     const singleFileFilteringOptions = config.getFileFilteringOptions();
     const filtered = fileService.filterFiles([relativePath], {
       respectGitIgnore: singleFileFilteringOptions.respectGitIgnore,
@@ -17335,16 +17760,16 @@ __name(readPathFromWorkspace, "readPathFromWorkspace");
 
 // packages/core/src/utils/projectSummary.ts
 init_esbuild_shims();
-import * as fs15 from "fs/promises";
-import * as path18 from "path";
+import * as fs16 from "fs/promises";
+import * as path19 from "path";
 var PROJECT_SUMMARY_FILENAME = "PROJECT_SUMMARY.md";
 var WELCOME_BACK_STATE_FILENAME = "welcome-back-state.json";
 function getProjectSummaryPath() {
-  return path18.join(process.cwd(), ".qwen", PROJECT_SUMMARY_FILENAME);
+  return path19.join(process.cwd(), ".qwen", PROJECT_SUMMARY_FILENAME);
 }
 __name(getProjectSummaryPath, "getProjectSummaryPath");
 function getWelcomeBackStatePath() {
-  return path18.join(process.cwd(), ".qwen", WELCOME_BACK_STATE_FILENAME);
+  return path19.join(process.cwd(), ".qwen", WELCOME_BACK_STATE_FILENAME);
 }
 __name(getWelcomeBackStatePath, "getWelcomeBackStatePath");
 function buildSummaryFingerprint(stat5) {
@@ -17353,7 +17778,7 @@ function buildSummaryFingerprint(stat5) {
 __name(buildSummaryFingerprint, "buildSummaryFingerprint");
 async function getWelcomeBackState() {
   try {
-    const raw = await fs15.readFile(getWelcomeBackStatePath(), "utf-8");
+    const raw = await fs16.readFile(getWelcomeBackStatePath(), "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.version !== 1 || parsed.lastChoice !== "restart" || typeof parsed.summaryFingerprint !== "string") {
       return null;
@@ -17369,7 +17794,7 @@ async function getWelcomeBackState() {
 __name(getWelcomeBackState, "getWelcomeBackState");
 async function saveWelcomeBackRestartChoice(summaryFingerprint) {
   const statePath = getWelcomeBackStatePath();
-  await fs15.mkdir(path18.dirname(statePath), { recursive: true });
+  await fs16.mkdir(path19.dirname(statePath), { recursive: true });
   const state = {
     version: 1,
     lastChoice: "restart",
@@ -17382,7 +17807,7 @@ async function saveWelcomeBackRestartChoice(summaryFingerprint) {
 __name(saveWelcomeBackRestartChoice, "saveWelcomeBackRestartChoice");
 async function clearWelcomeBackState() {
   try {
-    await fs15.rm(getWelcomeBackStatePath(), { force: true });
+    await fs16.rm(getWelcomeBackStatePath(), { force: true });
   } catch {
   }
 }
@@ -17390,15 +17815,15 @@ __name(clearWelcomeBackState, "clearWelcomeBackState");
 async function getProjectSummaryInfo() {
   const summaryPath = getProjectSummaryPath();
   try {
-    await fs15.access(summaryPath);
+    await fs16.access(summaryPath);
   } catch {
     return {
       hasHistory: false
     };
   }
   try {
-    const summaryStat = await fs15.stat(summaryPath);
-    const content = await fs15.readFile(summaryPath, "utf-8");
+    const summaryStat = await fs16.stat(summaryPath);
+    const content = await fs16.readFile(summaryPath, "utf-8");
     const summaryFingerprint = buildSummaryFingerprint(summaryStat);
     const timestampMatch = content.match(/\*\*Update time\*\*: (.+)/);
     const timestamp = timestampMatch ? timestampMatch[1] : (/* @__PURE__ */ new Date()).toISOString();
@@ -17466,9 +17891,9 @@ __name(getProjectSummaryInfo, "getProjectSummaryInfo");
 
 // packages/core/src/tools/readManyFiles.ts
 init_esbuild_shims();
-import * as fs16 from "node:fs";
+import * as fs17 from "node:fs";
 import * as os3 from "node:os";
-import * as path19 from "node:path";
+import * as path20 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;
@@ -17488,7 +17913,7 @@ async function readManyFiles(config, options) {
     for (const rawPattern of inputPatterns) {
       signal?.throwIfAborted();
       const normalizedPattern = rawPattern.replace(/\\/g, "/");
-      const fullPath = path19.resolve(projectRoot, normalizedPattern);
+      const fullPath = path20.resolve(projectRoot, normalizedPattern);
       const displayPath = displayPaths?.get(fullPath) ?? fullPath;
       const validatedIdentity = validatedPathIdentities?.get(fullPath);
       if (validatedPathIdentities && !validatedIdentity) continue;
@@ -17507,7 +17932,7 @@ async function readManyFiles(config, options) {
       if (validatedIdentity && !await matchesValidatedPathIdentity(fullPath, validatedIdentity)) {
         continue;
       }
-      const stats = fs16.existsSync(fullPath) ? fs16.statSync(fullPath) : null;
+      const stats = fs17.existsSync(fullPath) ? fs17.statSync(fullPath) : null;
       if (stats?.isDirectory()) {
         const { contentParts: dirParts, info } = await readDirectory(
           config,
@@ -17627,9 +18052,9 @@ async function readValidatedTextFileContent(config, filePath, expected, preserve
 __name(readValidatedTextFileContent, "readValidatedTextFileContent");
 async function matchesValidatedPathIdentity(filePath, expected) {
   try {
-    const canonicalPath = await fs16.promises.realpath(filePath);
+    const canonicalPath = await fs17.promises.realpath(filePath);
     if (canonicalPath !== filePath) return false;
-    const stats = await fs16.promises.stat(canonicalPath);
+    const stats = await fs17.promises.stat(canonicalPath);
     return statsMatchValidatedIdentity(stats, expected);
   } catch {
     return false;
@@ -17658,13 +18083,13 @@ async function snapshotValidatedFile(filePath, expected, signal) {
       if (stats.size > SNAPSHOT_MAX_SIZE_BYTES) {
         return void 0;
       }
-      snapshotDir = await fs16.promises.mkdtemp(
-        path19.join(os3.tmpdir(), "qwen-validated-read-")
+      snapshotDir = await fs17.promises.mkdtemp(
+        path20.join(os3.tmpdir(), "qwen-validated-read-")
       );
-      const snapshotPath = path19.join(snapshotDir, path19.basename(filePath));
-      const target = await fs16.promises.open(
+      const snapshotPath = path20.join(snapshotDir, path20.basename(filePath));
+      const target = await fs17.promises.open(
         snapshotPath,
-        fs16.constants.O_WRONLY | fs16.constants.O_CREAT | fs16.constants.O_EXCL,
+        fs17.constants.O_WRONLY | fs17.constants.O_CREAT | fs17.constants.O_EXCL,
         384
       );
       try {
@@ -17705,7 +18130,7 @@ async function snapshotValidatedFile(filePath, expected, signal) {
       result = {
         filePath: snapshotPath,
         stats,
-        cleanup: /* @__PURE__ */ __name(() => fs16.promises.rm(snapshotDir, { recursive: true, force: true }), "cleanup")
+        cleanup: /* @__PURE__ */ __name(() => fs17.promises.rm(snapshotDir, { recursive: true, force: true }), "cleanup")
       };
       return result;
     } finally {
@@ -17717,7 +18142,7 @@ async function snapshotValidatedFile(filePath, expected, signal) {
     return void 0;
   } finally {
     if (snapshotDir && !result) {
-      await fs16.promises.rm(snapshotDir, { recursive: true, force: true });
+      await fs17.promises.rm(snapshotDir, { recursive: true, force: true });
     }
   }
 }
@@ -17906,6 +18331,14 @@ export {
   IMAGE_CAPABILITY,
   generateSessionRecap,
   SessionReferenceService,
+  MAX_CONTROLLER_LABEL_CHARS,
+  PeerControllerError,
+  getPeerControllerRegistryPath,
+  readPeerControllerRegistrySync,
+  resolveControllerToken,
+  listPeerControllers,
+  addPeerController,
+  removePeerController,
   getLastPeerInboxFailure,
   describePeerInboxFailure,
   startPeerInbox,