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

package/chunks/{acpAgent-4MCETHF2.js → acpAgent-QEP6DXFW.js}

@@ -3,8 +3,13 @@
 import {
   classifyApiError,
   prefixMidTurnUserMessageParts
-} from "./chunk-LLFFKXZZ.js";
-import "./chunk-B6HQGTYR.js";
+} from "./chunk-YALKC62D.js";
+import {
+  EXTENSION_CONTEXT_BUDGET,
+  buildExtensionMentionContext,
+  matchExtensionByRef,
+  parseExtensionRef
+} from "./chunk-7UNP2XM7.js";
 import {
   HistoryReplayer,
   MessageEmitter,
@@ -12,105 +17,118 @@ import {
   ToolCallEmitter,
   getAvailableCommands,
   handleSlashCommand,
+  insertAfterFunctionResponses,
   isSlashCommand,
   normalizePartList
-} from "./chunk-2TJ3YN6Q.js";
+} from "./chunk-2RJA6J57.js";
 import {
   appEvents,
   buildDisabledSkillNamesProvider,
   loadCliConfig,
   normalizeDisabledToolList
-} from "./chunk-ZUAXI2OA.js";
+} from "./chunk-BOJWHRMX.js";
+import {
+  collectContextData,
+  formatContextUsageText
+} from "./chunk-JYPQTRA3.js";
 import {
   getCommandSubcommandNames
-} from "./chunk-4W4T77MO.js";
+} from "./chunk-BXVWV4GI.js";
+import "./chunk-5GOVVXEV.js";
 import {
   getEffectiveSupportedModes
-} from "./chunk-JTYRZODB.js";
-import "./chunk-MRO43B25.js";
-import "./chunk-UAARJR2G.js";
-import "./chunk-JZSY4WP3.js";
-import {
-  collectContextData,
-  formatContextUsageText
-} from "./chunk-TZM5JIAX.js";
+} from "./chunk-FOOIZCWL.js";
 import {
   isTerminalGoalStatusKind
 } from "./chunk-KSPVDFE4.js";
+import "./chunk-MRO43B25.js";
+import "./chunk-SMXULRAN.js";
+import "./chunk-WQT5SOI6.js";
 import "./chunk-KYMBIKIW.js";
-import "./chunk-I2RFAW6Q.js";
+import "./chunk-I4H7PRWQ.js";
+import "./chunk-JZSY4WP3.js";
+import "./chunk-4X7NIEQJ.js";
+import "./chunk-TT6Q3EN4.js";
 import "./chunk-3GONHQOA.js";
-import "./chunk-5R4SBCX6.js";
-import "./chunk-Z7XXFPGP.js";
-import "./chunk-JXQ23SNT.js";
-import "./chunk-TMBPDHXD.js";
+import "./chunk-SL5MOGQH.js";
+import "./chunk-LDWTYE33.js";
+import "./chunk-2JKEQWDZ.js";
 import {
-  PERMISSION_RULE_TYPES,
-  PermissionRulesValidationError,
-  buildPermissionSettings,
-  normalizePermissionRules,
-  readPermissionRuleSet
-} from "./chunk-WGAEWQTF.js";
-import "./chunk-NYOHZYHM.js";
-import "./chunk-CGOMICBE.js";
-import "./chunk-RKIZXJMB.js";
-import "./chunk-CI5O6SQL.js";
+  isValidServerName
+} from "./chunk-UAKXW3DN.js";
+import "./chunk-NDOC6M5S.js";
+import "./chunk-M2U5NM24.js";
+import "./chunk-BSZEQNUA.js";
+import "./chunk-6FKEVYCD.js";
 import "./chunk-KHDZHZMH.js";
+import "./chunk-ALX6BUYW.js";
 import {
-  MID_TURN_QUEUE_DRAIN_METHOD
-} from "./chunk-QBZ22PQX.js";
+  AgentSideConnection,
+  PROTOCOL_VERSION,
+  RequestError,
+  ndJsonStream
+} from "./chunk-UFC57OYT.js";
 import {
   formatAcpModelId,
   parseAcpBaseModelId,
   parseAcpModelOption,
   sanitizeProviderBaseUrl
-} from "./chunk-RS4HRC75.js";
+} from "./chunk-QI2CFVRF.js";
+import {
+  PERMISSION_RULE_TYPES,
+  PermissionRulesValidationError,
+  buildPermissionSettings,
+  normalizePermissionRules,
+  readPermissionRuleSet
+} from "./chunk-WN6K47NR.js";
+import "./chunk-5XQ4A26L.js";
+import "./chunk-BC3C4F3Q.js";
 import {
   NOT_CURRENTLY_GENERATING_CANCEL_MESSAGE
-} from "./chunk-S566HKUS.js";
-import "./chunk-BS64PXY3.js";
+} from "./chunk-DHXWNSJA.js";
+import {
+  ACP_PREFLIGHT_KINDS,
+  IDLE_HOOK_EVENTS,
+  SERVE_CONTROL_EXT_METHODS,
+  SERVE_STATUS_EXT_METHODS,
+  STATUS_SCHEMA_VERSION,
+  mapDomainErrorToErrorKind
+} from "./chunk-3M4W4U5G.js";
+import "./chunk-KFVU7ODN.js";
+import {
+  CLIENT_MCP_OVER_WS_CONFIG_FLAG,
+  MID_TURN_QUEUE_DRAIN_METHOD
+} from "./chunk-EWALXUAD.js";
 import "./chunk-SEZC2725.js";
-import "./chunk-DBZUXSSV.js";
-import "./chunk-R2BXK7SX.js";
-import "./chunk-ALX6BUYW.js";
 import "./chunk-5DWXLGOM.js";
 import {
   createLoadedSettingsAdapter
-} from "./chunk-5RVSM6NW.js";
+} from "./chunk-3HUHAQF3.js";
 import {
   OUTPUT_LANGUAGE_AUTO,
   getOutputLanguageFilePath,
   getPersistScopeForModelSelection,
   isAutoLanguage,
-  isWorkspaceTrusted,
   loadSettings,
   reloadEnvironment,
   resolveOutputLanguage,
   updateOutputLanguageFile,
   writeOutputLanguageAndRegisterPath
-} from "./chunk-OQHQHJRK.js";
+} from "./chunk-HEVBZSXG.js";
 import {
   SUPPORTED_LANGUAGES,
   getCurrentLanguage,
   setLanguageAsync
-} from "./chunk-5JZLXFPD.js";
+} from "./chunk-MTHMXSNT.js";
 import "./chunk-TLRYABYP.js";
-import "./chunk-Y6Z2O3WR.js";
-import {
-  AgentSideConnection,
-  PROTOCOL_VERSION,
-  RequestError,
-  ndJsonStream
-} from "./chunk-UFC57OYT.js";
+import "./chunk-PPFWEV7G.js";
 import {
-  ACP_PREFLIGHT_KINDS,
-  IDLE_HOOK_EVENTS,
-  SERVE_CONTROL_EXT_METHODS,
-  SERVE_STATUS_EXT_METHODS,
-  STATUS_SCHEMA_VERSION,
-  mapDomainErrorToErrorKind
-} from "./chunk-D5E5TMYH.js";
-import "./chunk-UN3C6GOR.js";
+  isFolderTrustEnabled,
+  isWorkspaceTrusted,
+  loadTrustedFolders
+} from "./chunk-ARYCHZ4B.js";
+import "./chunk-Y6Z2O3WR.js";
+import "./chunk-QYUE6W3T.js";
 import {
   ALL_PROVIDERS,
   APPROVAL_MODES,
@@ -119,6 +137,7 @@ import {
   ExtensionManager,
   FORK_SUBAGENT_TYPE,
   InvalidMcpConfigError,
+  LoopTickResolver,
   MAX_TRANSCRIPT_MESSAGES,
   MCPOAuthProvider,
   MCPOAuthTokenStorage,
@@ -127,9 +146,11 @@ import {
   McpBudgetWouldExceedError,
   McpServerSpawnFailedError,
   McpTransportPool,
+  ORPHAN_TOOL_USE_REPAIR_REASON,
   POOLED_TRANSPORTS_DEFAULT,
   SESSION_TITLE_MAX_LENGTH,
   SessionService,
+  TURN_INTERRUPTION_HISTORY_TAIL_COUNT,
   WorkspaceMcpBudget,
   abortGoalForStopHookCap,
   acquireSleepInhibitor,
@@ -138,17 +159,22 @@ import {
   buildBackgroundEntryLabel,
   buildBtwCacheSafeParams,
   buildBtwPrompt,
+  buildContextUsage,
   buildInstallPlan,
+  buildSyntheticToolResponseParts,
   clampInlineMediaPart,
   clearGoalTerminalObserver,
   computeUniqueBranchTitle,
   convertToFunctionResponse,
   createDuplicateProviderToolCallResponse,
   dedupeToolCallsById,
+  detectLoopSentinel,
+  detectTurnInterruption,
   evaluateAutoMode,
   evaluatePermissionFlow,
   findExistingProviderModels,
   findProviderById,
+  findRepeatedDuplicateProviderToolCall,
   fireNotificationHook,
   firePermissionRequestHook,
   firePostToolUseFailureHook,
@@ -174,6 +200,7 @@ import {
   isDenialFallbackReason,
   isPlanModeBlocked,
   isSystemReminderContent,
+  markDuplicateProviderToolCallResponseSent,
   needsConfirmation,
   parsePositiveIntegerEnv,
   persistPermissionOutcome,
@@ -193,32 +220,32 @@ import {
   subagentGenerator,
   unregisterGoalHook,
   updateSetting
-} from "./chunk-PXFFKNCO.js";
+} from "./chunk-RIP623NO.js";
 import {
   external_exports
 } from "./chunk-K5PGHDBN.js";
 import "./chunk-5P5XGNYH.js";
 import "./chunk-SKAZWEV5.js";
-import "./chunk-TXVGVZYR.js";
-import "./chunk-XU5P23GN.js";
-import "./chunk-2BIF2NVV.js";
+import "./chunk-XJYUPHRC.js";
+import "./chunk-QLDPRILK.js";
+import "./chunk-BVSVIN45.js";
 import {
   runSideQuery
-} from "./chunk-BG4BIP7F.js";
-import "./chunk-ZD3NW5KL.js";
+} from "./chunk-SBBN4BWR.js";
+import "./chunk-7LM4XHPE.js";
 import "./chunk-2MPVVENX.js";
 import "./chunk-ZTQ26VBE.js";
-import "./chunk-GZCJS5WH.js";
+import "./chunk-O2VBQ3Y2.js";
 import "./chunk-MLZQVCF3.js";
 import "./chunk-LQ7TMOCE.js";
 import "./chunk-LD2XBG6Z.js";
-import "./chunk-OTBK43JR.js";
+import "./chunk-HYCC3XM3.js";
 import {
   HookEventName,
   createHookOutput
-} from "./chunk-HGNSRCRB.js";
-import "./chunk-EEEZIVFJ.js";
-import "./chunk-PRYMDRBV.js";
+} from "./chunk-NL4C3H6C.js";
+import "./chunk-JOLIREYR.js";
+import "./chunk-DDMOU62Q.js";
 import {
   AuthType,
   ConversationFinishedEvent,
@@ -239,46 +266,48 @@ import {
   startToolSpan,
   uiTelemetryService,
   withInteractionSpan
-} from "./chunk-WA5OJGFL.js";
+} from "./chunk-SS6WJMQK.js";
 import "./chunk-3PJXIDKI.js";
 import "./chunk-UWCTAVOD.js";
 import "./chunk-OFEVLU4C.js";
 import "./chunk-OMX7CUOE.js";
 import {
   getAutoMemoryRoot
-} from "./chunk-BNXANYLH.js";
-import "./chunk-T2VDEFUU.js";
-import "./chunk-OIC6S73E.js";
+} from "./chunk-RD6YJJJ6.js";
+import "./chunk-SKQZZVAV.js";
+import "./chunk-BUUQ5HPX.js";
 import {
   ToolConfirmationOutcome,
   ToolNames
-} from "./chunk-TOEGRAVX.js";
+} from "./chunk-BX5YO7UW.js";
 import {
   clearCachedCredentialFile,
   qwenOAuth2Events
-} from "./chunk-BGUDAULQ.js";
-import "./chunk-EW6C27XX.js";
+} from "./chunk-3CPCDXFR.js";
+import "./chunk-GEHVIWAT.js";
 import "./chunk-22IFUCVR.js";
