@qwen-code/qwen-code 0.21.12 → 0.21.14-preview.0

package/chunks/{chunk-6P5EXEBL.js → chunk-VGAAAMRD.js}

@@ -19,7 +19,7 @@ import {
 } from "./chunk-OCPBI7J5.js";
 import {
   defaultSpawnChannelFactory
-} from "./chunk-DAV4QFD5.js";
+} from "./chunk-BQWNIPTE.js";
 import {
   BridgeChannelClosedError,
   BridgeTimeoutError,
@@ -29,7 +29,7 @@ import {
   SessionRestoreTimeoutError,
   createIdleWorkspaceExtensionsStatus,
   createIdleWorkspaceHooksStatus
-} from "./chunk-HTYND72J.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,
@@ -62,8 +63,9 @@ import {
   TODO_STOP_GUARD_QUEUE_RELEASE_METHOD,
   WORKTREE_MCP_DEFER_META_KEY,
   clampActiveWorkIntervalMs,
-  isValidTrustedModelPrompt
-} from "./chunk-FQDCO3CJ.js";
+  isValidTrustedModelPrompt,
+  sessionCloseDrainBudgetMs
+} from "./chunk-WP4WIUOJ.js";
 import {
   BranchWhilePromptActiveError,
   BridgeChannelQuarantinedError,
@@ -112,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,
@@ -119,17 +123,18 @@ import {
   isReservedWorkspaceMetadataKey,
   metadataBudgetBytes,
   normalizeSnapshotPayload,
+  normalizeTurnResultError,
   stableSessionArtifactId
-} from "./chunk-EBPLKY6U.js";
+} from "./chunk-XC377TLN.js";
 import {
   DAEMON_TRACEPARENT_META_KEY,
   DAEMON_TRACESTATE_META_KEY
-} from "./chunk-K34GJQOZ.js";
+} from "./chunk-OO4FKHLO.js";
 import {
   INVOCATION_CONTEXT_META_KEY,
   PRIVATE_ACP_CAPABILITY_ENV,
   PRIVATE_PARENT_CAPABILITY_META_KEY
-} from "./chunk-4KM2SYK5.js";
+} from "./chunk-KC4WMLZO.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -139,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
@@ -604,7 +609,7 @@ var TurnBoundaryCompactionEngine = class {
         const slot = this.slots[existingIdx];
         slot.chunks.push(text);
         if (event.id !== void 0) slot.lastEventId = event.id;
-        slot.lastMeta = meta ?? slot.lastMeta;
+        slot.lastMeta = mergeTranscriptUpdateMeta(slot.lastMeta, meta);
         slot.lastEnvelopeMeta = event._meta ?? slot.lastEnvelopeMeta;
         slot.lastTurn = captureTurnFields(event, slot.lastTurn);
         slot.lastSessionId = captureSessionId(event) ?? slot.lastSessionId;
@@ -628,7 +633,7 @@ var TurnBoundaryCompactionEngine = class {
       if (lastSlot && lastSlot.kind === kind && lastSlot.parentToolCallId == null && stringArraysEqual(lastSlot.sourceRecordIds, sourceRecordIds)) {
         lastSlot.chunks.push(text);
         if (event.id !== void 0) lastSlot.lastEventId = event.id;
-        lastSlot.lastMeta = meta ?? lastSlot.lastMeta;
+        lastSlot.lastMeta = mergeTranscriptUpdateMeta(lastSlot.lastMeta, meta);
         lastSlot.lastEnvelopeMeta = event._meta ?? lastSlot.lastEnvelopeMeta;
         lastSlot.lastTurn = captureTurnFields(event, lastSlot.lastTurn);
         lastSlot.lastSessionId = captureSessionId(event) ?? lastSlot.lastSessionId;
@@ -1053,13 +1058,26 @@ function mergeTranscriptUpdateMeta(existing, incoming) {
       ...extractSourceRecordIdsFromMeta(incomingRecord) ?? []
     ])
   ];
+  const existingTranscript = extractTranscriptMeta(existingRecord);
+  const incomingTranscript = extractTranscriptMeta(incomingRecord);
   return {
     ...existingRecord ?? {},
     ...incomingRecord ?? {},
-    ...sourceRecordIds.length > 0 ? { qwenTranscript: { sourceRecordIds } } : {}
+    ...existingTranscript || incomingTranscript || sourceRecordIds.length > 0 ? {
+      qwenTranscript: {
+        ...existingTranscript ?? {},
+        ...incomingTranscript ?? {},
+        ...sourceRecordIds.length > 0 ? { sourceRecordIds } : {}
+      }
+    } : {}
   };
 }
 __name(mergeTranscriptUpdateMeta, "mergeTranscriptUpdateMeta");
