@qwen-code/qwen-code 0.21.1 → 0.21.2-nightly.20260801.bc382c3ff

package/chunks/{chunk-TV64SXKD.js → chunk-RGJ4JWSU.js}

@@ -2,13 +2,13 @@
 "use strict";
 import {
   t
-} from "./chunk-TCIFAA7K.js";
+} from "./chunk-CHCLO3M7.js";
 import {
   SessionReferenceService,
   SessionService,
   readManyFiles,
   stripTerminalControlSequences
-} from "./chunk-X5WNMMIA.js";
+} from "./chunk-NGWYUZZO.js";
 import {
   emptyMcpResourceText,
   formatMcpResourceContents,
@@ -16,14 +16,15 @@ import {
 } from "./chunk-ZPJWUGCS.js";
 import {
   shouldRunVisionBridge
-} from "./chunk-PT722TDT.js";
+} from "./chunk-M2F5PLOW.js";
 import {
   Storage,
   getErrorMessage,
   isNodeError,
   isSubpath,
-  unescapePath
-} from "./chunk-UHUSJ6X7.js";
+  unescapePath,
+  unescapeShellSpecials
+} from "./chunk-3RXUYQJI.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -230,7 +231,8 @@ function isSessionId(value) {
 __name(isSessionId, "isSessionId");
 function parseSessionRef(pathName) {
   if (!pathName.startsWith(SESSION_MENTION_PREFIX)) return null;
-  const remainder = pathName.slice(SESSION_MENTION_PREFIX.length).trim();
+  const rawRemainder = pathName.slice(SESSION_MENTION_PREFIX.length).trim();
+  const remainder = process.platform === "win32" ? unescapeShellSpecials(rawRemainder) : rawRemainder;
   if (remainder.length === 0) return null;
   return isSessionId(remainder) ? { id: remainder } : { title: remainder };
 }
@@ -368,14 +370,29 @@ async function resolveAtCommandQuery({
   }
   const fileDiscovery = config.getFileService();
   const respectFileIgnore = config.getFileFilteringOptions();
+  const configuredProjectTempDir = Storage.getGlobalTempDir();
+  const projectTempDir = await fs2.realpath(configuredProjectTempDir).catch(() => path.resolve(configuredProjectTempDir));
   const pathSpecsToRead = [];
   const atPathToResolvedSpecMap = /* @__PURE__ */ new Map();
   const contentLabelsForDisplay = [];
+  const displayPaths = /* @__PURE__ */ new Map();
+  const displayPathsByCanonicalPath = /* @__PURE__ */ new Map();
   const ignoredByReason = {
     git: [],
     qwen: [],
     both: []
   };
+  const getIgnoreReason = /* @__PURE__ */ __name((candidate) => {
+    const gitIgnored = respectFileIgnore.respectGitIgnore && fileDiscovery.shouldIgnoreFile(candidate, {
+      respectGitIgnore: true,
+      respectQwenIgnore: false
+    });
+    const qwenIgnored = respectFileIgnore.respectQwenIgnore && fileDiscovery.shouldIgnoreFile(candidate, {
+      respectGitIgnore: false,
+      respectQwenIgnore: true
+    });
+    return gitIgnored && qwenIgnored ? "both" : gitIgnored ? "git" : qwenIgnored ? "qwen" : void 0;
+  }, "getIgnoreReason");
   const mcpServerNames = new Set(Object.keys(config.getMcpServers() || {}));
   const mcpResourceRefs = [];
   const mcpServerMentions = [];
@@ -413,7 +430,10 @@ async function resolveAtCommandQuery({
       )) {
         sessionMentions.push({ originalAtPath, ref: sessionRef });
       }
-      atPathToResolvedSpecMap.set(originalAtPath, pathName);
+      atPathToResolvedSpecMap.set(
+        originalAtPath,
+        buildSessionRef(sessionRef.id ?? sessionRef.title)
+      );
       continue;
     }
     const resourceRef = parseMcpResourceRef(pathName, mcpServerNames);
