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

package/chunks/{acpAgent-QYZFICEZ.js → acpAgent-UMN6OYTR.js}

@@ -3,13 +3,13 @@
 import {
   classifyApiError,
   prefixMidTurnUserMessageParts
-} from "./chunk-DJ25MIU2.js";
+} from "./chunk-VKGG724L.js";
 import {
   EXTENSION_CONTEXT_BUDGET,
   buildExtensionMentionContext,
   matchExtensionByRef,
   parseExtensionRef
-} from "./chunk-YCEHOJZJ.js";
+} from "./chunk-MNDTD5E5.js";
 import {
   HistoryReplayer,
   MessageEmitter,
@@ -20,76 +20,87 @@ import {
   insertAfterFunctionResponses,
   isSlashCommand,
   normalizePartList
-} from "./chunk-NOYV2NXI.js";
-import {
-  collectContextData,
-  formatContextUsageText
-} from "./chunk-GZKQ36JS.js";
+} from "./chunk-ZXCVPMIK.js";
 import {
   appEvents,
   buildDisabledSkillNamesProvider,
   loadCliConfig,
   normalizeDisabledToolList
-} from "./chunk-ZGSV5ORL.js";
+} from "./chunk-MVZXZWGT.js";
+import "./chunk-JZSY4WP3.js";
+import {
+  collectContextData,
+  formatContextUsageText
+} from "./chunk-SFN4TEHY.js";
 import {
   getCommandSubcommandNames
-} from "./chunk-BLAE2TCO.js";
-import "./chunk-32MCHZQC.js";
+} from "./chunk-TTFNVEO5.js";
+import "./chunk-CG7SVARK.js";
 import {
   getEffectiveSupportedModes
-} from "./chunk-IBEM64M4.js";
+} from "./chunk-75X2VLSH.js";
 import {
   isTerminalGoalStatusKind
 } from "./chunk-KSPVDFE4.js";
 import "./chunk-MRO43B25.js";
 import "./chunk-VXGPYF7U.js";
-import "./chunk-N4V4VBP6.js";
+import "./chunk-2X2JUE47.js";
 import "./chunk-KYMBIKIW.js";
-import "./chunk-JZSY4WP3.js";
 import "./chunk-HTWHAN44.js";
-import "./chunk-7SP275SH.js";
+import "./chunk-AHNXYU4O.js";
+import "./chunk-ND25GXEU.js";
+import "./chunk-BJBWRCSK.js";
+import "./chunk-CS5XYDBO.js";
 import "./chunk-3GONHQOA.js";
-import "./chunk-AIBPG5MB.js";
-import "./chunk-LDWTYE33.js";
-import "./chunk-2JKEQWDZ.js";
+import "./chunk-OAFUMTWW.js";
+import "./chunk-J3F7X3LW.js";
 import {
+  createLoadedSettingsAdapter
+} from "./chunk-73H73ASU.js";
+import {
+  MAX_REMEMBER_CONTENT_BYTES,
+  extractRememberErrorCode,
   isValidServerName
-} from "./chunk-UAKXW3DN.js";
-import "./chunk-Q3JOGB4U.js";
-import "./chunk-M2U5NM24.js";
-import "./chunk-GDIG7TMG.js";
-import "./chunk-G525INVW.js";
+} from "./chunk-RM3PGSGL.js";
+import "./chunk-L7QPM2YD.js";
+import "./chunk-54YZOP7P.js";
+import "./chunk-HRZB5CSC.js";
+import "./chunk-RNBYOUGV.js";
+import "./chunk-W2ZOAX7F.js";
 import "./chunk-KHDZHZMH.js";
+import "./chunk-W6X4FGWX.js";
+import {
+  CLIENT_MCP_OVER_WS_CONFIG_FLAG,
+  MID_TURN_QUEUE_DRAIN_METHOD
+} from "./chunk-EWALXUAD.js";
+import "./chunk-ALX6BUYW.js";
 import {
   formatAcpModelId,
   parseAcpBaseModelId,
   parseAcpModelOption,
   sanitizeProviderBaseUrl
-} from "./chunk-OEY3YAL2.js";
+} from "./chunk-BQNJBEUA.js";
 import {
   PERMISSION_RULE_TYPES,
   PermissionRulesValidationError,
   buildPermissionSettings,
   normalizePermissionRules,
   readPermissionRuleSet
-} from "./chunk-DBR7PF4B.js";
-import "./chunk-LXEW6BHF.js";
+} from "./chunk-QAFQLTXG.js";
+import "./chunk-Q7VHIRDD.js";
 import "./chunk-NIOPRZNN.js";
 import {
   NOT_CURRENTLY_GENERATING_CANCEL_MESSAGE
-} from "./chunk-DHXWNSJA.js";
-import "./chunk-HIYUAXBG.js";
-import {
-  CLIENT_MCP_OVER_WS_CONFIG_FLAG,
-  MID_TURN_QUEUE_DRAIN_METHOD
-} from "./chunk-EWALXUAD.js";
+} from "./chunk-T22H4V4R.js";
 import "./chunk-SEZC2725.js";
-import "./chunk-TMILTLP3.js";
-import "./chunk-BJBWRCSK.js";
-import "./chunk-ALX6BUYW.js";
 import {
-  createLoadedSettingsAdapter
-} from "./chunk-VN4CKYUW.js";
+  ACP_PREFLIGHT_KINDS,
+  IDLE_HOOK_EVENTS,
+  SERVE_CONTROL_EXT_METHODS,
+  SERVE_STATUS_EXT_METHODS,
+  STATUS_SCHEMA_VERSION,
+  mapDomainErrorToErrorKind
+} from "./chunk-GICCHL2Q.js";
 import {
   OUTPUT_LANGUAGE_AUTO,
   getOutputLanguageFilePath,
@@ -100,33 +111,29 @@ import {
   resolveOutputLanguage,
   updateOutputLanguageFile,
   writeOutputLanguageAndRegisterPath
-} from "./chunk-6FIWYVN4.js";
+} from "./chunk-MKHC4BYZ.js";
 import {
   SUPPORTED_LANGUAGES,
   getCurrentLanguage,
   setLanguageAsync
-} from "./chunk-3O2BJMFW.js";
+} from "./chunk-UQYOMM6J.js";
 import "./chunk-TLRYABYP.js";
