@qwen-code/qwen-code 0.19.9 → 0.19.10-nightly.20260716.506ce0a1a

package/chunks/{acpAgent-5FWSOZL5.js → acpAgent-55YDJDNM.js}

@@ -3,7 +3,7 @@
 import {
   classifyApiError,
   prefixMidTurnUserMessageParts
-} from "./chunk-Q4YQW46J.js";
+} from "./chunk-AMRZVQUY.js";
 import {
   EXTENSION_CONTEXT_BUDGET,
   buildExtensionMentionContext,
@@ -12,96 +12,109 @@ import {
   matchMcpServerByRef,
   parseExtensionRef,
   parseMcpServerRef
-} from "./chunk-77XJ3SWN.js";
+} from "./chunk-VDAR6UO2.js";
 import {
   getAvailableCommands,
   handleSlashCommand,
   insertAfterFunctionResponses,
   isSlashCommand,
   normalizePartList
-} from "./chunk-5U27BZ72.js";
+} from "./chunk-FKEGVMPX.js";
+import {
+  collectContextData,
+  formatContextUsageText
+} from "./chunk-UCUUH2JV.js";
 import {
   appEvents,
   buildDisabledSkillNamesProvider,
   loadCliConfig,
   normalizeDisabledToolList
-} from "./chunk-5HOMWMCL.js";
-import "./chunk-5DTTYNB7.js";
-import {
-  collectContextData,
-  formatContextUsageText
-} from "./chunk-D2GFWEXB.js";
+} from "./chunk-BSJAQUFD.js";
 import {
   getCommandSubcommandNames
-} from "./chunk-AURZZYMD.js";
-import "./chunk-JZETEN3Z.js";
+} from "./chunk-ZIVSSTUG.js";
+import "./chunk-N45S36AH.js";
 import {
   getEffectiveSupportedModes
-} from "./chunk-GWLSNBG4.js";
+} from "./chunk-NA3IG6XG.js";
 import "./chunk-4WGODMVR.js";
+import "./chunk-KW7NOTN6.js";
+import "./chunk-OVIV236K.js";
+import "./chunk-5DTTYNB7.js";
+import "./chunk-NHDKSOEY.js";
 import {
   isTerminalGoalStatusKind
 } from "./chunk-7X7TEQNX.js";
-import "./chunk-KW7NOTN6.js";
-import "./chunk-CNEIYWSA.js";
 import "./chunk-HTHUX2T5.js";
-import "./chunk-MXL5UP4X.js";
-import "./chunk-3G7CIHVV.js";
-import "./chunk-VA4KQY6V.js";
-import "./chunk-NHDKSOEY.js";
-import "./chunk-OQ4DRIOA.js";
-import "./chunk-EMDMPBJ4.js";
+import "./chunk-7HWE2W74.js";
+import "./chunk-Z7SVC7PJ.js";
 import "./chunk-YAF2MQZ6.js";
+import "./chunk-Q6TUALBE.js";
 import {
+  GENERATION_MAX_PROMPT_BYTES,
+  GENERATION_TIMEOUT_MS,
   MAX_REMEMBER_CONTENT_BYTES,
+  collectHistoryReplayUpdates,
+  copyCumulativeUsage,
+  createReplayCumulativeUsage,
   createWorkspaceMemoryExtractionErrorLogger,
+  executeGeneration,
   formatWorkspaceMemoryForgetSummary,
   isValidServerName,
+  replayTranscriptRecordPage,
   shouldSuppressRememberErrorDetails,
   workspaceMemoryFailureCode,
   workspaceMemoryFailureDiagnostics
-} from "./chunk-GZRTYZ2R.js";
+} from "./chunk-H3XMJV7T.js";
 import {
   HistoryReplayer,
   MessageEmitter,
   PlanEmitter,
   ToolCallEmitter
-} from "./chunk-N3EMS75V.js";
-import "./chunk-U2NNEY4R.js";
-import "./chunk-Q6I5QHMH.js";
+} from "./chunk-5DEJ4T6C.js";
+import "./chunk-VT5AWJN4.js";
+import "./chunk-MFNKBXYH.js";
 import "./chunk-QHTIBUWB.js";
 import "./chunk-L573Z2QZ.js";
+import {
+  computeCpuPercent
+} from "./chunk-HGT6JR3U.js";
+import "./chunk-RXFQM6FQ.js";
+import "./chunk-G3BIBPI7.js";
+import "./chunk-6H67XLET.js";
+import "./chunk-ABNYOMDG.js";
+import "./chunk-2JNR4VP2.js";
+import "./chunk-LXXMOYPL.js";
+import "./chunk-AN6C2U46.js";
+import "./chunk-E5Z2AVNV.js";
+import {
+  formatAcpModelId,
+  parseAcpBaseModelId,
+  parseAcpModelOption,
+  sanitizeProviderBaseUrl
+} from "./chunk-BA5JGE5F.js";
+import {
+  mapSkillConfigToStatus
+} from "./chunk-2W3OOD4W.js";
 import {
   PERMISSION_RULE_TYPES,
   PermissionRulesValidationError,
   buildPermissionSettings,
   normalizePermissionRules,
   readPermissionRuleSet
-} from "./chunk-5VXNZWGF.js";
+} from "./chunk-ENUQSKEY.js";
 import {
   MAX_AUDIO_BYTES,
   sanitizeVoiceErrorMessage,
   transcribeVoiceAudio
-} from "./chunk-PDZ7MBDG.js";
+} from "./chunk-EWILX3BM.js";
 import {
   readVoiceModel
-} from "./chunk-HPDUL5MF.js";
-import "./chunk-LK7KUE55.js";
+} from "./chunk-T2ZDAER2.js";
+import "./chunk-FSA7ERJ2.js";
 import {
-  computeCpuPercent
-} from "./chunk-YVEDCAUE.js";
-import "./chunk-RXFQM6FQ.js";
-import "./chunk-PODM4SZ4.js";
-import "./chunk-6H67XLET.js";
-import "./chunk-BAPGSC7U.js";
-import "./chunk-P67PFTUT.js";
-import "./chunk-57OAHC2Y.js";
-import "./chunk-TO6QE22P.js";
-import "./chunk-W3JHSWRP.js";
-import "./chunk-E5Z2AVNV.js";
-import {
-  NOT_CURRENTLY_GENERATING_CANCEL_MESSAGE
-} from "./chunk-IAVB3HM3.js";
+  parseSessionSource
+} from "./chunk-HGRXW4HQ.js";
 import {
   CLIENT_MCP_OVER_WS_CONFIG_FLAG,
   LOAD_REPLAY_BULK_MODE,
@@ -110,21 +123,23 @@ import {
   LOAD_REPLAY_VERSION,
   MID_TURN_QUEUE_DRAIN_METHOD
 } from "./chunk-PZL23GTM.js";
-import "./chunk-W7FJ3N32.js";
 import "./chunk-6RLROE6G.js";
 import "./chunk-COH43MRJ.js";
 import {
-  ndJsonStream
-} from "./chunk-TEGEBB2I.js";
+  NOT_CURRENTLY_GENERATING_CANCEL_MESSAGE
+} from "./chunk-L4Y55KIS.js";
+import "./chunk-UZP7K33Y.js";
+import "./chunk-KEYEYCHZ.js";
+import "./chunk-57OAHC2Y.js";
+import "./chunk-5CNYZ7TN.js";
+import "./chunk-FNX3LGAK.js";
+import "./chunk-V6WHFGST.js";
 import {
-  formatAcpModelId,
-  parseAcpBaseModelId,
-  parseAcpModelOption,
-  sanitizeProviderBaseUrl
-} from "./chunk-34MW4KTI.js";
+  createLoadedSettingsAdapter
+} from "./chunk-EZWX232B.js";
 import {
-  mapSkillConfigToStatus
-} from "./chunk-L36P3NBD.js";
+  ndJsonStream
+} from "./chunk-J4SEAF4X.js";
 import {
   ACP_PREFLIGHT_KINDS,
   IDLE_HOOK_EVENTS,
@@ -132,14 +147,21 @@ import {
   SERVE_STATUS_EXT_METHODS,
   STATUS_SCHEMA_VERSION,
   mapDomainErrorToErrorKind
-} from "./chunk-VWPVHAMO.js";
-import "./chunk-DC5Z3DU6.js";
-import "./chunk-V6WHFGST.js";
+} from "./chunk-XIWQ5QST.js";
+import "./chunk-W7FJ3N32.js";
+import "./chunk-GYTKQYDB.js";
+import "./chunk-TJTKSVIV.js";
+import "./chunk-M5GB774H.js";
+import "./chunk-OJAMDVF5.js";
+import "./chunk-LXLTBIDP.js";
+import "./chunk-3DWIFU7L.js";
+import "./chunk-ZQIYGQCG.js";
 import {
-  createLoadedSettingsAdapter
-} from "./chunk-BMGVRZN4.js";
-import "./chunk-CUMMSHH6.js";
-import "./chunk-ATAKVRIF.js";
+  AgentSideConnection,
+  PROTOCOL_VERSION,
+  RequestError
+} from "./chunk-UDXSXLER.js";
+import "./chunk-Z3XA2TNG.js";
 import {
   OUTPUT_LANGUAGE_AUTO,
   getOutputLanguageFilePath,
@@ -150,44 +172,37 @@ import {
   resolveOutputLanguage,
   updateOutputLanguageFile,
   writeOutputLanguageAndRegisterPath
-} from "./chunk-4C5BQ2D2.js";
+} from "./chunk-TIKDHS6V.js";
 import "./chunk-RKUWKYED.js";
 import {
   SUPPORTED_LANGUAGES,
   getCurrentLanguage,
   setLanguageAsync
-} from "./chunk-YAUFFXDS.js";
+} from "./chunk-7GM2RWCR.js";
 import {
   findEnvFiles,
   preResolveHomeEnvOverrides,
   reloadEnvironment
-} from "./chunk-SCGXUJBT.js";
+} from "./chunk-6LI3L22E.js";
+import "./chunk-GOXKNSDZ.js";
 import {
   getSystemDefaultsPath,
   getSystemSettingsPath
-} from "./chunk-3BTRNWWD.js";
+} from "./chunk-IDS7MSUP.js";
 import "./chunk-QRUIS3DN.js";
