@qwen-code/qwen-code 0.22.3-nightly.20260831.3a0c4c6108 → 0.23.0

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

@@ -3,9 +3,10 @@
 import {
   MAX_FRAME_BYTES,
   isLocalIpcPath,
+  parsePeerAuthLine,
   parsePeerFrame,
   resolvePeerSocketPath
-} from "./chunk-AYYKUUKP.js";
+} from "./chunk-4UANMABT.js";
 import {
   scanForSecrets
 } from "./chunk-UKYXYWI2.js";
@@ -62,7 +63,6 @@ import {
   recursivelyHydrateStrings,
   repairOrphanedToolUseTurns,
   require_picomatch,
-  resolveGitDir,
   runForkedAgent,
   runWithForkedChatModel,
   runWithTimeout,
@@ -70,7 +70,7 @@ import {
   stripToolResultImages,
   toolResultBoundaryArtifact,
   toolResultPartDiagnosticValues
-} from "./chunk-ZBDYI7VM.js";
+} from "./chunk-4F7GQGXB.js";
 import {
   hasVerifiableInode,
   openNoFollow
@@ -79,22 +79,18 @@ import {
   stripAnsi
 } from "./chunk-TWPJO254.js";
 import {
-  getProjectSkillsRoot
-} from "./chunk-OSTQZIOY.js";
-import {
-  resolveBundleDir
-} from "./chunk-PDXYZBBQ.js";
+  projectUserTranscriptForDisplay
+} from "./chunk-EFTPIZIC.js";
 import {
   glob,
   globSync
 } from "./chunk-QJNDUTOL.js";
 import {
-  findGitRoot,
-  readFirstLineNoFollow
-} from "./chunk-ZHO2CW6D.js";
+  getProjectSkillsRoot
+} from "./chunk-H43PSPYS.js";
 import {
-  projectUserTranscriptForDisplay
-} from "./chunk-7J6OTNGO.js";
+  resolveBundleDir
+} from "./chunk-VYIUNFEA.js";
 import {
   escapeJsonTagCharacters
 } from "./chunk-CHEIIBT3.js";
@@ -111,8 +107,9 @@ import {
   addMCPStatusChangeListener,
   getInvocationContext,
   removeMCPStatusChangeListener,
+  runSideQuery,
   updateMCPServerStatus
-} from "./chunk-FXUSWLBF.js";
+} from "./chunk-GH2S4GD5.js";
 import {
   E_TIMEOUT,
   Mutex,
@@ -126,14 +123,11 @@ import {
   getCurrentMemoryFilename,
   isCacheableReadResult,
   processSingleFileContent
-} from "./chunk-67AY5D3M.js";
+} from "./chunk-DYTW3QVG.js";
 import {
   getAutoMemoryRoot,
   getUserAutoMemoryRoot
 } from "./chunk-HT5S5TRQ.js";
-import {
-  runSideQuery
-} from "./chunk-LMMHS3RS.js";
 import {
   atomicWriteFile
 } from "./chunk-KHP66DFN.js";
