@qwen-code/qwen-code 0.21.13 → 0.21.14

package/chunks/{chunk-LJQAUZMR.js → chunk-L3T4V5GZ.js}

@@ -19,7 +19,7 @@ import {
 } from "./chunk-OCPBI7J5.js";
 import {
   defaultSpawnChannelFactory
-} from "./chunk-NHDR76JX.js";
+} from "./chunk-BQWNIPTE.js";
 import {
   BridgeChannelClosedError,
   BridgeTimeoutError,
@@ -29,7 +29,7 @@ import {
   SessionRestoreTimeoutError,
   createIdleWorkspaceExtensionsStatus,
   createIdleWorkspaceHooksStatus
-} from "./chunk-QNQAPSN2.js";
+} from "./chunk-UC67T4SF.js";
 import {
   ACTIVE_WORK_CLOSE_IF_UNHELD_PARAM,
   ACTIVE_WORK_CLOSE_TIMEOUT_MS,
@@ -45,6 +45,7 @@ import {
   CHANNEL_STARTUP_PROFILE_META_KEY,
   CHANNEL_STARTUP_PROFILE_VERSION,
   DAEMON_CHANNEL_DELIVERY_META_KEY,
+  DAEMON_MEDIA_REFERENCES_META_KEY,
   DAEMON_MODEL_PROMPT_META_KEY,
   DAEMON_PROMPT_DISPLAY_TEXT_META_KEY,
   LOAD_REPLAY_BULK_MODE,
@@ -64,7 +65,7 @@ import {
   clampActiveWorkIntervalMs,
   isValidTrustedModelPrompt,
   sessionCloseDrainBudgetMs
-} from "./chunk-S5DWMTHO.js";
+} from "./chunk-WP4WIUOJ.js";
 import {
   BranchWhilePromptActiveError,
   BridgeChannelQuarantinedError,
@@ -113,6 +114,8 @@ import {
   SESSION_ARTIFACT_PERSISTENCE_VERSION,
   SESSION_TRANSCRIPT_MAX_LIMIT,
   ShellExecutionService,
+  TURN_RESULT_CODE_TEXT_TRUNCATED,
+  TURN_RESULT_TEXT_MAX_CHARS,
   TrustGateError,
   WORKSPACE_CONTENT_MTIME_MS_METADATA_KEY,
   WORKSPACE_CONTENT_SHA256_METADATA_KEY,
@@ -120,17 +123,18 @@ import {
   isReservedWorkspaceMetadataKey,
   metadataBudgetBytes,
   normalizeSnapshotPayload,
+  normalizeTurnResultError,
   stableSessionArtifactId
-} from "./chunk-4S5337WV.js";
+} from "./chunk-OFTPCOGR.js";
 import {
   DAEMON_TRACEPARENT_META_KEY,
   DAEMON_TRACESTATE_META_KEY
-} from "./chunk-TIGA2IVL.js";
+} from "./chunk-OO4FKHLO.js";
 import {
   INVOCATION_CONTEXT_META_KEY,
   PRIVATE_ACP_CAPABILITY_ENV,
   PRIVATE_PARENT_CAPABILITY_META_KEY
-} from "./chunk-RVOJ2FBP.js";
+} from "./chunk-KC4WMLZO.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -140,8 +144,8 @@ import {
 
 // packages/acp-bridge/src/bridge.ts
 init_esbuild_shims();
-import { randomBytes, randomUUID as randomUUID2 } from "node:crypto";
-import * as path3 from "node:path";
+import { randomBytes, randomUUID as randomUUID3 } from "node:crypto";
+import * as path4 from "node:path";
 import { inspect } from "node:util";
 
 // packages/acp-bridge/src/compactionEngine.ts
@@ -1280,6 +1284,267 @@ function getChannelStartupProfileAttributes(response, receivedAtEpochMs, initial
 }
 __name(getChannelStartupProfileAttributes, "getChannelStartupProfileAttributes");
 
