@qwen-code/qwen-code 0.19.9 → 0.19.10

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

@@ -3,7 +3,7 @@
 import {
   classifyApiError,
   prefixMidTurnUserMessageParts
-} from "./chunk-Q4YQW46J.js";
+} from "./chunk-WIASPMLX.js";
 import {
   EXTENSION_CONTEXT_BUDGET,
   buildExtensionMentionContext,
@@ -12,96 +12,102 @@ import {
   matchMcpServerByRef,
   parseExtensionRef,
   parseMcpServerRef
-} from "./chunk-77XJ3SWN.js";
+} from "./chunk-X362TMXZ.js";
 import {
   getAvailableCommands,
   handleSlashCommand,
   insertAfterFunctionResponses,
   isSlashCommand,
   normalizePartList
-} from "./chunk-5U27BZ72.js";
+} from "./chunk-YX4LLZ3D.js";
 import {
   appEvents,
   buildDisabledSkillNamesProvider,
   loadCliConfig,
   normalizeDisabledToolList
-} from "./chunk-5HOMWMCL.js";
-import "./chunk-5DTTYNB7.js";
-import {
-  collectContextData,
-  formatContextUsageText
-} from "./chunk-D2GFWEXB.js";
+} from "./chunk-CEW4HDPK.js";
 import {
   getCommandSubcommandNames
-} from "./chunk-AURZZYMD.js";
-import "./chunk-JZETEN3Z.js";
+} from "./chunk-XXJKGHZV.js";
+import "./chunk-422XAKCK.js";
 import {
   getEffectiveSupportedModes
-} from "./chunk-GWLSNBG4.js";
+} from "./chunk-DK33QJ3V.js";
+import "./chunk-K4PZ5F5T.js";
+import "./chunk-5DTTYNB7.js";
+import {
+  collectContextData,
+  formatContextUsageText
+} from "./chunk-B5I2IIWY.js";
 import "./chunk-4WGODMVR.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-EQY6POVO.js";
+import "./chunk-7L4XBYVW.js";
 import "./chunk-YAF2MQZ6.js";
+import "./chunk-Q6TUALBE.js";
+import "./chunk-KW7NOTN6.js";
 import {
   MAX_REMEMBER_CONTENT_BYTES,
+  collectHistoryReplayUpdates,
+  copyCumulativeUsage,
+  createReplayCumulativeUsage,
   createWorkspaceMemoryExtractionErrorLogger,
   formatWorkspaceMemoryForgetSummary,
   isValidServerName,
+  replayTranscriptRecordPage,
   shouldSuppressRememberErrorDetails,
   workspaceMemoryFailureCode,
   workspaceMemoryFailureDiagnostics
-} from "./chunk-GZRTYZ2R.js";
+} from "./chunk-6W6DI34P.js";
 import {
   HistoryReplayer,
   MessageEmitter,
   PlanEmitter,
   ToolCallEmitter
-} from "./chunk-N3EMS75V.js";
-import "./chunk-U2NNEY4R.js";
-import "./chunk-Q6I5QHMH.js";
+} from "./chunk-4FMG7EDJ.js";
+import "./chunk-SPUYQB4T.js";
+import "./chunk-WTSXKLG5.js";
 import "./chunk-QHTIBUWB.js";
 import "./chunk-L573Z2QZ.js";
