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

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

@@ -3,8 +3,13 @@
 import {
   classifyApiError,
   prefixMidTurnUserMessageParts
-} from "./chunk-LLFFKXZZ.js";
-import "./chunk-B6HQGTYR.js";
+} from "./chunk-DJ25MIU2.js";
+import {
+  EXTENSION_CONTEXT_BUDGET,
+  buildExtensionMentionContext,
+  matchExtensionByRef,
+  parseExtensionRef
+} from "./chunk-YCEHOJZJ.js";
 import {
   HistoryReplayer,
   MessageEmitter,
@@ -12,90 +17,96 @@ import {
   ToolCallEmitter,
   getAvailableCommands,
   handleSlashCommand,
+  insertAfterFunctionResponses,
   isSlashCommand,
   normalizePartList
-} from "./chunk-2TJ3YN6Q.js";
+} from "./chunk-NOYV2NXI.js";
+import {
+  collectContextData,
+  formatContextUsageText
+} from "./chunk-GZKQ36JS.js";
 import {
   appEvents,
   buildDisabledSkillNamesProvider,
   loadCliConfig,
   normalizeDisabledToolList
-} from "./chunk-ZUAXI2OA.js";
+} from "./chunk-ZGSV5ORL.js";
 import {
   getCommandSubcommandNames
-} from "./chunk-4W4T77MO.js";
+} from "./chunk-BLAE2TCO.js";
+import "./chunk-32MCHZQC.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-IBEM64M4.js";
 import {
   isTerminalGoalStatusKind
 } from "./chunk-KSPVDFE4.js";
+import "./chunk-MRO43B25.js";
+import "./chunk-VXGPYF7U.js";
+import "./chunk-N4V4VBP6.js";
 import "./chunk-KYMBIKIW.js";
-import "./chunk-I2RFAW6Q.js";
+import "./chunk-JZSY4WP3.js";
+import "./chunk-HTWHAN44.js";
+import "./chunk-7SP275SH.js";
 import "./chunk-3GONHQOA.js";
-import "./chunk-5R4SBCX6.js";
-import "./chunk-Z7XXFPGP.js";
-import "./chunk-JXQ23SNT.js";
-import "./chunk-TMBPDHXD.js";
+import "./chunk-AIBPG5MB.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-Q3JOGB4U.js";
+import "./chunk-M2U5NM24.js";
+import "./chunk-GDIG7TMG.js";
+import "./chunk-G525INVW.js";
 import "./chunk-KHDZHZMH.js";
-import {
-  MID_TURN_QUEUE_DRAIN_METHOD
-} from "./chunk-QBZ22PQX.js";
 import {
   formatAcpModelId,
   parseAcpBaseModelId,
   parseAcpModelOption,
   sanitizeProviderBaseUrl
-} from "./chunk-RS4HRC75.js";
+} from "./chunk-OEY3YAL2.js";
+import {
+  PERMISSION_RULE_TYPES,
+  PermissionRulesValidationError,
+  buildPermissionSettings,
+  normalizePermissionRules,
+  readPermissionRuleSet
+} from "./chunk-DBR7PF4B.js";
+import "./chunk-LXEW6BHF.js";
+import "./chunk-NIOPRZNN.js";
 import {
   NOT_CURRENTLY_GENERATING_CANCEL_MESSAGE
-} from "./chunk-S566HKUS.js";
-import "./chunk-BS64PXY3.js";
+} from "./chunk-DHXWNSJA.js";
+import "./chunk-HIYUAXBG.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-TMILTLP3.js";
+import "./chunk-BJBWRCSK.js";
 import "./chunk-ALX6BUYW.js";
-import "./chunk-5DWXLGOM.js";
 import {
   createLoadedSettingsAdapter
-} from "./chunk-5RVSM6NW.js";
+} from "./chunk-VN4CKYUW.js";
 import {
   OUTPUT_LANGUAGE_AUTO,
   getOutputLanguageFilePath,
   getPersistScopeForModelSelection,
   isAutoLanguage,
-  isWorkspaceTrusted,
   loadSettings,
   reloadEnvironment,
   resolveOutputLanguage,
   updateOutputLanguageFile,
   writeOutputLanguageAndRegisterPath
-} from "./chunk-OQHQHJRK.js";
+} from "./chunk-6FIWYVN4.js";
 import {
   SUPPORTED_LANGUAGES,
   getCurrentLanguage,
   setLanguageAsync
-} from "./chunk-5JZLXFPD.js";
+} from "./chunk-3O2BJMFW.js";
 import "./chunk-TLRYABYP.js";
-import "./chunk-Y6Z2O3WR.js";
 import {
   AgentSideConnection,
   PROTOCOL_VERSION,
@@ -109,8 +120,15 @@ import {
   SERVE_STATUS_EXT_METHODS,
   STATUS_SCHEMA_VERSION,
   mapDomainErrorToErrorKind
-} from "./chunk-D5E5TMYH.js";
-import "./chunk-UN3C6GOR.js";
+} from "./chunk-VHRREANT.js";
+import "./chunk-PPFWEV7G.js";
+import {
+  isFolderTrustEnabled,
+  isWorkspaceTrusted,
+  loadTrustedFolders
+} from "./chunk-Z34RYLRO.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,23 @@ import {
   buildBackgroundEntryLabel,
   buildBtwCacheSafeParams,
   buildBtwPrompt,
+  buildContextUsage,
   buildInstallPlan,
+  buildSyntheticToolResponseParts,
   clampInlineMediaPart,
   clearGoalTerminalObserver,
   computeUniqueBranchTitle,
   convertToFunctionResponse,
   createDuplicateProviderToolCallResponse,
   dedupeToolCallsById,
+  detectAutonomousSentinel,
+  detectLoopSentinel,
+  detectTurnInterruption,
   evaluateAutoMode,
   evaluatePermissionFlow,
   findExistingProviderModels,
   findProviderById,
+  findRepeatedDuplicateProviderToolCall,
   fireNotificationHook,
   firePermissionRequestHook,
   firePostToolUseFailureHook,
@@ -174,6 +201,8 @@ import {
   isDenialFallbackReason,
   isPlanModeBlocked,
   isSystemReminderContent,
+  markDuplicateProviderToolCallResponseSent,
+  matchesAnyServerPattern,
   needsConfirmation,
   parsePositiveIntegerEnv,
   persistPermissionOutcome,
@@ -193,36 +222,37 @@ import {
   subagentGenerator,
   unregisterGoalHook,
   updateSetting
-} from "./chunk-PXFFKNCO.js";
+} from "./chunk-35FH347N.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-ESVSWG6Z.js";
+import "./chunk-CA4ML3VH.js";
+import "./chunk-HWG4XLD7.js";
 import {
   runSideQuery
-} from "./chunk-BG4BIP7F.js";
-import "./chunk-ZD3NW5KL.js";
+} from "./chunk-YCRTJYSQ.js";
+import "./chunk-FZY7NH37.js";
 import "./chunk-2MPVVENX.js";
 import "./chunk-ZTQ26VBE.js";
-import "./chunk-GZCJS5WH.js";
+import "./chunk-SJBIFVD2.js";
 import "./chunk-MLZQVCF3.js";
 import "./chunk-LQ7TMOCE.js";
 import "./chunk-LD2XBG6Z.js";
-import "./chunk-OTBK43JR.js";
+import "./chunk-B236XPGF.js";
 import {
   HookEventName,
   createHookOutput
-} from "./chunk-HGNSRCRB.js";
-import "./chunk-EEEZIVFJ.js";
-import "./chunk-PRYMDRBV.js";
+} from "./chunk-YXK4GPYO.js";
+import "./chunk-TOAUDIS7.js";
+import "./chunk-NPQWQYU6.js";
 import {
   AuthType,
   ConversationFinishedEvent,
   DiscoveredMCPTool,
+  LoopDetectedEvent,
   PromptSuggestionEvent,
   UserPromptEvent,
   endToolExecutionSpan,
@@ -231,6 +261,7 @@ import {
   getAllGeminiMdFilenames,
   getMCPServerStatus,
   logConversationFinishedEvent,
+  logLoopDetected,
   logPromptSuggestion,
   logToolCall,
   logUserPrompt,
@@ -239,46 +270,51 @@ import {
   startToolSpan,
   uiTelemetryService,
   withInteractionSpan
-} from "./chunk-WA5OJGFL.js";
+} from "./chunk-B5MPZI4K.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";
+  getAutoMemoryRoot,
+  getUserAutoMemoryRoot
+} from "./chunk-MOUXUCXQ.js";
+import "./chunk-BZHLWC6T.js";
+import "./chunk-E5I6YSNO.js";
 import {
   ToolConfirmationOutcome,
   ToolNames
-} from "./chunk-TOEGRAVX.js";
+} from "./chunk-JV7A66DR.js";
 import {
   clearCachedCredentialFile,
   qwenOAuth2Events
-} from "./chunk-BGUDAULQ.js";
-import "./chunk-EW6C27XX.js";
+} from "./chunk-LXGWLOCM.js";
+import "./chunk-QHHNFG22.js";
 import "./chunk-22IFUCVR.js";
-import "./chunk-64WXLC72.js";
-import "./chunk-3UALQ56H.js";
+import "./chunk-T42ACHFI.js";
 import {
+  DEFAULT_TOKEN_LIMIT,
   tokenLimit
-} from "./chunk-F6XNTYNE.js";
-import "./chunk-CGEGHF2C.js";
+} from "./chunk-YTFBURQD.js";
+import "./chunk-YPCPZSZB.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-FQDMX5IL.js";
 import {
   Storage,
   createDebugLogger,
-  getErrorStatus
-} from "./chunk-C4K3FEQ2.js";
-import "./chunk-PF523XJX.js";
+  getErrorMessage,
+  getErrorStatus,
+  isSubpath
+} from "./chunk-AVQDCKNF.js";
+import "./chunk-OE5J6UA7.js";
 import {
   runExitCleanup
-} from "./chunk-GYZQA2FO.js";
+} from "./chunk-WJAY4WXR.js";
 import "./chunk-ZERZSAZL.js";
 import "./chunk-QN5NZ3UQ.js";
 import "./chunk-BR4QREVK.js";
@@ -322,17 +358,50 @@ __name(pickAuthMethodsForAuthRequired, "pickAuthMethodsForAuthRequired");
 
 // packages/cli/src/acp-integration/service/filesystem.ts
 init_esbuild_shims();
+import { realpath } from "node:fs/promises";
+import path from "node:path";
 var RESOURCE_NOT_FOUND_CODE = -32002;