+// packages/acp-bridge/src/sessionMedia.ts
+init_esbuild_shims();
+import { randomUUID } from "node:crypto";
+import { promises as fs } from "node:fs";
+import { tmpdir } from "node:os";
+import * as path from "node:path";
+var SESSION_MEDIA_MAX_ITEM_BYTES = 8 * 1024 * 1024;
+var SESSION_MEDIA_MAX_TOTAL_BYTES = 100 * 1024 * 1024;
+var SESSION_MEDIA_MAX_ITEMS = 256;
+var SESSION_MEDIA_UNAVAILABLE_TEXT = "[Attached media is no longer available]";
+var SessionMediaReferenceError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "SessionMediaReferenceError";
+  }
+  static {
+    __name(this, "SessionMediaReferenceError");
+  }
+};
+function isSessionMediaReference(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  return record["type"] === "image" && typeof record["mediaId"] === "string" && record["mediaId"].length > 0 && typeof record["mimeType"] === "string" && record["mimeType"].startsWith(`${record["type"]}/`) && typeof record["size"] === "number" && Number.isSafeInteger(record["size"]) && record["size"] > 0;
+}
+__name(isSessionMediaReference, "isSessionMediaReference");
+function withMediaDegradationMarker(blocks) {
+  for (let i = blocks.length - 1; i >= 0; i--) {
+    const block = blocks[i];
+    if (block.type === "text") {
+      if (block.text.endsWith(SESSION_MEDIA_UNAVAILABLE_TEXT)) {
+        return [...blocks];
+      }
+      const next = [...blocks];
+      next[i] = {
+        type: "text",
+        text: `${block.text}
+${SESSION_MEDIA_UNAVAILABLE_TEXT}`
+      };
+      return next;
+    }
+  }
+  return [
+    ...blocks,
+    { type: "text", text: SESSION_MEDIA_UNAVAILABLE_TEXT }
+  ];
+}
+__name(withMediaDegradationMarker, "withMediaDegradationMarker");
+var SessionMediaStore = class {
+  static {
+    __name(this, "SessionMediaStore");
+  }
+  records = /* @__PURE__ */ new Map();
+  directoryPromise;
+  totalBytes = 0;
+  pendingItems = 0;
+  closed = false;
+  async put(data, mimeType) {
+    if (this.closed) throw new Error("Session media store is closed");
+    const type = "image";
+    if (!mimeType.startsWith("image/")) {
+      throw new TypeError("Session media must be image/*");
+    }
+    if (data.byteLength === 0 || data.byteLength > SESSION_MEDIA_MAX_ITEM_BYTES) {
+      throw new RangeError(
+        `Session media must be between 1 and ${SESSION_MEDIA_MAX_ITEM_BYTES} bytes`
+      );
+    }
+    if (this.totalBytes + data.byteLength > SESSION_MEDIA_MAX_TOTAL_BYTES) {
+      throw new RangeError(
+        `Session media exceeds the ${SESSION_MEDIA_MAX_TOTAL_BYTES}-byte session limit`
+      );
+    }
+    if (this.records.size + this.pendingItems >= SESSION_MEDIA_MAX_ITEMS) {
+      throw new RangeError(
+        `Session media exceeds the ${SESSION_MEDIA_MAX_ITEMS}-item session limit`
+      );
+    }
+    const mediaId = randomUUID();
+    let filePath;
+    this.totalBytes += data.byteLength;
+    this.pendingItems += 1;
+    try {
+      const directory = await this.directory();
+      filePath = path.join(directory, mediaId);
+      await fs.writeFile(filePath, data, { flag: "wx" });
+      if (this.closed) {
+        throw new Error("Session media store is closed");
+      }
+      const record = {
+        type,
+        mediaId,
+        mimeType,
+        size: data.byteLength,
+        filePath
+      };
+      this.records.set(mediaId, record);
+      return { type, mediaId, mimeType, size: data.byteLength };
+    } catch (error) {
+      if (filePath) await fs.rm(filePath, { force: true }).catch(() => {
+      });
+      if (!this.closed) this.totalBytes -= data.byteLength;
+      throw error;
+    } finally {
+      if (!this.closed) this.pendingItems -= 1;
+    }
+  }
+  // Validate one block against the store. Blocks without a `mediaId` (inline
+  // media, text) pass through untouched, matching `assertReferences`.
+  assertReference(block) {
+    if (!block || typeof block !== "object" || Array.isArray(block) || !("mediaId" in block)) {
+      return;
+    }
+    if (!isSessionMediaReference(block)) {
+      throw new SessionMediaReferenceError(
+        "Invalid session media reference",
+        "invalid_session_media_reference"
+      );
+    }
+    this.assertStored(block);
+  }
+  assertReferences(content) {
+    const seenMediaIds = /* @__PURE__ */ new Set();
+    for (const block of content) {
+      if (!block || typeof block !== "object" || Array.isArray(block) || !("mediaId" in block)) {
+        continue;
+      }
+      if (!isSessionMediaReference(block)) {
+        throw new SessionMediaReferenceError(
+          "Invalid session media reference",
+          "invalid_session_media_reference"
+        );
+      }
+      if (seenMediaIds.has(block.mediaId)) {
+        throw new SessionMediaReferenceError(
+          `Session media referenced more than once: ${block.mediaId}`,
+          "invalid_session_media_reference"
+        );
+      }
+      seenMediaIds.add(block.mediaId);
+      this.assertStored(block);
+    }
+  }
+  async resolveContent(content, memo) {
+    const pendingByMediaId = memo ?? /* @__PURE__ */ new Map();
+    return await Promise.all(
+      content.map(async (block) => {
+        if (!isSessionMediaReference(block)) return block;
+        let pending = pendingByMediaId.get(block.mediaId);
+        if (!pending) {
+          const created = this.resolve(block);
+          pendingByMediaId.set(block.mediaId, created);
+          void created.catch(() => {
+            if (pendingByMediaId.get(block.mediaId) === created) {
+              pendingByMediaId.delete(block.mediaId);
+            }
+          });
+          pending = created;
+        }
+        return await pending;
+      })
+    );
+  }
+  // Per-block variant of `resolveContent` for degrade paths: one unresolvable
+  // reference drops only itself, keeping the sibling blocks a wholesale
+  // fallback would discard. Non-media errors still propagate.
+  async resolveContentDegrading(content, memo) {
+    const retainedBlocks = [];
+    const resolvedBlocks = [];
+    let degraded = 0;
+    for (const block of content) {
+      if (!isSessionMediaReference(block)) {
+        retainedBlocks.push(block);
+        resolvedBlocks.push(block);
+        continue;
+      }
+      try {
+        const [resolved] = await this.resolveContent([block], memo);
+        if (resolved) resolvedBlocks.push(resolved);
+        retainedBlocks.push(block);
+      } catch (error) {
+        if (!(error instanceof SessionMediaReferenceError)) throw error;
+        degraded += 1;
+      }
+    }
+    return { retainedBlocks, resolvedBlocks, degraded };
+  }
+  async read(mediaId) {
+    const record = this.records.get(mediaId);
+    if (!record) return void 0;
+    try {
+      return {
+        data: await fs.readFile(record.filePath),
+        mimeType: record.mimeType
+      };
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        if (this.records.delete(mediaId)) this.totalBytes -= record.size;
+        return void 0;
+      }
+      throw error;
+    }
+  }
+  async remove(mediaId) {
+    const record = this.records.get(mediaId);
+    if (!record) return false;
+    this.records.delete(mediaId);
+    this.totalBytes -= record.size;
+    await fs.rm(record.filePath, { force: true });
+    return true;
+  }
+  get sizeBytes() {
+    return this.totalBytes;
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.records.clear();
+    this.totalBytes = 0;
+    this.pendingItems = 0;
+    if (!this.directoryPromise) return;
+    const directory = await this.directoryPromise.catch(() => void 0);
+    if (!directory) return;
+    await fs.rm(directory, { recursive: true, force: true });
+  }
+  assertStored(reference) {
+    const stored = this.records.get(reference.mediaId);
+    if (!stored || stored.type !== reference.type || stored.mimeType !== reference.mimeType || stored.size !== reference.size) {
+      throw new SessionMediaReferenceError(
+        `Unknown or unavailable session media: ${reference.mediaId}`,
+        "session_media_gone"
+      );
+    }
+  }
+  async resolve(reference) {
+    const media = await this.read(reference.mediaId);
+    if (!media || media.mimeType !== reference.mimeType) {
+      throw new SessionMediaReferenceError(
+        `Unknown or unavailable session media: ${reference.mediaId}`,
+        "session_media_gone"
+      );
+    }
+    return {
+      type: reference.type,
+      data: media.data.toString("base64"),
+      mimeType: media.mimeType
+    };
+  }
+  async directory() {
+    if (!this.directoryPromise) {
+      const pending = fs.mkdtemp(path.join(tmpdir(), "qwen-session-media-"));
+      this.directoryPromise = pending;
+      void pending.catch(() => {
+        if (this.directoryPromise === pending)
+          this.directoryPromise = void 0;
+      });
+    }
+    return await this.directoryPromise;
+  }
+};
+
 // packages/acp-bridge/src/internal/stderrLine.ts
 init_esbuild_shims();
 function writeStderrLine(message) {
@@ -1290,9 +1555,9 @@ __name(writeStderrLine, "writeStderrLine");
 
 // packages/acp-bridge/src/bridgeClient.ts
 init_esbuild_shims();
-import { randomUUID } from "node:crypto";
-import { promises as fs } from "node:fs";
-import * as path from "node:path";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { promises as fs2 } from "node:fs";
+import * as path2 from "node:path";
 
 // packages/acp-bridge/src/daemonEventTypes.ts
 init_esbuild_shims();
@@ -2278,7 +2543,7 @@ function sliceLineRange(content, startLine, endLine) {
 }
 __name(sliceLineRange, "sliceLineRange");
 var BridgeClient = class {
-  constructor(resolveEntry, resolvePendingRestoreEvents, mediator, permissionTimeoutMs, maxPendingPerSession, fileSystem, onModelPromoted, onModePromoted, clientMcpSender, ownsSession = () => true, onTokenUsage, onCreateSubSession, onGenerationEvent, onWorkspaceGenerationEvent, onChannelDelivery, hasSessionSpawnInFlight = () => false, getLiveScreenContextCaptureHandler = () => void 0, getLiveTaskToolRequestHandler = () => void 0, getLiveSpeakToUserHandler = () => void 0, externalToolGuard, onActiveWork) {
+  constructor(resolveEntry, resolvePendingRestoreEvents, mediator, permissionTimeoutMs, maxPendingPerSession, fileSystem, onModelPromoted, onModePromoted, clientMcpSender, ownsSession = () => true, onTokenUsage, onCreateSubSession, onGenerationEvent, onWorkspaceGenerationEvent, onChannelDelivery, hasSessionSpawnInFlight = () => false, getLiveScreenContextCaptureHandler = () => void 0, getLiveTaskToolRequestHandler = () => void 0, getLiveSpeakToUserHandler = () => void 0, externalToolGuard, onActiveWork, onSessionCatalogChanged) {
     this.resolveEntry = resolveEntry;
     this.resolvePendingRestoreEvents = resolvePendingRestoreEvents;
     this.mediator = mediator;
@@ -2300,6 +2565,7 @@ var BridgeClient = class {
     this.getLiveSpeakToUserHandler = getLiveSpeakToUserHandler;
     this.externalToolGuard = externalToolGuard;
     this.onActiveWork = onActiveWork;
+    this.onSessionCatalogChanged = onSessionCatalogChanged;
   }
   static {
     __name(this, "BridgeClient");
@@ -2318,7 +2584,7 @@ var BridgeClient = class {
       options.map((o) => String(o.optionId ?? ""))
     );
     allowedOptionIds.delete("");
-    const requestId = randomUUID();
+    const requestId = randomUUID2();
     if (allowedOptionIds.has(CANCEL_VOTE_SENTINEL)) {
       throw new CancelSentinelCollisionError(requestId, CANCEL_VOTE_SENTINEL);
     }
@@ -2564,8 +2830,8 @@ var BridgeClient = class {
    * between tool batches to pull any messages the browser queued mid-turn. We splice the per-session
    * queue, return them to the child as the response, and — when non-empty —
    * publish a `mid_turn_message_injected` SSE frame so the browser can move
-   * those messages out of its pending queue (a dedupe signal, not a transcript
-   * render). Unknown methods reject with ACP `methodNotFound` (-32601), matching
+   * those messages out of its pending queue and render the immediate echo.
+   * Unknown methods reject with ACP `methodNotFound` (-32601), matching
    * the SDK's
    * default for an unimplemented client surface; the child's drain caller
    * treats that as "drain unsupported" and stops asking.
@@ -2599,9 +2865,12 @@ var BridgeClient = class {
       throw RequestError.methodNotFound(method);
     }
     const sessionId = typeof params["sessionId"] === "string" ? params["sessionId"] : void 0;
-    if (!sessionId) return { messages: [], hasQueuedPrompt: false };
+    if (!sessionId) return { messages: [], items: [], hasQueuedPrompt: false };
+    if (!this.ownsSession(sessionId)) {
+      return { messages: [], items: [], hasQueuedPrompt: false };
+    }
     const entry = this.resolveEntry(sessionId);
-    if (!entry) return { messages: [], hasQueuedPrompt: false };
+    if (!entry) return { messages: [], items: [], hasQueuedPrompt: false };
     const drained = entry.midTurnMessageQueue.splice(0);
     if (drained.length > 0) {
       for (const item of drained) {
@@ -2614,6 +2883,64 @@ var BridgeClient = class {
         );
       }
     }
+    const mediaMemo = /* @__PURE__ */ new Map();
+    const serializedMediaIds = /* @__PURE__ */ new Set();
+    const items = [];
+    try {
+      for (const item of drained) {
+        let degraded = 0;
+        const planned = (item.content ?? []).filter((block) => {
+          if (!isSessionMediaReference(block)) return true;
+          if (serializedMediaIds.has(block.mediaId)) {
+            degraded += 1;
+            return false;
+          }
+          serializedMediaIds.add(block.mediaId);
+          return true;
+        });
+        let resolvedBlocks;
+        let mediaReferences;
+        try {
+          resolvedBlocks = await entry.media.resolveContent(planned, mediaMemo);
+          mediaReferences = planned.filter(isSessionMediaReference);
+        } catch (error) {
+          if (!(error instanceof SessionMediaReferenceError)) throw error;
+          writeStderrLine(
+            `[mid-turn] session=${JSON.stringify(entry.sessionId)} degraded media for message ${JSON.stringify(item.messageId)}: ${JSON.stringify(error instanceof Error ? error.message : String(error))}`
+          );
+          const perBlock = await entry.media.resolveContentDegrading(
+            planned,
+            mediaMemo
+          );
+          resolvedBlocks = perBlock.resolvedBlocks;
+          mediaReferences = perBlock.retainedBlocks.filter(
+            isSessionMediaReference
+          );
+          degraded += perBlock.degraded;
+        }
+        let content = [
+          ...item.text ? [{ type: "text", text: item.text }] : [],
+          ...resolvedBlocks
+        ];
+        if (degraded > 0) content = withMediaDegradationMarker(content);
+        items.push({
+          messageId: item.messageId,
+          displayText: item.text,
+          content,
+          ...mediaReferences.length > 0 ? { mediaReferences } : {}
+        });
+      }
+    } catch (error) {
+      const requeued = new Set(drained.map((queued) => queued.messageId));
+      const ring = entry.settledMidTurnMessageIds;
+      const kept = ring.filter((id) => !requeued.has(id));
+      ring.splice(0, ring.length, ...kept);
+      entry.midTurnMessageQueue.unshift(...drained);
+      writeStderrLine(
+        `[mid-turn] session=${JSON.stringify(entry.sessionId)} drain failed, requeued ${drained.length} message(s): ${JSON.stringify(error instanceof Error ? error.message : String(error))}`
+      );
+      throw error;
+    }
     const echoed = drained.filter((item) => !item.queueOnly);
     const messages = drained.map((item) => item.text);
     const hasQueuedPrompt = entry.pendingPromptList.some(
@@ -2626,14 +2953,21 @@ var BridgeClient = class {
         data: {
           sessionId: entry.sessionId,
           messages: echoed.map((item) => item.text),
-          messageIds: echoed.map((item) => item.messageId)
+          messageIds: echoed.map((item) => item.messageId),
+          // Carry the structured `items` twin (content blocks per message) so
+          // the browser-side echo renderer can show attached images alongside
+          // the message text. Older consumers that don't read this field keep
+          // working unchanged.
+          items: echoed.map((item) => ({
+            ...item.content && item.content.length > 0 ? { content: item.content } : {}
+          }))
         }
       });
       writeStderrLine(
         published ? `[mid-turn] session=${entry.sessionId} drained=${messages.length} echoed=${echoed.length} injected into running turn` : `[mid-turn] session=${entry.sessionId} drained=${messages.length} echoed=${echoed.length} echo frame dropped (bus closed); reconciliation required`
       );
     }
-    return { messages, hasQueuedPrompt };
+    return { messages, items, hasQueuedPrompt };
   }
   async handleExternalToolGuardPrepare(params) {
     if (!this.externalToolGuard) {
@@ -3160,6 +3494,7 @@ var BridgeClient = class {
         return;
       const entry = this.resolveEntry(sessionId2);
       if (!entry) return;
+      this.onSessionCatalogChanged?.();
       try {
         entry.events.publish({
           type: "session_metadata_updated",
@@ -3602,20 +3937,20 @@ var BridgeClient = class {
     }
     let realTarget = params.path;
     try {
-      realTarget = await fs.realpath(params.path);
+      realTarget = await fs2.realpath(params.path);
     } catch (err) {
       const code = err && typeof err === "object" && "code" in err ? err.code : void 0;
       if (code !== "ENOENT") throw err;
       try {
-        const linkTarget = await fs.readlink(params.path);
-        realTarget = path.resolve(path.dirname(params.path), linkTarget);
+        const linkTarget = await fs2.readlink(params.path);
+        realTarget = path2.resolve(path2.dirname(params.path), linkTarget);
       } catch {
       }
     }
-    const tmp = `${realTarget}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`;
+    const tmp = `${realTarget}.${process.pid}.${Date.now()}.${randomUUID2()}.tmp`;
     let preserveMode;
     try {
-      const targetStat = await fs.stat(realTarget);
+      const targetStat = await fs2.stat(realTarget);
       preserveMode = {
         mode: targetStat.mode & 4095,
         uid: targetStat.uid,
@@ -3626,20 +3961,20 @@ var BridgeClient = class {
       if (code !== "ENOENT") throw err;
     }
     try {
-      await fs.writeFile(tmp, params.content, {
+      await fs2.writeFile(tmp, params.content, {
         encoding: "utf8",
         flag: "wx",
         mode: preserveMode?.mode ?? 384
       });
       if (preserveMode) {
-        await fs.chmod(tmp, preserveMode.mode).catch(() => {
+        await fs2.chmod(tmp, preserveMode.mode).catch(() => {
         });
-        await fs.chown(tmp, preserveMode.uid, preserveMode.gid).catch(() => {
+        await fs2.chown(tmp, preserveMode.uid, preserveMode.gid).catch(() => {
         });
       }
-      await fs.rename(tmp, realTarget);
+      await fs2.rename(tmp, realTarget);
     } catch (err) {
-      await fs.unlink(tmp).catch(() => {
+      await fs2.unlink(tmp).catch(() => {
       });
       throw err;
     }
@@ -3669,7 +4004,7 @@ var BridgeClient = class {
       );
     }
     const READ_FILE_SIZE_CAP = 100 * 1024 * 1024;
-    const stats = await fs.stat(params.path);
+    const stats = await fs2.stat(params.path);
     if (!stats.isFile()) {
       throw new Error(
         `readTextFile: ${params.path} is not a regular file (reported as ${describeStatKind(stats)}). Pipe / device / proc-like inputs can produce unbounded data and aren't supported by the bridge fs proxy.`
@@ -3680,7 +4015,7 @@ var BridgeClient = class {
         `readTextFile: ${params.path} is ${stats.size} bytes, exceeds the ${READ_FILE_SIZE_CAP}-byte daemon cap. Tail/grep externally and feed the relevant slice instead.`
       );
     }
-    const content = await fs.readFile(params.path, "utf8");
+    const content = await fs2.readFile(params.path, "utf8");
     if (typeof params.line === "number" || typeof params.limit === "number") {
       const startLine = params.line ?? 1;
       const start = startLine > 0 ? startLine - 1 : 0;
@@ -3882,8 +4217,8 @@ var GenerationStreamQueue = class {
 // packages/acp-bridge/src/sessionArtifacts.ts
 init_esbuild_shims();
 import { createHash } from "node:crypto";
-import { constants as fsConstants, promises as fs2 } from "node:fs";
-import path2 from "node:path";
+import { constants as fsConstants, promises as fs3 } from "node:fs";
+import path3 from "node:path";
 var SOURCE_RESERVATIONS = {
   tool: 100,
   client: 50,
@@ -4954,7 +5289,7 @@ var SessionArtifactStore = class {
   }
   getRealWorkspaceCwd() {
     if (!this.realWorkspaceCwdPromise) {
-      const promise = fs2.realpath(this.workspaceCwd).catch((error) => {
+      const promise = fs3.realpath(this.workspaceCwd).catch((error) => {
         if (this.realWorkspaceCwdPromise === promise) {
           this.realWorkspaceCwdPromise = void 0;
         }
@@ -5074,8 +5409,15 @@ function mergeBatchArtifact(existing, next) {
     delete merged.workspacePath;
     return merged;
   }
+  const refreshDisplay = existing.storage === "workspace" && next.storage === "workspace" && shouldRefreshWorkspaceDisplay(next, existing);
   return {
     ...existing,
+    title: refreshDisplay ? next.title : existing.title,
+    description: refreshDisplay ? next.description ?? existing.description : existing.description,
+    toolName: refreshDisplay ? next.toolName : existing.toolName,
+    source: refreshDisplay ? next.source : existing.source,
+    hookEventName: refreshDisplay ? next.hookEventName : existing.hookEventName,
+    toolCallId: refreshDisplay ? next.toolCallId : existing.toolCallId,
     status: next.status,
     sizeBytes: mergeSizeBytes(existing, next),
     metadata: mergeMetadata(existing, next),
@@ -5122,6 +5464,13 @@ function mergeArtifact(existing, incoming) {
     next.description = incoming.description;
     delete next.workspacePath;
     delete next.hideWorkspacePath;
+  } else if (existing.storage === "workspace" && incoming.storage === "workspace" && shouldRefreshWorkspaceDisplay(incoming, existing)) {
+    next.title = incoming.title;
+    next.description = incoming.description ?? existing.description;
+    next.toolCallId = incoming.toolCallId;
+    next.toolName = incoming.toolName;
+    next.source = incoming.source;
+    next.hookEventName = incoming.hookEventName;
   }
   const changed = !publicArtifactsEqual(
     toPublicArtifact(existing),
@@ -5137,6 +5486,16 @@ function shouldRecordEphemeralUnpin(existing, incoming) {
   return incoming.retentionExplicit && incoming.retention === "ephemeral" && (existing.retention !== "ephemeral" || existing.persistedAt !== void 0 || existing.durableTombstoneRequired === true);
 }
 __name(shouldRecordEphemeralUnpin, "shouldRecordEphemeralUnpin");
+function shouldRefreshWorkspaceDisplay(incoming, existing) {
+  if (incoming.toolName === "record_artifact" && incoming.source !== "hook") {
+    return true;
+  }
+  if (!incoming.toolName) {
+    return true;
+  }
+  return incoming.toolName === existing.toolName && incoming.source === existing.source && incoming.hookEventName === existing.hookEventName;
+}
+__name(shouldRefreshWorkspaceDisplay, "shouldRefreshWorkspaceDisplay");
 function publicArtifactsEqual(a, b) {
   return a.id === b.id && a.kind === b.kind && a.storage === b.storage && a.source === b.source && a.status === b.status && a.title === b.title && a.description === b.description && a.workspacePath === b.workspacePath && a.managedId === b.managedId && a.url === b.url && a.mimeType === b.mimeType && a.sizeBytes === b.sizeBytes && metadataEqual(a.metadata, b.metadata) && a.retention === b.retention && a.restoreState === b.restoreState && a.persistenceWarning === b.persistenceWarning && a.persistedAt === b.persistedAt && a.clientRetained === b.clientRetained && a.createdAt === b.createdAt && a.updatedAt === b.updatedAt && a.toolCallId === b.toolCallId && a.toolName === b.toolName && a.hookEventName === b.hookEventName && a.clientId === b.clientId;
 }
@@ -5589,7 +5948,7 @@ function buildIdentityKey(input) {
 }
 __name(buildIdentityKey, "buildIdentityKey");
 function managedIdForWorkspacePath(workspaceCwd, workspacePath) {
-  return createHash("sha1").update(path2.resolve(workspaceCwd, workspacePath)).digest("hex").slice(0, 16);
+  return createHash("sha1").update(path3.resolve(workspaceCwd, workspacePath)).digest("hex").slice(0, 16);
 }
 __name(managedIdForWorkspacePath, "managedIdForWorkspacePath");
 function normalizeString(value, field, maxLength, required) {
@@ -5636,7 +5995,7 @@ __name(normalizeString, "normalizeString");
 function normalizeManagedId(value) {
   const managedId = normalizeString(value, "managedId", 200, false);
   if (!managedId) return void 0;
-  if (managedId.includes("/") || managedId.includes("\\") || managedId.includes("..") || path2.isAbsolute(managedId) || path2.win32.isAbsolute(managedId)) {
+  if (managedId.includes("/") || managedId.includes("\\") || managedId.includes("..") || path3.isAbsolute(managedId) || path3.win32.isAbsolute(managedId)) {
     throw new SessionArtifactValidationError(
       "managedId must be an opaque managed resource id",
       "managedId"
@@ -5670,21 +6029,21 @@ function hasUnsafeDisplayPayload(value) {
 __name(hasUnsafeDisplayPayload, "hasUnsafeDisplayPayload");
 function normalizeWorkspacePath(raw, workspaceCwd) {
   const trimmed = normalizeString(raw, "workspacePath", 500, true);
-  if (path2.isAbsolute(trimmed)) {
+  if (path3.isAbsolute(trimmed)) {
     throw new SessionArtifactValidationError(
       "workspacePath must be relative to the workspace",
       "workspacePath"
     );
   }
-  const absolute = path2.resolve(workspaceCwd, trimmed);
-  const relative = path2.relative(workspaceCwd, absolute);
+  const absolute = path3.resolve(workspaceCwd, trimmed);
+  const relative = path3.relative(workspaceCwd, absolute);
   if (!relative || isOutsidePath(relative)) {
     throw new SessionArtifactValidationError(
       "workspacePath must stay inside the workspace",
       "workspacePath"
     );
   }
-  return relative.split(path2.sep).join("/");
+  return relative.split(path3.sep).join("/");
 }
 __name(normalizeWorkspacePath, "normalizeWorkspacePath");
 function normalizeArtifactUrl(raw, allowFile) {
@@ -5885,7 +6244,7 @@ __name(normalizeSizeBytes, "normalizeSizeBytes");
 function inferKind(input) {
   if (input.storage === "published") return "html";
   if (input.url) return "link";
-  const ext = input.workspacePath ? path2.extname(input.workspacePath).toLowerCase() : "";
+  const ext = input.workspacePath ? path3.extname(input.workspacePath).toLowerCase() : "";
   if (ext === ".html" || ext === ".htm") return "html";
   if ([".png", ".jpg", ".jpeg", ".gif", ".webp", ".svg"].includes(ext)) {
     return "image";
@@ -5899,15 +6258,15 @@ function inferKind(input) {
 __name(inferKind, "inferKind");
 async function getWorkspaceStatus(workspacePath, realWorkspaceCwd, expected, options = { hashContent: true }) {
   const realWorkspace = await realWorkspaceCwd;
-  const absolutePath = path2.resolve(realWorkspace, workspacePath);
+  const absolutePath = path3.resolve(realWorkspace, workspacePath);
   try {
-    const realPath = await fs2.realpath(absolutePath);
-    const relative = path2.relative(realWorkspace, realPath);
+    const realPath = await fs3.realpath(absolutePath);
+    const relative = path3.relative(realWorkspace, realPath);
     if (!relative || isOutsidePath(relative)) {
       return { status: "missing", escaped: true };
     }
-    const preOpenStat = await fs2.lstat(realPath);
-    const handle = await fs2.open(
+    const preOpenStat = await fs3.lstat(realPath);
+    const handle = await fs3.open(
       realPath,
       fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW
     );
@@ -6021,14 +6380,14 @@ function isWorkspaceContentChanged(artifact, status) {
 __name(isWorkspaceContentChanged, "isWorkspaceContentChanged");
 async function danglingSymlinkEscapesWorkspace(absolutePath, realWorkspace) {
   try {
-    const stat = await fs2.lstat(absolutePath);
+    const stat = await fs3.lstat(absolutePath);
     if (!stat.isSymbolicLink()) {
       return false;
     }
-    const target = await fs2.readlink(absolutePath);
-    const parent = await fs2.realpath(path2.dirname(absolutePath));
-    const targetPath = path2.resolve(parent, target);
-    return isOutsidePath(path2.relative(realWorkspace, targetPath));
+    const target = await fs3.readlink(absolutePath);
+    const parent = await fs3.realpath(path3.dirname(absolutePath));
+    const targetPath = path3.resolve(parent, target);
+    return isOutsidePath(path3.relative(realWorkspace, targetPath));
   } catch (error) {
     if (isNotFoundError(error)) {
       return false;
@@ -6059,7 +6418,7 @@ function isNoFollowSymlinkError(error) {
 }
 __name(isNoFollowSymlinkError, "isNoFollowSymlinkError");
 function isOutsidePath(relative) {
-  return relative === ".." || relative.startsWith(`..${path2.sep}`) || path2.isAbsolute(relative);
+  return relative === ".." || relative.startsWith(`..${path3.sep}`) || path3.isAbsolute(relative);
 }
 __name(isOutsidePath, "isOutsidePath");
 
@@ -6866,6 +7225,57 @@ function broadcastTurnError(entry, sessionId, err, promptId, originatorClientId,
   }
 }
 __name(broadcastTurnError, "broadcastTurnError");
+var TERMINAL_TURN_STATUS_OVERLAY_LIMIT = 64;
+function truncateTurnText(text) {
+  const truncated = text.length > TURN_RESULT_TEXT_MAX_CHARS;
+  return {
+    text: truncated ? text.slice(0, TURN_RESULT_TEXT_MAX_CHARS) : text,
+    truncated
+  };
+}
+__name(truncateTurnText, "truncateTurnText");
+function rememberTerminalTurnStatus(entry, pending, terminal) {
+  const promptText = truncateTurnText(pending.text);
+  const shared = {
+    sessionId: entry.sessionId,
+    promptId: pending.promptId,
+    promptText: promptText.text,
+    ...promptText.truncated ? { promptTextTruncated: true } : {},
+    queuedAt: pending.queuedAt,
+    ...pending.startedAt !== void 0 ? { startedAt: pending.startedAt } : {},
+    endedAt: Date.now(),
+    ...pending.originatorClientId !== void 0 ? { originatorClientId: pending.originatorClientId } : {}
+  };
+  const status = terminal.kind === "complete" ? {
+    ...shared,
+    state: terminal.result.stopReason === "cancelled" ? "cancelled" : "completed",
+    ...terminal.result.stopReason !== void 0 ? { stopReason: terminal.result.stopReason } : {}
+  } : terminal.kind === "cancelled" ? { ...shared, state: "cancelled", stopReason: "cancelled" } : {
+    ...shared,
+    state: "error",
+    error: normalizeTurnResultError(terminal.err)
+  };
+  entry.terminalTurnStatuses.set(pending.promptId, status);
+  entry.enrichedTerminalPromptIds.delete(pending.promptId);
+  while (entry.terminalTurnStatuses.size > TERMINAL_TURN_STATUS_OVERLAY_LIMIT) {
+    const oldest2 = entry.terminalTurnStatuses.keys().next().value;
+    if (oldest2 === void 0) break;
+    entry.terminalTurnStatuses.delete(oldest2);
+    entry.enrichedTerminalPromptIds.delete(oldest2);
+  }
+}
+__name(rememberTerminalTurnStatus, "rememberTerminalTurnStatus");
+function rememberEnrichedTerminalTurnStatus(entry, promptId, status) {
+  entry.terminalTurnStatuses.set(promptId, status);
+  entry.enrichedTerminalPromptIds.add(promptId);
+  while (entry.terminalTurnStatuses.size > TERMINAL_TURN_STATUS_OVERLAY_LIMIT) {
+    const oldest2 = entry.terminalTurnStatuses.keys().next().value;
+    if (oldest2 === void 0) break;
+    entry.terminalTurnStatuses.delete(oldest2);
+    entry.enrichedTerminalPromptIds.delete(oldest2);
+  }
+}
+__name(rememberEnrichedTerminalTurnStatus, "rememberEnrichedTerminalTurnStatus");
 function publishPromptTerminal(entry, pendingEntry, terminal) {
   if (pendingEntry.terminalPublished) {
     writeServeDebugLine(
@@ -6874,6 +7284,7 @@ function publishPromptTerminal(entry, pendingEntry, terminal) {
     return;
   }
   pendingEntry.terminalPublished = true;
+  rememberTerminalTurnStatus(entry, pendingEntry, terminal);
   const originatorClientId = pendingEntry.originatorClientId;
   const mutateTurnState = pendingEntry.state === "running";
   if (!mutateTurnState && entry.turnErrorEvent) {
@@ -6941,16 +7352,109 @@ function extractPromptText(prompt) {
   if (!Array.isArray(prompt)) return "";
   let hasImage = false;
   for (const block of prompt) {
-    if (block["type"] === "image") {
+    const record = block;
+    if (record["type"] === "image") {
       hasImage = true;
     }
-    if (block["type"] === "text" && typeof block["text"] === "string" && block["text"].length > 0) {
-      return block["text"];
+    if (record["type"] === "text" && typeof record["text"] === "string" && record["text"].length > 0) {
+      return record["text"];
     }
   }
   return hasImage ? "[image]" : "";
 }
 __name(extractPromptText, "extractPromptText");
+function liveTurnStatus(sessionId, pending) {
+  const promptText = truncateTurnText(pending.text);
+  return {
+    sessionId,
+    state: pending.state === "running" ? "running" : "queued",
+    promptId: pending.promptId,
+    promptText: promptText.text,
+    ...promptText.truncated ? { promptTextTruncated: true } : {},
+    queuedAt: pending.queuedAt,
+    ...pending.startedAt !== void 0 ? { startedAt: pending.startedAt } : {},
+    ...pending.originatorClientId !== void 0 ? { originatorClientId: pending.originatorClientId } : {}
+  };
+}
+__name(liveTurnStatus, "liveTurnStatus");
+function findLiveTurnStatus(entry, promptId) {
+  const live = entry.pendingPromptList.filter(
+    (pending) => !pending.terminalPublished && (!pending.removed || pending.state === "running")
+  );
+  if (promptId !== void 0) {
+    const match = live.find((pending) => pending.promptId === promptId);
+    return match ? liveTurnStatus(entry.sessionId, match) : void 0;
+  }
+  const running = live.find((pending) => pending.state === "running");
+  if (running) return liveTurnStatus(entry.sessionId, running);
+  const queued = live.find((pending) => pending.state === "queued");
+  return queued ? liveTurnStatus(entry.sessionId, queued) : void 0;
+}
+__name(findLiveTurnStatus, "findLiveTurnStatus");
+function settledTurnStatus(sessionId, record) {
+  return {
+    sessionId,
+    state: record.state,
+    promptId: record.promptId,
+    ...record.stopReason !== void 0 ? { stopReason: record.stopReason } : {},
+    ...record.error !== void 0 ? { error: record.error } : {},
+    ...record.startedAt !== void 0 ? { startedAt: record.startedAt } : {},
+    endedAt: record.endedAt,
+    ...record.promptText !== void 0 ? { promptText: record.promptText } : {},
+    ...record.promptTextTruncated !== void 0 ? { promptTextTruncated: record.promptTextTruncated } : {},
+    ...record.resultText !== void 0 ? { resultText: record.resultText } : {},
+    ...record.resultTruncated !== void 0 ? { resultTruncated: record.resultTruncated } : {},
+    ...record.resultTruncated === true ? { resultCode: record.resultCode ?? TURN_RESULT_CODE_TEXT_TRUNCATED } : {},
+    ...record.originatorClientId !== void 0 ? { originatorClientId: record.originatorClientId } : {}
+  };
+}
+__name(settledTurnStatus, "settledTurnStatus");
+function enrichTerminalTurnStatus(terminal, persisted) {
+  return {
+    ...terminal,
+    // The bridge's display projection is trusted; the child-recorded text
+    // only backfills when the terminal has none, so hidden channel context
+    // the child derived from raw blocks never replaces it.
+    ...terminal.promptText === void 0 && persisted.promptText !== void 0 ? { promptText: persisted.promptText } : {},
+    ...terminal.promptTextTruncated === void 0 && persisted.promptTextTruncated !== void 0 ? { promptTextTruncated: persisted.promptTextTruncated } : {},
+    ...persisted.resultText !== void 0 ? { resultText: persisted.resultText } : {},
+    ...persisted.resultTruncated !== void 0 ? { resultTruncated: persisted.resultTruncated } : {},
+    ...persisted.resultCode !== void 0 ? { resultCode: persisted.resultCode } : {},
+    ...terminal.originatorClientId === void 0 && persisted.originatorClientId !== void 0 ? { originatorClientId: persisted.originatorClientId } : {}
+  };
+}
+__name(enrichTerminalTurnStatus, "enrichTerminalTurnStatus");
+function mergeTerminalWithPersisted(terminal, persisted) {
+  if (terminal.state === "error" && persisted.state !== "error") {
+    return {
+      ...persisted,
+      ...terminal.promptText !== void 0 ? { promptText: terminal.promptText } : {},
+      ...terminal.promptTextTruncated !== void 0 ? { promptTextTruncated: terminal.promptTextTruncated } : {}
+    };
+  }
+  return enrichTerminalTurnStatus(terminal, persisted);
+}
+__name(mergeTerminalWithPersisted, "mergeTerminalWithPersisted");
+function latestTerminalTurnStatus(entry) {
+  let latest;
+  for (const status of entry.terminalTurnStatuses.values()) {
+    if ((status.endedAt ?? 0) >= (latest?.endedAt ?? 0)) latest = status;
+  }
+  return latest;
+}
+__name(latestTerminalTurnStatus, "latestTerminalTurnStatus");
+function extractMediaBlocks(prompt) {
+  if (!Array.isArray(prompt)) return void 0;
+  const media = [];
+  for (const block of prompt) {
+    if (!block || typeof block !== "object") continue;
+    if (block.type === "image" || block.type === "audio") {
+      media.push(block);
+    }
+  }
+  return media.length > 0 ? media : void 0;
+}
+__name(extractMediaBlocks, "extractMediaBlocks");
 var DEFAULT_INIT_TIMEOUT_MS = 1e4;
 var PERSIST_TIMEOUT_MS = 5e3;
 var MAX_PARENT_PERSIST_ATTEMPTS = 3;
@@ -6968,6 +7472,15 @@ var MAX_EMPTY_TRANSCRIPT_PAGES = 20;
 var SHELL_COMMAND_TIMEOUT_MS = 12e4;
 var MAX_SHELL_OUTPUT_FOR_HISTORY = 1e4;
 var MAX_MID_TURN_QUEUE_DEPTH = 20;
+var inlineMediaBlockBytes = /* @__PURE__ */ __name((blocks) => {
+  let total = 0;
+  for (const block of blocks) {
+    if (block.type === "image" && "data" in block) {
+      total += block.data.length;
+    }
+  }
+  return total;
+}, "inlineMediaBlockBytes");
 var DEFAULT_MAX_SESSIONS = 32;
 var DEFAULT_MAX_PENDING_PROMPTS_PER_SESSION = 5;
 var CHAT_RECORD_UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
@@ -6976,6 +7489,8 @@ var DEFAULT_PERMISSION_TIMEOUT_MS = 5 * 60 * 1e3;
 var DEFAULT_MAX_PENDING_PER_SESSION = 64;
 var DEFAULT_SESSION_REAP_INTERVAL_MS = 6e4;
 var DEFAULT_SESSION_IDLE_TIMEOUT_MS = 30 * 6e4;
+var MAX_RETAINED_SESSION_MEDIA_BYTES = 512 * 1024 * 1024;
+var RETAINED_SESSION_MEDIA_TTL_MS = 3 * 60 * 6e4;
 function createAcpSessionBridge(opts) {
   let liveScreenContextCaptureHandler;
   let liveTaskToolRequestHandler;
@@ -7034,7 +7549,17 @@ function createAcpSessionBridge(opts) {
       );
     }
   }, "releaseFreshSessionReservation");
+  const sessionCatalogGeneration = randomUUID3();
+  let sessionCatalogRevision = 0;
+  const getSessionCatalogVersion = /* @__PURE__ */ __name(() => ({
+    generation: sessionCatalogGeneration,
+    revision: sessionCatalogRevision
+  }), "getSessionCatalogVersion");
+  const markSessionCatalogChanged = /* @__PURE__ */ __name(() => {
+    sessionCatalogRevision += 1;
+  }, "markSessionCatalogChanged");
   const emitSessionLifecycle = /* @__PURE__ */ __name((event) => {
+    markSessionCatalogChanged();
     try {
       opts.sessionLifecycle?.(event);
     } catch (err) {
@@ -7104,7 +7629,7 @@ function createAcpSessionBridge(opts) {
   } else {
     maxPendingPromptsPerSession = maxPendingPromptsRaw;
   }
-  if (!path3.isAbsolute(opts.boundWorkspace)) {
+  if (!path4.isAbsolute(opts.boundWorkspace)) {
     throw new TypeError(
       `Invalid boundWorkspace: "${opts.boundWorkspace}". Must be an absolute path.`
     );
@@ -7127,6 +7652,7 @@ function createAcpSessionBridge(opts) {
     DEFAULT_SESSION_IDLE_TIMEOUT_MS
   );
   let sessionReaper;
+  let mediaSweeper;
   let lastActivityTimestamp = null;
   let activePromptCounter = 0;
   function touchActivity() {
@@ -7443,9 +7969,32 @@ function createAcpSessionBridge(opts) {
     }
   }
   __name(withWorkspaceControl, "withWorkspaceControl");
+  function sweepRetainedMedia() {
+    const now = Date.now();
+    for (const [id] of retainedMedia) {
+      if (byId.has(id) || inFlightRestores.has(id)) continue;
+      const detachedAt = retainedMediaDetachedAt.get(id);
+      if (detachedAt === void 0 || now - detachedAt < RETAINED_SESSION_MEDIA_TTL_MS) {
+        continue;
+      }
+      void releaseSessionMedia(id).catch((error) => {
+        writeStderrLine(
+          `qwen serve: failed to release retained media for ${JSON.stringify(id)}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      });
+    }
+  }
+  __name(sweepRetainedMedia, "sweepRetainedMedia");
   function startSessionReaper() {
-    if (sessionReapIntervalMs <= 0 || sessionIdleTimeoutMs <= 0) {
-      writeStderrLine("qwen serve: session reaper disabled");
+    if (sessionReapIntervalMs <= 0) {
+      writeStderrLine(
+        `qwen serve: session reaper disabled; retained media sweep runs every ${DEFAULT_SESSION_REAP_INTERVAL_MS}ms`
+      );
+      mediaSweeper = setInterval(() => {
+        if (shuttingDown) return;
+        sweepRetainedMedia();
+      }, DEFAULT_SESSION_REAP_INTERVAL_MS);
+      mediaSweeper.unref();
       return;
     }
     writeStderrLine(
@@ -7455,6 +8004,7 @@ function createAcpSessionBridge(opts) {
       if (shuttingDown) return;
       const now = Date.now();
       for (const [id, entry] of byId) {
+        if (sessionIdleTimeoutMs <= 0) break;
         if (!entryIsAutoCloseCandidate(entry)) continue;
         const lastActive = entry.sessionLastSeenAt ?? Date.parse(entry.createdAt);
         const idle = now - lastActive;
@@ -7467,6 +8017,7 @@ function createAcpSessionBridge(opts) {
           closeReason: "idle_timeout"
         });
       }
+      sweepRetainedMedia();
     }, sessionReapIntervalMs);
     sessionReaper.unref();
   }
@@ -7476,11 +8027,29 @@ function createAcpSessionBridge(opts) {
       clearInterval(sessionReaper);
       sessionReaper = void 0;
     }
+    if (mediaSweeper !== void 0) {
+      clearInterval(mediaSweeper);
+      mediaSweeper = void 0;
+    }
   }
   __name(stopSessionReaper, "stopSessionReaper");
   const aliveChannels = /* @__PURE__ */ new Set();
   let inFlightChannelSpawn;
   const byId = /* @__PURE__ */ new Map();
+  const retainedMedia = /* @__PURE__ */ new Map();
+  const retainedMediaDetachedAt = /* @__PURE__ */ new Map();
+  let mediaPutQueue = Promise.resolve();
+  const retainSessionMedia = /* @__PURE__ */ __name((sessionId, store = retainedMedia.get(sessionId) ?? new SessionMediaStore()) => {
+    retainedMedia.set(sessionId, store);
+    return store;
+  }, "retainSessionMedia");
+  const releaseSessionMedia = /* @__PURE__ */ __name(async (sessionId) => {
+    const store = retainedMedia.get(sessionId);
+    if (!store) return;
+    retainedMedia.delete(sessionId);
+    retainedMediaDetachedAt.delete(sessionId);
+    await store.close();
+  }, "releaseSessionMedia");
   const forwardRunningPromptCancel = /* @__PURE__ */ __name(async (entry, pending, notification) => {
     if (pending.cancelForwardInitial) {
       return pending.cancelForwardInitial;
@@ -7620,7 +8189,7 @@ function createAcpSessionBridge(opts) {
     return limits;
   }, "journalSessionLimits");
   const unregisterJournalGrowthSessionLimits = journalGrowthPolicy !== void 0 && opts.registerJournalGrowthSessionLimits !== void 0 ? opts.registerJournalGrowthSessionLimits(journalSessionLimits) : void 0;
-  const createClientId = /* @__PURE__ */ __name(() => `client_${randomUUID2()}`, "createClientId");
+  const createClientId = /* @__PURE__ */ __name(() => `client_${randomUUID3()}`, "createClientId");
   const registerClient = /* @__PURE__ */ __name((entry, requestedClientId) => {
     if (requestedClientId && entry.clientIds.has(requestedClientId)) {
       entry.clientIds.set(
@@ -7679,7 +8248,7 @@ function createAcpSessionBridge(opts) {
     if (inFlightChannelSpawn) return await inFlightChannelSpawn;
     const promise = (async () => {
       const privateParentCapability = randomBytes(32).toString("base64url");
-      const acpChannelId = randomUUID2();
+      const acpChannelId = randomUUID3();
       const channel = await telemetry.withSpan(
         "channel.spawn",
         {
@@ -7800,7 +8369,10 @@ function createAcpSessionBridge(opts) {
             const currentInfo = infoRef.current;
             if (!currentInfo) return;
             applyActiveWorkSnapshot(currentInfo, snapshot);
-          }
+          },
+          // Child-side automatic title updates change persisted catalog
+          // metadata the bridge never sees; forward the catalog-clock mark.
+          markSessionCatalogChanged
         );
         const rawConnection = new ClientSideConnection(
           () => channel.transportGuard ? createLogSafeAcpClient(client, channel.transportGuard) : client,
@@ -7938,6 +8510,9 @@ function createAcpSessionBridge(opts) {
             touchActivity();
           }
           byId.delete(sid);
+          if (retainedMedia.has(sid)) {
+            retainedMediaDetachedAt.set(sid, Date.now());
+          }
           telemetry.metrics?.sessionLifecycle("die");
           emitSessionLifecycle({
             type: "removed",
@@ -8975,6 +9550,7 @@ function createAcpSessionBridge(opts) {
         workspaceCwd,
         persistence: createSessionArtifactPersistence(ci.connection, sessionId)
       }),
+      media: retainSessionMedia(sessionId),
       recordingDegraded: false,
       closing: false,
       cwdChangeQueue: Promise.resolve(),
@@ -8982,6 +9558,9 @@ function createAcpSessionBridge(opts) {
       pendingPromptCount: 0,
       pendingAgentNotificationCount: 0,
       pendingPromptList: [],
+      terminalTurnStatuses: /* @__PURE__ */ new Map(),
+      enrichedTerminalPromptIds: /* @__PURE__ */ new Set(),
+      rewindGeneration: 0,
       midTurnMessageQueue: [],
       settledMidTurnMessageIds: [],
       promotedMidTurnMessageIds: [],
@@ -9931,6 +10510,9 @@ function createAcpSessionBridge(opts) {
         const restoreEntry = byId.get(req.sessionId);
         if (restoreEntry?.events === restoreEvents) {
           byId.delete(req.sessionId);
+          if (retainedMedia.has(req.sessionId)) {
+            retainedMediaDetachedAt.set(req.sessionId, Date.now());
+          }
           ci?.sessionIds.delete(req.sessionId);
           emitSessionLifecycle({
             type: "removed",
@@ -10094,6 +10676,15 @@ function createAcpSessionBridge(opts) {
     } catch {
     }
     entry.events.close();
+    if (reason === "last_client_detached" || reason === "idle_timeout") {
+      retainedMediaDetachedAt.set(sessionId, Date.now());
+    } else {
+      await releaseSessionMedia(sessionId).catch((error) => {
+        writeStderrLine(
+          `qwen serve: failed to release media for closed session ${JSON.stringify(sessionId)}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      });
+    }
     if (!agentSessionClosed) {
       try {
         await telemetry.withSpan(
@@ -10122,25 +10713,76 @@ function createAcpSessionBridge(opts) {
       ring.splice(0, ring.length - MID_TURN_RECONCILIATION_RING_SIZE);
     }
   }, "rememberMidTurnId");
-  const promoteMidTurnMessage = /* @__PURE__ */ __name((entry, messageId, text, originatorClientId) => {
-    void bridgeApi.sendPrompt(
+  const removeQueuedMedia = /* @__PURE__ */ __name((entry, content) => {
+    for (const block of content ?? []) {
+      if (!isSessionMediaReference(block)) continue;
+      void entry.media.remove(block.mediaId).catch((error) => {
+        writeStderrLine(
+          `[session-media] session=${JSON.stringify(entry.sessionId)} failed to remove queued media ${JSON.stringify(block.mediaId)}: ${JSON.stringify(error instanceof Error ? error.message : String(error))}`
+        );
+      });
+    }
+  }, "removeQueuedMedia");
+  const promoteMidTurnMessage = /* @__PURE__ */ __name((entry, messageId, text, originatorClientId, content) => {
+    const resolvableBlocks = [];
+    let degraded = 0;
+    for (const block of content ?? []) {
+      try {
+        entry.media.assertReference(block);
+        resolvableBlocks.push(block);
+      } catch (error) {
+        if (!(error instanceof SessionMediaReferenceError)) throw error;
+        degraded += 1;
+      }
+    }
+    let prompt = [
+      ...text ? [{ type: "text", text }] : [],
+      ...resolvableBlocks
+    ];
+    if (degraded > 0) {
+      prompt = withMediaDegradationMarker(prompt);
+    }
+    const context = {
+      promptId: messageId,
+      promotedMidTurn: { originatorClientId },
+      onPromptAdmitted: /* @__PURE__ */ __name(() => {
+        rememberMidTurnId(entry.promotedMidTurnMessageIds, messageId);
+      }, "onPromptAdmitted")
+    };
+    const sendFallback = /* @__PURE__ */ __name(() => bridgeApi.sendPrompt(
       entry.sessionId,
       {
         sessionId: entry.sessionId,
-        prompt: [{ type: "text", text }]
+        prompt: withMediaDegradationMarker(
+          text ? [{ type: "text", text }] : []
+        )
       },
       void 0,
-      {
-        promptId: messageId,
-        promotedMidTurn: { originatorClientId },
-        // Record the id only once sendPrompt owns its FIFO slot: an
-        // admission failure must not land the id in the reconciliation
-        // ring, or retries would be acked for a message that never runs.
-        onPromptAdmitted: /* @__PURE__ */ __name(() => {
-          rememberMidTurnId(entry.promotedMidTurnMessageIds, messageId);
-        }, "onPromptAdmitted")
-      }
-    ).catch((error) => {
+      context
+    ), "sendFallback");
+    let result;
+    try {
+      result = bridgeApi.sendPrompt(
+        entry.sessionId,
+        {
+          sessionId: entry.sessionId,
+          prompt
+        },
+        void 0,
+        context
+      );
+    } catch (error) {
+      try {
+        if (!(error instanceof SessionMediaReferenceError)) throw error;
+        result = sendFallback();
+      } catch (fallbackError) {
+        writeStderrLine(
+          `[mid-turn] session=${JSON.stringify(entry.sessionId)} failed to run promoted message ${JSON.stringify(messageId)}: ${JSON.stringify(fallbackError instanceof Error ? fallbackError.message : String(fallbackError))}`
+        );
+        return;
+      }
+    }
+    void result.catch((error) => {
       writeStderrLine(
         `[mid-turn] session=${JSON.stringify(entry.sessionId)} failed to run promoted message ${JSON.stringify(messageId)}: ${JSON.stringify(error instanceof Error ? error.message : String(error))}`
       );
@@ -10460,7 +11102,7 @@ function createAcpSessionBridge(opts) {
         req.branch,
         req.sessionId
       );
-      const tracker = effectiveScope === "single" ? workspaceKey : `${workspaceKey}#${randomUUID2()}`;
+      const tracker = effectiveScope === "single" ? workspaceKey : `${workspaceKey}#${randomUUID3()}`;
       inFlightSpawns.set(tracker, promise);
       try {
         return await promise;
@@ -10490,9 +11132,15 @@ function createAcpSessionBridge(opts) {
           )
         );
       }
+      if (!Array.isArray(req.prompt)) {
+        return Promise.reject(
+          RequestError.invalidParams(void 0, "Prompt must be an array")
+        );
+      }
       const promotedMidTurn = context?.promotedMidTurn;
       const isPromotedMidTurn = promotedMidTurn !== void 0;
       const originatorClientId = promotedMidTurn ? promotedMidTurn.originatorClientId : resolveTrustedClientId(entry, context?.clientId);
+      entry.media.assertReferences(req.prompt);
       const modelPrompt = context?.modelPrompt;
       if (modelPrompt !== void 0 && !isValidTrustedModelPrompt(modelPrompt)) {
         throw new TypeError(
@@ -10516,7 +11164,7 @@ function createAcpSessionBridge(opts) {
         promptSlotReleased = true;
         entry.pendingPromptCount = Math.max(0, entry.pendingPromptCount - 1);
       }, "releasePromptSlot");
-      const promptId = context?.promptId ?? randomUUID2();
+      const promptId = context?.promptId ?? randomUUID3();
       const invocationContext = Object.freeze({
         version: 1,
         sessionId,
@@ -10549,6 +11197,7 @@ function createAcpSessionBridge(opts) {
         ...originatorClientId !== void 0 ? { originatorClientId } : {},
         ...isPromotedMidTurn ? { promotedMidTurn: true } : {},
         text: pendingText,
+        content: extractMediaBlocks(req.prompt),
         abortController: pendingAbort,
         state: isQueued ? "queued" : "running"
       };
@@ -10641,6 +11290,7 @@ function createAcpSessionBridge(opts) {
             }
             throw new DOMException("Prompt aborted", "AbortError");
           }
+          pendingEntry.startedAt = Date.now();
           if (pendingEntry.state === "queued" || isPromotedMidTurn) {
             if (pendingEntry.state === "queued") {
               delete entry.todoStopGuardAwaitingQueuedPromptOwnerPromptId;
@@ -10668,10 +11318,25 @@ function createAcpSessionBridge(opts) {
                 ...context?.clientId ? { "qwen-code.client_id": context.clientId } : {}
               },
               async () => {
+                let dispatchBlocks = req.prompt;
+                let resolvedPrompt;
+                try {
+                  resolvedPrompt = await entry.media.resolveContent(dispatchBlocks);
+                } catch (error) {
+                  if (!isPromotedMidTurn || !(error instanceof SessionMediaReferenceError)) {
+                    throw error;
+                  }
+                  const perBlock = await entry.media.resolveContentDegrading(dispatchBlocks);
+                  dispatchBlocks = perBlock.retainedBlocks;
+                  resolvedPrompt = withMediaDegradationMarker(
+                    perBlock.resolvedBlocks
+                  );
+                }
                 const normalized = telemetry.injectPromptContext(
                   {
                     ...req,
-                    sessionId
+                    sessionId,
+                    prompt: resolvedPrompt
                   }
                 );
                 assertLivePromptEntry(sessionId, entry);
@@ -10694,6 +11359,7 @@ function createAcpSessionBridge(opts) {
                   delete meta[DAEMON_CHANNEL_DELIVERY_META_KEY];
                   delete meta[DAEMON_PROMPT_DISPLAY_TEXT_META_KEY];
                   delete meta[DAEMON_MODEL_PROMPT_META_KEY];
+                  delete meta[DAEMON_MEDIA_REFERENCES_META_KEY];
                   delete meta[CHANNEL_PROMPT_META_KEY];
                   if (isRetry) {
                     meta[DAEMON_RETRY_META_KEY] = true;
@@ -10710,6 +11376,12 @@ function createAcpSessionBridge(opts) {
                   if (modelPrompt !== void 0) {
                     meta[DAEMON_MODEL_PROMPT_META_KEY] = modelPrompt;
                   }
+                  const mediaReferences = dispatchBlocks.filter(
+                    isSessionMediaReference
+                  );
+                  if (mediaReferences.length > 0) {
+                    meta[DAEMON_MEDIA_REFERENCES_META_KEY] = mediaReferences;
+                  }
                   if (context?.channelPrompt === true) {
                     meta[CHANNEL_PROMPT_META_KEY] = true;
                   }
@@ -10738,7 +11410,10 @@ function createAcpSessionBridge(opts) {
                   if (!isRetry && !isContinue) {
                     echoPromptToSessionBus(
                       entry,
-                      promptRequest,
+                      {
+                        ...promptRequest,
+                        prompt: dispatchBlocks
+                      },
                       pendingEntry.promptId,
                       originatorClientId,
                       channelDisplayText
@@ -10894,7 +11569,8 @@ function createAcpSessionBridge(opts) {
             entry,
             message.messageId,
             message.text,
-            message.originatorClientId
+            message.originatorClientId,
+            message.content
           );
         }
         void maybeCloseIdleSession(entry, "prompt_settled");
@@ -11141,6 +11817,7 @@ function createAcpSessionBridge(opts) {
               `branchSession: agent returned invalid response: ${JSON.stringify(result)}`
             );
           }
+          markSessionCatalogChanged();
           const rawBranchName = result.displayName ?? result.title;
           const branchDisplayName = typeof rawBranchName === "string" ? rawBranchName : result.newSessionId.slice(0, 8);
           if (!restoreBranch) {
@@ -11334,6 +12011,7 @@ function createAcpSessionBridge(opts) {
       const entry = byId.get(sessionId);
       if (entry) {
         entry.worktree = worktree;
+        markSessionCatalogChanged();
       }
     },
     async closeSession(sessionId, context, closeOpts) {
@@ -11359,6 +12037,7 @@ function createAcpSessionBridge(opts) {
         const nextDisplayName = metadata.displayName || void 0;
         if (entry.displayName !== nextDisplayName) {
           entry.displayName = nextDisplayName;
+          markSessionCatalogChanged();
           writeStderrLine(
             `qwen serve: updated session metadata ${JSON.stringify(sessionId)} displayName=${entry.displayName === void 0 ? "cleared" : "set"}` + (context?.clientId ? ` by client ${JSON.stringify(context.clientId)}` : "")
           );
@@ -11421,7 +12100,7 @@ function createAcpSessionBridge(opts) {
       return warnings.length > 0 ? { ...result, warnings } : result;
     },
     listWorkspaceSessions(workspaceCwd) {
-      if (!path3.isAbsolute(workspaceCwd)) return [];
+      if (!path4.isAbsolute(workspaceCwd)) return [];
       const key = workspaceCwd === boundWorkspace ? boundWorkspace : canonicalizeWorkspace(workspaceCwd);
       if (key !== boundWorkspace) return [];
       const out = [];
@@ -11432,6 +12111,8 @@ function createAcpSessionBridge(opts) {
       }
       return out;
     },
+    getSessionCatalogVersion,
+    markSessionCatalogChanged,
     getSessionSummary(sessionId) {
       const entry = byId.get(sessionId);
       if (!entry) throw new SessionNotFoundError(sessionId);
@@ -12124,7 +12805,7 @@ function createAcpSessionBridge(opts) {
       const info = channelInfoForEntry(entry);
       if (!info || info.isDying) throw new SessionNotFoundError(sessionId);
       resolveTrustedClientId(entry, context?.clientId);
-      const requestId = randomUUID2();
+      const requestId = randomUUID3();
       const queue = new GenerationStreamQueue(
         GENERATION_STREAM_QUEUE_CAPACITY
       );
@@ -12191,14 +12872,110 @@ function createAcpSessionBridge(opts) {
       const entry = byId.get(sessionId);
       if (!entry) throw new SessionNotFoundError(sessionId);
       resolveTrustedClientId(entry, context?.clientId);
-      return entry.pendingPromptList.filter((p) => !p.removed).map((p) => ({
+      return entry.pendingPromptList.filter((p) => !p.removed && !p.terminalPublished).map((p) => ({
         promptId: p.promptId,
         text: p.text,
+        ...p.content ? { content: p.content } : {},
         queuedAt: p.queuedAt,
         state: p.state,
         ...p.originatorClientId !== void 0 ? { originatorClientId: p.originatorClientId } : {}
       }));
     },
+    async getSessionTurnStatus(sessionId, context, promptId) {
+      const entry = byId.get(sessionId);
+      if (!entry) throw new SessionNotFoundError(sessionId);
+      resolveTrustedClientId(entry, context?.clientId);
+      const liveBeforeRead = findLiveTurnStatus(entry, promptId);
+      if (liveBeforeRead) return liveBeforeRead;
+      if (promptId !== void 0 && entry.enrichedTerminalPromptIds.has(promptId)) {
+        const enrichedTerminal = entry.terminalTurnStatuses.get(promptId);
+        if (enrichedTerminal) return enrichedTerminal;
+      }
+      const rewindGenerationBeforeRead = entry.rewindGeneration;
+      let result;
+      try {
+        result = await requestSessionStatus(
+          sessionId,
+          SERVE_CONTROL_EXT_METHODS.sessionTurnStatus,
+          { ...promptId !== void 0 ? { promptId } : {} },
+          // Transcript scans of large histories exceed the 10s init default;
+          // give the read the same budget as other transcript reads.
+          SESSION_TRANSCRIPT_TIMEOUT_MS
+        );
+      } catch (error) {
+        const liveAfterFailure = findLiveTurnStatus(entry, promptId);
+        if (liveAfterFailure) return liveAfterFailure;
+        const terminalAfterFailure = promptId !== void 0 ? entry.terminalTurnStatuses.get(promptId) : latestTerminalTurnStatus(entry);
+        if (terminalAfterFailure) return terminalAfterFailure;
+        throw error;
+      }
+      const liveAfterRead = findLiveTurnStatus(entry, promptId);
+      if (liveAfterRead) return liveAfterRead;
+      const terminal = promptId !== void 0 ? entry.terminalTurnStatuses.get(promptId) : latestTerminalTurnStatus(entry);
+      const persisted = result.turnResult && entry.rewindGeneration === rewindGenerationBeforeRead ? settledTurnStatus(sessionId, result.turnResult) : void 0;
+      if (promptId !== void 0) {
+        if (terminal && persisted) {
+          const merged = mergeTerminalWithPersisted(terminal, persisted);
+          rememberEnrichedTerminalTurnStatus(entry, promptId, merged);
+          return merged;
+        }
+        if (terminal) return terminal;
+        if (persisted) {
+          rememberEnrichedTerminalTurnStatus(entry, promptId, persisted);
+          return persisted;
+        }
+      } else {
+        if (terminal && persisted && terminal.promptId === persisted.promptId) {
+          return mergeTerminalWithPersisted(terminal, persisted);
+        }
+        if (terminal && persisted) {
+          return (terminal.endedAt ?? 0) >= (persisted.endedAt ?? 0) ? terminal : persisted;
+        }
+        if (terminal) return terminal;
+        if (persisted) return persisted;
+      }
+      if (promptId !== void 0) {
+        return void 0;
+      }
+      return { sessionId, state: "idle" };
+    },
+    async storeSessionMedia(sessionId, data, mimeType, context) {
+      const entry = byId.get(sessionId);
+      if (!entry) throw new SessionNotFoundError(sessionId);
+      resolveTrustedClientId(entry, context?.clientId);
+      const operation = mediaPutQueue.then(async () => {
+        if (byId.get(sessionId) !== entry) {
+          throw new SessionNotFoundError(sessionId);
+        }
+        const retainedBytes = [...new Set(retainedMedia.values())].reduce(
+          (total, store) => total + store.sizeBytes,
+          0
+        );
+        if (retainedBytes + data.byteLength > MAX_RETAINED_SESSION_MEDIA_BYTES) {
+          throw new RangeError(
+            `Session media exceeds the ${MAX_RETAINED_SESSION_MEDIA_BYTES}-byte daemon limit`
+          );
+        }
+        return await entry.media.put(data, mimeType);
+      });
+      mediaPutQueue = operation.then(
+        () => void 0,
+        () => void 0
+      );
+      return await operation;
+    },
+    async readSessionMedia(sessionId, mediaId, context) {
+      const entry = byId.get(sessionId);
+      if (!entry) throw new SessionNotFoundError(sessionId);
+      resolveTrustedClientId(entry, context?.clientId);
+      return await entry.media.read(mediaId);
+    },
+    async removeSessionMedia(sessionId, mediaId, context) {
+      const entry = byId.get(sessionId);
+      if (!entry) throw new SessionNotFoundError(sessionId);
+      resolveTrustedClientId(entry, context?.clientId);
+      return await entry.media.remove(mediaId);
+    },
     removePendingPrompt(sessionId, promptId, context) {
       const entry = byId.get(sessionId);
       if (!entry) throw new SessionNotFoundError(sessionId);
@@ -12217,6 +12994,7 @@ function createAcpSessionBridge(opts) {
       );
       if (target.state === "queued") {
         entry.pendingPromptList.splice(idx, 1);
+        removeQueuedMedia(entry, target.content);
       } else {
         target.removed = true;
       }
@@ -12242,7 +13020,10 @@ function createAcpSessionBridge(opts) {
         context?.clientId
       );
       const trimmed = message.trim();
-      if (trimmed.length === 0) {
+      const mediaBlocks = (options?.content ?? []).filter(
+        (block) => block.type === "image"
+      );
+      if (trimmed.length === 0 && mediaBlocks.length === 0) {
         writeStderrLine(
           `[mid-turn] session=${entry.sessionId} rejected: empty`
         );
@@ -12253,11 +13034,12 @@ function createAcpSessionBridge(opts) {
           (queued) => queued.messageId === requestedMessageId
         );
         if (existing) {
-          if (existing.text === trimmed) {
+          const sameMedia = JSON.stringify(existing.content ?? []) === JSON.stringify(mediaBlocks);
+          if (existing.text === trimmed && sameMedia) {
             return { accepted: true, messageId: requestedMessageId };
           }
           writeStderrLine(
-            `[mid-turn] session=${JSON.stringify(entry.sessionId)} rejected id ${JSON.stringify(requestedMessageId)}: text mismatch`
+            `[mid-turn] session=${JSON.stringify(entry.sessionId)} rejected id ${JSON.stringify(requestedMessageId)}: text or content mismatch`
           );
           return { accepted: false };
         }
@@ -12265,11 +13047,16 @@ function createAcpSessionBridge(opts) {
           (pending) => pending.promptId === requestedMessageId
         );
         if (promoted) {
-          if (promoted.text === trimmed) {
+          const promotedImages = (promoted.content ?? []).filter(
+            (block) => block.type === "image"
+          );
+          const sameMedia = JSON.stringify(promotedImages) === JSON.stringify(mediaBlocks);
+          const promotedText = promoted.text === "[image]" && trimmed.length === 0 ? "" : promoted.text;
+          if (promotedText === trimmed && sameMedia) {
             return { accepted: true, messageId: requestedMessageId };
           }
           writeStderrLine(
-            `[mid-turn] session=${JSON.stringify(entry.sessionId)} rejected promoted id ${JSON.stringify(requestedMessageId)}: text mismatch`
+            `[mid-turn] session=${JSON.stringify(entry.sessionId)} rejected promoted id ${JSON.stringify(requestedMessageId)}: text or content mismatch`
           );
           return { accepted: false };
         }
@@ -12286,7 +13073,21 @@ function createAcpSessionBridge(opts) {
         );
         return { accepted: false };
       }
-      const messageId = requestedMessageId ?? randomUUID2();
+      entry.media.assertReferences(mediaBlocks);
+      const inlineBytes = inlineMediaBlockBytes(mediaBlocks);
+      if (inlineBytes > 0) {
+        const queuedInlineBytes = entry.midTurnMessageQueue.reduce(
+          (total, queued) => total + inlineMediaBlockBytes(queued.content ?? []),
+          0
+        );
+        if (queuedInlineBytes + inlineBytes > SESSION_MEDIA_MAX_TOTAL_BYTES) {
+          writeStderrLine(
+            `[mid-turn] session=${entry.sessionId} rejected: queued inline media exceeds the ${SESSION_MEDIA_MAX_TOTAL_BYTES}-byte session budget`
+          );
+          return { accepted: false };
+        }
+      }
+      const messageId = requestedMessageId ?? randomUUID3();
       if (entry.pendingPromptCount === 0) {
         if (options?.queueOnly) {
           writeStderrLine(
@@ -12294,7 +13095,13 @@ function createAcpSessionBridge(opts) {
           );
           return { accepted: false };
         }
-        promoteMidTurnMessage(entry, messageId, trimmed, originatorClientId);
+        promoteMidTurnMessage(
+          entry,
+          messageId,
+          trimmed,
+          originatorClientId,
+          mediaBlocks.length > 0 ? mediaBlocks : void 0
+        );
         return { accepted: true, messageId };
       }
       if (entry.midTurnMessageQueue.length >= MAX_MID_TURN_QUEUE_DEPTH) {
@@ -12306,6 +13113,7 @@ function createAcpSessionBridge(opts) {
       const queuedMessage = {
         messageId,
         text: trimmed,
+        ...mediaBlocks.length > 0 ? { content: mediaBlocks } : {},
         originatorClientId,
         ...options?.queueOnly ? {
           queueOnly: true,
@@ -12365,6 +13173,7 @@ function createAcpSessionBridge(opts) {
       const [removed] = entry.midTurnMessageQueue.splice(index, 1);
       rememberMidTurnId(entry.settledMidTurnMessageIds, messageId);
       if (removed) {
+        removeQueuedMedia(entry, removed.content);
         try {
           entry.events.publish({
             type: "pending_prompt_completed",
@@ -12414,7 +13223,11 @@ function createAcpSessionBridge(opts) {
         // should restore into their queue views.
         messages: entry.midTurnMessageQueue.filter((message) => message.originatorClientId !== void 0).map((message) => ({
           messageId: message.messageId,
-          text: message.text
+          text: message.text,
+          // Carry the media blocks so a refreshed client can rebuild the
+          // queued row with its attachments (the snapshot is the only
+          // recovery source once the client's in-memory copy is gone).
+          ...message.content ? { content: message.content } : {}
         })),
         settledMessageIds: [...entry.settledMidTurnMessageIds],
         promotedMessageIds: [...entry.promotedMidTurnMessageIds]
@@ -12716,6 +13529,9 @@ function createAcpSessionBridge(opts) {
           }
           throw err;
         }
+        entry.terminalTurnStatuses.clear();
+        entry.enrichedTerminalPromptIds.clear();
+        entry.rewindGeneration += 1;
         const targetTurnIndex = response["targetTurnIndex"] ?? 0;
         const filesChanged = response["filesChanged"] ?? [];
         const filesFailed = response["filesFailed"] ?? [];
@@ -12919,7 +13735,7 @@ function createAcpSessionBridge(opts) {
       ]);
     },
     generateWorkspaceContent(prompt, signal, _originatorClientId) {
-      const requestId = randomUUID2();
+      const requestId = randomUUID3();
       const queue = new GenerationStreamQueue(
         GENERATION_STREAM_QUEUE_CAPACITY
       );
@@ -13098,6 +13914,11 @@ function createAcpSessionBridge(opts) {
           closingChannel,
           `force kill closing session ${JSON.stringify(sessionId)}`
         );
+        await releaseSessionMedia(sessionId).catch((releaseError) => {
+          writeStderrLine(
+            `qwen serve: failed to release media for killed session ${JSON.stringify(sessionId)}: ${releaseError instanceof Error ? releaseError.message : String(releaseError)}`
+          );
+        });
         return true;
       }
       entry.closing = true;
@@ -13125,6 +13946,11 @@ function createAcpSessionBridge(opts) {
             ci,
             `force kill session ${JSON.stringify(sessionId)}`
           );
+          await releaseSessionMedia(sessionId).catch((releaseError) => {
+            writeStderrLine(
+              `qwen serve: failed to release media for killed session ${JSON.stringify(sessionId)}: ${releaseError instanceof Error ? releaseError.message : String(releaseError)}`
+            );
+          });
           return true;
         }
         entry.closing = false;
@@ -13161,6 +13987,11 @@ function createAcpSessionBridge(opts) {
       } catch {
       }
       entry.events.close();
+      await releaseSessionMedia(sessionId).catch((error) => {
+        writeStderrLine(
+          `qwen serve: failed to release media for killed session ${JSON.stringify(sessionId)}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      });
       if (ci && hasNoChannelWork(ci)) {
         await reapPendingEmptyChannel(ci);
         if (!ci.isDying) {
@@ -13265,6 +14096,8 @@ function createAcpSessionBridge(opts) {
         ) : Promise.resolve();
         const teardownResults = await Promise.allSettled([
           ...channels.map((ci) => ci.channel.kill()),
+          ...[...retainedMedia.values()].map((store) => store.close()),
+          mediaPutQueue,
           ...inFlightSessionAwaits,
           ...inFlightRestoreAwaits,
           inFlightChannelAwait