+import {
+  computeCpuPercent
+} from "./chunk-HGT6JR3U.js";
+import "./chunk-RXFQM6FQ.js";
+import "./chunk-WDW64OW3.js";
+import "./chunk-6H67XLET.js";
+import "./chunk-L62SEJWY.js";
+import "./chunk-65N2J6V2.js";
+import "./chunk-WDWJ4OQJ.js";
+import "./chunk-E5Z2AVNV.js";
+import {
+  formatAcpModelId,
+  parseAcpBaseModelId,
+  parseAcpModelOption,
+  sanitizeProviderBaseUrl
+} from "./chunk-GGJII3FM.js";
+import {
+  mapSkillConfigToStatus
+} from "./chunk-2W3OOD4W.js";
 import {
   PERMISSION_RULE_TYPES,
   PermissionRulesValidationError,
   buildPermissionSettings,
   normalizePermissionRules,
   readPermissionRuleSet
-} from "./chunk-5VXNZWGF.js";
+} from "./chunk-N6FXRR6P.js";
 import {
   MAX_AUDIO_BYTES,
   sanitizeVoiceErrorMessage,
   transcribeVoiceAudio
-} from "./chunk-PDZ7MBDG.js";
+} from "./chunk-FXMC7SL2.js";
 import {
   readVoiceModel
-} from "./chunk-HPDUL5MF.js";
-import "./chunk-LK7KUE55.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";
+} from "./chunk-DPFBNG72.js";
+import "./chunk-FSA7ERJ2.js";
 import {
   CLIENT_MCP_OVER_WS_CONFIG_FLAG,
   LOAD_REPLAY_BULK_MODE,
@@ -110,21 +116,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-KSO42X3Z.js";
+import "./chunk-Q5GLXH5Q.js";
+import "./chunk-AAR5SGMD.js";
+import "./chunk-57OAHC2Y.js";
+import "./chunk-OATTJGPJ.js";
+import "./chunk-ZRKBI3DP.js";
+import "./chunk-V6WHFGST.js";
 import {
-  formatAcpModelId,
-  parseAcpBaseModelId,
-  parseAcpModelOption,
-  sanitizeProviderBaseUrl
-} from "./chunk-34MW4KTI.js";
+  createLoadedSettingsAdapter
+} from "./chunk-W34A5MJH.js";
 import {
-  mapSkillConfigToStatus
-} from "./chunk-L36P3NBD.js";
+  ndJsonStream
+} from "./chunk-TEGEBB2I.js";
 import {
   ACP_PREFLIGHT_KINDS,
   IDLE_HOOK_EVENTS,
@@ -132,14 +140,21 @@ import {
   SERVE_STATUS_EXT_METHODS,
   STATUS_SCHEMA_VERSION,
   mapDomainErrorToErrorKind
-} from "./chunk-VWPVHAMO.js";
-import "./chunk-DC5Z3DU6.js";
-import "./chunk-V6WHFGST.js";
+} from "./chunk-CUUXANEQ.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-BBNVFRGD.js";
+import "./chunk-SXU3KKNI.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-YYPXHMWO.js";
 import {
   OUTPUT_LANGUAGE_AUTO,
   getOutputLanguageFilePath,
@@ -150,44 +165,37 @@ import {
   resolveOutputLanguage,
   updateOutputLanguageFile,
   writeOutputLanguageAndRegisterPath
-} from "./chunk-4C5BQ2D2.js";
+} from "./chunk-6GETGQWP.js";
 import "./chunk-RKUWKYED.js";
 import {
   SUPPORTED_LANGUAGES,
   getCurrentLanguage,
   setLanguageAsync
-} from "./chunk-YAUFFXDS.js";
+} from "./chunk-RDRVMDWV.js";
 import {
   findEnvFiles,
   preResolveHomeEnvOverrides,
   reloadEnvironment
-} from "./chunk-SCGXUJBT.js";
+} from "./chunk-5EBKKSBX.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-4YWLED2A.js";
+import "./chunk-ALGGS7UH.js";
+import "./chunk-MR3PXB6E.js";
 import {
   writeStderrLine
 } from "./chunk-YUZI3WAC.js";
