@qwen-code/qwen-code 0.19.11 → 0.19.12-preview.0

package/chunks/{acpAgent-PTNBGJDN.js → acpAgent-JDVJXVBO.js}

@@ -1,58 +1,55 @@
 // Force strict mode and setup for ESM
 "use strict";
 import {
-  classifyApiError,
-  prefixMidTurnUserMessageParts
-} from "./chunk-YLSSEUAM.js";
+  recomputeMcpGating
+} from "./chunk-6WZZHJSZ.js";
+import {
+  classifyApiError
+} from "./chunk-675SVDMD.js";
 import {
   EXTENSION_CONTEXT_BUDGET,
   buildExtensionMentionContext,
   buildMcpServerContextText,
+  extractAtPathCommands,
   matchExtensionByRef,
   matchMcpServerByRef,
   parseExtensionRef,
   parseMcpServerRef
-} from "./chunk-HASK4LMI.js";
+} from "./chunk-IKLWU6YS.js";
 import {
   getAvailableCommands,
   handleSlashCommand,
   insertAfterFunctionResponses,
   isSlashCommand,
   normalizePartList
-} from "./chunk-THXDQSTA.js";
-import {
-  collectContextData,
-  formatContextUsageText
-} from "./chunk-FMNYGWOD.js";
-import {
-  recomputeMcpGating
-} from "./chunk-BYH2JRK3.js";
+} from "./chunk-IQRQVPGN.js";
 import {
   appEvents,
   buildDisabledSkillNamesProvider,
   loadCliConfig,
   normalizeDisabledToolList
-} from "./chunk-YGYSMY2R.js";
+} from "./chunk-PSISZNIT.js";
+import "./chunk-5DTTYNB7.js";
+import {
+  collectContextData,
+  formatContextUsageText
+} from "./chunk-Z4ZCVYJ5.js";
 import {
   getCommandSubcommandNames
-} from "./chunk-BYB3GF2T.js";
-import "./chunk-FYQ22K62.js";
+} from "./chunk-JCYMQU5F.js";
+import "./chunk-CHVH4DVN.js";
 import {
   getEffectiveSupportedModes
-} from "./chunk-NVTQZXR7.js";
+} from "./chunk-6QGZVKOO.js";
 import "./chunk-4WGODMVR.js";
 import "./chunk-KW7NOTN6.js";
-import "./chunk-OWT2CAEQ.js";
-import "./chunk-5DTTYNB7.js";
+import "./chunk-GEHSF7MS.js";
+import "./chunk-XAAEDML2.js";
+import "./chunk-NVUGS23Y.js";
 import "./chunk-NHDKSOEY.js";
-import {
-  isTerminalGoalStatusKind
-} from "./chunk-7X7TEQNX.js";
-import "./chunk-HTHUX2T5.js";
-import "./chunk-TL4R5TRK.js";
-import "./chunk-V2DXTLUE.js";
+import "./chunk-4W55BHOC.js";
+import "./chunk-Y5UDBQYF.js";
 import "./chunk-YAF2MQZ6.js";
-import "./chunk-Q6TUALBE.js";
 import {
   GENERATION_MAX_PROMPT_BYTES,
   GENERATION_TIMEOUT_MS,
@@ -71,34 +68,51 @@ import {
   shouldSuppressRememberErrorDetails,
   workspaceMemoryFailureCode,
   workspaceMemoryFailureDiagnostics
-} from "./chunk-QOTQH4CB.js";
+} from "./chunk-4AGBO6RB.js";
 import {
   HistoryReplayer,
   MessageEmitter,
   PlanEmitter,
-  ToolCallEmitter
-} from "./chunk-6Y6ORE2G.js";
-import "./chunk-CF5VJRGC.js";
-import "./chunk-SUARMD4Q.js";
+  ToolCallEmitter,
+  collectGoalStatusItemsFromRecords,
+  goalTerminalEventToHistoryItem,
+  recordGoalStatusItem,
+  restoreGoalFromHistory
+} from "./chunk-WACI4VES.js";
+import "./chunk-QSG4ZFG4.js";
+import "./chunk-7LMAKIWE.js";
+import "./chunk-J6NT5YTN.js";
 import "./chunk-QHTIBUWB.js";
+import {
+  isTerminalGoalStatusKind
+} from "./chunk-76BFY7AF.js";
+import "./chunk-HTHUX2T5.js";
 import "./chunk-L573Z2QZ.js";
 import {
   computeCpuPercent
 } from "./chunk-HGT6JR3U.js";
 import "./chunk-RXFQM6FQ.js";
-import "./chunk-Y3KFTWVX.js";
+import "./chunk-OZWJAFFE.js";
 import "./chunk-6H67XLET.js";
-import "./chunk-CITWNIXJ.js";
-import "./chunk-4HUDDSO5.js";
+import {
+  beginAcpBootstrapConfigProfiling,
+  buildAndFreezeAcpStartupProfile,
+  endAcpBootstrapConfigProfiling,
+  markAcpStartup
+} from "./chunk-TDKQP3M6.js";
+import "./chunk-LLIGYAQU.js";
 import "./chunk-LXXMOYPL.js";
-import "./chunk-S63Z5V42.js";
+import "./chunk-F2YCCUXI.js";
 import "./chunk-E5Z2AVNV.js";
 import {
-  formatAcpModelId,
+  ACP_ROUTE_ID_PREFIX,
+  buildAcpModelOptions,
+  getCurrentAcpModelId,
   parseAcpBaseModelId,
   parseAcpModelOption,
+  resolveAcpModelOption,
   sanitizeProviderBaseUrl
-} from "./chunk-ZIXOTAPZ.js";
+} from "./chunk-2DZ7E27L.js";
 import {
   mapSkillConfigToStatus
 } from "./chunk-2W3OOD4W.js";
@@ -108,44 +122,39 @@ import {
   buildPermissionSettings,
   normalizePermissionRules,
   readPermissionRuleSet
-} from "./chunk-K7VD4XLT.js";
+} from "./chunk-LHEQDKAR.js";
 import {
   MAX_AUDIO_BYTES,
   sanitizeVoiceErrorMessage,
   transcribeVoiceAudio
-} from "./chunk-BUAXJVNP.js";
+} from "./chunk-XACBIZJB.js";
 import {
   readVoiceModel
-} from "./chunk-3M75MSVA.js";
-import "./chunk-FSA7ERJ2.js";
+} from "./chunk-SMASS3CY.js";
+import "./chunk-F2RR4HO2.js";
 import {
   parseSessionSource
-} from "./chunk-574PTLMU.js";
+} from "./chunk-4OVECYBM.js";
+import "./chunk-6RLROE6G.js";
+import "./chunk-COH43MRJ.js";
 import {
+  CHANNEL_STARTUP_PROFILE_META_KEY,
+  CHANNEL_STARTUP_PROFILE_VERSION,
   CLIENT_MCP_OVER_WS_CONFIG_FLAG,
   LOAD_REPLAY_BULK_MODE,
   LOAD_REPLAY_META_KEY,
   LOAD_REPLAY_MODE_META_KEY,
+  LOAD_REPLAY_PAGE_SIZE_META_KEY,
   LOAD_REPLAY_VERSION,
-  MID_TURN_QUEUE_DRAIN_METHOD
-} from "./chunk-PZL23GTM.js";
-import "./chunk-6RLROE6G.js";
-import "./chunk-COH43MRJ.js";
-import {
-  NOT_CURRENTLY_GENERATING_CANCEL_MESSAGE
-} from "./chunk-L4Y55KIS.js";
-import "./chunk-7NMU22Q3.js";
-import "./chunk-YFVO2HOR.js";
-import "./chunk-57OAHC2Y.js";
-import "./chunk-5CNYZ7TN.js";
-import "./chunk-FNX3LGAK.js";
-import "./chunk-V6WHFGST.js";
-import {
-  createLoadedSettingsAdapter
-} from "./chunk-SQ5BK3GO.js";
+  MID_TURN_QUEUE_DRAIN_METHOD,
+  TODO_STOP_GUARD_QUEUE_RELEASE_METHOD
+} from "./chunk-QR6U5QPP.js";
 import {
   ndJsonStream
-} from "./chunk-3AYLDB6B.js";
+} from "./chunk-FEZXQXW2.js";
+import {
+  NOT_CURRENTLY_GENERATING_CANCEL_MESSAGE
+} from "./chunk-X6YQWCIJ.js";
 import {
   ACP_PREFLIGHT_KINDS,
   IDLE_HOOK_EVENTS,
@@ -153,14 +162,23 @@ import {
   SERVE_STATUS_EXT_METHODS,
   STATUS_SCHEMA_VERSION,
   mapDomainErrorToErrorKind
-} from "./chunk-VFX7EZIR.js";
+} from "./chunk-TFV3XVAZ.js";
+import "./chunk-HQ7MDVBO.js";
+import "./chunk-HZXU6YZW.js";
+import "./chunk-57OAHC2Y.js";
+import "./chunk-NJQPQ4IO.js";
+import "./chunk-E655RDRL.js";
+import "./chunk-V6WHFGST.js";
+import {
+  createLoadedSettingsAdapter
+} from "./chunk-DYUPBU7H.js";
 import "./chunk-W7FJ3N32.js";
-import "./chunk-KSZKSE23.js";
+import "./chunk-HVWPSGDY.js";
 import "./chunk-TJTKSVIV.js";
 import "./chunk-M5GB774H.js";
-import "./chunk-LXLTBIDP.js";
-import "./chunk-3DWIFU7L.js";
-import "./chunk-ZQIYGQCG.js";
+import "./chunk-HCCR43AY.js";
+import "./chunk-53UMEONK.js";
+import "./chunk-MHEZV3OY.js";
 import {
   AgentSideConnection,
   PROTOCOL_VERSION,
@@ -169,48 +187,47 @@ import {
 import {
   assembleMcpServers,
   loadMcpApprovals
-} from "./chunk-4ROQY23C.js";
+} from "./chunk-PTXVHS2O.js";
 import {
-  OUTPUT_LANGUAGE_AUTO,
   getOutputLanguageFilePath,
   getPersistScopeForModelSelection,
   getUserSettingsPath,
-  isAutoLanguage,
   loadSettings,
-  resolveOutputLanguage,
+  resolveOutputLanguageOrPreserveAuto,
   updateOutputLanguageFile,
   writeOutputLanguageAndRegisterPath
-} from "./chunk-GNBBAQ6J.js";
+} from "./chunk-ILQ42UG6.js";
 import "./chunk-RKUWKYED.js";
+import "./chunk-GOXKNSDZ.js";
+import {
+  getSystemDefaultsPath,
+  getSystemSettingsPath
+} from "./chunk-IDS7MSUP.js";
 import {
   SUPPORTED_LANGUAGES,
   getCurrentLanguage,
   setLanguageAsync
-} from "./chunk-4AGTGMCQ.js";
+} from "./chunk-3PE7OY2G.js";
 import {
   findEnvFiles,
   preResolveHomeEnvOverrides,
   reloadEnvironment
-} from "./chunk-JWICTOXS.js";
-import "./chunk-GOXKNSDZ.js";
-import {
-  getSystemDefaultsPath,
-  getSystemSettingsPath
-} from "./chunk-IDS7MSUP.js";
+} from "./chunk-NGTQA57Y.js";
 import "./chunk-QRUIS3DN.js";
+import "./chunk-W4DFAUAO.js";
+import "./chunk-VJNBRRZG.js";
 import {
   isFolderTrustEnabled,
   isWorkspaceTrusted,
   loadTrustedFolders
-} from "./chunk-2OG646IN.js";
+} from "./chunk-XFJU7SVP.js";
 import "./chunk-ALGGS7UH.js";
 import "./chunk-MR3PXB6E.js";
 import {
-  writeStderrLine
-} from "./chunk-YUZI3WAC.js";
+  writeStderrLine,
+  writeStderrLineSafe
+} from "./chunk-OWAK7LMW.js";
 import "./chunk-XFSFZCM5.js";
-import "./chunk-GLNHPRZT.js";
-import "./chunk-VJNBRRZG.js";
 import {
   ALL_PROVIDERS,
   APPROVAL_MODE_INFO,
@@ -233,7 +250,9 @@ import {
   SESSION_ARTIFACT_PERSISTENCE_VERSION,
   SESSION_TITLE_MAX_LENGTH,
   SESSION_TRANSCRIPT_MAX_LIMIT,
+  SESSION_TRANSCRIPT_MAX_PAGE_BYTES,
   SessionService,
+  SessionTranscriptPageTooLargeError,
   SessionTranscriptReader,
   SessionTranscriptSnapshotUnavailableError,
   SessionTranscriptTooLargeError,
@@ -275,6 +294,7 @@ import {
   generatePromptSuggestion,
   generateSessionRecap,
   generateToolUseId,
+  getActiveGoal,
   getArenaSystemReminder,
   getAutoModePermissionDeniedReason,
   getDefaultBaseUrlForProtocol,
@@ -321,35 +341,42 @@ import {
   subagentGenerator,
   unregisterGoalHook,
   updateSetting
-} from "./chunk-NJOFRXTM.js";
+} from "./chunk-6TDA4EVC.js";
+import "./chunk-5M6IDOMF.js";
 import "./chunk-T4TZQJ7W.js";
 import {
   external_exports
 } from "./chunk-H6XPXXMH.js";
-import "./chunk-5M6IDOMF.js";
-import "./chunk-A2HWMJVO.js";
-import "./chunk-RCEEXIOO.js";
-import "./chunk-KKRTYONM.js";
-import "./chunk-TV6K2FB4.js";
+import "./chunk-LKR7QQ63.js";
+import "./chunk-4XCVGEEX.js";
+import "./chunk-XSPFQQRE.js";
+import "./chunk-4RPARQ5D.js";
 import "./chunk-E2UVIFI2.js";
 import "./chunk-XU457J4V.js";
 import "./chunk-VDDGDZMA.js";
-import "./chunk-SPJQO2CE.js";
+import "./chunk-J2MKYJKZ.js";
 import "./chunk-SZRN75WQ.js";
 import "./chunk-HTO4JFDZ.js";
 import "./chunk-CPBF7KYF.js";
 import {
   APPROVAL_MODES,
-  FORK_SUBAGENT_TYPE
-} from "./chunk-F333XEAU.js";
+  FORK_SUBAGENT_TYPE,
+  runWithRuntimeContentGenerator
+} from "./chunk-UOA2IHRI.js";
 import "./chunk-6AM5D4ME.js";
-import "./chunk-2Z5UX4KI.js";
+import "./chunk-OSSDHJDU.js";
 import {
   HookEventName,
   createHookOutput
-} from "./chunk-ARKANCNX.js";
-import "./chunk-L5U3ELZX.js";
-import "./chunk-TYLOFD2U.js";
+} from "./chunk-SGPFJMRP.js";
+import "./chunk-335ECZTA.js";
+import "./chunk-JCJPZMJV.js";
+import {
+  clearCachedCredentialFile,
+  qwenOAuth2Events
+} from "./chunk-QGONRHUS.js";
+import "./chunk-7KS72E2N.js";
+import "./chunk-JESCGQM3.js";
 import {
   AuthType,
   ConversationFinishedEvent,
@@ -360,9 +387,12 @@ import {
   endToolExecutionSpan,
   endToolSpan,
   extractDaemonTraceContext,
+  formatFullTurnVisionNotice,
   formatVisionBridgeNotice,
   getAllGeminiMdFilenames,
+  getFullTurnVisionModelSelector,
   getMCPServerStatus,
+  getSpecificMimeType,
   hasImageParts,
   logConversationFinishedEvent,
   logLoopDetected,
@@ -372,6 +402,7 @@ import {
   normalizeParts,
   registerAcpEventLoopLagGauge,
   runInToolSpanContext,
+  runSideQuery,
   runVisionBridge,
   shouldRunVisionBridge,
   splitImageParts,
@@ -379,57 +410,49 @@ import {
   startToolExecutionSpan,
   startToolSpan,
   uiTelemetryService,
+  withDaemonSpan,
   withInteractionSpan
-} from "./chunk-MQOVXZAF.js";
+} from "./chunk-YN2I5I42.js";
 import "./chunk-4WKAA4KS.js";
 import "./chunk-CR3C7WXL.js";
-import {
-  runSideQuery
-} from "./chunk-RTV5TUYB.js";
 import "./chunk-VGC4I5JJ.js";
 import {
   getAutoMemoryRoot,
   getUserAutoMemoryRoot
-} from "./chunk-FBU7WRZI.js";
-import "./chunk-Y66VOBRP.js";
-import "./chunk-WTNZ6DXB.js";
+} from "./chunk-LPHGXXZX.js";
+import "./chunk-4CA4WUMS.js";
+import "./chunk-VAJS2E2D.js";
+import "./chunk-WEPXQKGP.js";
 import {
   ToolConfirmationOutcome,
   ToolNames,
   isShellProgressData
-} from "./chunk-JGUT3LWZ.js";
-import {
-  clearCachedCredentialFile,
-  qwenOAuth2Events
-} from "./chunk-OKAIGAYW.js";
-import "./chunk-ZPAHLFZU.js";
-import "./chunk-JESCGQM3.js";
-import "./chunk-WIEO4CWB.js";
+} from "./chunk-ANRANWVE.js";
 import "./chunk-XVNQMZ2I.js";
 import "./chunk-FEOZBUMT.js";
+import "./chunk-DJ2GSRLV.js";
+import "./chunk-4CHDYDG3.js";
 import {
   DEFAULT_TOKEN_LIMIT,
   getToolCallPreparations,
   tokenLimit
-} from "./chunk-VRR65QYW.js";
+} from "./chunk-V4PCIS25.js";
 import "./chunk-A4UCTEB5.js";
 import "./chunk-XWRJCPHC.js";
-import "./chunk-4LD5APFL.js";
+import "./chunk-TYQMGACW.js";
 import "./chunk-TYAMGABM.js";
 import "./chunk-FCMNKVXT.js";
-import "./chunk-DJ2GSRLV.js";
-import "./chunk-LQIDP6K5.js";
 import {
   Storage,
   createDebugLogger,
   getErrorMessage,
   getErrorStatus,
   isSubpath
-} from "./chunk-7NFB7LBQ.js";
-import "./chunk-QYG4BY6Q.js";
+} from "./chunk-UE5TZ55T.js";
+import "./chunk-ZPVGEMVC.js";
 import {
   runExitCleanup
-} from "./chunk-CAHY5ABC.js";
+} from "./chunk-DULSE2SH.js";
 import "./chunk-75DOP5OR.js";
 import "./chunk-DMTGGOSA.js";
 import "./chunk-YQ3U5MUC.js";