@@ -447,24 +467,16 @@ async function resolveAtCommandQuery({
       continue;
     }
     const workspaceContext = config.getWorkspaceContext();
-    const projectTempDir = Storage.getGlobalTempDir();
     const absolutePathName = path.isAbsolute(pathName) ? pathName : path.resolve(workspaceContext.getDirectories()[0] || "", pathName);
-    if (!isSubpath(projectTempDir, absolutePathName) && !workspaceContext.isPathWithinWorkspace(pathName)) {
+    if (!isSubpath(configuredProjectTempDir, absolutePathName) && !isSubpath(projectTempDir, absolutePathName) && !workspaceContext.isPathWithinWorkspace(pathName)) {
       onDebugMessage(
         `Path ${pathName} is not in the workspace and will be skipped.`
       );
       continue;
     }
-    const gitIgnored = respectFileIgnore.respectGitIgnore && fileDiscovery.shouldIgnoreFile(pathName, {
-      respectGitIgnore: true,
-      respectQwenIgnore: false
-    });
-    const qwenIgnored = respectFileIgnore.respectQwenIgnore && fileDiscovery.shouldIgnoreFile(pathName, {
-      respectGitIgnore: false,
-      respectQwenIgnore: true
-    });
-    if (gitIgnored || qwenIgnored) {
-      const reason = gitIgnored && qwenIgnored ? "both" : gitIgnored ? "git" : "qwen";
+    const ignoredReason = getIgnoreReason(pathName);
+    if (ignoredReason) {
+      const reason = ignoredReason;
       ignoredByReason[reason].push(pathName);
       const reasonText = reason === "both" ? "ignored by both git and qwen" : reason === "git" ? "git-ignored" : "qwen-ignored";
       onDebugMessage(`Path ${pathName} is ${reasonText} and will be skipped.`);
@@ -472,17 +484,39 @@ async function resolveAtCommandQuery({
     }
     let resolvedSuccessfully = false;
     let sawNotFound = false;
+    let deferredIgnoreReason;
     for (const dir of config.getWorkspaceContext().getDirectories()) {
-      let currentPathSpec = pathName;
       try {
         const absolutePath = path.resolve(dir, pathName);
-        const stats = await fs2.stat(absolutePath);
+        const canonicalPath = await fs2.realpath(absolutePath);
+        const stats = await fs2.stat(canonicalPath);
+        if (!isSubpath(configuredProjectTempDir, canonicalPath) && !isSubpath(projectTempDir, canonicalPath) && !workspaceContext.isPathWithinWorkspace(canonicalPath)) {
+          onDebugMessage(
+            `Path ${pathName} is not in the workspace and will be skipped.`
+          );
+          continue;
+        }
+        const canonicalIgnoreReason = getIgnoreReason(canonicalPath);
+        if (canonicalIgnoreReason) {
+          deferredIgnoreReason = canonicalIgnoreReason;
+          const reasonText = canonicalIgnoreReason === "both" ? "ignored by both git and qwen" : canonicalIgnoreReason === "git" ? "git-ignored" : "qwen-ignored";
+          onDebugMessage(
+            `Path ${pathName} is ${reasonText} and will be skipped.`
+          );
+          continue;
+        }
         if (stats.isDirectory()) {
-          currentPathSpec = pathName;
           onDebugMessage(`Path ${pathName} resolved to directory.`);
         } else {
           onDebugMessage(`Path ${pathName} resolved to file: ${absolutePath}`);
         }
+        pathSpecsToRead.push(canonicalPath);
+        atPathToResolvedSpecMap.set(originalAtPath, pathName);
+        contentLabelsForDisplay.push(pathName);
+        displayPaths.set(canonicalPath, pathName);
+        const canonicalDisplays = displayPathsByCanonicalPath.get(canonicalPath) ?? /* @__PURE__ */ new Set();
+        canonicalDisplays.add(pathName);
+        displayPathsByCanonicalPath.set(canonicalPath, canonicalDisplays);
         resolvedSuccessfully = true;
       } catch (error) {
         if (isNodeError(error) && error.code === "ENOENT") {
@@ -495,9 +529,6 @@ async function resolveAtCommandQuery({
         }
       }
       if (resolvedSuccessfully) {
-        pathSpecsToRead.push(currentPathSpec);
-        atPathToResolvedSpecMap.set(originalAtPath, currentPathSpec);
-        contentLabelsForDisplay.push(pathName);
         break;
       }
     }
@@ -506,31 +537,37 @@ async function resolveAtCommandQuery({
         `Path ${pathName} not found. Path ${pathName} will be skipped.`
       );
     }
+    if (!resolvedSuccessfully && deferredIgnoreReason) {
+      ignoredByReason[deferredIgnoreReason].push(pathName);
+    }
   }
-  let initialQueryText = "";
-  for (let i = 0; i < commandParts.length; i++) {
-    const part = commandParts[i];
-    if (part.type === "text") {
-      initialQueryText += part.content;
-    } else {
-      const resolvedSpec = atPathToResolvedSpecMap.get(part.content);
-      if (i > 0 && initialQueryText.length > 0 && !initialQueryText.endsWith(" ")) {
-        const prevPart = commandParts[i - 1];
-        if (prevPart.type === "text" || prevPart.type === "atPath" && atPathToResolvedSpecMap.has(prevPart.content)) {
-          initialQueryText += " ";
-        }
-      }
-      if (resolvedSpec) {
-        initialQueryText += `@${resolvedSpec}`;
+  const buildInitialQueryText = /* @__PURE__ */ __name(() => {
+    let text = "";
+    for (let i = 0; i < commandParts.length; i++) {
+      const part = commandParts[i];
+      if (part.type === "text") {
+        text += part.content;
       } else {
-        if (i > 0 && initialQueryText.length > 0 && !initialQueryText.endsWith(" ") && !part.content.startsWith(" ")) {
-          initialQueryText += " ";
+        const resolvedSpec = atPathToResolvedSpecMap.get(part.content);
+        if (i > 0 && text.length > 0 && !text.endsWith(" ")) {
+          const prevPart = commandParts[i - 1];
+          if (prevPart.type === "text" || prevPart.type === "atPath") {
+            text += " ";
+          }
+        }
+        if (resolvedSpec) {
+          text += `@${resolvedSpec}`;
+        } else {
+          if (i > 0 && text.length > 0 && !text.endsWith(" ") && !part.content.startsWith(" ")) {
+            text += " ";
+          }
+          text += part.content;
         }
-        initialQueryText += part.content;
       }
     }
-  }
-  initialQueryText = initialQueryText.trim();
+    return text.trim();
+  }, "buildInitialQueryText");
+  let initialQueryText = buildInitialQueryText();
   const totalIgnored = ignoredByReason["git"].length + ignoredByReason["qwen"].length + ignoredByReason["both"].length;
   if (totalIgnored > 0) {
     const messages = [];
@@ -787,12 +824,58 @@ ${messages.join("\n")}`;
   );
   const fileParts = [];
   let fileDisplays = [];
-  if (pathSpecsToRead.length > 0) {
+  const revalidatedPathSpecs = [];
+  const revalidatedDisplayPaths = /* @__PURE__ */ new Map();
+  const validatedPathIdentities = /* @__PURE__ */ new Map();
+  const pruneSkippedPath = /* @__PURE__ */ __name((approvedPath) => {
+    const displayPath = displayPaths.get(approvedPath);
+    const displayLabels = displayPathsByCanonicalPath.get(approvedPath) ?? new Set(displayPath ? [displayPath] : []);
+    for (const [originalAtPath, resolvedSpec] of atPathToResolvedSpecMap) {
+      if (resolvedSpec === approvedPath || displayLabels.has(resolvedSpec)) {
+        atPathToResolvedSpecMap.delete(originalAtPath);
+      }
+    }
+    for (let index = contentLabelsForDisplay.length - 1; index >= 0; index--) {
+      const label = contentLabelsForDisplay[index];
+      if (label === approvedPath || displayLabels.has(label)) {
+        contentLabelsForDisplay.splice(index, 1);
+      }
+    }
+  }, "pruneSkippedPath");
+  for (const approvedPath of pathSpecsToRead) {
+    try {
+      const currentPath = await fs2.realpath(approvedPath);
+      const stats = await fs2.stat(currentPath);
+      if (currentPath === approvedPath && (stats.isFile() || stats.isDirectory()) && (isSubpath(configuredProjectTempDir, currentPath) || isSubpath(projectTempDir, currentPath) || config.getWorkspaceContext().isPathWithinWorkspace(currentPath)) && getIgnoreReason(currentPath) === void 0) {
+        revalidatedPathSpecs.push(currentPath);
+        const displayPath = displayPaths.get(approvedPath);
+        if (displayPath) revalidatedDisplayPaths.set(currentPath, displayPath);
+        validatedPathIdentities.set(currentPath, {
+          dev: stats.dev,
+          ino: stats.ino
+        });
+      } else {
+        pruneSkippedPath(approvedPath);
+        onDebugMessage(
+          `Path ${approvedPath} failed revalidation and will be skipped.`
+        );
+      }
+    } catch {
+      pruneSkippedPath(approvedPath);
+      onDebugMessage(
+        `Path ${approvedPath} changed before it could be read and will be skipped.`
+      );
+    }
+  }
+  initialQueryText = buildInitialQueryText();
+  if (revalidatedPathSpecs.length > 0) {
     try {
       const result = await readManyFiles(config, {
-        paths: pathSpecsToRead,
+        paths: revalidatedPathSpecs,
         signal,
-        preserveUnsupportedImageForBridge: shouldRunVisionBridge(config)
+        preserveUnsupportedImageForBridge: shouldRunVisionBridge(config),
+        validatedPathIdentities,
+        displayPaths: revalidatedDisplayPaths
       });
       const parts = Array.isArray(result.contentParts) ? result.contentParts : [result.contentParts];
       fileDisplays = result.files.map((file, index) => ({

package/chunks/{chunk-75MIQ3LV.js → chunk-RPYYTL7E.js}

@@ -2,12 +2,12 @@
 "use strict";
 import {
   stringifyGenAiJson
-} from "./chunk-DZLYR4U3.js";
+} from "./chunk-2DNKEBXY.js";
 import {
   getMeter,
   isTelemetrySdkInitialized,
   truncateSpanError
-} from "./chunk-BGTQCTQW.js";
+} from "./chunk-O2ZYHG33.js";
 import {
   require_src
 } from "./chunk-W4RQUHY3.js";
@@ -16,13 +16,13 @@ import {
   SENSITIVE_SPAN_ATTRIBUTE_MAX_LENGTH_LIMIT,
   SERVICE_NAME,
   isValidSensitiveSpanAttributeMaxLength
-} from "./chunk-S7W2GKIO.js";
+} from "./chunk-G7XXKQYS.js";
 import {
   FatalConfigError,
   createDebugLogger,
   formatTraceparent,
   getActiveSpanTraceContext
-} from "./chunk-UHUSJ6X7.js";
+} from "./chunk-3RXUYQJI.js";
 import {
   ROOT_CONTEXT,
   SpanKind,
@@ -554,6 +554,8 @@ init_esbuild_shims();
 import { monitorEventLoopDelay } from "node:perf_hooks";
 var DEFAULT_RESOLUTION_MS = 20;
 var DEFAULT_STALL_THRESHOLD_MS = 1e3;
+var DEFAULT_EVENT_LOOP_SUSPEND_THRESHOLD_MS = 5 * 60 * 1e3;
+var DEFAULT_SUSPEND_CPU_RATIO = 0.01;
 var NS_PER_MS = 1e6;
 function startEventLoopLagMonitor(options = {}) {
   const resolutionMs = positiveFiniteOrDefault(
@@ -564,24 +566,54 @@ function startEventLoopLagMonitor(options = {}) {
     options.stallThresholdMs,
     DEFAULT_STALL_THRESHOLD_MS
   );
+  const suspendThresholdMs = positiveFiniteOrDefault(
+    options.suspendThresholdMs,
+    DEFAULT_EVENT_LOOP_SUSPEND_THRESHOLD_MS
+  );
+  const suspendCpuRatio = fractionOrDefault(
+    options.suspendCpuRatio,
+    DEFAULT_SUSPEND_CPU_RATIO
+  );
   const histogram = monitorEventLoopDelay({ resolution: resolutionMs });
   histogram.enable();
   let disposed = false;
   let lastReportedMaxMs = 0;
+  let lastObservedMaxMs = 0;
+  let lastCheckTimeMs = Date.now();
+  let lastCpuUsage = safeCpuUsage();
+  let pendingSuspendGapMs = 0;
   const readMaxMs = /* @__PURE__ */ __name(() => nsToMs(histogram.max), "readMaxMs");
-  const checkForNewMaxStall = /* @__PURE__ */ __name(() => {
-    if (disposed || !options.onNewMaxStall) return;
+  const checkHistogram = /* @__PURE__ */ __name(() => {
+    if (disposed) return;
+    const nowMs = Date.now();
+    const cpuUsage = safeCpuUsage();
+    const elapsedMs = Math.max(0, nowMs - lastCheckTimeMs);
     const maxMs = readMaxMs();
-    if (maxMs >= stallThresholdMs && maxMs > lastReportedMaxMs) {
+    const newMaxMs = maxMs > lastObservedMaxMs ? maxMs : 0;
+    const cpuRatio = calculateCpuRatio(lastCpuUsage, cpuUsage, elapsedMs);
+    lastCheckTimeMs = nowMs;
+    if (cpuUsage) lastCpuUsage = cpuUsage;
+    lastObservedMaxMs = maxMs;
+    const isLowCpuGap = elapsedMs >= suspendThresholdMs && cpuRatio !== void 0 && cpuRatio <= suspendCpuRatio;
+    const suspendGapMs = isLowCpuGap ? elapsedMs : pendingSuspendGapMs;
+    pendingSuspendGapMs = isLowCpuGap ? elapsedMs : 0;
+    if (newMaxMs >= suspendThresholdMs && suspendGapMs >= suspendThresholdMs && newMaxMs <= suspendGapMs * 1.5) {
+      histogram.reset();
+      lastObservedMaxMs = 0;
+      lastReportedMaxMs = 0;
+      pendingSuspendGapMs = 0;
+      return;
+    }
+    if (options.onNewMaxStall && maxMs >= stallThresholdMs && maxMs > lastReportedMaxMs) {
       lastReportedMaxMs = maxMs;
       try {
         options.onNewMaxStall(maxMs);
       } catch {
       }
     }
-  }, "checkForNewMaxStall");
-  const interval = options.onNewMaxStall !== void 0 ? setInterval(checkForNewMaxStall, resolutionMs) : void 0;
-  interval?.unref();
+  }, "checkHistogram");
+  const interval = setInterval(checkHistogram, resolutionMs);
+  interval.unref();
   return {
     snapshot() {
       return {
@@ -594,14 +626,26 @@ function startEventLoopLagMonitor(options = {}) {
     dispose() {
       if (disposed) return;
       disposed = true;
-      if (interval) {
-        clearInterval(interval);
-      }
+      clearInterval(interval);
       histogram.disable();
     }
   };
 }
 __name(startEventLoopLagMonitor, "startEventLoopLagMonitor");
+function safeCpuUsage() {
+  try {
+    return process.cpuUsage();
+  } catch {
+    return void 0;
+  }
+}
+__name(safeCpuUsage, "safeCpuUsage");
+function calculateCpuRatio(previous, current, elapsedMs) {
+  if (!previous || !current || elapsedMs <= 0) return void 0;
+  const cpuMicroseconds = current.user - previous.user + (current.system - previous.system);
+  return Math.max(0, cpuMicroseconds / (elapsedMs * 1e3));
+}
+__name(calculateCpuRatio, "calculateCpuRatio");
 function nsToMs(value) {
   return Number.isFinite(value) ? value / NS_PER_MS : 0;
 }
@@ -610,6 +654,10 @@ function positiveFiniteOrDefault(value, fallback) {
   return value !== void 0 && Number.isFinite(value) && value > 0 ? value : fallback;
 }
 __name(positiveFiniteOrDefault, "positiveFiniteOrDefault");
+function fractionOrDefault(value, fallback) {
+  return value !== void 0 && Number.isFinite(value) && value >= 0 && value <= 1 ? value : fallback;
+}
+__name(fractionOrDefault, "fractionOrDefault");
 
 // packages/core/src/telemetry/event-loop-lag-metrics.ts
 init_esbuild_shims();

package/chunks/{chunk-52ZSWYEG.js → chunk-SK2UKB45.js}

@@ -64,7 +64,7 @@ async function runExitCleanup(options = {}) {
 }
 __name(runExitCleanup, "runExitCleanup");
 async function cleanupCheckpoints() {
-  const { Storage } = await import("./deferred-core-runtime-X4QV662U.js");
+  const { Storage } = await import("./deferred-core-runtime-JJBHKM2C.js");
   const storage = new Storage(process.cwd());
   const tempDir = storage.getProjectTempDir();
   const checkpointsDir = join(tempDir, "checkpoints");

package/chunks/{chunk-PLDQBIO6.js → chunk-SWEBEXPI.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   BaseJsonOutputAdapter
-} from "./chunk-BPZKP57P.js";
+} from "./chunk-OCRM53TT.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";