@qwen-code/qwen-code 0.19.2 → 0.19.3-nightly.20260701.a974594d7

package/chunks/{chunk-HG6YKEBI.js → chunk-Q7TDHJ2G.js}

@@ -2,26 +2,28 @@
 "use strict";
 import {
   handleAtCommand
-} from "./chunk-B6HQGTYR.js";
+} from "./chunk-YCEHOJZJ.js";
 import {
   JsonOutputAdapter
-} from "./chunk-EX4W6ZYG.js";
+} from "./chunk-EUURTJY7.js";
 import {
   StreamJsonOutputAdapter
-} from "./chunk-J6AW7O5D.js";
+} from "./chunk-NVTRORSK.js";
 import {
+  buildInitialSystemReminders,
   buildSystemMessage,
   computeUsageFromMetrics,
   createAgentToolProgressHandler,
   createToolProgressHandler,
   extractPartsFromUserMessage,
   handleSlashCommand,
+  insertAfterFunctionResponses,
   isSlashCommand,
   normalizePartList
-} from "./chunk-2TJ3YN6Q.js";
+} from "./chunk-NOYV2NXI.js";
 import {
   RunBudgetEnforcer
-} from "./chunk-ZUAXI2OA.js";
+} from "./chunk-ZGSV5ORL.js";
 import {
   AlreadyReportedError,
   handleBudgetExceededError,
@@ -29,26 +31,37 @@ import {
   handleError,
   handleMaxTurnsExceededError,
   handleToolError
-} from "./chunk-5R4SBCX6.js";
+} from "./chunk-AIBPG5MB.js";
 import {
+  isInlineModelOverrideAllowed
+} from "./chunk-OEY3YAL2.js";
+import {
+  ORPHAN_TOOL_USE_REPAIR_REASON,
+  buildSyntheticToolResponseParts,
   createDuplicateProviderToolCallResponse,
+  detectAutonomousSentinel,
+  detectLoopSentinel,
+  detectTurnInterruption,
   executeToolCall,
+  findRepeatedDuplicateProviderToolCall,
+  isSystemReminderContent,
+  markDuplicateProviderToolCallResponseSent,
   parseAndFormatApiError,
   promptIdContext,
   restoreWorktreeContext
-} from "./chunk-PXFFKNCO.js";
+} from "./chunk-35FH347N.js";
 import {
   isTelemetrySdkInitialized,
   shutdownTelemetry,
   uiTelemetryService
-} from "./chunk-WA5OJGFL.js";
+} from "./chunk-B5MPZI4K.js";
 import {
   ToolNames
-} from "./chunk-TOEGRAVX.js";
+} from "./chunk-JV7A66DR.js";
 import {
   FatalInputError,
   createDebugLogger
-} from "./chunk-C4K3FEQ2.js";
+} from "./chunk-AVQDCKNF.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -60,6 +73,10 @@ import {
 init_esbuild_shims();
 var debugLogger = createDebugLogger("NON_INTERACTIVE_CLI");
 var STRUCTURED_SHUTDOWN_HOLDBACK_MS = 500;