+function extractTranscriptMeta(meta) {
+  const transcript = meta?.["qwenTranscript"];
+  return typeof transcript === "object" && transcript !== null ? transcript : void 0;
+}
+__name(extractTranscriptMeta, "extractTranscriptMeta");
 
 // packages/acp-bridge/src/journalGrowthPolicy.ts
 init_esbuild_shims();
@@ -1266,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) {
@@ -1276,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();
@@ -2264,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;
@@ -2286,6 +2565,7 @@ var BridgeClient = class {
     this.getLiveSpeakToUserHandler = getLiveSpeakToUserHandler;
     this.externalToolGuard = externalToolGuard;
     this.onActiveWork = onActiveWork;
+    this.onSessionCatalogChanged = onSessionCatalogChanged;
   }
   static {
     __name(this, "BridgeClient");
@@ -2304,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);
     }
@@ -2550,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.
@@ -2585,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) {
@@ -2600,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(
@@ -2612,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) {
@@ -3146,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",
@@ -3588,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,
@@ -3612,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;
     }
@@ -3655,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.`
@@ -3666,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;
@@ -3868,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,
@@ -4940,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;
         }
@@ -5060,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),
@@ -5108,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),
@@ -5123,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;
 }
@@ -5575,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) {
@@ -5622,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"
@@ -5656,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) {
@@ -5871,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";
@@ -5885,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
     );
@@ -6007,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;
@@ -6045,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");
 
@@ -6678,13 +7051,20 @@ function broadcastPromptCancelledOnce(entry, sessionId, promptId, originatorClie
 __name(broadcastPromptCancelledOnce, "broadcastPromptCancelledOnce");
 function broadcastTurnComplete(entry, sessionId, promptResult, promptId, originatorClientId, mutateTurnState) {
   try {
+    const meta = promptResult["_meta"] && typeof promptResult["_meta"] === "object" ? promptResult["_meta"] : void 0;
+    const rawBranchPoint = meta?.["qwen.branchPoint"] && typeof meta["qwen.branchPoint"] === "object" ? meta["qwen.branchPoint"] : void 0;
+    const branchPoint = promptResult.stopReason === "end_turn" && typeof rawBranchPoint?.["assistantRecordUuid"] === "string" && CHAT_RECORD_UUID_RE.test(rawBranchPoint["assistantRecordUuid"]) && typeof rawBranchPoint["checkpointUuid"] === "string" && CHAT_RECORD_UUID_RE.test(rawBranchPoint["checkpointUuid"]) ? {
+      assistantRecordUuid: rawBranchPoint["assistantRecordUuid"],
+      checkpointUuid: rawBranchPoint["checkpointUuid"]
+    } : void 0;
     const published = entry.events.publish({
       type: "turn_complete",
       ...promptId ? { promptId } : {},
       data: {
         sessionId,
         stopReason: promptResult.stopReason ?? "end_turn",
-        ...promptId ? { promptId } : {}
+        ...promptId ? { promptId } : {},
+        ...branchPoint ? { branchPoint } : {}
       },
       ...originatorClientId ? { originatorClientId } : {}
     });
@@ -6845,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(
@@ -6853,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) {
@@ -6920,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;
@@ -6947,13 +7472,25 @@ 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;
 var MAX_EVENT_RING_SIZE = 1e6;
 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;
@@ -7012,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) {
@@ -7082,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.`
     );
@@ -7105,6 +7652,7 @@ function createAcpSessionBridge(opts) {
     DEFAULT_SESSION_IDLE_TIMEOUT_MS
   );
   let sessionReaper;
