@qwen-code/qwen-code 0.19.5 → 0.19.6-nightly.20260705.015ee4248

package/chunks/{server-QSQ45QFR.js → server-QIYIN34N.js}

@@ -1,21 +1,46 @@
 // Force strict mode and setup for ESM
 "use strict";
-import {
-  openQwenAsrRealtimeStream,
-  openVoiceStream,
-  openVoiceStreamWithRetry
-} from "./chunk-G4M7FPNY.js";
 import {
   MAX_REMEMBER_CONTENT_BYTES,
   extractRememberErrorCode,
+  formatWorkspaceMemoryDreamSummary,
+  formatWorkspaceMemoryForgetSummary,
   isValidServerName
-} from "./chunk-RM3PGSGL.js";
+} from "./chunk-6SHO7WFF.js";
+import {
+  openQwenAsrRealtimeStream,
+  openVoiceStream,
+  openVoiceStreamWithRetry
+} from "./chunk-RB5GAQR6.js";
 import {
   SetupGithubError,
-  setupGithub
-} from "./chunk-L7QPM2YD.js";
+  collectSessionData,
+  generateExportFilename,
+  normalizeSessionData,
+  setupGithub,
+  toHtml,
+  toJson,
+  toJsonl,
+  toMarkdown
+} from "./chunk-JFFOH2XO.js";
 import "./chunk-54YZOP7P.js";
-import "./chunk-2CAII5HD.js";
+import "./chunk-J7XUJALJ.js";
+import {
+  createDaemonStatusProvider
+} from "./chunk-IL6ZEDZ2.js";
+import "./chunk-3VRMGS3A.js";
+import "./chunk-KHDZHZMH.js";
+import {
+  createWorkspaceProvidersStatusProvider
+} from "./chunk-NYKWPUAE.js";
+import {
+  getAuthTypeFromEnv,
+  resolveCliGenerationConfig
+} from "./chunk-OGEJMKN5.js";
+import {
+  createWorkspaceSkillsStatusProvider
+} from "./chunk-3WOJO5EJ.js";
+import "./chunk-6IAWPIQ6.js";
 import {
   EMPTY_WORKSPACE_VOICE_UPDATE_ERROR,
   WorkspaceVoiceError,
@@ -26,7 +51,14 @@ import {
   transcribeWorkspaceVoiceAudio,
   validateWorkspaceVoiceState,
   voiceSettingsScopeToWire
-} from "./chunk-CSPSJU5R.js";
+} from "./chunk-7WLJPMWU.js";
+import {
+  PermissionRulesValidationError,
+  buildPermissionSettings,
+  isPermissionRuleType,
+  normalizePermissionRules,
+  readPermissionRuleSet
+} from "./chunk-WKP5QZOP.js";
 import {
   assertVoiceBaseUrlNetworkAllowed,
   isStreamingVoiceModel,
@@ -34,20 +66,17 @@ import {
   resolveVoiceTranscriptionConfig,
   sanitizeVoiceErrorMessage,
   transcribeVoiceAudio
-} from "./chunk-MNOXKSM2.js";
-import {
-  PermissionRulesValidationError,
-  buildPermissionSettings,
-  isPermissionRuleType,
-  normalizePermissionRules,
-  readPermissionRuleSet
-} from "./chunk-6QVQZAW6.js";
+} from "./chunk-LFFF2SPV.js";
 import {
   isVoiceEnabled,
   isVoiceMode,
   readVoiceModel
-} from "./chunk-Y4UQT3PM.js";
-import "./chunk-NIOPRZNN.js";
+} from "./chunk-FV5SBNNC.js";
+import "./chunk-E7KNELIZ.js";
+import {
+  WorkspacePermissionRulesSessionRequiredError,
+  WorkspaceSettingsPartialPersistError
+} from "./chunk-BMFMJINR.js";
 import {
   CAPABILITIES_SCHEMA_VERSION,
   CLIENT_ID_HEADER,
@@ -92,21 +121,28 @@ import {
   setRateLimiter,
   unsafeRevealSecret,
   validateMcpRuntimeServerName
-} from "./chunk-YCU7QV7Q.js";
+} from "./chunk-73WGF3NW.js";
 import {
   isLoopbackBind
 } from "./chunk-RNBYOUGV.js";
 import "./chunk-3HX5LZ6R.js";
 import "./chunk-7RYW5LQV.js";
 import {
-  createDaemonStatusProvider
-} from "./chunk-OQHLUA2Y.js";
-import "./chunk-JKGCBO3O.js";
-import "./chunk-KHDZHZMH.js";
-import "./chunk-RSBQS6M4.js";
+  getDialogSettingKeys,
+  getNestedProperty,
+  getSettingDefinition,
+  loadSettings,
+  validateSettingValue
+} from "./chunk-NLD2WKE3.js";
 import {
+  SUPPORTED_LANGUAGES
+} from "./chunk-WNTS5A2R.js";
+import "./chunk-TLRYABYP.js";
+import "./chunk-4RQIB5UZ.js";
+import {
+  SessionArtifactValidationError,
   createAcpSessionBridge
-} from "./chunk-ZISMVA6U.js";
+} from "./chunk-VDMM5LVR.js";
 import "./chunk-P7M4GA57.js";
 import {
   BranchWhilePromptActiveError,
@@ -137,7 +173,7 @@ import {
   WorkspaceInitSymlinkError,
   WorkspaceMismatchError
 } from "./chunk-T22H4V4R.js";
-import "./chunk-EWALXUAD.js";
+import "./chunk-AGHU5VRK.js";
 import {
   MAX_WORKSPACE_PATH_LENGTH,
   canonicalizeWorkspace
@@ -145,45 +181,20 @@ import {
 import {
   EVENT_SCHEMA_VERSION,
   SubscriberLimitExceededError
-} from "./chunk-ALX6BUYW.js";
-import "./chunk-EROWZQN7.js";
-import {
-  createWorkspaceProvidersStatusProvider
-} from "./chunk-NSSVORTQ.js";
-import {
-  getAuthTypeFromEnv,
-  resolveCliGenerationConfig
-} from "./chunk-K4I4STSL.js";
-import {
-  createWorkspaceSkillsStatusProvider
-} from "./chunk-TN6RT6EJ.js";
-import "./chunk-CXBG27SF.js";
+} from "./chunk-NUGPZXAZ.js";
+import "./chunk-VRDMOSQS.js";
+import "./chunk-XD3OLPII.js";
+import "./chunk-3VJ7MT3N.js";
 import {
   STATUS_SCHEMA_VERSION,
   createIdleWorkspaceMemoryStatus,
   mapDomainErrorToErrorKind
-} from "./chunk-LHMZCIKL.js";
-import {
-  WorkspacePermissionRulesSessionRequiredError,
-  WorkspaceSettingsPartialPersistError
-} from "./chunk-BMFMJINR.js";
-import {
-  getDialogSettingKeys,
-  getNestedProperty,
-  getSettingDefinition,
-  loadSettings,
-  validateSettingValue
-} from "./chunk-BC4R5C5R.js";
-import {
-  SUPPORTED_LANGUAGES
-} from "./chunk-DM4E337C.js";
-import "./chunk-TLRYABYP.js";
-import "./chunk-2Z43HUXT.js";
-import "./chunk-UFC57OYT.js";
-import "./chunk-PPFWEV7G.js";
+} from "./chunk-FUW7YGJU.js";
+import "./chunk-HLKG6CZN.js";
+import "./chunk-CODWJXQA.js";
 import {
   getWorkspaceTrustStatus
-} from "./chunk-Z7XNVNPM.js";
+} from "./chunk-YZ5ANQMR.js";
 import {
   writeStderrLine
 } from "./chunk-Y6Z2O3WR.js";
@@ -195,14 +206,13 @@ import {
   Client,
   ClientMcpRegistrar,
   ExtensionManager,
+  IMAGE_CAPABILITY,
   ModelsConfig,
   RUNTIME_MCP_IF_ABSENT_CONFIG_FLAG,
   SessionService,
   StandardFileSystemService,
   StdioClientTransport,
   StreamableHTTPClientTransport,
-  SubagentError,
-  SubagentErrorCode,
   SubagentManager,
   TrustGateError,
   WorkspaceMemoryFileTooLargeError,
@@ -216,29 +226,32 @@ import {
   redactUrlCredentials,
   shouldShowStep,
   writeWorkspaceContextFile
-} from "./chunk-6QTCOQX7.js";
+} from "./chunk-WOG7QWIT.js";
 import "./chunk-5P5XGNYH.js";
-import "./chunk-K5PGHDBN.js";
 import "./chunk-SKAZWEV5.js";
-import "./chunk-QOMAHFYI.js";
-import "./chunk-G7OQ3RFJ.js";
-import "./chunk-LKWAVAB5.js";
-import "./chunk-L7OJ3ZO3.js";
-import "./chunk-R6RI2HIC.js";
+import "./chunk-K5PGHDBN.js";
+import "./chunk-ACD5DFUY.js";
+import "./chunk-W7EEOR7D.js";
+import "./chunk-42XGFRJS.js";
+import "./chunk-X2XNQQJI.js";
+import "./chunk-VZ7HY3YU.js";
 import "./chunk-2MPVVENX.js";
 import "./chunk-ZTQ26VBE.js";
-import "./chunk-SJBIFVD2.js";
+import "./chunk-NFE3DQ4R.js";
 import "./chunk-MLZQVCF3.js";
 import "./chunk-LQ7TMOCE.js";
 import "./chunk-E5A7LHNN.js";
 import {
-  APPROVAL_MODES
-} from "./chunk-BPFJQGY7.js";
+  APPROVAL_MODES,
+  SubagentError,
+  SubagentErrorCode
+} from "./chunk-VEB3NYSO.js";
 import "./chunk-GO6LNQXT.js";
-import "./chunk-B236XPGF.js";
-import "./chunk-YXK4GPYO.js";
-import "./chunk-TOAUDIS7.js";
-import "./chunk-NPQWQYU6.js";
+import "./chunk-5UDYETKK.js";
+import "./chunk-WMPVYQ4P.js";
+import "./chunk-TLWA7TPR.js";
+import "./chunk-QYNNN7BK.js";
+import "./chunk-QT7XKZT7.js";
 import {
   addDaemonRequestAttribute,
   decodeBufferWithEncodingInfo,
@@ -252,15 +265,15 @@ import {
   recordDaemonHttpRequest,
   recordDaemonHttpResponse,
   withDaemonRequestSpan
-} from "./chunk-CHY5C5T4.js";
+} from "./chunk-SJ2CTIYH.js";
 import "./chunk-E6US47KI.js";
 import "./chunk-UWCTAVOD.js";
 import "./chunk-OFEVLU4C.js";
 import "./chunk-OMX7CUOE.js";