-import "./chunk-X4NKFGFJ.js";
-import "./chunk-TJTKSVIV.js";
-import "./chunk-M5GB774H.js";
-import "./chunk-34Z3U5RQ.js";
-import {
-  AgentSideConnection,
-  PROTOCOL_VERSION,
-  RequestError
-} from "./chunk-UDXSXLER.js";
 import {
   isFolderTrustEnabled,
   isWorkspaceTrusted,
   loadTrustedFolders
-} from "./chunk-HKMAENAO.js";
-import "./chunk-RDJSGHZE.js";
-import "./chunk-XFSFZCM5.js";
-import "./chunk-3AHXV67U.js";
-import "./chunk-VJNBRRZG.js";
+} from "./chunk-QDTGDM2T.js";
+import "./chunk-ALGGS7UH.js";
+import "./chunk-MR3PXB6E.js";
 import {
   writeStderrLine
 } from "./chunk-YUZI3WAC.js";
+import "./chunk-XFSFZCM5.js";
+import "./chunk-AGZLXLBY.js";
+import "./chunk-VJNBRRZG.js";
 import {
   ALL_PROVIDERS,
   APPROVAL_MODE_INFO,
@@ -205,7 +220,7 @@ import {
   McpBudgetWouldExceedError,
   McpServerSpawnFailedError,
   McpTransportPool,
-  ORPHAN_TOOL_USE_REPAIR_REASON,
+  MessageDisplayDispatcher,
   POOLED_TRANSPORTS_DEFAULT,
   SESSION_ARTIFACT_PERSISTENCE_VERSION,
   SESSION_TITLE_MAX_LENGTH,
@@ -226,16 +241,16 @@ import {
   buildBtwPrompt,
   buildContextUsage,
   buildInstallPlan,
-  buildSyntheticToolResponseParts,
+  buildSessionRecoveryPlanFromApiHistory,
   clampInlineMediaPart,
   clearGoalTerminalObserver,
   computeUniqueBranchTitle,
+  convertToFunctionErrorResponse,
   convertToFunctionResponse,
   createDuplicateProviderToolCallResponse,
   dedupeToolCallsById,
   detectAutonomousSentinel,
   detectLoopSentinel,
-  detectTurnInterruption,
   encodeSessionTranscriptCursor,
   evaluateAutoMode,
   evaluatePermissionFlow,
@@ -262,7 +277,6 @@ import {
   getProviderToolCallId,
   getScopedEnvContents,
   getStartupContextLength,
-  hasImageParts,
   ideContextStore,
   injectPermissionRulesIfMissing,
   isApproveOutcome,
@@ -273,7 +287,6 @@ import {
   matchesAnyServerPattern,
   needsConfirmation,
   normalizeEventPayload,
-  normalizeParts,
   normalizeSnapshotPayload,
   parsePositiveIntegerEnv,
   persistPermissionOutcome,
@@ -281,12 +294,13 @@ import {
   recordAllow,
   recordFallbackApprove,
   redactUrlCredentials,
+  refreshMemoryAfterManagedWrite,
+  refreshMemoryInstruction,
   resolveBaseUrl,
   restoreWorktreeContext,
   runForkedAgent,
   runManagedAutoMemoryDream,
   runManagedRememberByAgent,
-  runVisionBridge,
   sessionIdContext,
   setGoalTerminalObserver,
   shouldClassifyAllShellForAutoMode,
@@ -294,42 +308,37 @@ import {
   shouldFirePermissionDeniedForAutoMode,
   shouldForceAutoModeReviewForAllow,
   shouldRunAutoModeForCall,
-  shouldRunVisionBridge,
-  splitImageParts,
   subagentGenerator,
   unregisterGoalHook,
   updateSetting
-} from "./chunk-NVYTCB5Z.js";
-import "./chunk-CU3L64TP.js";
-import "./chunk-ZJE7NSL3.js";
+} from "./chunk-SA6QVLWI.js";
 import {
   external_exports
 } from "./chunk-H6XPXXMH.js";
-import "./chunk-MC23XKFE.js";
-import "./chunk-LUODI7WD.js";
-import "./chunk-ORBGV7NJ.js";
-import "./chunk-KKNMOEZH.js";
-import {
-  runSideQuery
-} from "./chunk-W2UIXQDL.js";
+import "./chunk-5M6IDOMF.js";
+import "./chunk-A2HWMJVO.js";
+import "./chunk-RCEEXIOO.js";
+import "./chunk-KKRTYONM.js";
+import "./chunk-TV6K2FB4.js";
+import "./chunk-E2UVIFI2.js";
 import "./chunk-XU457J4V.js";
 import "./chunk-VDDGDZMA.js";
-import "./chunk-CEA3E3JB.js";
+import "./chunk-SPJQO2CE.js";
 import "./chunk-SZRN75WQ.js";
 import "./chunk-HTO4JFDZ.js";
 import "./chunk-CPBF7KYF.js";
 import {
   APPROVAL_MODES,
   FORK_SUBAGENT_TYPE
-} from "./chunk-4GORAUCN.js";
+} from "./chunk-F333XEAU.js";
 import "./chunk-6AM5D4ME.js";
-import "./chunk-7R3CZA3Q.js";
+import "./chunk-2Z5UX4KI.js";
 import {
   HookEventName,
   createHookOutput
-} from "./chunk-GWHYEOV2.js";
-import "./chunk-4QLQE5WJ.js";
-import "./chunk-5XUCZNSY.js";
+} from "./chunk-ARKANCNX.js";
+import "./chunk-L5U3ELZX.js";
+import "./chunk-TYLOFD2U.js";
 import {
   AuthType,
   ConversationFinishedEvent,
@@ -340,66 +349,76 @@ import {
   endToolExecutionSpan,
   endToolSpan,
   extractDaemonTraceContext,
+  formatVisionBridgeNotice,
   getAllGeminiMdFilenames,
   getMCPServerStatus,
+  hasImageParts,
   logConversationFinishedEvent,
   logLoopDetected,
   logPromptSuggestion,
   logToolCall,
   logUserPrompt,
+  normalizeParts,
   registerAcpEventLoopLagGauge,
   runInToolSpanContext,
+  runVisionBridge,
+  shouldRunVisionBridge,
+  splitImageParts,
   startEventLoopLagMonitor,
   startToolExecutionSpan,
   startToolSpan,
   uiTelemetryService,
   withInteractionSpan
-} from "./chunk-3VAGG5T5.js";
+} from "./chunk-YYBZUIPL.js";
 import "./chunk-4WKAA4KS.js";
 import "./chunk-CR3C7WXL.js";
-import "./chunk-CARU2RR2.js";
+import {
+  runSideQuery
+} from "./chunk-RTV5TUYB.js";
 import "./chunk-VGC4I5JJ.js";
 import {
   getAutoMemoryRoot,
   getUserAutoMemoryRoot
-} from "./chunk-YLV3XXFB.js";
-import "./chunk-TDEXZKMT.js";
-import "./chunk-J3JA76CF.js";
+} from "./chunk-FBU7WRZI.js";
+import "./chunk-Y66VOBRP.js";
+import "./chunk-WTNZ6DXB.js";
 import {
   ToolConfirmationOutcome,
-  ToolNames
-} from "./chunk-B5ORX3FG.js";
+  ToolNames,
+  isShellProgressData
+} from "./chunk-JGUT3LWZ.js";
 import {
   clearCachedCredentialFile,
   qwenOAuth2Events
-} from "./chunk-BZIFY5TF.js";
-import "./chunk-UOZWKTQG.js";
+} from "./chunk-OKAIGAYW.js";
+import "./chunk-ZPAHLFZU.js";
 import "./chunk-JESCGQM3.js";
-import "./chunk-ZLXQN2QS.js";
+import "./chunk-WIEO4CWB.js";
 import "./chunk-XVNQMZ2I.js";
+import "./chunk-FEOZBUMT.js";
 import {
   DEFAULT_TOKEN_LIMIT,
+  getToolCallPreparations,
   tokenLimit
-} from "./chunk-524RQP4Q.js";
-import "./chunk-JSG7ZSBC.js";
+} from "./chunk-VRR65QYW.js";
 import "./chunk-A4UCTEB5.js";
 import "./chunk-XWRJCPHC.js";
 import "./chunk-4LD5APFL.js";
 import "./chunk-TYAMGABM.js";
 import "./chunk-FCMNKVXT.js";
 import "./chunk-DJ2GSRLV.js";
-import "./chunk-4ZVWQHEQ.js";
+import "./chunk-LQIDP6K5.js";
 import {
   Storage,
   createDebugLogger,
   getErrorMessage,
   getErrorStatus,
   isSubpath
-} from "./chunk-J4TSQ5EQ.js";
-import "./chunk-CCDMCZPP.js";
+} from "./chunk-7NFB7LBQ.js";
+import "./chunk-YZ3SBNP7.js";
 import {
   runExitCleanup
-} from "./chunk-ECNYL4AA.js";
+} from "./chunk-HUEWOHKV.js";
 import "./chunk-75DOP5OR.js";
 import "./chunk-DMTGGOSA.js";
 import "./chunk-YQ3U5MUC.js";
@@ -793,6 +812,79 @@ import { Buffer as Buffer2 } from "node:buffer";
 import * as os2 from "node:os";
 import * as path3 from "node:path";
 