+  let mediaSweeper;
   let lastActivityTimestamp = null;
   let activePromptCounter = 0;
   function touchActivity() {
@@ -7158,12 +7706,15 @@ function createAcpSessionBridge(opts) {
   }
   __name(isClosingOrAuthorizingClose, "isClosingOrAuthorizingClose");
   async function maybeCloseIdleSession(entry, reason) {
-    if (!entryIsAutoCloseCandidate(entry)) return;
-    if (entry.spawnOwnerWantedKill && entry.attachCount === 0) {
+    if (byId.get(entry.sessionId) === entry && !isClosingOrAuthorizingClose(entry) && entry.spawnOwnerWantedKill && entry.attachCount === 0) {
+      writeStderrLine(
+        `qwen serve: completing deferred kill of session ${JSON.stringify(entry.sessionId)} (${reason})`
+      );
       await bridgeApi.killSession(entry.sessionId).catch(() => {
       });
       return;
     }
+    if (!entryIsAutoCloseCandidate(entry)) return;
     if (entry.clientIds.size > 0) return;
     await closeIfChildUnheld(entry, {
       trigger: reason,
@@ -7200,7 +7751,10 @@ function createAcpSessionBridge(opts) {
       const response = await withTimeout(
         entry.connection.extMethod(SERVE_CONTROL_EXT_METHODS.sessionClose, {
           sessionId: entry.sessionId,
-          [ACTIVE_WORK_CLOSE_IF_UNHELD_PARAM]: true
+          [ACTIVE_WORK_CLOSE_IF_UNHELD_PARAM]: true,
+          drainTimeoutMs: sessionCloseDrainBudgetMs(
+            ACTIVE_WORK_CLOSE_TIMEOUT_MS
+          )
         }),
         ACTIVE_WORK_CLOSE_TIMEOUT_MS,
         SERVE_CONTROL_EXT_METHODS.sessionClose
@@ -7415,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(
@@ -7427,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;
@@ -7439,6 +8017,7 @@ function createAcpSessionBridge(opts) {
           closeReason: "idle_timeout"
         });
       }
+      sweepRetainedMedia();
     }, sessionReapIntervalMs);
     sessionReaper.unref();
   }
@@ -7448,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;
@@ -7592,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(
@@ -7651,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",
         {
@@ -7772,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,
@@ -7910,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",
@@ -8730,7 +9333,9 @@ function createAcpSessionBridge(opts) {
         SERVE_CONTROL_EXT_METHODS.sessionClose,
         {
           sessionId: entry.sessionId,
-          drainTimeoutMs: Math.max(1, Math.floor(initTimeoutMs * 0.8)),
+          drainTimeoutMs: sessionCloseDrainBudgetMs(
+            opts2?.timeoutMs ?? initTimeoutMs
+          ),
           ...opts2?.requireFlush === true ? { requireFlush: true } : {}
         }
       );
@@ -8945,6 +9550,7 @@ function createAcpSessionBridge(opts) {
         workspaceCwd,
         persistence: createSessionArtifactPersistence(ci.connection, sessionId)
       }),
+      media: retainSessionMedia(sessionId),
       recordingDegraded: false,
       closing: false,
       cwdChangeQueue: Promise.resolve(),
@@ -8952,6 +9558,9 @@ function createAcpSessionBridge(opts) {
       pendingPromptCount: 0,
       pendingAgentNotificationCount: 0,
       pendingPromptList: [],
+      terminalTurnStatuses: /* @__PURE__ */ new Map(),
+      enrichedTerminalPromptIds: /* @__PURE__ */ new Set(),
+      rewindGeneration: 0,
       midTurnMessageQueue: [],
       settledMidTurnMessageIds: [],
       promotedMidTurnMessageIds: [],
@@ -9531,7 +10140,7 @@ function createAcpSessionBridge(opts) {
                 SERVE_CONTROL_EXT_METHODS.sessionClose,
                 {
                   sessionId: req.sessionId,
-                  drainTimeoutMs: Math.max(1, Math.floor(initTimeoutMs * 0.8))
+                  drainTimeoutMs: sessionCloseDrainBudgetMs(initTimeoutMs)
                 }
               ),
               initTimeoutMs,
@@ -9901,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",
@@ -10064,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(
@@ -10092,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))}`
       );
@@ -10430,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;
@@ -10460,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(
@@ -10486,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,
@@ -10519,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"
       };
@@ -10611,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;
@@ -10638,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);
@@ -10664,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;
@@ -10680,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;
                   }
@@ -10708,7 +11410,10 @@ function createAcpSessionBridge(opts) {
                   if (!isRetry && !isContinue) {
                     echoPromptToSessionBus(
                       entry,
-                      promptRequest,
+                      {
+                        ...promptRequest,
+                        prompt: dispatchBlocks
+                      },
                       pendingEntry.promptId,
                       originatorClientId,
                       channelDisplayText
@@ -10864,7 +11569,8 @@ function createAcpSessionBridge(opts) {
             entry,
             message.messageId,
             message.text,
-            message.originatorClientId
+            message.originatorClientId,
+            message.content
           );
         }
         void maybeCloseIdleSession(entry, "prompt_settled");
@@ -11044,60 +11750,87 @@ function createAcpSessionBridge(opts) {
       if (shuttingDown) throw new Error("AcpSessionBridge is shutting down");
       const entry = byId.get(sessionId);
       if (!entry) throw new SessionNotFoundError(sessionId);
+      if (isClosingOrAuthorizingClose(entry)) {
+        throw new SessionNotFoundError(sessionId, "The session is closing");
+      }
       const source = parseSessionSource(req.sourceType, req.sourceId);
       if ("error" in source) {
         throw new InvalidSessionMetadataError("sourceType", source.error);
       }
       const isSideTask = source.sourceType === "side_task";
-      let originatorClientId;
+      const restoreBranch = isSideTask || req.atRecordId === void 0;
       if (context?.clientId !== void 0) {
-        originatorClientId = resolveTrustedClientId(entry, context.clientId);
+        resolveTrustedClientId(entry, context.clientId);
       }
       const concurrentSideTask = isSideTask && entry.promptActive;
+      if (!isSideTask && (entry.pendingPromptCount > 0 || entry.promptActive)) {
+        throw new BranchWhilePromptActiveError(sessionId);
+      }
       const branchResult = (concurrentSideTask ? Promise.resolve() : entry.promptQueue).then(async () => {
-        if (entry.promptActive && !isSideTask) {
-          throw new BranchWhilePromptActiveError(sessionId);
+        if (isClosingOrAuthorizingClose(entry) || byId.get(sessionId) !== entry) {
+          throw new SessionNotFoundError(sessionId, "The session is closing");
         }
         assertFreshSessionsAvailable();
-        if (byId.size + inFlightSpawns.size + inFlightRestores.size >= maxSessions) {
-          throw new SessionLimitExceededError(maxSessions);
+        let admission;
+        if (restoreBranch) {
+          if (byId.size + inFlightSpawns.size + inFlightRestores.size >= maxSessions) {
+            throw new SessionLimitExceededError(maxSessions);
+          }
+          admission = reserveFreshSession({
+            operation: "branch",
+            workspaceCwd: boundWorkspace,
+            sourceSessionId: sessionId
+          });
         }
-        const admission = reserveFreshSession({
-          operation: "branch",
-          workspaceCwd: boundWorkspace,
-          sourceSessionId: sessionId
-        });
         let admissionReleased = false;
         const releaseAdmissionOnce = /* @__PURE__ */ __name(() => {
-          if (admissionReleased) return;
+          if (admissionReleased || !admission) return;
           admissionReleased = true;
           releaseFreshSessionReservation(admission);
         }, "releaseAdmissionOnce");
         try {
-          assertLivePromptEntry(sessionId, entry);
-          const ci = channelInfoForEntry(entry);
-          const result = await withTimeout(
-            Promise.race([
-              ci.connection.extMethod(
-                isSideTask ? SERVE_CONTROL_EXT_METHODS.sessionSideTask : SERVE_CONTROL_EXT_METHODS.sessionBranch,
-                {
-                  sessionId,
-                  cwd: boundWorkspace,
-                  name: req.name
-                }
-              ),
-              getTransportClosedReject(entry)
-            ]),
-            initTimeoutMs,
-            isSideTask ? "createSideTaskSession" : "branchSession"
+          const mutation = entry.connection.extMethod(
+            isSideTask ? SERVE_CONTROL_EXT_METHODS.sessionSideTask : SERVE_CONTROL_EXT_METHODS.sessionBranch,
+            {
+              sessionId,
+              cwd: boundWorkspace,
+              name: req.name,
+              ...req.atRecordId !== void 0 ? { atRecordId: req.atRecordId } : {}
+            }
           );
+          let result;
+          try {
+            result = await Promise.race([
+              mutation,
+              getTransportClosedReject(entry)
+            ]);
+          } catch (err) {
+            const data = err?.data;
+            if (!isSideTask && data && typeof data === "object" && data.errorKind === "session_busy") {
+              const msg = err?.message ?? "Branch failed";
+              throw new SessionBusyError(sessionId, msg);
+            }
+            throw err;
+          }
           if (!result || typeof result.newSessionId !== "string") {
             throw new Error(
               `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) {
+            return {
+              sessionId: result.newSessionId,
+              displayName: branchDisplayName,
+              forkedFrom: {
+                sessionId,
+                displayName: entry.displayName ?? sessionId.slice(0, 8)
+              }
+            };
+          }
+          const ci = await ensureChannel();
           let restored;
           try {
             const hideInheritedHistory = req.replayInheritedHistory === false;
@@ -11120,7 +11853,7 @@ function createAcpSessionBridge(opts) {
             releaseAdmissionOnce();
           } catch (restoreErr) {
             writeStderrLine(
-              `qwen serve: branchSession load failed for ${result.newSessionId}, attempting cleanup...`
+              `qwen serve: branchSession load failed for ${result.newSessionId}; closing partial live state while preserving the committed session...`
             );
             try {
               if (!ci.isDying) {
@@ -11130,7 +11863,8 @@ function createAcpSessionBridge(opts) {
                       SERVE_CONTROL_EXT_METHODS.sessionClose,
                       {
                         sessionId: result.newSessionId,
-                        cwd: boundWorkspace
+                        cwd: boundWorkspace,
+                        drainTimeoutMs: sessionCloseDrainBudgetMs(initTimeoutMs)
                       }
                     ),
                     channelUnavailableReject(
@@ -11144,7 +11878,7 @@ function createAcpSessionBridge(opts) {
               }
             } catch (cleanupErr) {
               writeStderrLine(
-                `qwen serve: branchSession cleanup of ${result.newSessionId} failed: ${cleanupErr instanceof Error ? cleanupErr.message : cleanupErr}`
+                `qwen serve: branchSession live-state close for ${result.newSessionId} failed: ${cleanupErr instanceof Error ? cleanupErr.message : cleanupErr}`
               );
             }
             throw restoreErr;
@@ -11174,19 +11908,6 @@ function createAcpSessionBridge(opts) {
               );
             }
           }
-          if (!isSideTask) {
-            const eventData = {
-              sourceSessionId: sessionId,
-              newSessionId: result.newSessionId,
-              displayName: branchDisplayName
-            };
-            const branchEnvelope = {
-              type: "session_branched",
-              data: eventData,
-              ...originatorClientId ? { originatorClientId } : {}
-            };
-            newEntry?.events.publish(branchEnvelope);
-          }
           return {
             ...restored,
             displayName: branchDisplayName,
@@ -11219,7 +11940,8 @@ function createAcpSessionBridge(opts) {
         },
         context
       );
-      const { forkedFrom: _forkedFrom, ...sideTask } = result;
+      const restoredResult = result;
+      const { forkedFrom: _forkedFrom, ...sideTask } = restoredResult;
       return {
         ...sideTask,
         parentSessionId: sessionId
@@ -11289,6 +12011,7 @@ function createAcpSessionBridge(opts) {
       const entry = byId.get(sessionId);
       if (entry) {
         entry.worktree = worktree;
+        markSessionCatalogChanged();
       }
     },
     async closeSession(sessionId, context, closeOpts) {
@@ -11314,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)}` : "")
           );
@@ -11376,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 = [];
@@ -11387,6 +12111,8 @@ function createAcpSessionBridge(opts) {
       }
       return out;
     },
+    getSessionCatalogVersion,
+    markSessionCatalogChanged,
     getSessionSummary(sessionId) {
       const entry = byId.get(sessionId);
       if (!entry) throw new SessionNotFoundError(sessionId);
@@ -12079,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
       );
@@ -12146,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);
@@ -12172,6 +12994,7 @@ function createAcpSessionBridge(opts) {
       );
       if (target.state === "queued") {
         entry.pendingPromptList.splice(idx, 1);
+        removeQueuedMedia(entry, target.content);
       } else {
         target.removed = true;
       }
@@ -12197,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`
         );
@@ -12208,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 };
         }
@@ -12220,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 };
         }