-import "./chunk-MOUXUCXQ.js";
-import "./chunk-BZHLWC6T.js";
-import "./chunk-DG573EOO.js";
-import "./chunk-MTNTVOJR.js";
+import "./chunk-4KJ2BPIT.js";
+import "./chunk-SUAKHHK7.js";
+import "./chunk-FEJ2FZ3U.js";
+import "./chunk-X3YGAX7V.js";
 import {
   QwenOAuth2Client,
   QwenOAuthPollError,
@@ -269,13 +282,13 @@ import {
   isDeviceAuthorizationSuccess,
   isDeviceTokenPending,
   isDeviceTokenSuccess
-} from "./chunk-TENOUWY2.js";
-import "./chunk-GLPV75ES.js";
+} from "./chunk-IJRL2S3D.js";
+import "./chunk-AHNJGLFV.js";
 import "./chunk-22IFUCVR.js";
-import "./chunk-T42ACHFI.js";
+import "./chunk-7LTB54MK.js";
 import "./chunk-SIUQ3YYX.js";
-import "./chunk-YTFBURQD.js";
-import "./chunk-YPCPZSZB.js";
+import "./chunk-GB6HDZIK.js";
+import "./chunk-DT3B47QP.js";
 import "./chunk-IRJWHZWU.js";
 import "./chunk-SYCJMSIJ.js";
 import "./chunk-55ZMG67I.js";
@@ -284,12 +297,12 @@ import {
 } from "./chunk-H6BD2ELD.js";
 import "./chunk-5IFG2VC4.js";
 import "./chunk-64WXLC72.js";
-import "./chunk-D5KISTLW.js";
+import "./chunk-H6EMK6QK.js";
 import {
   FatalConfigError,
   Storage,
   createDebugLogger
-} from "./chunk-AVQDCKNF.js";
+} from "./chunk-22MNNNXE.js";
 import "./chunk-ZERZSAZL.js";
 import "./chunk-QN5NZ3UQ.js";
 import "./chunk-BR4QREVK.js";
@@ -3006,55 +3019,619 @@ function registerWorkspaceVoiceRoutes(app, deps) {
         });
         return;
       }