-import "./chunk-64WXLC72.js";
-import "./chunk-3UALQ56H.js";
+import "./chunk-3227DZO4.js";
 import {
+  DEFAULT_TOKEN_LIMIT,
   tokenLimit
-} from "./chunk-F6XNTYNE.js";
-import "./chunk-CGEGHF2C.js";
+} from "./chunk-YTFBURQD.js";
+import "./chunk-BKXBARJZ.js";
 import "./chunk-IRJWHZWU.js";
 import "./chunk-SYCJMSIJ.js";
 import "./chunk-55ZMG67I.js";
 import "./chunk-H6BD2ELD.js";
 import "./chunk-5IFG2VC4.js";
+import "./chunk-64WXLC72.js";
+import "./chunk-E6XQPQXW.js";
 import {
   Storage,
   createDebugLogger,
   getErrorStatus
-} from "./chunk-C4K3FEQ2.js";
-import "./chunk-PF523XJX.js";
+} from "./chunk-UX4SGCGN.js";
+import "./chunk-HPGTGMP3.js";
 import {
   runExitCleanup
-} from "./chunk-GYZQA2FO.js";
+} from "./chunk-YLZJCUH6.js";
 import "./chunk-ZERZSAZL.js";
 import "./chunk-QN5NZ3UQ.js";
 import "./chunk-BR4QREVK.js";