+// packages/cli/src/acp-integration/session/tool-call-preparation-tracker.ts
+init_esbuild_shims();
+var ToolCallPreparationTracker = class {
+  constructor(emitter) {
+    this.emitter = emitter;
+  }
+  static {
+    __name(this, "ToolCallPreparationTracker");
+  }
+  /** Contains only calls whose start frame was emitted successfully. */
+  pending = /* @__PURE__ */ new Map();
+  /** Contains calls whose start frame was intentionally suppressed. */
+  suppressed = /* @__PURE__ */ new Set();
+  /** Calls parsed completely but not yet handed to tool execution. */
+  resolved = /* @__PURE__ */ new Set();
+  /**
+   * Emits at most one preparing frame per call ID before the full call arrives.
+   */
+  async observe(response) {
+    for (const preparation of getToolCallPreparations(response)) {
+      if (this.pending.has(preparation.callId) || this.suppressed.has(preparation.callId)) {
+        continue;
+      }
+      const emitted = await this.emitter.emitStart({
+        callId: preparation.callId,
+        toolName: preparation.toolName,
+        args: {},
+        status: "pending",
+        phase: "preparing"
+      });
+      if (emitted) {
+        this.pending.set(preparation.callId, preparation.toolName);
+      } else {
+        this.suppressed.add(preparation.callId);
+      }
+    }
+  }
+  /** Resolves preparations once their complete function calls arrive. */
+  resolve(functionCalls) {
+    for (const functionCall of functionCalls) {
+      if (functionCall.id && this.pending.has(functionCall.id)) {
+        this.resolved.add(functionCall.id);
+      }
+    }
+  }
+  /**
+   * Terminates unresolved preparations. The map is cleared first so repeated
+   * cleanup, including re-entry after an emission failure, cannot emit twice.
+   */
+  async discard(includeResolved = false) {
+    const pending = [...this.pending.entries()];
+    this.pending.clear();
+    const resolved = new Set(this.resolved);
+    this.resolved.clear();
+    let firstError;
+    let hasError = false;
+    for (const [callId, toolName] of pending) {
+      if (!includeResolved && resolved.has(callId)) continue;
+      try {
+        await this.emitter.emitPreparationDiscarded(callId, toolName);
+      } catch (error) {
+        if (!hasError) {
+          firstError = error;
+          hasError = true;
+        }
+      }
+    }
+    if (hasError) {
+      throw firstError;
+    }
+  }
+};
+
 // packages/cli/src/acp-integration/session/SubAgentTracker.ts
 init_esbuild_shims();
 