@@ -142,7 +136,7 @@ import {
   getStartupContextLength,
   isSystemReminderContent,
   stripSystemReminderBlocks
-} from "./chunk-D7D3HSYQ.js";
+} from "./chunk-G7HBEEX7.js";
 import {
   getQwenIgnoreFileNames,
   require_ignore
@@ -150,7 +144,7 @@ import {
 import {
   ToolNames,
   canonicalToolName
-} from "./chunk-LYSZVCCD.js";
+} from "./chunk-7JMGTOH7.js";
 import {
   PATH_ARG_KEYS,
   Storage,
@@ -178,8 +172,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(path19) {
+      let normalized2 = (0, path_1.normalize)(path19);
       if (normalized2.length > 1 && normalized2[normalized2.length - 1] === path_1.sep)
         normalized2 = normalized2.substring(0, normalized2.length - 1);
       return normalized2;
@@ -187,28 +181,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(path19, separator) {
+      return path19.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(path19) {
+      return path19 === "/" || WINDOWS_ROOT_DIR_REGEX.test(path19);
     }
     __name(isRootDirectory, "isRootDirectory");
     exports.isRootDirectory = isRootDirectory;
-    function normalizePath2(path20, options) {
+    function normalizePath2(path19, options) {
       const { resolvePaths, normalizePath: normalizePath3, pathSeparator } = options;
-      const pathNeedsCleaning = process.platform === "win32" && path20.includes("/") || path20.startsWith(".");
+      const pathNeedsCleaning = process.platform === "win32" && path19.includes("/") || path19.startsWith(".");
       if (resolvePaths)
-        path20 = (0, path_1.resolve)(path20);
+        path19 = (0, path_1.resolve)(path19);
       if (normalizePath3 || pathNeedsCleaning)
-        path20 = cleanPath(path20);
-      if (path20 === ".")
+        path19 = cleanPath(path19);
+      if (path19 === ".")
         return "";
-      const needsSeperator = path20[path20.length - 1] !== pathSeparator;
-      return convertSlashes(needsSeperator ? path20 + pathSeparator : path20, pathSeparator);
+      const needsSeperator = path19[path19.length - 1] !== pathSeparator;
+      return convertSlashes(needsSeperator ? path19 + pathSeparator : path19, pathSeparator);
     }
     __name(normalizePath2, "normalizePath");
     exports.normalizePath = normalizePath2;
@@ -283,9 +277,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 path19 = directoryPath || ".";
+      if (filters.every((filter2) => filter2(path19, true))) {
+        paths.push(path19);
       }
     }, "pushDirectoryFilter");
     var empty = /* @__PURE__ */ __name(() => {
@@ -396,31 +390,31 @@ var require_resolve_symlink = __commonJS({
     exports.build = void 0;
     var fs_1 = __importDefault(__require("fs"));
     var path_1 = __require("path");
-    var resolveSymlinksAsync = /* @__PURE__ */ __name(function(path20, state, callback) {
+    var resolveSymlinksAsync = /* @__PURE__ */ __name(function(path19, state, callback) {
       const { queue, options: { suppressErrors } } = state;
       queue.enqueue();
-      fs_1.default.realpath(path20, (error, resolvedPath) => {
+      fs_1.default.realpath(path19, (error, resolvedPath) => {
         if (error)
           return queue.dequeue(suppressErrors ? null : error, state);
-        fs_1.default.stat(resolvedPath, (error2, stat5) => {
+        fs_1.default.stat(resolvedPath, (error2, stat4) => {
           if (error2)
             return queue.dequeue(suppressErrors ? null : error2, state);
-          if (stat5.isDirectory() && isRecursive(path20, resolvedPath, state))
+          if (stat4.isDirectory() && isRecursive(path19, resolvedPath, state))
             return queue.dequeue(null, state);
-          callback(stat5, resolvedPath);
+          callback(stat4, resolvedPath);
           queue.dequeue(null, state);
         });
       });
     }, "resolveSymlinksAsync");
-    var resolveSymlinks = /* @__PURE__ */ __name(function(path20, state, callback) {
+    var resolveSymlinks = /* @__PURE__ */ __name(function(path19, state, callback) {
       const { queue, options: { suppressErrors } } = state;
       queue.enqueue();
       try {
-        const resolvedPath = fs_1.default.realpathSync(path20);
-        const stat5 = fs_1.default.statSync(resolvedPath);
-        if (stat5.isDirectory() && isRecursive(path20, resolvedPath, state))
+        const resolvedPath = fs_1.default.realpathSync(path19);
+        const stat4 = fs_1.default.statSync(resolvedPath);
+        if (stat4.isDirectory() && isRecursive(path19, resolvedPath, state))
           return;
-        callback(stat5, resolvedPath);
+        callback(stat4, resolvedPath);
       } catch (e) {
         if (!suppressErrors)
           throw e;
@@ -433,10 +427,10 @@ var require_resolve_symlink = __commonJS({
     }
     __name(build, "build");
     exports.build = build;
-    function isRecursive(path20, resolved, state) {
+    function isRecursive(path19, resolved, state) {
       if (state.options.useRealPaths)
         return isRecursiveUsingRealPaths(resolved, state);
-      let parent = (0, path_1.dirname)(path20);
+      let parent = (0, path_1.dirname)(path19);
       let depth = 1;
       while (parent !== state.root && depth < 2) {
         const resolvedPath = state.symlinks.get(parent);
@@ -446,7 +440,7 @@ var require_resolve_symlink = __commonJS({
         else
           parent = (0, path_1.dirname)(parent);
       }
-      state.symlinks.set(path20, resolved);
+      state.symlinks.set(path19, resolved);
       return depth > 1;
     }
     __name(isRecursive, "isRecursive");
@@ -732,21 +726,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 path19 = joinPath.joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
+            if (exclude && exclude(entry.name, path19))
               continue;
-            this.pushDirectory(path20, paths, filters);
-            this.walkDirectory(this.state, path20, path20, depth - 1, this.walk);
+            this.pushDirectory(path19, paths, filters);
+            this.walkDirectory(this.state, path19, path19, depth - 1, this.walk);
           } else if (this.resolveSymlink && entry.isSymbolicLink()) {
-            let path20 = joinPath.joinPathWithBasePath(entry.name, directoryPath);
-            this.resolveSymlink(path20, this.state, (stat5, resolvedPath) => {
-              if (stat5.isDirectory()) {
+            let path19 = joinPath.joinPathWithBasePath(entry.name, directoryPath);
+            this.resolveSymlink(path19, this.state, (stat4, resolvedPath) => {
+              if (stat4.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 : path19 + pathSeparator))
                   return;
-                this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path20 + pathSeparator, depth - 1, this.walk);
+                this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path19 + pathSeparator, depth - 1, this.walk);
               } else {
-                resolvedPath = useRealPaths ? resolvedPath : path20;
+                resolvedPath = useRealPaths ? resolvedPath : path19;
                 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);
@@ -771,11 +765,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((resolve5, reject) => {
         callback(root, options, (err, output) => {
           if (err)
             return reject(err);
-          resolve6(output);
+          resolve5(output);
         });
       });
     }
@@ -973,7 +967,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((path19) => isMatch(path19));
         return this;
       }
     };
@@ -1053,7 +1047,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((resolve5, reject) => {
     new CoreToolScheduler({
       config,
       chatRecordingService: options.recordToolResult === false ? void 0 : config.getChatRecordingService(),
@@ -1062,7 +1056,7 @@ async function executeToolCall(config, toolCallRequest, abortSignal, options = {
         if (options.onAllToolCallsComplete) {
           await options.onAllToolCallsComplete(completedToolCalls);
         }
-        resolve6(completedToolCalls[0].response);
+        resolve5(completedToolCalls[0].response);
       }, "onAllToolCallsComplete"),
       onToolCallsUpdate: options.onToolCallsUpdate,
       onToolResultFullTurnModel: options.onToolResultFullTurnModel,
@@ -2556,7 +2550,7 @@ var McpTransportPool = class {
         spawnWait.then(() => {
           if (inflightTimer) clearTimeout(inflightTimer);
         }),
-        new Promise((resolve6) => {
+        new Promise((resolve5) => {
           inflightTimer = setTimeout(
             () => {
               const stuckIds = [...this.spawnInFlight.keys()];
@@ -2565,7 +2559,7 @@ var McpTransportPool = class {
                   ", "
                 )}. Proceeding with drain.`
               );
-              resolve6();
+              resolve5();
             },
             Math.max(0, deadline - Date.now())
           );
@@ -2591,8 +2585,8 @@ var McpTransportPool = class {
       Promise.all(shutdownPromises).then(() => {
         if (drainTimer) clearTimeout(drainTimer);
       }),
-      new Promise((resolve6) => {
-        drainTimer = setTimeout(() => resolve6(), remaining);
+      new Promise((resolve5) => {
+        drainTimer = setTimeout(() => resolve5(), remaining);
         drainTimer.unref?.();
       })
     ]);
@@ -5287,12 +5281,12 @@ __name(isWithin, "isWithin");
 async function readBoundedTaskFile(filePath) {
   const handle = await fs.open(filePath, "r");
   try {
-    const stat5 = await handle.stat();
-    if (!stat5.isFile()) {
+    const stat4 = await handle.stat();
+    if (!stat4.isFile()) {
       return null;
     }
     const cap = LOOP_TASK_FILE_MAX_BYTES + 1;
-    const allocSize = Math.min(cap, stat5.size + 1);
+    const allocSize = Math.min(cap, stat4.size + 1);
     const buffer = Buffer.alloc(allocSize);
     let total = 0;
     while (total < allocSize) {
@@ -5678,768 +5672,6 @@ ${PACING_SUFFIX[mode]}`,
   }
 };
 
-// packages/core/src/utils/github-prs.ts
-init_esbuild_shims();
-import { execFile as execFile2 } from "node:child_process";
-import { promisify as promisify2 } from "node:util";
-
-// packages/core/src/utils/git-branches.ts
-init_esbuild_shims();
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-
-// packages/core/src/utils/gitDirect.ts
-init_esbuild_shims();
-import * as fs2 from "node:fs";
-import * as fsPromises from "node:fs/promises";
-import * as path4 from "node:path";
-var SHORT_SHA_LENGTH = 7;
-var debug = createDebugLogger("gitDirect");
-var MAX_REF_COMPONENT_LENGTH = 255;
-var INVALID_REF_CHARS = /[\x00-\x20\x7f-\x9f\u200b-\u200d\u2028\u2029\u202a-\u202e\u2066-\u2069\ufeff~^:?*[\\]/;
-function isValidRefName(name) {
-  if (!name || name === "HEAD") return false;
-  if (name.startsWith("/") || name.endsWith("/")) return false;
-  if (name.startsWith(".") || name.endsWith(".")) return false;
-  if (name.endsWith(".lock")) return false;
-  if (name.includes("..") || name.includes("//")) return false;
-  if (name.includes("/.") || name.includes("./") || name.includes(".lock/")) {
-    return false;
-  }
-  if (name.includes("@{")) return false;
-  if (INVALID_REF_CHARS.test(name)) return false;
-  if (name.split("/").some((c) => c.length > MAX_REF_COMPONENT_LENGTH)) {
-    return false;
-  }
-  return true;
-}
-__name(isValidRefName, "isValidRefName");
-function isValidGitSha(value) {
-  return /^[0-9a-f]{40}$/.test(value) || /^[0-9a-f]{64}$/.test(value);
-}
-__name(isValidGitSha, "isValidGitSha");
-var gitDirCache = /* @__PURE__ */ new Map();
-async function isDir(p) {
-  try {
-    return (await fsPromises.stat(p)).isDirectory();
-  } catch {
-    return false;
-  }
-}
-__name(isDir, "isDir");
-async function hasGitStore(dir) {
-  const [objects, refs] = await Promise.all([
-    isDir(path4.join(dir, "objects")),
-    isDir(path4.join(dir, "refs"))
-  ]);
-  return objects && refs;
-}
-__name(hasGitStore, "hasGitStore");
-async function isRealGitDir(gitDir) {
-  if (await hasGitStore(gitDir)) return true;
-  const rel = await readFirstLineNoFollow(path4.join(gitDir, "commondir"));
-  if (!rel) return false;
-  return hasGitStore(path4.resolve(gitDir, rel.trim()));
-}
-__name(isRealGitDir, "isRealGitDir");
-async function resolveTrustedGitDir(cwd) {
-  const gitDir = await resolveGitDir(cwd);
-  if (!gitDir) return null;
-  return await isRealGitDir(gitDir) ? gitDir : null;
-}
-__name(resolveTrustedGitDir, "resolveTrustedGitDir");
-async function getCachedGitDir(cwd) {
-  const key = path4.resolve(cwd);
-  const cached = gitDirCache.get(key);
-  if (cached !== void 0) return cached;
-  const gitDir = await resolveTrustedGitDir(key);
-  if (gitDir !== null) gitDirCache.set(key, gitDir);
-  return gitDir;
-}
-__name(getCachedGitDir, "getCachedGitDir");
-async function readGitHead(gitDir) {
-  const firstLine = await readFirstLineNoFollow(path4.join(gitDir, "HEAD"));
-  if (firstLine === null) return null;
-  const content = firstLine.trim();
-  if (content.startsWith("ref:")) {
-    const ref = content.slice(4).trim();
-    if (!ref.startsWith("refs/heads/")) return null;
-    const name = ref.slice("refs/heads/".length);
-    if (!isValidRefName(name)) return null;
-    return { type: "branch", name };
-  }
-  if (isValidGitSha(content)) {
-    return { type: "detached", name: content };
-  }
-  return null;
-}
-__name(readGitHead, "readGitHead");
-async function resolveBranchName(cwd) {
-  const gitDir = await getCachedGitDir(cwd);
-  if (!gitDir) return void 0;
-  const head = await readGitHead(gitDir);
-  if (!head) return void 0;
-  return head.type === "branch" ? head.name : head.name.slice(0, SHORT_SHA_LENGTH);
-}
-__name(resolveBranchName, "resolveBranchName");
-var repoBranchWatches = /* @__PURE__ */ new Map();
-async function watchRepoBranch(cwd, onChange) {
-  const gitDir = await getCachedGitDir(cwd);
-  if (!gitDir) return () => {
-  };
-  let entry = repoBranchWatches.get(gitDir);
-  if (!entry) {
-    const logsHeadPath = path4.join(gitDir, "logs", "HEAD");
-    try {
-      await fsPromises.access(logsHeadPath, fs2.constants?.F_OK ?? 0);
-      if ((await fsPromises.lstat(logsHeadPath)).isSymbolicLink()) {
-        return () => {
-        };
-      }
-    } catch {
-      return () => {
-      };
-    }
-    const existing = repoBranchWatches.get(gitDir);
-    if (existing) {
-      entry = existing;
-    } else {
-      let watcher;
-      try {
-        watcher = fs2.watch(logsHeadPath, (eventType) => {
-          if (eventType === "change" || eventType === "rename") {
-            repoBranchWatches.get(gitDir)?.subscribers.forEach((cb) => {
-              try {
-                cb();
-              } catch {
-              }
-            });
-          }
-        });
-      } catch (err) {
-        debug.warn(`failed to watch reflog for ${gitDir}: ${err}`);
-        return () => {
-        };
-      }
-      watcher.on("error", (err) => {
-        debug.warn(
-          `reflog watcher error for ${gitDir}; branch will no longer auto-update: ${err?.message}`
-        );
-        const current = repoBranchWatches.get(gitDir);
-        if (current?.watcher === watcher) {
-          try {
-            watcher.close();
-          } catch {
-          }
-          repoBranchWatches.delete(gitDir);
-        }
-      });
-      entry = { watcher, subscribers: /* @__PURE__ */ new Set() };
-      repoBranchWatches.set(gitDir, entry);
-    }
-  }
-  entry.subscribers.add(onChange);
-  let disposed = false;
-  return () => {
-    if (disposed) return;
-    disposed = true;
-    const e = repoBranchWatches.get(gitDir);
-    if (!e) return;
-    e.subscribers.delete(onChange);
-    if (e.subscribers.size === 0) {
-      e.watcher.close();
-      repoBranchWatches.delete(gitDir);
-    }
-  };
-}
-__name(watchRepoBranch, "watchRepoBranch");
-
-// packages/core/src/utils/git-branches.ts
-var execFileAsync = promisify(execFile);
-var GIT_TIMEOUT_MS = 3e4;
-var MAX_RECENT_BRANCHES = 20;
-var MAX_REFLOG_ENTRIES = 200;
-var GIT_ENV_VARS_TO_CLEAR = [
-  "GIT_DIR",
-  "GIT_WORK_TREE",
-  "GIT_COMMON_DIR",
-  "GIT_INDEX_FILE",
-  "GIT_CONFIG_GLOBAL",
-  "GIT_CONFIG_SYSTEM",
-  "GIT_CONFIG_NOSYSTEM",
-  // Repository selectors that an inherited daemon environment could use to
-  // redirect a trusted-workspace git/gh invocation to a different repository
-  // or object database despite the resolved cwd.
-  "GH_REPO",
-  "GIT_CONFIG_COUNT",
-  "GIT_CONFIG_PARAMETERS",
-  "GIT_OBJECT_DIRECTORY",
-  "GIT_ALTERNATE_OBJECT_DIRECTORIES"
-];
-var GIT_ENV_PREFIXES_TO_CLEAR = ["GIT_CONFIG_KEY_", "GIT_CONFIG_VALUE_"];
-function gitEnv(base) {
-  const env2 = { ...base ?? process.env };
-  for (const key of GIT_ENV_VARS_TO_CLEAR) {
-    delete env2[key];
-  }
-  for (const key of Object.keys(env2)) {
-    if (GIT_ENV_PREFIXES_TO_CLEAR.some((prefix) => key.startsWith(prefix))) {
-      delete env2[key];
-    }
-  }
-  env2["LC_ALL"] = "C";
-  env2["LANG"] = "C";
-  return env2;
-}
-__name(gitEnv, "gitEnv");
-function runGit(cwd, args, env2) {
-  return execFileAsync("git", args, {
-    cwd,
-    timeout: GIT_TIMEOUT_MS,
-    maxBuffer: 10 * 1024 * 1024,
-    env: gitEnv(env2)
-  }).then(({ stdout }) => stdout);
-}
-__name(runGit, "runGit");
-var SEPARATOR = "\0";
-async function fetchGitBranches(cwd, env2) {
-  await runGit(cwd, ["rev-parse", "--git-dir"], env2);
-  const [localRaw, remoteRaw, tagsRaw, headRaw, reflogRaw] = await Promise.all([
-    runGit(
-      cwd,
-      [
-        "for-each-ref",
-        "--format=%(refname:short)%00%(HEAD)%00%(upstream:short)%00%(upstream:track,nobracket)%00%(committerdate:unix)%00%(subject)%00%(symref)",
-        "refs/heads/"
-      ],
-      env2
-    ).catch(() => ""),
-    runGit(
-      cwd,
-      [
-        "for-each-ref",
-        "--format=%(refname:short)%00%(HEAD)%00%(upstream:short)%00%(upstream:track,nobracket)%00%(committerdate:unix)%00%(subject)%00%(symref)",
-        "refs/remotes/"
-      ],
-      env2
-    ).catch(() => ""),
-    runGit(
-      cwd,
-      [
-        "for-each-ref",
-        "--format=%(refname:short)%00%(creatordate:unix)%00%(subject)",
-        "--sort=-creatordate",
-        "refs/tags/"
-      ],
-      env2
-    ).catch(() => ""),
-    runGit(cwd, ["symbolic-ref", "--short", "HEAD"], env2).catch(() => ""),
-    runGit(
-      cwd,
-      ["reflog", "show", "--format=%gs", `-${MAX_REFLOG_ENTRIES}`],
-      env2
-    ).catch(() => "")
-  ]);
-  const local = parseBranchLines(localRaw);
-  const remote = parseBranchLines(remoteRaw);
-  const tags = parseTagLines(tagsRaw);
-  const recent = parseRecentBranches(reflogRaw, headRaw.trim());
-  const headTrimmed = headRaw.trim();
-  const detached = !headTrimmed;
-  return {
-    local,
-    remote,
-    tags,
-    recent,
-    head: headTrimmed || await getDetachedHead(cwd, env2),
-    detached
-  };
-}
-__name(fetchGitBranches, "fetchGitBranches");
-function parseBranchLines(raw) {
-  if (!raw.trim()) return [];
-  return raw.trim().split("\n").filter(Boolean).filter((line) => {
-    const parts = line.split(SEPARATOR);
-    return !(parts[6] ?? "");
-  }).map((line) => {
-    const parts = line.split(SEPARATOR);
-    const name = parts[0] ?? "";
-    const isHead = parts[1] === "*";
-    const upstream = parts[2] || void 0;
-    const track = parts[3] ?? "";
-    const commitDate = parseInt(parts[4] ?? "0", 10) || 0;
-    const commitSubject = parts[5] ?? "";
-    let ahead = 0;
-    let behind = 0;
-    const aheadMatch = /ahead (\d+)/.exec(track);
-    const behindMatch = /behind (\d+)/.exec(track);
-    if (aheadMatch) ahead = parseInt(aheadMatch[1], 10);
-    if (behindMatch) behind = parseInt(behindMatch[1], 10);
-    const upstreamGone = upstream !== void 0 && /\bgone\b/.test(track);
-    return {
-      name,
-      isHead,
-      upstream,
-      ...upstreamGone ? { upstreamGone } : {},
-      ahead,
-      behind,
-      commitDate,
-      commitSubject
-    };
-  });
-}
-__name(parseBranchLines, "parseBranchLines");
-function parseTagLines(raw) {
-  if (!raw.trim()) return [];
-  return raw.trim().split("\n").filter(Boolean).map((line) => {
-    const parts = line.split(SEPARATOR);
-    return {
-      name: parts[0] ?? "",
-      date: parseInt(parts[1] ?? "0", 10) || 0,
-      subject: parts[2] ?? ""
-    };
-  });
-}
-__name(parseTagLines, "parseTagLines");
-function parseRecentBranches(reflogRaw, currentHead) {
-  if (!reflogRaw.trim()) return [];
-  const seen = /* @__PURE__ */ new Set();
-  const result = [];
-  for (const line of reflogRaw.trim().split("\n")) {
-    if (!line.startsWith("checkout: moving from ")) continue;
-    const idx = line.indexOf(" to ");
-    if (idx === -1) continue;
-    const branch = line.slice(idx + 4);
-    if (branch && !seen.has(branch) && branch !== currentHead && !/^[0-9a-f]{7,40}$/.test(branch)) {
-      seen.add(branch);
-      result.push(branch);
-      if (result.length >= MAX_RECENT_BRANCHES) break;
-    }
-  }
-  return result;
-}
-__name(parseRecentBranches, "parseRecentBranches");
-async function getDetachedHead(cwd, env2) {
-  try {
-    const sha = await runGit(cwd, ["rev-parse", "--short", "HEAD"], env2);
-    return sha.trim();
-  } catch {
-    return "";
-  }
-}
-__name(getDetachedHead, "getDetachedHead");
-function isValidCheckoutRef(value) {
-  const ref = value.trim();
-  if (!ref || ref.startsWith("-")) return false;
-  if (ref === "HEAD") return true;
-  return isValidRefName(ref) || isValidGitSha(ref);
-}
-__name(isValidCheckoutRef, "isValidCheckoutRef");
-async function gitCheckout(cwd, ref, env2) {
-  if (!isValidCheckoutRef(ref)) {
-    throw new Error(`invalid checkout ref: ${ref}`);
-  }
-  const isRemoteTracking = await runGit(
-    cwd,
-    ["show-ref", "--verify", "--quiet", `refs/remotes/${ref}`],
-    env2
-  ).then(() => true).catch(() => false);
-  if (isRemoteTracking) {
-    const localName = ref.slice(ref.indexOf("/") + 1);
-    if (!isValidCheckoutRef(localName)) {
-      throw new Error(
-        `invalid local branch name derived from remote ref: ${localName}`
-      );
-    }
-    const hasLocal = await runGit(
-      cwd,
-      ["show-ref", "--verify", "--quiet", `refs/heads/${localName}`],
-      env2
-    ).then(() => true).catch(() => false);
-    if (hasLocal) {
-      await runGit(cwd, ["checkout", localName, "--"], env2);
-    } else {
-      await runGit(cwd, ["checkout", "--track", ref], env2);
-    }
-    const head = (await runGit(cwd, ["symbolic-ref", "--short", "HEAD"], env2)).trim();
-    return { branch: head, detached: false };
-  }
-  await runGit(cwd, ["checkout", ref, "--"], env2);
-  const headRaw = await runGit(
-    cwd,
-    ["symbolic-ref", "--short", "HEAD"],
-    env2
-  ).catch(() => "");
-  const trimmed = headRaw.trim();
-  if (trimmed) {
-    return { branch: trimmed, detached: false };
-  }
-  const sha = await runGit(cwd, ["rev-parse", "--short", "HEAD"], env2);
-  return { branch: sha.trim(), detached: true };
-}
-__name(gitCheckout, "gitCheckout");
-async function gitCreateBranch(cwd, name, startPoint, env2) {
-  if (!isValidRefName(name) || name.startsWith("-")) {
-    throw new Error(`invalid branch name: ${name}`);
-  }
-  const args = ["checkout", "-b", name];
-  if (startPoint) {
-    if (!isValidCheckoutRef(startPoint)) {
-      throw new Error(`invalid start point: ${startPoint}`);
-    }
-    args.push(startPoint);
-  }
-  args.push("--");
-  const originalRef = (await runGit(
-    cwd,
-    ["symbolic-ref", "--quiet", "--short", "HEAD"],
-    env2
-  ).catch(() => "")).trim();
-  const originalCommit = originalRef ? "" : (await runGit(cwd, ["rev-parse", "HEAD"], env2).catch(() => "")).trim();
-  try {
-    await runGit(cwd, args, env2);
-  } catch (err) {
-    const nowOn = (await runGit(
-      cwd,
-      ["symbolic-ref", "--quiet", "--short", "HEAD"],
-      env2
-    ).catch(() => "")).trim();
-    if (nowOn === name) {
-      if (originalRef) {
-        await runGit(cwd, ["checkout", originalRef, "--"], env2).catch(() => {
-        });
-      } else if (originalCommit) {
-        await runGit(
-          cwd,
-          ["checkout", "--detach", originalCommit, "--"],
-          env2
-        ).catch(() => {
-        });
-      }
-      await runGit(cwd, ["branch", "-D", name], env2).catch(() => {
-      });
-    }
-    throw err;
-  }
-  return { branch: name, detached: false };
-}
-__name(gitCreateBranch, "gitCreateBranch");
-async function gitPush(cwd, opts, env2) {
-  const args = ["push"];
-  if (opts?.force) args.push("--force-with-lease");
-  if (opts?.setUpstream) {
-    let branch;
-    try {
-      branch = (await runGit(cwd, ["symbolic-ref", "--short", "HEAD"], env2)).trim();
-    } catch {
-      throw new Error(
-        "cannot push with --set-upstream in detached HEAD state; check out a branch first"
-      );
-    }
-    const hasUpstream = await runGit(
-      cwd,
-      ["rev-parse", "--abbrev-ref", `${branch}@{u}`],
-      env2
-    ).catch(() => "");
-    if (hasUpstream.trim()) {
-      const output2 = await runGit(cwd, args, env2);
-      return { success: true, output: output2.trim() };
-    }
-    let remote = (await runGit(cwd, ["config", `branch.${branch}.pushRemote`], env2).catch(
-      () => ""
-    )).trim();
-    if (!remote) {
-      remote = (await runGit(cwd, ["config", "remote.pushDefault"], env2).catch(() => "")).trim();
-    }
-    if (!remote) {
-      remote = (await runGit(cwd, ["config", `branch.${branch}.remote`], env2).catch(
-        () => ""
-      )).trim();
-    }
-    if (!remote) {
-      const remotes = (await runGit(cwd, ["remote"], env2).catch(() => "")).trim();
-      const remoteList = remotes ? remotes.split("\n") : [];
-      remote = remoteList.length === 1 ? remoteList[0] ?? "origin" : "origin";
-    }
-    args.push("--set-upstream", remote, branch);
-  }
-  const output = await runGit(cwd, args, env2);
-  return { success: true, output: output.trim() };
-}
-__name(gitPush, "gitPush");
-async function gitPull(cwd, opts, env2) {
-  if (opts?.fetchOnly) {
-    const output2 = await runGit(cwd, ["fetch", "--all", "--prune"], env2);
-    return { success: true, output: output2.trim() };
-  }
-  const args = ["pull"];
-  if (opts?.rebase) args.push("--rebase");
-  const output = await runGit(cwd, args, env2);
-  return { success: true, output: output.trim() };
-}
-__name(gitPull, "gitPull");
-async function gitCommit(cwd, message, opts, env2) {
-  let savedIndex = null;
-  if (opts?.all) {
-    const tree = (await runGit(cwd, ["write-tree"], env2).catch(() => "")).trim();
-    if (tree) {
-      savedIndex = tree;
-    } else {
-      const unmerged = (await runGit(cwd, ["ls-files", "--unmerged"], env2)).trim();
-      if (unmerged) {
-        throw new Error(
-          "cannot stage all changes: unresolved merge conflicts in the index"
-        );
-      }
-      throw new Error(
-        "cannot stage all changes: failed to snapshot index (write-tree failed)"
-      );
-    }
-  }
-  try {
-    if (opts?.all) {
-      await runGit(cwd, ["add", "-A"], env2);
-    }
-    await runGit(cwd, ["commit", "-m", message], env2);
-  } catch (err) {
-    if (savedIndex) {
-      await runGit(cwd, ["read-tree", savedIndex], env2).catch((rollbackErr) => {
-        console.error("git index rollback failed:", rollbackErr);
-      });
-    }
-    throw err;
-  }
-  const sha = (await runGit(cwd, ["rev-parse", "--short", "HEAD"], env2)).trim();
-  const subject = (await runGit(cwd, ["log", "-1", "--format=%s"], env2)).trim();
-  return { sha, subject };
-}
-__name(gitCommit, "gitCommit");
-
-// packages/core/src/utils/github-prs.ts
-var execFileAsync2 = promisify2(execFile2);
-var GH_TIMEOUT_MS = 1e4;
-var GH_MAX_BUFFER = 16 * 1024 * 1024;
-var GH_ERROR_RAW_MAX = 4096;
-var GITHUB_PR_ERROR_MESSAGE_MAX = 512;
-var GITHUB_PR_LIST_LIMIT = 30;
-var GH_PR_LIST_FIELDS = "number,title,url,author,headRefName,isDraft,reviewDecision,statusCheckRollup,updatedAt";
-var GH_PR_LIST_FIELDS_SLIM = "number,url,headRefName,state";
-var FAILING_CHECK_RUN_CONCLUSIONS = /* @__PURE__ */ new Set([
-  "FAILURE",
-  "CANCELLED",
-  "TIMED_OUT",
-  "ACTION_REQUIRED",
-  "STARTUP_FAILURE",
-  "STALE"
-]);
-var FAILING_STATUS_CONTEXT_STATES = /* @__PURE__ */ new Set(["ERROR", "FAILURE"]);
-function aggregateChecks(rollup) {
-  if (!Array.isArray(rollup) || rollup.length === 0) return "none";
-  let sawPassing = false;
-  let sawPending = false;
-  for (const entry of rollup) {
-    if (entry.__typename === "StatusContext") {
-      const state = entry.state?.toUpperCase();
-      if (state && FAILING_STATUS_CONTEXT_STATES.has(state)) return "failing";
-      if (state === "SUCCESS") sawPassing = true;
-      else sawPending = true;
-    } else {
-      const conclusion = entry.conclusion?.toUpperCase();
-      if (conclusion) {
-        if (FAILING_CHECK_RUN_CONCLUSIONS.has(conclusion)) return "failing";
-        sawPassing = true;
-      } else {
-        sawPending = true;
-      }
-    }
-  }
-  if (sawPending) return "pending";
-  return sawPassing ? "passing" : "none";
-}
-__name(aggregateChecks, "aggregateChecks");
-function mapReviewDecision(value) {
-  switch (value) {
-    case "APPROVED":
-      return "approved";
-    case "CHANGES_REQUESTED":
-      return "changes_requested";
-    case "REVIEW_REQUIRED":
-      return "review_required";
-    default:
-      return null;
-  }
-}
-__name(mapReviewDecision, "mapReviewDecision");
-function mapEntry(entry) {
-  if (typeof entry.number !== "number") return null;
-  const parsed = Date.parse(entry.updatedAt ?? "");
-  let state;
-  switch (entry.state?.toUpperCase()) {
-    case "MERGED":
-      state = "merged";
-      break;
-    case "CLOSED":
-      state = "closed";
-      break;
-    default:
-      state = entry.isDraft ? "draft" : "open";
-      break;
-  }
-  return {
-    number: entry.number,
-    title: entry.title ?? "",
-    url: entry.url ?? "",
-    author: entry.author?.login ?? "",
-    headRefName: entry.headRefName ?? "",
-    state,
-    reviewDecision: mapReviewDecision(entry.reviewDecision),
-    checks: aggregateChecks(entry.statusCheckRollup),
-    updatedAt: Number.isNaN(parsed) ? 0 : Math.floor(parsed / 1e3)
-  };
-}
-__name(mapEntry, "mapEntry");
-function parseGhPrList(stdout) {
-  const parsed = JSON.parse(stdout);
-  if (!Array.isArray(parsed)) {
-    throw new Error("unexpected gh output: expected a JSON array");
-  }
-  return parsed.map((entry) => mapEntry(entry)).filter((entry) => entry !== null).sort((a, b) => b.updatedAt - a.updatedAt);
-}
-__name(parseGhPrList, "parseGhPrList");
-function runGhPrList(gitRoot, env2, options = {}) {
-  const limit = Math.min(
-    Math.max(options.limit ?? GITHUB_PR_LIST_LIMIT, 1),
-    1e3
-  );
-  return new Promise((resolve6, reject) => {
-    execFile2(
-      "gh",
-      [
-        "pr",
-        "list",
-        "--state",
-        options.state ?? "open",
-        "--limit",
-        String(limit),
-        "--json",
-        options.slim ? GH_PR_LIST_FIELDS_SLIM : GH_PR_LIST_FIELDS
-      ],
-      {
-        cwd: gitRoot,
-        timeout: GH_TIMEOUT_MS,
-        maxBuffer: GH_MAX_BUFFER,
-        windowsHide: true,
-        encoding: "utf8",
-        env: gitEnv(env2)
-      },
-      (error, stdout) => {
-        if (error) reject(error);
-        else resolve6(stdout);
-      }
-    );
-  });
-}
-__name(runGhPrList, "runGhPrList");
-function ghErrorMessage(error, commandLabel = "gh pr list", timeoutMs = GH_TIMEOUT_MS) {
-  if (error?.killed === true) {
-    return `${commandLabel} timed out after ${timeoutMs / 1e3}s`;
-  }
-  const stderr = error?.stderr;
-  const raw = typeof stderr === "string" && stderr.trim() ? stderr : error instanceof Error ? error.message : String(error);
-  return raw.replace(/\s+/g, " ").trim().slice(0, GH_ERROR_RAW_MAX);
-}
-__name(ghErrorMessage, "ghErrorMessage");
-async function fetchGitHubPullRequests(cwd, env2, options) {
-  const gitRoot = findGitRoot(cwd);
-  if (!gitRoot) return { kind: "not_a_repo" };
-  let stdout;
-  try {
-    stdout = await runGhPrList(gitRoot, env2, options);
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return { kind: "cli_unavailable" };
-    }
-    return { kind: "failed", message: ghErrorMessage(error), gitRoot };
-  }
-  try {
-    return { kind: "ok", pullRequests: parseGhPrList(stdout) };
-  } catch (error) {
-    return { kind: "failed", message: ghErrorMessage(error), gitRoot };
-  }
-}
-__name(fetchGitHubPullRequests, "fetchGitHubPullRequests");
-var GH_CREATE_TIMEOUT_MS = 3e4;
-function runGhPrCreate(gitRoot, opts, env2) {
-  const args = ["pr", "create", "--title", opts.title];
-  args.push("--body", opts.body ?? "");
-  if (opts.base) args.push("--base", opts.base);
-  if (opts.head) args.push("--head", opts.head);
-  return new Promise((resolve6, reject) => {
-    execFile2(
-      "gh",
-      args,
-      {
-        cwd: gitRoot,
-        timeout: GH_CREATE_TIMEOUT_MS,
-        maxBuffer: GH_MAX_BUFFER,
-        windowsHide: true,
-        encoding: "utf8",
-        env: gitEnv(env2)
-      },
-      (error, stdout) => {
-        if (error) reject(error);
-        else resolve6(stdout);
-      }
-    );
-  });
-}
-__name(runGhPrCreate, "runGhPrCreate");
-async function createGitHubPullRequest(cwd, opts, env2) {
-  const gitRoot = findGitRoot(cwd);
-  if (!gitRoot) return { kind: "not_a_repo" };
-  let stdout;
-  try {
-    stdout = await runGhPrCreate(gitRoot, opts, env2);
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return { kind: "cli_unavailable" };
-    }
-    return {
-      kind: "failed",
-      message: ghErrorMessage(error, "gh pr create", GH_CREATE_TIMEOUT_MS),
-      gitRoot
-    };
-  }
-  const url = stdout.trim();
-  const numberMatch = /\/pull\/(\d+)/.exec(url);
-  const number = numberMatch ? parseInt(numberMatch[1], 10) : null;
-  return { kind: "ok", url, number };
-}
-__name(createGitHubPullRequest, "createGitHubPullRequest");
-async function getDefaultBranch(cwd, env2) {
-  const gitRoot = findGitRoot(cwd);
-  if (!gitRoot) return null;
-  try {
-    const { stdout } = await execFileAsync2(
-      "git",
-      ["symbolic-ref", "refs/remotes/origin/HEAD", "--short"],
-      {
-        cwd: gitRoot,
-        timeout: 5e3,
-        encoding: "utf8",
-        windowsHide: true,
-        env: gitEnv(env2)
-      }
-    );
-    const raw = stdout.trim();
-    if (!raw) return null;
-    return raw;
-  } catch {
-    return null;
-  }
-}
-__name(getDefaultBranch, "getDefaultBranch");
-
 // packages/core/src/utils/subagentGenerator.ts
 init_esbuild_shims();
 var SYSTEM_PROMPT = `You are an elite AI agent architect specializing in crafting high-performance agent configurations. Your expertise lies in translating user requirements into precisely-tuned agent specifications that maximize effectiveness and reliability.
@@ -6780,9 +6012,9 @@ function encodeInsightProgressMessage(stage, progress, detail) {
   return JSON.stringify(payload);
 }
 __name(encodeInsightProgressMessage, "encodeInsightProgressMessage");
-function encodeInsightReadyMessage(path20) {
+function encodeInsightReadyMessage(path19) {
   const payload = {
-    insight_ready: { path: path20 }
+    insight_ready: { path: path19 }
   };
   return JSON.stringify(payload);
 }
@@ -6797,8 +6029,8 @@ __name(encodeInsightErrorMessage, "encodeInsightErrorMessage");
 
 // packages/core/src/core/logger.ts
 init_esbuild_shims();
-import path5 from "node:path";
-import { promises as fs3 } from "node:fs";
+import path4 from "node:path";
+import { promises as fs2 } from "node:fs";
 var LOG_FILE_NAME = "logs.json";
 function encodeTagName(str) {
   return encodeURIComponent(str);
@@ -6851,7 +6083,7 @@ var Logger = class {
       throw new Error("Log file path not set during read attempt.");
     }
     try {
-      const fileContent = await fs3.readFile(this.logFilePath, "utf-8");
+      const fileContent = await fs2.readFile(this.logFilePath, "utf-8");
       const parsedLogs = JSON.parse(fileContent);
       if (!Array.isArray(parsedLogs)) {
         this.debugLogger.debug(
@@ -6887,7 +6119,7 @@ var Logger = class {
     if (!this.logFilePath) return;
     const backupPath = `${this.logFilePath}.${reason}.${Date.now()}.bak`;
     try {
-      await fs3.rename(this.logFilePath, backupPath);
+      await fs2.rename(this.logFilePath, backupPath);
       this.debugLogger.debug(`Backed up corrupted log file to ${backupPath}`);
     } catch (_backupError) {
     }
@@ -6897,12 +6129,12 @@ var Logger = class {
       return;
     }
     this.qwenDir = this.storage.getProjectTempDir();
-    this.logFilePath = path5.join(this.qwenDir, LOG_FILE_NAME);
+    this.logFilePath = path4.join(this.qwenDir, LOG_FILE_NAME);
     try {
-      await fs3.mkdir(this.qwenDir, { recursive: true });
+      await fs2.mkdir(this.qwenDir, { recursive: true });
       let fileExisted = true;
       try {
-        await fs3.access(this.logFilePath);
+        await fs2.access(this.logFilePath);
       } catch (_e) {
         fileExisted = false;
       }
@@ -7126,12 +6358,12 @@ var Logger = class {
       throw new Error("Checkpoint file path not set.");
     }
     const encodedTag = encodeTagName(tag);
-    return path5.join(this.qwenDir, `checkpoint-${encodedTag}.json`);
+    return path4.join(this.qwenDir, `checkpoint-${encodedTag}.json`);
   }
   async _getCheckpointPath(tag) {
     const newPath = this._checkpointPath(tag);
     try {
-      await fs3.access(newPath);
+      await fs2.access(newPath);
       return newPath;
     } catch (error) {
       const nodeError = error;
@@ -7139,9 +6371,9 @@ var Logger = class {
         throw error;
       }
     }
-    const oldPath = path5.join(this.qwenDir, `checkpoint-${tag}.json`);
+    const oldPath = path4.join(this.qwenDir, `checkpoint-${tag}.json`);
     try {
-      await fs3.access(oldPath);
+      await fs2.access(oldPath);
       return oldPath;
     } catch (error) {
       const nodeError = error;
@@ -7158,9 +6390,9 @@ var Logger = class {
       );
       return;
     }
-    const path20 = this._checkpointPath(tag);
+    const path19 = this._checkpointPath(tag);
     try {
-      await atomicWriteFile(path20, JSON.stringify(conversation, null, 2), {
+      await atomicWriteFile(path19, JSON.stringify(conversation, null, 2), {
         encoding: "utf-8"
       });
     } catch (error) {
@@ -7174,13 +6406,13 @@ var Logger = class {
       );
       return [];
     }
-    const path20 = await this._getCheckpointPath(tag);
+    const path19 = await this._getCheckpointPath(tag);
     try {
-      const fileContent = await fs3.readFile(path20, "utf-8");
+      const fileContent = await fs2.readFile(path19, "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 ${path19} is not a valid JSON array. Returning empty checkpoint.`
         );
         return [];
       }
@@ -7191,7 +6423,7 @@ var Logger = class {
         return [];
       }
       this.debugLogger.error(
-        `Failed to read or parse checkpoint file ${path20}:`,
+        `Failed to read or parse checkpoint file ${path19}:`,
         error
       );
       return [];
@@ -7207,7 +6439,7 @@ var Logger = class {
     let deletedSomething = false;
     const newPath = this._checkpointPath(tag);
     try {
-      await fs3.unlink(newPath);
+      await fs2.unlink(newPath);
       deletedSomething = true;
     } catch (error) {
       const nodeError = error;
@@ -7219,10 +6451,10 @@ var Logger = class {
         throw error;
       }
     }
-    const oldPath = path5.join(this.qwenDir, `checkpoint-${tag}.json`);
+    const oldPath = path4.join(this.qwenDir, `checkpoint-${tag}.json`);
     if (newPath !== oldPath) {
       try {
-        await fs3.unlink(oldPath);
+        await fs2.unlink(oldPath);
         deletedSomething = true;
       } catch (error) {
         const nodeError = error;
@@ -7246,7 +6478,7 @@ var Logger = class {
     let filePath;
     try {
       filePath = await this._getCheckpointPath(tag);
-      await fs3.access(filePath);
+      await fs2.access(filePath);
       return true;
     } catch (error) {
       const nodeError = error;
@@ -7369,7 +6601,7 @@ var ClientMcpRegistrar = class {
       }
       return Promise.resolve(ack);
     }
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve5, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id);
         reject(
@@ -7379,7 +6611,7 @@ var ClientMcpRegistrar = class {
         );
       }, this.messageTimeoutMs);
       timer.unref?.();
-      this.pending.set(id, { resolve: resolve6, reject, timer, server: serverName });
+      this.pending.set(id, { resolve: resolve5, reject, timer, server: serverName });
       let sendResult;
       try {
         sendResult = this.sendFrame({
@@ -7591,10 +6823,11 @@ ${body}`;
 
 // packages/core/src/ipc/uds-inbox.ts
 init_esbuild_shims();
+import { timingSafeEqual } from "node:crypto";
 import * as fsSync from "node:fs";
-import * as fs4 from "node:fs/promises";
+import * as fs3 from "node:fs/promises";
 import * as net from "node:net";
-import * as path6 from "node:path";
+import * as path5 from "node:path";
 var debugLogger9 = createDebugLogger("PEER_IPC");
 var SOCKET_DIR_MODE = 448;
 var SOCKET_MODE = 384;
@@ -7625,9 +6858,9 @@ async function startPeerInbox(options) {
     return null;
   }
   try {
-    const dir = path6.dirname(socketPath);
-    await fs4.mkdir(dir, { recursive: true, mode: SOCKET_DIR_MODE });
-    const dirStat = await fs4.lstat(dir);
+    const dir = path5.dirname(socketPath);
+    await fs3.mkdir(dir, { recursive: true, mode: SOCKET_DIR_MODE });
+    const dirStat = await fs3.lstat(dir);
     const uid = typeof process.getuid === "function" ? process.getuid() : null;
     if (!dirStat.isDirectory()) {
       throw new Error(`${dir} is not a directory`);
@@ -7635,13 +6868,13 @@ async function startPeerInbox(options) {
     if (uid !== null && dirStat.uid !== uid) {
       throw new Error(`${dir} belongs to uid ${dirStat.uid}, not ${uid}`);
     }
-    await fs4.chmod(dir, SOCKET_DIR_MODE);
+    await fs3.chmod(dir, SOCKET_DIR_MODE);
   } catch (error) {
     debugLogger9.error(`peer inbox directory unusable: ${describe(error)}`);
     return null;
   }
   try {
-    await fs4.unlink(socketPath);
+    await fs3.unlink(socketPath);
   } catch {
   }
   const connections = /* @__PURE__ */ new Set();
@@ -7653,8 +6886,28 @@ async function startPeerInbox(options) {
       debugLogger9.debug("dropping an idle peer connection");
       socket.destroy();
     });
+    let authed = options.requiredToken === void 0;
+    let auth;
+    let refused = false;
     const read2 = createLineReader(
       (line) => {
+        if (refused) return;
+        if (!authed) {
+          const presented = parsePeerAuthLine(line);
+          if (presented !== null) {
+            auth = authKindOf(options, presented);
+          }
+          if (auth !== void 0) {
+            authed = true;
+            return;
+          }
+          debugLogger9.debug(
+            "dropping a connection whose first line did not authenticate: no valid auth line, or token mismatch"
+          );
+          refused = true;
+          socket.destroy();
+          return;
+        }
         const frame = parsePeerFrame(line);
         if (frame === null) {
           debugLogger9.debug(
@@ -7663,7 +6916,7 @@ async function startPeerInbox(options) {
           return;
         }
         try {
-          options.onFrame(frame);
+          options.onFrame(frame, auth);
         } catch (error) {
           debugLogger9.error(`onFrame threw: ${describe(error)}`);
         }
@@ -7691,11 +6944,11 @@ async function startPeerInbox(options) {
     debugLogger9.error(`peer inbox server error: ${describe(error)}`);
   });
   try {
-    await new Promise((resolve6, reject) => {
+    await new Promise((resolve5, reject) => {
       server.once("error", reject);
       server.listen(socketPath, () => {
         server.removeListener("error", reject);
-        resolve6();
+        resolve5();
       });
     });
   } catch (error) {
@@ -7712,7 +6965,7 @@ async function startPeerInbox(options) {
     return null;
   }
   try {
-    await fs4.chmod(socketPath, SOCKET_MODE);
+    await fs3.chmod(socketPath, SOCKET_MODE);
   } catch (error) {
     debugLogger9.error(
       `peer inbox socket could not be restricted to 0600, refusing to listen: ${describe(error)}`
@@ -7734,9 +6987,9 @@ async function startPeerInbox(options) {
       closed = true;
       for (const socket of connections) socket.destroy();
       connections.clear();
-      await new Promise((resolve6) => server.close(() => resolve6()));
+      await new Promise((resolve5) => server.close(() => resolve5()));
       try {
-        await fs4.unlink(socketPath);
+        await fs3.unlink(socketPath);
       } catch {
       }
       debugLogger9.debug(`peer inbox closed: ${socketPath}`);
@@ -7744,6 +6997,20 @@ async function startPeerInbox(options) {
   };
 }
 __name(startPeerInbox, "startPeerInbox");
+function tokenMatches(expected, presented) {
+  const a = Buffer.from(expected);
+  const b = Buffer.from(presented);
+  return a.length === b.length && timingSafeEqual(a, b);
+}
+__name(tokenMatches, "tokenMatches");
+function authKindOf(options, presented) {
+  const peer = options.requiredToken !== void 0 && tokenMatches(options.requiredToken, presented);
+  const child = options.childToken !== void 0 && tokenMatches(options.childToken, presented);
+  if (peer) return "peer";
+  if (child) return "child";
+  return void 0;
+}
+__name(authKindOf, "authKindOf");
 function describe(error) {
   return error instanceof Error ? `${error.name}: ${error.message}` : String(error);
 }
@@ -8359,8 +7626,8 @@ __name(serializeChannelMemoryDocument, "serializeChannelMemoryDocument");
 init_esbuild_shims();
 var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
 import { createHash as createHash4, randomBytes } from "node:crypto";
-import * as fs5 from "node:fs/promises";
-import * as path7 from "node:path";
+import * as fs4 from "node:fs/promises";
+import * as path6 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;
@@ -8400,11 +7667,11 @@ async function releaseLock(release) {
 __name(releaseLock, "releaseLock");
 async function cleanupLegacyAfterCommit(legacyPath, expectedBytes) {
   try {
-    const currentBytes = await fs5.readFile(legacyPath);
+    const currentBytes = await fs4.readFile(legacyPath);
     if (legacyHash(currentBytes) !== legacyHash(expectedBytes) || !currentBytes.equals(expectedBytes)) {
       return;
     }
-    await fs5.unlink(legacyPath);
+    await fs4.unlink(legacyPath);
   } catch {
   }
 }
@@ -8420,7 +7687,7 @@ function hashedThreadPath(target) {
 }
 __name(hashedThreadPath, "hashedThreadPath");
 function getChannelMemoryDirectory(target) {
-  return path7.join(
+  return path6.join(
     Storage.getGlobalQwenDir(),
     "channels",
     "memory",
@@ -8430,11 +7697,11 @@ function getChannelMemoryDirectory(target) {
 }
 __name(getChannelMemoryDirectory, "getChannelMemoryDirectory");
 function getChannelMemoryFilePath(target) {
-  return path7.join(getChannelMemoryDirectory(target), CHANNEL_MEMORY_FILE_NAME);
+  return path6.join(getChannelMemoryDirectory(target), CHANNEL_MEMORY_FILE_NAME);
 }
 __name(getChannelMemoryFilePath, "getChannelMemoryFilePath");
 function getLegacyChannelMemoryFilePath(target) {
-  return path7.join(
+  return path6.join(
     getChannelMemoryDirectory(target),
     LEGACY_CHANNEL_MEMORY_FILE_NAME
   );
@@ -8444,8 +7711,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((resolve5) => {
+    resolveCurrent = resolve5;
   });
   const queued = previous.then(
     () => current,
@@ -8466,7 +7733,7 @@ async function serializeMutation(directory, task) {
 __name(serializeMutation, "serializeMutation");
 async function readFileIfExists(filePath) {
   try {
-    return await fs5.readFile(filePath);
+    return await fs4.readFile(filePath);
   } catch (error) {
     if (isMissingFile(error)) {
       return void 0;
@@ -8532,18 +7799,18 @@ async function writeChannelMemory(filePath, serialized) {
   const tempPath = `${filePath}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
   let committed = false;
   try {
-    const handle = await fs5.open(tempPath, "wx", 384);
+    const handle = await fs4.open(tempPath, "wx", 384);
     try {
       await handle.writeFile(serialized, "utf8");
       await handle.sync();
     } finally {
       await handle.close();
     }
-    await fs5.rename(tempPath, filePath);
+    await fs4.rename(tempPath, filePath);
     committed = true;
   } finally {
     if (!committed) {
-      await fs5.unlink(tempPath).catch((error) => {
+      await fs4.unlink(tempPath).catch((error) => {
         if (!isMissingFile(error)) {
           throw error;
         }
@@ -8554,12 +7821,12 @@ async function writeChannelMemory(filePath, serialized) {
 __name(writeChannelMemory, "writeChannelMemory");
 async function mutateChannelMemory(target, apply) {
   const filePath = getChannelMemoryFilePath(target);
-  const directory = path7.dirname(filePath);
+  const directory = path6.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 fs4.mkdir(directory, { recursive: true });
+    const lockPath = path6.join(directory, ".channel-memory.lock");
+    const lockHandle = await fs4.open(lockPath, "a", 384);
     await lockHandle.close();
     const release = await import_proper_lockfile.default.lock(lockPath, LOCK_OPTIONS);
     let releaseLegacy;
@@ -8598,7 +7865,7 @@ async function listChannelMemoryEntries(target) {
 __name(listChannelMemoryEntries, "listChannelMemoryEntries");
 async function getFileRevision(filePath) {
   try {
-    const stats = await fs5.stat(filePath, { bigint: true });
+    const stats = await fs4.stat(filePath, { bigint: true });
     return [
       stats.dev,
       stats.ino,
@@ -8938,8 +8205,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 fs5 } from "node:fs";
+import * as path7 from "node:path";
 var fileLocks = /* @__PURE__ */ new Map();
 var FILE_LOCK_TIMEOUT_MS = 3e4;
 function getFileLock(filePath) {
@@ -8967,7 +8234,7 @@ var WorkspaceMemoryWriteTimeoutError = class extends Error {
   }
 };
 async function writeWorkspaceContextFile(options) {
-  if (!path8.isAbsolute(options.projectRoot)) {
+  if (!path7.isAbsolute(options.projectRoot)) {
     throw new Error(
       `writeWorkspaceContextFile: projectRoot must be absolute, got "${options.projectRoot}"`
     );
@@ -8993,10 +8260,10 @@ async function runWrite(filePath, options) {
     return { filePath, bytesWritten: 0, changed: false };
   }
   options.assertCanCommit?.();
-  await fs6.mkdir(path8.dirname(filePath), { recursive: true });
+  await fs5.mkdir(path7.dirname(filePath), { recursive: true });
   if (options.mode === "replace") {
     options.assertCanCommit?.();
-    await fs6.writeFile(filePath, options.content, {
+    await fs5.writeFile(filePath, options.content, {
       encoding: "utf8",
       mode: 420
     });
@@ -9008,7 +8275,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 fs5.writeFile(filePath, next, { encoding: "utf8", mode: 420 });
   return {
     filePath,
     bytesWritten: Buffer.byteLength(next, "utf8"),
@@ -9019,9 +8286,9 @@ __name(runWrite, "runWrite");
 function resolveContextFilePath(scope, projectRoot) {
   const filename = getCurrentMemoryFilename();
   if (scope === "workspace") {
-    return path8.join(projectRoot, filename);
+    return path7.join(projectRoot, filename);
   }
-  return path8.join(Storage.getGlobalQwenDir(), filename);
+  return path7.join(Storage.getGlobalQwenDir(), filename);
 }
 __name(resolveContextFilePath, "resolveContextFilePath");
 var MAX_EXISTING_FILE_BYTES = 16 * 1024 * 1024;
@@ -9045,15 +8312,15 @@ var WorkspaceMemoryFileTooLargeError = class extends Error {
 async function composeAppendedContent(filePath, newContent) {
   let existing = "";
   try {
-    const stat5 = await fs6.stat(filePath);
-    if (stat5.size > MAX_EXISTING_FILE_BYTES) {
+    const stat4 = await fs5.stat(filePath);
+    if (stat4.size > MAX_EXISTING_FILE_BYTES) {
       throw new WorkspaceMemoryFileTooLargeError(
         filePath,
-        stat5.size,
+        stat4.size,
         MAX_EXISTING_FILE_BYTES
       );
     }
-    existing = await fs6.readFile(filePath, "utf8");
+    existing = await fs5.readFile(filePath, "utf8");
   } catch (err) {
     if (err instanceof WorkspaceMemoryFileTooLargeError) throw err;
     if (!isEnoent(err)) throw err;
@@ -9132,8 +8399,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 path8 from "node:path";
+import * as fs6 from "node:fs";
 import * as os from "node:os";
 function getVsCodeCommand(platform2 = process2.platform) {
   return platform2 === "win32" ? "code.cmd" : "code";
@@ -9161,23 +8428,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")
+      path8.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")
+      path8.join(homeDir, ".local/share/code/bin/code")
     );
   } else if (platform2 === "win32") {
     locations.push(
-      path9.join(
+      path8.join(
         process2.env["ProgramFiles"] || "C:\\Program Files",
         "Microsoft VS Code",
         "bin",
         "code.cmd"
       ),
-      path9.join(
+      path8.join(
         homeDir,
         "AppData",
         "Local",
@@ -9189,7 +8456,7 @@ async function findVsCodeCommand(platform2 = process2.platform) {
     );
   }
   for (const location of locations) {
-    if (fs7.existsSync(location)) {
+    if (fs6.existsSync(location)) {
       return location;
     }
   }
@@ -9356,8 +8623,8 @@ __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 fs7 from "node:fs";
+import * as path9 from "path";
 import { pathToFileURL } from "url";
 var debugLogger13 = createDebugLogger("LSP");
 var MAX_TCP_PORT = 65535;
@@ -9373,12 +8640,12 @@ 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 = path9.join(this.workspaceRoot, ".lsp.json");
+    if (!fs7.existsSync(lspConfigPath)) {
       return [];
     }
     try {
-      const configContent = fs8.readFileSync(lspConfigPath, "utf-8");
+      const configContent = fs7.readFileSync(lspConfigPath, "utf-8");
       const data = JSON.parse(configContent);
       return this.parseConfigSource(data, lspConfigPath, {
         forceTrustRequired: true
@@ -9389,9 +8656,9 @@ var LspConfigLoader = class {
     }
   }
   async loadUserConfigsStrict() {
-    const lspConfigPath = path10.join(this.workspaceRoot, ".lsp.json");
+    const lspConfigPath = path9.join(this.workspaceRoot, ".lsp.json");
     try {
-      const configContent = fs8.readFileSync(lspConfigPath, "utf-8");
+      const configContent = fs7.readFileSync(lspConfigPath, "utf-8");
       const data = JSON.parse(configContent);
       return this.parseUserConfigSourceStrict(data, lspConfigPath);
     } catch (error) {
@@ -9420,14 +8687,14 @@ var LspConfigLoader = class {
           extension.path,
           lspServers
         );
-        if (!fs8.existsSync(configPath)) {
+        if (!fs7.existsSync(configPath)) {
           debugLogger13.warn(
             `LSP config not found for ${originBase}: ${configPath}`
           );
           continue;
         }
         try {
-          const configContent = fs8.readFileSync(configPath, "utf-8");
+          const configContent = fs7.readFileSync(configPath, "utf-8");
           const data = JSON.parse(configContent);
           const hydrated = this.hydrateExtensionLspConfig(data, extension.path);
           configs.push(
@@ -9557,15 +8824,15 @@ var LspConfigLoader = class {
     return { ok: true, configs };
   }
   resolveExtensionConfigPath(extensionPath, configPath) {
-    return path10.isAbsolute(configPath) ? path10.resolve(configPath) : path10.resolve(extensionPath, configPath);
+    return path9.isAbsolute(configPath) ? path9.resolve(configPath) : path9.resolve(extensionPath, configPath);
   }
   hydrateExtensionLspConfig(source, extensionPath) {
     return recursivelyHydrateStrings(source, {
       extensionPath,
       CLAUDE_PLUGIN_ROOT: extensionPath,
       workspacePath: this.workspaceRoot,
-      "/": path10.sep,
-      pathSeparator: path10.sep
+      "/": path9.sep,
+      pathSeparator: path9.sep
     });
   }
   buildServerConfig(name, languages, spec, origin, options = {}) {
@@ -9732,9 +8999,9 @@ 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 = path9.isAbsolute(value) ? path9.resolve(value) : path9.resolve(this.workspaceRoot, value);
+    const root = path9.resolve(this.workspaceRoot);
+    if (resolved === root || resolved.startsWith(root + path9.sep)) {
       return resolved;
     }
     debugLogger13.warn(
@@ -9828,12 +9095,12 @@ var JsonRpcConnection = class {
       method,
       params
     };
-    const requestPromise = new Promise((resolve6, reject) => {
+    const requestPromise = new Promise((resolve5, 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: resolve5, reject, timer });
     });
     this.writeMessage(payload);
     return requestPromise;
@@ -9961,7 +9228,7 @@ var LspConnectionFactory = class _LspConnectionFactory {
    * 创建基于 stdio 的 LSP 连接
    */
   static async createStdioConnection(command, args, options, timeoutMs = 1e4) {
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve5, reject) => {
       const spawnOptions = {
         stdio: "pipe",
         ...options
@@ -10020,7 +9287,7 @@ var LspConnectionFactory = class _LspConnectionFactory {
           recordProcessExit(code, signal);
           connection.end();
         });
-        resolve6({
+        resolve5({
           connection,
           process: processInstance,
           processDiagnostics
@@ -10041,7 +9308,7 @@ var LspConnectionFactory = class _LspConnectionFactory {
    * 创建基于 socket 的 LSP 连接（支持 TCP 或 unix socket）
    */
   static async createSocketConnection(options, timeoutMs = 1e4) {
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve5, reject) => {
       let socketOptions;
       if (options.path) {
         socketOptions = { path: options.path };
@@ -10075,7 +9342,7 @@ var LspConnectionFactory = class _LspConnectionFactory {
         connection.listen(socket);
         socket.once("close", () => connection.end());
         socket.once("error", () => connection.end());
-        resolve6({
+        resolve5({
           connection,
           socket
         });
@@ -10765,8 +10032,8 @@ ${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 fs8 from "node:fs";
+import * as path10 from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 var debugLogger15 = createDebugLogger("LSP");
 var SECURITY_SENSITIVE_ENV_KEYS = /* @__PURE__ */ new Set([
@@ -10982,7 +10249,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 = fs8.readFileSync(tsFile, "utf-8");
       handle.connection.send({
         jsonrpc: "2.0",
         method: "textDocument/didOpen",
@@ -10996,7 +10263,7 @@ var LspServerManager = class {
         }
       });
       await new Promise(
-        (resolve6) => setTimeout(resolve6, DEFAULT_LSP_WARMUP_DELAY_MS)
+        (resolve5) => setTimeout(resolve5, DEFAULT_LSP_WARMUP_DELAY_MS)
       );
       handle.warmedUp = true;
       return uri;
@@ -11215,8 +10482,8 @@ var LspServerManager = class {
       try {
         await Promise.race([
           shutdownPromise,
-          new Promise((resolve6) => {
-            timerId = setTimeout(resolve6, timeout);
+          new Promise((resolve5) => {
+            timerId = setTimeout(resolve5, timeout);
             if (typeof timerId === "object" && timerId !== null && "unref" in timerId) {
               timerId.unref();
             }
@@ -11419,11 +10686,11 @@ var LspServerManager = class {
   }
   async delayWithAbort(delayMs, signal) {
     if (!signal) {
-      await new Promise((resolve6) => setTimeout(resolve6, delayMs));
+      await new Promise((resolve5) => setTimeout(resolve5, delayMs));
       return;
     }
     this.throwIfStartupAborted(signal);
-    await new Promise((resolve6, reject) => {
+    await new Promise((resolve5, reject) => {
       const onAbort = /* @__PURE__ */ __name(() => {
         clearTimeout(timerId);
         signal.removeEventListener("abort", onAbort);
@@ -11431,7 +10698,7 @@ var LspServerManager = class {
       }, "onAbort");
       const timerId = setTimeout(() => {
         signal.removeEventListener("abort", onAbort);
-        resolve6();
+        resolve5();
       }, delayMs);
       signal.addEventListener("abort", onAbort, { once: true });
     });
@@ -11600,7 +10867,7 @@ var LspServerManager = class {
    */
   async waitForSocketProcessSpawn(process3, signal) {
     this.throwIfStartupAborted(signal);
-    await new Promise((resolve6, reject) => {
+    await new Promise((resolve5, reject) => {
       let settled = false;
       const cleanup = /* @__PURE__ */ __name(() => {
         process3.off("spawn", onSpawn);
@@ -11615,7 +10882,7 @@ var LspServerManager = class {
         cleanup();
         complete();
       }, "settle");
-      const onSpawn = /* @__PURE__ */ __name(() => settle(resolve6), "onSpawn");
+      const onSpawn = /* @__PURE__ */ __name(() => settle(resolve5), "onSpawn");
       const onError = /* @__PURE__ */ __name((error) => settle(
         () => reject(new Error(`Failed to spawn LSP server: ${error.message}`))
       ), "onError");
@@ -11669,7 +10936,7 @@ var LspServerManager = class {
   async initializeLspServer(connection, config) {
     const workspaceFolderPath = config.workspaceFolder ?? this.workspaceRoot;
     const workspaceFolder = {
-      name: path11.basename(workspaceFolderPath) || workspaceFolderPath,
+      name: path10.basename(workspaceFolderPath) || workspaceFolderPath,
       uri: config.rootUri
     };
     const initializeParams = {
@@ -11731,7 +10998,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((resolve5) => {
       let settled = false;
       const settle = /* @__PURE__ */ __name((value) => {
         if (settled) {
@@ -11739,7 +11006,7 @@ var LspServerManager = class {
         }
         settled = true;
         clearTimeout(timerId);
-        resolve6(value);
+        resolve5(value);
       }, "settle");
       const child = spawn2(command, ["--version"], {
         stdio: ["ignore", "ignore", "ignore"],
@@ -11774,16 +11041,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(path10.sep) && !command.includes("/")) {
       return true;
     }
-    if (path11.isAbsolute(command)) {
+    if (path10.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 = path10.resolve(workspacePath);
+    const basePath = cwd ? path10.resolve(cwd) : resolvedWorkspacePath;
+    const resolvedPath = path10.resolve(basePath, command);
+    return resolvedPath.startsWith(resolvedWorkspacePath + path10.sep) || resolvedPath === resolvedWorkspacePath;
   }
   /**
    * Check whether the workspace trust level allows starting an LSP server.
@@ -12043,9 +11310,9 @@ var NativeLspClient = class {
 
 // packages/core/src/lsp/NativeLspService.ts
 init_esbuild_shims();
-import * as path12 from "path";
+import * as path11 from "path";
 import { fileURLToPath, pathToFileURL as pathToFileURL3 } from "url";
-import * as fs10 from "node:fs";
+import * as fs9 from "node:fs";
 import { promises as fsp } from "node:fs";
 var debugLogger16 = createDebugLogger("LSP");
 var LANGUAGE_ID_TO_EXTENSIONS = {
@@ -12418,7 +11685,7 @@ var NativeLspService = class {
     }
     let text;
     try {
-      text = fs10.readFileSync(filePath, "utf-8");
+      text = fs9.readFileSync(filePath, "utf-8");
     } catch (error) {
       debugLogger16.warn(
         `Failed to read file for LSP didOpen: ${filePath}`,
@@ -12458,7 +11725,7 @@ var NativeLspService = class {
     this.openedDocuments.set(serverName, openedForServer);
   }
   resolveLanguageId(filePath, handle) {
-    const ext = path12.extname(filePath).slice(1).toLowerCase();
+    const ext = path11.extname(filePath).slice(1).toLowerCase();
     if (ext && handle.config.extensionToLanguage) {
       const mapping = handle.config.extensionToLanguage;
       return mapping[ext] ?? mapping["." + ext];
@@ -12586,11 +11853,11 @@ var NativeLspService = class {
   }
   async delay(ms, signal) {
     if (!signal) {
-      await new Promise((resolve6) => setTimeout(resolve6, ms));
+      await new Promise((resolve5) => setTimeout(resolve5, ms));
       return;
     }
     this.throwIfReinitializeAborted(signal);
-    await new Promise((resolve6, reject) => {
+    await new Promise((resolve5, reject) => {
       const onAbort = /* @__PURE__ */ __name(() => {
         clearTimeout(timer);
         signal.removeEventListener("abort", onAbort);
@@ -12598,7 +11865,7 @@ var NativeLspService = class {
       }, "onAbort");
       const timer = setTimeout(() => {
         signal.removeEventListener("abort", onAbort);
-        resolve6();
+        resolve5();
       }, ms);
       signal.addEventListener("abort", onAbort, { once: true });
     });
@@ -13211,8 +12478,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 (!path11.isAbsolute(filePath)) {
+      filePath = path11.resolve(this.workspaceRoot, filePath);
     }
     if (!this.workspaceContext.isPathWithinWorkspace(filePath)) {
       throw new Error(`Refusing to apply edits outside workspace: ${filePath}`);
@@ -13247,7 +12514,7 @@ var NativeLspService = class {
       lines.splice(startLine, endLine - startLine + 1, ...newLines);
     }
     try {
-      await fsp.access(filePath, fs10.constants.W_OK);
+      await fsp.access(filePath, fs9.constants.W_OK);
     } catch (err) {
       if (err?.code !== "ENOENT") {
         throw err;
@@ -13713,7 +12980,7 @@ __name(getFilterReason, "getFilterReason");
 init_esbuild_shims();
 import { mkdir as mkdir3, copyFile, rm } from "node:fs/promises";
 import { existsSync as existsSync3 } from "node:fs";
-import { join as join8, dirname as dirname4, relative, isAbsolute as isAbsolute5 } from "node:path";
+import { join as join7, dirname as dirname4, relative, isAbsolute as isAbsolute5 } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 var OverlayFs = class {
@@ -13721,7 +12988,7 @@ var OverlayFs = class {
   constructor(realCwd) {
     this.realCwd = realCwd;
     const id = randomUUID().slice(0, 8);
-    this.overlayDir = join8(
+    this.overlayDir = join7(
       tmpdir(),
       "qwen-speculation",
       String(process.pid),
@@ -13760,9 +13027,9 @@ var OverlayFs = class {
     if (this.writtenFiles.has(rel)) {
       return this.writtenFiles.get(rel);
     }
-    const overlayPath = join8(this.overlayDir, rel);
+    const overlayPath = join7(this.overlayDir, rel);
     await mkdir3(dirname4(overlayPath), { recursive: true });
-    const originalPath = join8(this.realCwd, rel);
+    const originalPath = join7(this.realCwd, rel);
     if (existsSync3(originalPath)) {
       try {
         await copyFile(originalPath, overlayPath);
@@ -13785,7 +13052,7 @@ var OverlayFs = class {
   async applyToReal() {
     const applied = [];
     for (const [rel, overlayPath] of this.writtenFiles) {
-      const realPath = join8(this.realCwd, rel);
+      const realPath = join7(this.realCwd, rel);
       try {
         await mkdir3(dirname4(realPath), { recursive: true });
         await copyFile(overlayPath, realPath);
@@ -13809,7 +13076,7 @@ var OverlayFs = class {
    * Returns null if the path is outside cwd.
    */
   toRelative(inputPath) {
-    const abs = isAbsolute5(inputPath) ? inputPath : join8(this.realCwd, inputPath);
+    const abs = isAbsolute5(inputPath) ? inputPath : join7(this.realCwd, inputPath);
     const rel = relative(this.realCwd, abs);
     if (isAbsolute5(rel) || rel.startsWith("..")) {
       return null;
@@ -14384,20 +13651,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 path15 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 fs10 from "node:fs";
+import path12 from "node:path";
 var hasFileExtension = (0, import_picomatch.default)("**/*[*.]*");
 var debugLogger19 = createDebugLogger("FILE_SEARCH_IGNORE");
 function loadIgnoreRules(options) {
   const ignorer = new Ignore();
   if (options.useGitignore) {
-    const gitignorePath = path13.join(options.projectRoot, ".gitignore");
+    const gitignorePath = path12.join(options.projectRoot, ".gitignore");
     const gitignoreContent = readIgnoreFile(gitignorePath);
     if (gitignoreContent !== void 0) {
       ignorer.add(gitignoreContent);
@@ -14407,7 +13674,7 @@ function loadIgnoreRules(options) {
     for (const ignoreFileName of getQwenIgnoreFileNames(
       options.customIgnoreFiles
     )) {
-      const qwenignorePath = path13.join(options.projectRoot, ignoreFileName);
+      const qwenignorePath = path12.join(options.projectRoot, ignoreFileName);
       const qwenignoreContent = readIgnoreFile(qwenignorePath);
       if (qwenignoreContent !== void 0) {
         ignorer.addSource(qwenignoreContent);
@@ -14428,7 +13695,7 @@ function loadIgnoreRules(options) {
 __name(loadIgnoreRules, "loadIgnoreRules");
 function readIgnoreFile(filePath) {
   try {
-    return fs11.readFileSync(filePath, "utf8");
+    return fs10.readFileSync(filePath, "utf8");
   } catch (_error) {
     const error = _error;
     if (error.code !== "ENOENT") {
@@ -14581,8 +13848,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 path13 from "node:path";
+import fs11 from "node:fs";
 import { spawn as spawn3 } from "node:child_process";
 
 // packages/core/src/utils/filesearch/crawlCache.ts
@@ -14667,7 +13934,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(path13.sep).join(path13.posix.sep);
 }
 __name(toPosixPath, "toPosixPath");
 function normalizeGitPath(p, stripTrailingSlash = false) {
@@ -14763,7 +14030,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(path13.sep) && t.length > 32) {
       return "<path>";
     }
     return t;
@@ -14794,7 +14061,7 @@ function withSafeGitConfig(args) {
 }
 __name(withSafeGitConfig, "withSafeGitConfig");
 function canonicalStatePath(p) {
-  return toPosixPath(path14.resolve(p));
+  return toPosixPath(path13.resolve(p));
 }
 __name(canonicalStatePath, "canonicalStatePath");
 function getStateKey(options) {
@@ -14831,7 +14098,7 @@ function evictChangeStateIfNeeded() {
   }
 }
 __name(evictChangeStateIfNeeded, "evictChangeStateIfNeeded");
-function resolveGitDir2(crawlDirectory) {
+function resolveGitDir(crawlDirectory) {
   const cacheKey = canonicalStatePath(crawlDirectory);
   const cached = pathCacheGet(resolveGitDirCache, cacheKey);
   if (cached !== void 0) {
@@ -14839,28 +14106,28 @@ function resolveGitDir2(crawlDirectory) {
   }
   let current = crawlDirectory;
   while (current) {
-    const gitPath = path14.join(current, ".git");
+    const gitPath = path13.join(current, ".git");
     try {
-      const stat5 = fs12.statSync(gitPath);
-      if (stat5.isDirectory()) {
+      const stat4 = fs11.statSync(gitPath);
+      if (stat4.isDirectory()) {
         pathCacheSet(resolveGitDirCache, cacheKey, gitPath);
         return gitPath;
       }
-      if (stat5.isFile()) {
-        const contents = fs12.readFileSync(gitPath, "utf8").trim();
+      if (stat4.isFile()) {
+        const contents = fs11.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 = path13.isAbsolute(resolvedGitDir) ? path13.resolve(resolvedGitDir) : path13.resolve(current, resolvedGitDir);
         try {
-          resolvedAbs = fs12.realpathSync(resolvedAbs);
+          resolvedAbs = fs11.realpathSync(resolvedAbs);
           try {
-            fs12.statSync(path14.join(resolvedAbs, "HEAD"));
+            fs11.statSync(path13.join(resolvedAbs, "HEAD"));
           } catch {
-            fs12.statSync(path14.join(resolvedAbs, "index"));
+            fs11.statSync(path13.join(resolvedAbs, "index"));
           }
         } catch {
           pathCacheSet(resolveGitDirCache, cacheKey, null);
@@ -14876,7 +14143,7 @@ function resolveGitDir2(crawlDirectory) {
         return null;
       }
     }
-    const parent = path14.dirname(current);
+    const parent = path13.dirname(current);
     if (parent === current) {
       break;
     }
@@ -14885,15 +14152,15 @@ function resolveGitDir2(crawlDirectory) {
   pathCacheSet(resolveGitDirCache, cacheKey, null);
   return null;
 }
-__name(resolveGitDir2, "resolveGitDir");
+__name(resolveGitDir, "resolveGitDir");
 function getGitRootMtime(crawlDirectory) {
   try {
-    const gitDir = resolveGitDir2(crawlDirectory);
+    const gitDir = resolveGitDir(crawlDirectory);
     if (!gitDir) {
       return null;
     }
-    const indexPath = path14.join(gitDir, "index");
-    const indexStat = fs12.statSync(indexPath);
+    const indexPath = path13.join(gitDir, "index");
+    const indexStat = fs11.statSync(indexPath);
     return indexStat.mtimeMs;
   } catch {
   }
@@ -14949,7 +14216,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((resolve5) => {
     const lines = [];
     let settled = false;
     let timedOut = false;
@@ -14961,7 +14228,7 @@ function runCommand(command, args, cwd, timeoutMs = 2e4, options) {
         return;
       }
       settled = true;
-      resolve6({ success, lines: resultLines });
+      resolve5({ success, lines: resultLines });
     }, "finalize");
     let stderrBuf = "";
     let child;
@@ -15129,19 +14396,19 @@ function normalizePath(p) {
 }
 __name(normalizePath, "normalizePath");
 function getPosixRelative(from, to) {
-  const fromResolved = path14.resolve(from);
-  const toResolved = path14.resolve(to);
+  const fromResolved = path13.resolve(from);
+  const toResolved = path13.resolve(to);
   let fromAbs = fromResolved;
   let toAbs = toResolved;
   try {
-    fromAbs = fs12.realpathSync(fromResolved);
+    fromAbs = fs11.realpathSync(fromResolved);
   } catch {
   }
   try {
-    toAbs = fs12.realpathSync(toResolved);
+    toAbs = fs11.realpathSync(toResolved);
   } catch {
   }
-  const relative2 = path14.relative(fromAbs, toAbs);
+  const relative2 = path13.relative(fromAbs, toAbs);
   const posixRel = toPosixPath(relative2);
   return posixRel === "" ? "." : posixRel;
 }
@@ -15150,18 +14417,18 @@ function isValidIgnorePath(relativePath) {
   if (!relativePath || relativePath === ".") {
     return false;
   }
-  if (path14.posix.isAbsolute(relativePath)) {
+  if (path13.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 = path13.resolve(crawlDirectory);
+  const absoluteCandidate = path13.isAbsolute(dirPath) ? dirPath : path13.join(base, dirPath);
+  let rel = path13.relative(base, absoluteCandidate);
   rel = toPosixPath(rel);
-  if (!rel || rel.startsWith("..") || path14.posix.isAbsolute(rel)) {
+  if (!rel || rel.startsWith("..") || path13.posix.isAbsolute(rel)) {
     return null;
   }
   return isValidIgnorePath(rel) ? rel : null;
@@ -15251,11 +14518,11 @@ __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((resolve5) => setImmediate(resolve5));
   }
 }
 __name(maybeYield, "maybeYield");
-async function findGitRoot2(dir) {
+async function findGitRoot(dir) {
   const result = await commandRunner(
     "git",
     withSafeGitConfig(["rev-parse", "--show-toplevel"]),
@@ -15266,7 +14533,7 @@ async function findGitRoot2(dir) {
   if (!result.success || result.lines.length === 0) return null;
   return normalizePath(result.lines[0]);
 }
-__name(findGitRoot2, "findGitRoot");
+__name(findGitRoot, "findGitRoot");
 function shouldIncludeFile(filePath, dirFilter, fileFilter) {
   if (!isValidIgnorePath(filePath)) {
     return false;
@@ -15338,7 +14605,7 @@ async function scanWorkingTreeForChange(state, crawlDirectory, useGitignore) {
   if (state.gitRootMtimeMs === null && state.untrackedFingerprint === null && state.deletedFingerprint === null) {
     return { changed: false };
   }
-  const gitRoot = await findGitRoot2(crawlDirectory);
+  const gitRoot = await findGitRoot(crawlDirectory);
   if (state.untrackedFingerprint === null && state.deletedFingerprint === null) {
     return gitRoot ? { changed: true } : { changed: false };
   }
@@ -15368,16 +14635,16 @@ function posixPathUnderGitRoot(normalizedFile, relativeToGitRoot, relativeToCraw
   if (relativeToGitRoot && relativeToGitRoot !== ".") {
     const rest = sliceAfterGitPathspecPrefix(nf, normGitRoot);
     if (rest !== null) {
-      return path14.posix.join(normCrawlDir, rest);
+      return path13.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 path13.posix.join(normCrawlDir, nfFile);
   }
-  return path14.posix.join(normCrawlDir, nf.replace(/\/+$/, ""));
+  return path13.posix.join(normCrawlDir, nf.replace(/\/+$/, ""));
 }
 __name(posixPathUnderGitRoot, "posixPathUnderGitRoot");
 async function crawlWithGitLsFiles(stateKey, crawlDirectory, cwd, options, workingTreePrefetch) {
@@ -15389,7 +14656,7 @@ async function crawlWithGitLsFiles(stateKey, crawlDirectory, cwd, options, worki
     untrackedFiles = workingTreePrefetch.untrackedFiles;
     deletedFiles = workingTreePrefetch.deletedFiles;
   } else {
-    gitRoot = await findGitRoot2(crawlDirectory);
+    gitRoot = await findGitRoot(crawlDirectory);
     if (!gitRoot) {
       return { success: false, files: [], gitRepoListingFailed: false };
     }
@@ -15454,13 +14721,13 @@ async function crawlWithGitLsFiles(stateKey, crawlDirectory, cwd, options, worki
     if (deletedSet.has(normalizedFile)) {
       return true;
     }
-    let stat5;
+    let stat4;
     try {
-      stat5 = fs12.lstatSync(path14.join(gitRoot, ...normalizedFile.split("/")));
+      stat4 = fs11.lstatSync(path13.join(gitRoot, ...normalizedFile.split("/")));
     } catch {
       return true;
     }
-    if (stat5.isDirectory()) {
+    if (stat4.isDirectory()) {
       return true;
     }
     if (relativeToGitRoot && relativeToGitRoot !== "." && normalizedFile === relativeToGitRoot) {
@@ -15558,7 +14825,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 : path13.posix.join(relativeToCrawlDir, relativePath);
     if (cwdRelative !== ".") {
       const row = cwdRelative.endsWith("/") ? cwdRelative : `${cwdRelative}/`;
       if (!isValidIgnorePath(row.slice(0, -1)) || dirFilter(row)) {
@@ -15571,7 +14838,7 @@ function collectDirectoryRows(options) {
     }
     let entries;
     try {
-      entries = fs12.readdirSync(dir, { withFileTypes: true });
+      entries = fs11.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -15579,8 +14846,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 ? path13.posix.join(relativePath, entry.name) : entry.name;
+      visit(path13.join(dir, entry.name), childRelative, depth + 1);
     }
   }, "visit");
   visit(options.crawlDirectory, "", 0);
@@ -15618,7 +14885,7 @@ async function crawlWithRipgrep(stateKey, crawlDirectory, cwd, options) {
       return false;
     }
     const normalizedFile = normalizePath(file);
-    const fullPath = path14.posix.join(relativeToCrawlDir, normalizedFile);
+    const fullPath = path13.posix.join(relativeToCrawlDir, normalizedFile);
     if (!shouldIncludeFile(fullPath, dirFilter, fileFilter)) {
       return true;
     }
@@ -15677,7 +14944,7 @@ async function crawlWithFdir(options) {
       return dirFilter(`${relativePath}/`);
     }).filter((filePath, isDirectory) => {
       if (isDirectory) return true;
-      const cwdRelative = path14.posix.join(relativeToCrawlDir, filePath);
+      const cwdRelative = path13.posix.join(relativeToCrawlDir, filePath);
       if (!isValidIgnorePath(cwdRelative)) {
         return false;
       }
@@ -15690,7 +14957,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) => path13.posix.join(relativeToCrawlDir, p));
   if (relativeToCrawlDir !== ".") {
     const rootDir = relativeToCrawlDir.endsWith("/") ? relativeToCrawlDir : `${relativeToCrawlDir}/`;
     if (!mapped.includes(rootDir)) {
@@ -15817,8 +15084,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 fs12 from "node:fs";
+import path14 from "node:path";
 import { Worker } from "node:worker_threads";
 
 // node_modules/fzf/dist/fzf.es.js
@@ -16685,7 +15952,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((resolve5, reject) => {
     const INCREMENT = 1e3;
     let i = 0, end = Math.min(INCREMENT, len);
     const step = /* @__PURE__ */ __name(() => {
@@ -16698,7 +15965,7 @@ function asyncMatcher(token, len, iter2, onFinish) {
         end = Math.min(end + INCREMENT, len);
         isNode ? setImmediate(step) : setTimeout(step);
       } else {
-        resolve6(onFinish());
+        resolve5(onFinish());
       }
     }, "step");
     step();
@@ -16753,6 +16020,22 @@ var syncDefaultOpts = {
   ...defaultOpts,
   match: basicMatch
 };
+var SyncFinder = class extends BaseFinder {
+  static {
+    __name(this, "SyncFinder");
+  }
+  constructor(list, ...optionsTuple) {
+    super(list, ...optionsTuple);
+    this.opts = { ...syncDefaultOpts, ...optionsTuple[0] };
+  }
+  find(query) {
+    if (query.length === 0 || this.items.length === 0)
+      return this.items.slice(0, this.opts.limit).map(createResultItemWithEmptyPos);
+    query = query.normalize();
+    let result = this.opts.match.bind(this)(query);
+    return postProcessResultItems(result, this.opts);
+  }
+};
 var asyncDefaultOpts = {
   ...defaultOpts,
   match: asyncBasicMatch
@@ -16804,6 +16087,15 @@ function postProcessResultItems(result, opts) {
   return result;
 }
 __name(postProcessResultItems, "postProcessResultItems");
+var Fzf = class {
+  static {
+    __name(this, "Fzf");
+  }
+  constructor(list, ...optionsTuple) {
+    this.finder = new SyncFinder(list, ...optionsTuple);
+    this.find = this.finder.find.bind(this.finder);
+  }
+};
 var AsyncFzf = class {
   static {
     __name(this, "AsyncFzf");
@@ -16845,11 +16137,11 @@ var inProcessTransport = {
 var resolvedWorkerPath;
 function getWorkerScriptPath() {
   if (resolvedWorkerPath !== void 0) return resolvedWorkerPath;
-  const candidate = path15.join(
+  const candidate = path14.join(
     resolveBundleDir(import.meta.url),
     "fzfWorker.js"
   );
-  resolvedWorkerPath = fs13.existsSync(candidate) ? candidate : null;
+  resolvedWorkerPath = fs12.existsSync(candidate) ? candidate : null;
   return resolvedWorkerPath;
 }
 __name(getWorkerScriptPath, "getWorkerScriptPath");
@@ -16945,12 +16237,12 @@ var workerTransport = {
         }
         await readyPromise;
         const reqId = nextReqId++;
-        return new Promise((resolve6, reject) => {
+        return new Promise((resolve5, 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: resolve5, reject });
           try {
             worker.postMessage({ type: "find", reqId, pattern, limit });
           } catch (err) {
@@ -17045,7 +16337,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((resolve5) => setImmediate(resolve5));
       if (signal?.aborted) {
         throw new AbortError();
       }
@@ -17124,7 +16416,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((resolve5) => setImmediate(resolve5));
         if (options.signal?.aborted) {
           throw new AbortError();
         }
@@ -17166,9 +16458,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 : path15.dirname(pattern);
+    const crawlDirectory = path15.join(this.options.projectRoot, dir);
+    const listingProjectRoot = path15.resolve(crawlDirectory) === path15.resolve(this.options.projectRoot);
     const results = await crawl({
       crawlDirectory,
       cwd: this.options.projectRoot,
@@ -17249,13 +16541,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 fs13 } from "node:fs";
+import path16 from "node:path";
 async function readPathFromWorkspace(pathStr, config) {
   const workspace = config.getWorkspaceContext();
   const fileService = config.getFileService();
   let absolutePath = null;
-  if (path17.isAbsolute(pathStr)) {
+  if (path16.isAbsolute(pathStr)) {
     if (!workspace.isPathWithinWorkspace(pathStr)) {
       throw new Error(
         `Absolute path is outside of the allowed workspace: ${pathStr}`
@@ -17265,9 +16557,9 @@ async function readPathFromWorkspace(pathStr, config) {
   } else {
     const searchDirs = workspace.getDirectories();
     for (const dir of searchDirs) {
-      const potentialPath = path17.resolve(dir, pathStr);
+      const potentialPath = path16.resolve(dir, pathStr);
       try {
-        await fs14.access(potentialPath);
+        await fs13.access(potentialPath);
         absolutePath = potentialPath;
         break;
       } catch {
@@ -17277,7 +16569,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 fs13.stat(absolutePath);
   if (stats.isDirectory()) {
     const allParts = [];
     allParts.push({
@@ -17293,7 +16585,7 @@ async function readPathFromWorkspace(pathStr, config) {
       absolute: true
     });
     const relativeFiles = files.map(
-      (p) => path17.relative(config.getTargetDir(), p)
+      (p) => path16.relative(config.getTargetDir(), p)
     );
     const filteringOptions = config.getFileFilteringOptions();
     const filteredFiles = fileService.filterFiles(relativeFiles, {
@@ -17301,10 +16593,10 @@ async function readPathFromWorkspace(pathStr, config) {
       respectQwenIgnore: filteringOptions.respectQwenIgnore
     });
     const finalFiles = filteredFiles.map(
-      (p) => path17.resolve(config.getTargetDir(), p)
+      (p) => path16.resolve(config.getTargetDir(), p)
     );
     for (const filePath of finalFiles) {
-      const relativePathForDisplay = path17.relative(absolutePath, filePath);
+      const relativePathForDisplay = path16.relative(absolutePath, filePath);
       allParts.push({ text: `--- ${relativePathForDisplay} ---
 ` });
       const result = await processSingleFileContent(filePath, config, {
@@ -17320,7 +16612,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 = path16.relative(config.getTargetDir(), absolutePath);
     const singleFileFilteringOptions = config.getFileFilteringOptions();
     const filtered = fileService.filterFiles([relativePath], {
       respectGitIgnore: singleFileFilteringOptions.respectGitIgnore,
@@ -17339,25 +16631,25 @@ __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 fs14 from "fs/promises";
+import * as path17 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 path17.join(process.cwd(), ".qwen", PROJECT_SUMMARY_FILENAME);
 }
 __name(getProjectSummaryPath, "getProjectSummaryPath");
 function getWelcomeBackStatePath() {
-  return path18.join(process.cwd(), ".qwen", WELCOME_BACK_STATE_FILENAME);
+  return path17.join(process.cwd(), ".qwen", WELCOME_BACK_STATE_FILENAME);
 }
 __name(getWelcomeBackStatePath, "getWelcomeBackStatePath");
-function buildSummaryFingerprint(stat5) {
-  return `${stat5.mtimeMs}:${stat5.size}`;
+function buildSummaryFingerprint(stat4) {
+  return `${stat4.mtimeMs}:${stat4.size}`;
 }
 __name(buildSummaryFingerprint, "buildSummaryFingerprint");
 async function getWelcomeBackState() {
   try {
-    const raw = await fs15.readFile(getWelcomeBackStatePath(), "utf-8");
+    const raw = await fs14.readFile(getWelcomeBackStatePath(), "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.version !== 1 || parsed.lastChoice !== "restart" || typeof parsed.summaryFingerprint !== "string") {
       return null;
@@ -17373,7 +16665,7 @@ async function getWelcomeBackState() {
 __name(getWelcomeBackState, "getWelcomeBackState");
 async function saveWelcomeBackRestartChoice(summaryFingerprint) {
   const statePath = getWelcomeBackStatePath();
-  await fs15.mkdir(path18.dirname(statePath), { recursive: true });
+  await fs14.mkdir(path17.dirname(statePath), { recursive: true });
   const state = {
     version: 1,
     lastChoice: "restart",
@@ -17386,7 +16678,7 @@ async function saveWelcomeBackRestartChoice(summaryFingerprint) {
 __name(saveWelcomeBackRestartChoice, "saveWelcomeBackRestartChoice");
 async function clearWelcomeBackState() {
   try {
-    await fs15.rm(getWelcomeBackStatePath(), { force: true });
+    await fs14.rm(getWelcomeBackStatePath(), { force: true });
   } catch {
   }
 }
@@ -17394,15 +16686,15 @@ __name(clearWelcomeBackState, "clearWelcomeBackState");
 async function getProjectSummaryInfo() {
   const summaryPath = getProjectSummaryPath();
   try {
-    await fs15.access(summaryPath);
+    await fs14.access(summaryPath);
   } catch {
     return {
       hasHistory: false
     };
   }
   try {
-    const summaryStat = await fs15.stat(summaryPath);
-    const content = await fs15.readFile(summaryPath, "utf-8");
+    const summaryStat = await fs14.stat(summaryPath);
+    const content = await fs14.readFile(summaryPath, "utf-8");
     const summaryFingerprint = buildSummaryFingerprint(summaryStat);
     const timestampMatch = content.match(/\*\*Update time\*\*: (.+)/);
     const timestamp = timestampMatch ? timestampMatch[1] : (/* @__PURE__ */ new Date()).toISOString();
@@ -17470,9 +16762,9 @@ __name(getProjectSummaryInfo, "getProjectSummaryInfo");
 
 // packages/core/src/tools/readManyFiles.ts
 init_esbuild_shims();
-import * as fs16 from "node:fs";
+import * as fs15 from "node:fs";
 import * as os2 from "node:os";
-import * as path19 from "node:path";
+import * as path18 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;
@@ -17492,7 +16784,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 = path18.resolve(projectRoot, normalizedPattern);
       const displayPath = displayPaths?.get(fullPath) ?? fullPath;
       const validatedIdentity = validatedPathIdentities?.get(fullPath);
       if (validatedPathIdentities && !validatedIdentity) continue;
@@ -17511,7 +16803,7 @@ async function readManyFiles(config, options) {
       if (validatedIdentity && !await matchesValidatedPathIdentity(fullPath, validatedIdentity)) {
         continue;
       }
-      const stats = fs16.existsSync(fullPath) ? fs16.statSync(fullPath) : null;
+      const stats = fs15.existsSync(fullPath) ? fs15.statSync(fullPath) : null;
       if (stats?.isDirectory()) {
         const { contentParts: dirParts, info } = await readDirectory(
           config,
@@ -17631,9 +16923,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 fs15.promises.realpath(filePath);
     if (canonicalPath !== filePath) return false;
-    const stats = await fs16.promises.stat(canonicalPath);
+    const stats = await fs15.promises.stat(canonicalPath);
     return statsMatchValidatedIdentity(stats, expected);
   } catch {
     return false;
@@ -17662,13 +16954,13 @@ async function snapshotValidatedFile(filePath, expected, signal) {
       if (stats.size > SNAPSHOT_MAX_SIZE_BYTES) {
         return void 0;
       }
-      snapshotDir = await fs16.promises.mkdtemp(
-        path19.join(os2.tmpdir(), "qwen-validated-read-")
+      snapshotDir = await fs15.promises.mkdtemp(
+        path18.join(os2.tmpdir(), "qwen-validated-read-")
       );
-      const snapshotPath = path19.join(snapshotDir, path19.basename(filePath));
-      const target = await fs16.promises.open(
+      const snapshotPath = path18.join(snapshotDir, path18.basename(filePath));
+      const target = await fs15.promises.open(
         snapshotPath,
-        fs16.constants.O_WRONLY | fs16.constants.O_CREAT | fs16.constants.O_EXCL,
+        fs15.constants.O_WRONLY | fs15.constants.O_CREAT | fs15.constants.O_EXCL,
         384
       );
       try {
@@ -17709,7 +17001,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(() => fs15.promises.rm(snapshotDir, { recursive: true, force: true }), "cleanup")
       };
       return result;
     } finally {
@@ -17721,7 +17013,7 @@ async function snapshotValidatedFile(filePath, expected, signal) {
     return void 0;
   } finally {
     if (snapshotDir && !result) {
-      await fs16.promises.rm(snapshotDir, { recursive: true, force: true });
+      await fs15.promises.rm(snapshotDir, { recursive: true, force: true });
     }
   }
 }
@@ -17943,23 +17235,9 @@ export {
   acceptSpeculation,
   abortSpeculation,
   loadIgnoreRules,
+  Fzf,
   AsyncFzf,
   FileSearchFactory,
-  isValidRefName,
-  resolveBranchName,
-  watchRepoBranch,
-  gitEnv,
-  fetchGitBranches,
-  isValidCheckoutRef,
-  gitCheckout,
-  gitCreateBranch,
-  gitPush,
-  gitPull,
-  gitCommit,
-  GITHUB_PR_ERROR_MESSAGE_MAX,
-  fetchGitHubPullRequests,
-  createGitHubPullRequest,
-  getDefaultBranch,
   analyzeToolResultRetention,
   readPathFromWorkspace,
   getWelcomeBackState,