+import "./chunk-XFSFZCM5.js";
+import "./chunk-YU56QGXX.js";
+import "./chunk-VJNBRRZG.js";
 import {
   ALL_PROVIDERS,
   APPROVAL_MODE_INFO,
@@ -205,7 +213,7 @@ import {
   McpBudgetWouldExceedError,
   McpServerSpawnFailedError,
   McpTransportPool,
-  ORPHAN_TOOL_USE_REPAIR_REASON,
+  MessageDisplayDispatcher,
   POOLED_TRANSPORTS_DEFAULT,
   SESSION_ARTIFACT_PERSISTENCE_VERSION,
   SESSION_TITLE_MAX_LENGTH,
@@ -226,7 +234,7 @@ import {
   buildBtwPrompt,
   buildContextUsage,
   buildInstallPlan,
-  buildSyntheticToolResponseParts,
+  buildSessionRecoveryPlanFromApiHistory,
   clampInlineMediaPart,
   clearGoalTerminalObserver,
   computeUniqueBranchTitle,
@@ -235,7 +243,6 @@ import {
   dedupeToolCallsById,
   detectAutonomousSentinel,
   detectLoopSentinel,
-  detectTurnInterruption,
   encodeSessionTranscriptCursor,
   evaluateAutoMode,
   evaluatePermissionFlow,
@@ -281,6 +288,8 @@ import {
   recordAllow,
   recordFallbackApprove,
   redactUrlCredentials,
+  refreshMemoryAfterManagedWrite,
+  refreshMemoryInstruction,
   resolveBaseUrl,
   restoreWorktreeContext,
   runForkedAgent,
@@ -299,37 +308,37 @@ import {
   subagentGenerator,
   unregisterGoalHook,
   updateSetting
-} from "./chunk-NVYTCB5Z.js";
-import "./chunk-CU3L64TP.js";
-import "./chunk-ZJE7NSL3.js";
+} from "./chunk-K7CRWKOE.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 "./chunk-5M6IDOMF.js";
+import "./chunk-E67NFMF4.js";
+import "./chunk-RCEEXIOO.js";
+import "./chunk-KKRTYONM.js";
+import "./chunk-TV6K2FB4.js";
+import "./chunk-E2UVIFI2.js";
 import {
   runSideQuery
-} from "./chunk-W2UIXQDL.js";
+} from "./chunk-6OATMEYN.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-TXY2C3D2.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,
@@ -354,7 +363,7 @@ import {
   startToolSpan,
   uiTelemetryService,
   withInteractionSpan
-} from "./chunk-3VAGG5T5.js";
+} from "./chunk-P6LART6G.js";
 import "./chunk-4WKAA4KS.js";
 import "./chunk-CR3C7WXL.js";
 import "./chunk-CARU2RR2.js";
@@ -362,44 +371,44 @@ 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-WX6SD4IQ.js";
 import {
   ToolConfirmationOutcome,
   ToolNames
-} from "./chunk-B5ORX3FG.js";
+} from "./chunk-2UUAIFQO.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 {
   DEFAULT_TOKEN_LIMIT,
   tokenLimit
-} from "./chunk-524RQP4Q.js";
-import "./chunk-JSG7ZSBC.js";
+} from "./chunk-B7NUUEXC.js";
+import "./chunk-TQBODCFD.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-XLIRF7IK.js";
 import {
   runExitCleanup
-} from "./chunk-ECNYL4AA.js";
+} from "./chunk-TISZXPAX.js";
 import "./chunk-75DOP5OR.js";
 import "./chunk-DMTGGOSA.js";
 import "./chunk-YQ3U5MUC.js";
@@ -1337,7 +1346,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 +1401,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 +1490,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);
     }
   }
 };
@@ -2022,6 +2040,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 +2150,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 +2410,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 +2545,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 +2562,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 +2600,8 @@ var Session = class {
             } else {
               parts = await this.#resolvePrompt(
                 params.prompt,
-                pendingSend.signal
+                pendingSend.signal,
+                { promptLast: true }
               );
             }
             const hooksEnabled = !this.config.getDisableAllHooks?.();
@@ -2656,6 +2678,9 @@ ${this.pendingWorktreeNotice}
                 const functionCalls = [];
                 let usageMetadata = null;
                 const streamStartTime = Date.now();
+                const messageDisplay = this.#createMessageDisplayDispatcher(
+                  pendingSend.signal
+                );
                 try {
                   const sendResult = await this.#sendMessageStreamWithAutoCompression(
                     promptId,
@@ -2686,6 +2711,9 @@ ${this.pendingWorktreeNotice}
                           "assistant",
                           part.thought
                         );