@@ -391,11 +420,14 @@ var AcpFileSystemService = class {
 import { Readable, Writable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import * as fs from "node:fs/promises";
-import * as path from "node:path";
+import { createRequire } from "node:module";
+import * as path2 from "node:path";
 import { createGunzip } from "node:zlib";
 
 // packages/cli/src/acp-integration/session/Session.ts
 init_esbuild_shims();
+import * as os from "node:os";
+import * as path from "node:path";
 
 // packages/cli/src/acp-integration/session/SubAgentTracker.ts
 init_esbuild_shims();
@@ -1087,6 +1119,7 @@ __name(loadRewriteConfig, "loadRewriteConfig");
 var debugLogger4 = createDebugLogger("SESSION");
 var USER_CANCEL_ABORT_REASON = "qwen:user-cancel";
 var DAEMON_RETRY_META_KEY = "qwen.daemon.retry";
+var DAEMON_CONTINUE_META_KEY = "qwen.daemon.continueLastTurn";
 function maskApiKeyForDisplay(apiKey) {
   const trimmed = apiKey?.trim() ?? "";
   if (trimmed.length === 0) return "(not set)";
@@ -1102,6 +1135,14 @@ var MAX_MID_TURN_DRAIN_ITEMS = 10;
 var MID_TURN_ATTACHMENT_PROCESSING_FAILURE_TEXT = "[Attachment could not be processed]";
 var MAX_MID_TURN_RESOURCE_TEXT_LENGTH = 1e5;
 var MID_TURN_QUEUE_DRAIN_MAX_TIMEOUT_STRIKES = 3;
+var TRANSIENT_FS_CODES = [
+  "EACCES",
+  "EIO",
+  "EBUSY",
+  "EPERM",
+  "EISDIR",
+  "ENOTDIR"
+];
 function isRecord(value) {
   return value !== null && typeof value === "object";
 }
@@ -1328,6 +1369,18 @@ function isUserPromptRecord(record) {
   ) ?? false;
 }
 __name(isUserPromptRecord, "isUserPromptRecord");
+var AT_TOKEN_RE = /@([^\s,;!?()[\]{}]+)/g;
+function collectExtensionMentionRefs(text, mentions) {
+  for (const match of text.matchAll(AT_TOKEN_RE)) {
+    const pathName = match[1];
+    if (!pathName) continue;
+    const ref = parseExtensionRef(pathName);
+    if (ref) {
+      mentions.set(ref.name.toLowerCase(), ref.name);
+    }
+  }
+}
+__name(collectExtensionMentionRefs, "collectExtensionMentionRefs");
 async function buildAvailableCommandsSnapshot(config, abortSignal = AbortSignal.timeout(1e4), settings) {
   const slashCommands = await getAvailableCommands(
     config,
@@ -1347,7 +1400,12 @@ async function buildAvailableCommandsSnapshot(config, abortSignal = AbortSignal.
         sourceLabel: cmd.sourceLabel,
         supportedModes: getEffectiveSupportedModes(cmd),
         subcommands: getCommandSubcommandNames(cmd),
-        modelInvocable: cmd.modelInvocable === true
+        modelInvocable: cmd.modelInvocable === true,
+        // Carry aliases so a channel consumer (which only sees the wire snapshot,
+        // not the command registry) can recognize an aliased command and avoid
+        // tagging it. _meta is ACP's extension point; omitted when there are none
+        // so command entries without aliases stay byte-identical on the wire.
+        ...cmd.altNames && cmd.altNames.length > 0 ? { altNames: cmd.altNames } : {}
       }
     };
   });
@@ -1442,12 +1500,23 @@ var Session = class {
   cronQueue = [];
   cronProcessing = false;
   cronAbortController = null;
+  // Resolves the `<<loop.md>>` / `<<loop.md-dynamic>>` sentinels at fire time.
+  // Lazily created on the first loop tick; its content cache is reset on
+  // compaction (see #sendMessageStreamWithAutoCompression) and it is rebuilt if
+  // the working dir changes (e.g. /cd) so it always reads the current project's
+  // loop.md.
+  loopTickResolver = null;
+  loopTickResolverRoot = null;
   cronCompletion = null;
   cronDisabledByTokenLimit = false;
   lastPromptTokenCount = 0;
   lastPromptTokenCountChat = null;
   midTurnDrainUnavailable = false;
   midTurnDrainTimeoutStrikes = 0;
+  // ACP can continue one logical conversation through prompt, cron, and
+  // background loops, so keep this with the session instead of a single
+  // runToolCalls invocation.
+  duplicateProviderToolCallResponseIds = /* @__PURE__ */ new Set();
   // Messages from a drain that the daemon answered but we timed out waiting for
   // (the daemon already spliced + SSE-published them). Re-injected on the next
   // batch so a transient stall can't silently lose them. See
@@ -1751,6 +1820,7 @@ var Session = class {
     if (pendingSend.signal.aborted) {
       return { stopReason: "cancelled" };
     }
+    this.duplicateProviderToolCallResponseIds.clear();
     let resolveCompletion;
     this.pendingPromptCompletion = new Promise((resolve3) => {
       resolveCompletion = resolve3;
@@ -1769,6 +1839,36 @@ var Session = class {
       this.pendingPromptCompletion = null;
     }
   }
+  /**
+   * Classify whether an unfinished previous turn can be resumed — an
+   * interrupted prompt (the model never answered) or a turn left with dangling
+   * tool calls — without injecting a synthetic "continue" user message.
+   * Classifies from persisted history. Idempotent no-op (accepted:false) when
+   * the last turn ended cleanly or a prompt is already in flight.
+   *
+   * This is the accept/reject pre-check only — it does NOT fire the turn. When
+   * accepted, the daemon bridge drives the continuation through the normal
+   * prompt-admission path (`sendPrompt` with the trusted continue meta) so it is
+   * tracked like any other prompt; `prompt()` then re-detects/strips
+   * authoritatively. Powers `qwen/control/session/continue`.
+   */
+  async continueLastTurn() {
+    const geminiClient = this.config.getGeminiClient();
+    if (!geminiClient || !geminiClient.isInitialized()) {
+      return { accepted: false, interruption: "none" };
+    }
+    const chat = this.#getCurrentChat();
+    const detection = detectTurnInterruption(
+      chat.getHistoryTailShallow?.(TURN_INTERRUPTION_HISTORY_TAIL_COUNT) ?? chat.getHistoryTail(TURN_INTERRUPTION_HISTORY_TAIL_COUNT)
+    );
+    if (detection.kind === "none") {
+      return { accepted: false, interruption: "none" };
+    }
+    if (this.pendingPrompt && !this.pendingPrompt.signal.aborted) {
+      return { accepted: false, interruption: detection.kind };
+    }
+    return { accepted: true, interruption: detection.kind };
+  }
   /**
    * Generate a server-side follow-up suggestion for the just-completed
    * turn and push it to attached clients via the daemon's
@@ -1886,7 +1986,40 @@ var Session = class {
               )
             );
             const isRetry = params.retry === true || params._meta?.[DAEMON_RETRY_META_KEY] === true;
-            if (isRetry) {
+            const isContinue = params._meta?.[DAEMON_CONTINUE_META_KEY] === true;
+            let continuationParts = null;
+            let strippedOrphanEntries = null;
+            let orphanPushCountSnapshot = 0;
+            if (isContinue) {
+              const detection = detectTurnInterruption(
+                this.#getCurrentChat().getHistory()
+              );
+              if (detection.kind === "none") {
+                debugLogger4.warn(
+                  `[Session] continue ${promptId}: no interrupted turn on re-detection, nothing to continue`
+                );
+                logConversationFinishedEvent(
+                  this.config,
+                  new ConversationFinishedEvent(
+                    this.config.getApprovalMode(),
+                    0
+                  )
+                );
+                return { stopReason: "end_turn" };
+              }
+              if (detection.kind === "interrupted_prompt") {
+                strippedOrphanEntries = this.#getCurrentChat().stripOrphanedUserEntriesFromHistory() ?? null;
+                orphanPushCountSnapshot = this.#getCurrentChat().getUserContentPushCount?.() ?? 0;
+                continuationParts = detection.parts;
+              } else {
+                continuationParts = buildSyntheticToolResponseParts(
+                  detection.danglingCalls,
+                  ORPHAN_TOOL_USE_REPAIR_REASON
+                );
+              }
+            }
+            if (isContinue) {
+            } else if (isRetry) {
               this.#getCurrentChat().stripOrphanedUserEntriesFromHistory();
             } else {
               this.config.getChatRecordingService()?.recordUserMessage(promptText);
@@ -1896,7 +2029,9 @@ var Session = class {
             );
             const inputText = firstTextBlock?.text || "";
             let parts;
-            if (isSlashCommand(inputText)) {
+            if (isContinue) {
+              parts = continuationParts;
+            } else if (isSlashCommand(inputText)) {
               const slashCommandResult = await handleSlashCommand(
                 inputText,
                 pendingSend,
@@ -1918,7 +2053,7 @@ var Session = class {
             }
             const hooksEnabled = !this.config.getDisableAllHooks?.();
             const messageBus = this.config.getMessageBus?.();
-            if (hooksEnabled && messageBus && this.config.hasHooksForEvent?.("UserPromptSubmit")) {
+            if (!isContinue && hooksEnabled && messageBus && this.config.hasHooksForEvent?.("UserPromptSubmit")) {
               const response = await messageBus.request(
                 {
                   type: "hook-execution-request" /* HOOK_EXECUTION_REQUEST */,
@@ -1959,19 +2094,22 @@ var Session = class {
             }
             const systemReminders = await this.#buildInitialSystemReminders();
             if (systemReminders.length > 0) {
-              parts = [...systemReminders, ...parts];
+              const alreadyHasReminder = isContinue && parts.some(
+                (part) => isSystemReminderContent({ role: "user", parts: [part] })
+              );
+              if (!alreadyHasReminder) {
+                parts = insertAfterFunctionResponses(parts, systemReminders);
+              }
             }
             if (this.pendingWorktreeNotice) {
-              parts = [
-                {
-                  text: `<system-reminder>
+              const noticePart = {
+                text: `<system-reminder>
 ${this.pendingWorktreeNotice}
 </system-reminder>
 
 `
-                },
-                ...parts
-              ];
+              };
+              parts = insertAfterFunctionResponses(parts, [noticePart]);
               this.pendingWorktreeNotice = null;
             }
             let nextMessage = { role: "user", parts };
@@ -1995,7 +2133,7 @@ ${this.pendingWorktreeNotice}
                   if (!sendResult.responseStream) {
                     this.#preserveUnsentMessageHistory(
                       nextMessage,
-                      sendResult.stopReason === "cancelled"
+                      isContinue || sendResult.stopReason === "cancelled"
                     );
                     return { stopReason: sendResult.stopReason };
                   }
@@ -2026,6 +2164,12 @@ ${this.pendingWorktreeNotice}
                     }
                   }
                 } catch (error) {
+                  if (strippedOrphanEntries && (this.#getCurrentChat().getUserContentPushCount?.() ?? 0) <= orphanPushCountSnapshot) {
+                    for (const entry of strippedOrphanEntries) {
+                      this.#getCurrentChat().addHistory(entry);
+                    }
+                    strippedOrphanEntries = null;
+                  }
                   if (pendingSend.signal.aborted && pendingSend.signal.reason === USER_CANCEL_ABORT_REASON && this.#isAbortError(error)) {
                     return { stopReason: "cancelled" };
                   }
@@ -2075,15 +2219,10 @@ ${this.pendingWorktreeNotice}
                     );
                     return { stopReason: "end_turn" };
                   }
-                  nextMessage = {
-                    role: "user",
-                    parts: [
-                      ...toolRun.parts,
-                      ...await this.#drainMidTurnUserMessages(
-                        pendingSend.signal
-                      )
-                    ]
-                  };
+                  nextMessage = await this.#buildNextMessageAfterToolRun(
+                    toolRun,
+                    pendingSend.signal
+                  );
                 }
               }
               if (this.messageRewriter) {
@@ -2131,13 +2270,18 @@ ${this.pendingWorktreeNotice}
         return { stopReason: "end_turn" };
       }
       const responseText = this.#getCurrentChat().getLastModelMessageText?.() || "[no response text]";
+      const contextUsage = buildContextUsage(
+        this.config.getContentGeneratorConfig()?.contextWindowSize ?? DEFAULT_TOKEN_LIMIT,
+        this.lastPromptTokenCount
+      );
       const response = await messageBus.request(
         {
           type: "hook-execution-request" /* HOOK_EXECUTION_REQUEST */,
           eventName: "Stop",
           input: {
             stop_hook_active: true,
-            last_assistant_message: responseText
+            last_assistant_message: responseText,
+            ...contextUsage
           },
           signal: pendingSend.signal
         },
@@ -2270,13 +2414,10 @@ ${this.pendingWorktreeNotice}
               );
               return { stopReason: "end_turn" };
             }
-            nextMessage = {
-              role: "user",
-              parts: [
-                ...toolRun.parts,
-                ...await this.#drainMidTurnUserMessages(pendingSend.signal)
-              ]
-            };
+            nextMessage = await this.#buildNextMessageAfterToolRun(
+              toolRun,
+              pendingSend.signal
+            );
           }
         }
         continue;
@@ -2317,6 +2458,7 @@ ${this.pendingWorktreeNotice}
         compressionInfo = compressed;
         this.#recordCompressionTokenCount(compressed);
         if (compressed.compressionStatus === 1 /* COMPRESSED */) {
+          this.loopTickResolver?.resetCache();
           const reasonClause = compressed.triggerReason === "image_overflow" ? `accumulated enough tool screenshots to trigger compaction for ${this.config.getModel()}` : `approached the input token limit for ${this.config.getModel()}`;
           compressionDiagnostic = `IMPORTANT: This conversation ${reasonClause}. A compressed context will be sent for future messages (compressed from: ${compressed.originalTokenCount ?? "unknown"} to ${compressed.newTokenCount ?? "unknown"} tokens).`;
         }
@@ -2410,6 +2552,19 @@ ${this.pendingWorktreeNotice}
     );
     await this.messageRewriter?.waitForPendingRewrites();
   }
+  async #buildNextMessageAfterToolRun(toolRun, abortSignal) {
+    if (toolRun.repeatedDuplicateProviderToolCall) {
+      debugLogger4.debug(
+        "Stopping ACP turn after dropping repeated duplicate provider tool-call response."
+      );
+      return null;
+    }
+    const parts = [
+      ...toolRun.parts,
+      ...await this.#drainMidTurnUserMessages(abortSignal)
+    ];
+    return { role: "user", parts };
+  }
   #recordCompressionTokenCount(info) {
     this.#syncPromptTokenCountWithCurrentChat();
     const tokenCount = this.#extractCompressionTokenCount(info);
@@ -2673,6 +2828,28 @@ ${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()) || path.dirname(homeQwenDir);
+      this.loopTickResolver = new LoopTickResolver({
+        projectRoot: root,
+        homeDir: homeConfineRoot,
+        homeQwenDir,
+        // The project `.qwen/loop.md` is repo-controlled, so an untrusted folder
+        // must not read it and feed it to the model (mirrors getProjectHooks()'s
+        // trust gate). The home/global `~/.qwen/loop.md` is user-owned and stays
+        // allowed. Pass a getter, not a snapshot: isTrustedFolder() can flip
+        // mid-session on an IDE workspace-trust update, and the resolver outlives
+        // a single tick — re-read it on every resolve() so a trusted→untrusted
+        // flip stops reading the project file immediately.
+        allowProjectFile: /* @__PURE__ */ __name(() => this.config.isTrustedFolder(), "allowProjectFile")
+      });
+      this.loopTickResolverRoot = root;
+    }
+    return this.loopTickResolver;
+  }
   /**
    * Executes a single cron-fired prompt: echoes it as a user message with
    * `_meta.source='cron'`, streams the model response, and handles tool calls.
@@ -2703,15 +2880,56 @@ ${this.pendingWorktreeNotice}
           async () => {
             let turnCount = 0;
             try {
+              const loopMode = detectLoopSentinel(prompt);
+              let loopTick = null;
+              if (loopMode) {
+                const resolver = this.#getLoopTickResolver();
+                const trustedAtResolve = this.config.isTrustedFolder();
+                try {
+                  loopTick = await resolver.resolve(loopMode, trustedAtResolve);
+                } catch (resolveErr) {
+                  const code = resolveErr.code ?? "unknown";
+                  debugLogger4.warn(
+                    `loop.md sentinel resolution failed (mode=${loopMode}, code=${code}) \u2014 check .qwen/loop.md permissions/IO`,
+                    resolveErr
+                  );
+                  if (loopMode === "dynamic" && TRANSIENT_FS_CODES.includes(code)) {
+                    loopTick = resolver.buildTransientErrorTick(
+                      loopMode,
+                      trustedAtResolve,
+                      code
+                    );
+                  } else {
+                    throw new Error(
+                      `loop.md resolution failed (${code}) for ${resolver.absentLocations(
+                        trustedAtResolve
+                      )}`
+                    );
+                  }
+                }
+              }
+              const modelText = loopTick ? loopTick.modelText : prompt;
+              if (loopTick) {
+                debugLogger4.debug(
+                  `loop tick: mode=${loopMode} delivery=${loopTick.full ? "full" : loopTick.sourceLabel ? "reminder" : "absent"} source=${loopTick.sourceLabel ?? "none"} transient=${loopTick.transientError ?? false}`
+                );
+              }
+              const echoText = loopTick ? loopTick.sourceLabel ? `Loop tick \u2014 tasks from ${loopTick.sourceLabel}` : (
+                // A transient-error tick (buildTransientErrorTick) resolved a
+                // file but couldn't read it this tick; it deliberately omits
+                // sourceLabel, so don't conflate it with a genuinely-absent
+                // loop.md. No errno/path here — those stay in the model text.
+                loopTick.transientError ? "Loop tick \u2014 loop.md temporarily unavailable" : "Loop tick \u2014 loop.md not present"
+              ) : prompt;
               await this.sendUpdate({
                 sessionUpdate: "user_message_chunk",
-                content: { type: "text", text: prompt },
+                content: { type: "text", text: echoText },
                 _meta: { source: item.source }
               });
               const cronReminders = await this.#buildInitialSystemReminders();
               let nextMessage = {
                 role: "user",
-                parts: [...cronReminders, { text: prompt }]
+                parts: [...cronReminders, { text: modelText }]
               };
               while (nextMessage !== null) {
                 turnCount++;
@@ -2735,6 +2953,9 @@ ${this.pendingWorktreeNotice}
                   return;
                 }
                 const responseStream = sendResult.responseStream;
+                if (loopTick && turnCount === 1) {
+                  this.loopTickResolver?.markDelivered();
+                }
                 nextMessage = null;
                 for await (const resp of responseStream) {
                   if (ac.signal.aborted) return;
@@ -2781,13 +3002,10 @@ ${this.pendingWorktreeNotice}
                     );
                     return;
                   }
-                  nextMessage = {
-                    role: "user",
-                    parts: [
-                      ...toolRun.parts,
-                      ...await this.#drainMidTurnUserMessages(ac.signal)
-                    ]
-                  };
+                  nextMessage = await this.#buildNextMessageAfterToolRun(
+                    toolRun,
+                    ac.signal
+                  );
                 }
               }
             } catch (error) {
@@ -3020,13 +3238,10 @@ ${this.pendingWorktreeNotice}
                 await this.#emitBackgroundNotificationEndTurn("end_turn");
                 return;
               }
-              nextMessage = {
-                role: "user",
-                parts: [
-                  ...toolRun.parts,
-                  ...await this.#drainMidTurnUserMessages(ac.signal)
-                ]
-              };
+              nextMessage = await this.#buildNextMessageAfterToolRun(
+                toolRun,
+                ac.signal
+              );
             }
           }
           if (this.messageRewriter) {
@@ -3270,10 +3485,32 @@ ${this.pendingWorktreeNotice}
     const handledProviderToolCallIds = new Set(
       this.#getCurrentChat().getHistoryFunctionResponseIds()
     );
+    const repeatedDuplicateCall = findRepeatedDuplicateProviderToolCall(
+      dedupedFunctionCalls,
+      (fc) => getProviderToolCallId(fc) ?? fc.id,
+      handledProviderToolCallIds,
+      this.duplicateProviderToolCallResponseIds
+    );
+    if (repeatedDuplicateCall) {
+      const providerCallId = getProviderToolCallId(repeatedDuplicateCall) ?? repeatedDuplicateCall.id;
+      debugLogger4.debug(
+        `[Session.runToolCalls] Dropping batch after repeated duplicate provider tool-call id: ${providerCallId} (tool: ${repeatedDuplicateCall.name ?? "unknown_tool"})`
+      );
+      return {
+        parts: [],
+        stopAfterPermissionCancel: false,
+        repeatedDuplicateProviderToolCall: true
+      };
+    }
     const pushDuplicateBatch = /* @__PURE__ */ __name((request) => {
+      const providerCallId = request.providerCallId ?? request.callId;
+      markDuplicateProviderToolCallResponseSent(
+        providerCallId,
+        this.duplicateProviderToolCallResponseIds
+      );
       const response = createDuplicateProviderToolCallResponse(request);
       debugLogger4.debug(
-        `[Session.runToolCalls] Suppressing duplicate provider tool-call id: ${request.providerCallId} (tool: ${request.name})`
+        `[Session.runToolCalls] Suppressing duplicate provider tool-call id: ${providerCallId} (tool: ${request.name})`
       );
       batches.push({ kind: "duplicate", request, response });
     }, "pushDuplicateBatch");
@@ -3459,7 +3696,11 @@ ${this.pendingWorktreeNotice}
         }
         if (shouldStop) {
           await appendSkippedAfter(parts, batch.calls[batch.calls.length - 1]);
-          return { parts, stopAfterPermissionCancel: true };
+          return {
+            parts,
+            stopAfterPermissionCancel: true,
+            repeatedDuplicateProviderToolCall: false
+          };
         }
       } else {
         for (const fc of batch.calls) {
@@ -3467,12 +3708,20 @@ ${this.pendingWorktreeNotice}
           parts.push(...r.parts);
           if (r.stopAfterPermissionCancel) {
             await appendSkippedAfter(parts, fc);
-            return { parts, stopAfterPermissionCancel: true };
+            return {
+              parts,
+              stopAfterPermissionCancel: true,
+              repeatedDuplicateProviderToolCall: false
+            };
           }
         }
       }
     }
-    return { parts, stopAfterPermissionCancel: false };
+    return {
+      parts,
+      stopAfterPermissionCancel: false,
+      repeatedDuplicateProviderToolCall: false
+    };
   }
   /**
    * Assemble the per-turn system reminders the model needs to see at the
@@ -4245,9 +4494,11 @@ ${this.pendingWorktreeNotice}
   async #resolvePrompt(message, abortSignal) {
     const FILE_URI_SCHEME = "file://";
     const embeddedContext = [];
+    const extensionMentions = /* @__PURE__ */ new Map();
     const parts = message.map((part) => {
       switch (part.type) {
         case "text":
+          collectExtensionMentionRefs(part.text, extensionMentions);
           return { text: part.text };
         case "image":
         case "audio":
@@ -4281,9 +4532,16 @@ ${this.pendingWorktreeNotice}
       }
     });
     const atPathCommandParts = parts.filter((part) => "fileData" in part);
-    if (atPathCommandParts.length === 0 && embeddedContext.length === 0) {
+    const extensionParts = await this.#resolveExtensionMentionParts(
+      extensionMentions,
+      abortSignal
+    );
+    if (atPathCommandParts.length === 0 && embeddedContext.length === 0 && extensionParts.length === 0) {
       return parts;
     }
+    if (atPathCommandParts.length === 0 && embeddedContext.length === 0) {
+      return [...parts, ...extensionParts];
+    }
     const pathSpecsToRead = atPathCommandParts.map(
       (part) => part.fileData.fileUri
     );
@@ -4308,6 +4566,7 @@ ${this.pendingWorktreeNotice}
       });
       const contentParts = Array.isArray(readResult.contentParts) ? readResult.contentParts : [readResult.contentParts];
       processedQueryParts.push({ text: initialQueryText });
+      processedQueryParts.push(...extensionParts);
       for (const part of contentParts) {
         if (typeof part === "string") {
           processedQueryParts.push({ text: part });
@@ -4317,6 +4576,7 @@ ${this.pendingWorktreeNotice}
       }
     } else {
       processedQueryParts.push({ text: initialQueryText.trim() });
+      processedQueryParts.push(...extensionParts);
     }
     for (const contextPart of embeddedContext) {
       if ("text" in contextPart && contextPart.text) {
@@ -4338,6 +4598,33 @@ ${contextPart.text}`
     }
     return processedQueryParts;
   }
+  async #resolveExtensionMentionParts(extensionMentions, abortSignal) {
+    if (extensionMentions.size === 0) return [];
+    const activeExtensions = this.config.getActiveExtensions?.() ?? [];
+    if (activeExtensions.length === 0) return [];
+    const extensionParts = [];
+    const resolvedExtensionNames = /* @__PURE__ */ new Set();
+    let remainingBudget = EXTENSION_CONTEXT_BUDGET;
+    for (const name of extensionMentions.values()) {
+      const extension = matchExtensionByRef(name, activeExtensions);
+      if (!extension) {
+        this.debug(
+          `Extension "${name}" not found among active extensions. Available: ${activeExtensions.map((e) => e.name).join(", ") || "(none)"}`
+        );
+        continue;
+      }
+      if (resolvedExtensionNames.has(extension.name)) continue;
+      resolvedExtensionNames.add(extension.name);
+      const context = await buildExtensionMentionContext(extension, {
+        remainingBudget,
+        signal: abortSignal,
+        onDebugMessage: /* @__PURE__ */ __name((message) => this.debug(message), "onDebugMessage")
+      });
+      remainingBudget = context.remainingBudget;
+      extensionParts.push({ text: context.text });
+    }
+    return extensionParts;
+  }
   debug(msg) {
     if (this.config.getDebugMode()) {
       debugLogger4.warn(msg);
@@ -4527,6 +4814,9 @@ var QWEN_CORE_SETTING_DEFINITIONS = {
   "memory.enableManagedAutoMemory": { type: "boolean" },
   "memory.enableManagedAutoDream": { type: "boolean" },
   "memory.enableAutoSkill": { type: "boolean" },
+  "memory.autoSkillConfirm": { type: "boolean" },
+  "memory.enableTeamMemory": { type: "boolean" },
+  "memory.enableTeamMemorySync": { type: "boolean" },
   disableAllHooks: { type: "boolean" }
 };
 var QWEN_CORE_SETTING_KEYS = Object.keys(
@@ -4536,12 +4826,18 @@ var QWEN_HOOK_EVENTS = Object.values(HookEventName);
 var DEFAULT_QWEN_MEMORY_SETTINGS = {
   enableManagedAutoMemory: true,
   enableManagedAutoDream: true,
-  enableAutoSkill: true
+  enableAutoSkill: true,
+  autoSkillConfirm: true,
+  enableTeamMemory: false,
+  enableTeamMemorySync: false
 };
 var QWEN_MEMORY_SETTING_KEYS = [
   "enableManagedAutoMemory",
   "enableManagedAutoDream",
-  "enableAutoSkill"
+  "enableAutoSkill",
+  "autoSkillConfirm",
+  "enableTeamMemory",
+  "enableTeamMemorySync"
 ];
 function normalizeQwenMemorySettings(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -4551,7 +4847,10 @@ function normalizeQwenMemorySettings(value) {
   return {
     enableManagedAutoMemory: typeof record["enableManagedAutoMemory"] === "boolean" ? record["enableManagedAutoMemory"] : DEFAULT_QWEN_MEMORY_SETTINGS.enableManagedAutoMemory,
     enableManagedAutoDream: typeof record["enableManagedAutoDream"] === "boolean" ? record["enableManagedAutoDream"] : DEFAULT_QWEN_MEMORY_SETTINGS.enableManagedAutoDream,
-    enableAutoSkill: typeof record["enableAutoSkill"] === "boolean" ? record["enableAutoSkill"] : DEFAULT_QWEN_MEMORY_SETTINGS.enableAutoSkill
+    enableAutoSkill: typeof record["enableAutoSkill"] === "boolean" ? record["enableAutoSkill"] : DEFAULT_QWEN_MEMORY_SETTINGS.enableAutoSkill,
+    autoSkillConfirm: typeof record["autoSkillConfirm"] === "boolean" ? record["autoSkillConfirm"] : DEFAULT_QWEN_MEMORY_SETTINGS.autoSkillConfirm,
+    enableTeamMemory: typeof record["enableTeamMemory"] === "boolean" ? record["enableTeamMemory"] : DEFAULT_QWEN_MEMORY_SETTINGS.enableTeamMemory,
+    enableTeamMemorySync: typeof record["enableTeamMemorySync"] === "boolean" ? record["enableTeamMemorySync"] : DEFAULT_QWEN_MEMORY_SETTINGS.enableTeamMemorySync
   };
 }
 __name(normalizeQwenMemorySettings, "normalizeQwenMemorySettings");
@@ -4583,7 +4882,7 @@ function readRequiredString(value, fieldName) {
 }
 __name(readRequiredString, "readRequiredString");
 function validateSkillSlug(slug) {
-  if (!slug || slug === "." || slug === ".." || slug.includes("/") || slug.includes(path.sep) || !/^[a-zA-Z0-9._-]+$/.test(slug)) {
+  if (!slug || slug === "." || slug === ".." || slug.includes("/") || slug.includes(path2.sep) || !/^[a-zA-Z0-9._-]+$/.test(slug)) {
     throw RequestError.invalidParams(void 0, "Invalid skill.slug");
   }
 }
@@ -5052,7 +5351,7 @@ async function downloadGitHubSkillDirectoryFromApi(githubUrl, directoryPath, rel
     const name = readRequiredString(record["name"], "github.name");
     const itemPath = readRequiredString(record["path"], "github.path");
     const type = readRequiredString(record["type"], "github.type");
-    const relativePath = relativeRoot ? path.posix.join(relativeRoot, name) : name;
+    const relativePath = relativeRoot ? path2.posix.join(relativeRoot, name) : name;
     if (type === "dir") {
       files.push(
         ...await downloadGitHubSkillDirectoryFromApi(
@@ -5112,10 +5411,10 @@ __name(downloadGitHubSkillDirectory, "downloadGitHubSkillDirectory");
 async function downloadSkill(sourceUrl) {
   assertAllowedSkillSourceUrl(sourceUrl);
   const githubUrl = parseGitHubBlobSkillUrl(sourceUrl);
-  if (!githubUrl || path.posix.basename(githubUrl.filePath) !== "SKILL.md") {
+  if (!githubUrl || path2.posix.basename(githubUrl.filePath) !== "SKILL.md") {
     return downloadSingleSkillFile(sourceUrl);
   }
-  const skillDirectory = path.posix.dirname(githubUrl.filePath);
+  const skillDirectory = path2.posix.dirname(githubUrl.filePath);
   const files = await downloadGitHubSkillDirectory(githubUrl, skillDirectory);
   const skillFile = files.find((file) => file.relativePath === "SKILL.md");
   if (!skillFile) {
@@ -5131,9 +5430,9 @@ async function downloadSkill(sourceUrl) {
 }
 __name(downloadSkill, "downloadSkill");
 function resolveSkillInstallPath(skillDir, relativePath) {
-  const root = path.resolve(skillDir);
-  const target = path.resolve(skillDir, relativePath);
-  if (target !== root && !target.startsWith(root + path.sep)) {
+  const root = path2.resolve(skillDir);
+  const target = path2.resolve(skillDir, relativePath);
+  if (target !== root && !target.startsWith(root + path2.sep)) {
     throw RequestError.invalidParams(
       void 0,
       `Invalid skill file path: ${relativePath}`
@@ -5143,9 +5442,9 @@ function resolveSkillInstallPath(skillDir, relativePath) {
 }
 __name(resolveSkillInstallPath, "resolveSkillInstallPath");
 function resolveManagedSkillDir(skillsBaseDir, slug) {
-  const root = path.resolve(skillsBaseDir);
-  const skillDir = path.resolve(skillsBaseDir, slug);
-  if (!skillDir.startsWith(root + path.sep)) {
+  const root = path2.resolve(skillsBaseDir);
+  const skillDir = path2.resolve(skillsBaseDir, slug);
+  if (!skillDir.startsWith(root + path2.sep)) {
     throw RequestError.invalidParams(void 0, "Invalid skill.slug");
   }
   return skillDir;
@@ -5822,14 +6121,14 @@ function readScopeSettings(settings, scope) {
 __name(readScopeSettings, "readScopeSettings");
 async function resolvePreferredMemoryFile(dir, fallbackFilename) {
   for (const filename of getAllGeminiMdFilenames()) {
-    const filePath = path.join(dir, filename);
+    const filePath = path2.join(dir, filename);
     try {
       await fs.access(filePath);
       return filePath;
     } catch {
     }
   }
-  return path.join(dir, fallbackFilename);
+  return path2.join(dir, fallbackFilename);
 }
 __name(resolvePreferredMemoryFile, "resolvePreferredMemoryFile");
 async function resolveQwenMemoryPaths(params) {
@@ -5850,13 +6149,37 @@ async function resolveQwenMemoryPaths(params) {
   };
 }
 __name(resolveQwenMemoryPaths, "resolveQwenMemoryPaths");
+async function deliverClientMcpMessage(connection, serverName, message) {
+  if (!connection) {
+    throw new Error(
+      `client MCP server '${serverName}' has no ACP connection yet`
+    );
+  }
+  const response = await connection.extMethod(
+    SERVE_CONTROL_EXT_METHODS.clientMcpMessage,
+    { server: serverName, payload: message }
+  );
+  const payload = response["payload"];
+  if (payload === void 0 || payload === null) {
+    throw new Error(
+      `client_mcp/message returned no payload for server '${serverName}'`
+    );
+  }
+  return payload;
+}
+__name(deliverClientMcpMessage, "deliverClientMcpMessage");
 async function runAcpAgent(config, settings, argv) {
+  let acpConnection;
+  const bootstrapClientMcpSender = /* @__PURE__ */ __name((serverName, message) => deliverClientMcpMessage(acpConnection, serverName, message), "bootstrapClientMcpSender");
   await config.initialize({
     skipGeminiInitialization: true,
     // Bootstrap skips MCP discovery — each session runs its own
     // pool-routed discovery, so bootstrap-level spawns would be
     // redundant subprocess leaks (W119).
-    skipMcpDiscovery: true
+    skipMcpDiscovery: true,
+    // Bind the workspace-level manager's SDK callback so a runtime-added
+    // client-hosted MCP server (#5626) round-trips over the parent WS.
+    sendSdkMcpMessage: bootstrapClientMcpSender
   });
   const stdout = Writable.toWeb(process.stdout);
   const stdin = Readable.toWeb(process.stdin);
@@ -5866,6 +6189,7 @@ async function runAcpAgent(config, settings, argv) {
   const stream = ndJsonStream(stdout, stdin);
   let agentInstance;
   const connection = new AgentSideConnection((conn) => {
+    acpConnection = conn;
     agentInstance = new QwenAgent(config, settings, argv, conn);
     return agentInstance;
   }, stream);
@@ -6179,7 +6503,7 @@ var QwenAgent = class {
   async initialize(args) {
     this.clientCapabilities = args.clientCapabilities;
     const authMethods = buildAuthMethods();
-    const version = "0.19.2";
+    const version = "0.19.3-nightly.20260630.e00fe6a27";
     return {
       protocolVersion: PROTOCOL_VERSION,
       agentInfo: {
@@ -6774,6 +7098,16 @@ var QwenAgent = class {
                 status: this.mcpStatus(e.status)
               }));
             }
+            if (!disabled) {
+              out.resourceCount = this.resolveServerMcpResources(
+                config,
+                name
+              ).length;
+              out.promptCount = this.resolveServerMcpPrompts(
+                config,
+                name
+              ).length;
+            }
             return out;
           })
         ),
@@ -6880,6 +7214,102 @@ var QwenAgent = class {
       };
     }
   }
+  /**
+   * Resolve the resources discovered for one server, with the same
+   * pool-mode fallback `buildWorkspaceMcpToolsStatus` uses for tools: the
+   * workspace `Config`'s `ResourceRegistry` is authoritative in
+   * single-session mode, but in pool mode resources are registered into
+   * per-session registries (`SessionMcpView.applyResources`), leaving the
+   * workspace registry empty. Fall back to the first active session that
+   * has this server's resources.
+   */
+  resolveServerMcpResources(config, serverName) {
+    const resources = config.getResourceRegistry?.()?.getResourcesByServer(serverName) ?? [];
+    if (resources.length > 0) {
+      return resources;
+    }
+    for (const session of this.getActiveSessions()) {
+      try {
+        const sessionResources = session.getConfig().getResourceRegistry?.()?.getResourcesByServer(serverName) ?? [];
+        if (sessionResources.length > 0) {
+          return sessionResources;
+        }
+      } catch {
+      }
+    }
+    return resources;
+  }
+  /**
+   * Resolve the prompts discovered for one server, mirroring
+   * {@link resolveServerMcpResources}. Used only for the per-server
+   * `promptCount` on the base status — prompts have no drill-down
+   * endpoint (they surface as slash commands).
+   */
+  resolveServerMcpPrompts(config, serverName) {
+    const prompts = config.getPromptRegistry?.()?.getPromptsByServer(serverName) ?? [];
+    if (prompts.length > 0) {
+      return prompts;
+    }
+    for (const session of this.getActiveSessions()) {
+      try {
+        const sessionPrompts = session.getConfig().getPromptRegistry?.()?.getPromptsByServer(serverName) ?? [];
+        if (sessionPrompts.length > 0) {
+          return sessionPrompts;
+        }
+      } catch {
+      }
+    }
+    return prompts;
+  }
+  buildWorkspaceMcpResourcesStatus(config, serverName) {
+    const workspaceCwd = this.safeWorkspaceCwd(config);
+    try {
+      const servers = config.getMcpServers() ?? {};
+      if (!Object.prototype.hasOwnProperty.call(servers, serverName)) {
+        return {
+          v: STATUS_SCHEMA_VERSION,
+          workspaceCwd,
+          serverName,
+          initialized: true,
+          acpChannelLive: true,
+          resources: [],
+          errors: [
+            {
+              kind: "mcp_resources",
+              status: "error",
+              error: `MCP server not configured: ${serverName}`
+            }
+          ]
+        };
+      }
+      const resources = this.resolveServerMcpResources(config, serverName).map((resource) => ({
+        uri: resource.uri,
+        ...typeof resource.name === "string" ? { name: resource.name } : {},
+        ...typeof resource.title === "string" ? { title: resource.title } : {},
+        ...typeof resource.description === "string" ? { description: resource.description } : {},
+        ...typeof resource.mimeType === "string" ? { mimeType: resource.mimeType } : {},
+        ...typeof resource.size === "number" ? { size: resource.size } : {}
+      }));
+      return {
+        v: STATUS_SCHEMA_VERSION,
+        workspaceCwd,
+        serverName,
+        initialized: true,
+        acpChannelLive: true,
+        resources
+      };
+    } catch (error) {
+      return {
+        v: STATUS_SCHEMA_VERSION,
+        workspaceCwd,
+        serverName,
+        initialized: true,
+        acpChannelLive: true,
+        resources: [],
+        errors: [this.errorCell("mcp_resources", error)]
+      };
+    }
+  }
   /**
    * Build the MCP budget status cells exposed on `GET /workspace/mcp`.
    *
@@ -6986,7 +7416,7 @@ var QwenAgent = class {
       const currentAuth = activeRuntimeSnapshot?.authType ?? currentAuthType;
       const currentAcpModelId = hasCurrentModel && currentAuth ? formatAcpModelId(currentModelId, currentAuth) : currentModelId || void 0;
       const providers = /* @__PURE__ */ new Map();
-      for (const model of config.getAllConfiguredModels()) {
+      for (const model of config.getAllConfiguredModels().filter(isMainSelectableModel)) {
         const authType = String(model.authType);
         let provider = providers.get(authType);
         if (!provider) {
@@ -7480,6 +7910,25 @@ var QwenAgent = class {
         }
       };
     }
+    const skillMetrics = metrics.skills ?? {
+      totalCalls: 0,
+      totalSuccess: 0,
+      totalFail: 0,
+      byName: {}
+    };
+    const skillsByName = {};
+    for (const [name, skill] of Object.entries(skillMetrics.byName)) {
+      Object.defineProperty(skillsByName, name, {
+        value: {
+          count: skill.count,
+          success: skill.success,
+          fail: skill.fail
+        },
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    }
     return {
       v: STATUS_SCHEMA_VERSION,
       sessionId,
@@ -7498,6 +7947,12 @@ var QwenAgent = class {
       files: {
         totalLinesAdded: metrics.files.totalLinesAdded,
         totalLinesRemoved: metrics.files.totalLinesRemoved
+      },
+      skills: {
+        totalCalls: skillMetrics.totalCalls,
+        totalSuccess: skillMetrics.totalSuccess,
+        totalFail: skillMetrics.totalFail,
+        byName: skillsByName
       }
     };
   }
@@ -7681,6 +8136,7 @@ var QwenAgent = class {
             id: ext.id,
             name: ext.name,
             displayName: ext.displayName,
+            ...ext.config.description ? { description: ext.config.description } : {},
             version: ext.version,
             isActive: ext.isActive,
             path: ext.path,
@@ -7727,9 +8183,9 @@ var QwenAgent = class {
       );
     }
     const download = await downloadSkill(request.sourceUrl);
-    const skillsBaseDir = path.join(Storage.getGlobalQwenDir(), "skills");
+    const skillsBaseDir = path2.join(Storage.getGlobalQwenDir(), "skills");
     const skillDir = resolveManagedSkillDir(skillsBaseDir, request.slug);
-    const skillFile = path.join(skillDir, "SKILL.md");
+    const skillFile = path2.join(skillDir, "SKILL.md");
     const parsed = skillManager.parseSkillContent(
       download.skillContent,
       skillFile,
@@ -7749,7 +8205,7 @@ var QwenAgent = class {
           stagingDir,
           file.relativePath
         );
-        await fs.mkdir(path.dirname(targetPath), { recursive: true });
+        await fs.mkdir(path2.dirname(targetPath), { recursive: true });
         await fs.writeFile(targetPath, file.content);
       }
       await fs.rm(skillDir, { recursive: true, force: true });
@@ -7788,11 +8244,11 @@ var QwenAgent = class {
         `Skill name "${parsed.name}" does not match requested slug "${request.slug}"`
       );
     }
-    const resolvedSkillDir = path.resolve(skillDir);
-    const resolvedSkillFile = path.resolve(skillFile);
-    const globalDir = path.resolve(Storage.getGlobalQwenDir());
-    const isDedicatedSkillDir = resolvedSkillFile === path.join(resolvedSkillDir, "SKILL.md");
-    if (!isDedicatedSkillDir || resolvedSkillDir === path.parse(resolvedSkillDir).root || resolvedSkillDir === globalDir) {
+    const resolvedSkillDir = path2.resolve(skillDir);
+    const resolvedSkillFile = path2.resolve(skillFile);
+    const globalDir = path2.resolve(Storage.getGlobalQwenDir());
+    const isDedicatedSkillDir = resolvedSkillFile === path2.join(resolvedSkillDir, "SKILL.md");
+    if (!isDedicatedSkillDir || resolvedSkillDir === path2.parse(resolvedSkillDir).root || resolvedSkillDir === globalDir) {
       throw RequestError.invalidParams(
         void 0,
         `Refusing to delete unexpected skill directory: ${skillDir}`
@@ -7808,10 +8264,10 @@ var QwenAgent = class {
   async readManagedSkillFile(slug, scope, skillManager, cwd) {
     if (scope === "global") {
       const qwenSkillDir = resolveManagedSkillDir(
-        path.join(Storage.getGlobalQwenDir(), "skills"),
+        path2.join(Storage.getGlobalQwenDir(), "skills"),
         slug
       );
-      const qwenSkillFile = path.join(qwenSkillDir, "SKILL.md");
+      const qwenSkillFile = path2.join(qwenSkillDir, "SKILL.md");
       const qwenContent = await fs.readFile(qwenSkillFile, "utf8").catch(() => void 0);
       if (qwenContent !== void 0) {
         return {
@@ -7847,15 +8303,15 @@ var QwenAgent = class {
       );
     });
     return {
-      skillDir: path.dirname(skillFile),
+      skillDir: path2.dirname(skillFile),
       skillFile,
       content
     };
   }
   async findProjectSkillFileFromCwd(slug, cwd, skillManager) {
-    const projectRoot = path.resolve(cwd);
+    const projectRoot = path2.resolve(cwd);
     for (const configDir of PROJECT_SKILL_DIRS) {
-      const baseDir = path.join(projectRoot, configDir, SKILLS_DIR);
+      const baseDir = path2.join(projectRoot, configDir, SKILLS_DIR);
       const skills = await skillManager.loadSkillsFromDir(baseDir, "project");
       const skill = skills.find((candidate) => candidate.name === slug);
       const skillFile = skill?.filePath;
@@ -7867,7 +8323,7 @@ var QwenAgent = class {
         );
       });
       return {
-        skillDir: path.dirname(skillFile),
+        skillDir: path2.dirname(skillFile),
         skillFile,
         content
       };
@@ -7898,7 +8354,7 @@ var QwenAgent = class {
     }
     const nextContent = setSkillFrontmatterEnabled(content, request.enabled);
     skillManager.parseSkillContent(nextContent, skillFile, level);
-    if (path.basename(skillFile) !== "SKILL.md") {
+    if (path2.basename(skillFile) !== "SKILL.md") {
       throw RequestError.invalidParams(
         void 0,
         `Refusing to write to unexpected skill file: ${skillFile}`
@@ -7948,19 +8404,25 @@ var QwenAgent = class {
         );
         const persistScope = readProviderConnectScope(params["scope"]);
         const plan = buildInstallPlan(providerConfig, inputs);
+        const adapter = createLoadedSettingsAdapter(
+          this.settings,
+          persistScope
+        );
         await applyProviderInstallPlan(plan, {
-          settings: createLoadedSettingsAdapter(this.settings, persistScope),
+          settings: adapter,
           reloadModelProviders: /* @__PURE__ */ __name((modelProviders) => this.config.reloadModelProvidersConfig(modelProviders), "reloadModelProviders"),
           syncAuthState: /* @__PURE__ */ __name((authType, modelId, baseUrl) => this.config.getModelsConfig().syncAfterAuthRefresh(authType, modelId, baseUrl), "syncAuthState"),
           refreshAuth: /* @__PURE__ */ __name((authType) => this.config.refreshAuth(authType), "refreshAuth")
         });
+        const effectiveModelId = adapter.getValue("model.name") ?? plan.modelSelection?.modelId;
+        const effectiveBaseUrl = adapter.getValue("model.baseUrl") ?? plan.modelSelection?.baseUrl;
         return {
           success: true,
           providerId: providerConfig.id,
           providerLabel: providerConfig.label,
           authType: plan.authType,
-          modelId: plan.modelSelection?.modelId,
-          ...plan.modelSelection?.baseUrl ? { baseUrl: plan.modelSelection.baseUrl } : {}
+          ...effectiveModelId ? { modelId: effectiveModelId } : {},
+          ...effectiveBaseUrl ? { baseUrl: effectiveBaseUrl } : {}
         };
       }
       case "qwen/skills/install": {
@@ -8026,6 +8488,19 @@ var QwenAgent = class {
           serverName
         );
       }
+      case SERVE_STATUS_EXT_METHODS.workspaceMcpResources: {
+        const serverName = params["serverName"];
+        if (typeof serverName !== "string" || serverName.length === 0) {
+          throw RequestError.invalidParams(
+            void 0,
+            "Invalid or missing serverName"
+          );
+        }
+        return this.buildWorkspaceMcpResourcesStatus(
+          this.config,
+          serverName
+        );
+      }
       case SERVE_STATUS_EXT_METHODS.workspaceSkills:
         return await this.buildWorkspaceSkillsStatus(
           this.config
@@ -8481,6 +8956,78 @@ var QwenAgent = class {
         await this.closeStoredSession(sessionId);
         return { sessionId, closed: true };
       }
+      case SERVE_CONTROL_EXT_METHODS.sessionCd: {
+        const sessionId = params["sessionId"];
+        const targetPath = params["path"];
+        if (typeof sessionId !== "string" || sessionId.length === 0) {
+          throw RequestError.invalidParams(
+            void 0,
+            "Invalid or missing sessionId"
+          );
+        }
+        if (typeof targetPath !== "string" || targetPath.length === 0 || !path2.isAbsolute(targetPath) || targetPath.includes("\0")) {
+          throw RequestError.invalidParams(
+            void 0,
+            "Invalid or missing path (must be an absolute path)"
+          );
+        }
+        const session = this.sessionOrThrow(sessionId);
+        const config = session.getConfig();
+        if (config.isRestrictiveSandbox()) {
+          throw new RequestError(-32003, "Restrictive sandbox mode active", {
+            errorKind: "restrictive_sandbox"
+          });
+        }
+        let stats;
+        try {
+          stats = await fs.stat(targetPath);
+        } catch {
+          throw new RequestError(-32002, `Directory not found: ${targetPath}`, {
+            errorKind: "directory_not_found",
+            path: targetPath
+          });
+        }
+        if (!stats.isDirectory()) {
+          throw new RequestError(-32002, `Not a directory: ${targetPath}`, {
+            errorKind: "directory_not_found",
+            path: targetPath
+          });
+        }
+        const canonicalPath = await fs.realpath(targetPath);
+        const previousCwd = config.getTargetDir();
+        if (canonicalPath === previousCwd) {
+          return { previousCwd, newCwd: canonicalPath, warnings: [] };
+        }
+        if (isFolderTrustEnabled(this.settings.merged)) {
+          const trustedFolders = loadTrustedFolders();
+          if (trustedFolders.isPathTrusted(canonicalPath) !== true) {
+            throw new RequestError(
+              -32001,
+              `Directory not trusted: ${canonicalPath}`,
+              { errorKind: "directory_not_trusted", path: canonicalPath }
+            );
+          }
+        }
+        const warnings = [];
+        const relocation = await config.relocateWorkingDirectory(
+          canonicalPath,
+          canonicalPath,
+          { skipProcessChdir: true, skipArtifactMigration: true }
+        );
+        if (relocation.memoryRefreshError) {
+          warnings.push(
+            `Memory refresh failed: ${relocation.memoryRefreshError instanceof Error ? relocation.memoryRefreshError.message : String(relocation.memoryRefreshError)}`
+          );
+        }
+        try {
+          await config.getGeminiClient()?.addWorkingDirectoryChangedContext(previousCwd, canonicalPath);
+        } catch (error) {
+          warnings.push(
+            `Model context refresh failed: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+        return { previousCwd, newCwd: canonicalPath, warnings };
+      }
       case SERVE_CONTROL_EXT_METHODS.sessionApprovalMode: {
         const sessionId = params["sessionId"];
         const mode = params["mode"];
@@ -8898,6 +9445,21 @@ ${outputText}
           condition: cleared?.condition
         };
       }
+      case SERVE_CONTROL_EXT_METHODS.sessionContinue: {
+        const sessionId = params["sessionId"];
+        if (typeof sessionId !== "string" || sessionId.length === 0) {
+          throw RequestError.invalidParams(
+            void 0,
+            "Invalid or missing sessionId"
+          );
+        }
+        const session = this.sessionOrThrow(sessionId);
+        const result = await session.continueLastTurn();
+        debugLogger5.info(
+          `sessionContinue sessionId=${sessionId} accepted=${result.accepted} interruption=${result.interruption}`
+        );
+        return result;
+      }
       case SERVE_CONTROL_EXT_METHODS.workspaceMcpRuntimeAdd: {
         const name = params["name"];
         const config = params["config"];
@@ -8908,7 +9470,7 @@ ${outputText}
             "Invalid or missing name"
           );
         }
-        if (name.length > 256 || !/^[A-Za-z0-9_-]+$/.test(name) || name === "__proto__" || name === "constructor" || name === "prototype") {
+        if (!isValidServerName(name)) {
           throw RequestError.invalidParams(
             void 0,
             "Server name must be \u2264256 chars, alphanumeric + underscore/hyphen, and not a reserved JS property name"
@@ -8944,13 +9506,37 @@ ${outputText}
             oauth: _oauth,
             headers: _headers,
             type: _type,
+            // Reverse tool channel marker (issue #5626, Phase 2). The parent
+            // serve process stamps this on a client-hosted (extension) MCP
+            // server's runtime config; it never reaches the transport itself.
+            [CLIENT_MCP_OVER_WS_CONFIG_FLAG]: clientMcpOverWs,
             ...safeConfig
           } = config;
+          if (clientMcpOverWs === true) {
+            safeConfig["type"] = "sdk";
+          }
           const result = await manager.addRuntimeMcpServer(
             name,
             safeConfig,
             originatorClientId
           );
+          await Promise.all(
+            this.getActiveSessions().map(async (session) => {
+              const sessionManager = session.getConfig().getToolRegistry()?.getMcpClientManager();
+              if (!sessionManager) return;
+              try {
+                await sessionManager.addRuntimeMcpServer(
+                  name,
+                  safeConfig,
+                  originatorClientId
+                );
+              } catch (sessionErr) {
+                debugLogger5.warn(
+                  `workspaceMcpRuntimeAdd: failed to add runtime MCP server '${name}' to active session ${session.getConfig().getSessionId()}: ${sessionErr instanceof Error ? sessionErr.message : String(sessionErr)}`
+                );
+              }
+            })
+          );
           return result;
         } catch (err) {
           if (err instanceof McpBudgetWouldExceedError) {
@@ -8985,7 +9571,7 @@ ${outputText}
             "Invalid or missing name"
           );
         }
-        if (name.length > 256 || !/^[A-Za-z0-9_-]+$/.test(name) || name === "__proto__" || name === "constructor" || name === "prototype") {
+        if (!isValidServerName(name)) {
           throw RequestError.invalidParams(
             void 0,
             "Server name must be \u2264256 chars, alphanumeric + underscore/hyphen, and not a reserved JS property name"
@@ -9008,6 +9594,22 @@ ${outputText}
           name,
           originatorClientId
         );
+        await Promise.all(
+          this.getActiveSessions().map(async (session) => {
+            const sessionManager = session.getConfig().getToolRegistry()?.getMcpClientManager();
+            if (!sessionManager) return;
+            try {
+              await sessionManager.removeRuntimeMcpServer(
+                name,
+                originatorClientId
+              );
+            } catch (sessionErr) {
+              debugLogger5.warn(
+                `workspaceMcpRuntimeRemove: failed to remove runtime MCP server '${name}' from active session ${session.getConfig().getSessionId()}: ${sessionErr instanceof Error ? sessionErr.message : String(sessionErr)}`
+              );
+            }
+          })
+        );
         return result;
       }
       case SERVE_CONTROL_EXT_METHODS.workspaceExtensionsRefresh: {
@@ -9576,9 +10178,13 @@ ${outputText}
             }
             const config = session.getConfig();
             const authType = config.getAuthType();
-            if (changed.has("modelProviders")) {
+            const providersChanged = changed.has("modelProviders") || changed.has("providerProtocol");
+            if (providersChanged) {
               try {
-                config.reloadModelProvidersConfig(newMerged.modelProviders);
+                config.reloadModelProvidersConfig(
+                  newMerged.modelProviders,
+                  newMerged.providerProtocol ?? {}
+                );
               } catch (err) {
                 debugLogger5.warn(
                   `reload: reloadModelProvidersConfig failed for session ${id}: ${err}`
@@ -9594,7 +10200,7 @@ ${outputText}
                   `reload: switchModel failed for session ${id}: ${err}`
                 );
               }
-            } else if ((changed.has("modelProviders") || envChanged) && authType) {
+            } else if ((providersChanged || envChanged) && authType) {
               try {
                 await config.refreshAuth(authType);
               } catch (err) {
@@ -9657,6 +10263,21 @@ ${outputText}
     }
   }
   // --- private helpers ---
+  /**
+   * Reverse tool channel (issue #5626, Phase 2). Build the session
+   * `McpClientManager`'s `sendSdkMcpMessage` callback. Client-hosted
+   * (extension) MCP servers are registered SDK-type, so the manager routes
+   * their JSON-RPC through this callback. We forward each frame UP to the
+   * parent serve process via the `qwen/control/client_mcp/message` ext-method;
+   * the parent's `BridgeClient.extMethod` hands it to the per-WS-connection
+   * `ClientMcpRegistrar`, which carries it down the daemon WS to the extension
+   * and returns the correlated response (the `payload` field). All SDK-type
+   * servers in this session share one callback — the `serverName` argument
+   * routes to the right client-hosted server in the parent.
+   */
+  buildClientMcpSender() {
+    return (serverName, message) => deliverClientMcpMessage(this.connection, serverName, message);
+  }
   async newSessionConfig(cwd, mcpServers, sessionId, resume) {
     this.settings = loadSettings(cwd);
     const sessionMcpServers = {};
@@ -9710,6 +10331,10 @@ ${outputText}
         continue;
       }
     }
+    const cdpTunnelMcp = buildCdpTunnelMcpServer();
+    if (cdpTunnelMcp && !sessionMcpServers["chrome-devtools"]) {
+      sessionMcpServers["chrome-devtools"] = cdpTunnelMcp;
+    }
     const settings = this.settings.merged;
     const argvForSession = {
       ...this.argv,
@@ -9741,6 +10366,14 @@ ${outputText}
     if (typeof config.enableFileCheckpointing === "function") {
       config.enableFileCheckpointing();
     }
+    if (typeof this.config.getRuntimeMcpServers === "function" && typeof config.addRuntimeMcpServer === "function") {
+      const bootstrapRuntimeMcpServers = this.config.getRuntimeMcpServers();
+      for (const [runtimeServerName, runtimeServerConfig] of Object.entries(
+        bootstrapRuntimeMcpServers
+      )) {
+        config.addRuntimeMcpServer(runtimeServerName, runtimeServerConfig);
+      }
+    }
     if (this.mcpPool !== void 0 && typeof config.setMcpTransportPool === "function") {
       config.setMcpTransportPool(this.mcpPool);
     }
@@ -9760,7 +10393,14 @@ ${outputText}
         });
       });
     }
-    await config.initialize();
+    await config.initialize({
+      // Reverse tool channel (issue #5626, Phase 2): bind the session
+      // manager's SDK MCP callback to the `client_mcp/message` ext-method so a
+      // client-hosted (extension) MCP server added at runtime reaches the
+      // daemon WS. Servers that aren't client-hosted never use this callback
+      // (the daemon only adds SDK-type runtime servers for client MCP).
+      sendSdkMcpMessage: this.buildClientMcpSender()
+    });
     await config.waitForMcpReady();
     const failedMcpServers = typeof config.getFailedMcpServerNames === "function" ? config.getFailedMcpServerNames() : [];
     if (failedMcpServers.length > 0) {
@@ -9822,6 +10462,9 @@ ${outputText}
     if (sessionData?.fileHistorySnapshots?.length) {
       config.getFileHistoryService().restoreFromSnapshots(sessionData.fileHistorySnapshots);
     }
+    if (sessionData?.conversation.messages) {
+      config.getChatRecordingService()?.rebuildTurnBoundaries(sessionData.conversation.messages);
+    }
     if (options.replayHistory !== false && sessionData?.conversation.messages) {
       await session.replayHistory(sessionData.conversation.messages);
     }
@@ -9832,7 +10475,7 @@ ${outputText}
   buildAvailableModels(config) {
     const rawCurrentModelId = (config.getModel() || this.config.getModel() || "").trim();
     const currentAuthType = config.getAuthType();
-    const allConfiguredModels = config.getAllConfiguredModels();
+    const allConfiguredModels = config.getAllConfiguredModels().filter(isMainSelectableModel);
     const activeRuntimeSnapshot = config.getActiveRuntimeModelSnapshot?.();
     const currentModelId = activeRuntimeSnapshot ? formatAcpModelId(
       activeRuntimeSnapshot.id,
@@ -9868,7 +10511,7 @@ ${outputText}
   }
   buildConfigOptions(config) {
     const currentApprovalMode = config.getApprovalMode();
-    const allConfiguredModels = config.getAllConfiguredModels();
+    const allConfiguredModels = config.getAllConfiguredModels().filter(isMainSelectableModel);
     const rawCurrentModelId = (config.getModel() || "").trim();
     const currentAuthType = config.getAuthType?.();
     const activeRuntimeSnapshot = config.getActiveRuntimeModelSnapshot?.();
@@ -9914,6 +10557,10 @@ ${outputText}
     return authType ? formatAcpModelId(baseModelId, authType) : baseModelId;
   }
 };
+function isMainSelectableModel(model) {
+  return model.fastOnly !== true && model.voiceOnly !== true;
+}
+__name(isMainSelectableModel, "isMainSelectableModel");
 function diffSettingsKeys(oldMerged, newMerged) {
   const changed = /* @__PURE__ */ new Set();
   const allKeys = /* @__PURE__ */ new Set([
@@ -9928,10 +10575,52 @@ 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 = path2.dirname(pkgJsonPath);
+    const binPath = path2.resolve(pkgDir, binRel);
+    const binRelToPkg = path2.relative(pkgDir, binPath);
+    if (binRelToPkg.startsWith("..") || path2.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,
   fetchAllowedGitHub,
   normalizeCoreSettingValue,