@@ -1337,7 +1429,12 @@ ${inputText}
 ${rewritten}
 ---`
       );
-      this.outputHistory.push(rewritten);
+      if (this.contextTurns > 0) {
+        this.outputHistory.push(rewritten);
+        if (Number.isFinite(this.contextTurns) && this.outputHistory.length > this.contextTurns) {
+          this.outputHistory = this.outputHistory.slice(-this.contextTurns);
+        }
+      }
       return rewritten;
     } catch (error) {
       debugLogger4.warn(
@@ -1387,6 +1484,9 @@ var MessageRewriteMiddleware = class {
     const content = updateRecord["content"];
     const text = content?.["text"] ?? "";
     await this.sendUpdate(update);
+    if (updateType === "agent_message_chunk" && updateRecord["_meta"]?.["source"] === "slash_command") {
+      return;
+    }
     let didAccumulate = false;
     if (updateType === "agent_thought_chunk") {
       if (this.target === "thought" || this.target === "all") {
@@ -1473,9 +1573,10 @@ var MessageRewriteMiddleware = class {
    * Call this before session ends to ensure all rewrites are flushed.
    */
   async waitForPendingRewrites() {
-    if (this.pendingRewrites.length > 0) {
-      await Promise.allSettled(this.pendingRewrites);
+    while (this.pendingRewrites.length > 0) {
+      const inFlight = this.pendingRewrites;
       this.pendingRewrites = [];
+      await Promise.allSettled(inFlight);
     }
   }
 };
@@ -1494,6 +1595,17 @@ 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";
+async function finalizeToolCallPreparations(tracker, includeResolved, streamName) {
+  try {
+    await tracker.discard(includeResolved);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    debugLogger6.warn(
+      `Failed to discard tool preparations for ${streamName}; continuing stream: ${message}`
+    );
+  }
+}
+__name(finalizeToolCallPreparations, "finalizeToolCallPreparations");
 function maskApiKeyForDisplay(apiKey) {
   const trimmed = apiKey?.trim() ?? "";
   if (trimmed.length === 0) return "(not set)";
@@ -2022,6 +2134,7 @@ var Session = class {
   // or session reload), which would otherwise execute orphaned cron prompts
   // on a session whose registries are already unregistered.
   disposed = false;
+  unsubscribeChatRecordingFailure;
   // Modular components
   historyReplayer;
   toolCallEmitter;
@@ -2131,6 +2244,8 @@ var Session = class {
     this.config.getMonitorRegistry().setNotificationCallback(void 0);
     this.config.getBackgroundShellRegistry().setNotificationCallback(void 0);
     this.config.getChatRecordingService()?.setTitleRecordedCallback(void 0);
+    this.unsubscribeChatRecordingFailure?.();
+    this.unsubscribeChatRecordingFailure = void 0;
     this.config.setSubSessionSpawner(void 0);
     clearGoalTerminalObserver(this.sessionId);
   }
@@ -2389,16 +2504,18 @@ var Session = class {
       return { accepted: false, interruption: "none" };
     }
     const chat = this.#getCurrentChat();
-    const detection = detectTurnInterruption(
-      chat.getHistoryTailShallow?.(TURN_INTERRUPTION_HISTORY_TAIL_COUNT) ?? chat.getHistoryTail(TURN_INTERRUPTION_HISTORY_TAIL_COUNT)
-    );
-    if (detection.kind === "none") {
+    const recoveryPlan = buildSessionRecoveryPlanFromApiHistory({
+      sessionId: this.sessionId,
+      apiHistory: chat.getHistoryTailShallow?.(TURN_INTERRUPTION_HISTORY_TAIL_COUNT) ?? chat.getHistoryTail(TURN_INTERRUPTION_HISTORY_TAIL_COUNT)
+    });
+    if (!recoveryPlan.continuation) {
       return { accepted: false, interruption: "none" };
     }
+    const interruption = recoveryPlan.kind === "interrupted_prompt" ? "interrupted_prompt" : "interrupted_turn";
     if (this.pendingPrompt && !this.pendingPrompt.signal.aborted) {
-      return { accepted: false, interruption: detection.kind };
+      return { accepted: false, interruption };
     }
-    return { accepted: true, interruption: detection.kind };
+    return { accepted: true, interruption };
   }
   /**
    * Generate a server-side follow-up suggestion for the just-completed
@@ -2522,10 +2639,11 @@ var Session = class {
             let strippedOrphanEntries = null;
             let orphanPushCountSnapshot = 0;
             if (isContinue) {
-              const detection = detectTurnInterruption(
-                this.#getCurrentChat().getHistory()
-              );
-              if (detection.kind === "none") {
+              const recoveryPlan = buildSessionRecoveryPlanFromApiHistory({
+                sessionId: this.sessionId,
+                apiHistory: this.#getCurrentChat().getHistory()
+              });
+              if (!recoveryPlan.continuation) {
                 debugLogger6.warn(
                   `[Session] continue ${promptId}: no interrupted turn on re-detection, nothing to continue`
                 );
@@ -2538,15 +2656,12 @@ var Session = class {
                 );
                 return { stopReason: "end_turn" };
               }
-              if (detection.kind === "interrupted_prompt") {
+              if (recoveryPlan.continuation.mode === "retry_user_parts") {
                 strippedOrphanEntries = this.#getCurrentChat().stripOrphanedUserEntriesFromHistory() ?? null;
                 orphanPushCountSnapshot = this.#getCurrentChat().getUserContentPushCount?.() ?? 0;
-                continuationParts = detection.parts;
+                continuationParts = recoveryPlan.continuation.parts;
               } else {
-                continuationParts = buildSyntheticToolResponseParts(
-                  detection.danglingCalls,
-                  ORPHAN_TOOL_USE_REPAIR_REASON
-                );
+                continuationParts = recoveryPlan.continuation.parts;
               }
             }
             if (isContinue) {
@@ -2579,7 +2694,8 @@ var Session = class {
             } else {
               parts = await this.#resolvePrompt(
                 params.prompt,
-                pendingSend.signal
+                pendingSend.signal,
+                { promptLast: true }
               );
             }
             const hooksEnabled = !this.config.getDisableAllHooks?.();
@@ -2654,8 +2770,14 @@ ${this.pendingWorktreeNotice}
                   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 sendResult = await this.#sendMessageStreamWithAutoCompression(
                     promptId,
@@ -2671,32 +2793,56 @@ ${this.pendingWorktreeNotice}
                   }
                   const responseStream = sendResult.responseStream;
                   nextMessage = null;
-                  for await (const resp of responseStream) {
-                    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;
+                  let streamFailed = false;
+                  try {
+                    for await (const resp of responseStream) {
+                      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);
+                          }
                         }
-                        this.messageEmitter.emitMessage(
-                          part.text,
-                          "assistant",
-                          part.thought
+                      }
+                      if (resp.type === "chunk" /* CHUNK */ && resp.value.usageMetadata) {
+                        usageMetadata = resp.value.usageMetadata;
+                      }
+                      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 (resp.type === "retry" /* RETRY */ || resp.type === "model_fallback" /* MODEL_FALLBACK */) {
+                        await finalizeToolCallPreparations(
+                          preparationTracker,
+                          true,
+                          `main prompt ${resp.type}`
                         );
+                        functionCalls.length = 0;
                       }
                     }
-                    if (resp.type === "chunk" /* CHUNK */ && resp.value.usageMetadata) {
-                      usageMetadata = resp.value.usageMetadata;
-                    }
-                    if (resp.type === "chunk" /* CHUNK */ && resp.value.functionCalls) {
-                      functionCalls.push(...resp.value.functionCalls);
-                    }
-                    if (resp.type === "model_fallback" /* MODEL_FALLBACK */) {
-                      functionCalls.length = 0;
-                    }
+                  } catch (error) {
+                    streamFailed = true;
+                    throw error;
+                  } finally {
+                    await finalizeToolCallPreparations(
+                      preparationTracker,
+                      streamFailed || pendingSend.signal.aborted,
+                      "main prompt"
+                    );
                   }
                 } catch (error) {
                   if (strippedOrphanEntries && (this.#getCurrentChat().getUserContentPushCount?.() ?? 0) <= orphanPushCountSnapshot) {
@@ -2728,6 +2874,8 @@ ${this.pendingWorktreeNotice}
                     );
                   }
                   throw error;
+                } finally {
+                  await messageDisplay?.finish();
                 }
                 if (usageMetadata) {
                   this.#recordPromptTokenCount(usageMetadata);
@@ -2874,8 +3022,14 @@ ${this.pendingWorktreeNotice}
             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,
@@ -2892,30 +3046,54 @@ ${this.pendingWorktreeNotice}
             }
             const continueResponseStream = continueSendResult.responseStream;
             nextMessage = null;
-            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
+            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);
+                    }
+                  }
+                }
+                if (resp.type === "chunk" /* CHUNK */ && resp.value.usageMetadata) {
+                  usageMetadata = resp.value.usageMetadata;
+                }
+                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 (resp.type === "retry" /* RETRY */ || resp.type === "model_fallback" /* MODEL_FALLBACK */) {
+                  await finalizeToolCallPreparations(
+                    preparationTracker,
+                    true,
+                    `Stop Hook continuation ${resp.type}`
                   );
+                  functionCalls.length = 0;
                 }
               }
-              if (resp.type === "chunk" /* CHUNK */ && resp.value.usageMetadata) {
-                usageMetadata = resp.value.usageMetadata;
-              }
-              if (resp.type === "chunk" /* CHUNK */ && resp.value.functionCalls) {
-                functionCalls.push(...resp.value.functionCalls);
-              }
-              if (resp.type === "model_fallback" /* MODEL_FALLBACK */) {
-                functionCalls.length = 0;
-              }
+            } catch (error) {
+              streamFailed = true;
+              throw error;
+            } finally {
+              await finalizeToolCallPreparations(
+                preparationTracker,
+                streamFailed || pendingSend.signal.aborted,
+                "Stop Hook continuation"
+              );
             }
           } catch (error) {
             const errorStatus = getErrorStatus(error);
@@ -2938,6 +3116,8 @@ ${this.pendingWorktreeNotice}
               );
             }
             throw error;
+          } finally {
+            await messageDisplay?.finish();
           }
           if (usageMetadata) {
             this.#recordPromptTokenCount(usageMetadata);
@@ -2993,6 +3173,28 @@ ${this.pendingWorktreeNotice}
    * stop reason when the provider send should be skipped because the request
    * was cancelled or the session token limit was exceeded.
    */
+  /**
+   * Create the MessageDisplay hook dispatcher for one model call's streamed
+   * reply, or null when the hook isn't registered (the common case — keeps
+   * the streaming loops zero-cost). The ACP surface consumes GeminiChat's
+   * raw stream directly rather than going through
+   * GeminiClient.sendMessageStream, so it has to fire this hook itself —
+   * with the same contract as the terminal UI path in client.ts: debounced
+   * cumulative text, one message_id per model call, and an is_final firing
+   * on every non-aborted exit (delivered by awaiting `finish()` in a
+   * finally around each streaming loop).
+   */
+  #createMessageDisplayDispatcher(signal) {
+    const messageBus = this.config.getMessageBus?.();
+    if (this.config.getDisableAllHooks?.() || !messageBus || !this.config.hasHooksForEvent?.("MessageDisplay")) {
+      return null;
+    }
+    return new MessageDisplayDispatcher(
+      messageBus,
+      signal,
+      (message) => debugLogger6.warn(message)
+    );
+  }
   async #sendMessageStreamWithAutoCompression(promptId, message, abortSignal, options = {}) {
     const geminiClient = this.config.getGeminiClient();
     let compressionDiagnostic = null;
@@ -3497,6 +3699,9 @@ ${this.pendingWorktreeNotice}
                 turnCount++;
                 if (ac.signal.aborted) return;
                 const functionCalls = [];
+                const preparationTracker = new ToolCallPreparationTracker(
+                  this.toolCallEmitter
+                );
                 let usageMetadata = null;
                 const streamStartTime = Date.now();
                 const sendResult = await this.#sendMessageStreamWithAutoCompression(
@@ -3519,27 +3724,58 @@ ${this.pendingWorktreeNotice}
                   this.loopTickResolver?.markDelivered();
                 }
                 nextMessage = null;
-                for await (const resp of responseStream) {
-                  if (ac.signal.aborted) 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 ?? []) {
-                      if (!part.text) continue;
-                      this.messageEmitter.emitMessage(
-                        part.text,
-                        "assistant",
-                        part.thought
+                const messageDisplay = this.#createMessageDisplayDispatcher(
+                  ac.signal
+                );
+                let streamFailed = false;
+                try {
+                  for await (const resp of responseStream) {
+                    if (ac.signal.aborted) 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 ?? []) {
+                        if (!part.text) continue;
+                        this.messageEmitter.emitMessage(
+                          part.text,
+                          "assistant",
+                          part.thought
+                        );
+                        if (!part.thought) {
+                          messageDisplay?.addChunk(part.text);
+                        }
+                      }
+                    }
+                    if (resp.type === "chunk" /* CHUNK */ && resp.value.usageMetadata) {
+                      usageMetadata = resp.value.usageMetadata;
+                    }
+                    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 (resp.type === "retry" /* RETRY */ || resp.type === "model_fallback" /* MODEL_FALLBACK */) {
+                      await finalizeToolCallPreparations(
+                        preparationTracker,
+                        true,
+                        `cron/loop tick ${resp.type}`
                       );
+                      functionCalls.length = 0;
                     }
                   }
-                  if (resp.type === "chunk" /* CHUNK */ && resp.value.usageMetadata) {
-                    usageMetadata = resp.value.usageMetadata;
-                  }
-                  if (resp.type === "chunk" /* CHUNK */ && resp.value.functionCalls) {
-                    functionCalls.push(...resp.value.functionCalls);
-                  }
-                  if (resp.type === "model_fallback" /* MODEL_FALLBACK */) {
-                    functionCalls.length = 0;
+                } catch (error) {
+                  streamFailed = true;
+                  throw error;
+                } finally {
+                  try {
+                    await finalizeToolCallPreparations(
+                      preparationTracker,
+                      streamFailed || ac.signal.aborted,
+                      "cron/loop tick"
+                    );
+                  } finally {
+                    await messageDisplay?.finish();
                   }
                 }
                 if (usageMetadata) {
@@ -3649,15 +3885,27 @@ ${this.pendingWorktreeNotice}
         kind: "shell"
       });
     });
-    this.config.getChatRecordingService()?.setTitleRecordedCallback((customTitle, titleSource) => {
+    this.config.getChatRecordingService()?.setTitleRecordedCallback((customTitle, titleSource, sessionId) => {
       void this.client.extNotification("qwen/notify/session/title-update", {
         v: 1,
-        sessionId: this.sessionId,
+        sessionId,
         title: customTitle,
         titleSource
       }).catch(() => {
       });
     });
+    if (typeof this.config.onChatRecordingFailure === "function") {
+      this.unsubscribeChatRecordingFailure = this.config.onChatRecordingFailure(
+        (event) => this.client.extNotification(
+          "qwen/notify/session/recording-degraded",
+          {
+            v: 1,
+            sessionId: event.sessionId,
+            reason: "write_failed"
+          }
+        )
+      );
+    }
   }
   #enqueueBackgroundNotification(item) {
     while (this.notificationQueue.length >= MAX_NOTIFICATION_QUEUE) {
@@ -3726,6 +3974,9 @@ ${this.pendingWorktreeNotice}
               return;
             }
             const functionCalls = [];
+            const preparationTracker = new ToolCallPreparationTracker(
+              this.toolCallEmitter
+            );
             let usageMetadata = null;
             let responseText = "";
             const streamStartTime = Date.now();
@@ -3746,34 +3997,63 @@ ${this.pendingWorktreeNotice}
             }
             const responseStream = sendResult.responseStream;
             nextMessage = null;
-            for await (const resp of responseStream) {
-              if (ac.signal.aborted) {
-                await this.#emitBackgroundNotificationEndTurn("cancelled");
-                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 ?? []) {
-                  if (!part.text) continue;
-                  if (part.thought) {
-                    await this.messageEmitter.emitMessage(
-                      part.text,
-                      "assistant",
-                      true
-                    );
-                  } else {
-                    responseText += part.text;
+            const messageDisplay = this.#createMessageDisplayDispatcher(
+              ac.signal
+            );
+            let streamFailed = false;
+            try {
+              for await (const resp of responseStream) {
+                if (ac.signal.aborted) {
+                  await this.#emitBackgroundNotificationEndTurn("cancelled");
+                  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 ?? []) {
+                    if (!part.text) continue;
+                    if (part.thought) {
+                      await this.messageEmitter.emitMessage(
+                        part.text,
+                        "assistant",
+                        true
+                      );
+                    } else {
+                      responseText += part.text;
+                      messageDisplay?.addChunk(part.text);
+                    }
                   }
                 }
+                if (resp.type === "chunk" /* CHUNK */ && resp.value.usageMetadata) {
+                  usageMetadata = resp.value.usageMetadata;
+                }
+                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 (resp.type === "retry" /* RETRY */ || resp.type === "model_fallback" /* MODEL_FALLBACK */) {
+                  await finalizeToolCallPreparations(
+                    preparationTracker,
+                    true,
+                    `background notification ${resp.type}`
+                  );
+                  functionCalls.length = 0;
+                }
               }
-              if (resp.type === "chunk" /* CHUNK */ && resp.value.usageMetadata) {
-                usageMetadata = resp.value.usageMetadata;
-              }
-              if (resp.type === "chunk" /* CHUNK */ && resp.value.functionCalls) {
-                functionCalls.push(...resp.value.functionCalls);
-              }
-              if (resp.type === "model_fallback" /* MODEL_FALLBACK */) {
-                functionCalls.length = 0;
+            } catch (error) {
+              streamFailed = true;
+              throw error;
+            } finally {
+              try {
+                await finalizeToolCallPreparations(
+                  preparationTracker,
+                  streamFailed || ac.signal.aborted,
+                  "background notification"
+                );
+              } finally {
+                await messageDisplay?.finish();
               }
             }
             if (responseText.length > 0) {
@@ -3901,26 +4181,54 @@ ${this.pendingWorktreeNotice}
   }
   async sendAvailableCommandsUpdate() {
     try {
-      const { availableCommands, availableSkills, availableSkillDetails } = await buildAvailableCommandsSnapshot(
-        this.config,
-        void 0,
-        this.settings
-      );
-      const update = {
-        sessionUpdate: "available_commands_update",
-        availableCommands,
-        ...availableSkills !== void 0 ? {
-          _meta: {
-            availableSkills,
-            ...availableSkillDetails ? { availableSkillDetails } : {}
-          }
-        } : {}
-      };
-      await this.sendUpdate(update);
+      await this.sendAvailableCommandsUpdateOrThrow();
     } catch (error) {
       debugLogger6.error("Error sending available commands update:", error);
     }
   }
+  async refreshSkillsFromSettings() {
+    this.settings.reloadScopeFromDisk("Workspace" /* Workspace */);
+    const skillManager = this.config.getSkillManager();
+    let updateFailed = false;
+    let updateError;
+    try {
+      await this.sendAvailableCommandsUpdateOrThrow();
+    } catch (error) {
+      updateFailed = true;
+      updateError = error;
+    }
+    if (skillManager) {
+      try {
+        skillManager.suppressNextSlashReload();
+        await skillManager.notifyConfigChanged();
+      } catch (error) {
+        if (!updateFailed) throw error;
+        debugLogger6.error(
+          "SkillManager refresh failed after command update failure:",
+          error
+        );
+      }
+    }
+    if (updateFailed) throw updateError;
+  }
+  async sendAvailableCommandsUpdateOrThrow() {
+    const { availableCommands, availableSkills, availableSkillDetails } = await buildAvailableCommandsSnapshot(
+      this.config,
+      void 0,
+      this.settings
+    );
+    const update = {
+      sessionUpdate: "available_commands_update",
+      availableCommands,
+      ...availableSkills !== void 0 ? {
+        _meta: {
+          availableSkills,
+          ...availableSkillDetails ? { availableSkillDetails } : {}
+        }
+      } : {}
+    };
+    await this.sendUpdate(update);
+  }
   /**
    * Requests permission from the client for a tool call.
    * Used by SubAgentTracker for sub-agent approval requests.
@@ -4212,6 +4520,17 @@ ${this.pendingWorktreeNotice}
         parts2.push(await recordSkippedToolCall(remainingCall, message));
       }
     }, "appendSkippedAfter");
+    const memoryWriteCandidates = [];
+    const collectMemoryWriteCandidates = /* @__PURE__ */ __name((result) => {
+      if (result.memoryWriteCandidates) {
+        memoryWriteCandidates.push(...result.memoryWriteCandidates);
+      }
+    }, "collectMemoryWriteCandidates");
+    const refreshMemoryIfNeeded = /* @__PURE__ */ __name(async () => {
+      await refreshMemoryAfterManagedWrite(this.config, memoryWriteCandidates, {
+        logContext: `ACP session ${this.sessionId} memory tool batch`
+      });
+    }, "refreshMemoryIfNeeded");
     const runBounded = /* @__PURE__ */ __name(async (calls, runAbortSignal, onStopAfterPermissionCancel, onStopAfterLoopDetected, shouldSkipUnstarted) => {
       const configuredMaxConcurrency = parsePositiveIntegerEnv(
         process.env["QWEN_CODE_MAX_TOOL_CONCURRENCY"],
@@ -4325,103 +4644,117 @@ ${this.pendingWorktreeNotice}
       return results;
     }, "runBounded");
     const parts = [];
-    for (const batch of batches) {
-      if (batch.kind === "duplicate") {
-        await emitDuplicateBatch(batch);
-        parts.push(...batch.response.responseParts);
-        continue;
-      }
-      if (batch.concurrent && batch.calls.length > 1) {
-        const batchAbortController = new AbortController();
-        let batchStopAfterPermissionCancel = false;
-        const propagateAbort = /* @__PURE__ */ __name(() => {
-          batchAbortController.abort(abortSignal.reason);
-        }, "propagateAbort");
-        if (abortSignal.aborted) {
-          propagateAbort();
-        } else {
-          abortSignal.addEventListener("abort", propagateAbort, {
-            once: true
-          });
-        }
-        const stopBatchAfterPermissionCancel = /* @__PURE__ */ __name(() => {
-          batchStopAfterPermissionCancel = true;
-          batchAbortController.abort(USER_CANCEL_ABORT_REASON);
-        }, "stopBatchAfterPermissionCancel");
-        let results;
-        try {
-          results = await runBounded(
-            batch.calls,
-            batchAbortController.signal,
-            stopBatchAfterPermissionCancel,
-            () => batchAbortController.abort("loop_detected"),
-            () => batchStopAfterPermissionCancel
-          );
-        } finally {
-          abortSignal.removeEventListener("abort", propagateAbort);
-        }
-        let shouldStop = false;
-        let shouldStopForLoop = false;
-        for (const r of results) {
-          parts.push(...r.parts);
-          shouldStop ||= r.stopAfterPermissionCancel;
-          shouldStopForLoop ||= r.loopDetected === true;
-        }
-        if (shouldStopForLoop) {
-          await appendSkippedAfter(
-            parts,
-            batch.calls[batch.calls.length - 1],
-            LOOP_DETECTED_SKIP_MESSAGE
-          );
-          return {
-            parts,
-            stopAfterPermissionCancel: false,
-            loopDetected: true
-          };
-        }
-        if (shouldStop) {
-          await appendSkippedAfter(parts, batch.calls[batch.calls.length - 1]);
-          return {
-            parts,
-            stopAfterPermissionCancel: true,
-            repeatedDuplicateProviderToolCall: false
-          };
+    try {
+      for (const batch of batches) {
+        if (batch.kind === "duplicate") {
+          await emitDuplicateBatch(batch);
+          parts.push(...batch.response.responseParts);
+          continue;
         }
-      } else {
-        for (const fc of batch.calls) {
-          const r = await this.runTool(
-            abortSignal,
-            promptId,
-            fc,
-            void 0,
-            toolLoopState,
-            recordSkippedToolCall
-          );
-          parts.push(...r.parts);
-          if (r.loopDetected) {
-            await appendSkippedAfter(parts, fc, LOOP_DETECTED_SKIP_MESSAGE);
+        if (batch.concurrent && batch.calls.length > 1) {
+          const batchAbortController = new AbortController();
+          let batchStopAfterPermissionCancel = false;
+          const propagateAbort = /* @__PURE__ */ __name(() => {
+            batchAbortController.abort(abortSignal.reason);
+          }, "propagateAbort");
+          if (abortSignal.aborted) {
+            propagateAbort();
+          } else {
+            abortSignal.addEventListener("abort", propagateAbort, {
+              once: true
+            });
+          }
+          const stopBatchAfterPermissionCancel = /* @__PURE__ */ __name(() => {
+            batchStopAfterPermissionCancel = true;
+            batchAbortController.abort(USER_CANCEL_ABORT_REASON);
+          }, "stopBatchAfterPermissionCancel");
+          let results;
+          try {
+            results = await runBounded(
+              batch.calls,
+              batchAbortController.signal,
+              stopBatchAfterPermissionCancel,
+              () => batchAbortController.abort("loop_detected"),
+              () => batchStopAfterPermissionCancel
+            );
+          } finally {
+            abortSignal.removeEventListener("abort", propagateAbort);
+          }
+          let shouldStop = false;
+          let shouldStopForLoop = false;
+          for (const r of results) {
+            parts.push(...r.parts);
+            collectMemoryWriteCandidates(r);
+            shouldStop ||= r.stopAfterPermissionCancel;
+            shouldStopForLoop ||= r.loopDetected === true;
+          }
+          if (shouldStopForLoop) {
+            await appendSkippedAfter(
+              parts,
+              batch.calls[batch.calls.length - 1],
+              LOOP_DETECTED_SKIP_MESSAGE
+            );
             return {
               parts,
               stopAfterPermissionCancel: false,
-              loopDetected: true
+              loopDetected: true,
+              memoryWriteCandidates
             };
           }
-          if (r.stopAfterPermissionCancel) {
-            await appendSkippedAfter(parts, fc);
+          if (shouldStop) {
+            await appendSkippedAfter(
+              parts,
+              batch.calls[batch.calls.length - 1]
+            );
             return {
               parts,
               stopAfterPermissionCancel: true,
-              repeatedDuplicateProviderToolCall: false
+              repeatedDuplicateProviderToolCall: false,
+              memoryWriteCandidates
             };
           }
+        } else {
+          for (const fc of batch.calls) {
+            const r = await this.runTool(
+              abortSignal,
+              promptId,
+              fc,
+              void 0,
+              toolLoopState,
+              recordSkippedToolCall
+            );
+            parts.push(...r.parts);
+            collectMemoryWriteCandidates(r);
+            if (r.loopDetected) {
+              await appendSkippedAfter(parts, fc, LOOP_DETECTED_SKIP_MESSAGE);
+              return {
+                parts,
+                stopAfterPermissionCancel: false,
+                loopDetected: true,
+                memoryWriteCandidates
+              };
+            }
+            if (r.stopAfterPermissionCancel) {
+              await appendSkippedAfter(parts, fc);
+              return {
+                parts,
+                stopAfterPermissionCancel: true,
+                repeatedDuplicateProviderToolCall: false,
+                memoryWriteCandidates
+              };
+            }
+          }
         }
       }
+      return {
+        parts,
+        stopAfterPermissionCancel: false,
+        repeatedDuplicateProviderToolCall: false,
+        memoryWriteCandidates
+      };
+    } finally {
+      await refreshMemoryIfNeeded();
     }
-    return {
-      parts,
-      stopAfterPermissionCancel: false,
-      repeatedDuplicateProviderToolCall: false
-    };
   }
   /**
    * Assemble the per-turn system reminders the model needs to see at the
@@ -4936,27 +5269,64 @@ ${this.pendingWorktreeNotice}
           }
           const execSpan = startToolExecutionSpan();
           let toolResult;
+          let isExecutionTimeout = false;
+          let aborted = false;
+          let toolSettled = false;
+          let heartbeatCount = 0;
+          let lastHeartbeat;
+          const onToolProgress = /* @__PURE__ */ __name((chunk) => {
+            if (toolSettled || !isShellProgressData(chunk)) {
+              return;
+            }
+            heartbeatCount++;
+            lastHeartbeat = chunk;
+            void this.sendUpdate({
+              sessionUpdate: "tool_call_update",
+              toolCallId: callId,
+              status: "in_progress",
+              _meta: { toolName, shellProgress: chunk }
+            }).catch((err) => {
+              debugLogger6.debug(
+                `[Session.runTool] heartbeat update failed for ${callId}: ${err}`
+              );
+            });
+          }, "onToolProgress");
+          const heartbeatSpanAttributes = /* @__PURE__ */ __name(() => heartbeatCount > 0 ? {
+            attributes: {
+              "shell.heartbeat_count": heartbeatCount,
+              ...lastHeartbeat?.lastOutputAgeMs !== void 0 && {
+                "shell.last_output_age_ms": lastHeartbeat.lastOutputAgeMs
+              }
+            }
+          } : void 0, "heartbeatSpanAttributes");
           try {
             const sleepInhibitorHandle = acquireSleepInhibitor(
               this.config,
               `Qwen Code is executing tool ${toolName}`
             );
             try {
-              toolResult = await invocation.execute(activeToolAbortSignal);
+              toolResult = await invocation.execute(
+                activeToolAbortSignal,
+                onToolProgress
+              );
             } finally {
+              toolSettled = true;
               sleepInhibitorHandle.release();
             }
-            const aborted2 = activeToolAbortSignal.aborted;
+            isExecutionTimeout = toolResult.error?.type === "execution_timeout" /* EXECUTION_TIMEOUT */;
+            aborted = activeToolAbortSignal.aborted && !isExecutionTimeout;
             endToolExecutionSpan(execSpan, {
-              success: !toolResult.error && !aborted2,
-              error: aborted2 ? "tool_cancelled" : toolResult.error ? "tool_error" : void 0,
-              cancelled: aborted2
+              success: !toolResult.error && !aborted,
+              error: aborted ? "tool_cancelled" : isExecutionTimeout ? "tool_timeout" : toolResult.error ? "tool_error" : void 0,
+              cancelled: aborted,
+              ...heartbeatSpanAttributes()
             });
           } catch (execError) {
             endToolExecutionSpan(execSpan, {
               success: false,
               error: activeToolAbortSignal.aborted ? "tool_cancelled" : "tool_exception",
-              cancelled: activeToolAbortSignal.aborted
+              cancelled: activeToolAbortSignal.aborted,
+              ...heartbeatSpanAttributes()
             });
             throw execError;
           }
@@ -4967,12 +5337,16 @@ ${this.pendingWorktreeNotice}
               currentModeId: this.config.getApprovalMode()
             });
           }
-          const responseParts = convertToFunctionResponse(
+          const responseParts = toolResult.error ? convertToFunctionErrorResponse(
+            toolName,
+            callId,
+            toolResult.llmContent,
+            toolResult.error.message
+          ) : convertToFunctionResponse(
             toolName,
             callId,
             toolResult.llmContent
           );
-          const aborted = activeToolAbortSignal.aborted;
           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;
@@ -5082,7 +5456,14 @@ ${this.pendingWorktreeNotice}
           }
           return {
             parts: responseParts,
-            stopAfterPermissionCancel: nestedPermissionCancelled
+            stopAfterPermissionCancel: nestedPermissionCancelled,
+            memoryWriteCandidates: status === "success" ? [
+              {
+                toolName,
+                args,
+                status
+              }
+            ] : void 0
           };
         } catch (e) {
           cleanupAgentToolResources();
@@ -5203,7 +5584,7 @@ ${this.pendingWorktreeNotice}
           throw new Error(result.content || "Slash command failed.");
         }
         const rendered = (result.content || "").replace(/\n/g, "  \n");
-        await this.messageEmitter.emitAgentMessage(rendered);
+        await this.messageEmitter.emitSlashCommandOutput(rendered);
         this.config.getChatRecordingService()?.recordSlashCommand({
           phase: "result",
           rawCommand: originalPrompt.filter((b) => b.type === "text").map((b) => b.type === "text" ? b.text : "").join(" "),
@@ -5219,7 +5600,7 @@ ${this.pendingWorktreeNotice}
           if (msg.messageType === "error") {
             throw new Error(msg.content || "Slash command failed.");
           }
-          await this.messageEmitter.emitAgentMessage(
+          await this.messageEmitter.emitSlashCommandOutput(
             (msg.content || "").replace(/\n/g, "  \n")
           );
           chunks.push(msg.content || "");
@@ -5242,7 +5623,8 @@ ${this.pendingWorktreeNotice}
       case "no_command":
         return this.#resolvePrompt(
           originalPrompt,
-          new AbortController().signal
+          new AbortController().signal,
+          { promptLast: true }
         );
       default: {
         const _exhaustive = result;
@@ -5251,7 +5633,7 @@ ${this.pendingWorktreeNotice}
       }
     }
   }
-  async #resolvePrompt(message, abortSignal) {
+  async #resolvePrompt(message, abortSignal, options = {}) {
     const FILE_URI_SCHEME = "file://";
     const embeddedContext = [];
     const extensionMentions = /* @__PURE__ */ new Map();
@@ -5341,7 +5723,7 @@ ${this.pendingWorktreeNotice}
         initialQueryText += `@${pathName}`;
       }
     }
-    const processedQueryParts = [];
+    const referenceParts = [...extensionParts, ...mcpServerParts];
     if (pathSpecsToRead.length > 0) {
       const readResult = await readManyFiles(this.config, {
         paths: pathSpecsToRead,
@@ -5349,26 +5731,19 @@ ${this.pendingWorktreeNotice}
         ...preserveUnsupportedImageForBridge ? { preserveUnsupportedImageForBridge } : {}
       });
       const contentParts = Array.isArray(readResult.contentParts) ? readResult.contentParts : [readResult.contentParts];
-      processedQueryParts.push({ text: initialQueryText });
-      processedQueryParts.push(...extensionParts);
-      processedQueryParts.push(...mcpServerParts);
       for (const part of contentParts) {
         if (typeof part === "string") {
-          processedQueryParts.push({ text: part });
+          referenceParts.push({ text: part });
         } else if (preserveUnsupportedImageForBridge && hasImageParts([part])) {
-          processedQueryParts.push(part);
+          referenceParts.push(part);
         } else {
-          processedQueryParts.push(clampInlineMediaPart(part));
+          referenceParts.push(clampInlineMediaPart(part));
         }
       }
-    } else {
-      processedQueryParts.push({ text: initialQueryText.trim() });
-      processedQueryParts.push(...extensionParts);
-      processedQueryParts.push(...mcpServerParts);
     }
     for (const contextPart of embeddedContext) {
       if ("text" in contextPart && contextPart.text) {
-        processedQueryParts.push({
+        referenceParts.push({
           text: `File: ${contextPart.uri}
 ${contextPart.text}`
         });
@@ -5380,11 +5755,14 @@ ${contextPart.text}`
             data: contextPart.blob
           }
         };
