@qwen-code/qwen-code 0.24.5-preview.0 → 0.24.5

package/chunks/{chunk-3JSIWFNA.js → chunk-XHHUGXYW.js}

@@ -69,19 +69,23 @@ import {
   recursivelyHydrateStrings,
   repairOrphanedToolUseTurns,
   runForkedAgent,
+  runGit,
+  runGitCapture,
   runWithForkedChatModel,
   runWithTimeout,
   sigtermPids,
+  streamGitRecords,
   stripToolResultImages,
   toolResultBoundaryArtifact,
   toolResultPartDiagnosticValues
-} from "./chunk-RL2HSTEB.js";
+} from "./chunk-SYZPPX3O.js";
 import {
   shellResultText
 } from "./chunk-4M7RD5QQ.js";
 import {
   hasVerifiableInode,
-  openNoFollow
+  openNoFollow,
+  openSyncNoFollow
 } from "./chunk-HEOH7JZY.js";
 import {
   projectUserTranscriptForDisplay
@@ -95,7 +99,7 @@ import {
 import {
   getProjectSkillsRoot,
   parse
-} from "./chunk-TFBQ5CKI.js";
+} from "./chunk-QNEBHC2E.js";
 import {
   glob,
   globSync
@@ -121,22 +125,21 @@ import {
 } from "./chunk-VNTJJ4WQ.js";
 import {
   require_picomatch
-} from "./chunk-47C3HPMW.js";
+} from "./chunk-O5YL6KSX.js";
 import {
   BUILT_IN_OUTPUT_STYLES,
   getBuiltInOutputStyle
-} from "./chunk-JE3J5HFM.js";
+} from "./chunk-KAOHUUM7.js";
 import {
-  DEFAULT_IMAGE_TOKEN_ESTIMATE,
-  estimatePartChars
-} from "./chunk-GC3J5W2O.js";
+  NO_EXEC_CONFIG
+} from "./chunk-P6OZD6V2.js";
 import {
   fetchWithPolicy
 } from "./chunk-Z27N2QYZ.js";
 import {
   getModelsForProviderProtocol,
   tryResolveModelProtocol
-} from "./chunk-OU4ZCLGJ.js";
+} from "./chunk-242INZ6Y.js";
 import {
   COMBINED_PASS_TOLERANCE_FACTOR,
   TOOL_OUTPUT_TRUNCATED_PREFIX,
@@ -144,7 +147,7 @@ import {
   addMCPStatusChangeListener,
   removeMCPStatusChangeListener,
   updateMCPServerStatus
-} from "./chunk-MZRJ2JJS.js";
+} from "./chunk-HDSI3RDN.js";
 import {
   E_TIMEOUT,
   Mutex,
@@ -159,7 +162,7 @@ import {
   isCacheableReadResult,
   isWithinRoot,
   processSingleFileContent
-} from "./chunk-NNN2PKPV.js";
+} from "./chunk-PYYPSK6Q.js";
 import {
   getAutoMemoryRoot,
   getUserAutoMemoryRoot
@@ -170,6 +173,10 @@ import {
 import {
   getInvocationContext
 } from "./chunk-5ETULJLP.js";
+import {
+  DEFAULT_IMAGE_TOKEN_ESTIMATE,
+  estimatePartChars
+} from "./chunk-GC3J5W2O.js";
 import {
   getFolderStructure,
   getStartupContextLength,
@@ -1685,7 +1692,7 @@ var McpTransportPool = class {
         spawnWait.then(() => {
           if (inflightTimer) clearTimeout(inflightTimer);
         }),
-        new Promise((resolve8) => {
+        new Promise((resolve9) => {
           inflightTimer = setTimeout(
             () => {
               const stuckIds = [...this.spawnInFlight.keys()];
@@ -1694,7 +1701,7 @@ var McpTransportPool = class {
                   ", "
                 )}. Proceeding with drain.`
               );
-              resolve8();
+              resolve9();
             },
             Math.max(0, deadline - Date.now())
           );
@@ -1720,8 +1727,8 @@ var McpTransportPool = class {
       Promise.all(shutdownPromises).then(() => {
         if (drainTimer) clearTimeout(drainTimer);
       }),
-      new Promise((resolve8) => {
-        drainTimer = setTimeout(() => resolve8(), remaining);
+      new Promise((resolve9) => {
+        drainTimer = setTimeout(() => resolve9(), remaining);
         drainTimer.unref?.();
       })
     ]);
@@ -3089,11 +3096,11 @@ async function bindAt(requestedPath, options, automaticPath) {
   server.on("error", (error) => {
     debugLogger6.error(`peer inbox server error: ${describe(error)}`);
   });
-  const listenAt = /* @__PURE__ */ __name((target) => new Promise((resolve8, reject) => {
+  const listenAt = /* @__PURE__ */ __name((target) => new Promise((resolve9, reject) => {
     server.once("error", reject);
     server.listen(target, () => {
       server.removeListener("error", reject);
-      resolve8();
+      resolve9();
     });
   }), "listenAt");
   try {
@@ -3153,7 +3160,7 @@ async function bindAt(requestedPath, options, automaticPath) {
         closed = true;
         for (const socket of connections) socket.destroy();
         connections.clear();
-        await new Promise((resolve8) => server.close(() => resolve8()));
+        await new Promise((resolve9) => server.close(() => resolve9()));
         try {
           await fs.unlink(socketPath);
         } catch {
@@ -4761,9 +4768,9 @@ function encodeInsightProgressMessage(stage, progress, detail) {
   return JSON.stringify(payload);
 }
 __name(encodeInsightProgressMessage, "encodeInsightProgressMessage");
-function encodeInsightReadyMessage(path21) {
+function encodeInsightReadyMessage(path22) {
   const payload = {
-    insight_ready: { path: path21 }
+    insight_ready: { path: path22 }
   };
   return JSON.stringify(payload);
 }
@@ -5295,9 +5302,9 @@ var Logger = class {
       );
       return;
     }
-    const path21 = this._checkpointPath(tag);
+    const path22 = this._checkpointPath(tag);
     try {
-      await atomicWriteFile(path21, JSON.stringify(conversation, null, 2), {
+      await atomicWriteFile(path22, JSON.stringify(conversation, null, 2), {
         encoding: "utf-8"
       });
     } catch (error) {
@@ -5311,13 +5318,13 @@ var Logger = class {
       );
       return [];
     }
-    const path21 = await this._getCheckpointPath(tag);
+    const path22 = await this._getCheckpointPath(tag);
     try {
-      const fileContent = await fs3.readFile(path21, "utf-8");
+      const fileContent = await fs3.readFile(path22, "utf-8");
       const parsedContent = JSON.parse(fileContent);
       if (!Array.isArray(parsedContent)) {
         this.debugLogger.warn(
-          `Checkpoint file at ${path21} is not a valid JSON array. Returning empty checkpoint.`
+          `Checkpoint file at ${path22} is not a valid JSON array. Returning empty checkpoint.`
         );
         return [];
       }
@@ -5328,7 +5335,7 @@ var Logger = class {
         return [];
       }
       this.debugLogger.error(
-        `Failed to read or parse checkpoint file ${path21}:`,
+        `Failed to read or parse checkpoint file ${path22}:`,
         error
       );
       return [];
@@ -5802,7 +5809,7 @@ var ClientMcpRegistrar = class {
       }
       return Promise.resolve(ack);
     }
-    return new Promise((resolve8, reject) => {
+    return new Promise((resolve9, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id);
         reject(
@@ -5812,7 +5819,7 @@ var ClientMcpRegistrar = class {
         );
       }, this.messageTimeoutMs);
       timer.unref?.();
-      this.pending.set(id, { resolve: resolve8, reject, timer, server: serverName });
+      this.pending.set(id, { resolve: resolve9, reject, timer, server: serverName });
       let sendResult;
       try {
         sendResult = this.sendFrame({
@@ -6536,8 +6543,8 @@ var DropReceiptCoalescer = class {
       if (batch.pending > 0) waiting.push(batch);
     }
     let overdue = false;
-    const deadline = new Promise((resolve8) => {
-      const timer = setTimeout(resolve8, boundMs);
+    const deadline = new Promise((resolve9) => {
+      const timer = setTimeout(resolve9, boundMs);
       timer.unref?.();
     });
     void deadline.then(() => {
@@ -7609,8 +7616,8 @@ async function serializeMutation(directory, task) {
   const previous = pendingMutations.get(directory) ?? Promise.resolve();
   let resolveCurrent = /* @__PURE__ */ __name(() => {
   }, "resolveCurrent");
-  const current = new Promise((resolve8) => {
-    resolveCurrent = resolve8;
+  const current = new Promise((resolve9) => {
+    resolveCurrent = resolve9;
   });
   const queued = previous.then(
     () => current,
@@ -8998,12 +9005,12 @@ var JsonRpcConnection = class {
       method,
       params
     };
-    const requestPromise = new Promise((resolve8, reject) => {
+    const requestPromise = new Promise((resolve9, 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: resolve8, reject, timer });
+      this.pendingRequests.set(id, { resolve: resolve9, reject, timer });
     });
     this.writeMessage(payload);
     return requestPromise;
@@ -9131,7 +9138,7 @@ var LspConnectionFactory = class _LspConnectionFactory {
    * 创建基于 stdio 的 LSP 连接
    */
   static async createStdioConnection(command, args, options, timeoutMs = 1e4) {
-    return new Promise((resolve8, reject) => {
+    return new Promise((resolve9, reject) => {
       const spawnOptions = {
         stdio: "pipe",
         ...options
@@ -9190,7 +9197,7 @@ var LspConnectionFactory = class _LspConnectionFactory {
           recordProcessExit(code, signal);
           connection.end();
         });
-        resolve8({
+        resolve9({
           connection,
           process: processInstance,
           processDiagnostics
@@ -9211,7 +9218,7 @@ var LspConnectionFactory = class _LspConnectionFactory {
    * 创建基于 socket 的 LSP 连接（支持 TCP 或 unix socket）
    */
   static async createSocketConnection(options, timeoutMs = 1e4) {
-    return new Promise((resolve8, reject) => {
+    return new Promise((resolve9, reject) => {
       let socketOptions;
       if (options.path) {
         socketOptions = { path: options.path };
@@ -9245,7 +9252,7 @@ var LspConnectionFactory = class _LspConnectionFactory {
         connection.listen(socket);
         socket.once("close", () => connection.end());
         socket.once("error", () => connection.end());
-        resolve8({
+        resolve9({
           connection,
           socket
         });
@@ -10176,7 +10183,7 @@ var LspServerManager = class {
         return;
       }
       await new Promise(
-        (resolve8) => setTimeout(resolve8, DEFAULT_LSP_WARMUP_DELAY_MS)
+        (resolve9) => setTimeout(resolve9, DEFAULT_LSP_WARMUP_DELAY_MS)
       );
       if (handle.connection === connection) handle.warmedUp = true;
     } catch (error) {
@@ -10395,8 +10402,8 @@ var LspServerManager = class {
       try {
         await Promise.race([
           shutdownPromise,
-          new Promise((resolve8) => {
-            timerId = setTimeout(resolve8, timeout);
+          new Promise((resolve9) => {
+            timerId = setTimeout(resolve9, timeout);
             if (typeof timerId === "object" && timerId !== null && "unref" in timerId) {
               timerId.unref();
             }
@@ -10599,11 +10606,11 @@ var LspServerManager = class {
   }
   async delayWithAbort(delayMs, signal) {
     if (!signal) {
-      await new Promise((resolve8) => setTimeout(resolve8, delayMs));
+      await new Promise((resolve9) => setTimeout(resolve9, delayMs));
       return;
     }
     this.throwIfStartupAborted(signal);
-    await new Promise((resolve8, reject) => {
+    await new Promise((resolve9, reject) => {
       const onAbort = /* @__PURE__ */ __name(() => {
         clearTimeout(timerId);
         signal.removeEventListener("abort", onAbort);
@@ -10611,7 +10618,7 @@ var LspServerManager = class {
       }, "onAbort");
       const timerId = setTimeout(() => {
         signal.removeEventListener("abort", onAbort);
-        resolve8();
+        resolve9();
       }, delayMs);
       signal.addEventListener("abort", onAbort, { once: true });
     });
@@ -10780,7 +10787,7 @@ var LspServerManager = class {
    */
   async waitForSocketProcessSpawn(process3, signal) {
     this.throwIfStartupAborted(signal);
-    await new Promise((resolve8, reject) => {
+    await new Promise((resolve9, reject) => {
       let settled = false;
       const cleanup = /* @__PURE__ */ __name(() => {
         process3.off("spawn", onSpawn);
@@ -10795,7 +10802,7 @@ var LspServerManager = class {
         cleanup();
         complete();
       }, "settle");
-      const onSpawn = /* @__PURE__ */ __name(() => settle(resolve8), "onSpawn");
+      const onSpawn = /* @__PURE__ */ __name(() => settle(resolve9), "onSpawn");
       const onError = /* @__PURE__ */ __name((error) => settle(
         () => reject(new Error(`Failed to spawn LSP server: ${error.message}`))
       ), "onError");
@@ -10912,7 +10919,7 @@ var LspServerManager = class {
    * @returns true if the command can be spawned, false if not found
    */
   async commandExists(command, env2, cwd) {
-    return new Promise((resolve8) => {
+    return new Promise((resolve9) => {
       let settled = false;
       const settle = /* @__PURE__ */ __name((value) => {
         if (settled) {
@@ -10920,7 +10927,7 @@ var LspServerManager = class {
         }
         settled = true;
         clearTimeout(timerId);
-        resolve8(value);
+        resolve9(value);
       }, "settle");
       const child = spawn2(command, ["--version"], {
         stdio: ["ignore", "ignore", "ignore"],
@@ -11918,11 +11925,11 @@ var NativeLspService = class {
   }
   async delay(ms, signal) {
     if (!signal) {
-      await new Promise((resolve8) => setTimeout(resolve8, ms));
+      await new Promise((resolve9) => setTimeout(resolve9, ms));
       return;
     }
     this.throwIfReinitializeAborted(signal);
-    await new Promise((resolve8, reject) => {
+    await new Promise((resolve9, reject) => {
       const onAbort = /* @__PURE__ */ __name(() => {
         clearTimeout(timer);
         signal.removeEventListener("abort", onAbort);
@@ -11930,7 +11937,7 @@ var NativeLspService = class {
       }, "onAbort");
       const timer = setTimeout(() => {
         signal.removeEventListener("abort", onAbort);
-        resolve8();
+        resolve9();
       }, ms);
       signal.addEventListener("abort", onAbort, { once: true });
     });
@@ -14122,30 +14129,30 @@ import { createRequire } from "module";
 import { basename as basename5, dirname as dirname7, normalize, relative as relative2, resolve as resolve6, sep as sep5 } from "path";
 import * as nativeFs from "fs";
 var __require2 = /* @__PURE__ */ createRequire(import.meta.url);
-function cleanPath(path21) {
-  let normalized2 = normalize(path21);
+function cleanPath(path22) {
+  let normalized2 = normalize(path22);
   if (normalized2.length > 1 && normalized2[normalized2.length - 1] === sep5) normalized2 = normalized2.substring(0, normalized2.length - 1);
   return normalized2;
 }
 __name(cleanPath, "cleanPath");
 var SLASHES_REGEX = /[\\/]/g;
-function convertSlashes(path21, separator) {
-  return path21.replace(SLASHES_REGEX, separator);
+function convertSlashes(path22, separator) {
+  return path22.replace(SLASHES_REGEX, separator);
 }
 __name(convertSlashes, "convertSlashes");
 var WINDOWS_ROOT_DIR_REGEX = /^[a-z]:[\\/]$/i;
-function isRootDirectory(path21) {
-  return path21 === "/" || WINDOWS_ROOT_DIR_REGEX.test(path21);
+function isRootDirectory(path22) {
+  return path22 === "/" || WINDOWS_ROOT_DIR_REGEX.test(path22);
 }
 __name(isRootDirectory, "isRootDirectory");
-function normalizePath(path21, options) {
+function normalizePath(path22, options) {
   const { resolvePaths, normalizePath: normalizePath$1, pathSeparator } = options;
-  const pathNeedsCleaning = process.platform === "win32" && path21.includes("/") || path21.startsWith(".");
-  if (resolvePaths) path21 = resolve6(path21);
-  if (normalizePath$1 || pathNeedsCleaning) path21 = cleanPath(path21);
-  if (path21 === ".") return "";
-  const needsSeperator = path21[path21.length - 1] !== pathSeparator;
-  return convertSlashes(needsSeperator ? path21 + pathSeparator : path21, pathSeparator);
+  const pathNeedsCleaning = process.platform === "win32" && path22.includes("/") || path22.startsWith(".");
+  if (resolvePaths) path22 = resolve6(path22);
+  if (normalizePath$1 || pathNeedsCleaning) path22 = cleanPath(path22);
+  if (path22 === ".") return "";
+  const needsSeperator = path22[path22.length - 1] !== pathSeparator;
+  return convertSlashes(needsSeperator ? path22 + pathSeparator : path22, pathSeparator);
 }
 __name(normalizePath, "normalizePath");
 function joinPathWithBasePath(filename, directoryPath) {
@@ -14190,8 +14197,8 @@ var pushDirectory = /* @__PURE__ */ __name((directoryPath, paths) => {
   paths.push(directoryPath || ".");
 }, "pushDirectory");
 var pushDirectoryFilter = /* @__PURE__ */ __name((directoryPath, paths, filters) => {
-  const path21 = directoryPath || ".";
-  if (filters.every((filter2) => filter2(path21, true))) paths.push(path21);
+  const path22 = directoryPath || ".";
+  if (filters.every((filter2) => filter2(path22, true))) paths.push(path22);
 }, "pushDirectoryFilter");
 var empty$2 = /* @__PURE__ */ __name(() => {
 }, "empty$2");
@@ -14247,26 +14254,26 @@ function build$3(options) {
   return options.group ? groupFiles : empty;
 }
 __name(build$3, "build$3");
-var resolveSymlinksAsync = /* @__PURE__ */ __name(function(path21, state, callback$1) {
-  const { queue, fs: fs17, options: { suppressErrors } } = state;
+var resolveSymlinksAsync = /* @__PURE__ */ __name(function(path22, state, callback$1) {
+  const { queue, fs: fs18, options: { suppressErrors } } = state;
   queue.enqueue();
-  fs17.realpath(path21, (error, resolvedPath) => {
+  fs18.realpath(path22, (error, resolvedPath) => {
     if (error) return queue.dequeue(suppressErrors ? null : error, state);
-    fs17.stat(resolvedPath, (error$1, stat5) => {
+    fs18.stat(resolvedPath, (error$1, stat5) => {
       if (error$1) return queue.dequeue(suppressErrors ? null : error$1, state);
-      if (stat5.isDirectory() && isRecursive(path21, resolvedPath, state)) return queue.dequeue(null, state);
+      if (stat5.isDirectory() && isRecursive(path22, resolvedPath, state)) return queue.dequeue(null, state);
       callback$1(stat5, resolvedPath);
       queue.dequeue(null, state);
     });
   });
 }, "resolveSymlinksAsync");
-var resolveSymlinks = /* @__PURE__ */ __name(function(path21, state, callback$1) {
-  const { queue, fs: fs17, options: { suppressErrors } } = state;
+var resolveSymlinks = /* @__PURE__ */ __name(function(path22, state, callback$1) {
+  const { queue, fs: fs18, options: { suppressErrors } } = state;
   queue.enqueue();
   try {
-    const resolvedPath = fs17.realpathSync(path21);
-    const stat5 = fs17.statSync(resolvedPath);
-    if (stat5.isDirectory() && isRecursive(path21, resolvedPath, state)) return;
+    const resolvedPath = fs18.realpathSync(path22);
+    const stat5 = fs18.statSync(resolvedPath);
+    if (stat5.isDirectory() && isRecursive(path22, resolvedPath, state)) return;
     callback$1(stat5, resolvedPath);
   } catch (e) {
     if (!suppressErrors) throw e;
@@ -14277,9 +14284,9 @@ function build$2(options, isSynchronous) {
   return isSynchronous ? resolveSymlinks : resolveSymlinksAsync;
 }
 __name(build$2, "build$2");
-function isRecursive(path21, resolved, state) {
+function isRecursive(path22, resolved, state) {
   if (state.options.useRealPaths) return isRecursiveUsingRealPaths(resolved, state);
-  let parent = dirname7(path21);
+  let parent = dirname7(path22);
   let depth = 1;
   while (parent !== state.root && depth < 2) {
     const resolvedPath = state.symlinks.get(parent);
@@ -14287,7 +14294,7 @@ function isRecursive(path21, resolved, state) {
     if (isSameRoot) depth++;
     else parent = dirname7(parent);
   }
-  state.symlinks.set(path21, resolved);
+  state.symlinks.set(path22, resolved);
   return depth > 1;
 }
 __name(isRecursive, "isRecursive");
@@ -14340,22 +14347,22 @@ var readdirOpts = { withFileTypes: true };
 var walkAsync = /* @__PURE__ */ __name((state, crawlPath, directoryPath, currentDepth, callback$1) => {
   state.queue.enqueue();
   if (currentDepth < 0) return state.queue.dequeue(null, state);
-  const { fs: fs17 } = state;
+  const { fs: fs18 } = state;
   state.visited.push(crawlPath);
   state.counts.directories++;
-  fs17.readdir(crawlPath || ".", readdirOpts, (error, entries = []) => {
+  fs18.readdir(crawlPath || ".", readdirOpts, (error, entries = []) => {
     callback$1(entries, directoryPath, currentDepth);
     state.queue.dequeue(state.options.suppressErrors ? null : error, state);
   });
 }, "walkAsync");
 var walkSync = /* @__PURE__ */ __name((state, crawlPath, directoryPath, currentDepth, callback$1) => {
-  const { fs: fs17 } = state;
+  const { fs: fs18 } = state;
   if (currentDepth < 0) return;
   state.visited.push(crawlPath);
   state.counts.directories++;
   let entries = [];
   try {
-    entries = fs17.readdirSync(crawlPath || ".", readdirOpts);
+    entries = fs18.readdirSync(crawlPath || ".", readdirOpts);
   } catch (e) {
     if (!state.options.suppressErrors) throw e;
   }
@@ -14476,19 +14483,19 @@ var Walker = class {
         const filename = this.joinPath(entry.name, directoryPath);
         this.pushFile(filename, files, this.state.counts, filters);
       } else if (entry.isDirectory()) {
-        let path21 = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
-        if (exclude && exclude(entry.name, path21)) continue;
-        this.pushDirectory(path21, paths, filters);
-        this.walkDirectory(this.state, path21, path21, depth - 1, this.walk);
+        let path22 = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
+        if (exclude && exclude(entry.name, path22)) continue;
+        this.pushDirectory(path22, paths, filters);
+        this.walkDirectory(this.state, path22, path22, depth - 1, this.walk);
       } else if (this.resolveSymlink && entry.isSymbolicLink()) {
-        let path21 = joinPathWithBasePath(entry.name, directoryPath);
-        this.resolveSymlink(path21, this.state, (stat5, resolvedPath) => {
+        let path22 = joinPathWithBasePath(entry.name, directoryPath);
+        this.resolveSymlink(path22, this.state, (stat5, resolvedPath) => {
           if (stat5.isDirectory()) {
             resolvedPath = normalizePath(resolvedPath, this.state.options);
-            if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path21 + pathSeparator)) return;
-            this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path21 + pathSeparator, depth - 1, this.walk);
+            if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path22 + pathSeparator)) return;
+            this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path22 + pathSeparator, depth - 1, this.walk);
           } else {
-            resolvedPath = useRealPaths ? resolvedPath : path21;
+            resolvedPath = useRealPaths ? resolvedPath : path22;
             const filename = basename5(resolvedPath);
             const directoryPath$1 = normalizePath(dirname7(resolvedPath), this.state.options);
             resolvedPath = this.joinPath(filename, directoryPath$1);
@@ -14663,7 +14670,7 @@ var Builder = class {
       isMatch = globFn(patterns, ...options);
       this.globCache[patterns.join("\0")] = isMatch;
     }
-    this.options.filters.push((path21) => isMatch(path21));
+    this.options.filters.push((path22) => isMatch(path22));
     return this;
   }
 };
@@ -15032,7 +15039,7 @@ function computeLinesFingerprint(lines) {
 __name(computeLinesFingerprint, "computeLinesFingerprint");
 function runCommand(command, args, cwd, timeoutMs = 2e4, options) {
   const collectLines = options?.collectLines !== false;
-  return new Promise((resolve8) => {
+  return new Promise((resolve9) => {
     const lines = [];
     let settled = false;
     let timedOut = false;
@@ -15044,7 +15051,7 @@ function runCommand(command, args, cwd, timeoutMs = 2e4, options) {
         return;
       }
       settled = true;
-      resolve8({ success, lines: resultLines });
+      resolve9({ success, lines: resultLines });
     }, "finalize");
     let stderrBuf = "";
     let child;
@@ -15334,7 +15341,7 @@ __name(isUnderIgnoredDirectory, "isUnderIgnoredDirectory");
 var YIELD_INTERVAL = 1e3;
 async function maybeYield(index) {
   if (index > 0 && index % YIELD_INTERVAL === 0) {
-    await new Promise((resolve8) => setImmediate(resolve8));
+    await new Promise((resolve9) => setImmediate(resolve9));
   }
 }
 __name(maybeYield, "maybeYield");
@@ -16768,7 +16775,7 @@ function basicMatch(query) {
 __name(basicMatch, "basicMatch");
 var isNode = typeof __require !== "undefined" && typeof window === "undefined";
 function asyncMatcher(token, len, iter2, onFinish) {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     const INCREMENT = 1e3;
     let i = 0, end = Math.min(INCREMENT, len);
     const step = /* @__PURE__ */ __name(() => {
@@ -16781,7 +16788,7 @@ function asyncMatcher(token, len, iter2, onFinish) {
         end = Math.min(end + INCREMENT, len);
         isNode ? setImmediate(step) : setTimeout(step);
       } else {
-        resolve8(onFinish());
+        resolve9(onFinish());
       }
     }, "step");
     step();
@@ -17053,12 +17060,12 @@ var workerTransport = {
         }
         await readyPromise;
         const reqId = nextReqId++;
-        return new Promise((resolve8, reject) => {
+        return new Promise((resolve9, reject) => {
           if (readyState === "disposed" || readyState === "failed") {
             reject(new Error(`fzf worker not available (${readyState})`));
             return;
           }
-          pending.set(reqId, { resolve: resolve8, reject });
+          pending.set(reqId, { resolve: resolve9, reject });
           try {
             worker.postMessage({ type: "find", reqId, pattern, limit });
           } catch (err) {
@@ -17153,7 +17160,7 @@ async function filter(allPaths, pattern, signal) {
   const results = [];
   for (const [i, p] of allPaths.entries()) {
     if (i % 1e3 === 0) {
-      await new Promise((resolve8) => setImmediate(resolve8));
+      await new Promise((resolve9) => setImmediate(resolve9));
       if (signal?.aborted) {
         throw new AbortError();
       }
@@ -17232,7 +17239,7 @@ var RecursiveFileSearch = class {
     const results = [];
     for (const [i, candidate] of filteredCandidates.entries()) {
       if (i % 1e3 === 0) {
-        await new Promise((resolve8) => setImmediate(resolve8));
+        await new Promise((resolve9) => setImmediate(resolve9));
         if (options.signal?.aborted) {
           throw new AbortError();
         }
@@ -17318,6 +17325,380 @@ var FileSearchFactory = class {
   }
 };
 
+// packages/core/src/utils/git-worktrees.ts
+init_esbuild_shims();
+import * as fs14 from "node:fs";
+import * as fsPromises from "node:fs/promises";
+import * as path18 from "node:path";
+function weightier(a, b) {
+  if (a === "present" || b === "present") return "present";
+  if (a === "unknown" || b === "unknown") return "unknown";
+  return "absent";
+}
+__name(weightier, "weightier");
+var NO_FOLLOW = fs14.constants.O_NOFOLLOW;
+var POINTER_OPEN_FLAGS = fs14.constants.O_RDONLY | (NO_FOLLOW ?? 0) | (fs14.constants.O_NONBLOCK ?? 0);
+function openPointer(file) {
+  return NO_FOLLOW === void 0 ? openNoFollow(file) : fsPromises.open(file, POINTER_OPEN_FLAGS);
+}
+__name(openPointer, "openPointer");
+function openPointerSync(file) {
+  return NO_FOLLOW === void 0 ? openSyncNoFollow(file) : fs14.openSync(file, POINTER_OPEN_FLAGS);
+}
+__name(openPointerSync, "openPointerSync");
+var GITDIR_POINTER_MAX_BYTES = 8192;
+function realpathOrSelf(target) {
+  try {
+    return fs14.realpathSync(target);
+  } catch {
+    return path18.resolve(target);
+  }
+}
+__name(realpathOrSelf, "realpathOrSelf");
+function realpathOnDiskOrSelf(target) {
+  try {
+    return fs14.realpathSync.native(target);
+  } catch {
+    return realpathOrSelf(target);
+  }
+}
+__name(realpathOnDiskOrSelf, "realpathOnDiskOrSelf");
+async function readGitdirPointer(adminEntryDir) {
+  const read2 = await readGitdirPointerAnswer(adminEntryDir);
+  return typeof read2 === "object" ? read2.at : null;
+}
+__name(readGitdirPointer, "readGitdirPointer");
+async function readGitdirPointerAnswer(adminEntryDir) {
+  let handle;
+  try {
+    handle = await openPointer(path18.join(adminEntryDir, "gitdir"));
+    const stat5 = await handle.stat();
+    if (!stat5.isFile() || stat5.size > GITDIR_POINTER_MAX_BYTES) {
+      return "unreadable";
+    }
+    const buffer = Buffer.alloc(stat5.size);
+    const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+    const raw = buffer.toString("utf8", 0, bytesRead).replace(/\s+$/, "");
+    if (!raw) return "missing";
+    return {
+      at: realpathOrSelf(
+        path18.dirname(path18.resolve(realpathOrSelf(adminEntryDir), raw))
+      )
+    };
+  } catch (err) {
+    return saysNothingIsThere(err) ? "missing" : "unreadable";
+  } finally {
+    await handle?.close().catch(() => {
+    });
+  }
+}
+__name(readGitdirPointerAnswer, "readGitdirPointerAnswer");
+function attribute(line, key) {
+  if (line === key) return "";
+  return line.startsWith(`${key} `) ? line.slice(key.length + 1) : void 0;
+}
+__name(attribute, "attribute");
+function parseGitWorktreeList(raw) {
+  const entries = [];
+  let current = null;
+  for (const line of raw.split("\0")) {
+    if (line === "") {
+      if (current) entries.push(current);
+      current = null;
+      continue;
+    }
+    const worktreePath = attribute(line, "worktree");
+    if (worktreePath !== void 0) {
+      current = {
+        path: worktreePath,
+        head: "",
+        branch: null,
+        detached: false,
+        bare: false,
+        isMain: entries.length === 0
+      };
+      continue;
+    }
+    if (!current) continue;
+    const head = attribute(line, "HEAD");
+    const branch = attribute(line, "branch");
+    const locked = attribute(line, "locked");
+    const prunable = attribute(line, "prunable");
+    if (head !== void 0) current.head = head;
+    else if (branch !== void 0)
+      current.branch = branch.replace(/^refs\/heads\//, "");
+    else if (line === "detached") current.detached = true;
+    else if (line === "bare") current.bare = true;
+    else if (locked !== void 0) current.locked = locked;
+    else if (prunable !== void 0) current.prunable = prunable;
+  }
+  if (current) entries.push(current);
+  return entries;
+}
+__name(parseGitWorktreeList, "parseGitWorktreeList");
+async function listGitWorktrees(cwd, env2) {
+  const raw = await runGit(
+    cwd,
+    [...NO_EXEC_CONFIG, "worktree", "list", "--porcelain", "-z"],
+    env2
+  );
+  return parseGitWorktreeList(raw);
+}
+__name(listGitWorktrees, "listGitWorktrees");
+async function removeGitWorktree(cwd, worktreePath, options = {}, env2) {
+  await runGit(
+    cwd,
+    [
+      ...NO_EXEC_CONFIG,
+      "worktree",
+      "remove",
+      ...options.force ? ["--force", "--force"] : [],
+      "--",
+      worktreePath
+    ],
+    env2
+  );
+}
+__name(removeGitWorktree, "removeGitWorktree");
+async function commitIsReachable(cwd, commit, env2) {
+  const out = await runGit(
+    cwd,
+    [
+      ...NO_EXEC_CONFIG,
+      "for-each-ref",
+      "--count=1",
+      "--contains",
+      commit,
+      "refs/heads",
+      "refs/remotes",
+      "refs/tags"
+    ],
+    env2
+  );
+  return out.trim().length > 0;
+}
+__name(commitIsReachable, "commitIsReachable");
+async function worktreeHoldsSubmodules(worktreePath, env2) {
+  let answer = "absent";
+  await streamGitRecords(
+    worktreePath,
+    [...NO_EXEC_CONFIG, "ls-files", "--stage", "-z"],
+    (record) => {
+      if (!record.subarray(0, GITLINK_MODE.length).equals(GITLINK_MODE)) {
+        return false;
+      }
+      const tab = record.indexOf(9);
+      if (tab === -1) return false;
+      const bytes = record.subarray(tab + 1);
+      const name = bytes.toString("utf8");
+      answer = Buffer.from(name, "utf8").equals(bytes) ? weightier(
+        answer,
+        pathHoldsRepository(path18.resolve(worktreePath, name))
+      ) : weightier(answer, "unknown");
+      return answer === "present";
+    },
+    env2
+  );
+  return answer;
+}
+__name(worktreeHoldsSubmodules, "worktreeHoldsSubmodules");
+var GITLINK_MODE = Buffer.from("160000 ");
+async function dryRunGitWorktreePrune(cwd, env2) {
+  const { stdout, stderr } = await runGitCapture(
+    cwd,
+    [...NO_EXEC_CONFIG, "worktree", "prune", "-n", "-v"],
+    env2
+  );
+  const report2 = `${stdout}
+${stderr}`;
+  const named = report2.split("\n").map((line) => /^Removing worktrees\/(.+): /.exec(line.trim())?.[1]).filter((id) => id !== void 0);
+  const announcements = report2.split("Removing worktrees/").length - 1;
+  while (named.length < announcements) named.push(null);
+  if (named.length === 0) return [];
+  const commonDir = (await runGit(cwd, [...NO_EXEC_CONFIG, "rev-parse", "--git-common-dir"], env2)).trim();
+  const admin = path18.resolve(cwd, commonDir, "worktrees");
+  const entries = [];
+  for (const id of named) {
+    if (id === null) {
+      entries.push({ id: null, worktreePath: null });
+      continue;
+    }
+    const entryPath = path18.join(admin, id);
+    if (isSymlink(entryPath)) {
+      entries.push({ id, worktreePath: null });
+      continue;
+    }
+    let dir;
+    try {
+      dir = fs14.statSync(entryPath);
+    } catch {
+      entries.push({ id, worktreePath: null });
+      continue;
+    }
+    if (!dir.isDirectory()) continue;
+    try {
+      if (fs14.readdirSync(path18.join(admin, id)).length === 0) continue;
+    } catch {
+    }
+    entries.push({
+      id,
+      worktreePath: await readGitdirPointer(path18.join(admin, id))
+    });
+  }
+  return entries;
+}
+__name(dryRunGitWorktreePrune, "dryRunGitWorktreePrune");
+function saysNothingIsThere(err) {
+  const code = err?.code;
+  return code === "ENOENT" || code === "ENOTDIR";
+}
+__name(saysNothingIsThere, "saysNothingIsThere");
+function isSymlink(target) {
+  try {
+    return fs14.lstatSync(target).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+__name(isSymlink, "isSymlink");
+function lookAt(target) {
+  try {
+    return fs14.statSync(target);
+  } catch (err) {
+    return saysNothingIsThere(err) ? "absent" : "unknown";
+  }
+}
+__name(lookAt, "lookAt");
+function adminEntryHoldsModules(adminEntryDir) {
+  const modules = path18.join(adminEntryDir, "modules");
+  const entry = lookAt(modules);
+  if (typeof entry === "string") return entry;
+  if (!entry.isDirectory()) return "absent";
+  try {
+    return fs14.readdirSync(modules).length > 0 ? "present" : "absent";
+  } catch {
+    return "unknown";
+  }
+}
+__name(adminEntryHoldsModules, "adminEntryHoldsModules");
+function pathHoldsRepository(at) {
+  const dot = lookAt(path18.join(at, ".git"));
+  if (typeof dot === "string") return dot;
+  if (dot.isDirectory()) {
+    const head = lookAt(path18.join(at, ".git", "HEAD"));
+    return typeof head === "string" ? head : "present";
+  }
+  return gitfileAnswer(at);
+}
+__name(pathHoldsRepository, "pathHoldsRepository");
+async function worktreeAdminHoldsModules(cwd, worktreePath, env2) {
+  const commonDir = (await runGit(cwd, [...NO_EXEC_CONFIG, "rev-parse", "--git-common-dir"], env2)).trim();
+  const admin = realpathOrSelf(path18.resolve(cwd, commonDir, "worktrees"));
+  const wanted = realpathOrSelf(worktreePath);
+  let ids;
+  try {
+    ids = fs14.readdirSync(admin);
+  } catch (err) {
+    return saysNothingIsThere(err) ? "absent" : "unknown";
+  }
+  let answer = "absent";
+  const found = [];
+  let doubt = false;
+  for (const id of ids) {
+    const back = await readGitdirPointerAnswer(path18.join(admin, id));
+    if (back === "missing") continue;
+    if (back === "unreadable") {
+      if (adminEntryHoldsModules(path18.join(admin, id)) !== "absent") {
+        doubt = true;
+      }
+      continue;
+    }
+    if (back.at !== wanted) continue;
+    found.push(realpathOrSelf(path18.join(admin, id)));
+    answer = weightier(answer, adminEntryHoldsModules(path18.join(admin, id)));
+    if (answer === "present") return answer;
+  }
+  if (!doubt) return answer;
+  const own = gitfileTarget(worktreePath);
+  return own !== null && found.includes(own) ? answer : weightier(answer, "unknown");
+}
+__name(worktreeAdminHoldsModules, "worktreeAdminHoldsModules");
+function gitfileTarget(worktreePath) {
+  let fd;
+  try {
+    fd = openPointerSync(path18.join(worktreePath, ".git"));
+    const stat5 = fs14.fstatSync(fd);
+    if (!stat5.isFile() || stat5.size > GITDIR_POINTER_MAX_BYTES) return null;
+    const buffer = Buffer.alloc(stat5.size);
+    const read2 = fs14.readSync(fd, buffer, 0, buffer.length, 0);
+    const raw = buffer.toString("utf8", 0, read2).replace(/\s+$/, "");
+    if (!raw.startsWith("gitdir: ")) return null;
+    return realpathOrSelf(
+      path18.resolve(realpathOrSelf(worktreePath), raw.slice("gitdir: ".length))
+    );
+  } catch {
+    return null;
+  } finally {
+    if (fd !== void 0) {
+      try {
+        fs14.closeSync(fd);
+      } catch {
+      }
+    }
+  }
+}
+__name(gitfileTarget, "gitfileTarget");
+function gitfileAnswer(at) {
+  let fd;
+  try {
+    fd = openPointerSync(path18.join(at, ".git"));
+    const stat5 = fs14.fstatSync(fd);
+    if (!stat5.isFile()) return "absent";
+    if (stat5.size > GITDIR_POINTER_MAX_BYTES) return "unknown";
+    const buffer = Buffer.alloc(stat5.size);
+    const read2 = fs14.readSync(fd, buffer, 0, buffer.length, 0);
+    return buffer.toString("utf8", 0, read2).startsWith("gitdir: ") ? "present" : "absent";
+  } catch (err) {
+    return saysNothingIsThere(err) ? "absent" : "unknown";
+  } finally {
+    if (fd !== void 0) {
+      try {
+        fs14.closeSync(fd);
+      } catch {
+      }
+    }
+  }
+}
+__name(gitfileAnswer, "gitfileAnswer");
+async function lockGitWorktree(cwd, worktreePath, reason, env2) {
+  await runGit(
+    cwd,
+    [
+      ...NO_EXEC_CONFIG,
+      "worktree",
+      "lock",
+      "--reason",
+      reason,
+      "--",
+      worktreePath
+    ],
+    env2
+  );
+}
+__name(lockGitWorktree, "lockGitWorktree");
+async function unlockGitWorktree(cwd, worktreePath, env2) {
+  await runGit(
+    cwd,
+    [...NO_EXEC_CONFIG, "worktree", "unlock", "--", worktreePath],
+    env2
+  );
+}
+__name(unlockGitWorktree, "unlockGitWorktree");
+async function pruneGitWorktrees(cwd, env2) {
+  await runGit(cwd, [...NO_EXEC_CONFIG, "worktree", "prune"], env2);
+}
+__name(pruneGitWorktrees, "pruneGitWorktrees");
+
 // packages/core/src/tools/tool-result-retention.ts
 init_esbuild_shims();
 var OVERSIZED_TOOL_RESULT_THRESHOLD_CHARS = 3e4;
@@ -17357,13 +17738,13 @@ __name(analyzeToolResultRetention, "analyzeToolResultRetention");
 
 // packages/core/src/utils/pathReader.ts
 init_esbuild_shims();
-import { promises as fs14 } from "node:fs";
-import path18 from "node:path";
+import { promises as fs15 } from "node:fs";
+import path19 from "node:path";
 async function readPathFromWorkspace(pathStr, config) {
   const workspace = config.getWorkspaceContext();
   const fileService = config.getFileService();
   let absolutePath = null;
-  if (path18.isAbsolute(pathStr)) {
+  if (path19.isAbsolute(pathStr)) {
     if (!workspace.isPathWithinWorkspace(pathStr)) {
       throw new Error(
         `Absolute path is outside of the allowed workspace: ${pathStr}`
@@ -17373,9 +17754,9 @@ async function readPathFromWorkspace(pathStr, config) {
   } else {
     const searchDirs = workspace.getDirectories();
     for (const dir of searchDirs) {
-      const potentialPath = path18.resolve(dir, pathStr);
+      const potentialPath = path19.resolve(dir, pathStr);
       try {
-        await fs14.access(potentialPath);
+        await fs15.access(potentialPath);
         absolutePath = potentialPath;
         break;
       } catch {
@@ -17385,7 +17766,7 @@ async function readPathFromWorkspace(pathStr, config) {
   if (!absolutePath) {
     throw new Error(`Path not found in workspace: ${pathStr}`);
   }
-  const stats = await fs14.stat(absolutePath);
+  const stats = await fs15.stat(absolutePath);
   if (stats.isDirectory()) {
     const allParts = [];
     allParts.push({
@@ -17401,7 +17782,7 @@ async function readPathFromWorkspace(pathStr, config) {
       absolute: true
     });
     const relativeFiles = files.map(
-      (p) => path18.relative(config.getTargetDir(), p)
+      (p) => path19.relative(config.getTargetDir(), p)
     );
     const filteringOptions = config.getFileFilteringOptions();
     const filteredFiles = fileService.filterFiles(relativeFiles, {
@@ -17409,10 +17790,10 @@ async function readPathFromWorkspace(pathStr, config) {
       respectQwenIgnore: filteringOptions.respectQwenIgnore
     });
     const finalFiles = filteredFiles.map(
-      (p) => path18.resolve(config.getTargetDir(), p)
+      (p) => path19.resolve(config.getTargetDir(), p)
     );
     for (const filePath of finalFiles) {
-      const relativePathForDisplay = path18.relative(absolutePath, filePath);
+      const relativePathForDisplay = path19.relative(absolutePath, filePath);
       allParts.push({ text: `--- ${relativePathForDisplay} ---
 ` });
       const result = await processSingleFileContent(filePath, config, {
@@ -17428,7 +17809,7 @@ async function readPathFromWorkspace(pathStr, config) {
     allParts.push({ text: `--- End of content for directory: ${pathStr} ---` });
     return allParts;
   } else {
-    const relativePath = path18.relative(config.getTargetDir(), absolutePath);
+    const relativePath = path19.relative(config.getTargetDir(), absolutePath);
     const singleFileFilteringOptions = config.getFileFilteringOptions();
     const filtered = fileService.filterFiles([relativePath], {
       respectGitIgnore: singleFileFilteringOptions.respectGitIgnore,
@@ -17447,16 +17828,16 @@ __name(readPathFromWorkspace, "readPathFromWorkspace");
 
 // packages/core/src/utils/projectSummary.ts
 init_esbuild_shims();
-import * as fs15 from "fs/promises";
-import * as path19 from "path";
+import * as fs16 from "fs/promises";
+import * as path20 from "path";
 var PROJECT_SUMMARY_FILENAME = "PROJECT_SUMMARY.md";
 var WELCOME_BACK_STATE_FILENAME = "welcome-back-state.json";
 function getProjectSummaryPath() {
-  return path19.join(process.cwd(), ".qwen", PROJECT_SUMMARY_FILENAME);
+  return path20.join(process.cwd(), ".qwen", PROJECT_SUMMARY_FILENAME);
 }
 __name(getProjectSummaryPath, "getProjectSummaryPath");
 function getWelcomeBackStatePath() {
-  return path19.join(process.cwd(), ".qwen", WELCOME_BACK_STATE_FILENAME);
+  return path20.join(process.cwd(), ".qwen", WELCOME_BACK_STATE_FILENAME);
 }
 __name(getWelcomeBackStatePath, "getWelcomeBackStatePath");
 function buildSummaryFingerprint(stat5) {
@@ -17465,7 +17846,7 @@ function buildSummaryFingerprint(stat5) {
 __name(buildSummaryFingerprint, "buildSummaryFingerprint");
 async function getWelcomeBackState() {
   try {
-    const raw = await fs15.readFile(getWelcomeBackStatePath(), "utf-8");
+    const raw = await fs16.readFile(getWelcomeBackStatePath(), "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.version !== 1 || parsed.lastChoice !== "restart" || typeof parsed.summaryFingerprint !== "string") {
       return null;
@@ -17481,7 +17862,7 @@ async function getWelcomeBackState() {
 __name(getWelcomeBackState, "getWelcomeBackState");
 async function saveWelcomeBackRestartChoice(summaryFingerprint) {
   const statePath = getWelcomeBackStatePath();
-  await fs15.mkdir(path19.dirname(statePath), { recursive: true });
+  await fs16.mkdir(path20.dirname(statePath), { recursive: true });
   const state = {
     version: 1,
     lastChoice: "restart",
@@ -17494,7 +17875,7 @@ async function saveWelcomeBackRestartChoice(summaryFingerprint) {
 __name(saveWelcomeBackRestartChoice, "saveWelcomeBackRestartChoice");
 async function clearWelcomeBackState() {
   try {
-    await fs15.rm(getWelcomeBackStatePath(), { force: true });
+    await fs16.rm(getWelcomeBackStatePath(), { force: true });
   } catch {
   }
 }
@@ -17502,15 +17883,15 @@ __name(clearWelcomeBackState, "clearWelcomeBackState");
 async function getProjectSummaryInfo() {
   const summaryPath = getProjectSummaryPath();
   try {
-    await fs15.access(summaryPath);
+    await fs16.access(summaryPath);
   } catch {
     return {
       hasHistory: false
     };
   }
   try {
-    const summaryStat = await fs15.stat(summaryPath);
-    const content = await fs15.readFile(summaryPath, "utf-8");
+    const summaryStat = await fs16.stat(summaryPath);
+    const content = await fs16.readFile(summaryPath, "utf-8");
     const summaryFingerprint = buildSummaryFingerprint(summaryStat);
     const timestampMatch = content.match(/\*\*Update time\*\*: (.+)/);
     const timestamp = timestampMatch ? timestampMatch[1] : (/* @__PURE__ */ new Date()).toISOString();
@@ -17578,9 +17959,9 @@ __name(getProjectSummaryInfo, "getProjectSummaryInfo");
 
 // packages/core/src/tools/readManyFiles.ts
 init_esbuild_shims();
-import * as fs16 from "node:fs";
+import * as fs17 from "node:fs";
 import * as os4 from "node:os";
-import * as path20 from "node:path";
+import * as path21 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;
@@ -17600,7 +17981,7 @@ async function readManyFiles(config, options) {
     for (const rawPattern of inputPatterns) {
       signal?.throwIfAborted();
       const normalizedPattern = rawPattern.replace(/\\/g, "/");
-      const fullPath = path20.resolve(projectRoot, normalizedPattern);
+      const fullPath = path21.resolve(projectRoot, normalizedPattern);
       const displayPath = displayPaths?.get(fullPath) ?? fullPath;
       const validatedIdentity = validatedPathIdentities?.get(fullPath);
       if (validatedPathIdentities && !validatedIdentity) continue;
@@ -17619,7 +18000,7 @@ async function readManyFiles(config, options) {
       if (validatedIdentity && !await matchesValidatedPathIdentity(fullPath, validatedIdentity)) {
         continue;
       }
-      const stats = fs16.existsSync(fullPath) ? fs16.statSync(fullPath) : null;
+      const stats = fs17.existsSync(fullPath) ? fs17.statSync(fullPath) : null;
       if (stats?.isDirectory()) {
         const { contentParts: dirParts, info } = await readDirectory(
           config,
@@ -17739,9 +18120,9 @@ async function readValidatedTextFileContent(config, filePath, expected, preserve
 __name(readValidatedTextFileContent, "readValidatedTextFileContent");
 async function matchesValidatedPathIdentity(filePath, expected) {
   try {
-    const canonicalPath = await fs16.promises.realpath(filePath);
+    const canonicalPath = await fs17.promises.realpath(filePath);
     if (canonicalPath !== filePath) return false;
-    const stats = await fs16.promises.stat(canonicalPath);
+    const stats = await fs17.promises.stat(canonicalPath);
     return statsMatchValidatedIdentity(stats, expected);
   } catch {
     return false;
@@ -17770,13 +18151,13 @@ async function snapshotValidatedFile(filePath, expected, signal) {
       if (stats.size > SNAPSHOT_MAX_SIZE_BYTES) {
         return void 0;
       }
-      snapshotDir = await fs16.promises.mkdtemp(
-        path20.join(os4.tmpdir(), "qwen-validated-read-")
+      snapshotDir = await fs17.promises.mkdtemp(
+        path21.join(os4.tmpdir(), "qwen-validated-read-")
       );
-      const snapshotPath = path20.join(snapshotDir, path20.basename(filePath));
-      const target = await fs16.promises.open(
+      const snapshotPath = path21.join(snapshotDir, path21.basename(filePath));
+      const target = await fs17.promises.open(
         snapshotPath,
-        fs16.constants.O_WRONLY | fs16.constants.O_CREAT | fs16.constants.O_EXCL,
+        fs17.constants.O_WRONLY | fs17.constants.O_CREAT | fs17.constants.O_EXCL,
         384
       );
       try {
@@ -17817,7 +18198,7 @@ async function snapshotValidatedFile(filePath, expected, signal) {
       result = {
         filePath: snapshotPath,
         stats,
-        cleanup: /* @__PURE__ */ __name(() => fs16.promises.rm(snapshotDir, { recursive: true, force: true }), "cleanup")
+        cleanup: /* @__PURE__ */ __name(() => fs17.promises.rm(snapshotDir, { recursive: true, force: true }), "cleanup")
       };
       return result;
     } finally {
@@ -17829,7 +18210,7 @@ async function snapshotValidatedFile(filePath, expected, signal) {
     return void 0;
   } finally {
     if (snapshotDir && !result) {
-      await fs16.promises.rm(snapshotDir, { recursive: true, force: true });
+      await fs17.promises.rm(snapshotDir, { recursive: true, force: true });
     }
   }
 }
@@ -18052,6 +18433,17 @@ export {
   Fzf,
   AsyncFzf,
   FileSearchFactory,
+  realpathOrSelf,
+  realpathOnDiskOrSelf,
+  listGitWorktrees,
+  removeGitWorktree,
+  commitIsReachable,
+  worktreeHoldsSubmodules,
+  dryRunGitWorktreePrune,
+  worktreeAdminHoldsModules,
+  lockGitWorktree,
+  unlockGitWorktree,
+  pruneGitWorktrees,
   analyzeToolResultRetention,
   readPathFromWorkspace,
   getWelcomeBackState,