+import "./chunk-EDAGQADF.js";
+import "./chunk-MX2YXRER.js";
+import "./chunk-HI55Z6PR.js";
 import {
   AgentSideConnection,
   PROTOCOL_VERSION,
   RequestError,
   ndJsonStream
 } from "./chunk-UFC57OYT.js";
-import {
-  ACP_PREFLIGHT_KINDS,
-  IDLE_HOOK_EVENTS,
-  SERVE_CONTROL_EXT_METHODS,
-  SERVE_STATUS_EXT_METHODS,
-  STATUS_SCHEMA_VERSION,
-  mapDomainErrorToErrorKind
-} from "./chunk-VHRREANT.js";
+import "./chunk-OJCECIJA.js";
 import "./chunk-PPFWEV7G.js";
 import {
   isFolderTrustEnabled,
   isWorkspaceTrusted,
   loadTrustedFolders
-} from "./chunk-Z34RYLRO.js";
+} from "./chunk-ZJP5T7IA.js";
 import "./chunk-Y6Z2O3WR.js";
 import "./chunk-QYUE6W3T.js";
 import {
@@ -196,6 +203,7 @@ import {
   getProviderToolCallId,
   getScopedEnvContents,
   getStartupContextLength,
+  hasImageParts,
   injectPermissionRulesIfMissing,
   isApproveOutcome,
   isDenialFallbackReason,
@@ -204,6 +212,7 @@ import {
   markDuplicateProviderToolCallResponseSent,
   matchesAnyServerPattern,
   needsConfirmation,
+  normalizeParts,
   parsePositiveIntegerEnv,
   persistPermissionOutcome,
   readManyFiles,
@@ -213,34 +222,41 @@ import {
   resolveBaseUrl,
   restoreWorktreeContext,
   runForkedAgent,
+  runManagedRememberByAgent,
+  runVisionBridge,
   sessionIdContext,
   setGoalTerminalObserver,
+  shouldClassifyAllShellForAutoMode,
   shouldFallback,
   shouldFirePermissionDeniedForAutoMode,
   shouldForceAutoModeReviewForAllow,
   shouldRunAutoModeForCall,
+  shouldRunVisionBridge,
+  splitImageParts,
   subagentGenerator,
   unregisterGoalHook,
   updateSetting
-} from "./chunk-35FH347N.js";
+} from "./chunk-BFG6OZN7.js";
+import "./chunk-5P5XGNYH.js";
 import {
   external_exports
 } from "./chunk-K5PGHDBN.js";
-import "./chunk-5P5XGNYH.js";
 import "./chunk-SKAZWEV5.js";
-import "./chunk-ESVSWG6Z.js";
-import "./chunk-CA4ML3VH.js";
-import "./chunk-HWG4XLD7.js";
+import "./chunk-QOMAHFYI.js";
+import "./chunk-G7OQ3RFJ.js";
+import "./chunk-LKWAVAB5.js";
 import {
   runSideQuery
-} from "./chunk-YCRTJYSQ.js";
-import "./chunk-FZY7NH37.js";
+} from "./chunk-MEQWZGK5.js";
+import "./chunk-UANCYOOQ.js";
 import "./chunk-2MPVVENX.js";
 import "./chunk-ZTQ26VBE.js";
 import "./chunk-SJBIFVD2.js";
 import "./chunk-MLZQVCF3.js";
+import "./chunk-S5EQPDTM.js";
 import "./chunk-LQ7TMOCE.js";
-import "./chunk-LD2XBG6Z.js";
+import "./chunk-E5A7LHNN.js";
+import "./chunk-GO6LNQXT.js";
 import "./chunk-B236XPGF.js";
 import {
   HookEventName,
@@ -270,8 +286,8 @@ import {
   startToolSpan,
   uiTelemetryService,
   withInteractionSpan
-} from "./chunk-B5MPZI4K.js";
-import "./chunk-3PJXIDKI.js";
+} from "./chunk-HJDF3ZVU.js";
+import "./chunk-E6US47KI.js";
 import "./chunk-UWCTAVOD.js";
 import "./chunk-OFEVLU4C.js";
 import "./chunk-OMX7CUOE.js";
@@ -280,16 +296,16 @@ import {
   getUserAutoMemoryRoot
 } from "./chunk-MOUXUCXQ.js";
 import "./chunk-BZHLWC6T.js";
-import "./chunk-E5I6YSNO.js";
+import "./chunk-UQFP2FEF.js";
 import {
   ToolConfirmationOutcome,
   ToolNames
-} from "./chunk-JV7A66DR.js";
+} from "./chunk-4VZH35PN.js";
 import {
   clearCachedCredentialFile,
   qwenOAuth2Events
-} from "./chunk-LXGWLOCM.js";
-import "./chunk-QHHNFG22.js";
+} from "./chunk-TENOUWY2.js";
+import "./chunk-GLPV75ES.js";
 import "./chunk-22IFUCVR.js";
 import "./chunk-T42ACHFI.js";
 import {
@@ -303,7 +319,7 @@ import "./chunk-55ZMG67I.js";
 import "./chunk-H6BD2ELD.js";
 import "./chunk-5IFG2VC4.js";
 import "./chunk-64WXLC72.js";
-import "./chunk-FQDMX5IL.js";
+import "./chunk-D5KISTLW.js";
 import {
   Storage,
   createDebugLogger,
@@ -311,10 +327,10 @@ import {
   getErrorStatus,
   isSubpath
 } from "./chunk-AVQDCKNF.js";
-import "./chunk-OE5J6UA7.js";
+import "./chunk-XCUFHOAD.js";
 import {
   runExitCleanup
-} from "./chunk-WJAY4WXR.js";
+} from "./chunk-FYKX6XOT.js";
 import "./chunk-ZERZSAZL.js";
 import "./chunk-QN5NZ3UQ.js";
 import "./chunk-BR4QREVK.js";
@@ -542,7 +558,6 @@ var AcpFileSystemService = class {
 import { Readable, Writable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import * as fs from "node:fs/promises";
-import { createRequire } from "node:module";
 import * as path3 from "node:path";
 import { createGunzip } from "node:zlib";
 
@@ -1252,6 +1267,8 @@ __name(maskApiKeyForDisplay, "maskApiKeyForDisplay");
 var DAEMON_TURN_TOOL_CALL_CAP = 100;
 var DAEMON_INVALID_TOOL_PARAMS_THRESHOLD = 3;
 var PERMISSION_CANCEL_SKIP_MESSAGE = "Skipped because a permission request was cancelled before the user answered; user input is required before continuing.";
+var LOOP_DETECTED_SKIP_MESSAGE = "Skipped because loop detection stopped the current turn before this tool call could run.";
+var LOOP_DETECTED_CONTEXT_MESSAGE = "System: this turn was terminated because the model exceeded tool-call safety limits. Try a different approach on the next turn.";
 function createDaemonToolLoopState() {
   return {
     totalToolCalls: 0,
@@ -1286,7 +1303,7 @@ __name(recordDaemonToolCalls, "recordDaemonToolCalls");
 function recordDaemonInvalidToolParams(config, promptId, loopState, toolName, error) {
   if (!loopState || loopState.loopDetected)
     return loopState?.loopDetected ?? false;
-  const key = `${toolName}\0${error.message}`;
+  const key = toolName;
   const count = (loopState.invalidToolParamErrors.get(key) ?? 0) + 1;
   loopState.invalidToolParamErrors.set(key, count);
   if (count < DAEMON_INVALID_TOOL_PARAMS_THRESHOLD) return false;
@@ -1465,6 +1482,17 @@ var MidTurnDrainTimeoutError = class extends Error {
   }
 };
 var MAX_NOTIFICATION_QUEUE = 20;
+function resolveHomeLoopResolverRoots({
+  homeQwenDir = Storage.getGlobalQwenDir(),
+  homeDir = os.homedir(),
+  qwenHome = process.env["QWEN_HOME"]
+} = {}) {
+  return {
+    homeConfineRoot: (qwenHome ? homeQwenDir : homeDir) || path2.dirname(homeQwenDir),
+    homeQwenDir
+  };
+}
+__name(resolveHomeLoopResolverRoots, "resolveHomeLoopResolverRoots");
 function computeInitialTurnFromHistory(records, sessionId) {
   let maxPromptTurn = 0;
   let userMessageCount = 0;
@@ -2386,7 +2414,7 @@ ${this.pendingWorktreeNotice}
                     toolLoopState
                   );
                   if (toolRun.stopAfterPermissionCancel) {
-                    await this.#preserveCancelledPermissionToolRun(
+                    await this.#preserveStoppedToolRun(
                       toolRun,
                       pendingSend.signal
                     );
@@ -2396,6 +2424,13 @@ ${this.pendingWorktreeNotice}
                     toolRun,
                     pendingSend.signal
                   );
+                  if (toolRun.loopDetected) {
+                    await this.#preserveStoppedToolRun(
+                      toolRun,
+                      pendingSend.signal
+                    );
+                    return { stopReason: "end_turn" };
+                  }
                 }
               }
               if (this.messageRewriter) {
@@ -2583,16 +2618,17 @@ ${this.pendingWorktreeNotice}
               toolLoopState
             );
             if (toolRun.stopAfterPermissionCancel) {
-              await this.#preserveCancelledPermissionToolRun(
-                toolRun,
-                pendingSend.signal
-              );
+              await this.#preserveStoppedToolRun(toolRun, pendingSend.signal);
               return { stopReason: "end_turn" };
             }
             nextMessage = await this.#buildNextMessageAfterToolRun(
               toolRun,
               pendingSend.signal
             );