-        processedQueryParts.push(
+        referenceParts.push(
           preserveUnsupportedImageForBridge && hasImageParts([inlinePart]) ? inlinePart : clampInlineMediaPart(inlinePart)
         );
       }
     }
+    const promptText = pathSpecsToRead.length > 0 ? initialQueryText : initialQueryText.trim();
+    const promptPart = { text: promptText };
+    const processedQueryParts = options.promptLast ? [...referenceParts, promptPart] : [promptPart, ...referenceParts];
     return this.#applyBridgeConversionsIfNeeded(
       processedQueryParts,
       abortSignal
@@ -5418,7 +5796,7 @@ ${contextPart.text}`
     if (bridgeResult.status !== "skipped" || bridgeResult.egressOccurred) {
       try {
         await this.messageEmitter.emitAgentMessage(
-          this.#formatVisionBridgeNotice(bridgeResult)
+          formatVisionBridgeNotice(bridgeResult)
         );
       } catch (error) {
         debugLogger6.debug(
@@ -5527,20 +5905,6 @@ ${contextPart.text}`
   #formatVoiceBridgeEgressNotice(modelId, audioCount) {
     return `Sent ${audioCount} audio file(s) to ${modelId} for transcription, but no transcript was produced.`;
   }
-  #formatVisionBridgeNotice(result) {
-    const modelName = result.modelId ?? "vision model";
-    const target = result.modelEndpoint ? `${modelName} (${result.modelEndpoint})` : modelName;
-    const egressNote = result.egressOccurred ? ` Your image and prompt/context were sent to ${target}.` : "";
-    if (result.status === "failed") {
-      const reason = result.egressOccurred ? "the vision model request failed" : "the vision bridge could not run";
-      return `Vision bridge (${modelName}) failed: ${reason}.${egressNote} The image was not interpreted.`;
-    }
-    if (result.status === "skipped") {
-      return `Vision bridge cancelled.${egressNote}`;
-    }
-    const omitted = result.omittedCount > 0 ? ` (${result.omittedCount} image(s) omitted)` : "";
-    return `Converted ${result.convertedCount} image(s)${omitted} to text via ${target}. Your image and prompt/context were sent to that model.`;
-  }
   async #resolveExtensionMentionParts(extensionMentions, abortSignal) {
     if (extensionMentions.size === 0) return [];
     const activeExtensions = this.config.getActiveExtensions?.() ?? [];
