@qwen-code/qwen-code 0.16.1-nightly.20260526.e8b79d772 → 0.16.1-preview.0

package/chunks/{chunk-ZKA3IIHA.js → chunk-QQAHXZS2.js}

@@ -160,7 +160,7 @@ import {
   truncateSpanError,
   truncateToolOutput,
   uiTelemetryService
-} from "./chunk-MYDM4QOE.js";
+} from "./chunk-DDU3LH4J.js";
 import {
   DEFAULT_QWEN_EMBEDDING_MODEL,
   DEFAULT_QWEN_MODEL
@@ -2144,16 +2144,16 @@ var require_windows = __commonJS({
       return false;
     }
     __name(checkPathExt, "checkPathExt");
-    function checkStat(stat15, path84, options2) {
-      if (!stat15.isSymbolicLink() && !stat15.isFile()) {
+    function checkStat(stat16, path84, options2) {
+      if (!stat16.isSymbolicLink() && !stat16.isFile()) {
         return false;
       }
       return checkPathExt(path84, options2);
     }
     __name(checkStat, "checkStat");
     function isexe(path84, options2, cb) {
-      fs81.stat(path84, function(er, stat15) {
-        cb(er, er ? false : checkStat(stat15, path84, options2));
+      fs81.stat(path84, function(er, stat16) {
+        cb(er, er ? false : checkStat(stat16, path84, options2));
       });
     }
     __name(isexe, "isexe");
@@ -2172,8 +2172,8 @@ var require_mode = __commonJS({
     isexe.sync = sync2;
     var fs81 = __require("fs");
     function isexe(path84, options2, cb) {
-      fs81.stat(path84, function(er, stat15) {
-        cb(er, er ? false : checkStat(stat15, options2));
+      fs81.stat(path84, function(er, stat16) {
+        cb(er, er ? false : checkStat(stat16, options2));
       });
     }
     __name(isexe, "isexe");
@@ -2181,14 +2181,14 @@ var require_mode = __commonJS({
       return checkStat(fs81.statSync(path84), options2);
     }
     __name(sync2, "sync");
-    function checkStat(stat15, options2) {
-      return stat15.isFile() && checkMode(stat15, options2);
+    function checkStat(stat16, options2) {
+      return stat16.isFile() && checkMode(stat16, options2);
     }
     __name(checkStat, "checkStat");
-    function checkMode(stat15, options2) {
-      var mod = stat15.mode;
-      var uid = stat15.uid;
-      var gid = stat15.gid;
+    function checkMode(stat16, options2) {
+      var mod = stat16.mode;
+      var uid = stat16.uid;
+      var gid = stat16.gid;
       var myUid = options2.uid !== void 0 ? options2.uid : process.getuid && process.getuid();
       var myGid = options2.gid !== void 0 ? options2.gid : process.getgid && process.getgid();
       var u = parseInt("100", 8);
@@ -2668,12 +2668,12 @@ var require_src3 = __commonJS({
     function check(path84, isFile2, isDirectory) {
       log(`checking %s`, path84);
       try {
-        const stat15 = fs_1.statSync(path84);
-        if (stat15.isFile() && isFile2) {
+        const stat16 = fs_1.statSync(path84);
+        if (stat16.isFile() && isFile2) {
           log(`[OK] path represents a file`);
           return true;
         }
-        if (stat15.isDirectory() && isDirectory) {
+        if (stat16.isDirectory() && isDirectory) {
           log(`[OK] path represents a directory`);
           return true;
         }
@@ -10526,10 +10526,10 @@ var require_resolve_block_map = __commonJS({
       let offset = bm.offset;
       let commentEnd = null;
       for (const collItem of bm.items) {
-        const { start: start2, key, sep: sep17, value } = collItem;
+        const { start: start2, key, sep: sep16, value } = collItem;
         const keyProps = resolveProps.resolveProps(start2, {
           indicator: "explicit-key-ind",
-          next: key ?? sep17?.[0],
+          next: key ?? sep16?.[0],
           offset,
           onError: onError2,
           parentIndent: bm.indent,
@@ -10543,7 +10543,7 @@ var require_resolve_block_map = __commonJS({
             else if ("indent" in key && key.indent !== bm.indent)
               onError2(offset, "BAD_INDENT", startColMsg);
           }
-          if (!keyProps.anchor && !keyProps.tag && !sep17) {
+          if (!keyProps.anchor && !keyProps.tag && !sep16) {
             commentEnd = keyProps.end;
             if (keyProps.comment) {
               if (map.comment)
@@ -10567,7 +10567,7 @@ var require_resolve_block_map = __commonJS({
         ctx.atKey = false;
         if (utilMapIncludes.mapIncludes(ctx, map.items, keyNode))
           onError2(keyStart, "DUPLICATE_KEY", "Map keys must be unique");
-        const valueProps = resolveProps.resolveProps(sep17 ?? [], {
+        const valueProps = resolveProps.resolveProps(sep16 ?? [], {
           indicator: "map-value-ind",
           next: value,
           offset: keyNode.range[2],
@@ -10583,7 +10583,7 @@ var require_resolve_block_map = __commonJS({
             if (ctx.options.strict && keyProps.start < valueProps.found.offset - 1024)
               onError2(keyNode.range, "KEY_OVER_1024_CHARS", "The : indicator must be at most 1024 chars after the start of an implicit block mapping key");
           }
-          const valueNode = value ? composeNode(ctx, value, valueProps, onError2) : composeEmptyNode(ctx, offset, sep17, null, valueProps, onError2);
+          const valueNode = value ? composeNode(ctx, value, valueProps, onError2) : composeEmptyNode(ctx, offset, sep16, null, valueProps, onError2);
           if (ctx.schema.compat)
             utilFlowIndentCheck.flowIndentCheck(bm.indent, value, onError2);
           offset = valueNode.range[2];
@@ -10678,7 +10678,7 @@ var require_resolve_end = __commonJS({
       let comment = "";
       if (end) {
         let hasSpace = false;
-        let sep17 = "";
+        let sep16 = "";
         for (const token of end) {
           const { source, type } = token;
           switch (type) {
@@ -10692,13 +10692,13 @@ var require_resolve_end = __commonJS({
               if (!comment)
                 comment = cb;
               else
-                comment += sep17 + cb;
-              sep17 = "";
+                comment += sep16 + cb;
+              sep16 = "";
               break;
             }
             case "newline":
               if (comment)
-                sep17 += source;
+                sep16 += source;
               hasSpace = true;
               break;
             default:
@@ -10743,18 +10743,18 @@ var require_resolve_flow_collection = __commonJS({
       let offset = fc.offset + fc.start.source.length;
       for (let i2 = 0; i2 < fc.items.length; ++i2) {
         const collItem = fc.items[i2];
-        const { start: start2, key, sep: sep17, value } = collItem;
+        const { start: start2, key, sep: sep16, value } = collItem;
         const props = resolveProps.resolveProps(start2, {
           flow: fcName,
           indicator: "explicit-key-ind",
-          next: key ?? sep17?.[0],
+          next: key ?? sep16?.[0],
           offset,
           onError: onError2,
           parentIndent: fc.indent,
           startOnNewline: false
         });
         if (!props.found) {
-          if (!props.anchor && !props.tag && !sep17 && !value) {
+          if (!props.anchor && !props.tag && !sep16 && !value) {
             if (i2 === 0 && props.comma)
               onError2(props.comma, "UNEXPECTED_TOKEN", `Unexpected , in ${fcName}`);
             else if (i2 < fc.items.length - 1)
@@ -10808,8 +10808,8 @@ var require_resolve_flow_collection = __commonJS({
             }
           }
         }
-        if (!isMap && !sep17 && !props.found) {
-          const valueNode = value ? composeNode(ctx, value, props, onError2) : composeEmptyNode(ctx, props.end, sep17, null, props, onError2);
+        if (!isMap && !sep16 && !props.found) {
+          const valueNode = value ? composeNode(ctx, value, props, onError2) : composeEmptyNode(ctx, props.end, sep16, null, props, onError2);
           coll.items.push(valueNode);
           offset = valueNode.range[2];
           if (isBlock(value))
@@ -10821,7 +10821,7 @@ var require_resolve_flow_collection = __commonJS({
           if (isBlock(key))
             onError2(keyNode.range, "BLOCK_IN_FLOW", blockMsg);
           ctx.atKey = false;
-          const valueProps = resolveProps.resolveProps(sep17 ?? [], {
+          const valueProps = resolveProps.resolveProps(sep16 ?? [], {
             flow: fcName,
             indicator: "map-value-ind",
             next: value,
@@ -10832,8 +10832,8 @@ var require_resolve_flow_collection = __commonJS({
           });
           if (valueProps.found) {
             if (!isMap && !props.found && ctx.options.strict) {
-              if (sep17)
-                for (const st of sep17) {
+              if (sep16)
+                for (const st of sep16) {
                   if (st === valueProps.found)
                     break;
                   if (st.type === "newline") {
@@ -10850,7 +10850,7 @@ var require_resolve_flow_collection = __commonJS({
             else
               onError2(valueProps.start, "MISSING_CHAR", `Missing , or : between ${fcName} items`);
           }
-          const valueNode = value ? composeNode(ctx, value, valueProps, onError2) : valueProps.found ? composeEmptyNode(ctx, valueProps.end, sep17, null, valueProps, onError2) : null;
+          const valueNode = value ? composeNode(ctx, value, valueProps, onError2) : valueProps.found ? composeEmptyNode(ctx, valueProps.end, sep16, null, valueProps, onError2) : null;
           if (valueNode) {
             if (isBlock(value))
               onError2(valueNode.range, "BLOCK_IN_FLOW", blockMsg);
@@ -11035,7 +11035,7 @@ var require_resolve_block_scalar = __commonJS({
           chompStart = i2 + 1;
       }
       let value = "";
-      let sep17 = "";
+      let sep16 = "";
       let prevMoreIndented = false;
       for (let i2 = 0; i2 < contentStart; ++i2)
         value += lines[i2][0].slice(trimIndent) + "\n";
@@ -11052,24 +11052,24 @@ var require_resolve_block_scalar = __commonJS({
           indent = "";
         }
         if (type === Scalar.Scalar.BLOCK_LITERAL) {
-          value += sep17 + indent.slice(trimIndent) + content;
-          sep17 = "\n";
+          value += sep16 + indent.slice(trimIndent) + content;
+          sep16 = "\n";
         } else if (indent.length > trimIndent || content[0] === "	") {
-          if (sep17 === " ")
-            sep17 = "\n";
-          else if (!prevMoreIndented && sep17 === "\n")
-            sep17 = "\n\n";
-          value += sep17 + indent.slice(trimIndent) + content;
-          sep17 = "\n";
+          if (sep16 === " ")
+            sep16 = "\n";
+          else if (!prevMoreIndented && sep16 === "\n")
+            sep16 = "\n\n";
+          value += sep16 + indent.slice(trimIndent) + content;
+          sep16 = "\n";
           prevMoreIndented = true;
         } else if (content === "") {
-          if (sep17 === "\n")
+          if (sep16 === "\n")
             value += "\n";
           else
-            sep17 = "\n";
+            sep16 = "\n";
         } else {
-          value += sep17 + content;
-          sep17 = " ";
+          value += sep16 + content;
+          sep16 = " ";
           prevMoreIndented = false;
         }
       }
@@ -11258,25 +11258,25 @@ var require_resolve_flow_scalar = __commonJS({
       if (!match2)
         return source;
       let res = match2[1];
-      let sep17 = " ";
+      let sep16 = " ";
       let pos2 = first2.lastIndex;
       line.lastIndex = pos2;
       while (match2 = line.exec(source)) {
         if (match2[1] === "") {
-          if (sep17 === "\n")
-            res += sep17;
+          if (sep16 === "\n")
+            res += sep16;
           else
-            sep17 = "\n";
+            sep16 = "\n";
         } else {
-          res += sep17 + match2[1];
-          sep17 = " ";
+          res += sep16 + match2[1];
+          sep16 = " ";
         }
         pos2 = line.lastIndex;
       }
       const last2 = /[ \t]*(.*)/sy;
       last2.lastIndex = pos2;
       match2 = last2.exec(source);
-      return res + sep17 + (match2?.[1] ?? "");
+      return res + sep16 + (match2?.[1] ?? "");
     }
     __name(foldLines, "foldLines");
     function doubleQuotedValue(source, onError2) {
@@ -12109,14 +12109,14 @@ var require_cst_stringify = __commonJS({
       }
     }
     __name(stringifyToken, "stringifyToken");
-    function stringifyItem({ start: start2, key, sep: sep17, value }) {
+    function stringifyItem({ start: start2, key, sep: sep16, value }) {
       let res = "";
       for (const st of start2)
         res += st.source;
       if (key)
         res += stringifyToken(key);
-      if (sep17)
-        for (const st of sep17)
+      if (sep16)
+        for (const st of sep16)
           res += st.source;
       if (value)
         res += stringifyToken(value);
@@ -13292,18 +13292,18 @@ var require_parser = __commonJS({
         if (this.type === "map-value-ind") {
           const prev = getPrevProps(this.peek(2));
           const start2 = getFirstKeyStartProps(prev);
-          let sep17;
+          let sep16;
           if (scalar.end) {
-            sep17 = scalar.end;
-            sep17.push(this.sourceToken);
+            sep16 = scalar.end;
+            sep16.push(this.sourceToken);
             delete scalar.end;
           } else
-            sep17 = [this.sourceToken];
+            sep16 = [this.sourceToken];
           const map = {
             type: "block-map",
             offset: scalar.offset,
             indent: scalar.indent,
-            items: [{ start: start2, key: scalar, sep: sep17 }]
+            items: [{ start: start2, key: scalar, sep: sep16 }]
           };
           this.onKeyLine = true;
           this.stack[this.stack.length - 1] = map;
@@ -13456,15 +13456,15 @@ var require_parser = __commonJS({
                 } else if (isFlowToken(it.key) && !includesToken(it.sep, "newline")) {
                   const start3 = getFirstKeyStartProps(it.start);
                   const key = it.key;
-                  const sep17 = it.sep;
-                  sep17.push(this.sourceToken);
+                  const sep16 = it.sep;
+                  sep16.push(this.sourceToken);
                   delete it.key;
                   delete it.sep;
                   this.stack.push({
                     type: "block-map",
                     offset: this.offset,
                     indent: this.indent,
-                    items: [{ start: start3, key, sep: sep17 }]
+                    items: [{ start: start3, key, sep: sep16 }]
                   });
                 } else if (start2.length > 0) {
                   it.sep = it.sep.concat(start2, this.sourceToken);
@@ -13658,13 +13658,13 @@ var require_parser = __commonJS({
             const prev = getPrevProps(parent);
             const start2 = getFirstKeyStartProps(prev);
             fixFlowSeqItems(fc);
-            const sep17 = fc.end.splice(1, fc.end.length);
-            sep17.push(this.sourceToken);
+            const sep16 = fc.end.splice(1, fc.end.length);
+            sep16.push(this.sourceToken);
             const map = {
               type: "block-map",
               offset: fc.offset,
               indent: fc.indent,
-              items: [{ start: start2, key: fc, sep: sep17 }]
+              items: [{ start: start2, key: fc, sep: sep16 }]
             };
             this.onKeyLine = true;
             this.stack[this.stack.length - 1] = map;
@@ -18110,8 +18110,8 @@ var require_main = __commonJS({
         const shortPaths = [];
         for (const filePath of optionPaths) {
           try {
-            const relative13 = path84.relative(process.cwd(), filePath);
-            shortPaths.push(relative13);
+            const relative12 = path84.relative(process.cwd(), filePath);
+            shortPaths.push(relative12);
           } catch (e) {
             if (debug2) {
               _debug(`Failed to load ${filePath} ${e.message}`);
@@ -20767,9 +20767,9 @@ var require_prompts = __commonJS({
     $.date = (args2) => toPrompt("DatePrompt", args2);
     $.confirm = (args2) => toPrompt("ConfirmPrompt", args2);
     $.list = (args2) => {
-      const sep17 = args2.separator || ",";
+      const sep16 = args2.separator || ",";
       return toPrompt("TextPrompt", args2, {
-        onSubmit: /* @__PURE__ */ __name((str) => str.split(sep17).map((s) => s.trim()), "onSubmit")
+        onSubmit: /* @__PURE__ */ __name((str) => str.split(sep16).map((s) => s.trim()), "onSubmit")
       });
     };
     $.toggle = (args2) => toPrompt("TogglePrompt", args2);
@@ -23162,9 +23162,9 @@ var require_prompts2 = __commonJS({
     $.date = (args2) => toPrompt("DatePrompt", args2);
     $.confirm = (args2) => toPrompt("ConfirmPrompt", args2);
     $.list = (args2) => {
-      const sep17 = args2.separator || ",";
+      const sep16 = args2.separator || ",";
       return toPrompt("TextPrompt", args2, {
-        onSubmit: /* @__PURE__ */ __name((str) => str.split(sep17).map((s) => s.trim()), "onSubmit")
+        onSubmit: /* @__PURE__ */ __name((str) => str.split(sep16).map((s) => s.trim()), "onSubmit")
       });
     };
     $.toggle = (args2) => toPrompt("TogglePrompt", args2);
@@ -23525,12 +23525,12 @@ var require_resolve_symlink = __commonJS({
       fs_1.default.realpath(path84, (error, resolvedPath) => {
         if (error)
           return queue.dequeue(suppressErrors ? null : error, state);
-        fs_1.default.stat(resolvedPath, (error2, stat15) => {
+        fs_1.default.stat(resolvedPath, (error2, stat16) => {
           if (error2)
             return queue.dequeue(suppressErrors ? null : error2, state);
-          if (stat15.isDirectory() && isRecursive(path84, resolvedPath, state))
+          if (stat16.isDirectory() && isRecursive(path84, resolvedPath, state))
             return queue.dequeue(null, state);
-          callback(stat15, resolvedPath);
+          callback(stat16, resolvedPath);
           queue.dequeue(null, state);
         });
       });
@@ -23540,10 +23540,10 @@ var require_resolve_symlink = __commonJS({
       queue.enqueue();
       try {
         const resolvedPath = fs_1.default.realpathSync(path84);
-        const stat15 = fs_1.default.statSync(resolvedPath);
-        if (stat15.isDirectory() && isRecursive(path84, resolvedPath, state))
+        const stat16 = fs_1.default.statSync(resolvedPath);
+        if (stat16.isDirectory() && isRecursive(path84, resolvedPath, state))
           return;
-        callback(stat15, resolvedPath);
+        callback(stat16, resolvedPath);
       } catch (e) {
         if (!suppressErrors)
           throw e;
@@ -23862,8 +23862,8 @@ var require_walker = __commonJS({
             this.walkDirectory(this.state, path84, path84, depth - 1, this.walk);
           } else if (this.resolveSymlink && entry.isSymbolicLink()) {
             let path84 = joinPath.joinPathWithBasePath(entry.name, directoryPath);
-            this.resolveSymlink(path84, this.state, (stat15, resolvedPath) => {
-              if (stat15.isDirectory()) {
+            this.resolveSymlink(path84, this.state, (stat16, resolvedPath) => {
+              if (stat16.isDirectory()) {
                 resolvedPath = (0, utils_1.normalizePath)(resolvedPath, this.state.options);
                 if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path84 + pathSeparator))
                   return;
@@ -28380,8 +28380,8 @@ async function atomicWriteFile(filePath, data, options2) {
   const tmpPath = `${targetPath}.${crypto.randomBytes(6).toString("hex")}.tmp`;
   let existingMode;
   try {
-    const stat15 = await fs3.stat(targetPath);
-    existingMode = stat15.mode & 4095;
+    const stat16 = await fs3.stat(targetPath);
+    existingMode = stat16.mode & 4095;
   } catch (err2) {
     if (!isNodeError(err2) || err2.code !== "ENOENT") {
       throw err2;
@@ -37504,6 +37504,85 @@ import { randomUUID as randomUUID5 } from "node:crypto";
 init_esbuild_shims();
 import { randomUUID as randomUUID3 } from "node:crypto";
 
+// packages/core/src/utils/abortController.ts
+init_esbuild_shims();
+import { setMaxListeners } from "node:events";
+var DEFAULT_MAX_LISTENERS = 50;
+function createAbortController(maxListeners = DEFAULT_MAX_LISTENERS) {
+  const controller = new AbortController();
+  setMaxListeners(maxListeners, controller.signal);
+  return controller;
+}
+__name(createAbortController, "createAbortController");
+function asSignal(parent) {
+  if (!parent) return void 0;
+  return parent instanceof AbortController ? parent.signal : parent;
+}
+__name(asSignal, "asSignal");
+function createChildAbortController(parent, maxListeners) {
+  const child = createAbortController(maxListeners);
+  const parentSignal = asSignal(parent);
+  if (!parentSignal) return child;
+  if (parentSignal.aborted) {
+    child.abort(parentSignal.reason);
+    return child;
+  }
+  const weakParent = new WeakRef(parentSignal);
+  const handler = /* @__PURE__ */ __name(() => {
+    child.abort(weakParent.deref()?.reason);
+  }, "handler");
+  parentSignal.addEventListener("abort", handler, { once: true });
+  child.signal.addEventListener(
+    "abort",
+    () => {
+      weakParent.deref()?.removeEventListener("abort", handler);
+    },
+    { once: true }
+  );
+  return child;
+}
+__name(createChildAbortController, "createChildAbortController");
+function combineAbortSignals(signals, options2) {
+  const controller = createAbortController(options2?.maxListeners);
+  const alreadyAborted = signals.find((s) => s?.aborted);
+  if (alreadyAborted) {
+    controller.abort(alreadyAborted.reason);
+    return { signal: controller.signal, cleanup: /* @__PURE__ */ __name(() => {
+    }, "cleanup") };
+  }
+  const cleanups = [];
+  for (const sourceSignal of signals) {
+    if (!sourceSignal) continue;
+    if (sourceSignal.aborted) {
+      controller.abort(sourceSignal.reason);
+      break;
+    }
+    const handler = /* @__PURE__ */ __name(() => controller.abort(sourceSignal.reason), "handler");
+    sourceSignal.addEventListener("abort", handler, { once: true });
+    cleanups.push(() => sourceSignal.removeEventListener("abort", handler));
+  }
+  const timeoutMs = options2?.timeoutMs;
+  if (timeoutMs !== void 0 && timeoutMs > 0 && !controller.signal.aborted) {
+    const timeoutId = setTimeout(() => {
+      controller.abort(new DOMException("Operation timed out", "TimeoutError"));
+    }, timeoutMs);
+    cleanups.push(() => clearTimeout(timeoutId));
+  }
+  let done = false;
+  const cleanup = /* @__PURE__ */ __name(() => {
+    if (done) return;
+    done = true;
+    for (const fn of cleanups) fn();
+  }, "cleanup");
+  if (controller.signal.aborted) {
+    cleanup();
+  } else {
+    controller.signal.addEventListener("abort", cleanup, { once: true });
+  }
+  return { signal: controller.signal, cleanup };
+}
+__name(combineAbortSignals, "combineAbortSignals");
+
 // packages/core/src/core/coreToolScheduler.ts
 init_esbuild_shims();
 
@@ -46616,13 +46695,13 @@ var IdeClient = class _IdeClient {
       lockFiles.map(async (file) => {
         const fullPath = path13.join(ideDir, file);
         try {
-          const stat15 = await fs13.promises.stat(fullPath);
+          const stat16 = await fs13.promises.stat(fullPath);
           const content = await fs13.promises.readFile(fullPath, "utf8");
           try {
             return {
               file,
               fullPath,
-              mtimeMs: stat15.mtimeMs,
+              mtimeMs: stat16.mtimeMs,
               parsed: JSON.parse(content)
             };
           } catch (error) {
@@ -47726,8 +47805,8 @@ var CoreToolScheduler = class {
       if (this.validationRetryCounts.size > 0) {
         const currentToolNames = new Set(requestsToProcess.map((r) => r.name));
         for (const key of [...this.validationRetryCounts.keys()]) {
-          const sep17 = key.indexOf(":");
-          const toolName = sep17 === -1 ? key : key.slice(0, sep17);
+          const sep16 = key.indexOf(":");
+          const toolName = sep16 === -1 ? key : key.slice(0, sep16);
           if (!currentToolNames.has(toolName)) {
             this.validationRetryCounts.delete(key);
           }
@@ -49434,96 +49513,91 @@ var AgentHeadless = class _AgentHeadless {
       this.terminateMode = "ERROR" /* ERROR */;
       return;
     }
-    const abortController = new AbortController();
-    const onExternalAbort = /* @__PURE__ */ __name(() => {
-      abortController.abort();
-    }, "onExternalAbort");
-    if (externalSignal) {
-      externalSignal.addEventListener("abort", onExternalAbort);
-    }
-    if (externalSignal?.aborted) {
-      abortController.abort();
-    }
-    const toolsList = await this.core.prepareTools();
-    const initialMessages = initialMessagesOverride && initialMessagesOverride.length > 0 ? initialMessagesOverride : [{ role: "user", parts: [{ text: initialTaskText }] }];
-    const startTime = Date.now();
-    this.core.executionStats.startTimeMs = startTime;
-    this.core.stats.start(startTime);
+    const abortController = createChildAbortController(externalSignal);
     try {
-      this.core.eventEmitter?.emit("start" /* START */, {
-        subagentId: this.core.subagentId,
-        name: this.core.name,
-        model: this.core.modelConfig.model || this.core.runtimeContext.getModel() || DEFAULT_QWEN_MODEL,
-        tools: (this.core.toolConfig?.tools || ["*"]).map(
-          (t) => typeof t === "string" ? t : t.name
-        ),
-        timestamp: Date.now()
-      });
-      const startEvent = new SubagentExecutionEvent(this.core.name, "started");
-      logSubagentExecution(this.core.runtimeContext, startEvent);
-      const result = await this.core.runReasoningLoop(
-        chat,
-        initialMessages,
-        toolsList,
-        abortController,
-        {
-          maxTurns: this.core.runConfig.max_turns,
-          maxTimeMinutes: this.core.runConfig.max_time_minutes,
-          startTimeMs: startTime,
-          getExternalMessages: this.externalMessageProvider,
-          waitForExternalMessages: this.externalMessageWaiter,
-          shouldWaitForExternalMessages: this.externalMessageWaitPredicate
-        }
-      );
-      this.finalText = result.text;
-      this.terminateMode = result.terminateMode ?? "GOAL" /* GOAL */;
-    } catch (error) {
-      debugLogger24.error("Error during subagent execution:", error);
-      this.terminateMode = "ERROR" /* ERROR */;
-      this.core.eventEmitter?.emit("error" /* ERROR */, {
-        subagentId: this.core.subagentId,
-        error: error instanceof Error ? error.message : String(error),
-        timestamp: Date.now()
-      });
-      throw error;
+      const toolsList = await this.core.prepareTools();
+      const initialMessages = initialMessagesOverride && initialMessagesOverride.length > 0 ? initialMessagesOverride : [{ role: "user", parts: [{ text: initialTaskText }] }];
+      const startTime = Date.now();
+      this.core.executionStats.startTimeMs = startTime;
+      this.core.stats.start(startTime);
+      try {
+        this.core.eventEmitter?.emit("start" /* START */, {
+          subagentId: this.core.subagentId,
+          name: this.core.name,
+          model: this.core.modelConfig.model || this.core.runtimeContext.getModel() || DEFAULT_QWEN_MODEL,
+          tools: (this.core.toolConfig?.tools || ["*"]).map(
+            (t) => typeof t === "string" ? t : t.name
+          ),
+          timestamp: Date.now()
+        });
+        const startEvent = new SubagentExecutionEvent(
+          this.core.name,
+          "started"
+        );
+        logSubagentExecution(this.core.runtimeContext, startEvent);
+        const result = await this.core.runReasoningLoop(
+          chat,
+          initialMessages,
+          toolsList,
+          abortController,
+          {
+            maxTurns: this.core.runConfig.max_turns,
+            maxTimeMinutes: this.core.runConfig.max_time_minutes,
+            startTimeMs: startTime,
+            getExternalMessages: this.externalMessageProvider,
+            waitForExternalMessages: this.externalMessageWaiter,
+            shouldWaitForExternalMessages: this.externalMessageWaitPredicate
+          }
+        );
+        this.finalText = result.text;
+        this.terminateMode = result.terminateMode ?? "GOAL" /* GOAL */;
+      } catch (error) {
+        debugLogger24.error("Error during subagent execution:", error);
+        this.terminateMode = "ERROR" /* ERROR */;
+        this.core.eventEmitter?.emit("error" /* ERROR */, {
+          subagentId: this.core.subagentId,
+          error: error instanceof Error ? error.message : String(error),
+          timestamp: Date.now()
+        });
+        throw error;
+      } finally {
+        this.core.executionStats.totalDurationMs = Date.now() - startTime;
+        const summary = this.core.stats.getSummary(Date.now());
+        this.core.eventEmitter?.emit("finish" /* FINISH */, {
+          subagentId: this.core.subagentId,
+          terminateReason: this.terminateMode,
+          timestamp: Date.now(),
+          rounds: summary.rounds,
+          totalDurationMs: summary.totalDurationMs,
+          totalToolCalls: summary.totalToolCalls,
+          successfulToolCalls: summary.successfulToolCalls,
+          failedToolCalls: summary.failedToolCalls,
+          inputTokens: summary.inputTokens,
+          outputTokens: summary.outputTokens,
+          totalTokens: summary.totalTokens
+        });
+        const completionEvent = new SubagentExecutionEvent(
+          this.core.name,
+          this.terminateMode === "GOAL" /* GOAL */ ? "completed" : "failed",
+          {
+            terminate_reason: this.terminateMode,
+            result: this.finalText,
+            execution_summary: this.core.stats.formatCompact(
+              "Subagent execution completed"
+            )
+          }
+        );
+        logSubagentExecution(this.core.runtimeContext, completionEvent);
+        await this.core.hooks?.onStop?.({
+          subagentId: this.core.subagentId,
+          name: this.core.name,
+          terminateReason: this.terminateMode,
+          summary,
+          timestamp: Date.now()
+        });
+      }
     } finally {
-      if (externalSignal) {
-        externalSignal.removeEventListener("abort", onExternalAbort);
-      }
-      this.core.executionStats.totalDurationMs = Date.now() - startTime;
-      const summary = this.core.stats.getSummary(Date.now());
-      this.core.eventEmitter?.emit("finish" /* FINISH */, {
-        subagentId: this.core.subagentId,
-        terminateReason: this.terminateMode,
-        timestamp: Date.now(),
-        rounds: summary.rounds,
-        totalDurationMs: summary.totalDurationMs,
-        totalToolCalls: summary.totalToolCalls,
-        successfulToolCalls: summary.successfulToolCalls,
-        failedToolCalls: summary.failedToolCalls,
-        inputTokens: summary.inputTokens,
-        outputTokens: summary.outputTokens,
-        totalTokens: summary.totalTokens
-      });
-      const completionEvent = new SubagentExecutionEvent(
-        this.core.name,
-        this.terminateMode === "GOAL" /* GOAL */ ? "completed" : "failed",
-        {
-          terminate_reason: this.terminateMode,
-          result: this.finalText,
-          execution_summary: this.core.stats.formatCompact(
-            "Subagent execution completed"
-          )
-        }
-      );
-      logSubagentExecution(this.core.runtimeContext, completionEvent);
-      await this.core.hooks?.onStop?.({
-        subagentId: this.core.subagentId,
-        name: this.core.name,
-        terminateReason: this.terminateMode,
-        summary,
-        timestamp: Date.now()
-      });
+      abortController.abort();
     }
   }
   // ─── Accessors ─────────────────────────────────────────────
@@ -49864,203 +49938,199 @@ var AgentCore = class {
         terminateMode = "TIMEOUT" /* TIMEOUT */;
         break;
       }
-      const roundAbortController = new AbortController();
-      const onParentAbort = /* @__PURE__ */ __name(() => roundAbortController.abort(), "onParentAbort");
-      abortController.signal.addEventListener("abort", onParentAbort);
-      if (abortController.signal.aborted) {
-        roundAbortController.abort();
-      }
-      const promptId = `${this.runtimeContext.getSessionId()}#${this.subagentId}#${turnCounter++}`;
-      const messageParams = {
-        message: currentMessages[0]?.parts || [],
-        config: {
-          abortSignal: roundAbortController.signal,
-          tools: [{ functionDeclarations: toolsList }]
-        }
-      };
-      const roundStreamStart = Date.now();
-      const responseStream = await chat.sendMessageStream(
-        this.modelConfig.model || this.runtimeContext.getModel() || DEFAULT_QWEN_MODEL,
-        messageParams,
-        promptId
-      );
-      this.eventEmitter?.emit("round_start" /* ROUND_START */, {
-        subagentId: this.subagentId,
-        round: turnCounter,
-        promptId,
-        timestamp: Date.now()
-      });
-      const functionCalls = [];
-      let roundText = "";
-      let roundThoughtText = "";
-      let lastUsage = void 0;
-      let currentResponseId = void 0;
-      let wasOutputTruncated = false;
-      for await (const streamEvent of responseStream) {
-        if (roundAbortController.signal.aborted) {
-          abortController.signal.removeEventListener("abort", onParentAbort);
-          return {
-            text: finalText,
-            terminateMode: "CANCELLED" /* CANCELLED */,
-            turnsUsed: turnCounter
-          };
-        }
-        if (streamEvent.type === "retry") {
-          functionCalls.length = 0;
-          roundText = "";
-          roundThoughtText = "";
-          lastUsage = void 0;
-          currentResponseId = void 0;
-          wasOutputTruncated = false;
-          continue;
-        }
-        if (streamEvent.type === "compressed") {
-          this.runtimeContext.getDebugLogger().debug(
-            `[AGENT-COMPACT] subagent=${this.subagentId} round=${turnCounter} tokens ${streamEvent.info.originalTokenCount} -> ${streamEvent.info.newTokenCount}`
-          );
-          continue;
-        }
-        if (streamEvent.type === "chunk") {
-          const resp = streamEvent.value;
-          if (resp.responseId) {
-            currentResponseId = resp.responseId;
-          }
-          if (resp.functionCalls) functionCalls.push(...resp.functionCalls);
-          if (resp.candidates?.[0]?.finishReason === FinishReason.MAX_TOKENS) {
-            wasOutputTruncated = true;
-          }
-          const content = resp.candidates?.[0]?.content;
-          const parts2 = content?.parts || [];
-          for (const p of parts2) {
-            const txt = p.text;
-            const isThought = p.thought ?? false;
-            if (txt && isThought) roundThoughtText += txt;
-            if (txt && !isThought) roundText += txt;
-            if (txt)
-              this.eventEmitter?.emit("stream_text" /* STREAM_TEXT */, {
-                subagentId: this.subagentId,
-                round: turnCounter,
-                text: txt,
-                thought: isThought,
-                timestamp: Date.now()
-              });
+      const roundAbortController = createChildAbortController(abortController);
+      try {
+        const promptId = `${this.runtimeContext.getSessionId()}#${this.subagentId}#${turnCounter++}`;
+        const messageParams = {
+          message: currentMessages[0]?.parts || [],
+          config: {
+            abortSignal: roundAbortController.signal,
+            tools: [{ functionDeclarations: toolsList }]
           }
-          if (resp.usageMetadata) lastUsage = resp.usageMetadata;
-        }
-      }
-      if (roundText || roundThoughtText) {
-        this.eventEmitter?.emit("round_text" /* ROUND_TEXT */, {
+        };
+        const roundStreamStart = Date.now();
+        const responseStream = await chat.sendMessageStream(
+          this.modelConfig.model || this.runtimeContext.getModel() || DEFAULT_QWEN_MODEL,
+          messageParams,
+          promptId
+        );
+        this.eventEmitter?.emit("round_start" /* ROUND_START */, {
           subagentId: this.subagentId,
           round: turnCounter,
-          text: roundText,
-          thoughtText: roundThoughtText,
+          promptId,
           timestamp: Date.now()
         });
-      }
-      this.executionStats.rounds = turnCounter;
-      this.stats.setRounds(turnCounter);
-      durationMin = (Date.now() - startTime) / (1e3 * 60);
-      if (options2?.maxTimeMinutes && durationMin >= options2.maxTimeMinutes) {
-        abortController.signal.removeEventListener("abort", onParentAbort);
-        terminateMode = "TIMEOUT" /* TIMEOUT */;
-        break;
-      }
-      if (lastUsage) {
-        this.recordTokenUsage(lastUsage, turnCounter, roundStreamStart);
-      }
-      if (functionCalls.length > 0) {
-        currentMessages = await this.processFunctionCalls(
-          functionCalls,
-          roundAbortController,
-          promptId,
-          turnCounter,
-          toolsList,
-          currentResponseId,
-          wasOutputTruncated
-        );
-        const externalInputs = this.drainExternalInputs(options2);
-        if (externalInputs.length > 0) {
-          const last2 = currentMessages[currentMessages.length - 1];
-          last2.parts.push(...this.externalInputsToParts(externalInputs, true));
-          this.emitExternalInputEvents(externalInputs);
+        const functionCalls = [];
+        let roundText = "";
+        let roundThoughtText = "";
+        let lastUsage = void 0;
+        let currentResponseId = void 0;
+        let wasOutputTruncated = false;
+        for await (const streamEvent of responseStream) {
+          if (roundAbortController.signal.aborted) {
+            return {
+              text: finalText,
+              terminateMode: "CANCELLED" /* CANCELLED */,
+              turnsUsed: turnCounter
+            };
+          }
+          if (streamEvent.type === "retry") {
+            functionCalls.length = 0;
+            roundText = "";
+            roundThoughtText = "";
+            lastUsage = void 0;
+            currentResponseId = void 0;
+            wasOutputTruncated = false;
+            continue;
+          }
+          if (streamEvent.type === "compressed") {
+            this.runtimeContext.getDebugLogger().debug(
+              `[AGENT-COMPACT] subagent=${this.subagentId} round=${turnCounter} tokens ${streamEvent.info.originalTokenCount} -> ${streamEvent.info.newTokenCount}`
+            );
+            continue;
+          }
+          if (streamEvent.type === "chunk") {
+            const resp = streamEvent.value;
+            if (resp.responseId) {
+              currentResponseId = resp.responseId;
+            }
+            if (resp.functionCalls) functionCalls.push(...resp.functionCalls);
+            if (resp.candidates?.[0]?.finishReason === FinishReason.MAX_TOKENS) {
+              wasOutputTruncated = true;
+            }
+            const content = resp.candidates?.[0]?.content;
+            const parts2 = content?.parts || [];
+            for (const p of parts2) {
+              const txt = p.text;
+              const isThought = p.thought ?? false;
+              if (txt && isThought) roundThoughtText += txt;
+              if (txt && !isThought) roundText += txt;
+              if (txt)
+                this.eventEmitter?.emit("stream_text" /* STREAM_TEXT */, {
+                  subagentId: this.subagentId,
+                  round: turnCounter,
+                  text: txt,
+                  thought: isThought,
+                  timestamp: Date.now()
+                });
+            }
+            if (resp.usageMetadata) lastUsage = resp.usageMetadata;
+          }
         }
-      } else {
-        const immediateExternalInputs = this.drainExternalInputs(options2);
-        if (immediateExternalInputs.length > 0) {
-          currentMessages = this.externalInputsToContent(
-            immediateExternalInputs
-          );
-          this.emitExternalInputEvents(immediateExternalInputs);
-        } else if (options2?.shouldWaitForExternalMessages?.()) {
-          this.eventEmitter?.emit("round_end" /* ROUND_END */, {
+        if (roundText || roundThoughtText) {
+          this.eventEmitter?.emit("round_text" /* ROUND_TEXT */, {
             subagentId: this.subagentId,
             round: turnCounter,
-            promptId,
+            text: roundText,
+            thoughtText: roundThoughtText,
             timestamp: Date.now()
           });
-          abortController.signal.removeEventListener("abort", onParentAbort);
-          const waitResult = await this.waitForExternalInputs(
-            options2,
-            abortController,
-            startTime,
-            turnCounter
+        }
+        this.executionStats.rounds = turnCounter;
+        this.stats.setRounds(turnCounter);
+        durationMin = (Date.now() - startTime) / (1e3 * 60);
+        if (options2?.maxTimeMinutes && durationMin >= options2.maxTimeMinutes) {
+          terminateMode = "TIMEOUT" /* TIMEOUT */;
+          break;
+        }
+        if (lastUsage) {
+          this.recordTokenUsage(lastUsage, turnCounter, roundStreamStart);
+        }
+        if (functionCalls.length > 0) {
+          currentMessages = await this.processFunctionCalls(
+            functionCalls,
+            roundAbortController,
+            promptId,
+            turnCounter,
+            toolsList,
+            currentResponseId,
+            wasOutputTruncated
           );
-          if (waitResult.terminateMode) {
-            finalText = roundText.trim();
-            terminateMode = waitResult.terminateMode;
-            break;
-          }
-          if (waitResult.inputs.length > 0) {
-            currentMessages = this.externalInputsToContent(waitResult.inputs);
-            this.emitExternalInputEvents(waitResult.inputs);
-            continue;
-          }
-          if (roundText && roundText.trim().length > 0) {
-            finalText = roundText.trim();
-            break;
+          const externalInputs = this.drainExternalInputs(options2);
+          if (externalInputs.length > 0) {
+            const last2 = currentMessages[currentMessages.length - 1];
+            last2.parts.push(
+              ...this.externalInputsToParts(externalInputs, true)
+            );
+            this.emitExternalInputEvents(externalInputs);
           }
-          currentMessages = [
-            {
-              role: "user",
-              parts: [
-                {
-                  text: "Please provide the final result now and stop calling tools."
-                }
-              ]
-            }
-          ];
-          continue;
         } else {
-          if (roundText && roundText.trim().length > 0) {
-            finalText = roundText.trim();
+          const immediateExternalInputs = this.drainExternalInputs(options2);
+          if (immediateExternalInputs.length > 0) {
+            currentMessages = this.externalInputsToContent(
+              immediateExternalInputs
+            );
+            this.emitExternalInputEvents(immediateExternalInputs);
+          } else if (options2?.shouldWaitForExternalMessages?.()) {
             this.eventEmitter?.emit("round_end" /* ROUND_END */, {
               subagentId: this.subagentId,
               round: turnCounter,
               promptId,
               timestamp: Date.now()
             });
-            abortController.signal.removeEventListener("abort", onParentAbort);
-            break;
-          }
-          currentMessages = [
-            {
-              role: "user",
-              parts: [
-                {
-                  text: "Please provide the final result now and stop calling tools."
-                }
-              ]
+            const waitResult = await this.waitForExternalInputs(
+              options2,
+              abortController,
+              startTime,
+              turnCounter
+            );
+            if (waitResult.terminateMode) {
+              finalText = roundText.trim();
+              terminateMode = waitResult.terminateMode;
+              break;
             }
-          ];
+            if (waitResult.inputs.length > 0) {
+              currentMessages = this.externalInputsToContent(waitResult.inputs);
+              this.emitExternalInputEvents(waitResult.inputs);
+              continue;
+            }
+            if (roundText && roundText.trim().length > 0) {
+              finalText = roundText.trim();
+              break;
+            }
+            currentMessages = [
+              {
+                role: "user",
+                parts: [
+                  {
+                    text: "Please provide the final result now and stop calling tools."
+                  }
+                ]
+              }
+            ];
+            continue;
+          } else {
+            if (roundText && roundText.trim().length > 0) {
+              finalText = roundText.trim();
+              this.eventEmitter?.emit("round_end" /* ROUND_END */, {
+                subagentId: this.subagentId,
+                round: turnCounter,
+                promptId,
+                timestamp: Date.now()
+              });
+              break;
+            }
+            currentMessages = [
+              {
+                role: "user",
+                parts: [
+                  {
+                    text: "Please provide the final result now and stop calling tools."
+                  }
+                ]
+              }
+            ];
+          }
         }
+        this.eventEmitter?.emit("round_end" /* ROUND_END */, {
+          subagentId: this.subagentId,
+          round: turnCounter,
+          promptId,
+          timestamp: Date.now()
+        });
+      } finally {
+        roundAbortController.abort();
       }
-      this.eventEmitter?.emit("round_end" /* ROUND_END */, {
-        subagentId: this.subagentId,
-        round: turnCounter,
-        promptId,
-        timestamp: Date.now()
-      });
-      abortController.signal.removeEventListener("abort", onParentAbort);
     }
     return {
       text: finalText,
@@ -50128,12 +50198,7 @@ ${text}` : text;
       if (!options2.shouldWaitForExternalMessages?.()) {
         return { inputs: [] };
       }
-      const waitAbortController = new AbortController();
-      const onAbort = /* @__PURE__ */ __name(() => waitAbortController.abort(), "onAbort");
-      abortController.signal.addEventListener("abort", onAbort, { once: true });
-      if (abortController.signal.aborted) {
-        waitAbortController.abort();
-      }
+      const waitAbortController = createChildAbortController(abortController);
       let timedOut = false;
       let timeout;
       if (remainingTimeMs !== void 0) {
@@ -50169,7 +50234,7 @@ ${text}` : text;
         throw error;
       } finally {
         if (timeout) clearTimeout(timeout);
-        abortController.signal.removeEventListener("abort", onAbort);
+        waitAbortController.abort();
       }
     }
   }
@@ -50420,12 +50485,15 @@ ${text}` : text;
         }
       }, "onAbort");
       abortController.signal.addEventListener("abort", onAbort, { once: true });
-      if (abortController.signal.aborted) {
-        onAbort();
+      try {
+        if (abortController.signal.aborted) {
+          onAbort();
+        }
+        await scheduler.schedule(requests, abortController.signal);
+        await batchDone;
+      } finally {
+        abortController.signal.removeEventListener("abort", onAbort);
       }
-      await scheduler.schedule(requests, abortController.signal);
-      await batchDone;
-      abortController.signal.removeEventListener("abort", onAbort);
     }
     if (functionCalls.length > 0 && toolResponseParts.length === 0) {
       toolResponseParts.push({
@@ -55625,8 +55693,8 @@ async function writeWorktreeSessionMarker(worktreePath, sessionId) {
     }
     const rule = WORKTREE_SESSION_FILE;
     if (!existing.split(/\r?\n/).includes(rule)) {
-      const sep17 = existing.length === 0 || existing.endsWith("\n") ? "" : "\n";
-      await fs15.writeFile(excludePath, `${existing}${sep17}${rule}
+      const sep16 = existing.length === 0 || existing.endsWith("\n") ? "" : "\n";
+      await fs15.writeFile(excludePath, `${existing}${sep16}${rule}
 `, "utf8");
     }
   } catch {
@@ -57097,8 +57165,8 @@ var WorkspaceContext = class _WorkspaceContext {
   }
 };
 function isPathWithinRoot(pathToCheck, rootDirectory) {
-  const relative13 = path19.relative(rootDirectory, pathToCheck);
-  return !relative13.startsWith(`..${path19.sep}`) && relative13 !== ".." && !path19.isAbsolute(relative13);
+  const relative12 = path19.relative(rootDirectory, pathToCheck);
+  return !relative12.startsWith(`..${path19.sep}`) && relative12 !== ".." && !path19.isAbsolute(relative12);
 }
 __name(isPathWithinRoot, "isPathWithinRoot");
 
@@ -60505,7 +60573,7 @@ var AgentInteractive = class {
   error;
   lastRoundError;
   executionPromise;
-  masterAbortController = new AbortController();
+  masterAbortController = createAbortController();
   roundAbortController;
   chat;
   toolsList = [];
@@ -60586,12 +60654,9 @@ var AgentInteractive = class {
     this.setStatus("running" /* RUNNING */);
     this.lastRoundError = void 0;
     this.roundCancelledByUser = false;
-    this.roundAbortController = new AbortController();
-    const onMasterAbort = /* @__PURE__ */ __name(() => this.roundAbortController?.abort(), "onMasterAbort");
-    this.masterAbortController.signal.addEventListener("abort", onMasterAbort);
-    if (this.masterAbortController.signal.aborted) {
-      this.roundAbortController.abort();
-    }
+    this.roundAbortController = createChildAbortController(
+      this.masterAbortController
+    );
     try {
       const initialMessages = [
         { role: "user", parts: [{ text: message }] }
@@ -60620,10 +60685,7 @@ var AgentInteractive = class {
       debugLogger33.error("AgentInteractive round error:", err2);
       this.addMessage("info", errorMessage, { metadata: { level: "error" } });
     } finally {
-      this.masterAbortController.signal.removeEventListener(
-        "abort",
-        onMasterAbort
-      );
+      this.roundAbortController?.abort();
       this.roundAbortController = void 0;
     }
   }
@@ -66667,6 +66729,7 @@ init_esbuild_shims();
 import * as path28 from "node:path";
 import * as fs30 from "node:fs/promises";
 var PROJECT_SKILLS_RELATIVE_DIR = path28.join(".qwen", "skills");
+var SKILL_FILE_NAME = "SKILL.md";
 function getProjectSkillsRoot(projectRoot) {
   return path28.join(projectRoot, PROJECT_SKILLS_RELATIVE_DIR);
 }
@@ -66778,8 +66841,7 @@ async function evaluateScopedDecision3(ctx, projectRoot) {
       }
       return "deny";
     }
-    case ToolNames.EDIT:
-    case ToolNames.WRITE_FILE: {
+    case ToolNames.EDIT: {
       if (!ctx.filePath || !isProjectSkillPath(ctx.filePath, projectRoot)) {
         return "deny";
       }
@@ -66794,6 +66856,26 @@ async function evaluateScopedDecision3(ctx, projectRoot) {
       }
       return sourceFlag ? "allow" : "deny";
     }
+    case ToolNames.WRITE_FILE: {
+      if (!ctx.filePath || !isProjectSkillPath(ctx.filePath, projectRoot)) {
+        return "deny";
+      }
+      if (path29.basename(ctx.filePath) !== SKILL_FILE_NAME) {
+        return "deny";
+      }
+      try {
+        await assertRealProjectSkillPath(ctx.filePath, projectRoot);
+      } catch {
+        return "deny";
+      }
+      try {
+        await fs31.stat(ctx.filePath);
+        return "deny";
+      } catch (err2) {
+        if (err2.code === "ENOENT") return "allow";
+        return "deny";
+      }
+    }
     default:
       return "default";
   }
@@ -66808,7 +66890,7 @@ function getScopedDenyRule3(ctx, projectRoot) {
     case ToolNames.EDIT:
       return `ManagedSkillReview(edit: only within ${getProjectSkillsRoot(projectRoot)} and only on skills with 'source: auto-skill' in frontmatter)`;
     case ToolNames.WRITE_FILE:
-      return `ManagedSkillReview(write_file: only within ${getProjectSkillsRoot(projectRoot)}; existing files must have 'source: auto-skill' in frontmatter)`;
+      return `ManagedSkillReview(write_file: only within ${getProjectSkillsRoot(projectRoot)} and only to a path that does not yet exist \u2014 use a different skill name like \`<name>-2\`, or use \`edit\` to update an existing auto-skill)`;
     default:
       return void 0;
   }
@@ -66877,10 +66959,36 @@ function buildAgentHistory2(history) {
   ];
 }
 __name(buildAgentHistory2, "buildAgentHistory");
-function buildTaskPrompt2(skillsRoot) {
+async function listExistingSkillDirNames(projectRoot) {
+  const skillsRoot = getProjectSkillsRoot(projectRoot);
+  let entries;
+  try {
+    entries = await fs31.readdir(skillsRoot, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const names = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+    try {
+      await fs31.stat(path29.join(skillsRoot, entry.name, SKILL_FILE_NAME));
+      names.push(entry.name);
+    } catch {
+    }
+  }
+  names.sort();
+  return names;
+}
+__name(listExistingSkillDirNames, "listExistingSkillDirNames");
+async function buildTaskPrompt2(projectRoot) {
+  const skillsRoot = getProjectSkillsRoot(projectRoot);
+  const existing = await listExistingSkillDirNames(projectRoot);
+  const existingLine = existing.length === 0 ? "(no skills exist yet \u2014 any name is available)" : `Existing skill names (do NOT reuse for write_file; use \`edit\` if you want to update one of these): ${existing.join(", ")}`;
   return [
     `Project skills directory: \`${skillsRoot}\``,
     "",
+    existingLine,
+    "",
     "Use `ls` and `read_file` to inspect existing skills before writing.",
     "Use `write_file` to create a new skill, `edit` to update an existing auto-skill.",
     "Each skill lives at .qwen/skills/<name>/SKILL.md. Skills you create MUST include 'source: auto-skill' in the frontmatter:",
@@ -66897,7 +67005,6 @@ function buildTaskPrompt2(skillsRoot) {
 }
 __name(buildTaskPrompt2, "buildTaskPrompt");
 async function runSkillReviewByAgent(params) {
-  const skillsRoot = getProjectSkillsRoot(params.projectRoot);
   const scopedConfig = createSkillScopedAgentConfig(
     params.config,
     params.projectRoot
@@ -66905,7 +67012,7 @@ async function runSkillReviewByAgent(params) {
   const result = await runForkedAgent({
     name: SKILL_REVIEW_AGENT_NAME,
     config: scopedConfig,
-    taskPrompt: buildTaskPrompt2(skillsRoot),
+    taskPrompt: await buildTaskPrompt2(params.projectRoot),
     systemPrompt: SKILL_REVIEW_SYSTEM_PROMPT,
     maxTurns: params.maxTurns ?? DEFAULT_AUTO_SKILL_MAX_TURNS,
     maxTimeMinutes: (params.timeoutMs ?? DEFAULT_AUTO_SKILL_TIMEOUT_MS) / 6e4,
@@ -69279,16 +69386,16 @@ import {
   mkdir as mkdir6,
   open as open2,
   readFile as readFile15,
-  stat as stat6,
+  stat as stat7,
   unlink as unlink4
 } from "node:fs/promises";
-import { dirname as dirname9, isAbsolute as isAbsolute6, join as join20, relative as relative5, sep as sep9 } from "node:path";
+import { dirname as dirname9, isAbsolute as isAbsolute6, join as join21, relative as relative5, sep as sep9 } from "node:path";
 
 // packages/core/src/utils/gitDiff.ts
 init_esbuild_shims();
 import { execFile as execFile2 } from "node:child_process";
 import * as nodeFs from "node:fs";
-import { access as access3, lstat as lstat3, open, readFile as readFile14, stat as stat5 } from "node:fs/promises";
+import { access as access3, lstat as lstat3, open, readFile as readFile14, stat as stat6 } from "node:fs/promises";
 import * as path31 from "node:path";
 import { promisify as promisify2 } from "node:util";
 var execFileAsync2 = promisify2(execFile2);
@@ -69764,7 +69871,7 @@ __name(resolveGitDir, "resolveGitDir");
 async function resolveGitDirFromRoot(gitRoot) {
   const dotGit = path31.join(gitRoot, ".git");
   try {
-    const s = await stat5(dotGit);
+    const s = await stat6(dotGit);
     if (s.isDirectory()) return dotGit;
     if (!s.isFile()) return null;
     const content = await readFile14(dotGit, "utf8");
@@ -69838,7 +69945,7 @@ function isENOENT(e) {
 __name(isENOENT, "isENOENT");
 async function pathExists(filePath) {
   try {
-    await stat6(filePath);
+    await stat7(filePath);
     return true;
   } catch {
     return false;
@@ -69859,7 +69966,7 @@ function getBackupFileName(filePath, version) {
 }
 __name(getBackupFileName, "getBackupFileName");
 function resolveBackupPath(backupFileName, sessionId) {
-  return join20(
+  return join21(
     Storage.getGlobalQwenDir(),
     FILE_HISTORY_DIR,
     sessionId,
@@ -69885,7 +69992,7 @@ async function createBackup(filePath, version, sessionId) {
   const backupPath = resolveBackupPath(backupFileName, sessionId);
   let srcStats;
   try {
-    srcStats = await stat6(filePath);
+    srcStats = await stat7(filePath);
   } catch (e) {
     if (isENOENT(e)) {
       return { backupFileName: null, version, backupTime: /* @__PURE__ */ new Date() };
@@ -69904,7 +70011,7 @@ async function restoreBackup(filePath, backupFileName, sessionId) {
   const backupPath = resolveBackupPath(backupFileName, sessionId);
   let backupStats;
   try {
-    backupStats = await stat6(backupPath);
+    backupStats = await stat7(backupPath);
   } catch (e) {
     if (isENOENT(e)) {
       debugLogger44.error(`FileHistory: Backup file not found: ${backupPath}`);
@@ -69928,14 +70035,14 @@ async function checkOriginFileChanged(originalFile, backupFileName, sessionId, o
   let originalStats = originalStatsHint ?? null;
   if (!originalStats) {
     try {
-      originalStats = await stat6(originalFile);
+      originalStats = await stat7(originalFile);
     } catch (e) {
       if (!isENOENT(e)) return true;
     }
   }
   let backupStats;
   try {
-    backupStats = await stat6(backupPath);
+    backupStats = await stat7(backupPath);
   } catch {
     return true;
   }
@@ -70128,7 +70235,7 @@ var FileHistoryService = class {
             const nextVersion = this.getMaxVersion(trackingPath) + 1;
             let fileStats;
             try {
-              fileStats = await stat6(filePath);
+              fileStats = await stat7(filePath);
             } catch (e) {
               if (!isENOENT(e)) throw e;
             }
@@ -70564,7 +70671,7 @@ var FileHistoryService = class {
   }
   maybeExpandFilePath(filePath) {
     if (isAbsolute6(filePath)) return filePath;
-    return join20(this.cwd, filePath);
+    return join21(this.cwd, filePath);
   }
 };
 
@@ -73323,7 +73430,7 @@ import { posix as posix3, win32 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { lstatSync, readdir as readdirCB, readdirSync, readlinkSync as readlinkSync2, realpathSync as rps } from "fs";
 import * as actualFS from "node:fs";
-import { lstat as lstat4, readdir as readdir6, readlink as readlink2, realpath as realpath3 } from "node:fs/promises";
+import { lstat as lstat4, readdir as readdir7, readlink as readlink2, realpath as realpath3 } from "node:fs/promises";
 
 // node_modules/minipass/dist/esm/index.js
 init_esbuild_shims();
@@ -74223,7 +74330,7 @@ var defaultFS = {
   realpathSync: realpathSync4,
   promises: {
     lstat: lstat4,
-    readdir: readdir6,
+    readdir: readdir7,
     readlink: readlink2,
     realpath: realpath3
   }
@@ -75348,7 +75455,7 @@ var PathScurryBase = class {
    *
    * @internal
    */
-  constructor(cwd2 = process.cwd(), pathImpl, sep17, { nocase, childrenCacheSize = 16 * 1024, fs: fs81 = defaultFS } = {}) {
+  constructor(cwd2 = process.cwd(), pathImpl, sep16, { nocase, childrenCacheSize = 16 * 1024, fs: fs81 = defaultFS } = {}) {
     this.#fs = fsFromOption(fs81);
     if (cwd2 instanceof URL || cwd2.startsWith("file://")) {
       cwd2 = fileURLToPath3(cwd2);
@@ -75359,7 +75466,7 @@ var PathScurryBase = class {
     this.#resolveCache = new ResolveCache();
     this.#resolvePosixCache = new ResolveCache();
     this.#children = new ChildrenCache(childrenCacheSize);
-    const split = cwdPath.substring(this.rootPath.length).split(sep17);
+    const split = cwdPath.substring(this.rootPath.length).split(sep16);
     if (split.length === 1 && !split[0]) {
       split.pop();
     }
@@ -76200,10 +76307,10 @@ var Ignore = class {
   ignored(p) {
     const fullpath = p.fullpath();
     const fullpaths = `${fullpath}/`;
-    const relative13 = p.relative() || ".";
-    const relatives = `${relative13}/`;
+    const relative12 = p.relative() || ".";
+    const relatives = `${relative12}/`;
     for (const m of this.relative) {
-      if (m.match(relative13) || m.match(relatives))
+      if (m.match(relative12) || m.match(relatives))
         return true;
     }
     for (const m of this.absolute) {
@@ -76214,9 +76321,9 @@ var Ignore = class {
   }
   childrenIgnored(p) {
     const fullpath = p.fullpath() + "/";
-    const relative13 = (p.relative() || ".") + "/";
+    const relative12 = (p.relative() || ".") + "/";
     for (const m of this.relativeChildren) {
-      if (m.match(relative13))
+      if (m.match(relative12))
         return true;
     }
     for (const m of this.absoluteChildren) {
@@ -78410,7 +78517,7 @@ var SdkControlClientTransport = class {
 
 // packages/core/src/tools/mcp-client.ts
 import { existsSync as existsSync6 } from "node:fs";
-import { basename as basename7 } from "node:path";
+import { basename as basename8 } from "node:path";
 import { pathToFileURL } from "node:url";
 
 // packages/core/src/mcp/oauth-provider.ts
@@ -79989,7 +80096,7 @@ var McpClient = class {
         for (const dir of this.workspaceContext.getDirectories()) {
           roots.push({
             uri: pathToFileURL(dir).toString(),
-            name: basename7(dir)
+            name: basename8(dir)
           });
         }
         return {
@@ -80458,7 +80565,7 @@ async function connectToMcpServer(mcpServerName, mcpServerConfig, debugMode, wor
     for (const dir of workspaceContext.getDirectories()) {
       roots.push({
         uri: pathToFileURL(dir).toString(),
-        name: basename7(dir)
+        name: basename8(dir)
       });
     }
     return {
@@ -83050,13 +83157,13 @@ import * as os9 from "os";
 // node_modules/chokidar/esm/index.js
 init_esbuild_shims();
 import { stat as statcb } from "fs";
-import { stat as stat10, readdir as readdir9 } from "fs/promises";
+import { stat as stat11, readdir as readdir10 } from "fs/promises";
 import { EventEmitter as EventEmitter5 } from "events";
 import * as sysPath2 from "path";
 
 // node_modules/readdirp/esm/index.js
 init_esbuild_shims();
-import { stat as stat8, lstat as lstat5, readdir as readdir8, realpath as realpath4 } from "node:fs/promises";
+import { stat as stat9, lstat as lstat5, readdir as readdir9, realpath as realpath4 } from "node:fs/promises";
 import { Readable } from "node:stream";
 import { resolve as presolve, relative as prelative, join as pjoin, sep as psep } from "node:path";
 var EntryTypes = {
@@ -83126,7 +83233,7 @@ var ReaddirpStream = class extends Readable {
     const { root, type } = opts;
     this._fileFilter = normalizeFilter(opts.fileFilter);
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
-    const statMethod = opts.lstat ? lstat5 : stat8;
+    const statMethod = opts.lstat ? lstat5 : stat9;
     if (wantBigintFsStats) {
       this._stat = (path84) => statMethod(path84, { bigint: true });
     } else {
@@ -83197,7 +83304,7 @@ var ReaddirpStream = class extends Readable {
   async _exploreDir(path84, depth) {
     let files;
     try {
-      files = await readdir8(path84, this._rdOptions);
+      files = await readdir9(path84, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
@@ -83205,10 +83312,10 @@ var ReaddirpStream = class extends Readable {
   }
   async _formatEntry(dirent, path84) {
     let entry;
-    const basename17 = this._isDirent ? dirent.name : dirent;
+    const basename18 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path84, basename17));
-      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename17 };
+      const fullPath = presolve(pjoin(path84, basename18));
+      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename18 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err2) {
       this._onError(err2);
@@ -83281,7 +83388,7 @@ __name(readdirp, "readdirp");
 // node_modules/chokidar/esm/handler.js
 init_esbuild_shims();
 import { watchFile, unwatchFile, watch as fs_watch } from "fs";
-import { open as open3, stat as stat9, lstat as lstat6, realpath as fsrealpath } from "fs/promises";
+import { open as open3, stat as stat10, lstat as lstat6, realpath as fsrealpath } from "fs/promises";
 import * as sysPath from "path";
 import { type as osType } from "os";
 var STR_DATA = "data";
@@ -83308,7 +83415,7 @@ var EVENTS = {
 };
 var EV = EVENTS;
 var THROTTLE_MODE_WATCH = "watch";
-var statMethods = { lstat: lstat6, stat: stat9 };
+var statMethods = { lstat: lstat6, stat: stat10 };
 var KEY_LISTENERS = "listeners";
 var KEY_ERR = "errHandlers";
 var KEY_RAW = "rawEmitters";
@@ -83753,9 +83860,9 @@ var NodeFsHandler = class {
   _watchWithNodeFs(path84, listener) {
     const opts = this.fsw.options;
     const directory = sysPath.dirname(path84);
-    const basename17 = sysPath.basename(path84);
+    const basename18 = sysPath.basename(path84);
     const parent = this.fsw._getWatchedDir(directory);
-    parent.add(basename17);
+    parent.add(basename18);
     const absolutePath = sysPath.resolve(path84);
     const options2 = {
       persistent: opts.persistent
@@ -83765,7 +83872,7 @@ var NodeFsHandler = class {
     let closer;
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
-      options2.interval = enableBin && isBinaryPath(basename17) ? opts.binaryInterval : opts.interval;
+      options2.interval = enableBin && isBinaryPath(basename18) ? opts.binaryInterval : opts.interval;
       closer = setFsWatchFileListener(path84, absolutePath, options2, {
         listener,
         rawEmitter: this.fsw._emitRaw
@@ -83788,17 +83895,17 @@ var NodeFsHandler = class {
       return;
     }
     const dirname29 = sysPath.dirname(file);
-    const basename17 = sysPath.basename(file);
+    const basename18 = sysPath.basename(file);
     const parent = this.fsw._getWatchedDir(dirname29);
     let prevStats = stats;
-    if (parent.has(basename17))
+    if (parent.has(basename18))
       return;
     const listener = /* @__PURE__ */ __name(async (path84, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
         try {
-          const newStats2 = await stat9(file);
+          const newStats2 = await stat10(file);
           if (this.fsw.closed)
             return;
           const at = newStats2.atimeMs;
@@ -83816,9 +83923,9 @@ var NodeFsHandler = class {
             prevStats = newStats2;
           }
         } catch (error) {
-          this.fsw._remove(dirname29, basename17);
+          this.fsw._remove(dirname29, basename18);
         }
-      } else if (parent.has(basename17)) {
+      } else if (parent.has(basename18)) {
         const at = newStats.atimeMs;
         const mt = newStats.mtimeMs;
         if (!at || at <= mt || mt !== prevStats.mtimeMs) {
@@ -84066,11 +84173,11 @@ function createPattern(matcher) {
       if (matcher.path === string2)
         return true;
       if (matcher.recursive) {
-        const relative13 = sysPath2.relative(matcher.path, string2);
-        if (!relative13) {
+        const relative12 = sysPath2.relative(matcher.path, string2);
+        if (!relative12) {
           return false;
         }
-        return !relative13.startsWith("..") && !sysPath2.isAbsolute(relative13);
+        return !relative12.startsWith("..") && !sysPath2.isAbsolute(relative12);
       }
       return false;
     };
@@ -84180,7 +84287,7 @@ var DirEntry = class {
       return;
     const dir = this.path;
     try {
-      await readdir9(dir);
+      await readdir10(dir);
     } catch (err2) {
       if (this._removeWatcher) {
         this._removeWatcher(sysPath2.dirname(dir), sysPath2.basename(dir));
@@ -84511,7 +84618,7 @@ var FSWatcher = class extends EventEmitter5 {
       const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path84) : path84;
       let stats2;
       try {
-        stats2 = await stat10(fullPath);
+        stats2 = await stat11(fullPath);
       } catch (err2) {
       }
       if (!stats2 || this.closed)
@@ -84639,8 +84746,8 @@ var FSWatcher = class extends EventEmitter5 {
     }
     return this._userIgnored(path84, stats);
   }
-  _isntIgnored(path84, stat15) {
-    return !this._isIgnored(path84, stat15);
+  _isntIgnored(path84, stat16) {
+    return !this._isIgnored(path84, stat16);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
@@ -91712,7 +91819,7 @@ var encString = /* @__PURE__ */ __name((buf, off, size, str) => str === void 0 ?
 
 // node_modules/tar/dist/esm/pax.js
 init_esbuild_shims();
-import { basename as basename11 } from "node:path";
+import { basename as basename12 } from "node:path";
 var Pax = class _Pax {
   static {
     __name(this, "Pax");
@@ -91768,7 +91875,7 @@ var Pax = class _Pax {
       // then the path should be PaxHeader + basename, but less than 99,
       // prepend with the dirname
       /* c8 ignore start */
-      path: ("PaxHeader/" + basename11(this.path ?? "")).slice(0, 99),
+      path: ("PaxHeader/" + basename12(this.path ?? "")).slice(0, 99),
       /* c8 ignore stop */
       mode: this.mode || 420,
       uid: this.uid,
@@ -92521,16 +92628,16 @@ var listFileSync = /* @__PURE__ */ __name((opt) => {
   let fd;
   try {
     fd = fs43.openSync(file, "r");
-    const stat15 = fs43.fstatSync(fd);
+    const stat16 = fs43.fstatSync(fd);
     const readSize = opt.maxReadSize || 16 * 1024 * 1024;
-    if (stat15.size < readSize) {
-      const buf = Buffer.allocUnsafe(stat15.size);
-      const read3 = fs43.readSync(fd, buf, 0, stat15.size, 0);
+    if (stat16.size < readSize) {
+      const buf = Buffer.allocUnsafe(stat16.size);
+      const read3 = fs43.readSync(fd, buf, 0, stat16.size, 0);
       p.end(read3 === buf.byteLength ? buf : buf.subarray(0, read3));
     } else {
       let pos2 = 0;
       const buf = Buffer.allocUnsafe(readSize);
-      while (pos2 < stat15.size) {
+      while (pos2 < stat16.size) {
         const bytesRead = fs43.readSync(fd, buf, 0, readSize, pos2);
         if (bytesRead === 0)
           break;
@@ -92555,13 +92662,13 @@ var listFile = /* @__PURE__ */ __name((opt, _files) => {
   const p = new Promise((resolve31, reject) => {
     parse14.on("error", reject);
     parse14.on("end", resolve31);
-    fs43.stat(file, (er, stat15) => {
+    fs43.stat(file, (er, stat16) => {
       if (er) {
         reject(er);
       } else {
         const stream2 = new ReadStream(file, {
           readSize,
-          size: stat15.size
+          size: stat16.size
         });
         stream2.on("error", reject);
         stream2.pipe(parse14);
@@ -92753,21 +92860,21 @@ var WriteEntry = class extends Minipass {
     return super.emit(ev, ...data);
   }
   [LSTAT]() {
-    fs44.lstat(this.absolute, (er, stat15) => {
+    fs44.lstat(this.absolute, (er, stat16) => {
       if (er) {
         return this.emit("error", er);
       }
-      this[ONLSTAT](stat15);
+      this[ONLSTAT](stat16);
     });
   }
-  [ONLSTAT](stat15) {
-    this.statCache.set(this.absolute, stat15);
-    this.stat = stat15;
-    if (!stat15.isFile()) {
-      stat15.size = 0;
+  [ONLSTAT](stat16) {
+    this.statCache.set(this.absolute, stat16);
+    this.stat = stat16;
+    if (!stat16.isFile()) {
+      stat16.size = 0;
     }
-    this.type = getType(stat15);
-    this.emit("stat", stat15);
+    this.type = getType(stat16);
+    this.emit("stat", stat16);
     this[PROCESS2]();
   }
   [PROCESS2]() {
@@ -93217,7 +93324,7 @@ var WriteEntryTar = class extends Minipass {
     return this;
   }
 };
-var getType = /* @__PURE__ */ __name((stat15) => stat15.isFile() ? "File" : stat15.isDirectory() ? "Directory" : stat15.isSymbolicLink() ? "SymbolicLink" : "Unsupported", "getType");
+var getType = /* @__PURE__ */ __name((stat16) => stat16.isFile() ? "File" : stat16.isDirectory() ? "Directory" : stat16.isSymbolicLink() ? "SymbolicLink" : "Unsupported", "getType");
 
 // node_modules/yallist/dist/esm/index.js
 init_esbuild_shims();
@@ -93798,21 +93905,21 @@ var Pack = class extends Minipass {
   [STAT](job) {
     job.pending = true;
     this[JOBS] += 1;
-    const stat15 = this.follow ? "stat" : "lstat";
-    fs45[stat15](job.absolute, (er, stat16) => {
+    const stat16 = this.follow ? "stat" : "lstat";
+    fs45[stat16](job.absolute, (er, stat17) => {
       job.pending = false;
       this[JOBS] -= 1;
       if (er) {
         this.emit("error", er);
       } else {
-        this[ONSTAT](job, stat16);
+        this[ONSTAT](job, stat17);
       }
     });
   }
-  [ONSTAT](job, stat15) {
-    this.statCache.set(job.absolute, stat15);
-    job.stat = stat15;
-    if (!this.filter(job.path, stat15)) {
+  [ONSTAT](job, stat16) {
+    this.statCache.set(job.absolute, stat16);
+    job.stat = stat16;
+    if (!this.filter(job.path, stat16)) {
       job.ignore = true;
     }
     this[PROCESS3]();
@@ -93994,8 +94101,8 @@ var PackSync = class extends Pack {
   resume() {
   }
   [STAT](job) {
-    const stat15 = this.follow ? "statSync" : "lstatSync";
-    this[ONSTAT](job, fs45[stat15](job.absolute));
+    const stat16 = this.follow ? "statSync" : "lstatSync";
+    this[ONSTAT](job, fs45[stat16](job.absolute));
   }
   [READDIR](job) {
     this[ONREADDIR](job, fs45.readdirSync(job.absolute));
@@ -94392,7 +94499,7 @@ var mkdirSync2 = /* @__PURE__ */ __name((dir, opt) => {
 
 // node_modules/tar/dist/esm/path-reservations.js
 init_esbuild_shims();
-import { join as join30 } from "node:path";
+import { join as join31 } from "node:path";
 
 // node_modules/tar/dist/esm/normalize-unicode.js
 init_esbuild_shims();
@@ -94426,7 +94533,7 @@ var getDirs = /* @__PURE__ */ __name((path84) => {
   const dirs = path84.split("/").slice(0, -1).reduce((set, path85) => {
     const s = set[set.length - 1];
     if (s !== void 0) {
-      path85 = join30(s, path85);
+      path85 = join31(s, path85);
     }
     set.push(path85 || "/");
     return set;
@@ -94447,7 +94554,7 @@ var PathReservations = class {
   #running = /* @__PURE__ */ new Set();
   reserve(paths, fn) {
     paths = isWindows3 ? ["win32 parallelization disabled"] : paths.map((p) => {
-      return stripTrailingSlashes(join30(normalizeUnicode(p))).toLowerCase();
+      return stripTrailingSlashes(join31(normalizeUnicode(p))).toLowerCase();
     });
     const dirs = new Set(paths.map((path84) => getDirs(path84)).reduce((a, b) => a.concat(b)));
     this.#reservations.set(fn, { dirs, paths });
@@ -95231,11 +95338,11 @@ var UnpackSync = class extends Unpack {
 var extractFileSync = /* @__PURE__ */ __name((opt) => {
   const u = new UnpackSync(opt);
   const file = opt.file;
-  const stat15 = fs50.statSync(file);
+  const stat16 = fs50.statSync(file);
   const readSize = opt.maxReadSize || 16 * 1024 * 1024;
   const stream2 = new ReadStreamSync(file, {
     readSize,
-    size: stat15.size
+    size: stat16.size
   });
   stream2.pipe(u);
 }, "extractFileSync");
@@ -95246,13 +95353,13 @@ var extractFile = /* @__PURE__ */ __name((opt, _) => {
   const p = new Promise((resolve31, reject) => {
     u.on("error", reject);
     u.on("close", resolve31);
-    fs50.stat(file, (er, stat15) => {
+    fs50.stat(file, (er, stat16) => {
       if (er) {
         reject(er);
       } else {
         const stream2 = new ReadStream(file, {
           readSize,
-          size: stat15.size
+          size: stat16.size
         });
         stream2.on("error", reject);
         stream2.pipe(u);
@@ -95479,9 +95586,9 @@ var mtimeFilter = /* @__PURE__ */ __name((opt) => {
   if (!opt.mtimeCache) {
     opt.mtimeCache = /* @__PURE__ */ new Map();
   }
-  opt.filter = filter3 ? (path84, stat15) => filter3(path84, stat15) && !/* c8 ignore start */
-  ((opt.mtimeCache?.get(path84) ?? stat15.mtime ?? 0) > (stat15.mtime ?? 0)) : (path84, stat15) => !/* c8 ignore start */
-  ((opt.mtimeCache?.get(path84) ?? stat15.mtime ?? 0) > (stat15.mtime ?? 0));
+  opt.filter = filter3 ? (path84, stat16) => filter3(path84, stat16) && !/* c8 ignore start */
+  ((opt.mtimeCache?.get(path84) ?? stat16.mtime ?? 0) > (stat16.mtime ?? 0)) : (path84, stat16) => !/* c8 ignore start */
+  ((opt.mtimeCache?.get(path84) ?? stat16.mtime ?? 0) > (stat16.mtime ?? 0));
 }, "mtimeFilter");
 
 // packages/core/src/extension/github.ts
@@ -96726,17 +96833,10 @@ async function collectResources(resourcePaths, pluginRoot, destDir) {
       debugLogger68.warn(`Resource path not found: ${resolvedPath}`);
       continue;
     }
-    const stat15 = fs56.statSync(resolvedPath);
-    if (stat15.isDirectory()) {
+    const stat16 = fs56.statSync(resolvedPath);
+    if (stat16.isDirectory()) {
       const dirName = path57.basename(resolvedPath);
-      const parentDir = path57.dirname(resolvedPath);
-      if (dirName === destFolderName && parentDir === pluginRoot) {
-        debugLogger68.debug(
-          `Skipping ${resolvedPath} as it's already in the correct location`
-        );
-        continue;
-      }
-      const finalDestDir = path57.join(destDir, dirName);
+      const finalDestDir = dirName === destFolderName ? destDir : path57.join(destDir, dirName);
       const files = await glob("**/*", {
         cwd: resolvedPath,
         nodir: true,
@@ -96762,14 +96862,6 @@ async function collectResources(resourcePaths, pluginRoot, destDir) {
         fs56.copyFileSync(srcFile, destFile);
       }
     } else {
-      const relativePath = path57.relative(pluginRoot, resolvedPath);
-      const segments = relativePath.split(path57.sep);
-      if (segments.length > 0 && segments[0] === destFolderName) {
-        debugLogger68.debug(
-          `Skipping ${resolvedPath} as it's already in ${destFolderName}/`
-        );
-        continue;
-      }
       const fileName = path57.basename(resolvedPath);
       const destFile = path57.join(destDir, fileName);
       fs56.copyFileSync(resolvedPath, destFile);
@@ -98612,42 +98704,6 @@ var UrlValidator = class {
   }
 };
 
-// packages/core/src/hooks/combinedAbortSignal.ts
-init_esbuild_shims();
-function createCombinedAbortSignal(externalSignal, options2) {
-  const controller = new AbortController();
-  const timeoutMs = options2?.timeoutMs;
-  let timeoutId;
-  if (timeoutMs !== void 0 && timeoutMs > 0) {
-    timeoutId = setTimeout(() => {
-      controller.abort();
-    }, timeoutMs);
-  }
-  let abortHandler;
-  if (externalSignal) {
-    if (externalSignal.aborted) {
-      controller.abort();
-    } else {
-      abortHandler = /* @__PURE__ */ __name(() => {
-        controller.abort();
-      }, "abortHandler");
-      externalSignal.addEventListener("abort", abortHandler, { once: true });
-    }
-  }
-  const cleanup = /* @__PURE__ */ __name(() => {
-    if (timeoutId !== void 0) {
-      clearTimeout(timeoutId);
-      timeoutId = void 0;
-    }
-    if (externalSignal && abortHandler) {
-      externalSignal.removeEventListener("abort", abortHandler);
-      abortHandler = void 0;
-    }
-  }, "cleanup");
-  return { signal: controller.signal, cleanup };
-}
-__name(createCombinedAbortSignal, "createCombinedAbortSignal");
-
 // packages/core/src/hooks/httpHookRunner.ts
 import { lookup as dnsLookup } from "dns";
 var debugLogger73 = createDebugLogger("HTTP_HOOK_RUNNER");
@@ -98770,8 +98826,8 @@ var HttpHookRunner = class {
         hook_event_name: eventName
       });
       const timeout = hookConfig.timeout ? hookConfig.timeout * 1e3 : DEFAULT_HTTP_TIMEOUT;
-      const { signal: combinedSignal, cleanup } = createCombinedAbortSignal(
-        signal,
+      const { signal: combinedSignal, cleanup } = combineAbortSignals(
+        [signal],
         { timeoutMs: timeout }
       );
       try {
@@ -99100,7 +99156,7 @@ var FunctionHookRunner = class {
           abortHandler = /* @__PURE__ */ __name(() => {
             reject(new Error("Function hook execution aborted"));
           }, "abortHandler");
-          signal.addEventListener("abort", abortHandler);
+          signal.addEventListener("abort", abortHandler, { once: true });
         }
       });
       const promises8 = [callback(input, context), timeoutPromise];
@@ -99272,17 +99328,8 @@ ${processedPrompt}`);
         parts: [{ text: prompt }]
       }
     ];
-    const internalAbortController = new AbortController();
+    const internalAbortController = createChildAbortController(signal);
     const internalSignal = internalAbortController.signal;
-    if (signal) {
-      if (signal.aborted) {
-        internalAbortController.abort();
-      } else {
-        signal.addEventListener("abort", () => {
-          internalAbortController.abort();
-        });
-      }
-    }
     let timeoutId;
     const timeoutPromise = new Promise((_, reject) => {
       timeoutId = setTimeout(() => {
@@ -99340,6 +99387,7 @@ ${processedPrompt}`);
       if (timeoutId) {
         clearTimeout(timeoutId);
       }
+      internalAbortController.abort();
     }
   }
   /**
@@ -100120,7 +100168,7 @@ var HookRunner = class {
         killChild();
       }, "abortHandler");
       if (signal) {
-        signal.addEventListener("abort", abortHandler);
+        signal.addEventListener("abort", abortHandler, { once: true });
       }
       if (child.stdin) {
         child.stdin.on("error", (err2) => {
@@ -102033,7 +102081,7 @@ var MessageBus = class extends EventEmitter6 {
         reject(new Error("Request aborted"));
       }, "abortHandler");
       if (signal) {
-        signal.addEventListener("abort", abortHandler);
+        signal.addEventListener("abort", abortHandler, { once: true });
       }
       const responseHandler = /* @__PURE__ */ __name((response) => {
         if ("correlationId" in response && response.correlationId === correlationId) {
@@ -107723,19 +107771,19 @@ var Config = class {
     }, "registerStructuredOutputIfRequested");
     if (this.getBareMode()) {
       await registerLazy(ToolNames.READ_FILE, async () => {
-        const { ReadFileTool } = await import("./read-file-WSEYLDOV.js");
+        const { ReadFileTool } = await import("./read-file-5QUJ3ZIL.js");
         return new ReadFileTool(this);
       });
       await registerLazy(ToolNames.EDIT, async () => {
-        const { EditTool } = await import("./edit-UJMWLGYK.js");
+        const { EditTool } = await import("./edit-2CY35GKJ.js");
         return new EditTool(this);
       });
       await registerLazy(ToolNames.NOTEBOOK_EDIT, async () => {
-        const { NotebookEditTool } = await import("./notebook-edit-5SR3UTIM.js");
+        const { NotebookEditTool } = await import("./notebook-edit-RWOEUTYU.js");
         return new NotebookEditTool(this);
       });
       await registerLazy(ToolNames.SHELL, async () => {
-        const { ShellTool: ShellTool2 } = await import("./shell-JJBUJGJM.js");
+        const { ShellTool: ShellTool2 } = await import("./shell-DA54BZO2.js");
         return new ShellTool2(this);
       });
       await registerStructuredOutputIfRequested();
@@ -107745,11 +107793,11 @@ var Config = class {
       return registry;
     }
     await registerLazy(ToolNames.TOOL_SEARCH, async () => {
-      const { ToolSearchTool } = await import("./tool-search-VS4IMEQF.js");
+      const { ToolSearchTool } = await import("./tool-search-PONJXBSP.js");
       return new ToolSearchTool(this);
     });
     await registerLazy(ToolNames.AGENT, async () => {
-      const { AgentTool: AgentTool2 } = await import("./agent-B5PF5GU4.js");
+      const { AgentTool: AgentTool2 } = await import("./agent-KYFWAFRH.js");
       return new AgentTool2(this);
     });
     await registerLazy(ToolNames.TASK_STOP, async () => {
@@ -107761,7 +107809,7 @@ var Config = class {
       return new SendMessageTool(this);
     });
     await registerLazy(ToolNames.SKILL, async () => {
-      const { SkillTool } = await import("./skill-T3PI55OA.js");
+      const { SkillTool } = await import("./skill-47FZXDEM.js");
       return new SkillTool(this);
     });
     await registerLazy(ToolNames.LS, async () => {
@@ -107769,7 +107817,7 @@ var Config = class {
       return new LSTool(this);
     });
     await registerLazy(ToolNames.READ_FILE, async () => {
-      const { ReadFileTool } = await import("./read-file-WSEYLDOV.js");
+      const { ReadFileTool } = await import("./read-file-5QUJ3ZIL.js");
       return new ReadFileTool(this);
     });
     if (this.getUseRipgrep()) {
@@ -107782,7 +107830,7 @@ var Config = class {
       }
       if (useRipgrep) {
         await registerLazy(ToolNames.GREP, async () => {
-          const { RipGrepTool: RipGrepTool2 } = await import("./ripGrep-N67GL3K7.js");
+          const { RipGrepTool: RipGrepTool2 } = await import("./ripGrep-PA7M7MJS.js");
           return new RipGrepTool2(this);
         });
       } else {
@@ -107795,34 +107843,34 @@ var Config = class {
           )
         );
         await registerLazy(ToolNames.GREP, async () => {
-          const { GrepTool } = await import("./grep-NID7EZU4.js");
+          const { GrepTool } = await import("./grep-GKU7Y77F.js");
           return new GrepTool(this);
         });
       }
     } else {
       await registerLazy(ToolNames.GREP, async () => {
-        const { GrepTool } = await import("./grep-NID7EZU4.js");
+        const { GrepTool } = await import("./grep-GKU7Y77F.js");
         return new GrepTool(this);
       });
     }
     await registerLazy(ToolNames.GLOB, async () => {
-      const { GlobTool } = await import("./glob-WU4BIR7K.js");
+      const { GlobTool } = await import("./glob-C5ZNGH7V.js");
       return new GlobTool(this);
     });
     await registerLazy(ToolNames.EDIT, async () => {
-      const { EditTool } = await import("./edit-UJMWLGYK.js");
+      const { EditTool } = await import("./edit-2CY35GKJ.js");
       return new EditTool(this);
     });
     await registerLazy(ToolNames.NOTEBOOK_EDIT, async () => {
-      const { NotebookEditTool } = await import("./notebook-edit-5SR3UTIM.js");
+      const { NotebookEditTool } = await import("./notebook-edit-RWOEUTYU.js");
       return new NotebookEditTool(this);
     });
     await registerLazy(ToolNames.WRITE_FILE, async () => {
-      const { WriteFileTool } = await import("./write-file-IPYT4F3N.js");
+      const { WriteFileTool } = await import("./write-file-2YX4NB3B.js");
       return new WriteFileTool(this);
     });
     await registerLazy(ToolNames.SHELL, async () => {
-      const { ShellTool: ShellTool2 } = await import("./shell-JJBUJGJM.js");
+      const { ShellTool: ShellTool2 } = await import("./shell-DA54BZO2.js");
       return new ShellTool2(this);
     });
     await registerLazy(ToolNames.TODO_WRITE, async () => {
@@ -107835,16 +107883,16 @@ var Config = class {
     });
     if (!this.sdkMode) {
       await registerLazy(ToolNames.EXIT_PLAN_MODE, async () => {
-        const { ExitPlanModeTool } = await import("./exitPlanMode-Q43DRSNG.js");
+        const { ExitPlanModeTool } = await import("./exitPlanMode-3JP3BRRO.js");
         return new ExitPlanModeTool(this);
       });
     }
     await registerLazy(ToolNames.ENTER_WORKTREE, async () => {
-      const { EnterWorktreeTool } = await import("./enter-worktree-E2EUJPD3.js");
+      const { EnterWorktreeTool } = await import("./enter-worktree-HJGN4DH2.js");
       return new EnterWorktreeTool(this);
     });
     await registerLazy(ToolNames.EXIT_WORKTREE, async () => {
-      const { ExitWorktreeTool } = await import("./exit-worktree-I7UHJCUU.js");
+      const { ExitWorktreeTool } = await import("./exit-worktree-VAPX5N2E.js");
       return new ExitWorktreeTool(this);
     });
     await registerLazy(ToolNames.WEB_FETCH, async () => {
@@ -107873,7 +107921,7 @@ var Config = class {
       });
     }
     await registerLazy(ToolNames.MONITOR, async () => {
-      const { MonitorTool } = await import("./monitor-4M5UH7WX.js");
+      const { MonitorTool } = await import("./monitor-HJTGGH2N.js");
       return new MonitorTool(this);
     });
     if (this.pendingMcpBudgetCallback) {
@@ -108713,15 +108761,15 @@ var GrepToolInvocation = class extends BaseToolInvocation {
         const parts2 = [];
         let currentLength = 0;
         for (const line of linesToInclude) {
-          const sep17 = includedLines > 0 ? 1 : 0;
-          const projectedLength = currentLength + line.rawLine.length + sep17;
+          const sep16 = includedLines > 0 ? 1 : 0;
+          const projectedLength = currentLength + line.rawLine.length + sep16;
           if (projectedLength <= charLimit) {
             parts2.push(line.rawLine);
             visibleLines.push(line);
             includedLines++;
             currentLength = projectedLength;
           } else {
-            const remaining = Math.max(charLimit - currentLength - sep17, 10);
+            const remaining = Math.max(charLimit - currentLength - sep16, 10);
             const partialLine = line.rawLine.slice(0, remaining);
             parts2.push(partialLine + "...");
             visibleLines.push(line);
@@ -109259,9 +109307,31 @@ var TOKEN_PLAN_MODELS = [
     enableThinking: true,
     modalities: { image: true, video: true }
   },
-  { id: "deepseek-v3.2", contextWindowSize: 131072, enableThinking: true },
+  { id: "qwen3.7-max", contextWindowSize: 1e6, enableThinking: true },
+  {
+    id: "qwen3.6-flash",
+    contextWindowSize: 1e6,
+    enableThinking: true,
+    modalities: { image: true, video: true }
+  },
+  { id: "deepseek-v4-pro", contextWindowSize: 1e6 },
+  { id: "deepseek-v4-flash", contextWindowSize: 1e6 },
+  { id: "deepseek-v3.2", contextWindowSize: 131072 },
+  {
+    id: "kimi-k2.6",
+    contextWindowSize: 262144,
+    enableThinking: true,
+    modalities: { image: true, video: true }
+  },
+  {
+    id: "kimi-k2.5",
+    contextWindowSize: 262144,
+    enableThinking: true,
+    modalities: { image: true, video: true }
+  },
+  { id: "glm-5.1", contextWindowSize: 202752, enableThinking: true },
   { id: "glm-5", contextWindowSize: 202752, enableThinking: true },
-  { id: "MiniMax-M2.5", contextWindowSize: 196608, enableThinking: true }
+  { id: "MiniMax-M2.5", contextWindowSize: 196608 }
 ];
 var tokenPlanProvider = {
   id: "token-plan",
@@ -109961,8 +110031,8 @@ async function restoreWorktreeContext(sidecarPath, onWarn) {
   }
   let worktreeAlive = false;
   try {
-    const stat15 = await fs67.stat(session.worktreePath);
-    worktreeAlive = stat15.isDirectory();
+    const stat16 = await fs67.stat(session.worktreePath);
+    worktreeAlive = stat16.isDirectory();
   } catch {
     worktreeAlive = false;
   }
@@ -110262,11 +110332,11 @@ var WorkspaceMemoryFileTooLargeError = class extends Error {
 async function composeAppendedContent(filePath, newContent) {
   let existing = "";
   try {
-    const stat15 = await fs68.stat(filePath);
-    if (stat15.size > MAX_EXISTING_FILE_BYTES) {
+    const stat16 = await fs68.stat(filePath);
+    if (stat16.size > MAX_EXISTING_FILE_BYTES) {
       throw new WorkspaceMemoryFileTooLargeError(
         filePath,
-        stat15.size,
+        stat16.size,
         MAX_EXISTING_FILE_BYTES
       );
     }
@@ -110284,8 +110354,8 @@ ${trimmed2}
   }
   const sectionIdx = existing.indexOf(MEMORY_SECTION_HEADER);
   if (sectionIdx === -1) {
-    const sep18 = existing.endsWith("\n") ? "" : "\n";
-    return `${existing}${sep18}
+    const sep17 = existing.endsWith("\n") ? "" : "\n";
+    return `${existing}${sep17}
 ${MEMORY_SECTION_HEADER}
 ${trimmed2}
 `;
@@ -110293,15 +110363,15 @@ ${trimmed2}
   const afterHeaderIdx = sectionIdx + MEMORY_SECTION_HEADER.length;
   const nextHeaderRel = findNextTopLevelHeading(existing, afterHeaderIdx);
   if (nextHeaderRel === -1) {
-    const sep18 = existing.endsWith("\n") ? "" : "\n";
-    return `${existing}${sep18}${trimmed2}
+    const sep17 = existing.endsWith("\n") ? "" : "\n";
+    return `${existing}${sep17}${trimmed2}
 `;
   }
   const insertAt = afterHeaderIdx + nextHeaderRel;
   const before = existing.slice(0, insertAt);
   const after = existing.slice(insertAt);
-  const sep17 = before.endsWith("\n") ? "" : "\n";
-  return `${before}${sep17}${trimmed2}
+  const sep16 = before.endsWith("\n") ? "" : "\n";
+  return `${before}${sep16}${trimmed2}
 ${after}`;
 }
 __name(composeAppendedContent, "composeAppendedContent");
@@ -113648,7 +113718,7 @@ init_esbuild_shims();
 import * as fs73 from "node:fs";
 import * as path74 from "node:path";
 import * as https3 from "node:https";
-import { stat as stat13 } from "node:fs/promises";
+import { stat as stat14 } from "node:fs/promises";
 function parseSourceAndPluginName(source) {
   const urlSchemes = ["http://", "https://", "git@", "sso://"];
   let repoEndIndex = source.length;
@@ -113761,7 +113831,7 @@ async function parseInstallSource(source) {
   let marketplaceConfig = null;
   let isLocalPath = false;
   try {
-    await stat13(repo);
+    await stat14(repo);
     isLocalPath = true;
   } catch {
   }
@@ -114213,7 +114283,7 @@ __name(reportSuggestionUsage, "reportSuggestionUsage");
 init_esbuild_shims();
 import { mkdir as mkdir13, copyFile as copyFile3, rm as rm4 } from "node:fs/promises";
 import { existsSync as existsSync16 } from "node:fs";
-import { join as join46, dirname as dirname27, relative as relative12, isAbsolute as isAbsolute17 } from "node:path";
+import { join as join47, dirname as dirname27, relative as relative11, isAbsolute as isAbsolute17 } from "node:path";
 import { tmpdir as tmpdir4 } from "node:os";
 import { randomUUID as randomUUID10 } from "node:crypto";
 var OverlayFs = class {
@@ -114221,7 +114291,7 @@ var OverlayFs = class {
   constructor(realCwd) {
     this.realCwd = realCwd;
     const id = randomUUID10().slice(0, 8);
-    this.overlayDir = join46(
+    this.overlayDir = join47(
       tmpdir4(),
       "qwen-speculation",
       String(process.pid),
@@ -114260,9 +114330,9 @@ var OverlayFs = class {
     if (this.writtenFiles.has(rel)) {
       return this.writtenFiles.get(rel);
     }
-    const overlayPath = join46(this.overlayDir, rel);
+    const overlayPath = join47(this.overlayDir, rel);
     await mkdir13(dirname27(overlayPath), { recursive: true });
-    const originalPath = join46(this.realCwd, rel);
+    const originalPath = join47(this.realCwd, rel);
     if (existsSync16(originalPath)) {
       try {
         await copyFile3(originalPath, overlayPath);
@@ -114285,7 +114355,7 @@ var OverlayFs = class {
   async applyToReal() {
     const applied = [];
     for (const [rel, overlayPath] of this.writtenFiles) {
-      const realPath = join46(this.realCwd, rel);
+      const realPath = join47(this.realCwd, rel);
       try {
         await mkdir13(dirname27(realPath), { recursive: true });
         await copyFile3(overlayPath, realPath);
@@ -114309,8 +114379,8 @@ var OverlayFs = class {
    * Returns null if the path is outside cwd.
    */
   toRelative(inputPath) {
-    const abs = isAbsolute17(inputPath) ? inputPath : join46(this.realCwd, inputPath);
-    const rel = relative12(this.realCwd, abs);
+    const abs = isAbsolute17(inputPath) ? inputPath : join47(this.realCwd, inputPath);
+    const rel = relative11(this.realCwd, abs);
     if (isAbsolute17(rel) || rel.startsWith("..")) {
       return null;
     }
@@ -115161,12 +115231,12 @@ function resolveGitDir2(crawlDirectory) {
   while (current) {
     const gitPath = path76.join(current, ".git");
     try {
-      const stat15 = fs75.statSync(gitPath);
-      if (stat15.isDirectory()) {
+      const stat16 = fs75.statSync(gitPath);
+      if (stat16.isDirectory()) {
         pathCacheSet(resolveGitDirCache, cacheKey, gitPath);
         return gitPath;
       }
-      if (stat15.isFile()) {
+      if (stat16.isFile()) {
         const contents = fs75.readFileSync(gitPath, "utf8").trim();
         const match2 = contents.match(/^gitdir:\s*(.+)$/i);
         if (!match2) {
@@ -115461,8 +115531,8 @@ function getPosixRelative(from, to) {
     toAbs = fs75.realpathSync(toResolved);
   } catch {
   }
-  const relative13 = path76.relative(fromAbs, toAbs);
-  const posixRel = toPosixPath2(relative13);
+  const relative12 = path76.relative(fromAbs, toAbs);
+  const posixRel = toPosixPath2(relative12);
   return posixRel === "" ? "." : posixRel;
 }
 __name(getPosixRelative, "getPosixRelative");
@@ -117252,7 +117322,7 @@ var formatMemoryUsage = /* @__PURE__ */ __name((bytes) => {
 
 // packages/core/src/utils/memoryDiagnostics.ts
 init_esbuild_shims();
-import { readdir as readdir14, readFile as readFile26 } from "node:fs/promises";
+import { readdir as readdir15, readFile as readFile26 } from "node:fs/promises";
 import { execFile as execFile5 } from "node:child_process";
 import process7 from "node:process";
 import { promisify as promisify4 } from "node:util";
@@ -117382,7 +117452,7 @@ function getProcessInternalCount(name3, internalMethod, probe) {
 }
 __name(getProcessInternalCount, "getProcessInternalCount");
 async function countOpenFileDescriptors() {
-  return (await readdir14("/proc/self/fd")).length;
+  return (await readdir15("/proc/self/fd")).length;
 }
 __name(countOpenFileDescriptors, "countOpenFileDescriptors");
 async function readProcSmapsRollup() {
@@ -117621,8 +117691,8 @@ function getWelcomeBackStatePath() {
   return path79.join(process.cwd(), ".qwen", WELCOME_BACK_STATE_FILENAME);
 }
 __name(getWelcomeBackStatePath, "getWelcomeBackStatePath");
-function buildSummaryFingerprint(stat15) {
-  return `${stat15.mtimeMs}:${stat15.size}`;
+function buildSummaryFingerprint(stat16) {
+  return `${stat16.mtimeMs}:${stat16.size}`;
 }
 __name(buildSummaryFingerprint, "buildSummaryFingerprint");
 async function getWelcomeBackState() {
@@ -122975,8 +123045,8 @@ function getShellDisplayName({
     case "cmd":
       return "cmd.exe";
     case "powershell": {
-      const basename17 = getExecutableBasename(executable).toLowerCase();
-      return basename17 === "pwsh.exe" ? "pwsh.exe" : "powershell.exe";
+      const basename18 = getExecutableBasename(executable).toLowerCase();
+      return basename18 === "pwsh.exe" ? "pwsh.exe" : "powershell.exe";
     }
     case "bash":
       return "bash";