+            if (toolRun.loopDetected) {
+              await this.#preserveStoppedToolRun(toolRun, pendingSend.signal);
+              return { stopReason: "end_turn" };
+            }
           }
         }
         continue;
@@ -2714,12 +2750,13 @@ ${this.pendingWorktreeNotice}
       });
     }
   }
-  async #preserveCancelledPermissionToolRun(toolRun, abortSignal) {
+  async #preserveStoppedToolRun(toolRun, abortSignal) {
     this.#preserveUnsentMessageHistory(
       {
         role: "user",
         parts: [
           ...toolRun.parts,
+          ...toolRun.loopDetected ? [{ text: LOOP_DETECTED_CONTEXT_MESSAGE }] : [],
           ...await this.#drainMidTurnUserMessages(abortSignal)
         ]
       },
@@ -3013,8 +3050,7 @@ ${this.pendingWorktreeNotice}
   #getLoopTickResolver() {
     const root = this.config.getWorkingDir();
     if (!this.loopTickResolver || this.loopTickResolverRoot !== root) {
-      const homeQwenDir = Storage.getGlobalQwenDir();
-      const homeConfineRoot = (process.env["QWEN_HOME"] ? homeQwenDir : os.homedir()) || path2.dirname(homeQwenDir);
+      const { homeConfineRoot, homeQwenDir } = resolveHomeLoopResolverRoots();
       this.loopTickResolver = new LoopTickResolver({
         projectRoot: root,
         homeDir: homeConfineRoot,
@@ -3187,16 +3223,17 @@ ${this.pendingWorktreeNotice}
                     toolLoopState
                   );
                   if (toolRun.stopAfterPermissionCancel) {
-                    await this.#preserveCancelledPermissionToolRun(
-                      toolRun,
-                      ac.signal
-                    );
+                    await this.#preserveStoppedToolRun(toolRun, ac.signal);
                     return;
                   }
                   nextMessage = await this.#buildNextMessageAfterToolRun(
                     toolRun,
                     ac.signal
                   );