@@ -444,6 +467,7 @@ import {
 // packages/cli/src/acp-integration/acpAgent.ts
 init_esbuild_shims();
 import { randomUUID } from "node:crypto";
+import { performance } from "node:perf_hooks";
 
 // packages/cli/src/acp-integration/authMethods.ts
 init_esbuild_shims();
@@ -820,9 +844,35 @@ __name(isInactiveExtensionSkill, "isInactiveExtensionSkill");
 // packages/cli/src/acp-integration/session/Session.ts
 init_esbuild_shims();
 import { Buffer as Buffer2 } from "node:buffer";
+import { existsSync as existsSync2, statSync as statSync2 } from "node:fs";
 import * as os2 from "node:os";
 import * as path3 from "node:path";
 
+// packages/cli/src/utils/midTurnUserMessage.ts
+init_esbuild_shims();
+var MID_TURN_USER_MESSAGE_PREFIX = "\n[User message received during tool execution]: ";
+function prefixMidTurnUserMessageParts(parts, displayText) {
+  const partArray = normalizePartList(parts);
+  if (partArray.length === 0) {
+    return [{ text: `${MID_TURN_USER_MESSAGE_PREFIX}${displayText}` }];
+  }
+  const [firstPart, ...rest] = partArray;
+  if ("text" in firstPart && typeof firstPart.text === "string") {
+    return [
+      {
+        ...firstPart,
+        text: `${MID_TURN_USER_MESSAGE_PREFIX}${firstPart.text}`
+      },
+      ...rest
+    ];
+  }
+  return [
+    { text: `${MID_TURN_USER_MESSAGE_PREFIX}${displayText}` },
+    ...partArray
+  ];
+}
+__name(prefixMidTurnUserMessageParts, "prefixMidTurnUserMessageParts");
+
 // packages/cli/src/acp-integration/session/tool-call-preparation-tracker.ts
 init_esbuild_shims();
 var ToolCallPreparationTracker = class {
@@ -1601,11 +1651,196 @@ function loadRewriteConfig(settings) {
 }
 __name(loadRewriteConfig, "loadRewriteConfig");
 
+// packages/cli/src/acp-integration/session/daemon-todo-stop-guard.ts
+init_esbuild_shims();
+var TODO_STOP_GUARD_MAX_ATTEMPTS = 2;
+function parseStructuredTodos(value) {
+  if (typeof value !== "object" || value === null) return null;
+  const record = value;
+  if (record["type"] !== "todo_list" || !Array.isArray(record["todos"])) {
+    return null;
+  }
+  for (const item of record["todos"]) {
+    if (typeof item !== "object" || item === null) return null;
+    const todo = item;
+    if (typeof todo["id"] !== "string" || typeof todo["content"] !== "string" || todo["status"] !== "pending" && todo["status"] !== "in_progress" && todo["status"] !== "completed") {
+      return null;
+    }
+  }
+  return record["todos"];
+}
+__name(parseStructuredTodos, "parseStructuredTodos");
+var DaemonTodoStopGuard = class {
+  constructor(enabled) {
+    this.enabled = enabled;
+  }
+  static {
+    __name(this, "DaemonTodoStopGuard");
+  }
+  #armed = false;
+  #unfinishedCount = 0;
+  #attempts = 0;
+  #suspended = false;
+  #retryPaused = false;
+  #awaitingQueuedPrompt = false;
+  #exhaustionReported = false;
+  get hasTrustedUnfinishedState() {
+    return this.enabled && this.#armed && !this.#suspended && this.#unfinishedCount > 0;
+  }
+  get isHardSuspended() {
+    return this.enabled && this.#suspended;
+  }
+  get hasCommittedContinuation() {
+    return this.enabled && this.#attempts > 0;
+  }
+  get blocksUnrelatedAutomaticTurns() {
+    return this.enabled && this.#armed && !this.#suspended && this.#unfinishedCount > 0;
+  }
+  get needsStopInspection() {
+    return this.enabled && this.#armed && !this.#suspended && !this.#retryPaused && !this.#awaitingQueuedPrompt && this.#unfinishedCount > 0;
+  }
+  clearTrust() {
+    this.#armed = false;
+    this.#unfinishedCount = 0;
+    this.#attempts = 0;
+    this.#suspended = false;
+    this.#retryPaused = false;
+    this.#awaitingQueuedPrompt = false;
+    this.#exhaustionReported = false;
+  }
+  startOrdinaryPrompt() {
+    this.clearTrust();
+  }
+  resumeTrustedPrompt() {
+    this.#awaitingQueuedPrompt = false;
+    this.#retryPaused = false;
+  }
+  blockUntilOrdinaryPromptStarts() {
+    this.clearTrust();
+    this.#suspended = true;
+  }
+  acceptMidTurnUserInput() {
+    if (!this.enabled || this.#suspended) return;
+    if (!this.#armed && this.#attempts === 0) return;
+    this.#attempts = 0;
+    this.#retryPaused = false;
+    this.#awaitingQueuedPrompt = false;
+    this.#exhaustionReported = false;
+  }
+  observeTodoWrite(resultDisplay, allowArm) {
+    if (!this.enabled) return false;
+    const todos = parseStructuredTodos(resultDisplay);
+    if (todos === null) return false;
+    if (!allowArm) {
+      this.blockUntilOrdinaryPromptStarts();
+      return true;
+    }
+    this.#unfinishedCount = todos.filter(
+      (todo) => todo.status === "pending" || todo.status === "in_progress"
+    ).length;
+    this.#exhaustionReported = false;
+    if (this.#unfinishedCount === 0) {
+      this.#armed = false;
+      return true;
+    }
+    if (!this.#suspended) this.#armed = true;
+    return true;
+  }
+  suspend() {
+    if (!this.enabled) return;
+    this.#suspended = true;
+    this.#awaitingQueuedPrompt = false;
+  }
+  pauseForTrustedRetry() {
+    if (!this.#armed) return;
+    this.#retryPaused = true;
+    this.#awaitingQueuedPrompt = false;
+  }
+  awaitQueuedPrompt() {
+    if (!this.#armed && this.#attempts === 0 || this.#suspended) return false;
+    this.#awaitingQueuedPrompt = true;
+    return true;
+  }
+  decide(hasRelevantBackgroundInput) {
+    if (!this.needsStopInspection) return { kind: "inactive" };
+    if (hasRelevantBackgroundInput) return { kind: "deferred" };
+    if (this.#attempts >= TODO_STOP_GUARD_MAX_ATTEMPTS) {
+      return {
+        kind: "exhausted",
+        attempt: this.#attempts,
+        maxAttempts: TODO_STOP_GUARD_MAX_ATTEMPTS,
+        unfinishedCount: this.#unfinishedCount
+      };
+    }
+    return {
+      kind: "continue",
+      attempt: this.#attempts + 1,
+      maxAttempts: TODO_STOP_GUARD_MAX_ATTEMPTS,
+      unfinishedCount: this.#unfinishedCount
+    };
+  }
+  decideToolClosure(currentAttempt, hasRelevantBackgroundInput) {
+    if (this.#unfinishedCount > 0) {
+      return this.decide(hasRelevantBackgroundInput);
+    }
+    if (!this.enabled || this.#suspended || this.#retryPaused || this.#awaitingQueuedPrompt || this.#attempts !== currentAttempt) {
+      return { kind: "inactive" };
+    }
+    if (hasRelevantBackgroundInput) return { kind: "deferred" };
+    if (currentAttempt >= TODO_STOP_GUARD_MAX_ATTEMPTS) {
+      return { kind: "inactive" };
+    }
+    return {
+      kind: "continue",
+      attempt: currentAttempt + 1,
+      maxAttempts: TODO_STOP_GUARD_MAX_ATTEMPTS,
+      unfinishedCount: 0,
+      toolClosure: true
+    };
+  }
+  commitContinuation(attempt) {
+    const canCloseTools = this.enabled && this.#unfinishedCount === 0 && this.#attempts > 0 && !this.#suspended && !this.#retryPaused && !this.#awaitingQueuedPrompt;
+    if (!this.needsStopInspection && !canCloseTools || attempt !== this.#attempts + 1 || attempt > TODO_STOP_GUARD_MAX_ATTEMPTS) {
+      return false;
+    }
+    this.#attempts = attempt;
+    return true;
+  }
+  markExhaustionReported() {
+    if (this.#exhaustionReported) return false;
+    this.#exhaustionReported = true;
+    this.#suspended = true;
+    return true;
+  }
+};
+
 // packages/cli/src/acp-integration/session/Session.ts
 var debugLogger6 = 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";
+var TODO_STOP_GUARD_PROMPT_PREFIX = "[Todo Stop Guard] ";
+var TODO_STOP_GUARD_PROMPT_BODY_SUFFIX = " todo item(s) are still pending or in progress. Continue executing the current task now. Do not ask the user whether to continue. If progress requires user input, use the structured question or permission flow. If progress depends on external state, report the blocker explicitly.";
+var TODO_STOP_GUARD_FINAL_PROMPT_SUFFIX = " This is the final automatic continuation. Before ending, either complete/update the todos or report the completed progress and the exact blocker.";
+function isTodoStopGuardPromptText(text) {
+  if (typeof text !== "string") return false;
+  if (!text.startsWith(TODO_STOP_GUARD_PROMPT_PREFIX)) return false;
+  const remainder = text.slice(TODO_STOP_GUARD_PROMPT_PREFIX.length);
+  const separator = remainder.indexOf(" ");
+  if (separator <= 0) return false;
+  const countText = remainder.slice(0, separator);
+  const count = Number(countText);
+  if (!Number.isSafeInteger(count) || count <= 0 || String(count) !== countText) {
+    return false;
+  }
+  const body = `${countText}${TODO_STOP_GUARD_PROMPT_BODY_SUFFIX}`;
+  return remainder === body || remainder === body + TODO_STOP_GUARD_FINAL_PROMPT_SUFFIX;
+}
+__name(isTodoStopGuardPromptText, "isTodoStopGuardPromptText");
+function isCompressionFailureStatus(status) {
+  return status === 2 /* COMPRESSION_FAILED_INFLATED_TOKEN_COUNT */ || status === 3 /* COMPRESSION_FAILED_TOKEN_COUNT_ERROR */ || status === 4 /* COMPRESSION_FAILED_EMPTY_SUMMARY */ || status === 6 /* COMPRESSION_FAILED_OUTPUT_TRUNCATED */;
+}
+__name(isCompressionFailureStatus, "isCompressionFailureStatus");
 async function finalizeToolCallPreparations(tracker, includeResolved, streamName) {
   try {
     await tracker.discard(includeResolved);
@@ -1860,6 +2095,15 @@ var MidTurnDrainTimeoutError = class extends Error {
   }
 };
 var MAX_NOTIFICATION_QUEUE = 20;
+var MAX_DEFERRED_UNRELATED_CRON_QUEUE = 20;
+function isExistingFile(resolved, fileExists = existsSync2, statFile = statSync2) {
+  try {
+    return fileExists(resolved) && statFile(resolved).isFile();
+  } catch {
+    return false;
+  }
+}
+__name(isExistingFile, "isExistingFile");
 function resolveHomeLoopResolverRoots({
   homeQwenDir = Storage.getGlobalQwenDir(),
   homeDir = os2.homedir(),
@@ -2067,11 +2311,21 @@ var Session = class {
     this.settings = settings;
     this.sessionId = id;
     this.runtimeBaseDir = Storage.getRuntimeBaseDir();
+    const todoStopGuardEnabled = this.settings.merged.experimental?.todoStopGuard === true && !this.config.getBareMode() && !this.config.isSafeMode();
+    this.todoStopGuard = new DaemonTodoStopGuard(todoStopGuardEnabled);
+    this.todoStopGuardBackgroundBaseline = todoStopGuardEnabled ? this.#captureTodoStopGuardBackgroundBaseline() : {
+      agents: /* @__PURE__ */ new Set(),
+      shells: /* @__PURE__ */ new Set(),
+      monitors: /* @__PURE__ */ new Set(),
+      wakeups: /* @__PURE__ */ new Set()
+    };
     this.toolCallEmitter = new ToolCallEmitter(this);
     this.planEmitter = new PlanEmitter(this);
-    this.historyReplayer = new HistoryReplayer(this);
+    this.historyReplayer = new HistoryReplayer(this, {
+      supersedeUnrestorableGoal: true
+    });
     this.messageEmitter = new MessageEmitter(this);
-    this.#installGoalTerminalObserver();
+    this.installGoalTerminalObserver();
     this.#registerBackgroundNotificationCallbacks();
     this.#registerSubSessionSpawner();
   }
@@ -2133,6 +2387,10 @@ var Session = class {
   // batch so a transient stall can't silently lose them. See
   // `#drainMidTurnUserMessages`.
   midTurnRecoveredMessages = [];
+  todoStopGuard;
+  todoStopGuardBackgroundBaseline;
+  todoStopGuardQueuedPromptPriority = false;
+  todoStopGuardDrainAutomaticQueuesWhenIdle = false;
   // Background notification drain state. ACP does not have the TUI's idle
   // hook, so the session serializes registry callbacks through this queue.
   notificationQueue = [];
@@ -2169,6 +2427,169 @@ var Session = class {
   pendingWorktreeNotice = null;
   // Implement SessionContext interface
   sessionId;
+  #prepareTodoStopGuardForPrompt(params) {
+    if (!this.todoStopGuard.enabled) {
+      return {
+        startsWorkChain: false,
+        drainSupersededAutomaticQueues: false
+      };
+    }
+    const drainSupersededAutomaticQueues = this.todoStopGuard.blocksUnrelatedAutomaticTurns || this.todoStopGuard.hasCommittedContinuation || this.todoStopGuardQueuedPromptPriority;
+    if (this.config.getApprovalMode() === "plan" /* PLAN */) {
+      this.todoStopGuardQueuedPromptPriority = false;
+      this.todoStopGuard.blockUntilOrdinaryPromptStarts();
+      return {
+        startsWorkChain: false,
+        drainSupersededAutomaticQueues
+      };
+    }
+    const metadata = params._meta;
+    const isRetry = params.retry === true || metadata?.[DAEMON_RETRY_META_KEY] === true;
+    const isContinue = metadata?.[DAEMON_CONTINUE_META_KEY] === true;
+    if (isRetry || isContinue) {
+      this.todoStopGuardQueuedPromptPriority = false;
+      if (this.todoStopGuard.hasTrustedUnfinishedState) {
+        this.todoStopGuard.resumeTrustedPrompt();
+        return {
+          startsWorkChain: false,
+          drainSupersededAutomaticQueues: false
+        };
+      }
+      this.todoStopGuard.blockUntilOrdinaryPromptStarts();
+      return {
+        startsWorkChain: true,
+        drainSupersededAutomaticQueues
+      };
+    }
+    this.todoStopGuardQueuedPromptPriority = false;
+    this.todoStopGuard.blockUntilOrdinaryPromptStarts();
+    return {
+      startsWorkChain: true,
+      drainSupersededAutomaticQueues
+    };
+  }
+  #prepareTodoStopGuardForAutomaticTurn(continuesCurrentWorkChain) {
+    if (!this.todoStopGuard.enabled) return;
+    if (this.config.getApprovalMode() === "plan" /* PLAN */) {
+      this.todoStopGuard.blockUntilOrdinaryPromptStarts();
+      return;
+    }
+    if (continuesCurrentWorkChain && this.todoStopGuard.isHardSuspended) {
+      return;
+    }
+    if (continuesCurrentWorkChain && this.todoStopGuard.hasTrustedUnfinishedState) {
+      this.todoStopGuard.resumeTrustedPrompt();
+      return;
+    }
+    this.todoStopGuard.clearTrust();
+    this.todoStopGuardBackgroundBaseline = this.#captureTodoStopGuardBackgroundBaseline();
+  }
+  #clearTodoStopGuardTrustAndDrainAutomaticQueues() {
+    const preserveQueuedPromptPriority = this.todoStopGuardQueuedPromptPriority;
+    const shouldDrain = (this.todoStopGuard.blocksUnrelatedAutomaticTurns || this.todoStopGuard.hasCommittedContinuation) && !preserveQueuedPromptPriority;
+    this.todoStopGuard.blockUntilOrdinaryPromptStarts();
+    if (preserveQueuedPromptPriority || !shouldDrain) return;
+    if (this.pendingPrompt) {
+      this.todoStopGuardDrainAutomaticQueuesWhenIdle = true;
+      return;
+    }
+    void this.#drainCronQueue();
+    void this.#drainNotificationQueue();
+  }
+  releaseTodoStopGuardQueuedPromptWait() {
+    if (!this.todoStopGuardQueuedPromptPriority) return false;
+    this.todoStopGuardQueuedPromptPriority = false;
+    this.todoStopGuard.blockUntilOrdinaryPromptStarts();
+    if (this.pendingPrompt) {
+      this.todoStopGuardDrainAutomaticQueuesWhenIdle = true;
+      return true;
+    }
+    void this.#drainCronQueue();
+    void this.#drainNotificationQueue();
+    return true;
+  }
+  clearTodoStopGuardTrust() {
+    this.#clearTodoStopGuardTrustAndDrainAutomaticQueues();
+  }
+  #beginTodoStopGuardQueuedPromptCheck() {
+    this.todoStopGuardQueuedPromptPriority = this.todoStopGuard.awaitQueuedPrompt();
+  }
+  #finishTodoStopGuardQueuedPromptCheck(hasQueuedPrompt) {
+    const shouldWait = hasQueuedPrompt && this.todoStopGuardQueuedPromptPriority;
+    this.todoStopGuardQueuedPromptPriority = shouldWait;
+    if (!shouldWait) this.todoStopGuard.resumeTrustedPrompt();
+    return shouldWait;
+  }
+  #notificationContinuesTodoStopGuardWorkChain(item) {
+    const baseline = this.todoStopGuardBackgroundBaseline;
+    if (item.kind === "agent") return !baseline.agents.has(item.taskId);
+    if (item.kind === "shell") return !baseline.shells.has(item.taskId);
+    return !baseline.monitors.has(item.taskId);
+  }
+  #cronContinuesTodoStopGuardWorkChain(item) {
+    return item.source === "loop" && item.taskId !== void 0 && !this.todoStopGuardBackgroundBaseline.wakeups.has(item.taskId);
+  }
+  #captureTodoStopGuardBackgroundBaseline() {
+    const agents = this.config.getBackgroundTaskRegistry?.()?.getAll?.() ?? [];
+    const shells = this.config.getBackgroundShellRegistry?.()?.getAll?.() ?? [];
+    const monitors = this.config.getMonitorRegistry?.()?.getAll?.() ?? [];
+    const wakeups = this.config.isCronEnabled?.() ? (this.config.getCronScheduler?.()?.list?.() ?? []).filter(
+      (job) => job.cronExpr === "@wakeup"
+    ) : [];
+    return {
+      agents: /* @__PURE__ */ new Set([
+        ...agents.map((task) => task.id),
+        ...this.notificationQueue.filter((item) => item.kind === "agent").map((item) => item.taskId)
+      ]),
+      shells: /* @__PURE__ */ new Set([
+        ...shells.map((task) => task.id),
+        ...this.notificationQueue.filter((item) => item.kind === "shell").map((item) => item.taskId)
+      ]),
+      monitors: /* @__PURE__ */ new Set([
+        ...monitors.map((task) => task.id),
+        ...this.notificationQueue.filter((item) => item.kind === "monitor").map((item) => item.taskId)
+      ]),
+      wakeups: /* @__PURE__ */ new Set([
+        ...wakeups.map((job) => job.id),
+        ...this.cronQueue.flatMap(
+          (item) => item.source === "loop" && item.taskId ? [item.taskId] : []
+        )
+      ])
+    };
+  }
+  #hasRelevantTodoStopGuardBackgroundInput() {
+    if (this.notificationQueue.some(
+      (item) => this.#notificationContinuesTodoStopGuardWorkChain(item)
+    ) || this.cronQueue.some(
+      (item) => this.#cronContinuesTodoStopGuardWorkChain(item)
+    )) {
+      return true;
+    }
+    const baseline = this.todoStopGuardBackgroundBaseline;
+    const agents = this.config.getBackgroundTaskRegistry?.()?.getAll?.() ?? [];
+    if (agents.some(
+      (task) => !baseline.agents.has(task.id) && task.isBackgrounded && (task.status === "running" || task.status === "paused" || task.status === "cancelled" && !task.notified)
+    )) {
+      return true;
+    }
+    const shells = this.config.getBackgroundShellRegistry?.()?.getAll?.() ?? [];
+    if (shells.some(
+      (task) => !baseline.shells.has(task.id) && task.status === "running"
+    )) {
+      return true;
+    }
+    const monitors = this.config.getMonitorRegistry?.()?.getAll?.() ?? [];
+    if (monitors.some(
+      (task) => !baseline.monitors.has(task.id) && task.status === "running"
+    )) {
+      return true;
+    }
+    if (!this.config.isCronEnabled?.()) return false;
+    const wakeups = this.config.getCronScheduler?.()?.list?.() ?? [];
+    return wakeups.some(
+      (job) => job.cronExpr === "@wakeup" && !baseline.wakeups.has(job.id)
+    );
+  }
   /**
    * Wire the sub-session spawner to the daemon over the ACP `extMethod` request
    * channel. The `create_sub_session` tool (model-initiated) is its caller. ONLY
@@ -2236,6 +2657,9 @@ var Session = class {
   }
   dispose() {
     this.disposed = true;
+    this.todoStopGuardQueuedPromptPriority = false;
+    this.todoStopGuardDrainAutomaticQueuesWhenIdle = false;
+    this.todoStopGuard.clearTrust();
     this.notificationQueue = [];
     this.cronQueue = [];
     this.notificationAbortController?.abort();
@@ -2275,21 +2699,42 @@ var Session = class {
       );
     }
   }
-  #installGoalTerminalObserver() {
+  /**
+   * Installs (or replaces) this session's goal-terminal observer.
+   *
+   * Public because it does not stay installed: `registerGoalHook` and
+   * `unregisterGoalHook` both clear the observer table for the session, so any
+   * caller that (re-)registers a goal outside `#processSlashCommandResult` —
+   * notably goal restore on resume — has to put it back. Idempotent.
+   */
+  installGoalTerminalObserver() {
     setGoalTerminalObserver(this.sessionId, (event) => {
       void this.messageEmitter.emitGoalTerminal(event).catch((error) => {
         debugLogger6.warn(
           `Failed to emit goal terminal update: ${this.#formatError(error)}`
         );
       });
+      recordGoalStatusItem(this.config, goalTerminalEventToHistoryItem(event));
     });
   }
+  /**
+   * Emits a goal card and persists it to the transcript. Both `set` and
+   * `cleared` reach the client this way — from `#emitGoalStatusItems` for a
+   * `/goal` prompt, and from the `sessionGoalClear` ext method — so recording
+   * here (rather than at each call site) keeps the transcript in step with the
+   * hook. Replay goes through `messageEmitter.emitGoalStatus` directly and so
+   * does not re-record.
+   */
   emitGoalStatus(status) {
     void this.messageEmitter.emitGoalStatus(status).catch((error) => {
       debugLogger6.warn(
         `Failed to emit goal status update: ${this.#formatError(error)}`
       );
     });
+    recordGoalStatusItem(this.config, {
+      type: "goal_status" /* GOAL_STATUS */,
+      ...status
+    });
   }
   /**
    * Replays conversation history to the client using modular components.
@@ -2332,6 +2777,9 @@ var Session = class {
     }
     chat.truncateHistory(apiTruncateIndex);
     chat.stripThoughtsFromHistory();
+    const preserveQueuedPromptPriority = this.todoStopGuardQueuedPromptPriority;
+    const shouldDrainAutomaticQueues = (this.todoStopGuard.blocksUnrelatedAutomaticTurns || this.todoStopGuard.hasCommittedContinuation) && !preserveQueuedPromptPriority;
+    this.todoStopGuard.blockUntilOrdinaryPromptStarts();
     const rewindFiles = opts?.rewindFiles !== false;
     const fileHistoryService = this.config.getFileHistoryService();
     const survivingSnapshots = rewindFiles ? fileHistoryService.getSnapshots().slice(0, targetTurnIndex + 1) : void 0;
@@ -2343,6 +2791,10 @@ var Session = class {
       { truncatedCount: Math.max(0, apiHistory.length - apiTruncateIndex) },
       survivingSnapshots
     );
+    if (shouldDrainAutomaticQueues) {
+      void this.#drainCronQueue();
+      void this.#drainNotificationQueue();
+    }
     return { targetTurnIndex, apiTruncateIndex };
   }
   captureHistorySnapshot() {
@@ -2369,6 +2821,7 @@ var Session = class {
       );
     }
     this.config.getGeminiClient().getChat().setHistory(structuredClone(history));
+    this.#clearTodoStopGuardTrustAndDrainAutomaticQueues();
   }
   #computeApiTruncationIndexForUserTurn(apiHistory, targetTurnIndex) {
     const startIndex = getStartupContextLength(apiHistory, {
@@ -2397,6 +2850,11 @@ var Session = class {
     );
     if (hasFunctionResponse) return false;
     if (isSystemReminderContent(content)) return false;
+    if (content.parts.some(
+      (part) => "text" in part && isTodoStopGuardPromptText(part.text)
+    )) {
+      return false;
+    }
     return content.parts.some((part) => "text" in part && part.text);
   }
   async cancelPendingPrompt() {
@@ -2410,6 +2868,7 @@ var Session = class {
     if (!hadPrompt && !hadCron && !hadNotification) {
       throw new Error(NOT_CURRENTLY_GENERATING_CANCEL_MESSAGE);
     }
+    this.todoStopGuard.suspend();
     if (this.pendingPrompt) {
       this.pendingPrompt.abort(USER_CANCEL_ABORT_REASON);
       this.pendingPrompt = null;
@@ -2436,6 +2895,7 @@ var Session = class {
     }
   }
   async prompt(params) {
+    const todoStopGuardPreparation = this.#prepareTodoStopGuardForPrompt(params);
     this.pendingPrompt?.abort();
     const pendingSend = new AbortController();
     this.pendingPrompt = pendingSend;
@@ -2477,10 +2937,15 @@ var Session = class {
     if (pendingSend.signal.aborted) {
       return { stopReason: "cancelled" };
     }
+    if (todoStopGuardPreparation.startsWorkChain) {
+      this.todoStopGuardQueuedPromptPriority = false;
+      this.todoStopGuard.startOrdinaryPrompt();
+      this.todoStopGuardBackgroundBaseline = this.#captureTodoStopGuardBackgroundBaseline();
+    }
     this.duplicateProviderToolCallResponseIds.clear();
     let resolveCompletion;
-    this.pendingPromptCompletion = new Promise((resolve4) => {
-      resolveCompletion = resolve4;
+    this.pendingPromptCompletion = new Promise((resolve5) => {
+      resolveCompletion = resolve5;
     });
     try {
       const result = await this.#executePrompt(params, pendingSend);
@@ -2491,6 +2956,12 @@ var Session = class {
       return result;
     } finally {
       this.pendingPrompt = null;
+      const shouldDrainAutomaticQueues = todoStopGuardPreparation.drainSupersededAutomaticQueues || this.todoStopGuardDrainAutomaticQueuesWhenIdle || this.todoStopGuard.blocksUnrelatedAutomaticTurns || this.todoStopGuard.hasCommittedContinuation || this.todoStopGuardQueuedPromptPriority;
+      this.todoStopGuardDrainAutomaticQueuesWhenIdle = false;
+      if (shouldDrainAutomaticQueues) {
+        void this.#drainCronQueue();
+        void this.#drainNotificationQueue();
+      }
       void this.#startCronSchedulerIfNeeded();
       resolveCompletion();
       this.pendingPromptCompletion = null;
@@ -2552,6 +3023,9 @@ var Session = class {
    */
   #maybeEmitFollowupSuggestion(result) {
     if (result.stopReason !== "end_turn") return;
+    if (this.todoStopGuard.blocksUnrelatedAutomaticTurns || this.todoStopGuardQueuedPromptPriority) {
+      return;
+    }
     if (this.settings.merged.ui?.enableFollowupSuggestions === false) return;
     if (this.config.getApprovalMode() === "plan" /* PLAN */) return;
     const chat = this.config.getGeminiClient()?.getChat();
@@ -2686,6 +3160,14 @@ var Session = class {
             );
             const inputText = firstTextBlock?.text || "";
             let parts;
+            let fullTurnModelOverride;
+            const onFullTurnModel = /* @__PURE__ */ __name((model) => {
+              if (fullTurnModelOverride) {
+                return false;
+              }
+              fullTurnModelOverride = model;
+              return true;
+            }, "onFullTurnModel");
             if (isContinue) {
               parts = continuationParts;
             } else if (isSlashCommand(inputText)) {
@@ -2697,7 +3179,9 @@ var Session = class {
               );
               parts = await this.#processSlashCommandResult(
                 slashCommandResult,
-                params.prompt
+                params.prompt,
+                pendingSend.signal,
+                onFullTurnModel
               );
               if (parts === null) {
                 return { stopReason: "end_turn" };
@@ -2706,7 +3190,7 @@ var Session = class {
               parts = await this.#resolvePrompt(
                 params.prompt,
                 pendingSend.signal,
-                { promptLast: true }
+                { promptLast: true, onFullTurnModel }
               );
             }
             const hooksEnabled = !this.config.getDisableAllHooks?.();
@@ -2777,6 +3261,7 @@ ${this.pendingWorktreeNotice}
               while (nextMessage !== null) {
                 turnCount++;
                 if (pendingSend.signal.aborted) {
+                  this.todoStopGuard.suspend();
                   this.#getCurrentChat().addHistory(nextMessage);
                   return { stopReason: "cancelled" };
                 }
@@ -2793,9 +3278,11 @@ ${this.pendingWorktreeNotice}
                   const sendResult = await this.#sendMessageStreamWithAutoCompression(
                     promptId,
                     nextMessage?.parts ?? [],
-                    pendingSend.signal
+                    pendingSend.signal,
+                    { modelOverride: fullTurnModelOverride }
                   );
                   if (!sendResult.responseStream) {
+                    this.todoStopGuard.suspend();
                     this.#preserveUnsentMessageHistory(
                       nextMessage,
                       isContinue || sendResult.stopReason === "cancelled"
@@ -2808,6 +3295,7 @@ ${this.pendingWorktreeNotice}
                   try {
                     for await (const resp of responseStream) {
                       if (pendingSend.signal.aborted) {
+                        this.todoStopGuard.suspend();
                         return { stopReason: "cancelled" };
                       }
                       if (resp.type === "chunk" /* CHUNK */ && resp.value.candidates && resp.value.candidates.length > 0) {
@@ -2863,8 +3351,10 @@ ${this.pendingWorktreeNotice}
                     strippedOrphanEntries = null;
                   }
                   if (pendingSend.signal.aborted && pendingSend.signal.reason === USER_CANCEL_ABORT_REASON && this.#isAbortError(error)) {
+                    this.todoStopGuard.suspend();
                     return { stopReason: "cancelled" };
                   }
+                  this.todoStopGuard.pauseForTrustedRetry();
                   const errorStatus = getErrorStatus(error);
                   const errorMessage = error instanceof Error ? error.message : String(error);
                   const errorType = classifyApiError({
@@ -2901,24 +3391,31 @@ ${this.pendingWorktreeNotice}
                   );
                 }
                 if (functionCalls.length > 0) {
-                  const toolRun = await this.runToolCalls(
-                    pendingSend.signal,
-                    promptId,
-                    functionCalls,
-                    toolLoopState
+                  const toolRun = await this.#runWithFullTurnModel(
+                    fullTurnModelOverride,
+                    () => this.runToolCalls(
+                      pendingSend.signal,
+                      promptId,
+                      functionCalls,
+                      toolLoopState
+                    )
                   );
                   if (toolRun.stopAfterPermissionCancel) {
+                    this.todoStopGuard.suspend();
                     await this.#preserveStoppedToolRun(
                       toolRun,
                       pendingSend.signal
                     );
                     return { stopReason: "end_turn" };
                   }
-                  nextMessage = await this.#buildNextMessageAfterToolRun(
+                  const nextAfterTools = await this.#buildNextMessageAfterToolRun(
                     toolRun,
-                    pendingSend.signal
+                    pendingSend.signal,
+                    onFullTurnModel
                   );
+                  nextMessage = nextAfterTools.message;
                   if (toolRun.loopDetected) {
+                    this.todoStopGuard.suspend();
                     await this.#preserveStoppedToolRun(
                       toolRun,
                       pendingSend.signal
@@ -2934,7 +3431,9 @@ ${this.pendingWorktreeNotice}
                 pendingSend,
                 promptId,
                 hooksEnabled,
-                messageBus
+                messageBus,
+                true,
+                fullTurnModelOverride
               );
             } finally {
               logConversationFinishedEvent(
@@ -2951,220 +3450,558 @@ ${this.pendingWorktreeNotice}
       }
     );
   }
-  /**
-   * Handles the Stop hook iteration loop.
-   * This method processes Stop hooks after a model response completes with no pending tool calls.
-   * If a Stop hook requests continuation, it sends a follow-up message and loops back.
-   * Maximum iterations (100) prevent infinite loops.
-   *
-   * @param pendingSend - The abort controller for the current prompt
-   * @param promptId - The prompt ID for tracking
-   * @param hooksEnabled - Whether hooks are enabled
-   * @param messageBus - The MessageBus for hook communication (may be undefined)
-   * @returns The ACP stop reason for the prompt.
-   */
-  async #handleStopHookLoop(pendingSend, promptId, hooksEnabled, messageBus) {
+  async #handleStopHookLoop(pendingSend, promptId, hooksEnabled, messageBus, allowExternalHooks = true, modelOverride) {
     const stopHookBlockingCap = this.config.getStopHookBlockingCap();
     let stopHookIterationCount = 0;
     let stopHookReasons = [];
-    while (stopHookIterationCount < stopHookBlockingCap) {
-      if (!hooksEnabled || !messageBus || pendingSend.signal.aborted || !this.config.hasHooksForEvent?.("Stop")) {
+    const onFullTurnModel = /* @__PURE__ */ __name((model) => {
+      if (modelOverride) {
+        return false;
+      }
+      modelOverride = model;
+      return true;
+    }, "onFullTurnModel");
+    let midTurnContinuationCount = 0;
+    while (true) {
+      if (pendingSend.signal.aborted) {
+        this.todoStopGuard.suspend();
         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,
-            ...contextUsage
-          },
-          signal: pendingSend.signal
-        },
-        "hook-execution-response" /* HOOK_EXECUTION_RESPONSE */
-      );
-      if (pendingSend.signal.aborted) {
-        return { stopReason: "cancelled" };
-      }
-      const hookOutput = response.output ? createHookOutput("Stop", response.output) : void 0;
-      const stopOutput = hookOutput;
-      if (stopOutput?.systemMessage) {
-        await this.messageEmitter.emitAgentMessage(stopOutput.systemMessage);
-      }
-      if (stopOutput?.isBlockingDecision() || stopOutput?.shouldStopExecution()) {
-        const continueReason = stopOutput.getEffectiveReason();
-        stopHookIterationCount++;
-        stopHookReasons = [...stopHookReasons, continueReason];
-        if (stopHookIterationCount >= stopHookBlockingCap) {
-          const warning = formatStopHookBlockingCapWarning(
-            "Stop",
-            stopHookBlockingCap
-          );
-          abortGoalForStopHookCap(
-            this.config,
-            this.config.getSessionId(),
-            warning
+      if (this.config.getApprovalMode() === "plan" /* PLAN */) {
+        this.#clearTodoStopGuardTrustAndDrainAutomaticQueues();
+      }
+      if (this.todoStopGuardQueuedPromptPriority) {
+        return { stopReason: "end_turn" };
+      }
+      if (this.todoStopGuard.needsStopInspection) {
+        this.#beginTodoStopGuardQueuedPromptCheck();
+        const drained = await this.#drainMidTurnInput(pendingSend.signal, {
+          watchQueuedPromptForTodoStopGuard: true,
+          onFullTurnModel
+        });
+        const waitsForQueuedPrompt = this.#finishTodoStopGuardQueuedPromptCheck(
+          drained.hasQueuedPrompt
+        );
+        if (drained.parts.length > 0) {
+          this.todoStopGuard.acceptMidTurnUserInput();
+          const continuation2 = await this.#runStopContinuation(
+            pendingSend,
+            promptId + "_mid_turn_" + ++midTurnContinuationCount,
+            promptId,
+            drained.parts,
+            false,
+            {
+              onFullTurnModel,
+              getModelOverride: /* @__PURE__ */ __name(() => modelOverride, "getModelOverride")
+            }
           );
-          await this.messageEmitter.emitAgentMessage(warning);
-          debugLogger6.warn(warning);
+          if (continuation2.kind === "terminal") {
+            return { stopReason: continuation2.stopReason };
+          }
+          continue;
+        }
+        if (waitsForQueuedPrompt) {
           return { stopReason: "end_turn" };
         }
-        if (stopHookIterationCount > 1) {
-          await this.messageEmitter.emitStopHookLoop(
-            stopHookIterationCount,
-            stopHookReasons,
-            response.stopHookCount ?? 1
+      }
+      let externalReason = null;
+      let stopHookCount = 1;
+      let queuedPromptArrivedDuringStopHook = false;
+      if (allowExternalHooks && hooksEnabled && messageBus && stopHookIterationCount < stopHookBlockingCap && this.config.hasHooksForEvent?.("Stop")) {
+        const responseText = this.#getCurrentChat().getLastModelMessageText?.() || "[no response text]";
+        const contextUsage = buildContextUsage(
+          this.config.getContentGeneratorConfig()?.contextWindowSize ?? DEFAULT_TOKEN_LIMIT,
+          this.lastPromptTokenCount
+        );
+        let response;
+        try {
+          response = await messageBus.request(
+            {
+              type: "hook-execution-request" /* HOOK_EXECUTION_REQUEST */,
+              eventName: "Stop",
+              input: {
+                stop_hook_active: true,
+                last_assistant_message: responseText,
+                ...contextUsage
+              },
+              signal: pendingSend.signal
+            },
+            "hook-execution-response" /* HOOK_EXECUTION_RESPONSE */
           );
+        } catch (error) {
+          this.todoStopGuard.pauseForTrustedRetry();
+          throw error;
         }
-        const continueParts = [{ text: continueReason }];
-        let nextMessage = {
-          role: "user",
-          parts: continueParts
-        };
-        const toolLoopState = createDaemonToolLoopState();
-        while (nextMessage !== null) {
-          if (pendingSend.signal.aborted) {
-            return { stopReason: "cancelled" };
-          }
-          const functionCalls = [];
-          const preparationTracker = new ToolCallPreparationTracker(
-            this.toolCallEmitter
-          );
-          let usageMetadata = null;
-          const streamStartTime = Date.now();
-          const messageDisplay = this.#createMessageDisplayDispatcher(
-            pendingSend.signal
-          );
-          try {
-            const continueSendResult = await this.#sendMessageStreamWithAutoCompression(
-              promptId + "_stop_hook_" + stopHookIterationCount,
-              nextMessage?.parts ?? [],
-              pendingSend.signal,
-              { skipCompression: stopHookIterationCount > 1 }
+        if (pendingSend.signal.aborted) {
+          this.todoStopGuard.suspend();
+          return { stopReason: "cancelled" };
+        }
+        if (this.todoStopGuard.needsStopInspection) {
+          this.#beginTodoStopGuardQueuedPromptCheck();
+          const drained = await this.#drainMidTurnInput(pendingSend.signal, {
+            watchQueuedPromptForTodoStopGuard: true,
+            onFullTurnModel
+          });
+          const waitsForQueuedPrompt = this.#finishTodoStopGuardQueuedPromptCheck(drained.hasQueuedPrompt);
+          queuedPromptArrivedDuringStopHook = waitsForQueuedPrompt;
+          if (drained.parts.length > 0) {
+            this.todoStopGuard.acceptMidTurnUserInput();
+            const continuation2 = await this.#runStopContinuation(
+              pendingSend,
+              promptId + "_mid_turn_" + ++midTurnContinuationCount,
+              promptId,
+              drained.parts,
+              false,
+              {
+                onFullTurnModel,
+                getModelOverride: /* @__PURE__ */ __name(() => modelOverride, "getModelOverride")
+              }
             );
-            if (!continueSendResult.responseStream) {
-              this.#preserveUnsentMessageHistory(
-                nextMessage,
-                continueSendResult.stopReason === "cancelled"
-              );
-              return { stopReason: continueSendResult.stopReason };
+            if (continuation2.kind === "terminal") {
+              return { stopReason: continuation2.stopReason };
             }
-            const continueResponseStream = continueSendResult.responseStream;
-            nextMessage = null;
-            let streamFailed = false;
-            try {
-              for await (const resp of continueResponseStream) {
-                if (pendingSend.signal.aborted) {
-                  return { stopReason: "cancelled" };
-                }
-                if (resp.type === "chunk" /* CHUNK */ && resp.value.candidates && resp.value.candidates.length > 0) {
-                  const candidate = resp.value.candidates[0];
-                  for (const part of candidate.content?.parts ?? []) {
-                    if (!part.text) continue;
-                    this.messageEmitter.emitMessage(
-                      part.text,
-                      "assistant",
-                      part.thought
-                    );
-                    if (!part.thought) {
-                      messageDisplay?.addChunk(part.text);
-                    }
+          }
+        }
+        const hookOutput = response.output ? createHookOutput("Stop", response.output) : void 0;
+        const stopOutput = hookOutput;
+        if (stopOutput?.systemMessage) {
+          await this.messageEmitter.emitAgentMessage(stopOutput.systemMessage);
+        }
+        if (stopOutput?.isBlockingDecision() || stopOutput?.shouldStopExecution()) {
+          externalReason = stopOutput.getEffectiveReason();
+          stopHookIterationCount++;
+          stopHookReasons = [...stopHookReasons, externalReason];
+          stopHookCount = response.stopHookCount ?? 1;
+        }
+      }
+      const guardDecision = queuedPromptArrivedDuringStopHook ? null : this.todoStopGuard.decide(
+        this.todoStopGuard.needsStopInspection ? this.#hasRelevantTodoStopGuardBackgroundInput() : false
+      );
+      const guardContinuation = guardDecision?.kind === "continue" ? guardDecision : null;
+      if (guardDecision?.kind === "exhausted") {
+        await this.#emitTodoStopGuardExhausted(guardDecision);
+        if (!externalReason) return { stopReason: "end_turn" };
+      }
+      if (externalReason && stopHookIterationCount >= stopHookBlockingCap) {
+        const warning = formatStopHookBlockingCapWarning(
+          "Stop",
+          stopHookBlockingCap
+        );
+        abortGoalForStopHookCap(
+          this.config,
+          this.config.getSessionId(),
+          warning
+        );
+        this.todoStopGuard.suspend();
+        await this.messageEmitter.emitAgentMessage(warning);
+        debugLogger6.warn(warning);
+        return { stopReason: "end_turn" };
+      }
+      if (queuedPromptArrivedDuringStopHook) {
+        return { stopReason: "end_turn" };
+      }
+      if (!externalReason && !guardContinuation) {
+        return { stopReason: "end_turn" };
+      }
+      const continueParts = [];
+      if (externalReason) continueParts.push({ text: externalReason });
+      if (guardContinuation) {
+        continueParts.push({
+          text: this.#buildTodoStopGuardPrompt(guardContinuation)
+        });
+      }
+      const continuationPromptId = externalReason ? promptId + "_stop_hook_" + stopHookIterationCount : promptId + "_todo_stop_guard_" + guardContinuation.attempt;
+      if (externalReason && stopHookIterationCount > 1 && !guardContinuation) {
+        await this.messageEmitter.emitStopHookLoop(
+          stopHookIterationCount,
+          stopHookReasons,
+          stopHookCount
+        );
+      }
+      const continuation = await this.#runStopContinuation(
+        pendingSend,
+        continuationPromptId,
+        promptId,
+        continueParts,
+        stopHookIterationCount > 1 || (guardContinuation?.attempt ?? 0) > 1,
+        {
+          ...guardContinuation ? { guardContinuation } : {},
+          ...externalReason ? { externalParts: [{ text: externalReason }] } : {},
+          ...externalReason && stopHookIterationCount > 1 && guardContinuation ? {
+            onAutomaticContinuationValidated: /* @__PURE__ */ __name(() => this.messageEmitter.emitStopHookLoop(
+              stopHookIterationCount,
+              stopHookReasons,
+              stopHookCount
+            ), "onAutomaticContinuationValidated")
+          } : {},
+          onFullTurnModel,
+          getModelOverride: /* @__PURE__ */ __name(() => modelOverride, "getModelOverride")
+        }
+      );
+      if (continuation.supersededAutomaticContinuation && externalReason) {
+        stopHookIterationCount--;
+        stopHookReasons = stopHookReasons.slice(0, -1);
+      }
+      if (continuation.kind === "terminal") {
+        return { stopReason: continuation.stopReason };
+      }
+    }
+  }
+  async #runStopContinuation(pendingSend, streamPromptId, toolPromptId, parts, skipCompression, options = {}) {
+    let nextMessage = { role: "user", parts };
+    let nextGuardContinuation = options.guardContinuation;
+    const toolLoopState = createDaemonToolLoopState();
+    let initialSend = true;
+    let automaticContinuationValidated = false;
+    let supersededAutomaticContinuation = false;
+    while (nextMessage !== null) {
+      if (pendingSend.signal.aborted) {
+        this.todoStopGuard.suspend();
+        return {
+          kind: "terminal",
+          stopReason: "cancelled",
+          ...supersededAutomaticContinuation ? { supersededAutomaticContinuation: true } : {}
+        };
+      }
+      const functionCalls = [];
+      const preparationTracker = new ToolCallPreparationTracker(
+        this.toolCallEmitter
+      );
+      let usageMetadata = null;
+      const streamStartTime = Date.now();
+      let streamFailed = false;
+      let guardForThisSend = nextGuardContinuation;
+      let preserveGuardOnSkippedSend = false;
+      let messageForPreservation = nextMessage;
+      const externalParts = initialSend ? options.externalParts : void 0;
+      const promptIdForSend = guardForThisSend && guardForThisSend.attempt !== options.guardContinuation?.attempt ? toolPromptId + "_todo_stop_guard_" + guardForThisSend.attempt : streamPromptId;
+      const messageDisplay = this.#createMessageDisplayDispatcher(
+        pendingSend.signal
+      );
+      try {
+        const sendResult = await this.#sendMessageStreamWithAutoCompression(
+          promptIdForSend,
+          nextMessage.parts ?? [],
+          pendingSend.signal,
+          {
+            skipCompression: skipCompression || (guardForThisSend?.attempt ?? 0) > 1,
+            getModelOverride: options.getModelOverride,
+            beforeSend: guardForThisSend || !automaticContinuationValidated && options.onAutomaticContinuationValidated ? async ({ compressionFailed }) => {
+              const inspectGuardPriority = guardForThisSend !== void 0;
+              const guardCompressionFailed = inspectGuardPriority && compressionFailed;
+              if (inspectGuardPriority) {
+                this.#beginTodoStopGuardQueuedPromptCheck();
+                const drained = await this.#drainMidTurnInput(
+                  pendingSend.signal,
+                  {
+                    watchQueuedPromptForTodoStopGuard: true,
+                    onFullTurnModel: options.onFullTurnModel
+                  }
+                );
+                const waitsForQueuedPrompt = this.#finishTodoStopGuardQueuedPromptCheck(
+                  drained.hasQueuedPrompt
+                );
+                if (drained.parts.length > 0) {
+                  this.todoStopGuard.acceptMidTurnUserInput();
+                  guardForThisSend = void 0;
+                  nextGuardContinuation = void 0;
+                  if (initialSend) {
+                    supersededAutomaticContinuation = true;
                   }
+                  const replacementMessage = initialSend ? drained.parts : [
+                    ...(nextMessage?.parts ?? []).filter(
+                      (part) => !("text" in part && isTodoStopGuardPromptText(part.text))
+                    ),
+                    ...drained.parts
+                  ];
+                  messageForPreservation = {
+                    role: "user",
+                    parts: replacementMessage
+                  };
+                  return {
+                    kind: "send",
+                    message: replacementMessage
+                  };
                 }
-                if (resp.type === "chunk" /* CHUNK */ && resp.value.usageMetadata) {
-                  usageMetadata = resp.value.usageMetadata;
+                if (waitsForQueuedPrompt) {
+                  guardForThisSend = void 0;
+                  nextGuardContinuation = void 0;
+                  preserveGuardOnSkippedSend = true;
+                  if (initialSend) {
+                    supersededAutomaticContinuation = true;
+                  }
+                  return { kind: "stop", stopReason: "end_turn" };
                 }
-                if (resp.type === "chunk" /* CHUNK */) {
-                  await preparationTracker.observe(resp.value);
-                  if (resp.value.functionCalls) {
-                    preparationTracker.resolve(resp.value.functionCalls);
-                    functionCalls.push(...resp.value.functionCalls);
+                if (guardCompressionFailed) {
+                  this.todoStopGuard.suspend();
+                  guardForThisSend = void 0;
+                  nextGuardContinuation = void 0;
+                  if (!externalParts || externalParts.length === 0) {
+                    preserveGuardOnSkippedSend = true;
+                    return { kind: "stop", stopReason: "end_turn" };
                   }
                 }
-                if (resp.type === "retry" /* RETRY */ || resp.type === "model_fallback" /* MODEL_FALLBACK */) {
-                  await finalizeToolCallPreparations(
-                    preparationTracker,
-                    true,
-                    `Stop Hook continuation ${resp.type}`
+                if (guardForThisSend && this.config.getApprovalMode() === "plan" /* PLAN */) {
+                  this.#clearTodoStopGuardTrustAndDrainAutomaticQueues();
+                }
+                if (guardForThisSend) {
+                  const hasRelevantBackgroundInput = this.#hasRelevantTodoStopGuardBackgroundInput();
+                  const refreshedDecision = guardForThisSend.toolClosure ? this.todoStopGuard.decideToolClosure(
+                    guardForThisSend.attempt - 1,
+                    hasRelevantBackgroundInput
+                  ) : this.todoStopGuard.decide(
+                    hasRelevantBackgroundInput
                   );
-                  functionCalls.length = 0;
+                  if (refreshedDecision.kind !== "continue" || refreshedDecision.attempt !== guardForThisSend.attempt) {
+                    guardForThisSend = void 0;
+                    nextGuardContinuation = void 0;
+                    if (!options.externalParts) {
+                      preserveGuardOnSkippedSend = true;
+                      return { kind: "stop", stopReason: "end_turn" };
+                    }
+                    if (!initialSend && nextMessage) {
+                      nextMessage = {
+                        ...nextMessage,
+                        parts: (nextMessage.parts ?? []).filter(
+                          (part) => !("text" in part && isTodoStopGuardPromptText(part.text))
+                        )
+                      };
+                    }
+                  }
                 }
               }
-            } catch (error) {
-              streamFailed = true;
-              throw error;
-            } finally {
-              await finalizeToolCallPreparations(
-                preparationTracker,
-                streamFailed || pendingSend.signal.aborted,
-                "Stop Hook continuation"
-              );
-            }
-          } catch (error) {
-            const errorStatus = getErrorStatus(error);
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            const errorType = classifyApiError({
-              message: errorMessage,
-              status: errorStatus
-            });
-            const hookSystem = this.config.getHookSystem?.();
-            const hooksEnabledForStopFailure = !this.config.getDisableAllHooks?.();
-            if (hooksEnabledForStopFailure && hookSystem && this.config.hasHooksForEvent?.("StopFailure")) {
-              hookSystem.fireStopFailureEvent(errorType, errorMessage).catch((err) => {
-                debugLogger6.warn(`StopFailure hook failed: ${err}`);
-              });
-            }
-            if (errorStatus === 429) {
-              throw new RequestError(
-                429,
-                "Rate limit exceeded. Try again later."
+              if (!automaticContinuationValidated && options.onAutomaticContinuationValidated) {
+                await options.onAutomaticContinuationValidated();
+                automaticContinuationValidated = true;
+              }
+              const selectedMessage = guardForThisSend || !externalParts ? nextMessage?.parts ?? [] : externalParts;
+              messageForPreservation = {
+                role: "user",
+                parts: selectedMessage
+              };
+              return {
+                kind: "send",
+                message: selectedMessage
+              };
+            } : void 0
+          }
+        );
+        if (!sendResult.responseStream) {
+          if (!automaticContinuationValidated && !supersededAutomaticContinuation && options.onAutomaticContinuationValidated) {
+            await options.onAutomaticContinuationValidated();
+            automaticContinuationValidated = true;
+          }
+          if (!preserveGuardOnSkippedSend) {
+            this.todoStopGuard.suspend();
+          }
+          const preservedParts = (messageForPreservation.parts ?? []).filter(
+            (part) => !("text" in part && isTodoStopGuardPromptText(part.text))
+          );
+          this.#preserveUnsentMessageHistory(
+            preservedParts.length > 0 ? { ...messageForPreservation, parts: preservedParts } : null,
+            sendResult.stopReason === "cancelled"
+          );
+          return {
+            kind: "terminal",
+            stopReason: sendResult.stopReason,
+            ...supersededAutomaticContinuation ? { supersededAutomaticContinuation: true } : {}
+          };
+        }
+        const responseStream = sendResult.responseStream;
+        nextMessage = null;
+        initialSend = false;
+        if (guardForThisSend) {
+          const guardCommitted = this.todoStopGuard.commitContinuation(
+            guardForThisSend.attempt
+          );
+          if (guardCommitted) {
+            await this.#emitTodoStopGuardContinuation(guardForThisSend);
+          }
+          if (!guardCommitted && externalParts) {
+            guardForThisSend = void 0;
+          }
+        }
+        for await (const response of responseStream) {
+          if (pendingSend.signal.aborted) {
+            this.todoStopGuard.suspend();
+            return {
+              kind: "terminal",
+              stopReason: "cancelled",
+              ...supersededAutomaticContinuation ? { supersededAutomaticContinuation: true } : {}
+            };
+          }
+          if (response.type === "chunk" /* CHUNK */ && response.value.candidates && response.value.candidates.length > 0) {
+            const candidate = response.value.candidates[0];
+            for (const part of candidate.content?.parts ?? []) {
+              if (!part.text) continue;
+              this.messageEmitter.emitMessage(
+                part.text,
+                "assistant",
+                part.thought
               );
+              if (!part.thought) messageDisplay?.addChunk(part.text);
             }
-            throw error;
-          } finally {
-            await messageDisplay?.finish();
           }
-          if (usageMetadata) {
-            this.#recordPromptTokenCount(usageMetadata);
-            const durationMs = Date.now() - streamStartTime;
-            await this.messageEmitter.emitUsageMetadata(
-              usageMetadata,
-              "",
-              durationMs
-            );
+          if (response.type === "chunk" /* CHUNK */ && response.value.usageMetadata) {
+            usageMetadata = response.value.usageMetadata;
           }
-          if (functionCalls.length > 0) {
-            const toolRun = await this.runToolCalls(
-              pendingSend.signal,
-              promptId,
-              functionCalls,
-              toolLoopState
-            );
-            if (toolRun.stopAfterPermissionCancel) {
-              await this.#preserveStoppedToolRun(toolRun, pendingSend.signal);
-              return { stopReason: "end_turn" };
+          if (response.type === "chunk" /* CHUNK */) {
+            await preparationTracker.observe(response.value);
+            if (response.value.functionCalls) {
+              preparationTracker.resolve(response.value.functionCalls);
+              functionCalls.push(...response.value.functionCalls);
             }
-            nextMessage = await this.#buildNextMessageAfterToolRun(
-              toolRun,
-              pendingSend.signal
+          }
+          if (response.type === "retry" /* RETRY */ || response.type === "model_fallback" /* MODEL_FALLBACK */) {
+            await finalizeToolCallPreparations(
+              preparationTracker,
+              true,
+              `daemon continuation ${response.type}`
             );
-            if (toolRun.loopDetected) {
-              await this.#preserveStoppedToolRun(toolRun, pendingSend.signal);
-              return { stopReason: "end_turn" };
+            functionCalls.length = 0;
+          }
+        }
+      } catch (error) {
+        streamFailed = true;
+        this.todoStopGuard.pauseForTrustedRetry();
+        const errorStatus = getErrorStatus(error);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const errorType = classifyApiError({
+          message: errorMessage,
+          status: errorStatus
+        });
+        const hookSystem = this.config.getHookSystem?.();
+        if (!this.config.getDisableAllHooks?.() && hookSystem && this.config.hasHooksForEvent?.("StopFailure")) {
+          hookSystem.fireStopFailureEvent(errorType, errorMessage).catch((err) => {
+            debugLogger6.warn(`StopFailure hook failed: ${err}`);
+          });
+        }
+        if (errorStatus === 429) {
+          throw new RequestError(429, "Rate limit exceeded. Try again later.");
+        }
+        throw error;
+      } finally {
+        try {
+          await finalizeToolCallPreparations(
+            preparationTracker,
+            streamFailed || pendingSend.signal.aborted,
+            "daemon continuation"
+          );
+        } finally {
+          await messageDisplay?.finish();
+        }
+      }
+      if (usageMetadata) {
+        this.#recordPromptTokenCount(usageMetadata);
+        const durationMs = Date.now() - streamStartTime;
+        await this.messageEmitter.emitUsageMetadata(
+          usageMetadata,
+          "",
+          durationMs
+        );
+      }
+      if (functionCalls.length > 0) {
+        const toolRun = await this.#runWithFullTurnModel(
+          options.getModelOverride?.(),
+          () => this.runToolCalls(
+            pendingSend.signal,
+            toolPromptId,
+            functionCalls,
+            toolLoopState
+          )
+        );
+        if (toolRun.stopAfterPermissionCancel || toolRun.loopDetected) {
+          this.todoStopGuard.suspend();
+          await this.#preserveStoppedToolRun(toolRun, pendingSend.signal);
+          return {
+            kind: "terminal",
+            stopReason: "end_turn",
+            ...supersededAutomaticContinuation ? { supersededAutomaticContinuation: true } : {}
+          };
+        }
+        const nextAfterTools = await this.#buildNextMessageAfterToolRun(
+          toolRun,
+          pendingSend.signal,
+          options.onFullTurnModel
+        );
+        nextMessage = nextAfterTools.message;
+        if (nextAfterTools.hadMidTurnUserInput) {
+          nextGuardContinuation = void 0;
+          continue;
+        }
+        if (guardForThisSend && nextMessage) {
+          const nextDecision = this.todoStopGuard.decideToolClosure(
+            guardForThisSend.attempt,
+            this.#hasRelevantTodoStopGuardBackgroundInput()
+          );
+          if (nextDecision.kind === "continue" && nextDecision.attempt > guardForThisSend.attempt) {
+            nextGuardContinuation = nextDecision;
+            if (!nextDecision.toolClosure) {
+              nextMessage = {
+                ...nextMessage,
+                parts: [
+                  ...nextMessage.parts ?? [],
+                  { text: this.#buildTodoStopGuardPrompt(nextDecision) }
+                ]
+              };
             }
+          } else if (nextDecision.kind === "continue" && nextDecision.attempt <= guardForThisSend.attempt) {
+            nextGuardContinuation = void 0;
+          } else if (options.externalParts) {
+            nextGuardContinuation = void 0;
+          } else {
+            this.#preserveUnsentMessageHistory(nextMessage, true);
+            return {
+              kind: "natural_stop",
+              ...supersededAutomaticContinuation ? { supersededAutomaticContinuation: true } : {}
+            };
           }
+        } else {
+          nextGuardContinuation = void 0;
         }
-        continue;
       }
-      break;
     }
-    return { stopReason: "end_turn" };
+    return {
+      kind: "natural_stop",
+      ...supersededAutomaticContinuation ? { supersededAutomaticContinuation: true } : {}
+    };
+  }
+  #buildTodoStopGuardPrompt(state) {
+    const prompt = `${TODO_STOP_GUARD_PROMPT_PREFIX}${state.unfinishedCount}${TODO_STOP_GUARD_PROMPT_BODY_SUFFIX}`;
+    if (state.attempt < state.maxAttempts) return prompt;
+    return prompt + TODO_STOP_GUARD_FINAL_PROMPT_SUFFIX;
+  }
+  async #emitTodoStopGuardContinuation(state) {
+    await this.#emitTodoStopGuardMessageSafely(
+      `[Todo Stop Guard] Automatic continuation ${state.attempt}/${state.maxAttempts} started; ${state.unfinishedCount} todo item(s) remain unfinished.`,
+      state
+    );
+  }
+  async #emitTodoStopGuardExhausted(state) {
+    if (!this.todoStopGuard.markExhaustionReported()) return;
+    await this.#emitTodoStopGuardMessageSafely(
+      `[Todo Stop Guard] Automatic continuation stopped after ${state.maxAttempts} attempts; ${state.unfinishedCount} todo item(s) remain unfinished.`,
+      state
+    );
+  }
+  async #emitTodoStopGuardMessageSafely(text, state) {
+    try {
+      await this.sendUpdate({
+        sessionUpdate: "agent_message_chunk",
+        content: { type: "text", text },
+        _meta: {
+          source: "todo_stop_guard",
+          qwenDiscreteMessage: true,
+          attempt: state.attempt,
+          maxAttempts: state.maxAttempts,
+          unfinishedCount: state.unfinishedCount
+        }
+      });
+    } catch (error) {
+      debugLogger6.warn(
+        `Failed to emit Todo Stop Guard status: ${this.#formatError(error)}`
+      );
+    }
   }
   async sendUpdate(update) {
     const params = {
@@ -3176,14 +4013,13 @@ ${this.pendingWorktreeNotice}
   #getCurrentChat() {
     return this.config.getGeminiClient().getChat();
   }
-  /**
-   * Mirrors the core send path for ACP model sends.
-   *
-   * Attempts automatic chat compression first, checks the session token limit,
-   * emits an ACP-visible notice when compression succeeds, and returns the ACP
-   * stop reason when the provider send should be skipped because the request
-   * was cancelled or the session token limit was exceeded.
-   */
+  async #runWithFullTurnModel(modelOverride, fn) {
+    if (!modelOverride?.endsWith("\0")) {
+      return fn();
+    }
+    const runtimeView = await this.config.getBaseLlmClient().resolveForModel(modelOverride.slice(0, -1), { failClosed: true });
+    return runWithRuntimeContentGenerator(runtimeView, fn);
+  }
   /**
    * Create the MessageDisplay hook dispatcher for one model call's streamed
    * reply, or null when the hook isn't registered (the common case — keeps
@@ -3206,11 +4042,20 @@ ${this.pendingWorktreeNotice}
       (message) => debugLogger6.warn(message)
     );
   }
+  /**
+   * Mirrors the core send path for ACP model sends.
+   *
+   * Attempts automatic chat compression first, checks the session token limit,
+   * emits an ACP-visible notice when compression succeeds, and returns the ACP
+   * stop reason when the provider send should be skipped because the request
+   * was cancelled or the session token limit was exceeded.
+   */
   async #sendMessageStreamWithAutoCompression(promptId, message, abortSignal, options = {}) {
     const geminiClient = this.config.getGeminiClient();
     let compressionDiagnostic = null;
     let compressionInfo = null;