@@ -5830,132 +6194,6 @@ function isBulkLoadReplayRequest(params) {
   return meta?.[LOAD_REPLAY_MODE_META_KEY] === LOAD_REPLAY_BULK_MODE;
 }
 __name(isBulkLoadReplayRequest, "isBulkLoadReplayRequest");
-function createReplayCumulativeUsage() {
-  return {
-    promptTokens: 0,
-    cachedTokens: 0,
-    candidateTokens: 0,
-    apiTimeMs: 0
-  };
-}
-__name(createReplayCumulativeUsage, "createReplayCumulativeUsage");
-function copyCumulativeUsage(target, source) {
-  target.promptTokens = source.promptTokens;
-  target.cachedTokens = source.cachedTokens;
-  target.candidateTokens = source.candidateTokens;
-  target.apiTimeMs = source.apiTimeMs;
-}
-__name(copyCumulativeUsage, "copyCumulativeUsage");
-function isCumulativeUsage(value) {
-  if (!isObjectRecord(value)) return false;
-  return typeof value["promptTokens"] === "number" && Number.isFinite(value["promptTokens"]) && typeof value["cachedTokens"] === "number" && Number.isFinite(value["cachedTokens"]) && typeof value["candidateTokens"] === "number" && Number.isFinite(value["candidateTokens"]) && typeof value["apiTimeMs"] === "number" && Number.isFinite(value["apiTimeMs"]);
-}
-__name(isCumulativeUsage, "isCumulativeUsage");
-function isPendingReplayToolCall(value) {
-  if (!isObjectRecord(value)) return false;
-  return typeof value["callId"] === "string" && typeof value["toolName"] === "string" && (value["timestamp"] === void 0 || typeof value["timestamp"] === "string") && typeof value["recordId"] === "string";
-}
-__name(isPendingReplayToolCall, "isPendingReplayToolCall");
-function parseTranscriptReplayState(replay) {
-  if (!isObjectRecord(replay)) {
-    return {
-      pendingToolCalls: [],
-      cumulativeUsage: createReplayCumulativeUsage()
-    };
-  }
-  const rawPending = replay["pendingToolCalls"];
-  const pendingToolCalls = Array.isArray(rawPending) ? rawPending.filter(isPendingReplayToolCall) : [];
-  if (Array.isArray(rawPending) && pendingToolCalls.length !== rawPending.length) {
-    const dropped = rawPending.length - pendingToolCalls.length;
-    debugLogger7.warn(
-      `[transcript] replay state dropped ${dropped} of ${rawPending.length} malformed pending tool calls`
-    );
-  }
-  const cumulativeUsage = isCumulativeUsage(replay["cumulativeUsage"]) ? { ...replay["cumulativeUsage"] } : createReplayCumulativeUsage();
-  return { pendingToolCalls, cumulativeUsage };
-}
-__name(parseTranscriptReplayState, "parseTranscriptReplayState");
-async function collectHistoryReplayUpdates({
-  sessionId,
-  config,
-  records,
-  gaps,
-  cumulativeUsage
-}) {
-  const updates = [];
-  const replayContext = {
-    sessionId,
-    config,
-    sendUpdate: /* @__PURE__ */ __name(async (update) => {
-      updates.push(update);
-    }, "sendUpdate"),
-    cumulativeUsage
-  };
-  try {
-    await new HistoryReplayer(replayContext).replay(records, gaps);
-  } catch (error) {
-    const replayError = error instanceof Error ? error.message : String(error);
-    debugLogger7.warn(
-      "[historyReplay] History replay failed for session %s (partial updates: %d):",
-      sessionId,
-      updates.length,
-      error
-    );
-    return { updates, replayError };
-  }
-  return { updates };
-}
-__name(collectHistoryReplayUpdates, "collectHistoryReplayUpdates");
-async function collectHistoryReplayUpdatesPage({
-  sessionId,
-  config,
-  records,
-  gaps,
-  cumulativeUsage,
-  pendingToolCalls,
-  finalizeDangling
-}) {
-  const updates = [];
-  const replayContext = {
-    sessionId,
-    config,
-    sendUpdate: /* @__PURE__ */ __name(async (update) => {
-      updates.push(update);
-    }, "sendUpdate"),
-    cumulativeUsage
-  };
-  const replayer = new HistoryReplayer(replayContext);
-  try {
-    const state = await replayer.replayPage(records, {
-      pendingToolCalls,
-      finalizeDangling,
-      gaps
-    });
-    return { updates, pendingToolCalls: state.pendingToolCalls };
-  } catch (error) {
-    debugLogger7.warn(
-      "[historyReplay] Paged history replay failed for session %s (partial updates: %d):",
-      sessionId,
-      updates.length,
-      error
-    );
-    return {
-      updates,
-      pendingToolCalls: replayer.getPendingToolCalls(),
-      replayError: "Replay conversion failed for this page"
-    };
-  }
-}
-__name(collectHistoryReplayUpdatesPage, "collectHistoryReplayUpdatesPage");
-function liftSessionUpdateTimestamps(updates) {
-  return updates.map((update) => {
-    const record = update;
-    const meta = record["_meta"];
-    const timestamp = isObjectRecord(meta) ? meta["timestamp"] : void 0;
-    return typeof timestamp === "number" || typeof timestamp === "string" ? { ...record, timestamp } : update;
-  });
-}
-__name(liftSessionUpdateTimestamps, "liftSessionUpdateTimestamps");
 function createHiddenWorkspaceMemoryConfig(config) {
   return new Proxy(config, {
     get(target, prop) {
@@ -6013,6 +6251,10 @@ var QWEN_CORE_SETTING_DEFINITIONS = {
   "general.showSessionRecap": { type: "boolean" },
   "general.sessionRecapAwayThresholdMinutes": { type: "number", min: 1 },
   "general.terminalBell": { type: "boolean" },
+  "general.notificationMode": {
+    type: "enum",
+    values: ["all", "task-complete"]
+  },
   "general.gitCoAuthor.commit": { type: "boolean" },
   "general.gitCoAuthor.pr": { type: "boolean" },
   "general.defaultFileEncoding": {
@@ -6037,7 +6279,7 @@ var QWEN_HOOK_EVENTS = Object.values(HookEventName);
 var DEFAULT_QWEN_MEMORY_SETTINGS = {
   enableManagedAutoMemory: true,
   enableManagedAutoDream: true,
-  enableAutoSkill: true,
+  enableAutoSkill: false,
   autoSkillConfirm: true,
   enableTeamMemory: false,
   enableTeamMemorySync: false
@@ -7643,6 +7885,7 @@ var QwenAgent = class {
     __name(this, "QwenAgent");
   }
   sessions = /* @__PURE__ */ new Map();
+  generationControllers = /* @__PURE__ */ new Map();
   transcriptReplayConfigCache = /* @__PURE__ */ new Map();
   clientCapabilities;
   // CPU-usage delta baseline for the daemon's `workspaceResource` extMethod
@@ -7697,6 +7940,11 @@ var QwenAgent = class {
     }
   }
   async closeStoredSession(sessionId, opts) {
+    for (const [requestId, generation] of this.generationControllers) {
+      if (generation.sessionId !== sessionId) continue;
+      generation.controller.abort();
+      this.generationControllers.delete(requestId);
+    }
     const session = this.sessions.get(sessionId);
     if (!session) {
       this.mcpPool?.releaseSession(sessionId);
@@ -7775,6 +8023,10 @@ var QwenAgent = class {
     this.sessions.delete(sessionId);
   }
   disposeSessions() {
+    for (const generation of this.generationControllers.values()) {
+      generation.controller.abort();
+    }
+    this.generationControllers.clear();
     for (const session of this.sessions.values()) {
       session.dispose();
     }
@@ -7809,7 +8061,7 @@ var QwenAgent = class {
   async initialize(args) {
     this.clientCapabilities = args.clientCapabilities;
     const authMethods = buildAuthMethods();
-    const version = "0.19.9";
+    const version = "0.19.10-nightly.20260716.506ce0a1a";
     return {
       protocolVersion: PROTOCOL_VERSION,
       agentInfo: {
@@ -7933,9 +8185,10 @@ var QwenAgent = class {
             config,
             records,
             gaps: sessionData?.historyGaps,
-            cumulativeUsage: replayUsage
+            cumulativeUsage: replayUsage,
+            logger: debugLogger7
           });
-          replayUpdates = liftSessionUpdateTimestamps(replay.updates);
+          replayUpdates = replay.updates;
           copyCumulativeUsage(session.cumulativeUsage, replayUsage);
           if (replay.replayError !== void 0) {
             replayEnvelope = {
@@ -9191,6 +9444,19 @@ var QwenAgent = class {
     }
     return session;
   }
+  async refreshLiveSessionMemoryInstructions(logContext) {
+    const sessions = [...this.sessions.values()];
+    if (sessions.length === 0) {
+      return;
+    }
+    await Promise.all(
+      sessions.map(
+        (session) => refreshMemoryInstruction(session.getConfig(), {
+          logContext: `${logContext} session ${session.getId()}`
+        })
+      )
+    );
+  }
   buildSessionContextStatus(sessionId) {
     const session = this.sessionOrThrow(sessionId);
     const config = session.getConfig();
@@ -10041,43 +10307,25 @@ var QwenAgent = class {
               ...typeof rawLimit === "number" ? { limit: rawLimit } : {}
             });
             const config = await this.getTranscriptReplayConfig(cwd, settings);
-            const replayState = parseTranscriptReplayState(page.replay);
-            const replay = await collectHistoryReplayUpdatesPage({
+            const replay = await replayTranscriptRecordPage({
               sessionId,
+              page,
               config,
-              records: page.records,
-              gaps: page.gaps,
-              cumulativeUsage: replayState.cumulativeUsage,
-              pendingToolCalls: replayState.pendingToolCalls,
-              finalizeDangling: !page.hasMore
+              encodeCursor: /* @__PURE__ */ __name((state) => encodeSessionTranscriptCursor(state, cwd), "encodeCursor"),
+              logger: debugLogger7
             });
-            const updates = liftSessionUpdateTimestamps(replay.updates);
-            let nextCursor;
-            if (page.nextCursorState && replay.replayError === void 0) {
-              const nextCursorState = {
-                ...page.nextCursorState,
-                replay: {
-                  pendingToolCalls: replay.pendingToolCalls,
-                  // Preserved for future replay emitters that need cumulative
-                  // usage across page boundaries; current frames expose per-record
-                  // usage metadata only.
-                  cumulativeUsage: replayState.cumulativeUsage
-                }
-              };
-              nextCursor = encodeSessionTranscriptCursor(nextCursorState, cwd);
-            }
             return {
               v: 1,
               sessionId,
-              events: updates.map((update) => ({
+              events: replay.updates.map((update) => ({
                 v: 1,
                 type: "session_update",
                 data: update
               })),
-              ...nextCursor !== void 0 ? { nextCursor } : {},
-              hasMore: page.hasMore,
-              startTime: page.startTime,
-              lastUpdated: page.lastUpdated,
+              ...replay.nextCursor !== void 0 ? { nextCursor: replay.nextCursor } : {},
+              hasMore: replay.hasMore,
+              startTime: replay.startTime,
+              lastUpdated: replay.lastUpdated,
               ...replay.replayError !== void 0 ? { partial: true, replayError: replay.replayError } : {}
             };
           });
@@ -10228,6 +10476,11 @@ var QwenAgent = class {
             contextMode,
             abortSignal: childSignal
           });
+          if (result.filesTouched.length > 0) {
+            await this.refreshLiveSessionMemoryInstructions(
+              "workspace memory remember"
+            );
+          }
           return result;
         } catch (err) {
           if (err instanceof RequestError) {
@@ -10806,8 +11059,7 @@ var QwenAgent = class {
         const recording = session.getConfig().getChatRecordingService();
         let ok = false;
         if (recording) {
-          ok = recording.recordCustomTitle(displayName, source);
-          await recording.flush();
+          ok = await recording.recordCustomTitle(displayName, source);
         }
         return { sessionId, displayName, titleSource: source, persisted: ok };
       }
@@ -10834,6 +11086,39 @@ var QwenAgent = class {
         }
         return { sessionId, parentSessionId, persisted: ok };
       }
+      case SERVE_CONTROL_EXT_METHODS.sessionSource: {
+        const sessionId = params["sessionId"];
+        const sourceType = params["sourceType"];
+        const sourceId = params["sourceId"];
+        if (typeof sessionId !== "string" || sessionId.length === 0) {
+          throw RequestError.invalidParams(
+            void 0,
+            "Invalid or missing sessionId"
+          );
+        }
+        const source = parseSessionSource(sourceType, sourceId);
+        if ("error" in source || source.sourceType === void 0) {
+          throw RequestError.invalidParams(
+            void 0,
+            "error" in source ? source.error : "Invalid or missing sourceType"
+          );
+        }
+        const session = this.sessionOrThrow(sessionId);
+        const recording = session.getConfig().getChatRecordingService();
+        let ok = false;
+        if (recording) {
+          ok = await recording.recordSessionSource(
+            source.sourceType,
+            source.sourceId
+          );
+        }
+        return {
+          sessionId,
+          sourceType: source.sourceType,
+          ...source.sourceId !== void 0 ? { sourceId: source.sourceId } : {},
+          persisted: ok
+        };
+      }
       case SERVE_CONTROL_EXT_METHODS.sessionClose: {
         const sessionId = params["sessionId"];
         if (typeof sessionId !== "string" || sessionId.length === 0) {
@@ -11076,6 +11361,64 @@ var QwenAgent = class {
         );
         return { sessionId, recap };
       }
+      case SERVE_CONTROL_EXT_METHODS.sessionGenerationStart: {
+        const sessionId = params["sessionId"];
+        const requestId = params["requestId"];
+        const prompt = params["prompt"];
+        if (typeof sessionId !== "string" || typeof requestId !== "string" || typeof prompt !== "string" || prompt.trim().length === 0 || Buffer.byteLength(prompt, "utf8") > GENERATION_MAX_PROMPT_BYTES) {
+          throw RequestError.invalidParams(
+            void 0,
+            "Invalid generation request"
+          );
+        }
+        if (this.generationControllers.has(requestId)) {
+          throw RequestError.invalidParams(
+            void 0,
+            "Duplicate generation requestId"
+          );
+        }
+        const session = this.sessionOrThrow(sessionId);
+        const controller = new AbortController();
+        this.generationControllers.set(requestId, { sessionId, controller });
+        const signal = AbortSignal.any([
+          controller.signal,
+          AbortSignal.timeout(GENERATION_TIMEOUT_MS)
+        ]);
+        try {
+          const result = await executeGeneration(
+            session.getConfig(),
+            requestId,
+            prompt,
+            signal,
+            async (event) => {
+              await this.connection.extNotification(
+                "qwen/notify/session/generation/event",
+                { v: 1, sessionId, requestId, event }
+              );
+            }
+          );
+          return { sessionId, requestId, ...result };
+        } finally {
+          this.generationControllers.delete(requestId);
+        }
+      }
+      case SERVE_CONTROL_EXT_METHODS.sessionGenerationCancel: {
+        const sessionId = params["sessionId"];
+        const requestId = params["requestId"];
+        if (typeof sessionId !== "string" || typeof requestId !== "string") {
+          throw RequestError.invalidParams(
+            void 0,
+            "Invalid generation cancellation request"
+          );
+        }
+        const generation = this.generationControllers.get(requestId);
+        const cancelled = generation?.sessionId === sessionId;
+        if (cancelled) {
+          generation.controller.abort();
+          this.generationControllers.delete(requestId);
+        }
+        return { sessionId, requestId, cancelled };
+      }
       case SERVE_CONTROL_EXT_METHODS.sessionBtw: {
         const sessionId = params["sessionId"];
         if (typeof sessionId !== "string" || sessionId.length === 0) {
@@ -11506,28 +11849,33 @@ ${outputText}
       case SERVE_CONTROL_EXT_METHODS.workspaceExtensionsRefresh: {
         const sessionId = params["sessionId"];
         const session = this.sessionOrThrow(sessionId);
-        const extensionManager = session.getConfig().getExtensionManager();
-        const skillManager = session.getConfig().getSkillManager();
-        await Promise.all([
-          extensionManager.refreshCache().catch((err) => {
-            debugLogger7.warn(
-              `Extension refresh failed for session ${sessionId}: ${err instanceof Error ? err.message : String(err)}`
-            );
-          }),
-          skillManager?.refreshCache().catch((err) => {
-            debugLogger7.warn(
-              `Skill refresh failed after extension refresh for session ${sessionId}: ${err instanceof Error ? err.message : String(err)}`
-            );
-          })
-        ]);
-        try {
-          await extensionManager.refreshTools();
-        } catch (err) {
-          debugLogger7.warn(
-            `Extension tool refresh failed for session ${sessionId}: ${err instanceof Error ? err.message : String(err)}`
+        const config = session.getConfig();
+        const extensionManager = config.getExtensionManager();
+        const errors = [];
+        const runRefresh = /* @__PURE__ */ __name(async (refresh) => {
+          try {
+            await refresh();
+          } catch (error) {
+            errors.push(error);
+          }
+        }, "runRefresh");
+        await runRefresh(async () => await extensionManager.refreshCache());
+        await runRefresh(async () => await extensionManager.refreshTools());
+        await runRefresh(
+          async () => await config.getGeminiClient()?.refreshSystemInstruction()
+        );
+        await runRefresh(
+          async () => await session.sendAvailableCommandsUpdate()
+        );
+        if (errors.length > 0) {
+          const details = errors.map(
+            (error) => error instanceof Error ? error.message : String(error)
+          ).join("; ");
+          throw new AggregateError(
+            errors,
+            `Extension runtime refresh failed: ${details}`
           );
         }
-        await session.sendAvailableCommandsUpdate();
         return { ok: true };
       }
       case "deleteSession": {
@@ -11571,8 +11919,7 @@ ${outputText}
         }
         const liveRecording = this.sessions.get(sessionId)?.getConfig().getChatRecordingService();
         if (liveRecording) {
-          const ok = liveRecording.recordCustomTitle(title, "manual");
-          await liveRecording.flush();
+          const ok = await liveRecording.recordCustomTitle(title, "manual");
           return { success: ok };
         }
         const success = await runWithAcpRuntimeOutputDir(
@@ -11706,9 +12053,10 @@ ${outputText}
             };
           }
         } catch (err) {
-          artifactSnapshotUnavailable = err instanceof Error ? err.message : String(err);
+          const reason = err instanceof Error ? err.message : String(err);
+          artifactSnapshotUnavailable = "artifact snapshot unavailable after rewind";
           debugLogger7.warn(
-            `[ACP] Failed to rebuild artifact snapshot after rewind for session=${sessionId}: ${artifactSnapshotUnavailable}`
+            `[ACP] Failed to rebuild artifact snapshot after rewind for session=${sessionId}: ${reason}`
           );
         }
         return {
@@ -11745,10 +12093,11 @@ ${outputText}
           config: this.config,
           records: sessionData.conversation.messages,
           gaps: sessionData.historyGaps,
-          cumulativeUsage: createReplayCumulativeUsage()
+          cumulativeUsage: createReplayCumulativeUsage(),
+          logger: debugLogger7
         });
         return {
-          updates: liftSessionUpdateTimestamps(replay.updates),
+          updates: replay.updates,
           startTime: sessionData.conversation.startTime,
           lastUpdated: sessionData.conversation.lastUpdated,
           // Signal to the client that replay aborted partway so it doesn't
@@ -12166,6 +12515,29 @@ ${outputText}
           sessionsSkipped: skipped
         };
       }
+      case SERVE_CONTROL_EXT_METHODS.workspaceSkillsRefresh: {
+        this.settings.reloadScopeFromDisk("Workspace" /* Workspace */);
+        const sessions = this.getActiveSessions();
+        const results = await Promise.allSettled(
+          sessions.map((session) => session.refreshSkillsFromSettings())
+        );
+        for (let i = 0; i < results.length; i++) {
+          if (results[i].status === "rejected") {
+            const reason = results[i].reason;
+            debugLogger7.warn(
+              `Session ${sessions[i].getId()} skill refresh failed: ${reason}`
+            );
+          }
+        }
+        return {
+          sessionsRefreshed: results.filter(
+            (result) => result.status === "fulfilled"
+          ).length,
+          sessionsFailed: results.filter(
+            (result) => result.status === "rejected"
+          ).length
+        };
+      }
       default:
         throw RequestError.methodNotFound(method);
     }