@@ -12241,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(
@@ -12249,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) {
@@ -12261,6 +13113,7 @@ function createAcpSessionBridge(opts) {
       const queuedMessage = {
         messageId,
         text: trimmed,
+        ...mediaBlocks.length > 0 ? { content: mediaBlocks } : {},
         originatorClientId,
         ...options?.queueOnly ? {
           queueOnly: true,
@@ -12320,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",
@@ -12369,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]
@@ -12634,10 +13492,19 @@ function createAcpSessionBridge(opts) {
         entry,
         context?.clientId
       );
-      let response;
-      try {
-        response = await Promise.race([
-          withTimeout(
+      if (entry.pendingPromptCount > 0 || entry.promptActive) {
+        throw new SessionBusyError(
+          sessionId,
+          "Cannot rewind while a prompt is running"
+        );
+      }
+      const rewindResult = entry.promptQueue.then(async () => {
+        if (entry.closing) {
+          throw new SessionNotFoundError(sessionId, "The session is closing");
+        }
+        let response;
+        try {
+          response = await Promise.race([
             entry.connection.extMethod(
               SERVE_CONTROL_EXT_METHODS.sessionRewind,
               {
@@ -12646,92 +13513,98 @@ function createAcpSessionBridge(opts) {
                 rewindFiles: req.rewindFiles !== false
               }
             ),
-            initTimeoutMs,
-            SERVE_CONTROL_EXT_METHODS.sessionRewind
-          ),
-          getTransportClosedReject(entry)
-        ]);
-      } catch (err) {
-        const data = err?.data;
-        if (data && typeof data === "object" && "errorKind" in data) {
-          const kind = data.errorKind;
-          const msg = err?.message ?? "Rewind failed";
-          if (kind === "session_busy") {
-            throw new SessionBusyError(sessionId, msg);
-          }
-          if (kind === "invalid_rewind_target") {
-            throw new InvalidRewindTargetError(sessionId, msg);
+            getTransportClosedReject(entry)
+          ]);
+        } catch (err) {
+          const data = err?.data;
+          if (data && typeof data === "object" && "errorKind" in data) {
+            const kind = data.errorKind;
+            const msg = err?.message ?? "Rewind failed";
+            if (kind === "session_busy") {
+              throw new SessionBusyError(sessionId, msg);
+            }
+            if (kind === "invalid_rewind_target") {
+              throw new InvalidRewindTargetError(sessionId, msg);
+            }
           }
+          throw err;
         }
-        throw err;
-      }
-      const targetTurnIndex = response["targetTurnIndex"] ?? 0;
-      const filesChanged = response["filesChanged"] ?? [];
-      const filesFailed = response["filesFailed"] ?? [];
-      const artifactSnapshot = restoredArtifactSnapshotFromState(
-        response
-      );
-      const artifactSnapshotUnavailable = artifactSnapshotUnavailableReason(
-        response
-      );
-      const beforeArtifacts = (await entry.artifacts.list()).artifacts;
-      const shouldRestoreArtifactSnapshot = artifactSnapshot !== void 0 && artifactSnapshotUnavailable === void 0;
-      const artifactRestoreWarnings = artifactSnapshotUnavailable !== void 0 ? [
-        `artifact snapshot rebuild unavailable during rewind: ${artifactSnapshotUnavailable}`
-      ] : shouldRestoreArtifactSnapshot ? await entry.artifacts.restore(artifactSnapshot, {
-        preserveLiveEphemeral: true
-      }) : [];
-      const artifactRestoreFailed = artifactRestoreWarnings.some(
-        isArtifactRestoreFailureWarning
-      );
-      const shouldRecordArtifactSnapshot = shouldRestoreArtifactSnapshot && !artifactRestoreFailed;
-      const artifactSnapshotWarnings = shouldRecordArtifactSnapshot ? await entry.artifacts.recordSnapshot() : [];
-      const artifactWarnings = [
-        ...artifactRestoreWarnings,
-        ...artifactSnapshotWarnings
-      ];
-      for (const warning of artifactRestoreWarnings) {
-        writeStderrLine(
-          `[artifacts] session=${entry.sessionId} action=rewind_restore_warning warning=${JSON.stringify(
-            warning
-          )}`
+        entry.terminalTurnStatuses.clear();
+        entry.enrichedTerminalPromptIds.clear();
+        entry.rewindGeneration += 1;
+        const targetTurnIndex = response["targetTurnIndex"] ?? 0;
+        const filesChanged = response["filesChanged"] ?? [];
+        const filesFailed = response["filesFailed"] ?? [];
+        const artifactSnapshot = restoredArtifactSnapshotFromState(
+          response
         );
-      }
-      for (const warning of artifactSnapshotWarnings) {
-        writeStderrLine(
-          `[artifacts] session=${entry.sessionId} action=rewind_snapshot_warning warning=${JSON.stringify(
-            warning
-          )}`
+        const artifactSnapshotUnavailable = artifactSnapshotUnavailableReason(
+          response
         );
-      }
-      const afterArtifacts = (await entry.artifacts.list()).artifacts;
-      publishArtifactChanges(
-        entry,
-        artifactReseedChanges(beforeArtifacts, afterArtifacts),
-        originatorClientId
+        const beforeArtifacts = (await entry.artifacts.list()).artifacts;
+        const shouldRestoreArtifactSnapshot = artifactSnapshot !== void 0 && artifactSnapshotUnavailable === void 0;
+        const artifactRestoreWarnings = artifactSnapshotUnavailable !== void 0 ? [
+          `artifact snapshot rebuild unavailable during rewind: ${artifactSnapshotUnavailable}`
+        ] : shouldRestoreArtifactSnapshot ? await entry.artifacts.restore(artifactSnapshot, {
+          preserveLiveEphemeral: true
+        }) : [];
+        const artifactRestoreFailed = artifactRestoreWarnings.some(
+          isArtifactRestoreFailureWarning
+        );
+        const shouldRecordArtifactSnapshot = shouldRestoreArtifactSnapshot && !artifactRestoreFailed;
+        const artifactSnapshotWarnings = shouldRecordArtifactSnapshot ? await entry.artifacts.recordSnapshot() : [];
+        const artifactWarnings = [
+          ...artifactRestoreWarnings,
+          ...artifactSnapshotWarnings
+        ];
+        for (const warning of artifactRestoreWarnings) {
+          writeStderrLine(
+            `[artifacts] session=${entry.sessionId} action=rewind_restore_warning warning=${JSON.stringify(
+              warning
+            )}`
+          );
+        }
+        for (const warning of artifactSnapshotWarnings) {
+          writeStderrLine(
+            `[artifacts] session=${entry.sessionId} action=rewind_snapshot_warning warning=${JSON.stringify(
+              warning
+            )}`
+          );
+        }
+        const afterArtifacts = (await entry.artifacts.list()).artifacts;
+        publishArtifactChanges(
+          entry,
+          artifactReseedChanges(beforeArtifacts, afterArtifacts),
+          originatorClientId
+        );
+        try {
+          entry.events.publish({
+            type: "session_rewound",
+            data: {
+              sessionId,
+              promptId: req.promptId,
+              targetTurnIndex,
+              filesChanged,
+              filesFailed,
+              ...artifactWarnings.length > 0 ? { warnings: artifactWarnings } : {}
+            },
+            ...originatorClientId ? { originatorClientId } : {}
+          });
+        } catch {
+        }
+        return {
+          rewound: filesFailed.length === 0,
+          targetTurnIndex,
+          filesChanged,
+          filesFailed,
+          ...artifactWarnings.length > 0 ? { warnings: artifactWarnings } : {}
+        };
+      });
+      entry.promptQueue = rewindResult.then(
+        () => void 0,
+        () => void 0
       );
-      try {
-        entry.events.publish({
-          type: "session_rewound",
-          data: {
-            sessionId,
-            promptId: req.promptId,
-            targetTurnIndex,
-            filesChanged,
-            filesFailed,
-            ...artifactWarnings.length > 0 ? { warnings: artifactWarnings } : {}
-          },
-          ...originatorClientId ? { originatorClientId } : {}
-        });
-      } catch {
-      }
-      return {
-        rewound: filesFailed.length === 0,
-        targetTurnIndex,
-        filesChanged,
-        filesFailed,
-        ...artifactWarnings.length > 0 ? { warnings: artifactWarnings } : {}
-      };
+      return rewindResult;
     },
     async manageMcpServer(serverName, action, originatorClientId) {
       const info = await ensureChannel();
@@ -12862,7 +13735,7 @@ function createAcpSessionBridge(opts) {
       ]);
     },
     generateWorkspaceContent(prompt, signal, _originatorClientId) {
-      const requestId = randomUUID2();
+      const requestId = randomUUID3();
       const queue = new GenerationStreamQueue(
         GENERATION_STREAM_QUEUE_CAPACITY
       );
@@ -13041,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;
@@ -13059,11 +13937,20 @@ function createAcpSessionBridge(opts) {
           timeoutMs: initTimeoutMs
         });
       } catch (error) {
+        if (isDefinitiveAcpRequestError(error)) {
+          entry.closing = false;
+          return false;
+        }
         if (ci) {
           await killChannelWithLog(
             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;
@@ -13100,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) {
@@ -13204,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