-    if (!options.skipCompression) {
+    let compressionFailed = false;
+    if (!options.skipCompression && !(options.getModelOverride?.() ?? options.modelOverride)) {
       try {
         const compressed = await geminiClient.tryCompressChat(
           promptId,
@@ -3219,6 +4064,9 @@ ${this.pendingWorktreeNotice}
         );
         compressionInfo = compressed;
         this.#recordCompressionTokenCount(compressed);
+        compressionFailed = isCompressionFailureStatus(
+          compressed.compressionStatus
+        );
         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()}`;
@@ -3232,6 +4080,7 @@ ${this.pendingWorktreeNotice}
         debugLogger6.warn(
           `Auto-compression failed for prompt ${promptId}; proceeding without compression: ` + this.#formatError(compressionError)
         );
+        compressionFailed = true;
       }
     }
     if (abortSignal.aborted) {
@@ -3267,8 +4116,21 @@ ${this.pendingWorktreeNotice}
       );
       return { responseStream: null, stopReason: "cancelled" };
     }
+    if (options.beforeSend) {
+      const decision = await options.beforeSend({ compressionFailed });
+      if (decision.kind === "stop") {
+        return { responseStream: null, stopReason: decision.stopReason };
+      }
+      message = decision.message;
+    }
+    if (abortSignal.aborted) {
+      debugLogger6.debug(
+        `Send aborted after pre-send validation for prompt ${promptId}`
+      );
+      return { responseStream: null, stopReason: "cancelled" };
+    }
     const responseStream = await this.#getCurrentChat().sendMessageStream(
-      this.config.getModel(),
+      options.getModelOverride?.() ?? options.modelOverride ?? this.config.getModel(),
       {
         message,
         config: {
@@ -3315,22 +4177,30 @@ ${this.pendingWorktreeNotice}
     );
     await this.messageRewriter?.waitForPendingRewrites();
   }
-  async #buildNextMessageAfterToolRun(toolRun, abortSignal) {
+  async #buildNextMessageAfterToolRun(toolRun, abortSignal, onFullTurnModel) {
     if (toolRun.loopDetected) {
       debugLogger6.debug("Stopping ACP turn after daemon loop detection.");
-      return null;
+      return { message: null, hadMidTurnUserInput: false };
     }
     if (toolRun.repeatedDuplicateProviderToolCall) {
+      this.todoStopGuard.suspend();
       debugLogger6.debug(
         "Stopping ACP turn after dropping repeated duplicate provider tool-call response."
       );
-      return null;
+      return { message: null, hadMidTurnUserInput: false };
     }
-    const parts = [
-      ...toolRun.parts,
-      ...await this.#drainMidTurnUserMessages(abortSignal)
-    ];
-    return { role: "user", parts };
+    const drained = await this.#drainMidTurnInput(abortSignal, {
+      onFullTurnModel
+    });
+    const hadMidTurnUserInput = drained.parts.length > 0;
+    if (hadMidTurnUserInput) {
+      this.todoStopGuard.acceptMidTurnUserInput();
+    }
+    const parts = [...toolRun.parts, ...drained.parts];
+    return {
+      message: { role: "user", parts },
+      hadMidTurnUserInput
+    };
   }
   #recordCompressionTokenCount(info) {
     this.#syncPromptTokenCountWithCurrentChat();
@@ -3408,15 +4278,26 @@ ${this.pendingWorktreeNotice}
       content: { type: "text", text }
     });
   }
-  async #drainMidTurnUserMessages(abortSignal) {
+  async #drainMidTurnUserMessages(abortSignal, onFullTurnModel) {
+    return (await this.#drainMidTurnInput(abortSignal, { onFullTurnModel })).parts;
+  }
+  async #drainMidTurnInput(abortSignal, options = {}) {
     const recovered = this.#takeRecoveredMidTurnMessages();
     if (this.midTurnDrainUnavailable) {
-      return this.#buildMidTurnParts(recovered, abortSignal);
+      return {
+        parts: await this.#buildMidTurnParts(
+          recovered,
+          abortSignal,
+          options.onFullTurnModel
+        ),
+        hasQueuedPrompt: false
+      };
     }
     let drainPromise;
     try {
       drainPromise = this.client.extMethod(MID_TURN_QUEUE_DRAIN_METHOD, {
-        sessionId: this.sessionId
+        sessionId: this.sessionId,
+        ...options.watchQueuedPromptForTodoStopGuard ? { todoStopGuardWatchQueuedPrompt: true } : {}
       });
       let timeoutHandle;
       const timeoutPromise = new Promise((_, reject) => {
@@ -3432,10 +4313,14 @@ ${this.pendingWorktreeNotice}
         clearTimeout(timeoutHandle);
       }
       this.midTurnDrainTimeoutStrikes = 0;
-      return this.#buildMidTurnParts(
-        [...recovered, ...parseMidTurnDrainResponse(response)],
-        abortSignal
-      );
+      return {
+        parts: await this.#buildMidTurnParts(
+          [...recovered, ...parseMidTurnDrainResponse(response)],
+          abortSignal,
+          options.onFullTurnModel
+        ),
+        hasQueuedPrompt: isRecord2(response) && response["hasQueuedPrompt"] === true
+      };
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : error && typeof error === "object" && "message" in error ? String(error.message) : String(error);
       const errorCode = error && typeof error === "object" && "code" in error ? error.code : void 0;
@@ -3451,7 +4336,14 @@ ${this.pendingWorktreeNotice}
       debugLogger6.warn(
         `Mid-turn queue drain ${isPermanentError ? "permanently " : ""}unavailable [session ${this.sessionId}]: ${errorMessage}`
       );
-      return this.#buildMidTurnParts(recovered, abortSignal);
+      return {
+        parts: await this.#buildMidTurnParts(
+          recovered,
+          abortSignal,
+          options.onFullTurnModel
+        ),
+        hasQueuedPrompt: false
+      };
     }
   }
   /** Read and clear the buffer of messages recovered from a timed-out drain. */
@@ -3474,9 +4366,9 @@ ${this.pendingWorktreeNotice}
     });
     const expired = Symbol("mid-turn-recovery-expired");
     let timer;
-    const deadline = new Promise((resolve4) => {
+    const deadline = new Promise((resolve5) => {
       timer = setTimeout(
-        () => resolve4(expired),
+        () => resolve5(expired),
         MID_TURN_QUEUE_RECOVERY_TIMEOUT_MS
       );
       timer.unref?.();
@@ -3509,7 +4401,7 @@ ${this.pendingWorktreeNotice}
    * happens on injection (here), so a message recovered from an earlier
    * timed-out drain is still recorded exactly once.
    */
-  async #buildMidTurnParts(messages, abortSignal) {
+  async #buildMidTurnParts(messages, abortSignal, onFullTurnModel) {
     const parts = [];
     for (const message of messages) {
       const displayText = message.kind === "text" ? message.message : message.displayText;
@@ -3518,7 +4410,9 @@ ${this.pendingWorktreeNotice}
         rawParts = message.kind === "text" ? [{ text: message.message }] : await withTimeoutSignal(
           abortSignal,
           MID_TURN_QUEUE_RESOLVE_TIMEOUT_MS,
-          (signal) => this.#resolvePrompt(message.content, signal)
+          (signal) => this.#resolvePrompt(message.content, signal, {
+            onFullTurnModel
+          })
         );
       } catch (messageError) {
         if (abortSignal.aborted) return parts;
@@ -3557,13 +4451,38 @@ ${this.pendingWorktreeNotice}
     scheduler.start((job) => {
       if (this.cronDisabledByTokenLimit) return;
       if (job.missed && detectAutonomousSentinel(job.prompt)) return;
-      this.cronQueue.push({
+      this.#enqueueCronPrompt({
         prompt: job.prompt,
-        source: job.cronExpr === "@wakeup" ? "loop" : "cron"
+        source: job.cronExpr === "@wakeup" ? "loop" : "cron",
+        ...job.id ? { taskId: job.id } : {}
       });
       void this.#drainCronQueue();
     });
   }
+  #enqueueCronPrompt(item) {
+    if ((this.todoStopGuard.blocksUnrelatedAutomaticTurns || this.todoStopGuardQueuedPromptPriority) && !this.#cronContinuesTodoStopGuardWorkChain(item)) {
+      if (item.taskId) {
+        const duplicateIndex = this.cronQueue.findIndex(
+          (queued) => queued.taskId === item.taskId && !this.#cronContinuesTodoStopGuardWorkChain(queued)
+        );
+        if (duplicateIndex >= 0) {
+          this.cronQueue[duplicateIndex] = item;
+          return;
+        }
+      }
+      const unrelatedIndices = this.cronQueue.map(
+        (queued, index) => this.#cronContinuesTodoStopGuardWorkChain(queued) ? -1 : index
+      ).filter((index) => index >= 0);
+      if (unrelatedIndices.length >= MAX_DEFERRED_UNRELATED_CRON_QUEUE) {
+        const evictedIndex = unrelatedIndices[0];
+        const [evicted] = this.cronQueue.splice(evictedIndex, 1);
+        debugLogger6.warn(
+          `Cron queue overflow while automatic work is deferred: evicting task=${evicted?.taskId ?? "unknown"}`
+        );
+      }
+    }
+    this.cronQueue.push(item);
+  }
   /**
    * Processes queued cron prompts one at a time. Uses `cronProcessing`
    * as a mutex to prevent concurrent access to the chat.
@@ -3573,14 +4492,18 @@ ${this.pendingWorktreeNotice}
     if (this.cronProcessing) return;
     if (this.pendingPrompt) return;
     if (this.notificationProcessing) return;
+    if (this.#nextCronQueueIndex() < 0) return;
     this.cronProcessing = true;
     let resolveCompletion;
-    this.cronCompletion = new Promise((resolve4) => {
-      resolveCompletion = resolve4;
+    this.cronCompletion = new Promise((resolve5) => {
+      resolveCompletion = resolve5;
     });
     try {
       while (this.cronQueue.length > 0) {
-        const item = this.cronQueue.shift();
+        const nextIndex = this.#nextCronQueueIndex();
+        if (nextIndex < 0) break;
+        const [item] = this.cronQueue.splice(nextIndex, 1);
+        if (!item) break;
         await this.#executeCronPrompt(item);
       }
     } finally {
@@ -3596,6 +4519,14 @@ ${this.pendingWorktreeNotice}
       }
     }
   }
+  #nextCronQueueIndex() {
+    if (this.cronQueue.length === 0) return -1;
+    if (this.todoStopGuardQueuedPromptPriority) return -1;
+    if (!this.todoStopGuard.blocksUnrelatedAutomaticTurns) return 0;
+    return this.cronQueue.findIndex(
+      (item) => this.#cronContinuesTodoStopGuardWorkChain(item)
+    );
+  }
   #getLoopTickResolver() {
     const root = this.config.getWorkingDir();
     if (!this.loopTickResolver || this.loopTickResolverRoot !== root) {
@@ -3635,6 +4566,9 @@ ${this.pendingWorktreeNotice}
       async () => {
         const ac = new AbortController();
         this.cronAbortController = ac;
+        this.#prepareTodoStopGuardForAutomaticTurn(
+          this.#cronContinuesTodoStopGuardWorkChain(item)
+        );
         const promptId = this.config.getSessionId() + "########cron" + Date.now();
         let cronHadError = false;
         await withInteractionSpan(
@@ -3708,7 +4642,10 @@ ${this.pendingWorktreeNotice}
               const toolLoopState = createDaemonToolLoopState();
               while (nextMessage !== null) {
                 turnCount++;
-                if (ac.signal.aborted) return;
+                if (ac.signal.aborted) {
+                  this.todoStopGuard.suspend();
+                  return;
+                }
                 const functionCalls = [];
                 const preparationTracker = new ToolCallPreparationTracker(
                   this.toolCallEmitter
@@ -3721,6 +4658,7 @@ ${this.pendingWorktreeNotice}
                   ac.signal
                 );
                 if (!sendResult.responseStream) {
+                  this.todoStopGuard.suspend();
                   this.#preserveUnsentMessageHistory(
                     nextMessage,
                     sendResult.stopReason === "cancelled"
@@ -3741,7 +4679,10 @@ ${this.pendingWorktreeNotice}
                 let streamFailed = false;
                 try {
                   for await (const resp of responseStream) {
-                    if (ac.signal.aborted) return;
+                    if (ac.signal.aborted) {
+                      this.todoStopGuard.suspend();
+                      return;
+                    }
                     if (resp.type === "chunk" /* CHUNK */ && resp.value.candidates && resp.value.candidates.length > 0) {
                       const candidate = resp.value.candidates[0];
                       for (const part of candidate.content?.parts ?? []) {
@@ -3809,21 +4750,40 @@ ${this.pendingWorktreeNotice}
                     toolLoopState
                   );
                   if (toolRun.stopAfterPermissionCancel) {
+                    this.todoStopGuard.suspend();
                     await this.#preserveStoppedToolRun(toolRun, ac.signal);
                     return;
                   }
-                  nextMessage = await this.#buildNextMessageAfterToolRun(
+                  const nextAfterTools = await this.#buildNextMessageAfterToolRun(
                     toolRun,
                     ac.signal
                   );
+                  nextMessage = nextAfterTools.message;
                   if (toolRun.loopDetected) {
+                    this.todoStopGuard.suspend();
                     await this.#preserveStoppedToolRun(toolRun, ac.signal);
                     return;
                   }
                 }
               }
+              if (this.todoStopGuard.needsStopInspection) {
+                const guardStop = await this.#handleStopHookLoop(
+                  ac,
+                  promptId,
+                  false,
+                  void 0,
+                  false
+                );
+                if (guardStop.stopReason === "max_tokens") {
+                  this.#stopCronAfterTokenLimit();
+                }
+              }
             } catch (error) {
-              if (ac.signal.aborted) return;
+              if (ac.signal.aborted) {
+                this.todoStopGuard.suspend();
+                return;
+              }
+              this.todoStopGuard.pauseForTrustedRetry();
               cronHadError = true;
               debugLogger6.error("Error processing cron prompt:", error);
               const msg = error instanceof Error ? error.message : String(error);
@@ -3849,6 +4809,7 @@ ${this.pendingWorktreeNotice}
     );
   }
   #stopCronAfterTokenLimit() {
+    this.todoStopGuard.suspend();
     this.cronDisabledByTokenLimit = true;
     this.cronQueue = [];
     if (!this.config.isCronEnabled()) return;
@@ -3920,9 +4881,28 @@ ${this.pendingWorktreeNotice}
   }
   #enqueueBackgroundNotification(item) {
     while (this.notificationQueue.length >= MAX_NOTIFICATION_QUEUE) {
-      const evicted = this.notificationQueue.shift();
+      let evictedIndex = 0;
+      if (this.todoStopGuard.blocksUnrelatedAutomaticTurns || this.todoStopGuardQueuedPromptPriority) {
+        const incomingIsRelated = this.#notificationContinuesTodoStopGuardWorkChain(item);
+        evictedIndex = this.notificationQueue.findIndex(
+          (queued) => !this.#notificationContinuesTodoStopGuardWorkChain(queued)
+        );
+        if (evictedIndex < 0 && !incomingIsRelated) {
+          debugLogger6.warn(
+            `Notification queue overflow: dropping unrelated task=${item.taskId} kind=${item.kind} while automatic work is deferred`
+          );
+          return;
+        }
+        if (evictedIndex < 0) {
+          debugLogger6.warn(
+            `Notification queue overflow: dropping related task=${item.taskId} kind=${item.kind} because all queued items are related`
+          );
+          return;
+        }
+      }
+      const [evicted] = this.notificationQueue.splice(evictedIndex, 1);
       debugLogger6.warn(
-        `Notification queue overflow: evicting task=${evicted.taskId} kind=${evicted.kind}`
+        `Notification queue overflow: evicting task=${evicted?.taskId ?? "unknown"} kind=${evicted?.kind ?? "unknown"}`
       );
     }
     this.notificationQueue.push(item);
@@ -3935,17 +4915,21 @@ ${this.pendingWorktreeNotice}
       return;
     }
     if (this.notificationQueue.length === 0) return;
+    if (this.#nextNotificationQueueIndex() < 0) return;
     this.notificationProcessing = true;
     let resolveCompletion;
-    this.notificationCompletion = new Promise((resolve4) => {
-      resolveCompletion = resolve4;
+    this.notificationCompletion = new Promise((resolve5) => {
+      resolveCompletion = resolve5;
     });
     try {
       while (this.notificationQueue.length > 0) {
         if (this.pendingPrompt || this.cronProcessing || this.cronAbortController) {
           break;
         }
-        const item = this.notificationQueue.shift();
+        const nextIndex = this.#nextNotificationQueueIndex();
+        if (nextIndex < 0) break;
+        const [item] = this.notificationQueue.splice(nextIndex, 1);
+        if (!item) break;
         await sessionIdContext.run(
           this.config.getSessionId(),
           () => this.#executeBackgroundNotificationPromptInner(item)
@@ -3961,6 +4945,14 @@ ${this.pendingWorktreeNotice}
       }
     }
   }
+  #nextNotificationQueueIndex() {
+    if (this.notificationQueue.length === 0) return -1;
+    if (this.todoStopGuardQueuedPromptPriority) return -1;
+    if (!this.todoStopGuard.blocksUnrelatedAutomaticTurns) return 0;
+    return this.notificationQueue.findIndex(
+      (item) => this.#notificationContinuesTodoStopGuardWorkChain(item)
+    );
+  }
   async #executeBackgroundNotificationPromptInner(item) {
     return Storage.runWithRuntimeBaseDir(
       this.runtimeBaseDir,
@@ -3968,6 +4960,9 @@ ${this.pendingWorktreeNotice}
       async () => {
         const ac = new AbortController();
         this.notificationAbortController = ac;
+        this.#prepareTodoStopGuardForAutomaticTurn(
+          this.#notificationContinuesTodoStopGuardWorkChain(item)
+        );
         const promptId = this.config.getSessionId() + "########notification" + Date.now();
         try {
           await this.#emitBackgroundNotificationDisplay(item);
@@ -3981,6 +4976,7 @@ ${this.pendingWorktreeNotice}
           const toolLoopState = createDaemonToolLoopState();
           while (nextMessage !== null) {
             if (ac.signal.aborted) {
+              this.todoStopGuard.suspend();
               await this.#emitBackgroundNotificationEndTurn("cancelled");
               return;
             }
@@ -3997,6 +4993,7 @@ ${this.pendingWorktreeNotice}
               ac.signal
             );
             if (!sendResult.responseStream) {
+              this.todoStopGuard.suspend();
               this.#preserveUnsentMessageHistory(
                 nextMessage,
                 sendResult.stopReason === "cancelled"
@@ -4015,6 +5012,7 @@ ${this.pendingWorktreeNotice}
             try {
               for await (const resp of responseStream) {
                 if (ac.signal.aborted) {
+                  this.todoStopGuard.suspend();
                   await this.#emitBackgroundNotificationEndTurn("cancelled");
                   return;
                 }
@@ -4094,15 +5092,18 @@ ${this.pendingWorktreeNotice}
                 toolLoopState
               );
               if (toolRun.stopAfterPermissionCancel) {
+                this.todoStopGuard.suspend();
                 await this.#preserveStoppedToolRun(toolRun, ac.signal);
                 await this.#emitBackgroundNotificationEndTurn("end_turn");
                 return;
               }
-              nextMessage = await this.#buildNextMessageAfterToolRun(
+              const nextAfterTools = await this.#buildNextMessageAfterToolRun(
                 toolRun,
                 ac.signal
               );
+              nextMessage = nextAfterTools.message;
               if (toolRun.loopDetected) {
+                this.todoStopGuard.suspend();
                 await this.#preserveStoppedToolRun(toolRun, ac.signal);
                 await this.#emitBackgroundNotificationEndTurn("end_turn");
                 return;
@@ -4112,12 +5113,24 @@ ${this.pendingWorktreeNotice}
           if (this.messageRewriter) {
             await this.messageRewriter.waitForPendingRewrites();
           }
-          await this.#emitBackgroundNotificationEndTurn("end_turn");
+          let stopReason = "end_turn";
+          if (this.todoStopGuard.needsStopInspection) {
+            stopReason = (await this.#handleStopHookLoop(
+              ac,
+              promptId,
+              false,
+              void 0,
+              false
+            )).stopReason;
+          }
+          await this.#emitBackgroundNotificationEndTurn(stopReason);
         } catch (error) {
           if (ac.signal.aborted) {
+            this.todoStopGuard.suspend();
             await this.#emitBackgroundNotificationEndTurn("cancelled");
             return;
           }
+          this.todoStopGuard.pauseForTrustedRetry();
           debugLogger6.error("Error processing background notification:", error);
           const msg = error instanceof Error ? error.message : String(error);
           try {
@@ -4267,6 +5280,9 @@ ${this.pendingWorktreeNotice}
       );
     }
     this.config.setApprovalMode(approvalMode);
+    if (approvalMode === "plan" /* PLAN */) {
+      this.clearTodoStopGuardTrust();
+    }
     void this.client.extNotification("qwen/notify/session/mode-update", {
       v: 1,
       sessionId: this.sessionId,
@@ -4284,7 +5300,17 @@ ${this.pendingWorktreeNotice}
     if (!rawModelId) {
       throw RequestError.invalidParams(void 0, "modelId cannot be empty");
     }
-    const parsed = parseAcpModelOption(rawModelId);
+    const resolvedRoute = resolveAcpModelOption(
+      rawModelId,
+      this.config.getAllConfiguredModels()
+    );
+    if (!resolvedRoute && rawModelId.startsWith(ACP_ROUTE_ID_PREFIX)) {
+      throw RequestError.invalidParams(
+        void 0,
+        `Unknown or stale model route: "${rawModelId}"`
+      );
+    }
+    const parsed = resolvedRoute ?? parseAcpModelOption(rawModelId);
     const previousAuthType = this.config.getAuthType?.();
     const selectedAuthType = parsed.authType ?? previousAuthType;
     if (!selectedAuthType) {
@@ -4293,29 +5319,49 @@ ${this.pendingWorktreeNotice}
         `authType cannot be determined for modelId "${parsed.modelId}"`
       );
     }
+    const requireCachedCredentials = selectedAuthType !== previousAuthType && selectedAuthType === "qwen-oauth" /* QWEN_OAUTH */;
+    const switchOptions = resolvedRoute?.baseUrl !== void 0 || requireCachedCredentials ? {
+      ...resolvedRoute?.baseUrl !== void 0 ? { baseUrl: resolvedRoute.baseUrl } : {},
+      ...requireCachedCredentials ? { requireCachedCredentials: true } : {}
+    } : void 0;
     await this.config.switchModel(
       selectedAuthType,
       parsed.modelId,
-      selectedAuthType !== previousAuthType && selectedAuthType === "qwen-oauth" /* QWEN_OAUTH */ ? { requireCachedCredentials: true } : void 0
+      switchOptions
     );
     const after = this.config.getContentGeneratorConfig?.();
     const effectiveAuthType = after?.authType ?? selectedAuthType;
     const effectiveModelId = after?.model ?? parsed.modelId;
+    const activeRuntimeSnapshot = this.config.getActiveRuntimeModelSnapshot?.();
+    const currentAcpModelId = getCurrentAcpModelId(
+      buildAcpModelOptions(this.config.getAllConfiguredModels()),
+      activeRuntimeSnapshot?.id ?? effectiveModelId,
+      activeRuntimeSnapshot?.authType ?? effectiveAuthType,
+      activeRuntimeSnapshot ? void 0 : resolvedRoute ? resolvedRoute.registryBaseUrl : this.config.getCurrentModelRegistryBaseUrl?.()
+    );
     void this.client.extNotification("qwen/notify/session/model-update", {
       v: 1,
       sessionId: this.sessionId,
-      currentModelId: effectiveModelId
+      currentModelId: currentAcpModelId
     }).catch((error) => {
       debugLogger6.debug("model-update extNotification failed", error);
     });
     if (options.persistDefault ?? true) {
       const persistScope = getPersistScopeForModelSelection(this.settings);
-      this.settings.setValue(persistScope, "model.name", parsed.modelId);
-      this.settings.setValue(persistScope, "model.baseUrl", "");
+      this.settings.setValue(
+        persistScope,
+        "model.name",
+        resolvedRoute?.isRuntime ? resolvedRoute.modelId : effectiveModelId
+      );
+      this.settings.setValue(
+        persistScope,
+        "model.baseUrl",
+        resolvedRoute && !resolvedRoute.isRuntime ? resolvedRoute.baseUrl ?? "" : ""
+      );
       this.settings.setValue(
         persistScope,
         "security.auth.selectedType",
-        selectedAuthType
+        effectiveAuthType
       );
     }
     return {
@@ -4325,7 +5371,7 @@ ${this.pendingWorktreeNotice}
           modelId: effectiveModelId,
           baseUrl: after?.baseUrl ?? "(default)",
           apiKey: maskApiKeyForDisplay(after?.apiKey),
-          isRuntime: rawModelId.startsWith("$runtime|")
+          isRuntime: resolvedRoute?.isRuntime ?? rawModelId.startsWith("$runtime|")
         }
       }
     };
@@ -4334,33 +5380,29 @@ ${this.pendingWorktreeNotice}
    * Sends a current_mode_update notification to the client.
    * Called after the agent switches modes (e.g., from exit_plan_mode tool).
    */
-  async sendCurrentModeUpdateNotification(outcome) {
-    let newModeId;
-    switch (outcome) {
-      case "proceed_always" /* ProceedAlways */:
-        newModeId = "auto-edit";
-        break;
-      case "restore_previous" /* RestorePrevious */:
-        newModeId = this.config.getApprovalMode();
-        break;
-      case "proceed_once" /* ProceedOnce */:
-      default:
-        newModeId = "default";
-        break;
-    }
+  async sendCurrentModeUpdateNotification() {
+    const newModeId = this.config.getApprovalMode();
     const update = {
       sessionUpdate: "current_mode_update",
       currentModeId: newModeId
     };
-    await this.sendUpdate(update);
-    void this.client.extNotification("qwen/notify/session/mode-update", {
-      v: 1,
-      sessionId: this.sessionId,
-      currentModeId: newModeId,
-      legacyFrameSent: true
-    }).catch((error) => {
+    let legacyFrameSent = false;
+    try {
+      await this.sendUpdate(update);
+      legacyFrameSent = true;
+    } catch (error) {
+      debugLogger6.debug("current_mode_update notification failed", error);
+    }
+    try {
+      await this.client.extNotification("qwen/notify/session/mode-update", {
+        v: 1,
+        sessionId: this.sessionId,
+        currentModeId: newModeId,
+        legacyFrameSent
+      });
+    } catch (error) {
       debugLogger6.debug("mode-update extNotification failed", error);
-    });
+    }
   }
   /**
    * Execute a batch of model-returned tool calls, running Agent calls
@@ -4914,6 +5956,7 @@ ${this.pendingWorktreeNotice}
           );
         }
         const isTodoWriteTool = tool.name === ToolNames.TODO_WRITE;
+        const isTrustedTodoWriteTool = isTodoWriteTool && tool.kind === "think" /* Think */ && tool.constructor.name === "TodoWriteTool";
         const isAgentTool = tool.name === ToolNames.AGENT;
         const isExitPlanModeTool = tool.name === ToolNames.EXIT_PLAN_MODE;
         const isEnterPlanModeTool = tool.name === ToolNames.ENTER_PLAN_MODE;
@@ -4968,7 +6011,13 @@ ${this.pendingWorktreeNotice}
             toolName,
             toolParams
           );
-          const { finalPermission, pmForcedAsk, pmCtx, denyMessage } = flowResult;
+          const {
+            finalPermission,
+            pmForcedAsk,
+            pmCtx,
+            denyMessage,
+            requiresUserInteraction
+          } = flowResult;
           const isPlanMode = approvalMode === "plan" /* PLAN */;
           if (finalPermission === "deny") {
             return earlyErrorResponse(
@@ -4993,7 +6042,7 @@ ${this.pendingWorktreeNotice}
             );
           }
           let wasAutoModeDenialFallback = false;
-          if (!autoModeAllowed && shouldRunAutoModeForCall(approvalMode, toolName)) {
+          if (!autoModeAllowed && !requiresUserInteraction && shouldRunAutoModeForCall(approvalMode, toolName)) {
             const denialState = this.config.getAutoModeDenialState();
             const fallback = shouldFallback(denialState);
             const messages = this.config.getGeminiClient?.()?.getHistoryTail(MAX_TRANSCRIPT_MESSAGES, false) ?? [];
@@ -5066,7 +6115,12 @@ ${this.pendingWorktreeNotice}
               this.config.setAutoModeDenialState(after);
             }
           }, "recordAutoModeFallbackResolution");
-          if (!autoModeAllowed && needsConfirmation(confirmationPermission, approvalMode, toolName)) {
+          if (!autoModeAllowed && needsConfirmation(
+            confirmationPermission,
+            approvalMode,
+            toolName,
+            requiresUserInteraction
+          )) {
             confirmationDetails = await invocation.getConfirmationDetails(abortSignal);
             injectPermissionRulesIfMissing(confirmationDetails, pmCtx);
             if (isPlanModeBlocked(
@@ -5093,7 +6147,7 @@ ${this.pendingWorktreeNotice}
                 args,
                 String(approvalMode)
               );
-              if (hookResult.hasDecision) {
+              if (hookResult.hasDecision && (!hookResult.shouldAllow || !requiresUserInteraction)) {
                 hookHandled = true;
                 if (hookResult.shouldAllow) {
                   if (hookResult.updatedInput) {
@@ -5116,7 +6170,7 @@ ${this.pendingWorktreeNotice}
                 }
               }
             }
-            if (approvalMode === "auto-edit" /* AUTO_EDIT */ && (confirmationDetails.type === "edit" || confirmationDetails.type === "info")) {
+            if (!requiresUserInteraction && approvalMode === "auto-edit" /* AUTO_EDIT */ && (confirmationDetails.type === "edit" || confirmationDetails.type === "info")) {
             } else if (!hookHandled) {
               didRequestPermission = true;
               const content = buildPermissionRequestContent(confirmationDetails);
@@ -5184,12 +6238,11 @@ ${this.pendingWorktreeNotice}
                   );
                 }
                 onStopAfterPermissionCancel?.();
+                const permissionFailureMessage = isExitPlanModeTool ? "The host could not present plan-exit approval. Plan mode remains active; use the host mode selector or /plan exit to leave plan mode." : `Permission request failed for "${toolName}": ${this.#formatError(
+                  error
+                )}`;
                 return earlyErrorResponse(
-                  new Error(
-                    `Permission request failed for "${toolName}": ${this.#formatError(
-                      error
-                    )}`
-                  ),
+                  new Error(permissionFailureMessage),
                   toolName,
                   { stopAfterPermissionCancel: true }
                 );
@@ -5218,11 +6271,8 @@ ${this.pendingWorktreeNotice}
                   { answers: output.answers }
                 );
               }
-              if (isExitPlanModeTool && outcome !== "cancel" /* Cancel */) {
-                await this.sendCurrentModeUpdateNotification(outcome);
-              }
               if (confirmationDetails.type === "edit" && outcome === "proceed_always" /* ProceedAlways */) {
-                await this.sendCurrentModeUpdateNotification(outcome);
+                await this.sendCurrentModeUpdateNotification();
               }
               switch (outcome) {
                 case "cancel" /* Cancel */:
@@ -5342,11 +6392,11 @@ ${this.pendingWorktreeNotice}
             throw execError;
           }
           cleanupAgentToolResources();
-          if ((isEnterPlanModeTool || isExitPlanModeTool) && !didRequestPermission && !toolResult.error && this.config.getApprovalMode() !== approvalMode) {
-            await this.sendUpdate({
-              sessionUpdate: "current_mode_update",
-              currentModeId: this.config.getApprovalMode()
-            });
+          if ((isEnterPlanModeTool || isExitPlanModeTool) && !toolResult.error && this.config.getApprovalMode() !== approvalMode) {
+            await this.sendCurrentModeUpdateNotification();
+            if (this.config.getApprovalMode() === "plan" /* PLAN */) {
+              this.#clearTodoStopGuardTrustAndDrainAutomaticQueues();
+            }
           }
           const responseParts = toolResult.error ? convertToFunctionErrorResponse(
             toolName,
@@ -5361,6 +6411,13 @@ ${this.pendingWorktreeNotice}
           const status = aborted ? "cancelled" : toolResult.error ? "error" : "success";
           const succeeded = status === "success";
           const responseError = toolResult.error ? new Error(toolResult.error.message) : aborted ? new Error("Tool execution was cancelled") : void 0;
+          if (isTrustedTodoWriteTool && !toolResult.error) {
+            this.todoStopGuard.observeTodoWrite(
+              toolResult.returnDisplay,
+              this.config.getApprovalMode() !== "plan" /* PLAN */
+            );
+            if (aborted) this.todoStopGuard.suspend();
+          }
           if (hooksEnabledForTool && messageBusForTool && !toolResult.error && !aborted && !nestedPermissionCancelled) {
             const toolResponse = {
               llmContent: toolResult.llmContent,
@@ -5381,6 +6438,7 @@ ${this.pendingWorktreeNotice}
               debugLogger6.info(
                 `PostToolUse hook requested stop for ${toolName}: ${stopMessage}`
               );
+              this.todoStopGuard.suspend();
               return earlyErrorResponse(new Error(stopMessage), toolName);
             }
             if (postHookResult.additionalContext) {
@@ -5566,7 +6624,7 @@ ${this.pendingWorktreeNotice}
       }
     }
     if (hasActiveGoalStatus) {
-      this.#installGoalTerminalObserver();
+      this.installGoalTerminalObserver();
     }
   }
   /**
@@ -5585,11 +6643,15 @@ ${this.pendingWorktreeNotice}
    * @param originalPrompt The original prompt blocks
    * @returns Parts to use for the prompt, or null if command was handled without needing model interaction
    */
-  async #processSlashCommandResult(result, originalPrompt) {
+  async #processSlashCommandResult(result, originalPrompt, abortSignal, onFullTurnModel) {
     this.#emitGoalStatusItems(result);
     switch (result.type) {
       case "submit_prompt":
-        return normalizePartList(result.content);
+        return this.#applyBridgeConversionsIfNeeded(
+          normalizePartList(result.content),
+          abortSignal,
+          onFullTurnModel
+        );
       case "message": {
         if (result.messageType === "error") {
           throw new Error(result.content || "Slash command failed.");
@@ -5632,11 +6694,10 @@ ${this.pendingWorktreeNotice}
         throw new Error(unsupportedError);
       }
       case "no_command":
-        return this.#resolvePrompt(
-          originalPrompt,
-          new AbortController().signal,
-          { promptLast: true }
-        );
+        return this.#resolvePrompt(originalPrompt, abortSignal, {
+          promptLast: true,
+          onFullTurnModel
+        });
       default: {
         const _exhaustive = result;
         const unknownError = `Unknown slash command result type: ${_exhaustive.type}`;
@@ -5649,6 +6710,7 @@ ${this.pendingWorktreeNotice}
     const embeddedContext = [];
     const extensionMentions = /* @__PURE__ */ new Map();
     const mcpServerMentions = /* @__PURE__ */ new Map();
+    const textPathSpecsToRead = /* @__PURE__ */ new Set();
     const preserveUnsupportedImageForBridge = shouldRunVisionBridge(
       this.config
     );
@@ -5657,6 +6719,16 @@ ${this.pendingWorktreeNotice}
         case "text":
           collectExtensionMentionRefs(part.text, extensionMentions);
           collectMcpServerMentionRefs(part.text, mcpServerMentions);
+          for (const pathSpec of extractAtPathCommands(part.text)) {
+            const resolved = path3.resolve(
+              this.config.getProjectRoot(),
+              pathSpec
+            );
+            const filteringOptions = this.config.getFileFilteringOptions();
+            if (path3.isAbsolute(pathSpec) && getSpecificMimeType(resolved)?.startsWith("image/") && isExistingFile(resolved) && this.config.getWorkspaceContext().isPathWithinWorkspace(pathSpec) && !this.config.getFileService().shouldIgnoreFile(pathSpec, filteringOptions)) {
+              textPathSpecsToRead.add(pathSpec);
+            }
+          }
           return { text: part.text };
         case "image":
           if (preserveUnsupportedImageForBridge) {
@@ -5704,23 +6776,31 @@ ${this.pendingWorktreeNotice}
       }
     });
     const atPathCommandParts = parts.filter((part) => "fileData" in part);
+    const pathSpecsToRead = [
+      .../* @__PURE__ */ new Set([
+        ...textPathSpecsToRead,
+        ...atPathCommandParts.map((part) => part.fileData.fileUri)
+      ])
+    ];
     const extensionParts = await this.#resolveExtensionMentionParts(
       extensionMentions,
       abortSignal
     );
     const mcpServerParts = this.#resolveMcpServerMentionParts(mcpServerMentions);
-    if (atPathCommandParts.length === 0 && embeddedContext.length === 0 && extensionParts.length === 0 && mcpServerParts.length === 0) {
-      return this.#applyBridgeConversionsIfNeeded(parts, abortSignal);
+    if (pathSpecsToRead.length === 0 && embeddedContext.length === 0 && extensionParts.length === 0 && mcpServerParts.length === 0) {
+      return this.#applyBridgeConversionsIfNeeded(
+        parts,
+        abortSignal,
+        options.onFullTurnModel
+      );
     }
-    if (atPathCommandParts.length === 0 && embeddedContext.length === 0) {
+    if (pathSpecsToRead.length === 0 && embeddedContext.length === 0) {
       return this.#applyBridgeConversionsIfNeeded(
         [...parts, ...extensionParts, ...mcpServerParts],
-        abortSignal
+        abortSignal,
+        options.onFullTurnModel
       );
     }
-    const pathSpecsToRead = atPathCommandParts.map(
-      (part) => part.fileData.fileUri
-    );
     let initialQueryText = "";
     for (let i = 0; i < parts.length; i++) {
       const chunk = parts[i];
@@ -5776,10 +6856,11 @@ ${contextPart.text}`
     const processedQueryParts = options.promptLast ? [...referenceParts, promptPart] : [promptPart, ...referenceParts];
     return this.#applyBridgeConversionsIfNeeded(
       processedQueryParts,
