@qwen-code/qwen-code 0.19.2 → 0.19.3-nightly.20260630.e00fe6a27

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

@@ -2,26 +2,28 @@
 "use strict";
 import {
   handleAtCommand
-} from "./chunk-B6HQGTYR.js";
+} from "./chunk-7UNP2XM7.js";
 import {
   JsonOutputAdapter
-} from "./chunk-EX4W6ZYG.js";
+} from "./chunk-G5G4TFZ7.js";
 import {
   StreamJsonOutputAdapter
-} from "./chunk-J6AW7O5D.js";
+} from "./chunk-WHDQZHRU.js";
 import {
+  buildInitialSystemReminders,
   buildSystemMessage,
   computeUsageFromMetrics,
   createAgentToolProgressHandler,
   createToolProgressHandler,
   extractPartsFromUserMessage,
   handleSlashCommand,
+  insertAfterFunctionResponses,
   isSlashCommand,
   normalizePartList
-} from "./chunk-2TJ3YN6Q.js";
+} from "./chunk-2RJA6J57.js";
 import {
   RunBudgetEnforcer
-} from "./chunk-ZUAXI2OA.js";
+} from "./chunk-BOJWHRMX.js";
 import {
   AlreadyReportedError,
   handleBudgetExceededError,
@@ -29,26 +31,33 @@ import {
   handleError,
   handleMaxTurnsExceededError,
   handleToolError
-} from "./chunk-5R4SBCX6.js";
+} from "./chunk-SL5MOGQH.js";
 import {
+  ORPHAN_TOOL_USE_REPAIR_REASON,
+  buildSyntheticToolResponseParts,
   createDuplicateProviderToolCallResponse,
+  detectLoopSentinel,
+  detectTurnInterruption,
   executeToolCall,
+  findRepeatedDuplicateProviderToolCall,
+  isSystemReminderContent,
+  markDuplicateProviderToolCallResponseSent,
   parseAndFormatApiError,
   promptIdContext,
   restoreWorktreeContext
-} from "./chunk-PXFFKNCO.js";
+} from "./chunk-RIP623NO.js";
 import {
   isTelemetrySdkInitialized,
   shutdownTelemetry,
   uiTelemetryService
-} from "./chunk-WA5OJGFL.js";
+} from "./chunk-SS6WJMQK.js";
 import {
   ToolNames
-} from "./chunk-TOEGRAVX.js";
+} from "./chunk-BX5YO7UW.js";
 import {
   FatalInputError,
   createDebugLogger
-} from "./chunk-C4K3FEQ2.js";
+} from "./chunk-UX4SGCGN.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -72,6 +81,7 @@ 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"
@@ -79,11 +89,26 @@ var LOOP_TYPE_LABELS = {
 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 */;
   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 (!detectLoopSentinel(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 +157,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 +276,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 +295,49 @@ ${reason}
       let initialPartList = extractPartsFromUserMessage(
         options.userMessage
       );
+      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)) {
@@ -343,13 +416,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);
@@ -451,7 +524,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 +557,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 +580,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 +711,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 +748,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 +808,22 @@ ${text}
           return emitLoopDetectedResult();
         }
         if (toolCallRequests.length > 0) {
-          const toolResponseParts = await processToolCallBatch(
-            toolCallRequests,
-            (override) => {
-              modelOverride = override;
-            }
-          );
+          const {
+            responseParts: toolResponseParts,
+            repeatedDuplicateProviderToolCall
+          } = await processToolCallBatch(toolCallRequests, (override) => {
+            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 +949,10 @@ ${text}
                 return;
               }
               if (itemToolCallRequests.length > 0) {
-                const itemToolResponseParts = await processToolCallBatch(
+                const {
+                  responseParts: itemToolResponseParts,
+                  repeatedDuplicateProviderToolCall
+                } = await processToolCallBatch(
                   itemToolCallRequests,
                   (override) => {
                     itemModelOverride = override;
@@ -846,6 +961,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 +993,9 @@ ${text}
           }, "drainLocalQueue");
           const scheduler = !config.isCronEnabled() ? null : config.getCronScheduler();
           if (scheduler) {
+            scheduler.setSkipDurableFire(
+              (job) => detectLoopSentinel(job.prompt) !== null
+            );
             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 +1038,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 +1083,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 +1094,7 @@ ${text}
             });
             return 1;
           }
-          adapter.emitResult({
+          emitResult({
             isError: false,
             durationMs: Date.now() - startTime,
             apiDurationMs: totalApiDurationMs,
@@ -991,7 +1121,7 @@ ${text}
       const skipAdapterEmit = outputFormat === "text" /* TEXT */ && isAlreadyReportedError;
       if (!skipAdapterEmit) {
         try {
-          adapter.emitResult({
+          emitResult({
             isError: true,
             durationMs: Date.now() - startTime,
             apiDurationMs: totalApiDurationMs,
@@ -1043,6 +1173,7 @@ ${text}
 __name(runNonInteractive, "runNonInteractive");
 
 export {
+  skipHeadlessLoopSentinel,
   runNonInteractive
 };
 /**

package/chunks/{chunk-JTYRZODB.js → chunk-FOOIZCWL.js}

@@ -7,28 +7,28 @@ import {
   require_jsx_runtime,
   use_stdin_default,
   use_stdout_default
-} from "./chunk-UAARJR2G.js";
+} from "./chunk-WQT5SOI6.js";
 import {
   require_react
 } from "./chunk-KYMBIKIW.js";
 import {
   sanitizeFilenameForDisplay
-} from "./chunk-CGOMICBE.js";
+} from "./chunk-BSZEQNUA.js";
 import {
   t
-} from "./chunk-5JZLXFPD.js";
+} from "./chunk-MTHMXSNT.js";
 import {
   fetchGitDiff,
   findProviderByCredentials,
   resolveMetadataKey
-} from "./chunk-PXFFKNCO.js";
+} from "./chunk-RIP623NO.js";
 import {
   KittySequenceOverflowEvent,
   logKittySequenceOverflow
-} from "./chunk-WA5OJGFL.js";
+} from "./chunk-SS6WJMQK.js";
 import {
   createDebugLogger
-} from "./chunk-C4K3FEQ2.js";
+} from "./chunk-UX4SGCGN.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -759,6 +759,7 @@ var useFocus = /* @__PURE__ */ __name(() => {
 // packages/cli/src/ui/contexts/KeypressContext.tsx
 var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
 var ESC3 = "\x1B";
+var OPTION_T_COMPOSED_GLYPH = "\u2020";
 var PASTE_MODE_PREFIX = `${ESC3}[200~`;
 var PASTE_MODE_SUFFIX = `${ESC3}[201~`;
 var KITTY_SEQUENCE_TIMEOUT_MS = 200;
@@ -1529,6 +1530,10 @@ function KeypressProvider({
       if (key.name === "return" && key.sequence === `${ESC3}\r`) {
         key.meta = true;
       }
+      if (process.platform === "darwin" && !isPaste && key.sequence === OPTION_T_COMPOSED_GLYPH) {
+        key.name = "t";
+        key.meta = true;
+      }
       broadcast({ ...key, paste: isPaste });
     }, "handleKeypress");
     const clearRawFlushTimeout = /* @__PURE__ */ __name(() => {
@@ -2036,7 +2041,11 @@ function convertToHistoryItems(conversation, config) {
             });
             currentToolGroup = [];
           }
-          items.push({ type: "gemini", text });
+          items.push({
+            type: "gemini",
+            text,
+            timestamp: new Date(record.timestamp).getTime()
+          });
         }
         for (const fc of functionCalls) {
           const tool = getTool(config, fc.name);

package/chunks/{chunk-EX4W6ZYG.js → chunk-G5G4TFZ7.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   BaseJsonOutputAdapter
-} from "./chunk-J6AW7O5D.js";
+} from "./chunk-WHDQZHRU.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

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

@@ -1,9 +1,12 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  isTlsVerificationDisabled
+} from "./chunk-E6XQPQXW.js";
 import {
   getErrorMessage,
   isNodeError
-} from "./chunk-C4K3FEQ2.js";
+} from "./chunk-UX4SGCGN.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")}`;