+function isHeadlessLoopSentinel(prompt) {
+  return detectLoopSentinel(prompt) !== null || detectAutonomousSentinel(prompt) !== null;
+}
+__name(isHeadlessLoopSentinel, "isHeadlessLoopSentinel");
 var SUPPRESSED_OUTPUT_SUCCESS = "Skipped: this turn's structured_output contract took precedence as the terminal output.";
 var SUPPRESSED_OUTPUT_RETRY = `${SUPPRESSED_OUTPUT_SUCCESS} Re-issue this call in a separate turn if needed.`;
 function suppressedOutputBody(structuredCaptured) {
@@ -72,18 +89,35 @@ var LOOP_TYPE_LABELS = {
   ["repetitive_thoughts" /* REPETITIVE_THOUGHTS */]: "the model repeated the same reasoning thought",
   ["read_file_loop" /* READ_FILE_LOOP */]: "the model spent too many consecutive calls reading files without making progress",
   ["action_stagnation" /* ACTION_STAGNATION */]: "the model kept calling the same tool without making progress",
+  ["shell_command_stagnation" /* SHELL_COMMAND_STAGNATION */]: "the model repeated similar shell inspection commands without making progress",
   ["global_tool_call_duplicate" /* GLOBAL_TOOL_CALL_DUPLICATE */]: "the model repeated the same tool call across the turn, even when not back-to-back",
   ["alternating_tool_call_pattern" /* ALTERNATING_TOOL_CALL_PATTERN */]: "the model alternated between the same two tool calls in a repeating pattern",
-  ["turn_tool_call_cap" /* TURN_TOOL_CALL_CAP */]: "the model exceeded the maximum number of tool calls allowed in a single turn"
+  ["turn_tool_call_cap" /* TURN_TOOL_CALL_CAP */]: "the model exceeded the maximum number of tool calls allowed in a single turn",
+  ["invalid_tool_params_stagnation" /* INVALID_TOOL_PARAMS_STAGNATION */]: "the model repeatedly sent invalid tool parameters without correcting them"
 };
 function formatLoopDetectedMessage(loopType) {
   const reason = loopType ? LOOP_TYPE_LABELS[loopType] : void 0;
   const detail = reason ? ` (${loopType}: ${reason})` : "";
-  const isAlwaysOn = loopType === "turn_tool_call_cap" /* TURN_TOOL_CALL_CAP */ || loopType === "consecutive_identical_tool_calls" /* CONSECUTIVE_IDENTICAL_TOOL_CALLS */;
+  const isAlwaysOn = loopType === "turn_tool_call_cap" /* TURN_TOOL_CALL_CAP */ || loopType === "consecutive_identical_tool_calls" /* CONSECUTIVE_IDENTICAL_TOOL_CALLS */ || loopType === "shell_command_stagnation" /* SHELL_COMMAND_STAGNATION */ || loopType === "global_tool_call_duplicate" /* GLOBAL_TOOL_CALL_DUPLICATE */ || loopType === "invalid_tool_params_stagnation" /* INVALID_TOOL_PARAMS_STAGNATION */;
   const hint = isAlwaysOn ? " This is an always-on guard and cannot be disabled via `model.skipLoopDetection`." : " Set the `model.skipLoopDetection` setting to true to disable.";
   return `Loop detection halted the run${detail}.${hint}`;
 }
 __name(formatLoopDetectedMessage, "formatLoopDetectedMessage");
+function skipHeadlessLoopSentinel(scheduler, job) {
+  if (!isHeadlessLoopSentinel(job.prompt)) {
+    return false;
+  }
+  if (job.recurring && !job.durable) {
+    debugLogger.debug(
+      "skipHeadlessLoopSentinel: cleaning up recurring session loop.md cron in headless mode",
+      { jobId: job.id }
+    );
+    void scheduler.delete(job.id).catch(() => {
+    });
+  }
+  return true;
+}
+__name(skipHeadlessLoopSentinel, "skipHeadlessLoopSentinel");
 function emitLoopDetectedMessage(config, loopType) {
   const message = formatLoopDetectedMessage(loopType);
   if (config.getOutputFormat() !== "text" /* TEXT */) {
@@ -132,6 +166,10 @@ async function runNonInteractive(config, settings, input, prompt_id, options = {
     } else {
       adapter = new JsonOutputAdapter(config);
     }
+    const emitResult = /* @__PURE__ */ __name((result) => {
+      adapter.emitResult(result);
+      options.onResultEmitted?.();
+    }, "emitResult");
     const sessionId = config.getSessionId();
     const permissionMode = config.getApprovalMode();
     let turnCount = 0;
@@ -247,6 +285,7 @@ ${reason}
         manager.getEventEmitter().on("teammate_approval_request" /* TEAMMATE_APPROVAL_REQUEST */, approvalListener);
       }
     }, "onTeamManagerChangeHandler");
+    let continueSendType = null;
     try {
       process.stdout.on("error", stdoutErrorHandler);
       process.on("SIGINT", shutdownHandler);
@@ -265,6 +304,50 @@ ${reason}
       let initialPartList = extractPartsFromUserMessage(
         options.userMessage
       );
+      let inlineModelOverride;
+      if (options.continueInterrupted) {
+        const detection = detectTurnInterruption(
+          geminiClient.getChat().getHistory()
+        );
+        debugLogger.info("[runNonInteractive] continueInterrupted detection", {
+          kind: detection.kind,
+          partsCount: detection.kind === "interrupted_prompt" ? detection.parts.length : 0,
+          danglingCallCount: detection.kind === "interrupted_turn" ? detection.danglingCalls.length : 0
+        });
+        if (detection.kind === "none") {
+          await emitNonInteractiveFinalMessage({
+            message: "No interrupted turn to continue.",
+            isError: false,
+            adapter,
+            config,
+            startTimeMs: startTime
+          });
+          return 0;
+        }
+        if (detection.kind === "interrupted_prompt") {
+          initialPartList = detection.parts;
+          continueSendType = "retry" /* Retry */;
+        } else {
+          initialPartList = buildSyntheticToolResponseParts(
+            detection.danglingCalls,
+            ORPHAN_TOOL_USE_REPAIR_REASON
+          );
+          continueSendType = "toolResult" /* ToolResult */;
+        }
+        const reminderParts = buildInitialSystemReminders(config);
+        if (reminderParts.length > 0 && initialPartList) {
+          const continuationParts = normalizePartList(initialPartList);
+          const hasSystemReminderPart = continuationParts.some(
+            (part) => isSystemReminderContent({ role: "user", parts: [part] })
+          );
+          if (!hasSystemReminderPart) {
+            initialPartList = insertAfterFunctionResponses(
+              continuationParts,
+              reminderParts
+            );
+          }
+        }
+      }
       if (!initialPartList) {
         let slashHandled = false;
         if (isSlashCommand(input)) {
@@ -277,6 +360,19 @@ ${reason}
           switch (slashCommandResult.type) {
             case "submit_prompt":
               initialPartList = slashCommandResult.content;
+              if (slashCommandResult.modelOverride !== void 0 && isInlineModelOverrideAllowed(
+                config,
+                slashCommandResult.modelOverride
+              )) {
+                inlineModelOverride = slashCommandResult.modelOverride;
+                debugLogger.debug(
+                  `[runNonInteractive] inline model override captured: ${inlineModelOverride}`
+                );
+              } else if (slashCommandResult.modelOverride !== void 0) {
+                debugLogger.warn(
+                  `[runNonInteractive] ignoring model override '${slashCommandResult.modelOverride}': not a model on the active provider`
+                );
+              }
               slashHandled = true;
               break;
             case "message": {
@@ -343,13 +439,13 @@ ${text}
         };
         return Array.isArray(existing) ? [reminderPart, ...existing] : [reminderPart, existing];
       }, "withReminder");
-      const startupNotice = config.consumePendingStartupWorktreeNotice();
+      const startupNotice = options.continueInterrupted ? null : config.consumePendingStartupWorktreeNotice();
       if (startupNotice) {
         initialPartList = withReminder(initialPartList, startupNotice);
         adapter.emitSystemMessage("worktree_started", {
           notice: startupNotice
         });
-      } else if (config.getResumedSessionData()) {
+      } else if (!options.continueInterrupted && config.getResumedSessionData()) {
         try {
           const sessionPath = config.getSessionService().getWorktreeSessionPath(sessionId);
           const restored = await restoreWorktreeContext(sessionPath);
@@ -434,7 +530,13 @@ ${text}
       }
       let isFirstTurn = true;
       let hasUnsentToolResponse = false;
-      let modelOverride;
+      let modelOverride = inlineModelOverride;
+      const inlineModelOverrideActive = inlineModelOverride !== void 0;
+      if (inlineModelOverrideActive) {
+        debugLogger.debug(
+          `[runNonInteractive] inline model override active for turn: ${inlineModelOverride}`
+        );
+      }
       let structuredSubmission = void 0;
       let plainTextPreview = "";
       const PLAIN_TEXT_PREVIEW_LIMIT = 200;
@@ -451,7 +553,7 @@ ${text}
         const metrics = uiTelemetryService.getMetrics();
         const usage = computeUsageFromMetrics(metrics);
         const stats = outputFormat === "json" /* JSON */ ? uiTelemetryService.getMetrics() : void 0;
-        adapter.emitResult({
+        emitResult({
           isError: false,
           durationMs: Date.now() - startTime,
           apiDurationMs: totalApiDurationMs,
@@ -484,9 +586,11 @@ ${text}
         return 1;
       }, "emitLoopDetectedResult");
       const handledProviderToolCallIds = geminiClient.getHistoryFunctionResponseIds();
+      const duplicateProviderToolCallResponseIds = /* @__PURE__ */ new Set();
       const processToolCallBatch = /* @__PURE__ */ __name(async (batchRequests, setModelOverride) => {
         const toolResponseParts = [];
         const structuredOutputActive = config.getJsonSchema() && batchRequests.some((r) => r.name === ToolNames.STRUCTURED_OUTPUT);
+        const getProviderResponseId = /* @__PURE__ */ __name((request) => request.providerCallId ?? (structuredOutputActive ? void 0 : request.callId || void 0), "getProviderResponseId");
         const seenBatchCallIds = /* @__PURE__ */ new Set();
         const duplicateBatchRequests = [];
         const uniqueBatchRequests = batchRequests.filter((request) => {
@@ -505,22 +609,43 @@ ${text}
           }
           return true;
         });
+        const repeatedDuplicateRequest = findRepeatedDuplicateProviderToolCall(
+          [...uniqueBatchRequests, ...duplicateBatchRequests],
+          getProviderResponseId,
+          handledProviderToolCallIds,
+          duplicateProviderToolCallResponseIds
+        );
+        if (repeatedDuplicateRequest) {
+          const providerCallId = repeatedDuplicateRequest.providerCallId ?? repeatedDuplicateRequest.callId;
+          debugLogger.debug(
+            `[runNonInteractive] Dropping batch after repeated duplicate provider tool-call id: ${providerCallId} (tool: ${repeatedDuplicateRequest.name})`
+          );
+          return {
+            responseParts: [],
+            repeatedDuplicateProviderToolCall: true
+          };
+        }
         const respondedRequests = /* @__PURE__ */ new Set();
         const executableBatchRequests = [];
         const duplicatePendingResponses = [];
         for (const requestInfo of uniqueBatchRequests) {
-          if (!requestInfo.providerCallId) {
+          const providerCallId = getProviderResponseId(requestInfo);
+          if (!providerCallId) {
             executableBatchRequests.push(requestInfo);
             continue;
           }
-          if (!handledProviderToolCallIds.has(requestInfo.providerCallId)) {
-            handledProviderToolCallIds.add(requestInfo.providerCallId);
+          if (!handledProviderToolCallIds.has(providerCallId)) {
+            handledProviderToolCallIds.add(providerCallId);
             executableBatchRequests.push(requestInfo);
             continue;
           }
+          markDuplicateProviderToolCallResponseSent(
+            providerCallId,
+            duplicateProviderToolCallResponseIds
+          );
           const toolResponse = createDuplicateProviderToolCallResponse(requestInfo);
           debugLogger.debug(
-            `[runNonInteractive] Suppressing duplicate provider tool-call id: ${requestInfo.providerCallId} (tool: ${requestInfo.name})`
+            `[runNonInteractive] Suppressing duplicate provider tool-call id: ${providerCallId} (tool: ${requestInfo.name})`
           );
           respondedRequests.add(requestInfo);
           adapter.emitToolResult(requestInfo, toolResponse);
@@ -615,11 +740,20 @@ ${text}
           }
         }
         for (const requestInfo of duplicateBatchRequests) {
+          const providerCallId = getProviderResponseId(requestInfo);
+          if (!providerCallId) continue;
+          markDuplicateProviderToolCallResponseSent(
+            providerCallId,
+            duplicateProviderToolCallResponseIds
+          );
           const toolResponse = createDuplicateProviderToolCallResponse(requestInfo);
           adapter.emitToolResult(requestInfo, toolResponse);
           toolResponseParts.push(...toolResponse.responseParts);
         }
-        return toolResponseParts;
+        return {
+          responseParts: toolResponseParts,
+          repeatedDuplicateProviderToolCall: false
+        };
       }, "processToolCallBatch");
       while (true) {
         let isTeammateTurn = false;
@@ -643,7 +777,7 @@ ${text}
         }
         let sendType;
         if (isFirstTurn) {
-          sendType = options.sendMessageType ?? "userQuery" /* UserQuery */;
+          sendType = continueSendType ?? options.sendMessageType ?? "userQuery" /* UserQuery */;
         } else if (isTeammateTurn) {
           sendType = "teammate" /* Teammate */;
         } else {
@@ -703,15 +837,24 @@ ${text}
           return emitLoopDetectedResult();
         }
         if (toolCallRequests.length > 0) {
-          const toolResponseParts = await processToolCallBatch(
-            toolCallRequests,
-            (override) => {
+          const {
+            responseParts: toolResponseParts,
+            repeatedDuplicateProviderToolCall
+          } = await processToolCallBatch(toolCallRequests, (override) => {
+            if (!inlineModelOverrideActive) {
               modelOverride = override;
             }
-          );
+          });
           if (structuredSubmission !== void 0) {
             return emitStructuredSuccess();
           }
+          if (repeatedDuplicateProviderToolCall && toolResponseParts.length === 0) {
+            loopDetectedMessage = emitLoopDetectedMessage(
+              config,
+              "global_tool_call_duplicate" /* GLOBAL_TOOL_CALL_DUPLICATE */
+            );
+            return emitLoopDetectedResult();
+          }
           currentMessages = [{ role: "user", parts: toolResponseParts }];
           hasUnsentToolResponse = true;
         } else {
@@ -837,7 +980,10 @@ ${text}
                 return;
               }
               if (itemToolCallRequests.length > 0) {
-                const itemToolResponseParts = await processToolCallBatch(
+                const {
+                  responseParts: itemToolResponseParts,
+                  repeatedDuplicateProviderToolCall
+                } = await processToolCallBatch(
                   itemToolCallRequests,
                   (override) => {
                     itemModelOverride = override;
@@ -846,6 +992,14 @@ ${text}
                 if (structuredSubmission !== void 0) {
                   return;
                 }
+                if (repeatedDuplicateProviderToolCall && itemToolResponseParts.length === 0) {
+                  loopDetectedMessage = emitLoopDetectedMessage(
+                    config,
+                    "global_tool_call_duplicate" /* GLOBAL_TOOL_CALL_DUPLICATE */
+                  );
+                  loopDetected = true;
+                  return;
+                }
                 itemMessages = [{ role: "user", parts: itemToolResponseParts }];
               } else {
                 break;
@@ -870,6 +1024,9 @@ ${text}
           }, "drainLocalQueue");
           const scheduler = !config.isCronEnabled() ? null : config.getCronScheduler();
           if (scheduler) {
+            scheduler.setSkipDurableFire(
+              (job) => isHeadlessLoopSentinel(job.prompt)
+            );
             await scheduler.enableDurable(config.getSessionId()).catch((err) => {
               debugLogger.warn(
                 `Durable cron init failed \u2014 persistent tasks will not fire in this run: ${err}`
@@ -912,6 +1069,10 @@ ${text}
                 reject(err);
               }, "onDrainError");
               scheduler.start((job) => {
+                if (skipHeadlessLoopSentinel(scheduler, job)) {
+                  checkCronDone();
+                  return;
+                }
                 const label = job.prompt.slice(0, 40);
                 localQueue.push({
                   displayText: `${job.cronExpr === "@wakeup" ? "Loop" : "Cron"}: ${label}`,
@@ -953,7 +1114,7 @@ ${text}
             const previewSnippet = plainTextPreview.trim();
             const previewSuffix = previewSnippet ? ` Output preview (${plainTextPreview.length}${plainTextPreview.length >= PLAIN_TEXT_PREVIEW_LIMIT ? "+" : ""} chars): ${JSON.stringify(previewSnippet)}.` : "";
             const errorMessage = `Model produced plain text instead of calling the structured_output tool as required by --json-schema after ${turnCount} turn(s).` + previewSuffix;
-            adapter.emitResult({
+            emitResult({
               isError: true,
               durationMs: Date.now() - startTime,
               apiDurationMs: totalApiDurationMs,
@@ -964,7 +1125,7 @@ ${text}
             });
             return 1;
           }
-          adapter.emitResult({
+          emitResult({
             isError: false,
             durationMs: Date.now() - startTime,
             apiDurationMs: totalApiDurationMs,
@@ -991,7 +1152,7 @@ ${text}
       const skipAdapterEmit = outputFormat === "text" /* TEXT */ && isAlreadyReportedError;
       if (!skipAdapterEmit) {
         try {
-          adapter.emitResult({
+          emitResult({
             isError: true,
             durationMs: Date.now() - startTime,
             apiDurationMs: totalApiDurationMs,
@@ -1043,6 +1204,7 @@ ${text}
 __name(runNonInteractive, "runNonInteractive");
 
 export {
+  skipHeadlessLoopSentinel,
   runNonInteractive
 };
 /**

package/chunks/{chunk-EW6C27XX.js → chunk-QHHNFG22.js}

@@ -1,9 +1,12 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  isTlsVerificationDisabled
+} from "./chunk-FQDMX5IL.js";
 import {
   getErrorMessage,
   isNodeError
-} from "./chunk-C4K3FEQ2.js";
+} from "./chunk-AVQDCKNF.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -146,8 +149,11 @@ function formatFetchErrorForUser(error, options = {}) {
     "Troubleshooting:",
     ...options.url ? [`- Confirm you can reach ${options.url} from this machine.`] : [],
     "- If you are behind a proxy, pass `--proxy <url>` (or set `proxy` in settings).",
-    ...shouldShowTlsHint ? [
-      "- If your network uses a corporate TLS inspection CA, set `NODE_EXTRA_CA_CERTS` to your CA bundle."
+    ...shouldShowTlsHint ? isTlsVerificationDisabled() ? [
+      "- TLS verification is already disabled (`--insecure` / `QWEN_TLS_INSECURE`), so this is likely a network or protocol issue rather than a certificate trust problem."
+    ] : [
+      "- If your network uses a corporate TLS inspection CA, set `NODE_EXTRA_CA_CERTS` to your CA bundle.",
+      "- For a trusted self-signed endpoint, pass `--insecure` (or set `QWEN_TLS_INSECURE=1`) to skip certificate verification."
     ] : []
   ];
   return `${fullErrorMessage}${hintLines.join("\n")}`;

package/chunks/chunk-QYUE6W3T.js

@@ -0,0 +1,123 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+import {
+  __commonJS,
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// node_modules/strip-json-comments/index.js
+var require_strip_json_comments = __commonJS({
+  "node_modules/strip-json-comments/index.js"(exports, module) {
+    "use strict";
+    init_esbuild_shims();
+    var singleComment = Symbol("singleComment");
+    var multiComment = Symbol("multiComment");
+    var stripWithoutWhitespace = /* @__PURE__ */ __name(() => "", "stripWithoutWhitespace");
+    var stripWithWhitespace = /* @__PURE__ */ __name((string, start, end) => string.slice(start, end).replace(/\S/g, " "), "stripWithWhitespace");
+    var isEscaped = /* @__PURE__ */ __name((jsonString, quotePosition) => {
+      let index = quotePosition - 1;
+      let backslashCount = 0;
+      while (jsonString[index] === "\\") {
+        index -= 1;
+        backslashCount += 1;
+      }
+      return Boolean(backslashCount % 2);
+    }, "isEscaped");
+    module.exports = (jsonString, options = {}) => {
+      if (typeof jsonString !== "string") {
+        throw new TypeError(`Expected argument \`jsonString\` to be a \`string\`, got \`${typeof jsonString}\``);
+      }
+      const strip = options.whitespace === false ? stripWithoutWhitespace : stripWithWhitespace;
+      let insideString = false;
+      let insideComment = false;
+      let offset = 0;
+      let result = "";
+      for (let i = 0; i < jsonString.length; i++) {
+        const currentCharacter = jsonString[i];
+        const nextCharacter = jsonString[i + 1];
+        if (!insideComment && currentCharacter === '"') {
+          const escaped = isEscaped(jsonString, i);
+          if (!escaped) {
+            insideString = !insideString;
+          }
+        }
+        if (insideString) {
+          continue;
+        }
+        if (!insideComment && currentCharacter + nextCharacter === "//") {
+          result += jsonString.slice(offset, i);
+          offset = i;
+          insideComment = singleComment;
+          i++;
+        } else if (insideComment === singleComment && currentCharacter + nextCharacter === "\r\n") {
+          i++;
+          insideComment = false;
+          result += strip(jsonString, offset, i);
+          offset = i;
+          continue;
+        } else if (insideComment === singleComment && currentCharacter === "\n") {
+          insideComment = false;
+          result += strip(jsonString, offset, i);
+          offset = i;
+        } else if (!insideComment && currentCharacter + nextCharacter === "/*") {
+          result += jsonString.slice(offset, i);
+          offset = i;
+          insideComment = multiComment;
+          i++;
+          continue;
+        } else if (insideComment === multiComment && currentCharacter + nextCharacter === "*/") {
+          i++;
+          insideComment = false;
+          result += strip(jsonString, offset, i + 1);
+          offset = i + 1;
+          continue;
+        }
+      }
+      return result + (insideComment ? strip(jsonString.slice(offset)) : jsonString.slice(offset));
+    };
+  }
+});
+
+// packages/cli/src/config/path-comparison.ts
+init_esbuild_shims();
+import * as fs from "node:fs";
+import * as path from "node:path";
+function isWithinRoot(childPath, parentPath) {
+  const relativePath = path.relative(parentPath, childPath);
+  return relativePath === "" || !relativePath.startsWith(`..${path.sep}`) && relativePath !== ".." && !path.isAbsolute(relativePath);
+}
+__name(isWithinRoot, "isWithinRoot");
+function getPathComparisonVariants(rawPath) {
+  const variants = /* @__PURE__ */ new Set([path.normalize(path.resolve(rawPath))]);
+  try {
+    variants.add(path.normalize(fs.realpathSync(rawPath)));
+  } catch {
+  }
+  return variants;
+}
+__name(getPathComparisonVariants, "getPathComparisonVariants");
+function arePathsEquivalent(left, right) {
+  const rightVariants = getPathComparisonVariants(right);
+  for (const leftVariant of getPathComparisonVariants(left)) {
+    if (rightVariants.has(leftVariant)) {
+      return true;
+    }
+  }
+  return false;
+}
+__name(arePathsEquivalent, "arePathsEquivalent");
+
+export {
+  require_strip_json_comments,
+  isWithinRoot,
+  getPathComparisonVariants,
+  arePathsEquivalent
+};
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-GZCJS5WH.js → chunk-SJBIFVD2.js}

@@ -5,11 +5,11 @@ import {
 } from "./chunk-OMX7CUOE.js";
 import {
   atomicWriteJSON
-} from "./chunk-3UALQ56H.js";
+} from "./chunk-T42ACHFI.js";
 import {
   Storage,
   getProjectHash
-} from "./chunk-C4K3FEQ2.js";
+} from "./chunk-AVQDCKNF.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-3UALQ56H.js → chunk-T42ACHFI.js}

@@ -3,7 +3,7 @@
 import {
   createDebugLogger,
   isNodeError
-} from "./chunk-C4K3FEQ2.js";
+} from "./chunk-AVQDCKNF.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";