+                  if (toolRun.loopDetected) {
+                    await this.#preserveStoppedToolRun(toolRun, ac.signal);
+                    return;
+                  }
                 }
               }
             } catch (error) {
@@ -3424,10 +3461,7 @@ ${this.pendingWorktreeNotice}
                 toolLoopState
               );
               if (toolRun.stopAfterPermissionCancel) {
-                await this.#preserveCancelledPermissionToolRun(
-                  toolRun,
-                  ac.signal
-                );
+                await this.#preserveStoppedToolRun(toolRun, ac.signal);
                 await this.#emitBackgroundNotificationEndTurn("end_turn");
                 return;
               }
@@ -3435,6 +3469,11 @@ ${this.pendingWorktreeNotice}
                 toolRun,
                 ac.signal
               );
+              if (toolRun.loopDetected) {
+                await this.#preserveStoppedToolRun(toolRun, ac.signal);
+                await this.#emitBackgroundNotificationEndTurn("end_turn");
+                return;
+              }
             }
           }
           if (this.messageRewriter) {
@@ -3673,19 +3712,57 @@ ${this.pendingWorktreeNotice}
    * on. Response-part ordering matches the original `functionCalls` order.
    */
   async runToolCalls(abortSignal, promptId, functionCalls, toolLoopState) {
+    const dedupedFunctionCalls = dedupeToolCallsById(functionCalls);
+    let skippedToolCallCounter = 0;
+    const recordSkippedToolCall = /* @__PURE__ */ __name(async (fc, message = PERMISSION_CANCEL_SKIP_MESSAGE, emitStart = true) => {
+      const toolName = fc.name ?? "unknown_tool";
+      const callId = fc.id ?? `${toolName}-skip-${++skippedToolCallCounter}`;
+      const part = {
+        functionResponse: {
+          id: callId,
+          name: toolName,
+          response: { error: message }
+        }
+      };
+      const error = new Error(message);
+      try {
+        this.config.getChatRecordingService()?.recordToolResult([part], {
+          callId,
+          status: "error",
+          resultDisplay: void 0,
+          error,
+          errorType: void 0
+        });
+        if (emitStart) {
+          await this.toolCallEmitter.emitStart({
+            callId,
+            toolName,
+            args: fc.args ?? {},
+            status: "pending"
+          });
+        }
+        await this.toolCallEmitter.emitError(callId, toolName, error);
+      } catch (recordError) {
+        debugLogger5.error("Failed to record skipped tool call:", recordError);
+      }
+      return part;
+    }, "recordSkippedToolCall");
     if (recordDaemonToolCalls(
       this.config,
       promptId,
       toolLoopState,
-      functionCalls.length
+      dedupedFunctionCalls.length
     )) {
       return {
-        parts: [],
+        parts: await Promise.all(
+          dedupedFunctionCalls.map(
+            (fc) => recordSkippedToolCall(fc, LOOP_DETECTED_SKIP_MESSAGE, false)
+          )
+        ),
         stopAfterPermissionCancel: false,
         loopDetected: true
       };
     }
-    const dedupedFunctionCalls = dedupeToolCallsById(functionCalls);
     const batches = [];
     const handledProviderToolCallIds = new Set(
       this.#getCurrentChat().getHistoryFunctionResponseIds()
@@ -3787,53 +3864,80 @@ ${this.pendingWorktreeNotice}
         batches.push({ kind: "execute", concurrent: isAgent, calls: [fc] });
       }
     }
-    let skippedToolCallCounter = 0;
-    const recordSkippedToolCall = /* @__PURE__ */ __name(async (fc) => {
-      const toolName = fc.name ?? "unknown_tool";
-      const callId = fc.id ?? `${toolName}-skip-${++skippedToolCallCounter}`;
-      const part = {
-        functionResponse: {
-          id: callId,
-          name: toolName,
-          response: { error: PERMISSION_CANCEL_SKIP_MESSAGE }
-        }
-      };
-      const error = new Error(PERMISSION_CANCEL_SKIP_MESSAGE);
-      try {
-        this.config.getChatRecordingService()?.recordToolResult([part], {
-          callId,
-          status: "error",
-          resultDisplay: void 0,
-          error,
-          errorType: void 0
-        });
-        await this.toolCallEmitter.emitStart({
-          callId,
-          toolName,
-          args: fc.args ?? {},
-          status: "pending"
-        });
-        await this.toolCallEmitter.emitError(callId, toolName, error);
-      } catch (recordError) {
-        debugLogger5.error("Failed to record skipped tool call:", recordError);
-      }
-      return part;
-    }, "recordSkippedToolCall");
-    const appendSkippedAfter = /* @__PURE__ */ __name(async (parts2, fc) => {
+    const appendSkippedAfter = /* @__PURE__ */ __name(async (parts2, fc, message = PERMISSION_CANCEL_SKIP_MESSAGE) => {
       const startIndex = dedupedFunctionCalls.indexOf(fc) + 1;
       for (const remainingCall of dedupedFunctionCalls.slice(startIndex)) {
-        parts2.push(await recordSkippedToolCall(remainingCall));
+        parts2.push(await recordSkippedToolCall(remainingCall, message));
       }
     }, "appendSkippedAfter");
-    const runBounded = /* @__PURE__ */ __name(async (calls, runAbortSignal, onStopAfterPermissionCancel, shouldSkipUnstarted) => {
-      const maxConcurrency = parsePositiveIntegerEnv(
+    const runBounded = /* @__PURE__ */ __name(async (calls, runAbortSignal, onStopAfterPermissionCancel, onStopAfterLoopDetected, shouldSkipUnstarted) => {
+      const configuredMaxConcurrency = parsePositiveIntegerEnv(
         process.env["QWEN_CODE_MAX_TOOL_CONCURRENCY"],
         10
       );
+      const maxConcurrency = toolLoopState ? Math.min(
+        configuredMaxConcurrency,
+        DAEMON_INVALID_TOOL_PARAMS_THRESHOLD
+      ) : configuredMaxConcurrency;
       const results = new Array(calls.length);
       const executing = /* @__PURE__ */ new Set();
-      for (let i = 0; i < calls.length; i++) {
+      const fillLoopSkippedFrom = /* @__PURE__ */ __name(async (startIndex2) => {
+        for (let i = startIndex2; i < calls.length; i++) {
+          if (results[i]) continue;
+          results[i] = {
+            parts: [
+              await recordSkippedToolCall(calls[i], LOOP_DETECTED_SKIP_MESSAGE)
+            ],
+            stopAfterPermissionCancel: false,
+            loopDetected: true
+          };
+        }
+      }, "fillLoopSkippedFrom");
+      const fillPermissionSkippedFrom = /* @__PURE__ */ __name(async (startIndex2) => {
+        for (let i = startIndex2; i < calls.length; i++) {
+          if (results[i]) continue;
+          results[i] = {
+            parts: [await recordSkippedToolCall(calls[i])],
+            stopAfterPermissionCancel: false
+          };
+        }
+      }, "fillPermissionSkippedFrom");
+      let startIndex = 0;
+      if (toolLoopState && calls.length > DAEMON_INVALID_TOOL_PARAMS_THRESHOLD) {
+        startIndex = DAEMON_INVALID_TOOL_PARAMS_THRESHOLD;
+        for (let i = 0; i < startIndex; i++) {
+          if (runAbortSignal.aborted && shouldSkipUnstarted?.()) {
+            results[i] = {
+              parts: [await recordSkippedToolCall(calls[i])],
+              stopAfterPermissionCancel: false
+            };
+            continue;
+          }
+          const r = await this.runTool(
+            runAbortSignal,
+            promptId,
+            calls[i],
+            onStopAfterPermissionCancel,
+            toolLoopState,
+            recordSkippedToolCall
+          );
+          results[i] = r;
+          if (r.loopDetected) {
+            await fillLoopSkippedFrom(i + 1);
+            return results;
+          }
+          if (r.stopAfterPermissionCancel) {
+            await fillPermissionSkippedFrom(i + 1);
+            return results;
+          }
+        }
+      }
+      for (let i = startIndex; i < calls.length; i++) {
         const idx = i;
+        if (toolLoopState?.loopDetected) {
+          await fillLoopSkippedFrom(idx);
+          return results;
+        }
         if (runAbortSignal.aborted && shouldSkipUnstarted?.()) {
           results[idx] = {
             parts: [await recordSkippedToolCall(calls[idx])],
@@ -3846,7 +3950,8 @@ ${this.pendingWorktreeNotice}
           promptId,
           calls[idx],
           onStopAfterPermissionCancel,
-          toolLoopState
+          toolLoopState,
+          recordSkippedToolCall
         ).then((r) => {
           results[idx] = r;
         }).finally(() => {
@@ -3855,6 +3960,23 @@ ${this.pendingWorktreeNotice}
         executing.add(p);
         if (executing.size >= maxConcurrency) {
           await Promise.race(executing);
+          if (results.some((result) => result?.loopDetected)) {
+            onStopAfterLoopDetected?.();
+            await Promise.all(executing);
+            await fillLoopSkippedFrom(idx + 1);
+            return results;
+          }
+          const invalidToolErrorNearThreshold = toolLoopState && [...toolLoopState.invalidToolParamErrors.values()].some(
+            (count) => count >= DAEMON_INVALID_TOOL_PARAMS_THRESHOLD - 1
+          );
+          if (invalidToolErrorNearThreshold && executing.size > 0) {
+            await Promise.all(executing);
+            if (results.some((result) => result?.loopDetected)) {
+              onStopAfterLoopDetected?.();
+              await fillLoopSkippedFrom(idx + 1);
+              return results;
+            }
+          }
         }
       }
       await Promise.all(executing);
@@ -3890,6 +4012,7 @@ ${this.pendingWorktreeNotice}
             batch.calls,
             batchAbortController.signal,
             stopBatchAfterPermissionCancel,
+            () => batchAbortController.abort("loop_detected"),
             () => batchStopAfterPermissionCancel
           );
         } finally {
@@ -3903,6 +4026,11 @@ ${this.pendingWorktreeNotice}
           shouldStopForLoop ||= r.loopDetected === true;
         }
         if (shouldStopForLoop) {
+          await appendSkippedAfter(
+            parts,
+            batch.calls[batch.calls.length - 1],
+            LOOP_DETECTED_SKIP_MESSAGE
+          );
           return {
             parts,
             stopAfterPermissionCancel: false,
@@ -3924,10 +4052,12 @@ ${this.pendingWorktreeNotice}
             promptId,
             fc,
             void 0,
-            toolLoopState
+            toolLoopState,
+            recordSkippedToolCall
           );
           parts.push(...r.parts);
           if (r.loopDetected) {
+            await appendSkippedAfter(parts, fc, LOOP_DETECTED_SKIP_MESSAGE);
             return {
               parts,
               stopAfterPermissionCancel: false,
@@ -3981,9 +4111,24 @@ ${this.pendingWorktreeNotice}
     }
     return reminders;
   }
-  async runTool(abortSignal, promptId, fc, onStopAfterPermissionCancel, toolLoopState) {
+  async runTool(abortSignal, promptId, fc, onStopAfterPermissionCancel, toolLoopState, recordSkippedToolCall) {
     const callId = fc.id ?? `${fc.name}-${Date.now()}`;
     let args = fc.args ?? {};
+    if (toolLoopState?.loopDetected) {
+      return {
+        parts: [
+          recordSkippedToolCall ? await recordSkippedToolCall(fc, LOOP_DETECTED_SKIP_MESSAGE, false) : {
+            functionResponse: {
+              id: callId,
+              name: fc.name ?? "unknown_tool",
+              response: { error: LOOP_DETECTED_SKIP_MESSAGE }
+            }
+          }
+        ],
+        stopAfterPermissionCancel: false,
+        loopDetected: true
+      };
+    }
     const startTime = Date.now();
     let spanError;
     let activeToolAbortSignal = abortSignal;
@@ -4036,20 +4181,32 @@ ${this.pendingWorktreeNotice}
         error,
         errorType: void 0
       });
+      const loopDetected = opts?.recordInvalidToolParams === true && !activeToolAbortSignal.aborted && !opts?.stopAfterPermissionCancel && recordDaemonInvalidToolParams(
+        this.config,
+        promptId,
+        toolLoopState,
+        toolName2,
+        error
+      );
       return {
         parts: errorParts,
-        stopAfterPermissionCancel: opts?.stopAfterPermissionCancel ?? false
+        stopAfterPermissionCancel: opts?.stopAfterPermissionCancel ?? false,
+        loopDetected
       };
     }, "earlyErrorResponse");
     if (!fc.name) {
-      return earlyErrorResponse(new Error("Missing function name"));
+      return earlyErrorResponse(new Error("Missing function name"), void 0, {
+        recordInvalidToolParams: true
+      });
     }
     const toolName = fc.name;
     const toolRegistry = this.config.getToolRegistry();
     const tool = toolRegistry.getTool(toolName);
     if (!tool) {
       return earlyErrorResponse(
-        new Error(`Tool "${toolName}" not found in registry.`)
+        new Error(`Tool "${toolName}" not found in registry.`),
+        toolName,
+        { recordInvalidToolParams: true }
       );
     }
     const toolSpan = startToolSpan(toolName, {
@@ -4133,7 +4290,7 @@ ${this.pendingWorktreeNotice}
               toolName
             );
           }
-          const forceAutoReviewForAllow = approvalMode === "auto" /* AUTO */ && shouldForceAutoModeReviewForAllow(pmCtx, this.config.getCwd());
+          const forceAutoReviewForAllow = approvalMode === "auto" /* AUTO */ && (shouldForceAutoModeReviewForAllow(pmCtx, this.config.getCwd()) || shouldClassifyAllShellForAutoMode(toolName, this.config));
           const confirmationPermission = getEffectivePermissionForConfirmation(
             finalPermission,
             forceAutoReviewForAllow
@@ -4733,12 +4890,29 @@ ${this.pendingWorktreeNotice}
     const FILE_URI_SCHEME = "file://";
     const embeddedContext = [];
     const extensionMentions = /* @__PURE__ */ new Map();
+    const preserveUnsupportedImageForBridge = shouldRunVisionBridge(
+      this.config
+    );
     const parts = message.map((part) => {
       switch (part.type) {
         case "text":
           collectExtensionMentionRefs(part.text, extensionMentions);
           return { text: part.text };
         case "image":
+          if (preserveUnsupportedImageForBridge) {
+            return {
+              inlineData: {
+                mimeType: part.mimeType,
+                data: part.data
+              }
+            };
+          }
+          return clampInlineMediaPart({
+            inlineData: {
+              mimeType: part.mimeType,
+              data: part.data
+            }
+          });
         case "audio":
           return clampInlineMediaPart({
             inlineData: {
@@ -4775,10 +4949,13 @@ ${this.pendingWorktreeNotice}
       abortSignal
     );
     if (atPathCommandParts.length === 0 && embeddedContext.length === 0 && extensionParts.length === 0) {
-      return parts;
+      return this.#applyVisionBridgeIfNeeded(parts, abortSignal);
     }
     if (atPathCommandParts.length === 0 && embeddedContext.length === 0) {
-      return [...parts, ...extensionParts];
+      return this.#applyVisionBridgeIfNeeded(
+        [...parts, ...extensionParts],
+        abortSignal
+      );
     }
     const pathSpecsToRead = atPathCommandParts.map(
       (part) => part.fileData.fileUri
@@ -4800,7 +4977,8 @@ ${this.pendingWorktreeNotice}
     if (pathSpecsToRead.length > 0) {
       const readResult = await readManyFiles(this.config, {
         paths: pathSpecsToRead,
-        signal: abortSignal
+        signal: abortSignal,
+        ...preserveUnsupportedImageForBridge ? { preserveUnsupportedImageForBridge } : {}
       });
       const contentParts = Array.isArray(readResult.contentParts) ? readResult.contentParts : [readResult.contentParts];
       processedQueryParts.push({ text: initialQueryText });
@@ -4808,6 +4986,8 @@ ${this.pendingWorktreeNotice}
       for (const part of contentParts) {
         if (typeof part === "string") {
           processedQueryParts.push({ text: part });
+        } else if (preserveUnsupportedImageForBridge && hasImageParts([part])) {
+          processedQueryParts.push(part);
         } else {
           processedQueryParts.push(clampInlineMediaPart(part));
         }
@@ -4824,17 +5004,73 @@ ${contextPart.text}`
         });
       }
       if ("blob" in contextPart && contextPart.blob) {
+        const inlinePart = {
+          inlineData: {
+            mimeType: contextPart.mimeType ?? "application/octet-stream",
+            data: contextPart.blob
+          }
+        };
         processedQueryParts.push(
-          clampInlineMediaPart({
-            inlineData: {
-              mimeType: contextPart.mimeType ?? "application/octet-stream",
-              data: contextPart.blob
-            }
-          })
+          preserveUnsupportedImageForBridge && hasImageParts([inlinePart]) ? inlinePart : clampInlineMediaPart(inlinePart)
         );
       }
     }
-    return processedQueryParts;
+    return this.#applyVisionBridgeIfNeeded(processedQueryParts, abortSignal);
+  }
+  async #applyVisionBridgeIfNeeded(parts, abortSignal) {
+    if (!hasImageParts(parts) || !shouldRunVisionBridge(this.config)) {
+      return parts;
+    }
+    let bridgeResult;
+    try {
+      debugLogger5.debug("vision bridge: gate matched, running conversion");
+      bridgeResult = await runVisionBridge({
+        config: this.config,
+        parts,
+        signal: abortSignal
+      });
+    } catch (error) {
+      debugLogger5.debug(
+        `vision bridge: failed before replacement; falling back to text-only parts error=${String(error instanceof Error ? error.message : error)}`
+      );
+      return splitImageParts(parts).nonImageParts;
+    }
+    debugLogger5.debug(
+      `vision bridge: status=${bridgeResult.status} applied=${bridgeResult.applied} model=${bridgeResult.modelId ?? "(none)"}${bridgeResult.error ? ` error=${bridgeResult.error}` : ""}`
+    );
+    if (bridgeResult.status !== "skipped" || bridgeResult.egressOccurred) {
+      try {
+        await this.messageEmitter.emitAgentMessage(
+          this.#formatVisionBridgeNotice(bridgeResult)
+        );
+      } catch (error) {
+        debugLogger5.debug(
+          `vision bridge: failed to emit notice; continuing with bridge result error=${String(error instanceof Error ? error.message : error)}`
+        );
+      }
+    }
+    if (abortSignal.aborted) {
+      debugLogger5.debug("vision bridge: turn aborted after bridge returned");
+      return splitImageParts(parts).nonImageParts;
+    }
+    if (bridgeResult.applied && bridgeResult.parts != null) {
+      return normalizeParts(bridgeResult.parts);
+    }
+    return splitImageParts(parts).nonImageParts;
+  }
+  #formatVisionBridgeNotice(result) {
+    const modelName = result.modelId ?? "vision model";
+    const target = result.modelEndpoint ? `${modelName} (${result.modelEndpoint})` : modelName;
+    const egressNote = result.egressOccurred ? ` Your image and prompt/context were sent to ${target}.` : "";
+    if (result.status === "failed") {
+      const reason = result.egressOccurred ? "the vision model request failed" : "the vision bridge could not run";
+      return `Vision bridge (${modelName}) failed: ${reason}.${egressNote} The image was not interpreted.`;
+    }
+    if (result.status === "skipped") {
+      return `Vision bridge cancelled.${egressNote}`;
+    }
+    const omitted = result.omittedCount > 0 ? ` (${result.omittedCount} image(s) omitted)` : "";
+    return `Converted ${result.convertedCount} image(s)${omitted} to text via ${target}. Your image and prompt/context were sent to that model.`;
   }
   async #resolveExtensionMentionParts(extensionMentions, abortSignal) {
     if (extensionMentions.size === 0) return [];
@@ -4998,6 +5234,7 @@ __name(runWithAcpRuntimeOutputDir, "runWithAcpRuntimeOutputDir");
 // packages/cli/src/acp-integration/acpAgent.ts
 var debugLogger6 = createDebugLogger("ACP_AGENT");
 var BTW_CHILD_TIMEOUT_MS = 55e3;
+var WORKSPACE_MEMORY_REMEMBER_CHILD_TIMEOUT_MS = 295e3;
 function collapseForkDirective(directive, maxLength) {
   const oneLine = directive.replace(/\s+/g, " ").trim();
   return oneLine.length > maxLength ? `${oneLine.slice(0, maxLength - 3)}\u2026` : oneLine;
@@ -6682,12 +6919,30 @@ var QwenAgent = class {
       );
     }
   }
-  async closeStoredSession(sessionId) {
+  async closeStoredSession(sessionId, opts) {
     const session = this.sessions.get(sessionId);
     if (!session) {
       this.mcpPool?.releaseSession(sessionId);
       return;
     }
+    const requireFlush = opts?.requireFlush === true;
+    const flushRecording = /* @__PURE__ */ __name(async () => {
+      try {
+        await session.getConfig().getChatRecordingService()?.flush();
+        return void 0;
+      } catch (err) {
+        debugLogger6.debug(
+          `Session ${sessionId} chat recording flush during close failed: ${err instanceof Error ? err.message : String(err)}`
+        );
+        return err;
+      }
+    }, "flushRecording");
+    if (requireFlush) {
+      const preCancelFlushError = await flushRecording();
+      if (preCancelFlushError !== void 0) {
+        throw preCancelFlushError;
+      }
+    }
     try {
       await session.cancelPendingPrompt();
     } catch (err) {
@@ -6695,6 +6950,10 @@ var QwenAgent = class {
         `Session ${sessionId} cancel during close failed: ${err instanceof Error ? err.message : String(err)}`
       );
     }
+    const flushError = await flushRecording();
+    if (flushError !== void 0 && requireFlush) {
+      throw flushError;
+    }
     try {
       await session.getConfig().getToolRegistry()?.stop();
     } catch (err) {
@@ -6741,7 +7000,7 @@ var QwenAgent = class {
   async initialize(args) {
     this.clientCapabilities = args.clientCapabilities;
     const authMethods = buildAuthMethods();
-    const version = "0.19.3-nightly.20260701.a974594d7";
+    const version = "0.19.4";
     return {
       protocolVersion: PROTOCOL_VERSION,
       agentInfo: {
@@ -8872,6 +9131,76 @@ var QwenAgent = class {
         return this.buildWorkspaceExtensionsStatus(
           this.config
         );
+      case SERVE_CONTROL_EXT_METHODS.workspaceMemoryRememberAvailability:
+        return {
+          available: this.config.isManagedMemoryAvailable()
+        };
+      case SERVE_CONTROL_EXT_METHODS.workspaceMemoryRemember: {
+        const content = params["content"];
+        if (typeof content !== "string" || !content.trim()) {
+          throw RequestError.invalidParams(
+            void 0,
+            "Invalid or missing content"
+          );
+        }
+        if (Buffer.byteLength(content, "utf8") > MAX_REMEMBER_CONTENT_BYTES) {
+          throw RequestError.invalidParams(
+            void 0,
+            "Content exceeds maximum size"
+          );
+        }
+        const rawContextMode = params["contextMode"] ?? "workspace";
+        if (rawContextMode !== "workspace" && rawContextMode !== "clean") {
+          throw RequestError.invalidParams(void 0, "Invalid contextMode");
+        }
+        const contextMode = rawContextMode;
+        if (!this.config.isManagedMemoryAvailable()) {
+          throw new RequestError(
+            -32009,
+            "Managed memory is unavailable for this daemon workspace",
+            { errorKind: "managed_memory_unavailable" }
+          );
+        }
+        const childSignal = AbortSignal.timeout(
+          WORKSPACE_MEMORY_REMEMBER_CHILD_TIMEOUT_MS
+        );
+        try {
+          const result = await runManagedRememberByAgent({
+            config: this.config,
+            projectRoot: this.config.getProjectRoot(),
+            content: content.trim(),
+            contextMode,
+            abortSignal: childSignal
+          });
+          return result;
+        } catch (err) {
+          if (err instanceof RequestError) {
+            throw err;
+          }
+          if (childSignal.aborted) {
+            throw new RequestError(
+              -32099,
+              "Workspace memory remember timed out",
+              { errorKind: "remember_timeout" }
+            );
+          }
+          const code = extractRememberErrorCode(err);
+          if (code === "managed_memory_unavailable") {
+            throw new RequestError(
+              -32009,
+              "Managed memory is unavailable for this daemon workspace",
+              { errorKind: "managed_memory_unavailable" }
+            );
+          }
+          throw new RequestError(
+            -32099,
+            err instanceof Error && err.message ? err.message : "Workspace memory remember failed",
+            {
+              errorKind: code
+            }
+          );
+        }
+      }
       case SERVE_CONTROL_EXT_METHODS.workspaceMcpRestart: {
         const serverName = params["serverName"];
         if (typeof serverName !== "string" || serverName.length === 0) {
@@ -9211,7 +9540,9 @@ var QwenAgent = class {
             "Invalid or missing sessionId"
           );
         }
-        await this.closeStoredSession(sessionId);
+        await this.closeStoredSession(sessionId, {
+          requireFlush: params["requireFlush"] === true
+        });
         return { sessionId, closed: true };
       }
       case SERVE_CONTROL_EXT_METHODS.sessionCd: {
@@ -10589,10 +10920,6 @@ ${outputText}
         continue;
       }
     }
-    const cdpTunnelMcp = buildCdpTunnelMcpServer();
-    if (cdpTunnelMcp && !sessionMcpServers["chrome-devtools"]) {
-      sessionMcpServers["chrome-devtools"] = cdpTunnelMcp;
-    }
     const settings = this.settings.merged;
     const argvForSession = {
       ...this.argv,
@@ -10846,50 +11173,9 @@ function diffSettingsKeys(oldMerged, newMerged) {
   return changed;
 }
 __name(diffSettingsKeys, "diffSettingsKeys");
-function buildCdpTunnelMcpServer() {
-  if (process.env["QWEN_SERVE_CDP_TUNNEL_OVER_WS"] !== "1") return void 0;
-  if (process.env["QWEN_SERVE_CDP_TUNNEL_AUTH_REQUIRED"] === "1") {
-    process.stderr.write(
-      "qwen serve: browser tools (chrome-devtools-mcp) disabled \u2014 the /cdp tunnel requires bearer auth, which is not yet supported for the auto-registered browser MCP server.\n"
-    );
-    return void 0;
-  }
-  const port = Number(process.env["QWEN_SERVE_CDP_TUNNEL_PORT"]);
-  if (!Number.isInteger(port) || port <= 0) {
-    process.stderr.write(
-      `qwen serve: browser tools (chrome-devtools-mcp) disabled \u2014 no valid /cdp tunnel port (QWEN_SERVE_CDP_TUNNEL_PORT=${process.env["QWEN_SERVE_CDP_TUNNEL_PORT"] ?? "<unset>"}). Start the daemon with a fixed --port (ephemeral --port 0 is not supported for the CDP tunnel).
-`
-    );
-    return void 0;
-  }
-  try {
-    const requireFromHere = createRequire(import.meta.url);
-    const pkgJsonPath = requireFromHere.resolve(
-      "chrome-devtools-mcp/package.json"
-    );
-    const pkg = requireFromHere("chrome-devtools-mcp/package.json");
-    const binRel = typeof pkg.bin === "string" ? pkg.bin : Object.values(pkg.bin ?? {})[0];
-    if (!binRel) return void 0;
-    const pkgDir = path3.dirname(pkgJsonPath);
-    const binPath = path3.resolve(pkgDir, binRel);
-    const binRelToPkg = path3.relative(pkgDir, binPath);
-    if (binRelToPkg.startsWith("..") || path3.isAbsolute(binRelToPkg)) {
-      return void 0;
-    }
-    return new MCPServerConfig(process.execPath, [
-      binPath,
-      "--wsEndpoint",
-      `ws://127.0.0.1:${port}/cdp`
-    ]);
-  } catch {
-    return void 0;
-  }
-}
-__name(buildCdpTunnelMcpServer, "buildCdpTunnelMcpServer");
 export {
   AUTH_PREFLIGHT_ENV_KEYS,
   AUTH_PREFLIGHT_WAIVED_AUTH_TYPES,
-  buildCdpTunnelMcpServer,
   createWorkspaceMcpBudget,
   deliverClientMcpMessage,
   extractFilesFromTarGz,