+var PATH_OUTSIDE_WORKSPACE_KIND = "path_outside_workspace";
+var SYMLINK_ESCAPE_KIND = "symlink_escape";
+var LOCAL_READ_FALLBACK_ERROR_KINDS = /* @__PURE__ */ new Set([
+  PATH_OUTSIDE_WORKSPACE_KIND,
+  SYMLINK_ESCAPE_KIND
+]);
+var debugLogger = createDebugLogger("ACP_FILE_SYSTEM");
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isRecord, "isRecord");
 function getErrorCode(error) {
   if (error instanceof RequestError) {
     return error.code;
   }
-  if (typeof error === "object" && error !== null && "code" in error) {
-    return error.code;
+  if (isRecord(error)) {
+    return error["code"];
   }
   return void 0;
 }
 __name(getErrorCode, "getErrorCode");
+function getErrorData(error) {
+  const data = isRecord(error) ? error["data"] : void 0;
+  return isRecord(data) ? data : void 0;
+}
+__name(getErrorData, "getErrorData");
+function getErrorKind(error) {
+  const data = getErrorData(error);
+  if (data && typeof data["errorKind"] === "string") {
+    return data["errorKind"];
+  }
+  return void 0;
+}
+__name(getErrorKind, "getErrorKind");
+function normalizeError(error) {
+  if (error instanceof Error) return error;
+  return new Error(getErrorMessage(error), {
+    cause: error
+  });
+}
+__name(normalizeError, "normalizeError");
 function createEnoentError(filePath) {
   const err = new Error(`File not found: ${filePath}`);
   err.code = "ENOENT";
@@ -341,12 +410,32 @@ function createEnoentError(filePath) {
   return err;
 }
 __name(createEnoentError, "createEnoentError");
+function isLocalReadFallbackErrorKind(errorKind) {
+  return typeof errorKind === "string" && LOCAL_READ_FALLBACK_ERROR_KINDS.has(errorKind);
+}
+__name(isLocalReadFallbackErrorKind, "isLocalReadFallbackErrorKind");
+async function resolveRealPath(value) {
+  if (!value.trim()) return void 0;
+  try {
+    return await realpath(path.resolve(value));
+  } catch (error) {
+    if (getErrorCode(error) !== "ENOENT") {
+      debugLogger.warn("realpath failed during ACP local read fallback check", {
+        path: value,
+        error: getErrorMessage(error)
+      });
+    }
+    return void 0;
+  }
+}
+__name(resolveRealPath, "resolveRealPath");
 var AcpFileSystemService = class {
-  constructor(connection, sessionId, capabilities, fallback) {
+  constructor(connection, sessionId, capabilities, fallback, options = {}) {
     this.connection = connection;
     this.sessionId = sessionId;
     this.capabilities = capabilities;
     this.fallback = fallback;
+    this.options = options;
   }
   static {
     __name(this, "AcpFileSystemService");
@@ -366,7 +455,45 @@ var AcpFileSystemService = class {
       if (errorCode === RESOURCE_NOT_FOUND_CODE) {
         throw createEnoentError(params.path);
       }
-      throw error;
+      const errorKind = getErrorKind(error);
+      const shouldTryLocalReadFallback = isLocalReadFallbackErrorKind(errorKind);
+      const fallbackPath = shouldTryLocalReadFallback ? await this.getLocalReadFallbackPath(params.path) : void 0;
+      if (shouldTryLocalReadFallback && !fallbackPath) {
+        debugLogger.debug("Local read fallback skipped - no safe local path", {
+          path: params.path,
+          errorKind
+        });
+      }
+      if (shouldTryLocalReadFallback && fallbackPath) {
+        debugLogger.debug("Falling back to local read after ACP error", {
+          path: params.path,
+          resolvedPath: fallbackPath,
+          errorKind,
+          error: getErrorMessage(error)
+        });
+        try {
+          return await this.fallback.readTextFile({
+            ...params,
+            path: fallbackPath
+          });
+        } catch (fallbackError) {
+          if (getErrorCode(fallbackError) === "ENOENT") {
+            throw fallbackError;
+          }
+          debugLogger.warn("Local read fallback failed after ACP error", {
+            path: params.path,
+            resolvedPath: fallbackPath,
+            errorKind,
+            originalError: getErrorMessage(error),
+            fallbackError: getErrorMessage(fallbackError)
+          });
+          throw new Error(
+            `Local fallback read failed for ${params.path}: ${getErrorMessage(fallbackError)} (original ACP error: ${getErrorMessage(error)})`,
+            { cause: { fallbackError, acpError: error } }
+          );
+        }
+      }
+      throw normalizeError(error);
     }
     return response;
   }
@@ -375,27 +502,54 @@ var AcpFileSystemService = class {
       return this.fallback.writeTextFile(params);
     }
     const finalContent = params._meta?.["bom"] && params.content.charCodeAt(0) !== 65279 ? "\uFEFF" + params.content : params.content;
-    await this.connection.writeTextFile({
-      ...params,
-      content: finalContent,
-      sessionId: this.sessionId
-    });
+    try {
+      await this.connection.writeTextFile({
+        ...params,
+        content: finalContent,
+        sessionId: this.sessionId
+      });
+    } catch (error) {
+      if (getErrorCode(error) === RESOURCE_NOT_FOUND_CODE) {
+        throw createEnoentError(params.path);
+      }
+      throw normalizeError(error);
+    }
     return { _meta: params._meta };
   }
   findFiles(fileName, searchPaths) {
     return this.fallback.findFiles(fileName, searchPaths);
   }
+  async getResolvedLocalReadRoots() {
+    const roots = await Promise.all(
+      (this.options.localReadRoots ?? []).map(resolveRealPath)
+    );
+    return roots.filter((root) => Boolean(root));
+  }
+  async getLocalReadFallbackPath(filePath) {
+    const normalizedFilePath = path.resolve(filePath);
+    const realFilePath = await resolveRealPath(normalizedFilePath);
+    if (!realFilePath) return void 0;
+    for (const realRoot of await this.getResolvedLocalReadRoots()) {
+      if (isSubpath(realRoot, realFilePath)) {
+        return realFilePath;
+      }
+    }
+    return void 0;
+  }
 };
 
 // packages/cli/src/acp-integration/acpAgent.ts
 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 path3 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 path2 from "node:path";
 
 // packages/cli/src/acp-integration/session/SubAgentTracker.ts
 init_esbuild_shims();
@@ -577,7 +731,7 @@ function toPermissionOptions(confirmation, forceHideAlwaysAllow = false) {
 __name(toPermissionOptions, "toPermissionOptions");
 
 // packages/cli/src/acp-integration/session/SubAgentTracker.ts
-var debugLogger = createDebugLogger("ACP_SUBAGENT_TRACKER");
+var debugLogger2 = createDebugLogger("ACP_SUBAGENT_TRACKER");
 var SubAgentTracker = class {
   constructor(ctx, client, parentToolCallId, subagentType, onPermissionCancel) {
     this.ctx = ctx;
@@ -637,7 +791,7 @@ var SubAgentTracker = class {
         try {
           invocation = tool.build(event.args);
         } catch (e) {
-          debugLogger.warn(`Failed to build subagent tool ${event.name}:`, e);
+          debugLogger2.warn(`Failed to build subagent tool ${event.name}:`, e);
         }
       }
       this.toolStates.set(event.callId, {
@@ -716,7 +870,7 @@ var SubAgentTracker = class {
           this.onPermissionCancel?.();
         }
       } catch (error) {
-        debugLogger.error(
+        debugLogger2.error(
           `Permission request failed for subagent tool ${event.name}:`,
           error
         );
@@ -724,7 +878,7 @@ var SubAgentTracker = class {
         try {
           await event.respond("cancel" /* Cancel */);
         } catch (respondError) {
-          debugLogger.error(
+          debugLogger2.error(
             `Failed to cancel subagent tool ${event.name} after permission request failure:`,
             respondError
           );
@@ -823,7 +977,7 @@ var TurnBuffer = class {
 init_esbuild_shims();
 import { readFileSync, existsSync } from "node:fs";
 import { resolve } from "node:path";
-var debugLogger2 = createDebugLogger("MESSAGE_REWRITER");
+var debugLogger3 = createDebugLogger("MESSAGE_REWRITER");
 var DEFAULT_REWRITE_PROMPT = `You are an assistant that rewrites raw coding-agent output into concise, user-friendly progress updates.
 
 The agent is a software engineering assistant that reads files, writes code, runs commands, and uses tools. Its raw output mixes internal reasoning with user-facing information. Your job: extract what the user cares about, drop what they don't.
@@ -852,11 +1006,11 @@ var LlmRewriter = class {
       const filePath = resolve(rewriteConfig.promptFile);
       if (existsSync(filePath)) {
         this.prompt = readFileSync(filePath, "utf-8").trim();
-        debugLogger2.info(
+        debugLogger3.info(
           `Loaded rewrite prompt from file: ${filePath} (${this.prompt.length} chars)`
         );
       } else {
-        debugLogger2.warn(
+        debugLogger3.warn(
           `Rewrite prompt file not found: ${filePath}, using default`
         );
         this.prompt = DEFAULT_REWRITE_PROMPT;
@@ -893,7 +1047,7 @@ var LlmRewriter = class {
     const inputText = inputParts.join("\n\n");
     if (!inputText.trim()) return null;
     if (inputText.length < 10) return null;
-    debugLogger2.info(
+    debugLogger3.info(
       `[REWRITE INPUT] system_prompt_len=${this.prompt.length} input_len=${inputText.length} context_turns=${this.outputHistory.length}
 --- INPUT TEXT ---
 ${inputText}
@@ -922,10 +1076,10 @@ ${inputText}
       });
       const rewritten = result.text;
       if (!rewritten || rewritten.length < 5) {
-        debugLogger2.info(`[REWRITE OUTPUT] empty or too short, skipping`);
+        debugLogger3.info(`[REWRITE OUTPUT] empty or too short, skipping`);
         return null;
       }
-      debugLogger2.info(
+      debugLogger3.info(
         `[REWRITE OUTPUT] len=${rewritten.length}
 --- OUTPUT ---
 ${rewritten}
@@ -934,7 +1088,7 @@ ${rewritten}
       this.outputHistory.push(rewritten);
       return rewritten;
     } catch (error) {
-      debugLogger2.warn(
+      debugLogger3.warn(
         `LLM rewrite failed, skipping: ${error instanceof Error ? error.message : String(error)}`
       );
       return null;
@@ -943,7 +1097,7 @@ ${rewritten}
 };
 
 // packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.ts
-var debugLogger3 = createDebugLogger("MESSAGE_REWRITE");
+var debugLogger4 = createDebugLogger("MESSAGE_REWRITE");
 var DEFAULT_REWRITE_TIMEOUT_MS = 3e4;
 var REWRITE_META_EXCLUDED_KEYS = /* @__PURE__ */ new Set([]);
 var MessageRewriteMiddleware = class {
@@ -1023,10 +1177,10 @@ var MessageRewriteMiddleware = class {
         try {
           const rewritten = await this.rewriter.rewrite(content, rewriteSignal);
           if (!rewritten) {
-            debugLogger3.info(`Turn ${turnIdx}: no rewrite output`);
+            debugLogger4.info(`Turn ${turnIdx}: no rewrite output`);
             return;
           }
-          debugLogger3.info(
+          debugLogger4.info(
             `Turn ${turnIdx}: rewritten ${rewritten.length} chars`
           );
           await this.sendUpdate({
@@ -1039,7 +1193,7 @@ var MessageRewriteMiddleware = class {
             }
           });
         } catch (error) {
-          debugLogger3.warn(
+          debugLogger4.warn(
             `Turn ${turnIdx}: rewrite failed: ${error instanceof Error ? error.message : String(error)}`
           );
         }
@@ -1084,9 +1238,10 @@ function loadRewriteConfig(settings) {
 __name(loadRewriteConfig, "loadRewriteConfig");
 
 // packages/cli/src/acp-integration/session/Session.ts
-var debugLogger4 = createDebugLogger("SESSION");
+var debugLogger5 = 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)";
@@ -1094,7 +1249,56 @@ function maskApiKeyForDisplay(apiKey) {
   return `${trimmed.slice(0, 3)}...${trimmed.slice(-4)}`;
 }
 __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.";
+function createDaemonToolLoopState() {
+  return {
+    totalToolCalls: 0,
+    invalidToolParamErrors: /* @__PURE__ */ new Map(),
+    loopDetected: false
+  };
+}
+__name(createDaemonToolLoopState, "createDaemonToolLoopState");
+function recordDaemonLoopDetected(config, promptId, loopType, message, loopState) {
+  if (!loopState.loopDetected) {
+    loopState.loopDetected = true;
+    debugLogger5.warn(message);
+    logLoopDetected(config, new LoopDetectedEvent(loopType, promptId));
+  }
+  return true;
+}
+__name(recordDaemonLoopDetected, "recordDaemonLoopDetected");
+function recordDaemonToolCalls(config, promptId, loopState, count) {
+  if (!loopState || loopState.loopDetected)
+    return loopState?.loopDetected ?? false;
+  loopState.totalToolCalls += count;
+  if (loopState.totalToolCalls <= DAEMON_TURN_TOOL_CALL_CAP) return false;
+  return recordDaemonLoopDetected(
+    config,
+    promptId,
+    "turn_tool_call_cap" /* TURN_TOOL_CALL_CAP */,
+    `Stopping ACP turn after ${loopState.totalToolCalls} tool calls in one turn.`,
+    loopState
+  );
+}
+__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 count = (loopState.invalidToolParamErrors.get(key) ?? 0) + 1;
+  loopState.invalidToolParamErrors.set(key, count);
+  if (count < DAEMON_INVALID_TOOL_PARAMS_THRESHOLD) return false;
+  return recordDaemonLoopDetected(
+    config,
+    promptId,
+    "invalid_tool_params_stagnation" /* INVALID_TOOL_PARAMS_STAGNATION */,
+    `Stopping ACP turn after repeated tool parameter errors from ${toolName}: ${error.message}`,
+    loopState
+  );
+}
+__name(recordDaemonInvalidToolParams, "recordDaemonInvalidToolParams");
 var MID_TURN_QUEUE_DRAIN_TIMEOUT_MS = 2e3;
 var MID_TURN_QUEUE_RECOVERY_TIMEOUT_MS = 3e4;
 var MID_TURN_QUEUE_RESOLVE_TIMEOUT_MS = 1e4;
@@ -1102,12 +1306,20 @@ 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;
-function isRecord(value) {
+var TRANSIENT_FS_CODES = [
+  "EACCES",
+  "EIO",
+  "EBUSY",
+  "EPERM",
+  "EISDIR",
+  "ENOTDIR"
+];
+function isRecord2(value) {
   return value !== null && typeof value === "object";
 }
-__name(isRecord, "isRecord");
+__name(isRecord2, "isRecord");
 function isContentBlock(value) {
-  if (!isRecord(value) || typeof value["type"] !== "string") return false;
+  if (!isRecord2(value) || typeof value["type"] !== "string") return false;
   switch (value["type"]) {
     case "text":
       return typeof value["text"] === "string";
@@ -1120,7 +1332,7 @@ function isContentBlock(value) {
     case "resource":
       return isEmbeddedResourceResource(value["resource"]);
     default:
-      debugLogger4.warn(`Unknown ContentBlock type: ${value["type"]}`);
+      debugLogger5.warn(`Unknown ContentBlock type: ${value["type"]}`);
       return false;
   }
 }
@@ -1146,7 +1358,7 @@ async function withTimeoutSignal(parentSignal, timeoutMs, fn) {
 }
 __name(withTimeoutSignal, "withTimeoutSignal");
 function isEmbeddedResourceResource(value) {
-  if (!isRecord(value) || typeof value["uri"] !== "string") return false;
+  if (!isRecord2(value) || typeof value["uri"] !== "string") return false;
   if (typeof value["text"] === "string") {
     return value["text"].length <= MAX_MID_TURN_RESOURCE_TEXT_LENGTH;
   }
@@ -1159,7 +1371,7 @@ function hasInlineMediaContentBlock(content) {
 __name(hasInlineMediaContentBlock, "hasInlineMediaContentBlock");
 function capMidTurnDrainItems(items, fieldName) {
   if (items.length <= MAX_MID_TURN_DRAIN_ITEMS) return items;
-  debugLogger4.warn(
+  debugLogger5.warn(
     `Mid-turn drain response had ${items.length} ${fieldName}; processing first ${MAX_MID_TURN_DRAIN_ITEMS}`
   );
   return items.slice(0, MAX_MID_TURN_DRAIN_ITEMS);
@@ -1174,7 +1386,7 @@ function getMidTurnItemDisplayTextForLog(displayText) {
 __name(getMidTurnItemDisplayTextForLog, "getMidTurnItemDisplayTextForLog");
 function getValidMidTurnContentBlocks(content, displayText) {
   if (!Array.isArray(content)) {
-    debugLogger4.warn(
+    debugLogger5.warn(
       `Dropped invalid mid-turn item: ${getMidTurnItemDisplayTextForLog(
         displayText
       )}`
@@ -1184,7 +1396,7 @@ function getValidMidTurnContentBlocks(content, displayText) {
   const validBlocks = content.filter(isContentBlock);
   const invalidBlockCount = content.length - validBlocks.length;
   if (invalidBlockCount > 0) {
-    debugLogger4.warn(
+    debugLogger5.warn(
       `Dropped ${invalidBlockCount} invalid mid-turn content block(s): ${getMidTurnItemDisplayTextForLog(
         displayText
       )}`
@@ -1204,11 +1416,11 @@ function getStructuredMidTurnDisplayText(content, displayText) {
 }
 __name(getStructuredMidTurnDisplayText, "getStructuredMidTurnDisplayText");
 function parseMidTurnDrainResponse(response) {
-  if (!isRecord(response)) return [];
+  if (!isRecord2(response)) return [];
   if (Array.isArray(response["items"])) {
     return capMidTurnDrainItems(response["items"], "item(s)").flatMap(
       (item) => {
-        if (!isRecord(item)) {
+        if (!isRecord2(item)) {
           return [];
         }
         const content = getValidMidTurnContentBlocks(
@@ -1230,7 +1442,7 @@ function parseMidTurnDrainResponse(response) {
     );
   }
   if (!Array.isArray(response["messages"])) {
-    debugLogger4.warn(
+    debugLogger5.warn(
       `Mid-turn drain response had no recognized 'items' or 'messages' field; keys: ${Object.keys(
         response
       ).join(", ")}`
@@ -1287,7 +1499,7 @@ async function fireSessionPermissionDeniedForAutoMode(config, decision, outcome,
         callId
       );
     } catch (hookError) {
-      debugLogger4.warn(
+      debugLogger5.warn(
         `PermissionDenied hook failed for tool ${callId}: ${hookError instanceof Error ? hookError.message : String(hookError)}`
       );
     }
@@ -1328,6 +1540,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 +1571,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 } : {}
       }
     };
   });
@@ -1370,7 +1599,7 @@ async function buildAvailableCommandsSnapshot(config, abortSignal = AbortSignal.
       }
     }
   } catch (error) {
-    debugLogger4.error("Error loading available skills:", error);
+    debugLogger5.error("Error loading available skills:", error);
   }
   for (const command of slashCommands) {
     if (command.kind !== "skill" /* SKILL */ || !command.skillDetail) {
@@ -1442,12 +1671,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
@@ -1501,7 +1741,7 @@ var Session = class {
    */
   startCronScheduler() {
     this.#startCronSchedulerIfNeeded().catch((error) => {
-      debugLogger4.warn(
+      debugLogger5.warn(
         `Cron scheduler startup failed [session ${this.sessionId}]: ${error}`
       );
     });
@@ -1548,7 +1788,7 @@ var Session = class {
   installRewriter() {
     const rewriteConfig = loadRewriteConfig(this.settings);
     if (rewriteConfig?.enabled) {
-      debugLogger4.info("Message rewrite middleware enabled");
+      debugLogger5.info("Message rewrite middleware enabled");
       this.messageRewriter = new MessageRewriteMiddleware(
         this.config,
         rewriteConfig,
@@ -1559,7 +1799,7 @@ var Session = class {
   #installGoalTerminalObserver() {
     setGoalTerminalObserver(this.sessionId, (event) => {
       void this.messageEmitter.emitGoalTerminal(event).catch((error) => {
-        debugLogger4.warn(
+        debugLogger5.warn(
           `Failed to emit goal terminal update: ${this.#formatError(error)}`
         );
       });
@@ -1567,7 +1807,7 @@ var Session = class {
   }
   emitGoalStatus(status) {
     void this.messageEmitter.emitGoalStatus(status).catch((error) => {
-      debugLogger4.warn(
+      debugLogger5.warn(
         `Failed to emit goal status update: ${this.#formatError(error)}`
       );
     });
@@ -1751,6 +1991,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 +2010,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
@@ -1805,7 +2076,7 @@ var Session = class {
         const fullHistory = chat.getHistory(true);
         const lastEntry = fullHistory[fullHistory.length - 1];
         if (!lastEntry || lastEntry.role !== "model") {
-          debugLogger4.debug(
+          debugLogger5.debug(
             "Skipping followup suggestion: last history entry is not model"
           );
           return;
@@ -1841,9 +2112,9 @@ var Session = class {
         }
       } catch (error) {
         if (ac.signal.aborted) {
-          debugLogger4.debug("Follow-up suggestion generation aborted");
+          debugLogger5.debug("Follow-up suggestion generation aborted");
         } else {
-          debugLogger4.warn("Follow-up suggestion generation failed", error);
+          debugLogger5.warn("Follow-up suggestion generation failed", error);
         }
       } finally {
         if (this.followupAbort === ac) {
@@ -1886,7 +2157,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") {
+                debugLogger5.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 +2200,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 +2224,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 */,
@@ -1934,7 +2240,7 @@ var Session = class {
               if (hookOutput?.isBlockingDecision() || hookOutput?.shouldStopExecution()) {
                 const blockReason = hookOutput?.getEffectiveReason() || "No reason provided";
                 await this.messageEmitter.emitAgentMessage(
-                  `\u{1F6AB} **UserPromptSubmit blocked**: ${blockReason}`
+                  `\u2717 **UserPromptSubmit blocked**: ${blockReason}`
                 );
                 return { stopReason: "end_turn" };
               }
@@ -1952,30 +2258,34 @@ var Session = class {
                   this.config.getChatRecordingService()?.recordFileHistorySnapshot(latestSnapshot);
                 }
               } catch (e) {
-                debugLogger4.error(`FileHistory: recordSnapshot failed: ${e}`);
+                debugLogger5.error(`FileHistory: recordSnapshot failed: ${e}`);
               }
             } catch (e) {
-              debugLogger4.error(`FileHistory: makeSnapshot failed: ${e}`);
+              debugLogger5.error(`FileHistory: makeSnapshot failed: ${e}`);
             }
             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 };
             let turnCount = 0;
+            const toolLoopState = createDaemonToolLoopState();
             try {
               while (nextMessage !== null) {
                 turnCount++;
@@ -1995,7 +2305,7 @@ ${this.pendingWorktreeNotice}
                   if (!sendResult.responseStream) {
                     this.#preserveUnsentMessageHistory(
                       nextMessage,
-                      sendResult.stopReason === "cancelled"
+                      isContinue || sendResult.stopReason === "cancelled"
                     );
                     return { stopReason: sendResult.stopReason };
                   }
@@ -2026,6 +2336,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" };
                   }
@@ -2039,7 +2355,7 @@ ${this.pendingWorktreeNotice}
                   const hooksEnabledForStopFailure = !this.config.getDisableAllHooks?.();
                   if (hooksEnabledForStopFailure && hookSystem && this.config.hasHooksForEvent?.("StopFailure")) {
                     hookSystem.fireStopFailureEvent(errorType, errorMessage).catch((err) => {
-                      debugLogger4.warn(`StopFailure hook failed: ${err}`);
+                      debugLogger5.warn(`StopFailure hook failed: ${err}`);
                     });
                   }
                   if (errorStatus === 429) {
@@ -2066,7 +2382,8 @@ ${this.pendingWorktreeNotice}
                   const toolRun = await this.runToolCalls(
                     pendingSend.signal,
                     promptId,
-                    functionCalls
+                    functionCalls,
+                    toolLoopState
                   );
                   if (toolRun.stopAfterPermissionCancel) {
                     await this.#preserveCancelledPermissionToolRun(
@@ -2075,15 +2392,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 +2443,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
         },
@@ -2166,7 +2483,7 @@ ${this.pendingWorktreeNotice}
             warning
           );
           await this.messageEmitter.emitAgentMessage(warning);
-          debugLogger4.warn(warning);
+          debugLogger5.warn(warning);
           return { stopReason: "end_turn" };
         }
         if (stopHookIterationCount > 1) {
@@ -2181,6 +2498,7 @@ ${this.pendingWorktreeNotice}
           role: "user",
           parts: continueParts
         };
+        const toolLoopState = createDaemonToolLoopState();
         while (nextMessage !== null) {
           if (pendingSend.signal.aborted) {
             return { stopReason: "cancelled" };
@@ -2237,7 +2555,7 @@ ${this.pendingWorktreeNotice}
             const hooksEnabledForStopFailure = !this.config.getDisableAllHooks?.();
             if (hooksEnabledForStopFailure && hookSystem && this.config.hasHooksForEvent?.("StopFailure")) {
               hookSystem.fireStopFailureEvent(errorType, errorMessage).catch((err) => {
-                debugLogger4.warn(`StopFailure hook failed: ${err}`);
+                debugLogger5.warn(`StopFailure hook failed: ${err}`);
               });
             }
             if (errorStatus === 429) {
@@ -2261,7 +2579,8 @@ ${this.pendingWorktreeNotice}
             const toolRun = await this.runToolCalls(
               pendingSend.signal,
               promptId,
-              functionCalls
+              functionCalls,
+              toolLoopState
             );
             if (toolRun.stopAfterPermissionCancel) {
               await this.#preserveCancelledPermissionToolRun(
@@ -2270,13 +2589,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,21 +2633,22 @@ ${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).`;
         }
       } catch (compressionError) {
         if (abortSignal.aborted || this.#isAbortError(compressionError)) {
-          debugLogger4.debug(`Auto-compression aborted for prompt ${promptId}`);
+          debugLogger5.debug(`Auto-compression aborted for prompt ${promptId}`);
           return { responseStream: null, stopReason: "cancelled" };
         }
-        debugLogger4.warn(
+        debugLogger5.warn(
           `Auto-compression failed for prompt ${promptId}; proceeding without compression: ` + this.#formatError(compressionError)
         );
       }
     }
     if (abortSignal.aborted) {
-      debugLogger4.debug(`Auto-compression aborted for prompt ${promptId}`);
+      debugLogger5.debug(`Auto-compression aborted for prompt ${promptId}`);
       return { responseStream: null, stopReason: "cancelled" };
     }
     if (!compressionInfo) {
@@ -2341,7 +2658,7 @@ ${this.pendingWorktreeNotice}
     if (sessionTokenLimit > 0) {
       const lastPromptTokenCount = this.#getPostCompressionTokenCount(compressionInfo);
       if (lastPromptTokenCount > sessionTokenLimit) {
-        debugLogger4.warn(
+        debugLogger5.warn(
           `Session token limit exceeded for prompt ${promptId}: ${lastPromptTokenCount} > ${sessionTokenLimit}. Send dropped.`
         );
         await this.#emitAgentDiagnosticMessageSafely(
@@ -2358,7 +2675,7 @@ ${this.pendingWorktreeNotice}
       );
     }
     if (abortSignal.aborted) {
-      debugLogger4.debug(
+      debugLogger5.debug(
         `Send aborted after compression diagnostic for prompt ${promptId}`
       );
       return { responseStream: null, stopReason: "cancelled" };
@@ -2386,7 +2703,7 @@ ${this.pendingWorktreeNotice}
     ) ?? [];
     const droppedParts = (message.parts?.length ?? 0) - functionResponseParts.length;
     if (droppedParts > 0) {
-      debugLogger4.debug(
+      debugLogger5.debug(
         `Dropping ${droppedParts} non-functionResponse part(s) from unsent ACP message after send was skipped.`
       );
     }
@@ -2410,6 +2727,23 @@ ${this.pendingWorktreeNotice}
     );
     await this.messageRewriter?.waitForPendingRewrites();
   }
+  async #buildNextMessageAfterToolRun(toolRun, abortSignal) {
+    if (toolRun.loopDetected) {
+      debugLogger5.debug("Stopping ACP turn after daemon loop detection.");
+      return null;
+    }
+    if (toolRun.repeatedDuplicateProviderToolCall) {
+      debugLogger5.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);
@@ -2477,7 +2811,7 @@ ${this.pendingWorktreeNotice}
     try {
       await this.#emitAgentDiagnosticMessage(text);
     } catch (notifyError) {
-      debugLogger4.warn(`${failureContext}: ${this.#formatError(notifyError)}`);
+      debugLogger5.warn(`${failureContext}: ${this.#formatError(notifyError)}`);
     }
   }
   async #emitAgentDiagnosticMessage(text) {
@@ -2526,7 +2860,7 @@ ${this.pendingWorktreeNotice}
       if (isPermanentError) {
         this.midTurnDrainUnavailable = true;
       }
-      debugLogger4.warn(
+      debugLogger5.warn(
         `Mid-turn queue drain ${isPermanentError ? "permanently " : ""}unavailable [session ${this.sessionId}]: ${errorMessage}`
       );
       return this.#buildMidTurnParts(recovered, abortSignal);
@@ -2568,14 +2902,14 @@ ${this.pendingWorktreeNotice}
       clearTimeout(timer);
     }
     if (late === expired) {
-      debugLogger4.warn(
+      debugLogger5.warn(
         `[mid-turn] dropped a drain response that arrived after the ${MID_TURN_QUEUE_RECOVERY_TIMEOUT_MS}ms recovery deadline [session ${this.sessionId}]`
       );
       return;
     }
     const lateMessages = parseMidTurnDrainResponse(late);
     if (lateMessages.length > 0) {
-      debugLogger4.debug(
+      debugLogger5.debug(
         `[mid-turn] recovered ${lateMessages.length} message(s) from a timed-out drain [session ${this.sessionId}]`
       );
       this.midTurnRecoveredMessages.push(...lateMessages);
@@ -2601,7 +2935,7 @@ ${this.pendingWorktreeNotice}
       } catch (messageError) {
         if (abortSignal.aborted) return parts;
         const errorMessage = this.#formatError(messageError);
-        debugLogger4.warn(`Failed to resolve mid-turn message: ${errorMessage}`);
+        debugLogger5.warn(`Failed to resolve mid-turn message: ${errorMessage}`);
         rawParts = [{ text: displayText }];
         if (message.kind === "structured" && hasInlineMediaContentBlock(message.content)) {
           rawParts.push({ text: MID_TURN_ATTACHMENT_PROCESSING_FAILURE_TEXT });
@@ -2626,20 +2960,23 @@ ${this.pendingWorktreeNotice}
     try {
       await scheduler.enableDurable(this.sessionId);
     } catch (err) {
-      debugLogger4.warn(
+      debugLogger5.warn(
         `Durable cron init failed \u2014 persistent tasks will not fire in this session: ${err}`
       );
     }
     if (this.disposed) return;
     if (!scheduler.hasPendingWork) return;
-    scheduler.start((job) => {
-      if (this.cronDisabledByTokenLimit) return;
-      this.cronQueue.push({
-        prompt: job.prompt,
-        source: job.cronExpr === "@wakeup" ? "loop" : "cron"
-      });
-      void this.#drainCronQueue();
-    });
+    scheduler.start(
+      (job) => {
+        if (this.cronDisabledByTokenLimit) return;
+        if (job.missed && detectAutonomousSentinel(job.prompt)) return;
+        this.cronQueue.push({
+          prompt: job.prompt,
+          source: job.cronExpr === "@wakeup" ? "loop" : "cron"
+        });
+        void this.#drainCronQueue();
+      }
+    );
   }
   /**
    * Processes queued cron prompts one at a time. Uses `cronProcessing`
@@ -2673,6 +3010,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()) || path2.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,16 +3062,65 @@ ${this.pendingWorktreeNotice}
           async () => {
             let turnCount = 0;
             try {
+              const loopMode = detectLoopSentinel(prompt);
+              const autonomousMode = loopMode ? null : detectAutonomousSentinel(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";
+                  debugLogger5.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
+                      )}`
+                    );
+                  }
+                }
+              } else if (autonomousMode) {
+                loopTick = this.#getLoopTickResolver().resolveAutonomous(autonomousMode);
+              }
+              const modelText = loopTick ? loopTick.modelText : prompt;
+              if (loopTick) {
+                debugLogger5.debug(
+                  `loop tick: mode=${loopMode ?? autonomousMode} delivery=${loopTick.full ? "full" : loopTick.transientError ? "transient-error" : loopTick.autonomous ? "autonomous-tick" : loopTick.sourceLabel ? "reminder" : "absent"} source=${loopTick.sourceLabel ?? "none"} autonomous=${loopTick.autonomous ?? false} transient=${loopTick.transientError ?? false}`
+                );
+              }
+              const echoText = !loopTick ? prompt : (
+                // An autonomous tick (a bare-`/loop` sentinel, or a loop.md
+                // sentinel whose file is gone and converged on the preamble).
+                loopTick.autonomous ? "Autonomous loop tick" : loopTick.sourceLabel ? `Loop tick \u2014 tasks from ${loopTick.sourceLabel}` : (
+                  // The only remaining tick is a transient read failure
+                  // (buildTransientErrorTick): a loop.md exists but couldn't be
+                  // read this tick. A genuinely-absent loop.md converges on the
+                  // autonomous branch above, so there is no "not present" echo.
+                  "Loop tick \u2014 loop.md temporarily unavailable"
+                )
+              );
               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 }]
               };
+              const toolLoopState = createDaemonToolLoopState();
               while (nextMessage !== null) {
                 turnCount++;
                 if (ac.signal.aborted) return;
@@ -2735,6 +3143,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;
@@ -2772,7 +3183,8 @@ ${this.pendingWorktreeNotice}
                   const toolRun = await this.runToolCalls(
                     ac.signal,
                     promptId,
-                    functionCalls
+                    functionCalls,
+                    toolLoopState
                   );
                   if (toolRun.stopAfterPermissionCancel) {
                     await this.#preserveCancelledPermissionToolRun(
@@ -2781,19 +3193,16 @@ ${this.pendingWorktreeNotice}
                     );
                     return;
                   }
-                  nextMessage = {
-                    role: "user",
-                    parts: [
-                      ...toolRun.parts,
-                      ...await this.#drainMidTurnUserMessages(ac.signal)
-                    ]
-                  };
+                  nextMessage = await this.#buildNextMessageAfterToolRun(
+                    toolRun,
+                    ac.signal
+                  );
                 }
               }
             } catch (error) {
               if (ac.signal.aborted) return;
               cronHadError = true;
-              debugLogger4.error("Error processing cron prompt:", error);
+              debugLogger5.error("Error processing cron prompt:", error);
               const msg = error instanceof Error ? error.message : String(error);
               await this.messageEmitter.emitAgentMessage(
                 `[${item.source} error] ${msg}`
@@ -2877,7 +3286,7 @@ ${this.pendingWorktreeNotice}
   #enqueueBackgroundNotification(item) {
     while (this.notificationQueue.length >= MAX_NOTIFICATION_QUEUE) {
       const evicted = this.notificationQueue.shift();
-      debugLogger4.warn(
+      debugLogger5.warn(
         `Notification queue overflow: evicting task=${evicted.taskId} kind=${evicted.kind}`
       );
     }
@@ -2934,6 +3343,7 @@ ${this.pendingWorktreeNotice}
             role: "user",
             parts: [...notificationReminders, ...notificationParts]
           };
+          const toolLoopState = createDaemonToolLoopState();
           while (nextMessage !== null) {
             if (ac.signal.aborted) {
               await this.#emitBackgroundNotificationEndTurn("cancelled");
@@ -3010,7 +3420,8 @@ ${this.pendingWorktreeNotice}
               const toolRun = await this.runToolCalls(
                 ac.signal,
                 promptId,
-                functionCalls
+                functionCalls,
+                toolLoopState
               );
               if (toolRun.stopAfterPermissionCancel) {
                 await this.#preserveCancelledPermissionToolRun(
@@ -3020,13 +3431,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) {
@@ -3038,14 +3446,14 @@ ${this.pendingWorktreeNotice}
             await this.#emitBackgroundNotificationEndTurn("cancelled");
             return;
           }
-          debugLogger4.error("Error processing background notification:", error);
+          debugLogger5.error("Error processing background notification:", error);
           const msg = error instanceof Error ? error.message : String(error);
           try {
             await this.messageEmitter.emitAgentMessage(
               `[notification error] ${msg}`
             );
           } catch (emitError) {
-            debugLogger4.error(
+            debugLogger5.error(
               "Failed to emit background notification error:",
               emitError
             );
@@ -3105,7 +3513,7 @@ ${this.pendingWorktreeNotice}
         source: "background_notification"
       });
     } catch (error) {
-      debugLogger4.debug(
+      debugLogger5.debug(
         `Background notification end-turn extNotification dropped: ${this.#formatError(error)}`
       );
     }
@@ -3129,7 +3537,7 @@ ${this.pendingWorktreeNotice}
       };
       await this.sendUpdate(update);
     } catch (error) {
-      debugLogger4.error("Error sending available commands update:", error);
+      debugLogger5.error("Error sending available commands update:", error);
     }
   }
   /**
@@ -3164,7 +3572,7 @@ ${this.pendingWorktreeNotice}
       sessionId: this.sessionId,
       currentModeId: params.modeId
     }).catch((error) => {
-      debugLogger4.debug("mode-update extNotification failed", error);
+      debugLogger5.debug("mode-update extNotification failed", error);
     });
   }
   /**
@@ -3198,7 +3606,7 @@ ${this.pendingWorktreeNotice}
       sessionId: this.sessionId,
       currentModelId: effectiveModelId
     }).catch((error) => {
-      debugLogger4.debug("model-update extNotification failed", error);
+      debugLogger5.debug("model-update extNotification failed", error);
     });
     if (options.persistDefault ?? true) {
       const persistScope = getPersistScopeForModelSelection(this.settings);
@@ -3251,7 +3659,7 @@ ${this.pendingWorktreeNotice}
       currentModeId: newModeId,
       legacyFrameSent: true
     }).catch((error) => {
-      debugLogger4.debug("mode-update extNotification failed", error);
+      debugLogger5.debug("mode-update extNotification failed", error);
     });
   }
   /**
@@ -3264,16 +3672,50 @@ ${this.pendingWorktreeNotice}
    * sequential batch to preserve the implicit ordering the model may rely
    * on. Response-part ordering matches the original `functionCalls` order.
    */
-  async runToolCalls(abortSignal, promptId, functionCalls) {
+  async runToolCalls(abortSignal, promptId, functionCalls, toolLoopState) {
+    if (recordDaemonToolCalls(
+      this.config,
+      promptId,
+      toolLoopState,
+      functionCalls.length
+    )) {
+      return {
+        parts: [],
+        stopAfterPermissionCancel: false,
+        loopDetected: true
+      };
+    }
     const dedupedFunctionCalls = dedupeToolCallsById(functionCalls);
     const batches = [];
     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;
+      debugLogger5.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})`
+      debugLogger5.debug(
+        `[Session.runToolCalls] Suppressing duplicate provider tool-call id: ${providerCallId} (tool: ${request.name})`
       );
       batches.push({ kind: "duplicate", request, response });
     }, "pushDuplicateBatch");
@@ -3373,7 +3815,7 @@ ${this.pendingWorktreeNotice}
         });
         await this.toolCallEmitter.emitError(callId, toolName, error);
       } catch (recordError) {
-        debugLogger4.error("Failed to record skipped tool call:", recordError);
+        debugLogger5.error("Failed to record skipped tool call:", recordError);
       }
       return part;
     }, "recordSkippedToolCall");
@@ -3403,7 +3845,8 @@ ${this.pendingWorktreeNotice}
           runAbortSignal,
           promptId,
           calls[idx],
-          onStopAfterPermissionCancel
+          onStopAfterPermissionCancel,
+          toolLoopState
         ).then((r) => {
           results[idx] = r;
         }).finally(() => {
@@ -3453,26 +3896,60 @@ ${this.pendingWorktreeNotice}
           abortSignal.removeEventListener("abort", propagateAbort);
         }
         let shouldStop = false;
+        let shouldStopForLoop = false;
         for (const r of results) {
           parts.push(...r.parts);
           shouldStop ||= r.stopAfterPermissionCancel;
+          shouldStopForLoop ||= r.loopDetected === true;
+        }
+        if (shouldStopForLoop) {
+          return {
+            parts,
+            stopAfterPermissionCancel: false,
+            loopDetected: true
+          };
         }
         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) {
-          const r = await this.runTool(abortSignal, promptId, fc);
+          const r = await this.runTool(
+            abortSignal,
+            promptId,
+            fc,
+            void 0,
+            toolLoopState
+          );
           parts.push(...r.parts);
+          if (r.loopDetected) {
+            return {
+              parts,
+              stopAfterPermissionCancel: false,
+              loopDetected: true
+            };
+          }
           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
@@ -3504,7 +3981,7 @@ ${this.pendingWorktreeNotice}
     }
     return reminders;
   }
-  async runTool(abortSignal, promptId, fc, onStopAfterPermissionCancel) {
+  async runTool(abortSignal, promptId, fc, onStopAfterPermissionCancel, toolLoopState) {
     const callId = fc.id ?? `${fc.name}-${Date.now()}`;
     let args = fc.args ?? {};
     const startTime = Date.now();
@@ -3616,8 +4093,10 @@ ${this.pendingWorktreeNotice}
         }
         const toolUseId = generateToolUseId();
         const approvalMode = this.config.getApprovalMode();
+        let toolBuildSucceeded = false;
         try {
           const invocation = tool.build(args);
+          toolBuildSucceeded = true;
           const taskEventEmitter = invocation.eventEmitter;
           if (isAgentTool && taskEventEmitter) {
             const parentToolCallId = callId;
@@ -3660,7 +4139,7 @@ ${this.pendingWorktreeNotice}
             forceAutoReviewForAllow
           );
           if (finalPermission === "allow" && forceAutoReviewForAllow) {
-            debugLogger4.info(
+            debugLogger5.info(
               `Auto mode: L4 allow overridden by protected-write guard for ${toolName}`
             );
           }
@@ -3703,7 +4182,7 @@ ${this.pendingWorktreeNotice}
                 autoModeAllowed = true;
                 break;
               case "blocked":
-                debugLogger4.warn(
+                debugLogger5.warn(
                   `Auto mode blocked (${outcome.reason}): tool=${toolName}, ` + formatDenialStateLog(denialState)
                 );
                 return earlyErrorResponse(
@@ -3715,7 +4194,7 @@ ${this.pendingWorktreeNotice}
                   outcome.reason
                 );
                 if (wasAutoModeDenialFallback) {
-                  debugLogger4.warn(
+                  debugLogger5.warn(
                     `Auto mode fallback to manual approval (${outcome.reason}): ` + formatDenialStateLog(denialState)
                   );
                 }
@@ -3733,12 +4212,12 @@ ${this.pendingWorktreeNotice}
               const before = this.config.getAutoModeDenialState();
               const after = recordFallbackApprove(before);
               if (after === before) {
-                debugLogger4.warn(
+                debugLogger5.warn(
                   `Auto mode denial counters already clear after fallback approval: ` + formatDenialStateLog(before)
                 );
                 return;
               }
-              debugLogger4.warn(
+              debugLogger5.warn(
                 `Auto mode denial counters reset after fallback approval: ${formatDenialStateLog(before)} -> ${formatDenialStateLog(after)}`
               );
               this.config.setAutoModeDenialState(after);
@@ -3844,7 +4323,7 @@ ${this.pendingWorktreeNotice}
                 );
                 outcome = output.outcome.outcome === "cancelled" ? "cancel" /* Cancel */ : external_exports.nativeEnum(ToolConfirmationOutcome).parse(output.outcome.optionId);
               } catch (error) {
-                debugLogger4.error(
+                debugLogger5.error(
                   `Permission request failed for tool ${toolName}:`,
                   error
                 );
@@ -3853,7 +4332,7 @@ ${this.pendingWorktreeNotice}
                     "cancel" /* Cancel */
                   );
                 } catch (confirmError) {
-                  debugLogger4.error(
+                  debugLogger5.error(
                     `Failed to cancel tool ${toolName} after permission request failure:`,
                     confirmError
                   );
@@ -3878,7 +4357,7 @@ ${this.pendingWorktreeNotice}
                 if (outcome !== "cancel" /* Cancel */) {
                   throw error;
                 }
-                debugLogger4.error(
+                debugLogger5.error(
                   `Failed to confirm cancellation for tool ${toolName}:`,
                   error
                 );
@@ -3943,12 +4422,12 @@ ${this.pendingWorktreeNotice}
             if (!preHookResult.shouldProceed) {
               const blockReason = preHookResult.blockReason || "Blocked by PreToolUse hook";
               await this.messageEmitter.emitAgentMessage(
-                `\u{1F6AB} **PreToolUse blocked**: ${toolName} - ${blockReason}`
+                `\u2717 **PreToolUse blocked**: ${toolName} - ${blockReason}`
               );
               return earlyErrorResponse(new Error(blockReason), toolName);
             }
             if (preHookResult.additionalContext) {
-              debugLogger4.debug(
+              debugLogger5.debug(
                 `PreToolUse hook additional context for ${toolName}: ${preHookResult.additionalContext}`
               );
             }
@@ -4011,7 +4490,7 @@ ${this.pendingWorktreeNotice}
             );
             if (postHookResult.shouldStop) {
               const stopMessage = postHookResult.stopReason || "Execution stopped by PostToolUse hook";
-              debugLogger4.info(
+              debugLogger5.info(
                 `PostToolUse hook requested stop for ${toolName}: ${stopMessage}`
               );
               return earlyErrorResponse(new Error(stopMessage), toolName);
@@ -4034,7 +4513,7 @@ ${this.pendingWorktreeNotice}
               callId
             );
             if (failureHookResult.additionalContext) {
-              debugLogger4.debug(
+              debugLogger5.debug(
                 `PostToolUseFailure hook additional context for ${toolName}: ${failureHookResult.additionalContext}`
               );
             }
@@ -4110,7 +4589,7 @@ ${this.pendingWorktreeNotice}
               callId
             );
             if (failureHookResult.additionalContext) {
-              debugLogger4.debug(
+              debugLogger5.debug(
                 `PostToolUseFailure hook additional context for ${toolName}: ${failureHookResult.additionalContext}`
               );
             }
@@ -4134,9 +4613,17 @@ ${this.pendingWorktreeNotice}
             error,
             errorType: void 0
           });
+          const loopDetected = !activeToolAbortSignal.aborted && !toolBuildSucceeded && recordDaemonInvalidToolParams(
+            this.config,
+            promptId,
+            toolLoopState,
+            toolName,
+            error
+          );
           return {
             parts: errorResponse(error),
-            stopAfterPermissionCancel: nestedPermissionCancelled
+            stopAfterPermissionCancel: nestedPermissionCancelled,
+            loopDetected
           };
         }
       });
@@ -4245,9 +4732,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 +4770,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 +4804,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 +4814,7 @@ ${this.pendingWorktreeNotice}
       }
     } else {
       processedQueryParts.push({ text: initialQueryText.trim() });
+      processedQueryParts.push(...extensionParts);
     }
     for (const contextPart of embeddedContext) {
       if ("text" in contextPart && contextPart.text) {
@@ -4338,9 +4836,36 @@ ${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);
+      debugLogger5.warn(msg);
     }
   }
   /**
@@ -4360,7 +4885,7 @@ ${contextPart.text}`
         }
       );
     }).catch((err) => {
-      debugLogger4.debug(
+      debugLogger5.debug(
         `ACP terminalSequence notification dropped (session=${this.sessionId}): ${err instanceof Error ? err.message : String(err)}`
       );
     });
@@ -4471,7 +4996,7 @@ function runWithAcpRuntimeOutputDir(settings, cwd, fn) {
 __name(runWithAcpRuntimeOutputDir, "runWithAcpRuntimeOutputDir");
 
 // packages/cli/src/acp-integration/acpAgent.ts
-var debugLogger5 = createDebugLogger("ACP_AGENT");
+var debugLogger6 = createDebugLogger("ACP_AGENT");
 var BTW_CHILD_TIMEOUT_MS = 55e3;
 function collapseForkDirective(directive, maxLength) {
   const oneLine = directive.replace(/\s+/g, " ").trim();
@@ -4527,6 +5052,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 +5064,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 +5085,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 +5120,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(path3.sep) || !/^[a-zA-Z0-9._-]+$/.test(slug)) {
     throw RequestError.invalidParams(void 0, "Invalid skill.slug");
   }
 }
@@ -5052,7 +5589,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 ? path3.posix.join(relativeRoot, name) : name;
     if (type === "dir") {
       files.push(
         ...await downloadGitHubSkillDirectoryFromApi(
@@ -5099,7 +5636,7 @@ async function downloadGitHubSkillDirectory(githubUrl, directoryPath) {
     githubUrl,
     directoryPath
   ).catch((error) => {
-    debugLogger5.warn(
+    debugLogger6.warn(
       "GitHub API directory listing failed, falling back to archive download:",
       error
     );
@@ -5112,10 +5649,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 || path3.posix.basename(githubUrl.filePath) !== "SKILL.md") {
     return downloadSingleSkillFile(sourceUrl);
   }
-  const skillDirectory = path.posix.dirname(githubUrl.filePath);
+  const skillDirectory = path3.posix.dirname(githubUrl.filePath);
   const files = await downloadGitHubSkillDirectory(githubUrl, skillDirectory);
   const skillFile = files.find((file) => file.relativePath === "SKILL.md");
   if (!skillFile) {
@@ -5131,9 +5668,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 = path3.resolve(skillDir);
+  const target = path3.resolve(skillDir, relativePath);
+  if (target !== root && !target.startsWith(root + path3.sep)) {
     throw RequestError.invalidParams(
       void 0,
       `Invalid skill file path: ${relativePath}`
@@ -5143,9 +5680,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 = path3.resolve(skillsBaseDir);
+  const skillDir = path3.resolve(skillsBaseDir, slug);
+  if (!skillDir.startsWith(root + path3.sep)) {
     throw RequestError.invalidParams(void 0, "Invalid skill.slug");
   }
   return skillDir;
@@ -5701,7 +6238,7 @@ function readMcpServers(source, scope) {
       const server = toMcpServerConfig(value);
       return server ? { name, scope, server: redactMcpServerSecrets(server) } : void 0;
     } catch (error) {
-      debugLogger5.warn(
+      debugLogger6.warn(
         `Skipping malformed MCP server config [${scope}:${name}]:`,
         error
       );
@@ -5797,7 +6334,7 @@ function readHooks(source, scope, extensionName) {
           extensionName
         });
       } catch (error) {
-        debugLogger5.warn(
+        debugLogger6.warn(
           `Skipping malformed hook entry [${scope}:${event}:${index}]:`,
           error
         );
@@ -5822,14 +6359,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 = path3.join(dir, filename);
     try {
       await fs.access(filePath);
       return filePath;
     } catch {
     }
   }
-  return path.join(dir, fallbackFilename);
+  return path3.join(dir, fallbackFilename);
 }
 __name(resolvePreferredMemoryFile, "resolvePreferredMemoryFile");
 async function resolveQwenMemoryPaths(params) {
@@ -5850,13 +6387,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 +6427,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);
@@ -5874,7 +6436,7 @@ async function runAcpAgent(config, settings, argv) {
     try {
       await agentInstance.shutdownMcpPool(8e3);
     } catch (err) {
-      debugLogger5.error(`[ACP] MCP pool drain (${label}) error:`, err);
+      debugLogger6.error(`[ACP] MCP pool drain (${label}) error:`, err);
     }
   }, "drainPoolBeforeExit");
   let shuttingDown = false;
@@ -5901,7 +6463,7 @@ async function runAcpAgent(config, settings, argv) {
       try {
         await hookSystem.fireSessionEndEvent(reason);
       } catch (err) {
-        debugLogger5.warn(
+        debugLogger6.warn(
           `SessionEnd hook failed: ${err instanceof Error ? err.message : String(err)}`
         );
       }
@@ -5910,7 +6472,7 @@ async function runAcpAgent(config, settings, argv) {
   const shutdownHandler = /* @__PURE__ */ __name(async () => {
     if (shuttingDown) return;
     shuttingDown = true;
-    debugLogger5.debug("[ACP] Shutdown signal received, closing streams");
+    debugLogger6.debug("[ACP] Shutdown signal received, closing streams");
     await fireSessionEndOnce("other" /* Other */);
     agentInstance?.disposeSessions();
     try {
@@ -5923,7 +6485,7 @@ async function runAcpAgent(config, settings, argv) {
     }
     await drainPoolBeforeExit("signal");
     runExitCleanup().catch((err) => {
-      debugLogger5.error("[ACP] Cleanup error:", err);
+      debugLogger6.error("[ACP] Cleanup error:", err);
     }).finally(() => {
       process.exit(0);
     });
@@ -6110,12 +6672,12 @@ var QwenAgent = class {
     try {
       const result = await this.mcpPool.drainAll({ force: true, timeoutMs });
       if (result.forced > 0 || result.errors.length > 0) {
-        debugLogger5.warn(
+        debugLogger6.warn(
           `MCP pool drain: ${result.drained} clean, ${result.forced} timed out, ${result.errors.length} errors`
         );
       }
     } catch (err) {
-      debugLogger5.error(
+      debugLogger6.error(
         `MCP pool drainAll failed: ${err instanceof Error ? err.message : String(err)}`
       );
     }
@@ -6129,14 +6691,14 @@ var QwenAgent = class {
     try {
       await session.cancelPendingPrompt();
     } catch (err) {
-      debugLogger5.debug(
+      debugLogger6.debug(
         `Session ${sessionId} cancel during close failed: ${err instanceof Error ? err.message : String(err)}`
       );
     }
     try {
       await session.getConfig().getToolRegistry()?.stop();
     } catch (err) {
-      debugLogger5.debug(
+      debugLogger6.debug(
         `Session ${sessionId} tool registry stop during close failed: ${err instanceof Error ? err.message : String(err)}`
       );
     }
@@ -6170,7 +6732,7 @@ var QwenAgent = class {
         scope: "workspace",
         ...event
       }).catch((err) => {
-        debugLogger5.debug(
+        debugLogger6.debug(
           `MCP workspace budget event delivery to session ${sid} failed (kind=${event.kind}): ${err instanceof Error ? err.message : String(err)}`
         );
       });
@@ -6179,7 +6741,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.20260701.a974594d7";
     return {
       protocolVersion: PROTOCOL_VERSION,
       agentInfo: {
@@ -6335,7 +6897,7 @@ var QwenAgent = class {
         session.pendingWorktreeNotice = restored.contextMessage;
       }
     } catch (error) {
-      debugLogger5.warn(`ACP worktree restore failed: ${error}`);
+      debugLogger6.warn(`ACP worktree restore failed: ${error}`);
     }
   }
   async unstable_listSessions(params) {
@@ -6456,7 +7018,7 @@ var QwenAgent = class {
       await extensionManager.refreshCache();
       extensions = extensionManager.getLoadedExtensions();
     } catch (error) {
-      debugLogger5.warn(
+      debugLogger6.warn(
         "Extension loading failed, continuing without extensions:",
         error
       );
@@ -6582,7 +7144,7 @@ var QwenAgent = class {
             pm.addPersistentRule(rule, ruleType);
           }
         } catch (error) {
-          debugLogger5.warn(
+          debugLogger6.warn(
             `Failed to sync permission rules to a live session: ${error instanceof Error ? error.message : String(error)}`
           );
         }
@@ -6774,6 +7336,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 +7452,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 +7654,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 +8148,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 +8185,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 +8374,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 +8421,9 @@ var QwenAgent = class {
       );
     }
     const download = await downloadSkill(request.sourceUrl);
-    const skillsBaseDir = path.join(Storage.getGlobalQwenDir(), "skills");
+    const skillsBaseDir = path3.join(Storage.getGlobalQwenDir(), "skills");
     const skillDir = resolveManagedSkillDir(skillsBaseDir, request.slug);
-    const skillFile = path.join(skillDir, "SKILL.md");
+    const skillFile = path3.join(skillDir, "SKILL.md");
     const parsed = skillManager.parseSkillContent(
       download.skillContent,
       skillFile,
@@ -7749,7 +8443,7 @@ var QwenAgent = class {
           stagingDir,
           file.relativePath
         );
-        await fs.mkdir(path.dirname(targetPath), { recursive: true });
+        await fs.mkdir(path3.dirname(targetPath), { recursive: true });
         await fs.writeFile(targetPath, file.content);
       }
       await fs.rm(skillDir, { recursive: true, force: true });
@@ -7788,11 +8482,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 = path3.resolve(skillDir);
+    const resolvedSkillFile = path3.resolve(skillFile);
+    const globalDir = path3.resolve(Storage.getGlobalQwenDir());
+    const isDedicatedSkillDir = resolvedSkillFile === path3.join(resolvedSkillDir, "SKILL.md");
+    if (!isDedicatedSkillDir || resolvedSkillDir === path3.parse(resolvedSkillDir).root || resolvedSkillDir === globalDir) {
       throw RequestError.invalidParams(
         void 0,
         `Refusing to delete unexpected skill directory: ${skillDir}`
@@ -7808,10 +8502,10 @@ var QwenAgent = class {
   async readManagedSkillFile(slug, scope, skillManager, cwd) {
     if (scope === "global") {
       const qwenSkillDir = resolveManagedSkillDir(
-        path.join(Storage.getGlobalQwenDir(), "skills"),
+        path3.join(Storage.getGlobalQwenDir(), "skills"),
         slug
       );
-      const qwenSkillFile = path.join(qwenSkillDir, "SKILL.md");
+      const qwenSkillFile = path3.join(qwenSkillDir, "SKILL.md");
       const qwenContent = await fs.readFile(qwenSkillFile, "utf8").catch(() => void 0);
       if (qwenContent !== void 0) {
         return {
@@ -7847,15 +8541,15 @@ var QwenAgent = class {
       );
     });
     return {
-      skillDir: path.dirname(skillFile),
+      skillDir: path3.dirname(skillFile),
       skillFile,
       content
     };
   }
   async findProjectSkillFileFromCwd(slug, cwd, skillManager) {
-    const projectRoot = path.resolve(cwd);
+    const projectRoot = path3.resolve(cwd);
     for (const configDir of PROJECT_SKILL_DIRS) {
-      const baseDir = path.join(projectRoot, configDir, SKILLS_DIR);
+      const baseDir = path3.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 +8561,7 @@ var QwenAgent = class {
         );
       });
       return {
-        skillDir: path.dirname(skillFile),
+        skillDir: path3.dirname(skillFile),
         skillFile,
         content
       };
@@ -7898,7 +8592,7 @@ var QwenAgent = class {
     }
     const nextContent = setSkillFrontmatterEnabled(content, request.enabled);
     skillManager.parseSkillContent(nextContent, skillFile, level);
-    if (path.basename(skillFile) !== "SKILL.md") {
+    if (path3.basename(skillFile) !== "SKILL.md") {
       throw RequestError.invalidParams(
         void 0,
         `Refusing to write to unexpected skill file: ${skillFile}`
@@ -7948,19 +8642,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 +8726,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
@@ -8314,23 +9027,34 @@ var QwenAgent = class {
         }
         if (action === "enable") {
           const settings = loadSettings(this.config.getTargetDir());
+          let settingsChanged = false;
           for (const scope of ["User" /* User */, "Workspace" /* Workspace */]) {
             const scopeSettings = settings.forScope(scope).settings;
             const currentExcluded2 = scopeSettings.mcp?.excluded || [];
-            if (currentExcluded2.includes(serverName)) {
-              settings.setValue(
-                scope,
-                "mcp.excluded",
-                currentExcluded2.filter((name) => name !== serverName)
-              );
+            const filtered = currentExcluded2.filter(
+              (pattern) => pattern !== serverName
+            );
+            if (filtered.length !== currentExcluded2.length) {
+              settings.setValue(scope, "mcp.excluded", filtered);
+              settingsChanged = true;
             }
           }
           const currentExcluded = this.config.getExcludedMcpServers() || [];
-          this.config.setExcludedMcpServers(
-            currentExcluded.filter((name) => name !== serverName)
+          const runtimeFiltered = currentExcluded.filter(
+            (pattern) => pattern !== serverName
           );
+          let runtimeChanged = false;
+          if (runtimeFiltered.length !== currentExcluded.length) {
+            this.config.setExcludedMcpServers(runtimeFiltered);
+            runtimeChanged = true;
+          }
           await toolRegistry.discoverToolsForServer(serverName);
-          return { serverName, action, ok: true, changed: true };
+          return {
+            serverName,
+            action,
+            ok: true,
+            changed: settingsChanged || runtimeChanged
+          };
         }
         if (action === "disable") {
           const settings = loadSettings(this.config.getTargetDir());
@@ -8352,18 +9076,27 @@ var QwenAgent = class {
           }
           const scopeSettings = settings.forScope(targetScope).settings;
           const currentExcluded = scopeSettings.mcp?.excluded || [];
-          if (!currentExcluded.includes(serverName)) {
+          let settingsChanged = false;
+          if (!matchesAnyServerPattern(serverName, currentExcluded)) {
             settings.setValue(targetScope, "mcp.excluded", [
               ...currentExcluded,
               serverName
             ]);
+            settingsChanged = true;
           }
           const runtimeExcluded = this.config.getExcludedMcpServers() || [];
-          if (!runtimeExcluded.includes(serverName)) {
+          let runtimeChanged = false;
+          if (!matchesAnyServerPattern(serverName, runtimeExcluded)) {
             this.config.setExcludedMcpServers([...runtimeExcluded, serverName]);
+            runtimeChanged = true;
           }
           await toolRegistry.disableMcpServer(serverName);
-          return { serverName, action, ok: true, changed: true };
+          return {
+            serverName,
+            action,
+            ok: true,
+            changed: settingsChanged || runtimeChanged
+          };
         }
         if (action === "clear-auth") {
           const tokenStorage = new MCPOAuthTokenStorage();
@@ -8481,6 +9214,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 || !path3.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"];
@@ -8536,7 +9341,7 @@ var QwenAgent = class {
         try {
           await setLanguageAsync(language);
         } catch (err) {
-          debugLogger5.warn("setLanguageAsync failed:", err);
+          debugLogger6.warn("setLanguageAsync failed:", err);
           throw new RequestError(
             -32603,
             `Failed to switch UI language: ${err instanceof Error ? err.message : String(err)}`
@@ -8550,7 +9355,7 @@ var QwenAgent = class {
             language
           );
         } catch (err) {
-          debugLogger5.warn("Failed to persist UI language setting:", err);
+          debugLogger6.warn("Failed to persist UI language setting:", err);
         }
         let outputLanguage = null;
         let refreshed = false;
@@ -8565,7 +9370,7 @@ var QwenAgent = class {
             );
             fileWriteOk = true;
           } catch (err) {
-            debugLogger5.warn("Failed to write output-language.md:", err);
+            debugLogger6.warn("Failed to write output-language.md:", err);
           }
           if (fileWriteOk) {
             try {
@@ -8575,7 +9380,7 @@ var QwenAgent = class {
                 settingValue
               );
             } catch (err) {
-              debugLogger5.warn(
+              debugLogger6.warn(
                 "Failed to persist output language setting:",
                 err
               );
@@ -8595,7 +9400,7 @@ var QwenAgent = class {
                     writeOutputLanguageAndRegisterPath(settingValue, cfg);
                   }
                 } catch (err) {
-                  debugLogger5.warn(
+                  debugLogger6.warn(
                     `Failed to write output-language.md for session ${s.getId()} (path=${sessionPath ?? "global-default"}):`,
                     err
                   );
@@ -8608,7 +9413,7 @@ var QwenAgent = class {
               (r) => r.status === "rejected"
             ).length;
             if (failedCount > 0) {
-              debugLogger5.warn(
+              debugLogger6.warn(
                 `Language refresh failed for ${failedCount}/${results.length} session(s)`
               );
             }
@@ -8626,14 +9431,14 @@ var QwenAgent = class {
             "Invalid or missing sessionId"
           );
         }
-        debugLogger5.debug(`recap ext-method received for session=${sessionId}`);
+        debugLogger6.debug(`recap ext-method received for session=${sessionId}`);
         const session = this.sessionOrThrow(sessionId);
         const config = session.getConfig();
         const recap = await generateSessionRecap(
           config,
           new AbortController().signal
         );
-        debugLogger5.debug(
+        debugLogger6.debug(
           `recap ext-method completed for session=${sessionId} result=${recap ? `len=${recap.length}` : "null"}`
         );
         return { sessionId, recap };
@@ -8657,7 +9462,7 @@ var QwenAgent = class {
         const config = session.getConfig();
         const cacheSafeParams = buildBtwCacheSafeParams(config);
         if (!cacheSafeParams) {
-          debugLogger5.debug(`btw: no cacheSafeParams for session=${sessionId}`);
+          debugLogger6.debug(`btw: no cacheSafeParams for session=${sessionId}`);
           return { sessionId, answer: null };
         }
         const childSignal = AbortSignal.timeout(BTW_CHILD_TIMEOUT_MS);
@@ -8705,7 +9510,7 @@ var QwenAgent = class {
         try {
           hasHistory = (config.getGeminiClient().getHistoryShallow() ?? []).length > 0;
         } catch (error) {
-          debugLogger5.debug("Failed to read history before /fork:", error);
+          debugLogger6.debug("Failed to read history before /fork:", error);
         }
         if (!hasHistory) {
           throw RequestError.invalidParams(
@@ -8747,7 +9552,7 @@ var QwenAgent = class {
             ]
           });
         } catch (error) {
-          debugLogger5.debug("Failed to record fork event in history:", error);
+          debugLogger6.debug("Failed to record fork event in history:", error);
         }
         return { sessionId, description, launched: true };
       }
@@ -8810,7 +9615,7 @@ ${outputText}
             'taskKind must be "agent", "shell", or "monitor"'
           );
         }
-        debugLogger5.info(
+        debugLogger6.info(
           `sessionTaskCancel requested sessionId=${sessionId} taskId=${taskId} taskKind=${taskKind}`
         );
         const session = this.sessionOrThrow(sessionId);
@@ -8820,7 +9625,7 @@ ${outputText}
             const task = config.getBackgroundTaskRegistry().get(taskId);
             if (!task || task.status !== "running" && task.status !== "paused") {
               const reason = task ? "not_running" : "not_found";
-              debugLogger5.info(
+              debugLogger6.info(
                 `sessionTaskCancel skipped sessionId=${sessionId} taskId=${taskId} taskKind=${taskKind} reason=${reason} status=${task?.status ?? "missing"}`
               );
               return { cancelled: false, reason, status: task?.status };
@@ -8830,7 +9635,7 @@ ${outputText}
             } else {
               config.getBackgroundTaskRegistry().cancel(taskId);
             }
-            debugLogger5.info(
+            debugLogger6.info(
               `sessionTaskCancel completed sessionId=${sessionId} taskId=${taskId} taskKind=${taskKind} status=${task.status}`
             );
             return { cancelled: true, status: task.status };
@@ -8839,13 +9644,13 @@ ${outputText}
             const task = config.getBackgroundShellRegistry().get(taskId);
             if (!task || task.status !== "running") {
               const reason = task ? "not_running" : "not_found";
-              debugLogger5.info(
+              debugLogger6.info(
                 `sessionTaskCancel skipped sessionId=${sessionId} taskId=${taskId} taskKind=${taskKind} reason=${reason} status=${task?.status ?? "missing"}`
               );
               return { cancelled: false, reason, status: task?.status };
             }
             config.getBackgroundShellRegistry().requestCancel(taskId);
-            debugLogger5.info(
+            debugLogger6.info(
               `sessionTaskCancel completed sessionId=${sessionId} taskId=${taskId} taskKind=${taskKind} status=${task.status}`
             );
             return { cancelled: true, status: task.status };
@@ -8854,13 +9659,13 @@ ${outputText}
             const task = config.getMonitorRegistry().get(taskId);
             if (!task || task.status !== "running") {
               const reason = task ? "not_running" : "not_found";
-              debugLogger5.info(
+              debugLogger6.info(
                 `sessionTaskCancel skipped sessionId=${sessionId} taskId=${taskId} taskKind=${taskKind} reason=${reason} status=${task?.status ?? "missing"}`
               );
               return { cancelled: false, reason, status: task?.status };
             }
             config.getMonitorRegistry().cancel(taskId);
-            debugLogger5.info(
+            debugLogger6.info(
               `sessionTaskCancel completed sessionId=${sessionId} taskId=${taskId} taskKind=${taskKind} status=${task.status}`
             );
             return { cancelled: true, status: task.status };
@@ -8890,7 +9695,7 @@ ${outputText}
             durationMs: Date.now() - cleared.setAt
           });
         }
-        debugLogger5.info(
+        debugLogger6.info(
           `sessionGoalClear sessionId=${sessionId} cleared=${!!cleared} condition=${cleared?.condition ?? "(none)"}`
         );
         return {
@@ -8898,6 +9703,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();
+        debugLogger6.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 +9728,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 +9764,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) {
+                debugLogger6.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 +9829,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 +9852,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) {
+              debugLogger6.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: {
@@ -9018,7 +9878,7 @@ ${outputText}
         try {
           await extensionManager.refreshTools();
         } catch (err) {
-          debugLogger5.warn(
+          debugLogger6.warn(
             `Extension tool refresh failed for session ${sessionId}: ${err instanceof Error ? err.message : String(err)}`
           );
         }
@@ -9166,7 +10026,7 @@ ${outputText}
             filesFailed = fileResult.filesFailed;
           } catch (err) {
             const reason = err instanceof Error ? err.message : String(err);
-            debugLogger5.error(
+            debugLogger6.error(
               `[ACP] File-history rewind failed for session=${sessionId} promptId=${promptId}: ${reason}`
             );
             filesFailed = [`file-history-rewind: ${reason}`];
@@ -9224,7 +10084,7 @@ ${outputText}
           );
         } catch (error) {
           replayError = error instanceof Error ? error.message : String(error);
-          debugLogger5.warn(
+          debugLogger6.warn(
             "[loadUpdates] History replay failed for session %s (partial updates: %d):",
             sessionId,
             updates.length,
@@ -9576,11 +10436,15 @@ ${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(
+                debugLogger6.warn(
                   `reload: reloadModelProvidersConfig failed for session ${id}: ${err}`
                 );
               }
@@ -9590,15 +10454,15 @@ ${outputText}
               try {
                 await config.switchModel(authType, newModelName);
               } catch (err) {
-                debugLogger5.warn(
+                debugLogger6.warn(
                   `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) {
-                debugLogger5.warn(
+                debugLogger6.warn(
                   `reload: refreshAuth failed for session ${id}: ${err}`
                 );
               }
@@ -9613,7 +10477,7 @@ ${outputText}
                 try {
                   config.setApprovalMode(newMode);
                 } catch (err) {
-                  debugLogger5.warn(
+                  debugLogger6.warn(
                     `reload: setApprovalMode failed for session ${id}: ${err}`
                   );
                 }
@@ -9622,14 +10486,14 @@ ${outputText}
             try {
               await config.refreshHierarchicalMemory();
             } catch (err) {
-              debugLogger5.warn(
+              debugLogger6.warn(
                 `reload: refreshHierarchicalMemory failed for session ${id}: ${err}`
               );
             }
             try {
               await config.getGeminiClient()?.refreshSystemInstruction();
             } catch (err) {
-              debugLogger5.warn(
+              debugLogger6.warn(
                 `reload: refreshSystemInstruction failed for session ${id}: ${err}`
               );
             }
@@ -9639,7 +10503,7 @@ ${outputText}
         for (let i = 0; i < results.length; i++) {
           if (results[i].status === "rejected") {
             const reason = results[i].reason;
-            debugLogger5.warn(
+            debugLogger6.warn(
               `Session ${sessions[i][0]} reload failed: ${reason}`
             );
             skipped.push(sessions[i][0]);
@@ -9657,6 +10521,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 +10589,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 +10624,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);
     }
@@ -9754,13 +10645,20 @@ ${outputText}
           sessionId: sid,
           ...event
         }).catch((err) => {
-          debugLogger5.debug(
+          debugLogger6.debug(
             `MCP budget extNotification dropped (session=${sid}, kind=${event.kind}): ${err instanceof Error ? err.message : String(err)}`
           );
         });
       });
     }
-    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) {
@@ -9782,7 +10680,7 @@ ${outputText}
     try {
       await config.refreshAuth(selectedType, true);
     } catch (e) {
-      debugLogger5.error(`Authentication failed: ${e}`);
+      debugLogger6.error(`Authentication failed: ${e}`);
       throw RequestError.authRequired(
         {
           authMethods: pickAuthMethodsForAuthRequired(selectedType)
@@ -9797,7 +10695,20 @@ ${outputText}
       this.connection,
       config.getSessionId(),
       this.clientCapabilities.fs,
-      config.getFileSystemService()
+      config.getFileSystemService(),
+      {
+        // SYNC: Mirrors ReadFileTool's default allowed local roots, including
+        // auto-memory roots, so ACP-local read fallback follows the same policy.
+        localReadRoots: [
+          config.storage.getProjectTempDir(),
+          path3.join(config.storage.getProjectDir(), "subagents"),
+          Storage.getGlobalTempDir(),
+          getAutoMemoryRoot(config.getTargetDir()),
+          getUserAutoMemoryRoot(),
+          ...config.storage.getUserSkillsDirs(),
+          Storage.getUserExtensionsDir()
+        ]
+      }
     );
     config.setFileSystemService(acpFileSystemService);
   }
@@ -9822,6 +10733,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 +10746,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 +10782,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 +10828,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 +10846,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 = 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,
   fetchAllowedGitHub,
   normalizeCoreSettingValue,