+                        if (!part.thought) {
+                          messageDisplay?.addChunk(part.text);
+                        }
                       }
                     }
                     if (resp.type === "chunk" /* CHUNK */ && resp.value.usageMetadata) {
@@ -2728,6 +2756,8 @@ ${this.pendingWorktreeNotice}
                     );
                   }
                   throw error;
+                } finally {
+                  await messageDisplay?.finish();
                 }
                 if (usageMetadata) {
                   this.#recordPromptTokenCount(usageMetadata);
@@ -2876,6 +2906,9 @@ ${this.pendingWorktreeNotice}
           const functionCalls = [];
           let usageMetadata = null;
           const streamStartTime = Date.now();
+          const messageDisplay = this.#createMessageDisplayDispatcher(
+            pendingSend.signal
+          );
           try {
             const continueSendResult = await this.#sendMessageStreamWithAutoCompression(
               promptId + "_stop_hook_" + stopHookIterationCount,
@@ -2905,6 +2938,9 @@ ${this.pendingWorktreeNotice}
                     "assistant",
                     part.thought
                   );
+                  if (!part.thought) {
+                    messageDisplay?.addChunk(part.text);
+                  }
                 }
               }
               if (resp.type === "chunk" /* CHUNK */ && resp.value.usageMetadata) {
@@ -2938,6 +2974,8 @@ ${this.pendingWorktreeNotice}
               );
             }
             throw error;
+          } finally {
+            await messageDisplay?.finish();
           }
           if (usageMetadata) {
             this.#recordPromptTokenCount(usageMetadata);
@@ -2993,6 +3031,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;
@@ -3519,28 +3579,38 @@ ${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
+                );
+                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 */ && resp.value.functionCalls) {
+                      functionCalls.push(...resp.value.functionCalls);
+                    }
+                    if (resp.type === "model_fallback" /* MODEL_FALLBACK */) {
+                      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;
-                  }
+                } finally {
+                  await messageDisplay?.finish();
                 }
                 if (usageMetadata) {
                   this.#recordPromptTokenCount(usageMetadata);
@@ -3649,15 +3719,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) {
@@ -3746,35 +3828,43 @@ ${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
+            );
+            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 */ && resp.value.functionCalls) {
+                  functionCalls.push(...resp.value.functionCalls);
+                }
+                if (resp.type === "model_fallback" /* MODEL_FALLBACK */) {
+                  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;
-              }
+            } finally {
+              await messageDisplay?.finish();
             }
             if (responseText.length > 0) {
               await this.#emitBackgroundNotificationResponse(
@@ -3901,26 +3991,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 +4330,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 +4454,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
@@ -5082,7 +5225,14 @@ ${this.pendingWorktreeNotice}
           }
           return {
             parts: responseParts,
-            stopAfterPermissionCancel: nestedPermissionCancelled
+            stopAfterPermissionCancel: nestedPermissionCancelled,
+            memoryWriteCandidates: status === "success" ? [
+              {
+                toolName,
+                args,
+                status
+              }
+            ] : void 0
           };
         } catch (e) {
           cleanupAgentToolResources();
@@ -5203,7 +5353,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 +5369,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 +5392,8 @@ ${this.pendingWorktreeNotice}
       case "no_command":
         return this.#resolvePrompt(
           originalPrompt,
-          new AbortController().signal
+          new AbortController().signal,
+          { promptLast: true }
         );
       default: {
         const _exhaustive = result;
@@ -5251,7 +5402,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 +5492,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 +5500,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 +5524,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
@@ -5830,132 +5977,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) {
@@ -7809,7 +7830,7 @@ var QwenAgent = class {
   async initialize(args) {
     this.clientCapabilities = args.clientCapabilities;
     const authMethods = buildAuthMethods();
-    const version = "0.19.9";
+    const version = "0.19.10";
     return {
       protocolVersion: PROTOCOL_VERSION,
       agentInfo: {
@@ -7933,9 +7954,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 +9213,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 +10076,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 +10245,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 +10828,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 };
       }
@@ -11506,28 +11527,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 +11597,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 +11731,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 +11771,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 +12193,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);
     }