-      abortSignal
+      abortSignal,
+      options.onFullTurnModel
     );
   }
-  async #applyBridgeConversionsIfNeeded(originalParts, abortSignal) {
+  async #applyBridgeConversionsIfNeeded(originalParts, abortSignal, onFullTurnModel) {
     const parts = await this.#applyVoiceBridgeIfNeeded(
       originalParts,
       abortSignal
@@ -5787,6 +6868,28 @@ ${contextPart.text}`
     if (!hasImageParts(parts) || !shouldRunVisionBridge(this.config)) {
       return parts;
     }
+    const fullTurnModel = this.config.getDefaultVisionBridgeModel();
+    if (onFullTurnModel && fullTurnModel?.agentCapable) {
+      const fullTurnParts = parts.map((part) => clampInlineMediaPart(part));
+      if (!hasImageParts(fullTurnParts)) {
+        return fullTurnParts;
+      }
+      const selected = onFullTurnModel(
+        getFullTurnVisionModelSelector(fullTurnModel)
+      );
+      if (selected) {
+        try {
+          await this.messageEmitter.emitAgentMessage(
+            formatFullTurnVisionNotice(fullTurnModel)
+          );
+        } catch (error) {
+          debugLogger6.debug(
+            `full-turn vision: failed to emit notice; continuing error=${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      return fullTurnParts;
+    }
     let bridgeResult;
     try {
       debugLogger6.debug("vision bridge: gate matched, running conversion");
@@ -6126,6 +7229,56 @@ var POSIX_TMP_LOCAL_READ_ROOT = "/tmp";
 var BTW_CHILD_TIMEOUT_MS = 55e3;
 var MCP_OAUTH_START_TIMEOUT_MS = 3e4;
 var WORKSPACE_MEMORY_REMEMBER_CHILD_TIMEOUT_MS = 295e3;
+function createAcpSessionStartProfiler(span) {
+  let failedStage;
+  const setAttribute = /* @__PURE__ */ __name((name, value) => {
+    try {
+      span?.setAttribute(name, value);
+    } catch {
+    }
+  }, "setAttribute");
+  const recordStage = /* @__PURE__ */ __name((stage, start) => {
+    const durationMs = Math.round((performance.now() - start) * 100) / 100;
+    if (Number.isFinite(durationMs) && durationMs >= 0) {
+      setAttribute(`qwen-code.daemon.session_start.${stage}_ms`, durationMs);
+    }
+  }, "recordStage");
+  const recordFailure = /* @__PURE__ */ __name((stage) => {
+    if (failedStage !== void 0) return;
+    failedStage = stage;
+    setAttribute("qwen-code.daemon.session_start.failed_stage", stage);
+  }, "recordFailure");
+  return {
+    async time(stage, fn) {
+      if (!span) return await fn();
+      const start = performance.now();
+      try {
+        return await fn();
+      } catch (error) {
+        recordFailure(stage);
+        throw error;
+      } finally {
+        recordStage(stage, start);
+      }
+    },
+    timeSync(stage, fn) {
+      if (!span) return fn();
+      const start = performance.now();
+      try {
+        return fn();
+      } catch (error) {
+        recordFailure(stage);
+        throw error;
+      } finally {
+        recordStage(stage, start);
+      }
+    },
+    setSessionId(sessionId) {
+      setAttribute("session.id", sessionId);
+    }
+  };
+}
+__name(createAcpSessionStartProfiler, "createAcpSessionStartProfiler");
 function workspaceMemoryErrorData(code, diagnostics) {
   return {
     errorKind: code,
@@ -6206,6 +7359,40 @@ function isBulkLoadReplayRequest(params) {
   return meta?.[LOAD_REPLAY_MODE_META_KEY] === LOAD_REPLAY_BULK_MODE;
 }
 __name(isBulkLoadReplayRequest, "isBulkLoadReplayRequest");
+function getLoadReplayPageSize(params) {
+  const meta = isObjectRecord(params._meta) ? params._meta : void 0;
+  const value = meta?.[LOAD_REPLAY_PAGE_SIZE_META_KEY];
+  if (value === void 0) return void 0;
+  if (!Number.isSafeInteger(value) || value < 1 || value > SESSION_TRANSCRIPT_MAX_LIMIT) {
+    throw RequestError.invalidParams(
+      void 0,
+      `Invalid load replay page size; expected 1..${SESSION_TRANSCRIPT_MAX_LIMIT}`
+    );
+  }
+  return value;
+}
+__name(getLoadReplayPageSize, "getLoadReplayPageSize");
+function isHistoryTurnStart(record) {
+  return record.type === "user" && record.subtype !== "mid_turn_user_message";
+}
+__name(isHistoryTurnStart, "isHistoryTurnStart");
+function selectRecentHistoryRecords(records, pageSize) {
+  if (pageSize === void 0 || records.length <= pageSize) {
+    return { records, hasMore: false };
+  }
+  let start = records.length - pageSize;
+  for (let i = start; i < records.length; i++) {
+    if (isHistoryTurnStart(records[i])) {
+      start = i;
+      break;
+    }
+  }
+  while (start > 0 && !isHistoryTurnStart(records[start])) {
+    start--;
+  }
+  return { records: records.slice(start), hasMore: start > 0 };
+}
+__name(selectRecentHistoryRecords, "selectRecentHistoryRecords");
 function createHiddenWorkspaceMemoryConfig(config) {
   return new Proxy(config, {
     get(target, prop) {
@@ -7604,16 +8791,21 @@ __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,
-    // 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
-  });
+  beginAcpBootstrapConfigProfiling();
+  try {
+    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,
+      // 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
+    });
+  } finally {
+    endAcpBootstrapConfigProfiling();
+  }
   const eventLoopMonitor = startEventLoopLagMonitor({
     onNewMaxStall: /* @__PURE__ */ __name((maxMs) => {
       console.error(`[perf] acp agent event loop stall: max=${maxMs}ms`);
@@ -7621,6 +8813,7 @@ async function runAcpAgent(config, settings, argv) {
   });
   let agentInstance;
   let connection;
+  markAcpStartup("transportSetupStart");
   try {
     const stdout = Writable.toWeb(process.stdout);
     const stdin = Readable.toWeb(process.stdin);
@@ -7633,6 +8826,7 @@ async function runAcpAgent(config, settings, argv) {
       agentInstance = new QwenAgent(config, settings, argv, conn);
       return agentInstance;
     }, stream);
+    markAcpStartup("transportSetupEnd");
   } catch (err) {
     eventLoopMonitor.dispose();
     throw err;
@@ -8212,10 +9406,11 @@ var QwenAgent = class {
     }
   }
   async initialize(args) {
+    markAcpStartup("initializeHandlerStart");
     this.clientCapabilities = args.clientCapabilities;
     const authMethods = buildAuthMethods();
-    const version = "0.19.11";
-    return {
+    const version = "0.19.12-preview.0";
+    const response = {
       protocolVersion: PROTOCOL_VERSION,
       agentInfo: {
         name: "qwen-code",
@@ -8243,6 +9438,22 @@ var QwenAgent = class {
         }
       }
     };
+    markAcpStartup("initializeHandlerEnd");
+    markAcpStartup("responseBuilt");
+    let startupProfile;
+    try {
+      startupProfile = buildAndFreezeAcpStartupProfile();
+    } catch {
+      startupProfile = void 0;
+    }
+    const requestedProfile = args._meta?.[CHANNEL_STARTUP_PROFILE_META_KEY];
+    const profileRequested = requestedProfile !== null && typeof requestedProfile === "object" && !Array.isArray(requestedProfile) && requestedProfile["v"] === CHANNEL_STARTUP_PROFILE_VERSION;
+    return profileRequested && startupProfile ? {
+      ...response,
+      _meta: {
+        [CHANNEL_STARTUP_PROFILE_META_KEY]: startupProfile
+      }
+    } : response;
   }
   async authenticate({ methodId }) {
     const method = external_exports.nativeEnum(AuthType).parse(methodId);
@@ -8270,25 +9481,42 @@ var QwenAgent = class {
       }
     }
   }
-  async newSession({
-    cwd,
-    mcpServers
-  }) {
-    const settings = loadSettingsCached(cwd);
-    this.settings = settings;
-    const config = await this.newSessionConfig(cwd, mcpServers, settings);
-    await this.ensureAuthenticated(config);
-    this.setupFileSystem(config);
-    const session = await this.createAndStoreSession(config, settings);
-    const availableModels = this.buildAvailableModels(config);
-    const modesData = this.buildModesData(config);
-    const configOptions = this.buildConfigOptions(config);
-    return {
-      sessionId: session.getId(),
-      models: availableModels,
-      modes: modesData,
-      configOptions
-    };
+  async newSession(params) {
+    const { cwd, mcpServers } = params;
+    const parentContext = extractDaemonTraceContext(params);
+    return await withDaemonSpan(
+      "qwen-code.daemon.session_start",
+      { "qwen-code.daemon.operation": "acp_session_new" },
+      async (span) => {
+        const profiler = createAcpSessionStartProfiler(span);
+        const settings = profiler.timeSync(
+          "settings_load",
+          () => loadSettingsCached(cwd)
+        );
+        this.settings = settings;
+        const config = await profiler.time(
+          "config_setup",
+          () => this.newSessionConfig(cwd, mcpServers, settings)
+        );
+        await profiler.time("auth", () => this.ensureAuthenticated(config));
+        profiler.timeSync(
+          "file_system_setup",
+          () => this.setupFileSystem(config)
+        );
+        const session = await profiler.time(
+          "session_register",
+          () => this.createAndStoreSession(config, settings)
+        );
+        profiler.setSessionId(session.getId());
+        return profiler.timeSync("response_build", () => ({
+          sessionId: session.getId(),
+          models: this.buildAvailableModels(config),
+          modes: this.buildModesData(config),
+          configOptions: this.buildConfigOptions(config)
+        }));
+      },
+      parentContext ? { parentContext } : {}
+    );
   }
   async loadSession(params) {
     const settings = loadSettingsCached(params.cwd);
@@ -8319,6 +9547,7 @@ var QwenAgent = class {
     this.setupFileSystem(config);
     const sessionData = config.getResumedSessionData();
     const bulkReplay = isBulkLoadReplayRequest(params);
+    const replayPageSize = bulkReplay ? getLoadReplayPageSize(params) : void 0;
     const session = await this.createAndStoreSession(
       config,
       settings,
@@ -8332,13 +9561,19 @@ var QwenAgent = class {
         let replayUpdates = [];
         if (records) {
           session.primeTurnFromHistory(records);
+          const replayPage = selectRecentHistoryRecords(
+            records,
+            replayPageSize
+          );
           const replayUsage = createReplayCumulativeUsage();
           const replay = await collectHistoryReplayUpdates({
             sessionId: params.sessionId,
             config,
-            records,
+            records: replayPage.records,
             gaps: sessionData?.historyGaps,
             cumulativeUsage: replayUsage,
+            // A resume: the goal restore runs right after this.
+            supersedeUnrestorableGoal: true,
             logger: debugLogger7
           });
           replayUpdates = replay.updates;
@@ -8348,9 +9583,15 @@ var QwenAgent = class {
               v: LOAD_REPLAY_VERSION,
               updates: replayUpdates,
               partial: true,
-              replayError: replay.replayError
+              replayError: replay.replayError,
+              ...replayPage.hasMore ? { hasMore: true } : {}
             };
           }
+          replayEnvelope ??= {
+            v: LOAD_REPLAY_VERSION,
+            updates: replayUpdates,
+            ...replayPage.hasMore ? { hasMore: true } : {}
+          };
         }
         replayEnvelope ??= {
           v: LOAD_REPLAY_VERSION,
@@ -8364,6 +9605,7 @@ var QwenAgent = class {
       }
     }
     await this.#restoreWorktreeOnResume(config, session);
+    this.#restoreGoalOnResume(config, session);
     const modesData = this.buildModesData(config);
     const availableModels = this.buildAvailableModels(config);
     const configOptions = this.buildConfigOptions(config);
@@ -8413,6 +9655,7 @@ var QwenAgent = class {
       { replayHistory: false }
     );
     await this.#restoreWorktreeOnResume(config, session);
+    this.#restoreGoalOnResume(config, session);
     const modesData = this.buildModesData(config);
     const availableModels = this.buildAvailableModels(config);
     const configOptions = this.buildConfigOptions(config);
@@ -8441,6 +9684,48 @@ var QwenAgent = class {
       debugLogger7.warn(`ACP worktree restore failed: ${error}`);
     }
   }
+  /**
+   * Re-registers the `/goal` Stop hook when a resumed transcript ends on an
+   * unsatisfied goal — the daemon counterpart of the TUI's resume restore.
+   * Without this the goal loop silently dies whenever a session is reloaded or
+   * `qwen serve` restarts, even though the transcript still shows it as active.
+   *
+   * The `addItem` bridge that `restoreGoalFromHistory` takes in the TUI is not
+   * used here — the daemon's terminal card goes out over the wire, not into an
+   * Ink history. But restore reaches `unregisterGoalHook` on every path,
+   * including the one where there was nothing to restore, and that clears the
+   * observer the `Session` constructor installed. So it is put back afterwards,
+   * unconditionally: without it a restored goal that later achieves or fails
+   * emits no terminal update and persists no terminal card, and the next reload
+   * revives a goal that already finished.
+   *
+   * Best-effort: a failed restore must not block session load.
+   */
+  #restoreGoalOnResume(config, session) {
+    try {
+      const records = config.getResumedSessionData()?.conversation.messages;
+      if (!records?.length) return;
+      const restored = restoreGoalFromHistory(
+        collectGoalStatusItemsFromRecords(records),
+        config
+      );
+      if (restored.restored) {
+        debugLogger7.info(
+          `ACP goal restored sessionId=${config.getSessionId()} condition=${restored.condition}`
+        );
+      } else if (restored.blockedBy && restored.blockedBy !== "condition-invalid") {
+        writeStderrLineSafe(
+          `qwen: not restoring the active goal for session ${config.getSessionId()} (${restored.blockedBy}).`
+        );
+      }
+    } catch (error) {
+      writeStderrLineSafe(
+        `qwen: goal restore failed for session ${config.getSessionId()}: ${error}`
+      );
+    } finally {
+      session.installGoalTerminalObserver();
+    }
+  }
   async unstable_listSessions(params) {
     const cwd = params.cwd || process.cwd();
     const numericCursor = parseAcpSessionListCursor(params.cursor);
@@ -9298,9 +10583,18 @@ var QwenAgent = class {
       const currentModelId = activeRuntimeSnapshot ? activeRuntimeSnapshot.id : (config.getModel() || "").trim();
       const hasCurrentModel = currentModelId.length > 0;
       const currentAuth = activeRuntimeSnapshot?.authType ?? currentAuthType;
-      const currentAcpModelId = hasCurrentModel && currentAuth ? formatAcpModelId(currentModelId, currentAuth) : currentModelId || void 0;
+      const modelOptions = buildAcpModelOptions(
+        config.getAllConfiguredModels()
+      );
+      const currentAcpModelId = hasCurrentModel ? getCurrentAcpModelId(
+        modelOptions,
+        currentModelId,
+        currentAuth,
+        activeRuntimeSnapshot ? void 0 : config.getCurrentModelRegistryBaseUrl?.()
+      ) : void 0;
       const providers = /* @__PURE__ */ new Map();
-      for (const model of config.getAllConfiguredModels().filter(isMainSelectableModel)) {
+      for (const option of modelOptions) {
+        const { model, effectiveModelId, modelId } = option;
         const authType = String(model.authType);
         let provider = providers.get(authType);
         if (!provider) {
@@ -9313,9 +10607,7 @@ var QwenAgent = class {
           };
           providers.set(authType, provider);
         }
-        const effectiveModelId = model.isRuntimeModel && model.runtimeSnapshotId ? model.runtimeSnapshotId : model.id;
-        const modelId = formatAcpModelId(effectiveModelId, model.authType);
-        const isCurrent = currentAuth === model.authType && hasCurrentModel && (currentModelId === effectiveModelId || currentModelId === model.id || currentAcpModelId === modelId);
+        const isCurrent = currentAuth === model.authType && currentAcpModelId === modelId;
         const providerModel = {
           modelId,
           baseModelId: parseAcpBaseModelId(effectiveModelId),
@@ -10279,6 +11571,25 @@ var QwenAgent = class {
     const cwd = requestedCwd || process.cwd();
     const SESSION_ID_RE = /^[0-9a-fA-F-]{32,36}$/;
     switch (method) {
+      case TODO_STOP_GUARD_QUEUE_RELEASE_METHOD: {
+        const sessionId = params["sessionId"];
+        if (typeof sessionId !== "string" || sessionId.length === 0) {
+          throw RequestError.invalidParams(
+            void 0,
+            "Invalid or missing sessionId"
+          );
+        }
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+          throw RequestError.invalidParams(
+            void 0,
+            `Session not found for id: ${sessionId}`
+          );
+        }
+        return {
+          released: session.releaseTodoStopGuardQueuedPromptWait()
+        };
+      }
       case "qwen/providers/list": {
         return {
           providers: ALL_PROVIDERS.map(
@@ -10516,6 +11827,19 @@ var QwenAgent = class {
             "Invalid transcript cursor"
           );
         }
+        const rawBeforeRecordId = params["beforeRecordId"];
+        if (rawBeforeRecordId !== void 0 && (typeof rawBeforeRecordId !== "string" || rawBeforeRecordId.length === 0)) {
+          throw RequestError.invalidParams(
+            void 0,
+            "Invalid transcript record boundary"
+          );
+        }
+        if (rawCursor !== void 0 && rawBeforeRecordId !== void 0) {
+          throw RequestError.invalidParams(
+            void 0,
+            "Transcript cursor and record boundary are mutually exclusive"
+          );
+        }
         const rawLimit = params["limit"];
         if (rawLimit !== void 0 && (!Number.isSafeInteger(rawLimit) || rawLimit < 1 || rawLimit > SESSION_TRANSCRIPT_MAX_LIMIT)) {
           throw RequestError.invalidParams(
@@ -10529,7 +11853,9 @@ var QwenAgent = class {
             const reader = new SessionTranscriptReader(cwd);
             const page = await reader.readPage(sessionId, {
               ...typeof rawCursor === "string" ? { cursor: rawCursor } : {},
-              ...typeof rawLimit === "number" ? { limit: rawLimit } : {}
+              ...typeof rawBeforeRecordId === "string" ? { beforeRecordId: rawBeforeRecordId } : {},
+              ...typeof rawLimit === "number" ? { limit: rawLimit } : {},
+              maxBytes: SESSION_TRANSCRIPT_MAX_PAGE_BYTES
             });
             const config = await this.getTranscriptReplayConfig(cwd, settings);
             const replay = await replayTranscriptRecordPage({
@@ -10578,6 +11904,14 @@ var QwenAgent = class {
               maxBytes: error.maxBytes
             });
           }
+          if (error instanceof SessionTranscriptPageTooLargeError) {
+            throw new RequestError(-32012, error.message, {
+              errorKind: "transcript_page_too_large",
+              sessionId,
+              pageBytes: error.pageBytes,
+              maxBytes: error.maxBytes
+            });
+          }
           if (error.code === "ENOENT") {
             if (typeof rawCursor === "string") {
               throw new RequestError(
@@ -11222,10 +12556,10 @@ var QwenAgent = class {
           let resolveStarted;
           let rejectStarted;
           let startedTimer;
-          const started = new Promise((resolve4, reject) => {
+          const started = new Promise((resolve5, reject) => {
             resolveStarted = /* @__PURE__ */ __name((value) => {
               clearTimeout(startedTimer);
-              resolve4(value);
+              resolve5(value);
             }, "resolveStarted");
             rejectStarted = /* @__PURE__ */ __name((reason) => {
               clearTimeout(startedTimer);
@@ -11543,6 +12877,7 @@ var QwenAgent = class {
             `Model context refresh failed: ${error instanceof Error ? error.message : String(error)}`
           );
         }
+        session.clearTodoStopGuardTrust();
         return { previousCwd, newCwd: canonicalPath, warnings };
       }
       case SERVE_CONTROL_EXT_METHODS.sessionApprovalMode: {
@@ -11574,6 +12909,9 @@ var QwenAgent = class {
           throw err;
         }
         const current = config.getApprovalMode();
+        if (current === "plan") {
+          session.clearTodoStopGuardTrust();
+        }
         return { previous, current };
       }
       case SERVE_CONTROL_EXT_METHODS.sessionLanguage: {
@@ -11619,8 +12957,7 @@ var QwenAgent = class {
         let outputLanguage = null;
         let refreshed = false;
         if (syncOutputLanguage) {
-          const resolved = resolveOutputLanguage(language);
-          const settingValue = isAutoLanguage(language) ? OUTPUT_LANGUAGE_AUTO : resolved;
+          const settingValue = resolveOutputLanguageOrPreserveAuto(language);
           let fileWriteOk = false;
           try {
             writeOutputLanguageAndRegisterPath(
@@ -11678,7 +13015,7 @@ var QwenAgent = class {
             }
             refreshed = results.length === 0 || failedCount === 0;
           }
-          outputLanguage = fileWriteOk ? resolved : null;
+          outputLanguage = fileWriteOk ? settingValue : null;
         }
         return { language: resolvedLanguage, outputLanguage, refreshed };
       }
@@ -12020,6 +13357,27 @@ ${outputText}
           condition: cleared?.condition
         };
       }
+      case SERVE_CONTROL_EXT_METHODS.sessionGoalGet: {
+        const sessionId = params["sessionId"];
+        if (typeof sessionId !== "string" || sessionId.length === 0) {
+          throw RequestError.invalidParams(
+            void 0,
+            "Invalid or missing sessionId"
+          );
+        }
+        this.sessionOrThrow(sessionId);
+        const active = getActiveGoal(sessionId);
+        return {
+          // Projected field by field: `ActiveGoal` also carries `hookId` and
+          // `tokensAtStart`, which are this process's business.
+          active: active ? {
+            condition: active.condition,
+            iterations: active.iterations,
+            setAt: active.setAt,
+            ...active.lastReason !== void 0 ? { lastReason: active.lastReason } : {}
+          } : null
+        };
+      }
       case SERVE_CONTROL_EXT_METHODS.sessionContinue: {
         const sessionId = params["sessionId"];
         if (typeof sessionId !== "string" || sessionId.length === 0) {
@@ -12816,6 +14174,9 @@ ${outputText}
               if (newMode && APPROVAL_MODES.includes(newMode) && newMode !== config.getApprovalMode()) {
                 try {
                   config.setApprovalMode(newMode);
+                  if (newMode === "plan") {
+                    session.clearTodoStopGuardTrust();
+                  }
                 } catch (err) {
                   debugLogger7.warn(
                     `reload: setApprovalMode failed for session ${id}: ${err}`
@@ -13179,23 +14540,22 @@ ${outputText}
   buildAvailableModels(config) {
     const rawCurrentModelId = (config.getModel() || this.config.getModel() || "").trim();
     const currentAuthType = config.getAuthType();
-    const allConfiguredModels = config.getAllConfiguredModels().filter(isMainSelectableModel);
+    const modelOptions = buildAcpModelOptions(config.getAllConfiguredModels());
     const activeRuntimeSnapshot = config.getActiveRuntimeModelSnapshot?.();
-    const currentModelId = activeRuntimeSnapshot ? formatAcpModelId(
-      activeRuntimeSnapshot.id,
-      activeRuntimeSnapshot.authType
-    ) : this.formatCurrentModelId(rawCurrentModelId, currentAuthType);
-    const mappedAvailableModels = allConfiguredModels.map((model) => {
-      const effectiveModelId = model.isRuntimeModel && model.runtimeSnapshotId ? model.runtimeSnapshotId : model.id;
-      return {
-        modelId: formatAcpModelId(effectiveModelId, model.authType),
-        name: model.label,
-        description: model.description ?? null,
-        _meta: {
-          contextLimit: model.contextWindowSize ?? tokenLimit(model.id)
-        }
-      };
-    });
+    const currentModelId = getCurrentAcpModelId(
+      modelOptions,
+      activeRuntimeSnapshot?.id ?? rawCurrentModelId,
+      activeRuntimeSnapshot?.authType ?? currentAuthType,
+      activeRuntimeSnapshot ? void 0 : config.getCurrentModelRegistryBaseUrl?.()
+    );
+    const mappedAvailableModels = modelOptions.map(({ model, modelId }) => ({
+      modelId,
+      name: model.label,
+      description: model.description ?? null,
+      _meta: {
+        contextLimit: model.contextWindowSize ?? tokenLimit(model.id)
+      }
+    }));
     return {
       currentModelId,
       availableModels: mappedAvailableModels
@@ -13215,14 +14575,16 @@ ${outputText}
   }
   buildConfigOptions(config) {
     const currentApprovalMode = config.getApprovalMode();
-    const allConfiguredModels = config.getAllConfiguredModels().filter(isMainSelectableModel);
+    const modelOptions = buildAcpModelOptions(config.getAllConfiguredModels());
     const rawCurrentModelId = (config.getModel() || "").trim();
     const currentAuthType = config.getAuthType?.();
     const activeRuntimeSnapshot = config.getActiveRuntimeModelSnapshot?.();
-    const currentModelId = activeRuntimeSnapshot ? formatAcpModelId(
-      activeRuntimeSnapshot.id,
-      activeRuntimeSnapshot.authType
-    ) : this.formatCurrentModelId(rawCurrentModelId, currentAuthType);
+    const currentModelId = getCurrentAcpModelId(
+      modelOptions,
+      activeRuntimeSnapshot?.id ?? rawCurrentModelId,
+      activeRuntimeSnapshot?.authType ?? currentAuthType,
+      activeRuntimeSnapshot ? void 0 : config.getCurrentModelRegistryBaseUrl?.()
+    );
     const modeOptions = APPROVAL_MODES.map((mode) => ({
       value: mode,
       name: APPROVAL_MODE_INFO[mode].name,
@@ -13237,14 +14599,11 @@ ${outputText}
       currentValue: currentApprovalMode,
       options: modeOptions
     };
-    const modelOptions = allConfiguredModels.map((model) => {
-      const effectiveModelId = model.isRuntimeModel && model.runtimeSnapshotId ? model.runtimeSnapshotId : model.id;
-      return {
-        value: formatAcpModelId(effectiveModelId, model.authType),
-        name: model.label,
-        description: model.description ?? ""
-      };
-    });
+    const configModelOptions = modelOptions.map(({ model, modelId }) => ({
+      value: modelId,
+      name: model.label,
+      description: model.description ?? ""
+    }));
     const modelConfigOption = {
       id: "model",
       name: "Model",
@@ -13252,19 +14611,11 @@ ${outputText}
       category: "model",
       type: "select",
       currentValue: currentModelId,
-      options: modelOptions
+      options: configModelOptions
     };
     return [modeConfigOption, modelConfigOption];
   }
-  formatCurrentModelId(baseModelId, authType) {
-    if (!baseModelId) return baseModelId;
-    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([
@@ -13297,6 +14648,11 @@ export {
  * Copyright 2025 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
  */
+/**
+ * @license
+ * Copyright 2026 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
 /**
  * @license
  * Copyright 2025 Qwen