-      const queryVoiceModel = req.query["voiceModel"];
-      if (queryVoiceModel !== void 0 && typeof queryVoiceModel !== "string") {
+      const queryVoiceModel = req.query["voiceModel"];
+      if (queryVoiceModel !== void 0 && typeof queryVoiceModel !== "string") {
+        res.status(400).json({
+          error: "`voiceModel` query parameter must be a string",
+          code: "invalid_voice_model"
+        });
+        return;
+      }
+      const requestedVoiceModel = typeof queryVoiceModel === "string" ? queryVoiceModel.trim() : "";
+      if (requestedVoiceModel && requestedVoiceModel.length > MAX_VOICE_MODEL_LENGTH) {
+        res.status(400).json({
+          error: `\`voiceModel\` exceeds the ${MAX_VOICE_MODEL_LENGTH}-character limit`,
+          code: "invalid_voice_model"
+        });
+        return;
+      }
+      const voiceModel = requestedVoiceModel || readVoiceModel(settings);
+      if (!voiceModel) {
+        res.status(400).json({
+          error: "A valid voiceModel is required before transcription.",
+          code: "voice_model_required"
+        });
+        return;
+      }
+      try {
+        const result = await transcribe({
+          data,
+          mimeType: audioContentType,
+          voiceModel,
+          settings,
+          workspaceCwd: deps.boundWorkspace,
+          abortSignal: requestAbortSignal2(req, res)
+        });
+        res.status(200).json({ v: 1, ...result });
+      } catch (err) {
+        if (sendVoiceError(res, err)) return;
+        const message = err instanceof Error ? sanitizeVoiceErrorMessage(err.message) : sanitizeVoiceErrorMessage(String(err));
+        writeStderrLine(
+          `qwen serve: POST /workspace/voice/transcribe error (workspace=${deps.boundWorkspace}): ${message}`
+        );
+        res.status(502).json({
+          error: "Voice transcription failed",
+          code: "voice_transcription_failed"
+        });
+      }
+    }
+  );
+}
+__name(registerWorkspaceVoiceRoutes, "registerWorkspaceVoiceRoutes");
+
+// packages/cli/src/serve/workspace-remember.ts
+init_esbuild_shims();
+import { randomUUID } from "node:crypto";
+var debugLogger = createDebugLogger("WORKSPACE_REMEMBER");
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+__name(nowIso, "nowIso");
+function createMemoryTaskId(kind) {
+  return `${kind}-${randomUUID()}`;
+}
+__name(createMemoryTaskId, "createMemoryTaskId");
+function touchedScopesFromTopics(topics) {
+  const scopes = /* @__PURE__ */ new Set();
+  for (const topic of topics) {
+    scopes.add(topic === "user" || topic === "feedback" ? "user" : "project");
+  }
+  return [...scopes];
+}
+__name(touchedScopesFromTopics, "touchedScopesFromTopics");
+function cloneTask(task) {
+  const base = {
+    taskId: task.taskId,
+    status: task.status,
+    createdAt: task.createdAt,
+    updatedAt: task.updatedAt,
+    error: task.error ? { ...task.error } : void 0
+  };
+  if (task.kind === "remember") {
+    return {
+      ...base,
+      contextMode: task.contextMode,
+      result: task.result ? {
+        ...task.result,
+        filesTouched: [...task.result.filesTouched],
+        touchedScopes: [...task.result.touchedScopes]
+      } : void 0
+    };
+  }
+  if (task.kind === "forget") {
+    return {
+      ...base,
+      result: task.result ? {
+        ...task.result,
+        removedEntries: task.result.removedEntries.map((entry) => ({
+          ...entry
+        })),
+        touchedTopics: [...task.result.touchedTopics]
+      } : void 0
+    };
+  }
+  return {
+    ...base,
+    result: task.result ? {
+      ...task.result,
+      touchedTopics: [...task.result.touchedTopics]
+    } : void 0
+  };
+}
+__name(cloneTask, "cloneTask");
+function publicErrorMessage(code, kind) {
+  if (code === "managed_memory_unavailable") {
+    return "Managed memory is unavailable for this daemon workspace.";
+  }
+  if (code === "remember_path_escape") {
+    return "Remember agent touched a path outside managed memory.";
+  }
+  if (code === "remember_queue_full") {
+    return kind === "remember" ? "Workspace memory remember queue is full." : "Workspace memory task queue is full.";
+  }
+  if (code === "remember_timeout" || code === "forget_timeout" || code === "dream_timeout") {
+    return `Workspace memory ${kind} timed out.`;
+  }
+  return `Workspace memory ${kind} failed.`;
+}
+__name(publicErrorMessage, "publicErrorMessage");
+function publicErrorStatus(code) {
+  if (code === "remember_queue_full") return 429;
+  if (code === "managed_memory_unavailable") return 409;
+  return 500;
+}
+__name(publicErrorStatus, "publicErrorStatus");
+var WorkspaceRememberTaskLane = class _WorkspaceRememberTaskLane {
+  constructor(bridge) {
+    this.bridge = bridge;
+  }
+  static {
+    __name(this, "WorkspaceRememberTaskLane");
+  }
+  static MAX_TASKS = 1e3;
+  static TERMINAL_TASK_TTL_MS = 5 * 6e4;
+  // Two-tier pending capacity: all tasks share the global cap, while
+  // forget/dream share a smaller sub-cap so bursts cannot starve remember.
+  static MAX_PENDING = 16;
+  static MAX_NON_REMEMBER_PENDING = 8;
+  static NON_REMEMBER_KINDS = /* @__PURE__ */ new Set(
+    ["forget", "dream"]
+  );
+  tasks = /* @__PURE__ */ new Map();
+  tail = Promise.resolve();
+  pendingCounts() {
+    let total = 0;
+    let nonRemember = 0;
+    for (const task of this.tasks.values()) {
+      if (task.status !== "queued" && task.status !== "running") continue;
+      total++;
+      if (_WorkspaceRememberTaskLane.NON_REMEMBER_KINDS.has(task.kind)) {
+        nonRemember++;
+      }
+    }
+    return { total, nonRemember };
+  }
+  evictTerminalTasks(nowMs = Date.now()) {
+    const cutoffMs = nowMs - _WorkspaceRememberTaskLane.TERMINAL_TASK_TTL_MS;
+    for (const [id, task] of this.tasks) {
+      if (task.status !== "completed" && task.status !== "failed") continue;
+      const updatedAtMs = Date.parse(task.updatedAt);
+      if (!Number.isNaN(updatedAtMs) && updatedAtMs <= cutoffMs) {
+        this.tasks.delete(id);
+      } else if (Number.isNaN(updatedAtMs)) {
+        debugLogger.warn(
+          "Task with unparseable updatedAt skipped for TTL eviction:",
+          {
+            taskId: id,
+            updatedAt: task.updatedAt
+          }
+        );
+      }
+    }
+    if (this.tasks.size <= _WorkspaceRememberTaskLane.MAX_TASKS) return;
+    for (const [id, task] of this.tasks) {
+      if (task.status === "completed" || task.status === "failed") {
+        this.tasks.delete(id);
+        if (this.tasks.size <= _WorkspaceRememberTaskLane.MAX_TASKS) break;
+      }
+    }
+  }
+  assertCapacity(kind) {
+    const pending = this.pendingCounts();
+    if (pending.total >= _WorkspaceRememberTaskLane.MAX_PENDING) {
+      throw Object.assign(new Error("Workspace memory task queue is full"), {
+        code: "remember_queue_full"
+      });
+    }
+    if (_WorkspaceRememberTaskLane.NON_REMEMBER_KINDS.has(kind) && pending.nonRemember >= _WorkspaceRememberTaskLane.MAX_NON_REMEMBER_PENDING) {
+      throw Object.assign(new Error("Workspace memory task queue is full"), {
+        code: "remember_queue_full"
+      });
+    }
+  }
+  queue(task, run) {
+    this.tasks.set(task.taskId, task);
+    this.evictTerminalTasks();
+    this.tail = this.tail.then(run, run);
+    void this.tail.catch((err) => {
+      debugLogger.error("Unhandled task lane error:", err);
+    });
+    return cloneTask(task);
+  }
+  publishManagedMemoryChanged(params) {
+    if (params.touchedScopes.length === 0) return;
+    try {
+      this.bridge.publishWorkspaceEvent({
+        type: "memory_changed",
+        data: {
+          scope: "managed",
+          source: params.source,
+          taskId: params.taskId,
+          touchedScopes: params.touchedScopes
+        },
+        ...params.originatorClientId ? { originatorClientId: params.originatorClientId } : {}
+      });
+    } catch (err) {
+      debugLogger.error("Failed to publish memory_changed event:", err);
+    }
+  }
+  enqueue(params) {
+    this.assertCapacity("remember");
+    const task = {
+      kind: "remember",
+      taskId: createMemoryTaskId("remember"),
+      status: "queued",
+      contextMode: params.contextMode,
+      createdAt: nowIso(),
+      updatedAt: nowIso(),
+      ...params.originatorClientId ? { originatorClientId: params.originatorClientId } : {}
+    };
+    const run = /* @__PURE__ */ __name(async () => {
+      task.status = "running";
+      task.updatedAt = nowIso();
+      try {
+        const result = await this.bridge.runWorkspaceMemoryRemember({
+          content: params.content,
+          contextMode: params.contextMode
+        });
+        task.status = "completed";
+        task.result = {
+          summary: result.filesTouched.length > 0 ? "Memory update completed." : "No memory files updated.",
+          filesTouched: result.filesTouched,
+          touchedScopes: result.touchedScopes
+        };
+        task.updatedAt = nowIso();
+      } catch (err) {
+        const code = extractRememberErrorCode(err);
+        debugLogger.error(
+          "Workspace memory remember task failed:",
+          { taskId: task.taskId },
+          err
+        );
+        task.status = "failed";
+        task.error = {
+          code,
+          message: publicErrorMessage(code, task.kind)
+        };
+        task.updatedAt = nowIso();
+      }
+      try {
+        if (task.status === "completed" && task.result) {
+          this.publishManagedMemoryChanged({
+            source: "workspace_memory_remember",
+            taskId: task.taskId,
+            touchedScopes: task.result.touchedScopes,
+            ...params.originatorClientId ? { originatorClientId: params.originatorClientId } : {}
+          });
+        }
+      } finally {
+        this.evictTerminalTasks();
+      }
+    }, "run");
+    return this.queue(task, run);
+  }
+  enqueueForget(params) {
+    this.assertCapacity("forget");
+    const task = {
+      kind: "forget",
+      taskId: createMemoryTaskId("forget"),
+      status: "queued",
+      createdAt: nowIso(),
+      updatedAt: nowIso(),
+      ...params.originatorClientId ? { originatorClientId: params.originatorClientId } : {}
+    };
+    const run = /* @__PURE__ */ __name(async () => {
+      task.status = "running";
+      task.updatedAt = nowIso();
+      try {
+        const result = await this.bridge.runWorkspaceMemoryForget({
+          query: params.query
+        });
+        task.status = "completed";
+        task.result = {
+          summary: result.summary ?? formatWorkspaceMemoryForgetSummary(result.removedEntries.length),
+          removedEntries: result.removedEntries,
+          touchedTopics: result.touchedTopics
+        };
+        task.updatedAt = nowIso();
+      } catch (err) {
+        const code = extractRememberErrorCode(err, "forget_failed");
+        debugLogger.error(
+          "Workspace memory forget task failed:",
+          { taskId: task.taskId },
+          err
+        );
+        task.status = "failed";
+        task.error = {
+          code,
+          message: publicErrorMessage(code, task.kind)
+        };
+        task.updatedAt = nowIso();
+      }
+      try {
+        if (task.status === "completed" && task.result) {
+          this.publishManagedMemoryChanged({
+            source: "workspace_memory_forget",
+            taskId: task.taskId,
+            touchedScopes: touchedScopesFromTopics(task.result.touchedTopics),
+            ...params.originatorClientId ? { originatorClientId: params.originatorClientId } : {}
+          });
+        }
+      } finally {
+        this.evictTerminalTasks();
+      }
+    }, "run");
+    return this.queue(task, run);
+  }
+  enqueueDream(params) {
+    this.assertCapacity("dream");
+    const task = {
+      kind: "dream",
+      taskId: createMemoryTaskId("dream"),
+      status: "queued",
+      createdAt: nowIso(),
+      updatedAt: nowIso(),
+      ...params.originatorClientId ? { originatorClientId: params.originatorClientId } : {}
+    };
+    const run = /* @__PURE__ */ __name(async () => {
+      task.status = "running";
+      task.updatedAt = nowIso();
+      try {
+        const result = await this.bridge.runWorkspaceMemoryDream();
+        task.status = "completed";
+        task.result = {
+          summary: result.summary ?? formatWorkspaceMemoryDreamSummary(result.touchedTopics.length),
+          touchedTopics: result.touchedTopics,
+          dedupedEntries: result.dedupedEntries
+        };
+        task.updatedAt = nowIso();
+      } catch (err) {
+        const code = extractRememberErrorCode(err, "dream_failed");
+        debugLogger.error(
+          "Workspace memory dream task failed:",
+          { taskId: task.taskId },
+          err
+        );
+        task.status = "failed";
+        task.error = {
+          code,
+          message: publicErrorMessage(code, task.kind)
+        };
+        task.updatedAt = nowIso();
+      }
+      try {
+        if (task.status === "completed" && task.result) {
+          this.publishManagedMemoryChanged({
+            source: "workspace_memory_dream",
+            taskId: task.taskId,
+            touchedScopes: touchedScopesFromTopics(task.result.touchedTopics),
+            ...params.originatorClientId ? { originatorClientId: params.originatorClientId } : {}
+          });
+        }
+      } finally {
+        this.evictTerminalTasks();
+      }
+    }, "run");
+    return this.queue(task, run);
+  }
+  get(taskId, requesterClientId, kind) {
+    const task = this.tasks.get(taskId);
+    if (!task) return void 0;
+    if (kind && task.kind !== kind) return void 0;
+    if (task.originatorClientId) {
+      if (task.originatorClientId !== requesterClientId) return void 0;
+    } else if (requesterClientId) {
+      return void 0;
+    }
+    return cloneTask(task);
+  }
+};
+function validateOriginatorClientId(deps, req, res) {
+  const clientId = deps.parseClientId(req, res);
+  if (clientId === null) return null;
+  if (clientId === void 0) return void 0;
+  const known = deps.bridge.knownClientIds();
+  if (!known.has(clientId)) {
+    res.status(400).json({
+      error: `Client id "${clientId}" is not registered for this workspace`,
+      code: "invalid_client_id",
+      clientId
+    });
+    return null;
+  }
+  return clientId;
+}
+__name(validateOriginatorClientId, "validateOriginatorClientId");
+async function validateManagedMemoryAvailable(deps, res, kind) {
+  try {
+    const available = await deps.bridge.isWorkspaceMemoryRememberAvailable();
+    if (!available) {
+      res.status(409).json({
+        error: "Managed memory is unavailable for this daemon workspace",
+        code: "managed_memory_unavailable"
+      });
+      return false;
+    }
+    return true;
+  } catch (err) {
+    debugLogger.error("Availability check failed:", err);
+    const code = `${kind}_failed`;
+    res.status(500).json({
+      error: publicErrorMessage(code, kind),
+      code
+    });
+    return false;
+  }
+}
+__name(validateManagedMemoryAvailable, "validateManagedMemoryAvailable");
+function mountWorkspaceMemoryRememberRoutes(app, deps) {
+  app.post(
+    "/workspace/memory/remember",
+    deps.mutate({ strict: true }),
+    async (req, res) => {
+      const body = deps.safeBody(req);
+      const content = body["content"];
+      const trimmedContent = typeof content === "string" ? content.trim() : "";
+      if (!trimmedContent) {
+        res.status(400).json({
+          error: "`content` must be a non-empty string",
+          code: "invalid_content"
+        });
+        return;
+      }
+      if (Buffer.byteLength(trimmedContent, "utf8") > MAX_REMEMBER_CONTENT_BYTES) {
+        res.status(400).json({
+          error: `\`content\` exceeds the ${MAX_REMEMBER_CONTENT_BYTES}-byte limit`,
+          code: "invalid_content"
+        });
+        return;
+      }
+      const contextModeRaw = body["contextMode"] ?? "workspace";
+      if (contextModeRaw !== "workspace" && contextModeRaw !== "clean") {
+        res.status(400).json({
+          error: '`contextMode` must be "workspace", "clean", or omitted',
+          code: "invalid_context_mode"
+        });
+        return;
+      }
+      const originatorClientId = validateOriginatorClientId(deps, req, res);
+      if (originatorClientId === null) return;
+      if (!await validateManagedMemoryAvailable(deps, res, "remember")) {
+        return;
+      }
+      let task;
+      try {
+        task = deps.lane.enqueue({
+          content: trimmedContent,
+          contextMode: contextModeRaw,
+          ...originatorClientId ? { originatorClientId } : {}
+        });
+      } catch (err) {
+        const code = extractRememberErrorCode(err);
+        res.status(publicErrorStatus(code)).json({
+          error: publicErrorMessage(code, "remember"),
+          code
+        });
+        return;
+      }
+      res.status(202).json(task);
+    }
+  );
+  app.get(
+    "/workspace/memory/remember/:taskId",
+    deps.mutate({ strict: true }),
+    (req, res) => {
+      const requesterClientId = validateOriginatorClientId(deps, req, res);
+      if (requesterClientId === null) return;
+      const task = deps.lane.get(
+        req.params["taskId"],
+        requesterClientId,
+        "remember"
+      );
+      if (!task) {
+        res.status(404).json({
+          error: "Workspace memory remember task not found",
+          code: "remember_task_not_found"
+        });
+        return;
+      }
+      res.status(200).json(task);
+    }
+  );
+  app.post(
+    "/workspace/memory/forget",
+    deps.mutate({ strict: true }),
+    async (req, res) => {
+      const body = deps.safeBody(req);
+      const query = body["query"];
+      const trimmedQuery = typeof query === "string" ? query.trim() : "";
+      if (!trimmedQuery) {
+        res.status(400).json({
+          error: "`query` must be a non-empty string",
+          code: "invalid_query"
+        });
+        return;
+      }
+      if (Buffer.byteLength(trimmedQuery, "utf8") > MAX_REMEMBER_CONTENT_BYTES) {
         res.status(400).json({
-          error: "`voiceModel` query parameter must be a string",
-          code: "invalid_voice_model"
+          error: `\`query\` exceeds the ${MAX_REMEMBER_CONTENT_BYTES}-byte limit`,
+          code: "invalid_query"
         });
         return;
       }
-      const requestedVoiceModel = typeof queryVoiceModel === "string" ? queryVoiceModel.trim() : "";
-      if (requestedVoiceModel && requestedVoiceModel.length > MAX_VOICE_MODEL_LENGTH) {
-        res.status(400).json({
-          error: `\`voiceModel\` exceeds the ${MAX_VOICE_MODEL_LENGTH}-character limit`,
-          code: "invalid_voice_model"
+      const originatorClientId = validateOriginatorClientId(deps, req, res);
+      if (originatorClientId === null) return;
+      if (!await validateManagedMemoryAvailable(deps, res, "forget")) return;
+      try {
+        const task = deps.lane.enqueueForget({
+          query: trimmedQuery,
+          ...originatorClientId ? { originatorClientId } : {}
+        });
+        res.status(202).json(task);
+      } catch (err) {
+        const code = extractRememberErrorCode(err, "forget_failed");
+        res.status(publicErrorStatus(code)).json({
+          error: publicErrorMessage(code, "forget"),
+          code
         });
-        return;
       }
-      const voiceModel = requestedVoiceModel || readVoiceModel(settings);
-      if (!voiceModel) {
-        res.status(400).json({
-          error: "A valid voiceModel is required before transcription.",
-          code: "voice_model_required"
+    }
+  );
+  app.get(
+    "/workspace/memory/forget/:taskId",
+    deps.mutate({ strict: true }),
+    (req, res) => {
+      const requesterClientId = validateOriginatorClientId(deps, req, res);
+      if (requesterClientId === null) return;
+      const task = deps.lane.get(
+        req.params["taskId"],
+        requesterClientId,
+        "forget"
+      );
+      if (!task) {
+        res.status(404).json({
+          error: "Workspace memory forget task not found",
+          code: "forget_task_not_found"
         });
         return;
       }
+      res.status(200).json(task);
+    }
+  );
+  app.post(
+    "/workspace/memory/dream",
+    deps.mutate({ strict: true }),
+    async (req, res) => {
+      const originatorClientId = validateOriginatorClientId(deps, req, res);
+      if (originatorClientId === null) return;
+      if (!await validateManagedMemoryAvailable(deps, res, "dream")) return;
       try {
-        const result = await transcribe({
-          data,
-          mimeType: audioContentType,
-          voiceModel,
-          settings,
-          workspaceCwd: deps.boundWorkspace,
-          abortSignal: requestAbortSignal2(req, res)
+        const task = deps.lane.enqueueDream({
+          ...originatorClientId ? { originatorClientId } : {}
         });
-        res.status(200).json({ v: 1, ...result });
+        res.status(202).json(task);
       } catch (err) {
-        if (sendVoiceError(res, err)) return;
-        const message = err instanceof Error ? sanitizeVoiceErrorMessage(err.message) : sanitizeVoiceErrorMessage(String(err));
-        writeStderrLine(
-          `qwen serve: POST /workspace/voice/transcribe error (workspace=${deps.boundWorkspace}): ${message}`
-        );
-        res.status(502).json({
-          error: "Voice transcription failed",
-          code: "voice_transcription_failed"
+        const code = extractRememberErrorCode(err, "dream_failed");
+        res.status(publicErrorStatus(code)).json({
+          error: publicErrorMessage(code, "dream"),
+          code
+        });
+      }
+    }
+  );
+  app.get(
+    "/workspace/memory/dream/:taskId",
+    deps.mutate({ strict: true }),
+    (req, res) => {
+      const requesterClientId = validateOriginatorClientId(deps, req, res);
+      if (requesterClientId === null) return;
+      const task = deps.lane.get(
+        req.params["taskId"],
+        requesterClientId,
+        "dream"
+      );
+      if (!task) {
+        res.status(404).json({
+          error: "Workspace memory dream task not found",
+          code: "dream_task_not_found"
         });
+        return;
       }
+      res.status(200).json(task);
     }
   );
 }
-__name(registerWorkspaceVoiceRoutes, "registerWorkspaceVoiceRoutes");
+__name(mountWorkspaceMemoryRememberRoutes, "mountWorkspaceMemoryRememberRoutes");
 
 // packages/cli/src/serve/workspace-memory.ts
 init_esbuild_shims();
@@ -4569,6 +5146,7 @@ function errMsg(err) {
   return err instanceof Error ? err.message : String(err);
 }
 __name(errMsg, "errMsg");
+var debugLogger2 = createDebugLogger("ACP_HTTP_DISPATCH");
 var SESSION_SHELL_METHOD = `${QWEN_METHOD_NS}session/shell`;
 var INVALID_PERMISSION_OUTCOME_ERROR = '`outcome` must be `{ outcome: "cancelled" }` or `{ outcome: "selected", optionId: string }`';
 var ALL_QWEN_VENDOR_METHODS = [
@@ -4599,11 +5177,18 @@ var ALL_QWEN_VENDOR_METHODS = [
   `${QWEN_METHOD_NS}session/context_usage`,
   `${QWEN_METHOD_NS}session/tasks`,
   `${QWEN_METHOD_NS}session/lsp`,
+  `${QWEN_METHOD_NS}session/artifacts`,
+  `${QWEN_METHOD_NS}session/artifacts/add`,
+  `${QWEN_METHOD_NS}session/artifacts/remove`,
   // Wave 1: memory
   `${QWEN_METHOD_NS}workspace/memory`,
   `${QWEN_METHOD_NS}workspace/memory/write`,
   `${QWEN_METHOD_NS}workspace/memory/remember`,
   `${QWEN_METHOD_NS}workspace/memory/remember/get`,
+  `${QWEN_METHOD_NS}workspace/memory/forget`,
+  `${QWEN_METHOD_NS}workspace/memory/forget/get`,
+  `${QWEN_METHOD_NS}workspace/memory/dream`,
+  `${QWEN_METHOD_NS}workspace/memory/dream/get`,
   // Wave 1: files
   `${QWEN_METHOD_NS}file/read`,
   `${QWEN_METHOD_NS}file/read_bytes`,
@@ -4736,6 +5321,33 @@ function parsePermissionResponse(params) {
   return response;
 }
 __name(parsePermissionResponse, "parsePermissionResponse");
+function pickSessionArtifactInput(params) {
+  const {
+    title,
+    kind,
+    storage,
+    description,
+    workspacePath,
+    managedId,
+    url,
+    mimeType,
+    sizeBytes,
+    metadata
+  } = params;
+  return {
+    title,
+    kind,
+    storage,
+    description,
+    workspacePath,
+    managedId,
+    url,
+    mimeType,
+    sizeBytes,
+    metadata
+  };
+}
+__name(pickSessionArtifactInput, "pickSessionArtifactInput");
 function toRpcError(err) {
   if (err instanceof AcpParamError || err instanceof InvalidCursorError) {
     return { code: RPC.INVALID_PARAMS, message: err.message };
@@ -4816,6 +5428,16 @@ function toRpcError(err) {
       data: { errorKind: "client_id_required" }
     };
   }
+  if (err instanceof SessionArtifactValidationError) {
+    return {
+      code: RPC.INVALID_PARAMS,
+      message: err.message,
+      data: {
+        errorKind: "artifact_validation_failed",
+        ...err.field ? { field: err.field } : {}
+      }
+    };
+  }
   const name = err instanceof Error ? err.name : "";
   switch (name) {
     case "SessionArchivedError":
@@ -5069,7 +5691,8 @@ var AcpDispatcher = class {
             methods: advertisedQwenVendorMethods(
               this.sessionShellCommandEnabled
             )
-          }
+          },
+          imageCapability: IMAGE_CAPABILITY
         }
       }
     };
@@ -5225,7 +5848,8 @@ var AcpDispatcher = class {
               return method === "session/load" ? await this.bridge.loadSession({
                 sessionId,
                 workspaceCwd: cwd,
-                clientId: conn.clientId
+                clientId: conn.clientId,
+                historyReplay: "response"
               }) : await this.bridge.resumeSession({
                 sessionId,
                 workspaceCwd: cwd,
@@ -5255,12 +5879,31 @@ var AcpDispatcher = class {
             return;
           }
           conn.getOrCreateSession(sessionId).clientId = restored.clientId;
+          if (method === "session/load") {
+            conn.markInitialReplayPending(sessionId);
+          }
           conn.ownSession(sessionId);
           const loadConfigOptions = await this.configOptionsFor(sessionId);
           const loadModels = this.extractModelState(loadConfigOptions);
           const loadModes = this.extractModeState(loadConfigOptions);
+          const loadState = restored.state ?? {};
+          const loadMeta = isObject(loadState._meta) ? loadState._meta : void 0;
+          const loadQwenMeta = isObject(loadMeta?.[QWEN_META_KEY]) ? loadMeta[QWEN_META_KEY] : void 0;
+          const replayStatus = method === "session/load" && restored.partial === true ? {
+            partial: true,
+            ...typeof restored.replayError === "string" ? { replayError: restored.replayError } : {}
+          } : void 0;
           this.replyConn(conn, id, {
-            ...restored.state ?? {},
+            ...loadState,
+            ...replayStatus ? {
+              _meta: {
+                ...loadMeta ?? {},
+                [QWEN_META_KEY]: {
+                  ...loadQwenMeta ?? {},
+                  sessionLoadReplay: replayStatus
+                }
+              }
+            } : {},
             ...loadConfigOptions ? { configOptions: loadConfigOptions } : {},
             ...loadModels ? { models: loadModels } : {},
             ...loadModes ? { modes: loadModes } : {}
@@ -6289,6 +6932,46 @@ var AcpDispatcher = class {
           this.replyConn(conn, id, result);
           return;
         }
+        case `${QWEN_METHOD_NS}session/artifacts`: {
+          const sessionId = String(params["sessionId"] ?? "");
+          if (!this.requireOwned(conn, sessionId, id)) return;
+          const result = await this.bridge.getSessionArtifacts(sessionId);
+          this.replyConn(conn, id, result);
+          return;
+        }
+        case `${QWEN_METHOD_NS}session/artifacts/add`: {
+          const sessionId = String(params["sessionId"] ?? "");
+          await this.withMutableOwned(conn, sessionId, id, async () => {
+            const result = await this.bridge.addSessionArtifact(
+              sessionId,
+              pickSessionArtifactInput(params),
+              this.sessionCtx(conn, sessionId, loopback)
+            );
+            this.replyConn(conn, id, result);
+          });
+          return;
+        }
+        case `${QWEN_METHOD_NS}session/artifacts/remove`: {
+          const sessionId = String(params["sessionId"] ?? "");
+          await this.withMutableOwned(conn, sessionId, id, async () => {
+            const artifactId = String(params["artifactId"] ?? "");
+            if (!artifactId) {
+              if (id !== void 0) {
+                conn.sendConn(
+                  error(id, RPC.INVALID_PARAMS, "`artifactId` is required")
+                );
+              }
+              return;
+            }
+            const result = await this.bridge.removeSessionArtifact(
+              sessionId,
+              artifactId,
+              this.sessionCtx(conn, sessionId, loopback)
+            );
+            this.replyConn(conn, id, result);
+          });
+          return;
+        }
         case `${QWEN_METHOD_NS}workspace/memory`: {
           const result = await collectWorkspaceMemoryStatus(
             this.boundWorkspace
@@ -6404,15 +7087,180 @@ var AcpDispatcher = class {
           if (rawContextMode !== "workspace" && rawContextMode !== "clean") {
             if (id !== void 0) {
               conn.sendConn(
-                error(
-                  id,
-                  RPC.INVALID_PARAMS,
-                  '`contextMode` must be "workspace", "clean", or omitted'
-                )
+                error(
+                  id,
+                  RPC.INVALID_PARAMS,
+                  '`contextMode` must be "workspace", "clean", or omitted'
+                )
+              );
+            }
+            return;
+          }
+          try {
+            const available = await this.bridge.isWorkspaceMemoryRememberAvailable();
+            if (!available) {
+              if (id !== void 0) {
+                conn.sendConn(
+                  error(
+                    id,
+                    -32009,
+                    "Managed memory is unavailable for this daemon workspace",
+                    {
+                      errorKind: "managed_memory_unavailable",
+                      httpStatus: 409
+                    }
+                  )
+                );
+              }
+              return;
+            }
+            const task = this.workspaceRememberLane.enqueue({
+              content: content.trim(),
+              contextMode: rawContextMode,
+              ...conn.clientId ? { originatorClientId: conn.clientId } : {}
+            });
+            this.replyConn(conn, id, task);
+          } catch (err) {
+            const code = extractRememberErrorCode(err);
+            if (id !== void 0) {
+              conn.sendConn(
+                error(id, -32099, publicErrorMessage(code, "remember"), {
+                  errorKind: code,
+                  httpStatus: publicErrorStatus(code)
+                })
+              );
+            } else {
+              debugLogger2.warn(
+                "workspace memory remember notification failed:",
+                err
+              );
+            }
+          }
+          return;
+        }
+        case `${QWEN_METHOD_NS}workspace/memory/remember/get`: {
+          const taskId = params["taskId"];
+          if (typeof taskId !== "string" || taskId.length === 0) {
+            if (id !== void 0) {
+              conn.sendConn(error(id, RPC.INVALID_PARAMS, "`taskId` required"));
+            }
+            return;
+          }
+          const task = this.workspaceRememberLane.get(
+            taskId,
+            conn.clientId,
+            "remember"
+          );
+          if (!task) {
+            if (id !== void 0) {
+              conn.sendConn(
+                error(id, -32004, "Workspace memory remember task not found", {
+                  errorKind: "remember_task_not_found",
+                  httpStatus: 404
+                })
+              );
+            }
+            return;
+          }
+          this.replyConn(conn, id, task);
+          return;
+        }
+        case `${QWEN_METHOD_NS}workspace/memory/forget`: {
+          const query = params["query"];
+          const trimmedQuery = typeof query === "string" ? query.trim() : "";
+          if (!trimmedQuery) {
+            if (id !== void 0) {
+              conn.sendConn(
+                error(
+                  id,
+                  RPC.INVALID_PARAMS,
+                  "`query` must be a non-empty string"
+                )
+              );
+            }
+            return;
+          }
+          if (Buffer.byteLength(trimmedQuery, "utf8") > MAX_REMEMBER_CONTENT_BYTES) {
+            if (id !== void 0) {
+              conn.sendConn(
+                error(
+                  id,
+                  RPC.INVALID_PARAMS,
+                  `\`query\` exceeds the ${MAX_REMEMBER_CONTENT_BYTES}-byte limit`
+                )
+              );
+            }
+            return;
+          }
+          try {
+            const available = await this.bridge.isWorkspaceMemoryRememberAvailable();
+            if (!available) {
+              if (id !== void 0) {
+                conn.sendConn(
+                  error(
+                    id,
+                    -32009,
+                    "Managed memory is unavailable for this daemon workspace",
+                    {
+                      errorKind: "managed_memory_unavailable",
+                      httpStatus: 409
+                    }
+                  )
+                );
+              }
+              return;
+            }
+            const task = this.workspaceRememberLane.enqueueForget({
+              query: trimmedQuery,
+              ...conn.clientId ? { originatorClientId: conn.clientId } : {}
+            });
+            this.replyConn(conn, id, task);
+          } catch (err) {
+            const code = extractRememberErrorCode(err, "forget_failed");
+            if (id !== void 0) {
+              conn.sendConn(
+                error(id, -32099, publicErrorMessage(code, "forget"), {
+                  errorKind: code,
+                  httpStatus: publicErrorStatus(code)
+                })
+              );
+            } else {
+              debugLogger2.warn(
+                "workspace memory forget notification failed:",
+                err
+              );
+            }
+          }
+          return;
+        }
+        case `${QWEN_METHOD_NS}workspace/memory/forget/get`: {
+          const taskId = params["taskId"];
+          if (typeof taskId !== "string" || taskId.length === 0) {
+            if (id !== void 0) {
+              conn.sendConn(error(id, RPC.INVALID_PARAMS, "`taskId` required"));
+            }
+            return;
+          }
+          const task = this.workspaceRememberLane.get(
+            taskId,
+            conn.clientId,
+            "forget"
+          );
+          if (!task) {
+            if (id !== void 0) {
+              conn.sendConn(
+                error(id, -32004, "Workspace memory forget task not found", {
+                  errorKind: "forget_task_not_found",
+                  httpStatus: 404
+                })
               );
             }
             return;
           }
+          this.replyConn(conn, id, task);
+          return;
+        }
+        case `${QWEN_METHOD_NS}workspace/memory/dream`: {
           try {
             const available = await this.bridge.isWorkspaceMemoryRememberAvailable();
             if (!available) {
@@ -6431,31 +7279,29 @@ var AcpDispatcher = class {
               }
               return;
             }
-            const task = this.workspaceRememberLane.enqueue({
-              content: content.trim(),
-              contextMode: rawContextMode,
+            const task = this.workspaceRememberLane.enqueueDream({
               ...conn.clientId ? { originatorClientId: conn.clientId } : {}
             });
             this.replyConn(conn, id, task);
           } catch (err) {
-            const code = extractRememberErrorCode(err);
+            const code = extractRememberErrorCode(err, "dream_failed");
             if (id !== void 0) {
               conn.sendConn(
-                error(
-                  id,
-                  -32099,
-                  code === "remember_queue_full" ? "Workspace memory remember queue is full." : code === "managed_memory_unavailable" ? "Managed memory is unavailable for this daemon workspace" : "Workspace memory remember failed.",
-                  {
-                    errorKind: code,
-                    httpStatus: code === "remember_queue_full" ? 429 : code === "managed_memory_unavailable" ? 409 : 500
-                  }
-                )
+                error(id, -32099, publicErrorMessage(code, "dream"), {
+                  errorKind: code,
+                  httpStatus: publicErrorStatus(code)
+                })
+              );
+            } else {
+              debugLogger2.warn(
+                "workspace memory dream notification failed:",
+                err
               );
             }
           }
           return;
         }
-        case `${QWEN_METHOD_NS}workspace/memory/remember/get`: {
+        case `${QWEN_METHOD_NS}workspace/memory/dream/get`: {
           const taskId = params["taskId"];
           if (typeof taskId !== "string" || taskId.length === 0) {
             if (id !== void 0) {
@@ -6463,12 +7309,16 @@ var AcpDispatcher = class {
             }
             return;
           }
-          const task = this.workspaceRememberLane.get(taskId, conn.clientId);
+          const task = this.workspaceRememberLane.get(
+            taskId,
+            conn.clientId,
+            "dream"
+          );
           if (!task) {
             if (id !== void 0) {
               conn.sendConn(
-                error(id, -32004, "Workspace memory remember task not found", {
-                  errorKind: "remember_task_not_found",
+                error(id, -32004, "Workspace memory dream task not found", {
+                  errorKind: "dream_task_not_found",
                   httpStatus: 404
                 })
               );
@@ -7324,12 +8174,46 @@ var AcpDispatcher = class {
    */
   async pumpSessionEvents(conn, sessionId, signal, lastEventId) {
     try {
+      let lastDeliveredId = lastEventId ?? 0;
+      let sawEviction = false;
+      let subscribeFromEventId = lastEventId;
+      if (conn.hasInitialReplayPending(sessionId)) {
+        const snapshot = this.bridge.getSessionReplaySnapshot(sessionId);
+        if (snapshot) {
+          const snapshotEvents = [
+            ...snapshot.compactedTurns,
+            ...snapshot.liveJournal
+          ];
+          for (const event of snapshotEvents) {
+            if (signal.aborted) return;
+            if (typeof event.id === "number" && event.id <= lastDeliveredId) {
+              continue;
+            }
+            conn.touch();
+            this.translateEvent(conn, sessionId, event);
+            if (typeof event.id === "number") {
+              lastDeliveredId = event.id;
+              conn.releaseDeferredSessionReplies(sessionId, event.id);
+            }
+          }
+          if (signal.aborted) return;
+          lastDeliveredId = Math.max(lastDeliveredId, snapshot.lastEventId);
+          subscribeFromEventId = Math.max(
+            subscribeFromEventId ?? 0,
+            snapshot.lastEventId
+          );
+        } else {
+          writeStderrLine(
+            `qwen serve: /acp initial replay skipped (no snapshot) session=${logSafe(sessionId)}`
+          );
+          conn.markInitialReplayComplete(sessionId);
+          conn.endReplayDeferral(sessionId, lastDeliveredId, false);
+        }
+      }
       const iterable = this.bridge.subscribeEvents(sessionId, {
         signal,
-        ...lastEventId !== void 0 ? { lastEventId } : {}
+        ...subscribeFromEventId !== void 0 ? { lastEventId: subscribeFromEventId } : {}
       });
-      let lastDeliveredId = lastEventId ?? 0;
-      let sawEviction = false;
       for await (const event of iterable) {
         if (signal.aborted) break;
         conn.touch();
@@ -7341,6 +8225,7 @@ var AcpDispatcher = class {
         }
         if (event.type === "replay_complete") {
           conn.endReplayDeferral(sessionId, lastDeliveredId, sawEviction);
+          conn.markInitialReplayComplete(sessionId);
           const replayedCount = event.data?.replayedCount;
           writeStderrLine(
             `qwen serve: /acp replay complete (${logSafe(sessionId)}) from=${lastEventId ?? "none"} delivered_through=${lastDeliveredId} count=${replayedCount ?? "n/a"} evicted=${sawEviction}`
@@ -7561,7 +8446,7 @@ var AcpDispatcher = class {
 
 // packages/cli/src/serve/acp-http/connection-registry.ts
 init_esbuild_shims();
-import { randomUUID } from "node:crypto";
+import { randomUUID as randomUUID2 } from "node:crypto";
 var MAX_BUFFERED_FRAMES = 256;
 var HARD_BUFFERED_FRAMES_CAP = MAX_BUFFERED_FRAMES * 4;
 var DEFAULT_MAX_CONNECTIONS = 64;
@@ -7569,8 +8454,8 @@ var AcpConnection = class {
   constructor(connectionId, fromLoopback, onAbandonPending, onDetachSession) {
     this.onAbandonPending = onAbandonPending;
     this.onDetachSession = onDetachSession;
-    this.connectionId = connectionId ?? randomUUID();
-    this.clientId = randomUUID();
+    this.connectionId = connectionId ?? randomUUID2();
+    this.clientId = randomUUID2();
     this.fromLoopback = fromLoopback;
   }
   static {
@@ -7669,6 +8554,16 @@ var AcpConnection = class {
     }
     return binding;
   }
+  markInitialReplayPending(sessionId) {
+    this.getOrCreateSession(sessionId).initialReplayPending = true;
+  }
+  hasInitialReplayPending(sessionId) {
+    return this.sessions.get(sessionId)?.initialReplayPending === true;
+  }
+  markInitialReplayComplete(sessionId) {
+    const binding = this.sessions.get(sessionId);
+    if (binding) binding.initialReplayPending = false;
+  }
   getDiagnostic() {
     const liveStreams = /* @__PURE__ */ new Set();
     if (this.connStream && !this.connStream.isClosed) {
@@ -7856,15 +8751,16 @@ var AcpConnection = class {
     if (prevStream && prevStream !== stream && prevStream !== this.connStream) {
       prevStream.close();
     }
-    binding.replayPending = resumeFromEventId !== void 0;
+    const replayingOnAttach = resumeFromEventId !== void 0 || binding.initialReplayPending === true;
+    binding.replayPending = replayingOnAttach;
     if (binding.replayPending) {
       writeStderrLine(
-        `qwen serve: /acp replay deferral armed (${logSafe(sessionId)}, from id ${resumeFromEventId})`
+        `qwen serve: /acp replay deferral armed (${logSafe(sessionId)}, from id ${resumeFromEventId ?? "initial"})`
       );
     }
     const gap = binding.buffer.splice(0);
     for (const entry of gap) {
-      if (resumeFromEventId === void 0) {
+      if (!replayingOnAttach) {
         void stream.send(entry.frame, entry.id);
       } else if (entry.id !== void 0) {
         continue;
@@ -9306,6 +10202,7 @@ var WS_READ_METHODS = /* @__PURE__ */ new Set([
   "_qwen/session/context_usage",
   "_qwen/session/tasks",
   "_qwen/session/lsp",
+  "_qwen/session/artifacts",
   "_qwen/workspace/mcp",
   "_qwen/workspace/skills",
   "_qwen/workspace/providers",
@@ -9321,6 +10218,8 @@ var WS_READ_METHODS = /* @__PURE__ */ new Set([
   "_qwen/workspace/agents/get",
   "_qwen/workspace/memory",
   "_qwen/workspace/memory/remember/get",
+  "_qwen/workspace/memory/forget/get",
+  "_qwen/workspace/memory/dream/get",
   "_qwen/workspace/auth/status",
   "_qwen/workspace/auth/device_flow/get",
   "_qwen/file/read",
@@ -10228,7 +11127,7 @@ function loadDaemonVoiceContext(workspaceCwd) {
 __name(loadDaemonVoiceContext, "loadDaemonVoiceContext");
 
 // packages/cli/src/serve/voice/voice-ws.ts
-var debugLogger = createDebugLogger("VOICE_WS");
+var debugLogger3 = createDebugLogger("VOICE_WS");
 var MAX_BATCH_AUDIO_BYTES = 10 * 1024 * 1024;
 var MAX_QUEUED_AUDIO_BYTES = MAX_BATCH_AUDIO_BYTES * 2;
 var MAX_CONNECTION_MS = 6 * 6e4;
@@ -10267,7 +11166,7 @@ async function defaultOpenStream(ctx, callbacks) {
       () => cfg.transport === "qwen-asr-realtime" ? openQwenAsrRealtimeStream(cfg, callbacks) : openVoiceStream(cfg, callbacks)
     );
   } catch (error2) {
-    debugLogger.debug(`[voice-ws] stream open error: ${errMessage(error2)}`);
+    debugLogger3.debug(`[voice-ws] stream open error: ${errMessage(error2)}`);
     throw new Error(GENERIC_TRANSCRIPTION_ERROR);
   }
 }
@@ -10277,7 +11176,7 @@ function defaultTranscribe(ctx, pcm) {
     { data: encodeWav(pcm), mimeType: "audio/wav" },
     { config: ctx.models, settings: ctx.settings, voiceModel: ctx.voiceModel }
   ).catch((error2) => {
-    debugLogger.debug(
+    debugLogger3.debug(
       `[voice-ws] batch transcription error: ${errMessage(error2)}`
     );
     throw new Error(GENERIC_TRANSCRIPTION_ERROR);
@@ -10407,7 +11306,7 @@ function createVoiceWsConnectionHandler(boundWorkspace, deps = {}) {
       try {
         ctx = loadContext(boundWorkspace);
       } catch (error2) {
-        debugLogger.debug(
+        debugLogger3.debug(
           `[voice-ws] load context error: ${errMessage(error2)}`
         );
         fail(voiceConfigErrorMessage(error2));
@@ -10422,7 +11321,7 @@ function createVoiceWsConnectionHandler(boundWorkspace, deps = {}) {
         const callbacks = {
           onInterim: /* @__PURE__ */ __name((text) => sendJson({ type: "interim", text }), "onInterim"),
           onError: /* @__PURE__ */ __name((error2) => {
-            debugLogger.debug(
+            debugLogger3.debug(
               `[voice-ws] upstream error: ${errMessage(error2)}`
             );
             fail(GENERIC_TRANSCRIPTION_ERROR);
@@ -10541,7 +11440,7 @@ function createVoiceWsConnectionHandler(boundWorkspace, deps = {}) {
           releaseSlotWhenIdle();
         }
       }).catch((error2) => {
-        debugLogger.debug(`[voice-ws] ${errMessage(error2)}`);
+        debugLogger3.debug(`[voice-ws] ${errMessage(error2)}`);
         fail(GENERIC_TRANSCRIPTION_ERROR);
         releaseSlotWhenIdle();
       });
@@ -10551,7 +11450,7 @@ function createVoiceWsConnectionHandler(boundWorkspace, deps = {}) {
       releaseSlotWhenIdle();
     });
     ws.on("error", (error2) => {
-      debugLogger.debug(`[voice-ws] socket error: ${error2.message}`);
+      debugLogger3.debug(`[voice-ws] socket error: ${error2.message}`);
       if (state !== "closed") cleanup();
       releaseSlotWhenIdle();
     });
@@ -10631,335 +11530,78 @@ var WEB_SHELL_CSP = buildWebShellCsp();
 function isDocumentNavigation(req) {
   const fetchMode = req.headers["sec-fetch-mode"];
   const fetchDest = req.headers["sec-fetch-dest"];
-  const accept = req.headers.accept ?? "";
-  return fetchMode === "navigate" || fetchDest === "document" || accept.trim().toLowerCase().startsWith("text/html");
-}
-__name(isDocumentNavigation, "isDocumentNavigation");
-function createSendIndex(webShellDir, frameAncestors = []) {
-  const indexPath = path9.join(webShellDir, "index.html");
-  const csp = buildWebShellCsp(frameAncestors);
-  return (res) => {
-    res.status(200).set("Content-Security-Policy", csp).set("X-Content-Type-Options", "nosniff").set("Referrer-Policy", "no-referrer").set(
-      // `microphone=(self)` lets the same-origin Web Shell document request
-      // the mic for voice dictation (the prompt won't even appear under an
-      // empty `microphone=()` allowlist). Still blocks cross-origin iframes;
-      // camera/geolocation/payment stay disabled (unused).
-      "Permissions-Policy",
-      "camera=(), microphone=(self), geolocation=(), payment=()"
-    ).set("Cache-Control", "no-cache");
-    if (frameAncestors.length === 0) {
-      res.set("X-Frame-Options", "DENY");
-    }
-    res.sendFile(
-      indexPath,
-      { cacheControl: false, dotfiles: "allow" },
-      (err) => {
-        if (!err) return;
-        writeStderrLine(
-          `qwen serve: Web Shell index send failed: ${err instanceof Error ? err.message : String(err)}`
-        );
-        if (!res.headersSent) {
-          res.status(500).type("text/plain").send("Failed to load Web Shell");
-        } else {
-          res.end();
-        }
-      }
-    );
-  };
-}
-__name(createSendIndex, "createSendIndex");
-function mountWebShellAssets(app, webShellDir, frameAncestors = []) {
-  const sendIndex = createSendIndex(webShellDir, frameAncestors);
-  app.use(
-    "/assets",
-    import_express2.default.static(path9.join(webShellDir, "assets"), {
-      index: false,
-      immutable: true,
-      maxAge: "1y"
-    })
-  );
-  app.use("/assets", (req, res) => {
-    if (isServeDebugMode()) {
-      writeStderrLine(
-        `qwen serve: Web Shell asset not found: ${req.originalUrl}`
-      );
-    }
-    res.status(404).type("text/plain").send("Not found");
-  });
-  app.get("/", (_req, res) => sendIndex(res));
-}
-__name(mountWebShellAssets, "mountWebShellAssets");
-function mountWebShellSpaFallback(app, webShellDir, frameAncestors = []) {
-  const sendIndex = createSendIndex(webShellDir, frameAncestors);
-  app.use((req, res, next) => {
-    if (req.method !== "GET" && req.method !== "HEAD") return next();
-    if (!isDocumentNavigation(req)) return next();
-    if (isServeDebugMode()) {
-      writeStderrLine(
-        `qwen serve: Web Shell SPA fallback served for ${req.method} ${req.originalUrl}`
-      );
-    }
-    sendIndex(res);
-  });
-}
-__name(mountWebShellSpaFallback, "mountWebShellSpaFallback");
-
-// packages/cli/src/serve/workspace-remember.ts
-init_esbuild_shims();
-import { randomUUID as randomUUID2 } from "node:crypto";
-var debugLogger2 = createDebugLogger("WORKSPACE_REMEMBER");
-function nowIso() {
-  return (/* @__PURE__ */ new Date()).toISOString();
-}
-__name(nowIso, "nowIso");
-function createRememberTaskId() {
-  return `remember-${randomUUID2()}`;
-}
-__name(createRememberTaskId, "createRememberTaskId");
-function cloneTask(task) {
-  return {
-    taskId: task.taskId,
-    status: task.status,
-    contextMode: task.contextMode,
-    createdAt: task.createdAt,
-    updatedAt: task.updatedAt,
-    result: task.result ? {
-      ...task.result,
-      filesTouched: [...task.result.filesTouched],
-      touchedScopes: [...task.result.touchedScopes]
-    } : void 0,
-    error: task.error ? { ...task.error } : void 0
-  };
-}
-__name(cloneTask, "cloneTask");
-function publicErrorMessage(code) {
-  if (code === "managed_memory_unavailable") {
-    return "Managed memory is unavailable for this daemon workspace.";
-  }
-  if (code === "remember_path_escape") {
-    return "Remember agent touched a path outside managed memory.";
-  }
-  if (code === "remember_queue_full") {
-    return "Workspace memory remember queue is full.";
-  }
-  if (code === "remember_timeout") {
-    return "Workspace memory remember timed out.";
-  }
-  return "Workspace memory remember failed.";
-}
-__name(publicErrorMessage, "publicErrorMessage");
-function publicErrorStatus(code) {
-  if (code === "remember_queue_full") return 429;
-  if (code === "managed_memory_unavailable") return 409;
-  return 500;
-}
-__name(publicErrorStatus, "publicErrorStatus");
-var WorkspaceRememberTaskLane = class _WorkspaceRememberTaskLane {
-  constructor(bridge) {
-    this.bridge = bridge;
-  }
-  static {
-    __name(this, "WorkspaceRememberTaskLane");
-  }
-  static MAX_TASKS = 1e3;
-  static MAX_PENDING = 16;
-  tasks = /* @__PURE__ */ new Map();
-  tail = Promise.resolve();
-  pendingCount() {
-    let count = 0;
-    for (const task of this.tasks.values()) {
-      if (task.status === "queued" || task.status === "running") count++;
-    }
-    return count;
-  }
-  evictTerminalTasks() {
-    if (this.tasks.size <= _WorkspaceRememberTaskLane.MAX_TASKS) return;
-    for (const [id, task] of this.tasks) {
-      if (task.status === "completed" || task.status === "failed") {
-        this.tasks.delete(id);
-        if (this.tasks.size <= _WorkspaceRememberTaskLane.MAX_TASKS) break;
-      }
-    }
-  }
-  enqueue(params) {
-    if (this.pendingCount() >= _WorkspaceRememberTaskLane.MAX_PENDING) {
-      throw Object.assign(new Error("Remember queue is full"), {
-        code: "remember_queue_full"
-      });
-    }
-    const task = {
-      taskId: createRememberTaskId(),
-      status: "queued",
-      contextMode: params.contextMode,
-      createdAt: nowIso(),
-      updatedAt: nowIso(),
-      ...params.originatorClientId ? { originatorClientId: params.originatorClientId } : {}
-    };
-    this.tasks.set(task.taskId, task);
-    this.evictTerminalTasks();
-    const run = /* @__PURE__ */ __name(async () => {
-      task.status = "running";
-      task.updatedAt = nowIso();
-      try {
-        const result = await this.bridge.runWorkspaceMemoryRemember({
-          content: params.content,
-          contextMode: params.contextMode
-        });
-        task.status = "completed";
-        task.result = {
-          summary: result.filesTouched.length > 0 ? "Memory update completed." : "No memory files updated.",
-          filesTouched: result.filesTouched,
-          touchedScopes: result.touchedScopes
-        };
-        task.updatedAt = nowIso();
-      } catch (err) {
-        const code = extractRememberErrorCode(err);
-        debugLogger2.error("Remember task failed:", err);
-        task.status = "failed";
-        task.error = {
-          code,
-          message: publicErrorMessage(code)
-        };
-        task.updatedAt = nowIso();
-      } finally {
-        this.evictTerminalTasks();
-      }
-      if (task.status === "completed" && task.result && task.result.touchedScopes.length > 0) {
-        try {
-          this.bridge.publishWorkspaceEvent({
-            type: "memory_changed",
-            data: {
-              scope: "managed",
-              source: "workspace_memory_remember",
-              taskId: task.taskId,
-              touchedScopes: task.result.touchedScopes
-            },
-            ...params.originatorClientId ? { originatorClientId: params.originatorClientId } : {}
-          });
-        } catch (err) {
-          debugLogger2.error("Failed to publish memory_changed event:", err);
-        }
-      }
-    }, "run");
-    this.tail = this.tail.then(run, run);
-    void this.tail.catch((err) => {
-      debugLogger2.error("Unhandled task lane error:", err);
-    });
-    return cloneTask(task);
-  }
-  get(taskId, requesterClientId) {
-    const task = this.tasks.get(taskId);
-    if (!task) return void 0;
-    if (task.originatorClientId) {
-      if (task.originatorClientId !== requesterClientId) return void 0;
-    } else if (requesterClientId) {
-      return void 0;
-    }
-    return cloneTask(task);
-  }
-};
-function validateOriginatorClientId(deps, req, res) {
-  const clientId = deps.parseClientId(req, res);
-  if (clientId === null) return null;
-  if (clientId === void 0) return void 0;
-  const known = deps.bridge.knownClientIds();
-  if (!known.has(clientId)) {
-    res.status(400).json({
-      error: `Client id "${clientId}" is not registered for this workspace`,
-      code: "invalid_client_id",
-      clientId
-    });
-    return null;
-  }
-  return clientId;
+  const accept = req.headers.accept ?? "";
+  return fetchMode === "navigate" || fetchDest === "document" || accept.trim().toLowerCase().startsWith("text/html");
 }
-__name(validateOriginatorClientId, "validateOriginatorClientId");
-function mountWorkspaceMemoryRememberRoutes(app, deps) {
-  app.post(
-    "/workspace/memory/remember",
-    deps.mutate({ strict: true }),
-    async (req, res) => {
-      const body = deps.safeBody(req);
-      const content = body["content"];
-      const trimmedContent = typeof content === "string" ? content.trim() : "";
-      if (!trimmedContent) {
-        res.status(400).json({
-          error: "`content` must be a non-empty string",
-          code: "invalid_content"
-        });
-        return;
-      }
-      if (Buffer.byteLength(trimmedContent, "utf8") > MAX_REMEMBER_CONTENT_BYTES) {
-        res.status(400).json({
-          error: `\`content\` exceeds the ${MAX_REMEMBER_CONTENT_BYTES}-byte limit`,
-          code: "invalid_content"
-        });
-        return;
-      }
-      const contextModeRaw = body["contextMode"] ?? "workspace";
-      if (contextModeRaw !== "workspace" && contextModeRaw !== "clean") {
-        res.status(400).json({
-          error: '`contextMode` must be "workspace", "clean", or omitted',
-          code: "invalid_context_mode"
-        });
-        return;
-      }
-      const originatorClientId = validateOriginatorClientId(deps, req, res);
-      if (originatorClientId === null) return;
-      try {
-        const available = await deps.bridge.isWorkspaceMemoryRememberAvailable();
-        if (!available) {
-          res.status(409).json({
-            error: "Managed memory is unavailable for this daemon workspace",
-            code: "managed_memory_unavailable"
-          });
-          return;
+__name(isDocumentNavigation, "isDocumentNavigation");
+function createSendIndex(webShellDir, frameAncestors = []) {
+  const indexPath = path9.join(webShellDir, "index.html");
+  const csp = buildWebShellCsp(frameAncestors);
+  return (res) => {
+    res.status(200).set("Content-Security-Policy", csp).set("X-Content-Type-Options", "nosniff").set("Referrer-Policy", "no-referrer").set(
+      // `microphone=(self)` lets the same-origin Web Shell document request
+      // the mic for voice dictation (the prompt won't even appear under an
+      // empty `microphone=()` allowlist). Still blocks cross-origin iframes;
+      // camera/geolocation/payment stay disabled (unused).
+      "Permissions-Policy",
+      "camera=(), microphone=(self), geolocation=(), payment=()"
+    ).set("Cache-Control", "no-cache");
+    if (frameAncestors.length === 0) {
+      res.set("X-Frame-Options", "DENY");
+    }
+    res.sendFile(
+      indexPath,
+      { cacheControl: false, dotfiles: "allow" },
+      (err) => {
+        if (!err) return;
+        writeStderrLine(
+          `qwen serve: Web Shell index send failed: ${err instanceof Error ? err.message : String(err)}`
+        );
+        if (!res.headersSent) {
+          res.status(500).type("text/plain").send("Failed to load Web Shell");
+        } else {
+          res.end();
         }
-      } catch (err) {
-        debugLogger2.error("Availability check failed:", err);
-        res.status(500).json({
-          error: "Workspace memory remember failed.",
-          code: "remember_failed"
-        });
-        return;
-      }
-      let task;
-      try {
-        task = deps.lane.enqueue({
-          content: trimmedContent,
-          contextMode: contextModeRaw,
-          ...originatorClientId ? { originatorClientId } : {}
-        });
-      } catch (err) {
-        const code = extractRememberErrorCode(err);
-        res.status(publicErrorStatus(code)).json({
-          error: publicErrorMessage(code),
-          code
-        });
-        return;
       }
-      res.status(202).json(task);
-    }
+    );
+  };
+}
+__name(createSendIndex, "createSendIndex");
+function mountWebShellAssets(app, webShellDir, frameAncestors = []) {
+  const sendIndex = createSendIndex(webShellDir, frameAncestors);
+  app.use(
+    "/assets",
+    import_express2.default.static(path9.join(webShellDir, "assets"), {
+      index: false,
+      immutable: true,
+      maxAge: "1y"
+    })
   );
-  app.get(
-    "/workspace/memory/remember/:taskId",
-    deps.mutate({ strict: true }),
-    (req, res) => {
-      const requesterClientId = validateOriginatorClientId(deps, req, res);
-      if (requesterClientId === null) return;
-      const task = deps.lane.get(req.params["taskId"], requesterClientId);
-      if (!task) {
-        res.status(404).json({
-          error: "Workspace memory remember task not found",
-          code: "remember_task_not_found"
-        });
-        return;
-      }
-      res.status(200).json(task);
+  app.use("/assets", (req, res) => {
+    if (isServeDebugMode()) {
+      writeStderrLine(
+        `qwen serve: Web Shell asset not found: ${req.originalUrl}`
+      );
     }
-  );
+    res.status(404).type("text/plain").send("Not found");
+  });
+  app.get("/", (_req, res) => sendIndex(res));
 }
-__name(mountWorkspaceMemoryRememberRoutes, "mountWorkspaceMemoryRememberRoutes");
+__name(mountWebShellAssets, "mountWebShellAssets");
+function mountWebShellSpaFallback(app, webShellDir, frameAncestors = []) {
+  const sendIndex = createSendIndex(webShellDir, frameAncestors);
+  app.use((req, res, next) => {
+    if (req.method !== "GET" && req.method !== "HEAD") return next();
+    if (!isDocumentNavigation(req)) return next();
+    if (isServeDebugMode()) {
+      writeStderrLine(
+        `qwen serve: Web Shell SPA fallback served for ${req.method} ${req.originalUrl}`
+      );
+    }
+    sendIndex(res);
+  });
+}
+__name(mountWebShellSpaFallback, "mountWebShellSpaFallback");
 
 // packages/cli/src/serve/routes/daemon-status.ts
 init_esbuild_shims();
@@ -10991,7 +11633,8 @@ function registerDaemonStatusRoutes(app, deps) {
           supportedDeviceFlowProviders: deps.getSupportedDeviceFlowProviders(),
           deviceFlowRegistry: deps.deviceFlowRegistry,
           sessionShellCommandEnabled: deps.sessionShellCommandEnabled,
-          getChannelWorkerSnapshot: deps.getChannelWorkerSnapshot
+          getChannelWorkerSnapshot: deps.getChannelWorkerSnapshot,
+          getPerfSnapshot: deps.getPerfSnapshot
         })
       );
     } catch (err) {
@@ -13481,7 +14124,81 @@ function parseSessionPageSizeQuery(raw) {
 }
 __name(parseSessionPageSizeQuery, "parseSessionPageSizeQuery");
 
+// packages/cli/src/serve/server/session-export.ts
+init_esbuild_shims();
+var SESSION_EXPORT_FORMATS = ["html", "md", "json", "jsonl"];
+var EXPORT_FORMATS = {
+  html: {
+    mimeType: "text/html; charset=utf-8",
+    render: toHtml
+  },
+  md: {
+    mimeType: "text/markdown; charset=utf-8",
+    render: toMarkdown
+  },
+  json: {
+    mimeType: "application/json; charset=utf-8",
+    render: toJson
+  },
+  jsonl: {
+    mimeType: "application/jsonl; charset=utf-8",
+    render: toJsonl
+  }
+};
+function parseSessionExportFormat(rawFormat) {
+  if (rawFormat === void 0) return "html";
+  if (typeof rawFormat !== "string") return void 0;
+  return SESSION_EXPORT_FORMATS.includes(rawFormat) ? rawFormat : void 0;
+}
+__name(parseSessionExportFormat, "parseSessionExportFormat");
+function sessionExportFormatValues() {
+  return [...SESSION_EXPORT_FORMATS];
+}
+__name(sessionExportFormatValues, "sessionExportFormatValues");
+async function exportSessionTranscript(params) {
+  const { workspaceCwd, sessionId, format } = params;
+  const sessionData = await new SessionService(workspaceCwd).loadSession(
+    sessionId
+  );
+  if (!sessionData) {
+    throw new SessionNotFoundError(sessionId);
+  }
+  const exportConfig = params.config ?? {};
+  const collected = await collectSessionData(
+    sessionData.conversation,
+    exportConfig
+  );
+  const normalized = normalizeSessionData(
+    collected,
+    sessionData.conversation.messages,
+    exportConfig
+  );
+  const formatDefinition = EXPORT_FORMATS[format];
+  return {
+    format,
+    filename: generateExportFilename(format),
+    mimeType: formatDefinition.mimeType,
+    content: formatDefinition.render(normalized)
+  };
+}
+__name(exportSessionTranscript, "exportSessionTranscript");
+
 // packages/cli/src/serve/routes/session.ts
+function sendArtifactValidationError(res, err) {
+  if (!(err instanceof SessionArtifactValidationError)) {
+    return false;
+  }
+  res.status(400).json({
+    v: 1,
+    error: {
+      code: err.code,
+      message: err.message,
+      ...err.field ? { field: err.field } : {}
+    }
+  });
+  return true;
+}
+__name(sendArtifactValidationError, "sendArtifactValidationError");
 function registerSessionRoutes(app, deps) {
   const {
     boundWorkspace,
@@ -13593,6 +14310,7 @@ function registerSessionRoutes(app, deps) {
           return action === "load" ? await bridge.loadSession({
             sessionId,
             workspaceCwd: cwd,
+            historyReplay: "response",
             ...clientId !== void 0 ? { clientId } : {}
           }) : await bridge.resumeSession({
             sessionId,
@@ -13723,6 +14441,42 @@ function registerSessionRoutes(app, deps) {
       });
     }
   });
+  app.get("/session/:id/export", async (req, res) => {
+    const sessionId = requireSessionId(req, res);
+    if (sessionId === null) return;
+    const rawFormat = req.query["format"];
+    const format = parseSessionExportFormat(rawFormat);
+    if (!format) {
+      res.status(400).json({
+        error: "Invalid export format",
+        code: "invalid_export_format",
+        format: typeof rawFormat === "string" ? rawFormat : String(rawFormat),
+        allowedFormats: sessionExportFormatValues()
+      });
+      return;
+    }
+    try {
+      const result = await archiveCoordinator.runSharedMany(
+        [sessionId],
+        async () => {
+          await assertSessionLoadable(boundWorkspace, sessionId);
+          return exportSessionTranscript({
+            workspaceCwd: boundWorkspace,
+            sessionId,
+            format,
+            config: { getChannel: /* @__PURE__ */ __name(() => "daemon", "getChannel") }
+          });
+        }
+      );
+      const filename = result.filename.replace(/["\\\r\n]/g, "_");
+      res.status(200).set("Cache-Control", "no-store").set("X-Content-Type-Options", "nosniff").set("Content-Type", result.mimeType).set("Content-Disposition", `attachment; filename="${filename}"`).send(result.content);
+    } catch (err) {
+      sendBridgeError2(res, err, {
+        route: "GET /session/:id/export",
+        sessionId
+      });
+    }
+  });
   app.get("/session/:id/context", async (req, res) => {
     const sessionId = requireSessionId(req, res);
     if (sessionId === null) return;
@@ -13808,6 +14562,92 @@ function registerSessionRoutes(app, deps) {
       sendBridgeError2(res, err, { route: "GET /session/:id/hooks", sessionId });
     }
   });
+  app.get("/session/:id/artifacts", async (req, res) => {
+    const sessionId = requireSessionId(req, res);
+    if (sessionId === null) return;
+    try {
+      res.status(200).json(await bridge.getSessionArtifacts(sessionId));
+    } catch (err) {
+      sendBridgeError2(res, err, {
+        route: "GET /session/:id/artifacts",
+        sessionId
+      });
+    }
+  });
+  app.post(
+    "/session/:id/artifacts",
+    mutate({ strict: true }),
+    withMutableSession(
+      "POST /session/:id/artifacts",
+      async (req, res, sessionId) => {
+        const clientId = parseClientIdHeader(req, res);
+        if (clientId === null) return;
+        try {
+          const body = safeBody(req);
+          const artifact = {
+            title: body["title"],
+            kind: body["kind"],
+            storage: body["storage"],
+            description: body["description"],
+            workspacePath: body["workspacePath"],
+            managedId: body["managedId"],
+            url: body["url"],
+            mimeType: body["mimeType"],
+            sizeBytes: body["sizeBytes"],
+            metadata: body["metadata"]
+          };
+          const result = await bridge.addSessionArtifact(
+            sessionId,
+            artifact,
+            clientId !== void 0 ? { clientId } : void 0
+          );
+          res.status(200).json(result);
+        } catch (err) {
+          if (sendArtifactValidationError(res, err)) return;
+          sendBridgeError2(res, err, {
+            route: "POST /session/:id/artifacts",
+            sessionId
+          });
+        }
+      }
+    )
+  );
+  app.delete(
+    "/session/:id/artifacts/:artifactId",
+    mutate({ strict: true }),
+    withMutableSession(
+      "DELETE /session/:id/artifacts/:artifactId",
+      async (req, res, sessionId) => {
+        const artifactId = req.params["artifactId"];
+        const clientId = parseClientIdHeader(req, res);
+        if (clientId === null) return;
+        if (!artifactId) {
+          res.status(400).json({
+            v: 1,
+            error: {
+              code: "VALIDATION_FAILED",
+              message: "`artifactId` route parameter is required",
+              field: "artifactId"
+            }
+          });
+          return;
+        }
+        try {
+          const result = await bridge.removeSessionArtifact(
+            sessionId,
+            artifactId,
+            clientId !== void 0 ? { clientId } : void 0
+          );
+          res.status(200).json(result);
+        } catch (err) {
+          sendBridgeError2(res, err, {
+            route: "DELETE /session/:id/artifacts/:artifactId",
+            sessionId
+          });
+        }
+      }
+    )
+  );
   app.post(
     "/session/:id/tasks/:taskId/cancel",
     mutate({ strict: true }),
@@ -14136,6 +14976,7 @@ function registerSessionRoutes(app, deps) {
   });
   app.patch(
     "/session/:id/metadata",
+    mutate({ strict: true }),
     withMutableSession("PATCH /session/:id/metadata", (req, res, sessionId) => {
       const body = safeBody(req);
       const clientId = parseClientIdHeader(req, res);
@@ -15924,6 +16765,30 @@ function resolveDaemonTelemetryRoute(req) {
       sessionId: sessionMetadata[1]
     };
   }
+  const sessionArtifacts = path12.match(/^\/session\/([^/]+)\/artifacts$/);
+  if (sessionArtifacts?.[1]) {
+    if (req.method === "GET") {
+      return {
+        route: "GET /session/:id/artifacts",
+        sessionId: sessionArtifacts[1]
+      };
+    }
+    if (req.method === "POST") {
+      return {
+        route: "POST /session/:id/artifacts",
+        sessionId: sessionArtifacts[1]
+      };
+    }
+  }
+  const sessionArtifact = path12.match(
+    /^\/session\/([^/]+)\/artifacts\/([^/]+)$/
+  );
+  if (sessionArtifact?.[1] && req.method === "DELETE") {
+    return {
+      route: "DELETE /session/:id/artifacts/:artifactId",
+      sessionId: sessionArtifact[1]
+    };
+  }
   const sessionPermission = path12.match(
     /^\/session\/([^/]+)\/permission\/([^/]+)$/
   );
@@ -16858,7 +17723,8 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     getSupportedDeviceFlowProviders,
     deviceFlowRegistry,
     sessionShellCommandEnabled,
-    getChannelWorkerSnapshot: deps.getChannelWorkerSnapshot
+    getChannelWorkerSnapshot: deps.getChannelWorkerSnapshot,
+    getPerfSnapshot: deps.getPerfSnapshot
   });
   registerCapabilitiesRoutes(app, {
     qwenCodeVersion: deps.qwenCodeVersion,
@@ -17112,6 +17978,11 @@ export {
  * Copyright 2025 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
  */
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
 /**
  * @license
  * Copyright 2026 Qwen Team
@@ -17131,11 +18002,6 @@ export {
  *
  * See `packages/chrome-extension/docs/06-plan-c-cdp-tunnel.md`.
  */
-/**
- * @license
- * Copyright 2026 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */
 /**
  * @license
  * Copyright 2026 Qwen Team