@qwen-code/qwen-code 0.21.14 → 0.21.15

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

@@ -19,7 +19,7 @@ import {
 } from "./chunk-OCPBI7J5.js";
 import {
   defaultSpawnChannelFactory
-} from "./chunk-BQWNIPTE.js";
+} from "./chunk-V4UBYT3Y.js";
 import {
   BridgeChannelClosedError,
   BridgeTimeoutError,
@@ -29,7 +29,7 @@ import {
   SessionRestoreTimeoutError,
   createIdleWorkspaceExtensionsStatus,
   createIdleWorkspaceHooksStatus
-} from "./chunk-UC67T4SF.js";
+} from "./chunk-AQFWV4YF.js";
 import {
   ACTIVE_WORK_CLOSE_IF_UNHELD_PARAM,
   ACTIVE_WORK_CLOSE_TIMEOUT_MS,
@@ -44,8 +44,8 @@ import {
   CHANNEL_PROMPT_META_KEY,
   CHANNEL_STARTUP_PROFILE_META_KEY,
   CHANNEL_STARTUP_PROFILE_VERSION,
+  DAEMON_ATTACHMENT_REFERENCES_META_KEY,
   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,
@@ -65,7 +65,7 @@ import {
   clampActiveWorkIntervalMs,
   isValidTrustedModelPrompt,
   sessionCloseDrainBudgetMs
-} from "./chunk-WP4WIUOJ.js";
+} from "./chunk-QQUVPMMZ.js";
 import {
   BranchWhilePromptActiveError,
   BridgeChannelQuarantinedError,
@@ -97,9 +97,8 @@ import {
   LIVE_TASK_TOOL_NAMES,
   MAX_LIVE_SCREEN_CONTEXT_TEXT_CHARS,
   MAX_LIVE_SPEAK_TO_USER_MESSAGE_CHARS,
-  MAX_SUB_SESSION_NAME_CHARS,
-  MAX_SUB_SESSION_PROMPT_CHARS
-} from "./chunk-HIBNSEJE.js";
+  MAX_SUB_SESSION_NAME_CHARS
+} from "./chunk-UDG5EZJI.js";
 import {
   EXTERNAL_TOOL_GUARD_READY_META_KEY,
   EXTERNAL_TOOL_GUARD_REQUIRED_VALUE,
@@ -110,6 +109,9 @@ import {
   PROTOCOL_VERSION,
   RequestError
 } from "./chunk-IW6RQPQB.js";
+import {
+  MAX_SUB_SESSION_PROMPT_CHARS
+} from "./chunk-LJZSMWOH.js";
 import {
   SESSION_ARTIFACT_PERSISTENCE_VERSION,
   SESSION_TRANSCRIPT_MAX_LIMIT,
@@ -125,16 +127,19 @@ import {
   normalizeSnapshotPayload,
   normalizeTurnResultError,
   stableSessionArtifactId
-} from "./chunk-OFTPCOGR.js";
+} from "./chunk-L7RG5PVT.js";
 import {
   DAEMON_TRACEPARENT_META_KEY,
   DAEMON_TRACESTATE_META_KEY
-} from "./chunk-OO4FKHLO.js";
+} from "./chunk-7NLDU6J2.js";
 import {
   INVOCATION_CONTEXT_META_KEY,
   PRIVATE_ACP_CAPABILITY_ENV,
   PRIVATE_PARENT_CAPABILITY_META_KEY
-} from "./chunk-KC4WMLZO.js";
+} from "./chunk-EXY6APEA.js";
+import {
+  getSpecificMimeType
+} from "./chunk-MGEWDLRO.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -144,7 +149,7 @@ import {
 
 // packages/acp-bridge/src/bridge.ts
 init_esbuild_shims();
-import { randomBytes, randomUUID as randomUUID3 } from "node:crypto";
+import { randomBytes, randomUUID as randomUUID2 } from "node:crypto";
 import * as path4 from "node:path";
 import { inspect } from "node:util";
 
@@ -1284,161 +1289,276 @@ function getChannelStartupProfileAttributes(response, receivedAtEpochMs, initial
 }
 __name(getChannelStartupProfileAttributes, "getChannelStartupProfileAttributes");
 
-// packages/acp-bridge/src/sessionMedia.ts
+// packages/acp-bridge/src/sessionAttachments.ts
 init_esbuild_shims();
-import { randomUUID } from "node:crypto";
-import { promises as fs } from "node:fs";
+import { promises as fs, statSync } 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 {
+var SESSION_ATTACHMENT_MAX_ITEM_BYTES = 8 * 1024 * 1024;
+var SESSION_ATTACHMENT_MAX_NAME_BYTES = 255;
+var SUPPORTED_IMAGE_MIME_TYPES = /* @__PURE__ */ new Set([
+  "image/bmp",
+  "image/gif",
+  "image/jpeg",
+  "image/png",
+  "image/webp"
+]);
+var SESSION_ATTACHMENT_UNAVAILABLE_TEXT = "[Attachment is no longer available]";
+var SessionAttachmentReferenceError = class extends Error {
   constructor(message, code) {
     super(message);
     this.code = code;
-    this.name = "SessionMediaReferenceError";
+    this.name = "SessionAttachmentReferenceError";
   }
   static {
-    __name(this, "SessionMediaReferenceError");
+    __name(this, "SessionAttachmentReferenceError");
   }
 };
-function isSessionMediaReference(value) {
+function isSessionAttachmentReference(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;
+  return (record["type"] === "image" || record["type"] === "resource") && typeof record["attachmentId"] === "string" && record["attachmentId"].length > 0 && typeof record["mimeType"] === "string" && record["mimeType"].length > 0 && (record["type"] !== "image" || record["mimeType"].startsWith("image/")) && typeof record["size"] === "number" && Number.isSafeInteger(record["size"]) && record["size"] >= 0 && (record["type"] !== "image" || record["size"] > 0);
+}
+__name(isSessionAttachmentReference, "isSessionAttachmentReference");
+function safeAttachmentName(name) {
+  const safeName = path.basename(name.replaceAll("\\", "/")).trim();
+  const isWindowsReserved = /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(safeName);
+  const hasInvalidCharacter = Array.from(safeName).some((character) => {
+    const codePoint = character.codePointAt(0);
+    return codePoint !== void 0 && (codePoint <= 31 || codePoint === 127 || codePoint >= 55296 && codePoint <= 57343);
+  });
+  return !safeName || safeName === "." || safeName === ".." || safeName.endsWith(".") || isWindowsReserved || /[<>:"|?*]/.test(safeName) || hasInvalidCharacter || Buffer.byteLength(safeName) > SESSION_ATTACHMENT_MAX_NAME_BYTES ? void 0 : safeName;
+}
+__name(safeAttachmentName, "safeAttachmentName");
+function truncateUtf8(value, maxBytes) {
+  let bytes = 0;
+  let result = "";
+  for (const character of value) {
+    const characterBytes = Buffer.byteLength(character);
+    if (bytes + characterBytes > maxBytes) break;
+    result += character;
+    bytes += characterBytes;
+  }
+  return result;
+}
+__name(truncateUtf8, "truncateUtf8");
+function deduplicatedName(name, suffix) {
+  if (suffix === 0) return name;
+  const extension = path.extname(name);
+  const suffixText = ` (${suffix})`;
+  const stem = name.slice(0, -extension.length || void 0);
+  const extensionBudget = SESSION_ATTACHMENT_MAX_NAME_BYTES - Buffer.byteLength(suffixText) - 1;
+  const safeExtension = truncateUtf8(extension, extensionBudget).replace(
+    /[. ]+$/u,
+    ""
+  );
+  const stemBudget = SESSION_ATTACHMENT_MAX_NAME_BYTES - Buffer.byteLength(suffixText) - Buffer.byteLength(safeExtension);
+  return `${truncateUtf8(stem, stemBudget)}${suffixText}${safeExtension}`;
+}
+__name(deduplicatedName, "deduplicatedName");
+function imageName(mimeType) {
+  const extension = mimeType.slice("image/".length).split(/[;+]/, 1)[0];
+  return `image.${extension === "jpg" ? "jpeg" : extension || "img"}`;
+}
+__name(imageName, "imageName");
+function mimeTypeForName(name) {
+  if ([".ts", ".mts", ".cts", ".tsx"].includes(path.extname(name).toLowerCase())) {
+    return "text/plain";
+  }
+  return getSpecificMimeType(name) ?? "application/octet-stream";
+}
+__name(mimeTypeForName, "mimeTypeForName");
+function isSupportedImageMimeType(mimeType) {
+  return SUPPORTED_IMAGE_MIME_TYPES.has(mimeType);
 }
-__name(isSessionMediaReference, "isSessionMediaReference");
-function withMediaDegradationMarker(blocks) {
+__name(isSupportedImageMimeType, "isSupportedImageMimeType");
+function isTextMimeType(mimeType) {
+  return mimeType.startsWith("text/") || mimeType === "application/json" || mimeType.endsWith("+json") || mimeType === "application/xml" || mimeType.endsWith("+xml") || mimeType === "application/javascript" || mimeType === "application/typescript" || mimeType === "application/yaml" || mimeType === "application/x-yaml" || mimeType === "application/toml";
+}
+__name(isTextMimeType, "isTextMimeType");
+function isTextAttachment(data, mimeType) {
+  if (isTextMimeType(mimeType)) return true;
+  if (mimeType.startsWith("image/") || mimeType.startsWith("audio/") || mimeType.startsWith("video/") || mimeType.startsWith("font/") || mimeType === "application/pdf" || data.includes(0)) {
+    return false;
+  }
+  return Buffer.from(data.toString("utf8"), "utf8").equals(data);
+}
+__name(isTextAttachment, "isTextAttachment");
+function withAttachmentDegradationMarker(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)) {
+      if (block.text.endsWith(SESSION_ATTACHMENT_UNAVAILABLE_TEXT)) {
         return [...blocks];
       }
       const next = [...blocks];
       next[i] = {
         type: "text",
         text: `${block.text}
-${SESSION_MEDIA_UNAVAILABLE_TEXT}`
+${SESSION_ATTACHMENT_UNAVAILABLE_TEXT}`
       };
       return next;
     }
   }
   return [
     ...blocks,
-    { type: "text", text: SESSION_MEDIA_UNAVAILABLE_TEXT }
+    { type: "text", text: SESSION_ATTACHMENT_UNAVAILABLE_TEXT }
   ];
 }
-__name(withMediaDegradationMarker, "withMediaDegradationMarker");
-var SessionMediaStore = class {
+__name(withAttachmentDegradationMarker, "withAttachmentDegradationMarker");
+var SessionAttachmentStore = class {
+  constructor(directoryRoot, sessionId) {
+    this.directoryRoot = directoryRoot;
+    if (!directoryRoot || !sessionId) return;
+    this.persistentDirectory = path.join(
+      directoryRoot,
+      `session-${encodeURIComponent(sessionId)}`
+    );
+  }
   static {
-    __name(this, "SessionMediaStore");
+    __name(this, "SessionAttachmentStore");
   }
-  records = /* @__PURE__ */ new Map();
   directoryPromise;
-  totalBytes = 0;
+  persistentDirectory;
+  activeDirectory;
   pendingItems = 0;
+  pendingNames = /* @__PURE__ */ new Map();
+  pendingDrainWaiters = [];
+  copyDrainWaiters = [];
+  copying = false;
+  closing = false;
   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/*");
+  async putAttachment(data, mimeType, name) {
+    const isImage = isSupportedImageMimeType(mimeType);
+    const safeName = safeAttachmentName(
+      name ?? (isImage ? imageName(mimeType) : "")
+    );
+    if (!safeName) {
+      throw new TypeError("Session attachment name is invalid");
     }
-    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`
-      );
+    const storedMimeType = mimeTypeForName(safeName);
+    if (isImage && storedMimeType !== mimeType || isSupportedImageMimeType(storedMimeType) && !isImage) {
+      throw new TypeError("Attachment name and Content-Type do not match");
     }
-    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.closed || this.closing) {
+      throw new Error("Session attachment store is closed");
     }
-    if (this.records.size + this.pendingItems >= SESSION_MEDIA_MAX_ITEMS) {
+    if (this.copying) throw new Error("Session attachments are being copied");
+    if (isImage && data.byteLength === 0 || data.byteLength > SESSION_ATTACHMENT_MAX_ITEM_BYTES) {
       throw new RangeError(
-        `Session media exceeds the ${SESSION_MEDIA_MAX_ITEMS}-item session limit`
+        `Session attachment must be at most ${SESSION_ATTACHMENT_MAX_ITEM_BYTES} bytes and images cannot be empty`
       );
     }
-    const mediaId = randomUUID();
     let filePath;
-    this.totalBytes += data.byteLength;
+    let pendingName = safeName;
+    let removeFileOnFailure = false;
     this.pendingItems += 1;
+    this.reservePendingName(safeName);
     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
+      let suffix = 0;
+      for (; ; ) {
+        const candidateName = deduplicatedName(safeName, suffix);
+        if (safeAttachmentName(candidateName) !== candidateName) {
+          throw new TypeError("Session attachment name is invalid");
+        }
+        if (pendingName !== candidateName) {
+          if (pendingName) this.releasePendingName(pendingName);
+          this.reservePendingName(candidateName);
+          pendingName = candidateName;
+        }
+        filePath = path.join(directory, candidateName);
+        removeFileOnFailure = true;
+        try {
+          await fs.writeFile(filePath, data, { flag: "wx" });
+          break;
+        } catch (error) {
+          if (error.code !== "EEXIST") throw error;
+          removeFileOnFailure = false;
+          this.releasePendingName(candidateName);
+          pendingName = void 0;
+          filePath = void 0;
+          suffix += 1;
+        }
+      }
+      if (this.closed || this.closing) {
+        throw new Error("Session attachment store is closed");
+      }
+      const name2 = path.basename(filePath);
+      const storedMimeType2 = mimeTypeForName(name2);
+      const reference = {
+        type: isSupportedImageMimeType(storedMimeType2) ? "image" : "resource",
+        attachmentId: name2,
+        mimeType: storedMimeType2,
+        size: data.byteLength
       };
-      this.records.set(mediaId, record);
-      return { type, mediaId, mimeType, size: data.byteLength };
+      return reference;
     } catch (error) {
-      if (filePath) await fs.rm(filePath, { force: true }).catch(() => {
-      });
-      if (!this.closed) this.totalBytes -= data.byteLength;
+      if (removeFileOnFailure && filePath) {
+        await fs.rm(filePath, { force: true }).catch(() => {
+        });
+      }
       throw error;
     } finally {
-      if (!this.closed) this.pendingItems -= 1;
+      if (pendingName) this.releasePendingName(pendingName);
+      if (!this.closed) {
+        this.pendingItems -= 1;
+        if (this.pendingItems === 0) {
+          this.resolvePendingDrainWaiters();
+        }
+      }
     }
   }
-  // Validate one block against the store. Blocks without a `mediaId` (inline
-  // media, text) pass through untouched, matching `assertReferences`.
+  // Validate one block against the store. Ordinary ACP content passes through
+  // untouched, matching `assertReferences`.
   assertReference(block) {
-    if (!block || typeof block !== "object" || Array.isArray(block) || !("mediaId" in block)) {
+    if (!block || typeof block !== "object" || Array.isArray(block) || !("attachmentId" in block)) {
       return;
     }
-    if (!isSessionMediaReference(block)) {
-      throw new SessionMediaReferenceError(
-        "Invalid session media reference",
-        "invalid_session_media_reference"
+    if (!isSessionAttachmentReference(block)) {
+      throw new SessionAttachmentReferenceError(
+        "Invalid session attachment reference",
+        "invalid_session_attachment_reference"
       );
     }
     this.assertStored(block);
   }
   assertReferences(content) {
-    const seenMediaIds = /* @__PURE__ */ new Set();
+    const seenIds = /* @__PURE__ */ new Set();
     for (const block of content) {
-      if (!block || typeof block !== "object" || Array.isArray(block) || !("mediaId" in block)) {
+      if (!block || typeof block !== "object" || Array.isArray(block) || !("attachmentId" in block)) {
         continue;
       }
-      if (!isSessionMediaReference(block)) {
-        throw new SessionMediaReferenceError(
-          "Invalid session media reference",
-          "invalid_session_media_reference"
+      if (!isSessionAttachmentReference(block)) {
+        throw new SessionAttachmentReferenceError(
+          "Invalid session attachment reference",
+          "invalid_session_attachment_reference"
         );
       }
-      if (seenMediaIds.has(block.mediaId)) {
-        throw new SessionMediaReferenceError(
-          `Session media referenced more than once: ${block.mediaId}`,
-          "invalid_session_media_reference"
+      const id = block.attachmentId;
+      if (seenIds.has(id)) {
+        throw new SessionAttachmentReferenceError(
+          `Session attachment referenced more than once: ${id}`,
+          "invalid_session_attachment_reference"
         );
       }
-      seenMediaIds.add(block.mediaId);
+      seenIds.add(id);
       this.assertStored(block);
     }
   }
   async resolveContent(content, memo) {
-    const pendingByMediaId = memo ?? /* @__PURE__ */ new Map();
+    const pendingById = memo ?? /* @__PURE__ */ new Map();
     return await Promise.all(
       content.map(async (block) => {
-        if (!isSessionMediaReference(block)) return block;
-        let pending = pendingByMediaId.get(block.mediaId);
+        if (!isSessionAttachmentReference(block)) return block;
+        const id = block.attachmentId;
+        let pending = pendingById.get(id);
         if (!pending) {
           const created = this.resolve(block);
-          pendingByMediaId.set(block.mediaId, created);
+          pendingById.set(id, created);
           void created.catch(() => {
-            if (pendingByMediaId.get(block.mediaId) === created) {
-              pendingByMediaId.delete(block.mediaId);
+            if (pendingById.get(id) === created) {
+              pendingById.delete(id);
             }
           });
           pending = created;
@@ -1449,13 +1569,13 @@ var SessionMediaStore = class {
   }
   // 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.
+  // fallback would discard. Other errors still propagate.
   async resolveContentDegrading(content, memo) {
     const retainedBlocks = [];
     const resolvedBlocks = [];
     let degraded = 0;
     for (const block of content) {
-      if (!isSessionMediaReference(block)) {
+      if (!isSessionAttachmentReference(block)) {
         retainedBlocks.push(block);
         resolvedBlocks.push(block);
         continue;
@@ -1465,79 +1585,220 @@ var SessionMediaStore = class {
         if (resolved) resolvedBlocks.push(resolved);
         retainedBlocks.push(block);
       } catch (error) {
-        if (!(error instanceof SessionMediaReferenceError)) throw error;
+        if (!(error instanceof SessionAttachmentReferenceError)) throw error;
         degraded += 1;
       }
     }
     return { retainedBlocks, resolvedBlocks, degraded };
   }
-  async read(mediaId) {
-    const record = this.records.get(mediaId);
-    if (!record) return void 0;
+  async read(attachmentId) {
+    const name = safeAttachmentName(attachmentId);
+    if (!name || name !== attachmentId) return void 0;
+    const filePath = path.join(await this.directory(), name);
     try {
       return {
-        data: await fs.readFile(record.filePath),
-        mimeType: record.mimeType
+        data: await fs.readFile(filePath),
+        mimeType: mimeTypeForName(name)
       };
     } 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;
+  async copyFrom(source) {
+    if (source === this) return;
+    if (this.closed || this.closing) {
+      throw new Error("Session attachment store is closed");
+    }
+    if (this.copying) throw new Error("Session attachments are being copied");
+    if (source.closed || source.closing) {
+      throw new Error("Session attachment store is closed");
+    }
+    if (source.copying) {
+      throw new Error("Session attachments are being copied");
+    }
+    this.copying = true;
+    source.copying = true;
+    try {
+      if (this.pendingItems > 0) {
+        await new Promise(
+          (resolve2) => this.pendingDrainWaiters.push(resolve2)
+        );
+      }
+      if (source.pendingItems > 0) {
+        await new Promise(
+          (resolve2) => source.pendingDrainWaiters.push(resolve2)
+        );
+      }
+      if (this.closed) throw new Error("Session attachment store is closed");
+      const sourceDirectory = source.persistentDirectory ?? source.activeDirectory;
+      if (!sourceDirectory) return;
+      let entries;
+      try {
+        entries = await fs.readdir(sourceDirectory, { withFileTypes: true });
+      } catch (error) {
+        if (error.code === "ENOENT") return;
+        throw error;
+      }
+      const targetDirectory = await this.directory();
+      await Promise.all(
+        entries.filter(
+          (entry) => entry.isFile() && !source.pendingNames.has(entry.name)
+        ).map(async (entry) => {
+          const sourcePath = path.join(sourceDirectory, entry.name);
+          try {
+            await fs.copyFile(
+              sourcePath,
+              path.join(targetDirectory, entry.name)
+            );
+          } catch (error) {
+            if (error.code === "ENOENT") {
+              try {
+                await fs.stat(sourcePath);
+              } catch (sourceError) {
+                if (sourceError.code === "ENOENT") {
+                  return;
+                }
+              }
+            }
+            throw error;
+          }
+        })
+      );
+    } finally {
+      source.copying = false;
+      this.copying = false;
+      source.resolveCopyDrainWaiters();
+      this.resolveCopyDrainWaiters();
+    }
   }
-  get sizeBytes() {
-    return this.totalBytes;
+  async remove(attachmentId) {
+    const name = safeAttachmentName(attachmentId);
+    if (!name || name !== attachmentId || this.copying || this.pendingNames.has(name)) {
+      return false;
+    }
+    const directory = await this.directory();
+    const filePath = path.join(directory, name);
+    try {
+      await fs.unlink(filePath);
+      return true;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return false;
+      }
+      throw error;
+    }
   }
   async close() {
+    this.closing = true;
+    await this.waitForCopy();
     if (this.closed) return;
     this.closed = true;
-    this.records.clear();
-    this.totalBytes = 0;
     this.pendingItems = 0;
-    if (!this.directoryPromise) return;
+    this.pendingNames.clear();
+    this.resolvePendingDrainWaiters();
+    if (this.persistentDirectory || !this.directoryPromise) return;
     const directory = await this.directoryPromise.catch(() => void 0);
     if (!directory) return;
     await fs.rm(directory, { recursive: true, force: true });
   }
+  async delete() {
+    this.closing = true;
+    await this.waitForCopy();
+    if (!this.closed) {
+      this.closed = true;
+      this.pendingItems = 0;
+      this.pendingNames.clear();
+      this.resolvePendingDrainWaiters();
+    }
+    const directory = this.persistentDirectory ?? await this.directoryPromise?.catch(() => void 0);
+    if (directory) 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"
+    const id = reference.attachmentId;
+    const name = safeAttachmentName(id);
+    let size;
+    const directory = this.persistentDirectory ?? this.activeDirectory;
+    if (name && name === id && directory) {
+      try {
+        size = statSync(path.join(directory, name)).size;
+      } catch {
+        size = void 0;
+      }
+    }
+    const storedMimeType = name ? mimeTypeForName(name) : void 0;
+    const storedType = storedMimeType ? isSupportedImageMimeType(storedMimeType) ? "image" : "resource" : void 0;
+    if (size !== reference.size || storedMimeType !== reference.mimeType || storedType !== reference.type) {
+      throw new SessionAttachmentReferenceError(
+        `Unknown or unavailable session attachment: ${id}`,
+        "session_attachment_gone"
       );
     }
   }
+  releasePendingName(name) {
+    const count = this.pendingNames.get(name) ?? 0;
+    if (count <= 1) this.pendingNames.delete(name);
+    else this.pendingNames.set(name, count - 1);
+  }
+  reservePendingName(name) {
+    this.pendingNames.set(name, (this.pendingNames.get(name) ?? 0) + 1);
+  }
+  async waitForCopy() {
+    while (this.copying) {
+      await new Promise((resolve2) => this.copyDrainWaiters.push(resolve2));
+    }
+  }
+  resolveCopyDrainWaiters() {
+    for (const resolve2 of this.copyDrainWaiters.splice(0)) resolve2();
+  }
+  resolvePendingDrainWaiters() {
+    for (const resolve2 of this.pendingDrainWaiters.splice(0)) resolve2();
+  }
   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"
-      );
+    const id = reference.attachmentId;
+    const attachment = await this.read(id);
+    if (!attachment) {
+      throw new SessionAttachmentReferenceError(
+        `Unknown or unavailable session attachment: ${id}`,
+        "session_attachment_gone"
+      );
+    }
+    if (reference.type === "resource") {
+      const resource = {
+        uri: `attachment:///${encodeURIComponent(reference.attachmentId)}`,
+        mimeType: attachment.mimeType,
+        ...isTextAttachment(attachment.data, attachment.mimeType) ? { text: attachment.data.toString("utf8") } : { blob: attachment.data.toString("base64") }
+      };
+      return {
+        type: "resource",
+        resource
+      };
     }
     return {
-      type: reference.type,
-      data: media.data.toString("base64"),
-      mimeType: media.mimeType
+      type: "image",
+      data: attachment.data.toString("base64"),
+      mimeType: attachment.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)
+      const pending = this.persistentDirectory ? fs.mkdir(this.persistentDirectory, {
+        recursive: true,
+        mode: 448
+      }).then(() => this.persistentDirectory) : this.directoryRoot ? fs.mkdir(this.directoryRoot, { recursive: true, mode: 448 }).then(
+        () => fs.mkdtemp(
+          path.join(this.directoryRoot, "session-attachment-")
+        )
+      ) : fs.mkdtemp(path.join(tmpdir(), "qwen-session-attachment-"));
+      const directoryPromise = pending.then((directory) => {
+        this.activeDirectory = directory;
+        return directory;
+      });
+      this.directoryPromise = directoryPromise;
+      void directoryPromise.catch(() => {
+        if (this.directoryPromise === directoryPromise)
           this.directoryPromise = void 0;
       });
     }
@@ -1555,7 +1816,7 @@ __name(writeStderrLine, "writeStderrLine");
 
 // packages/acp-bridge/src/bridgeClient.ts
 init_esbuild_shims();
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID } from "node:crypto";
 import { promises as fs2 } from "node:fs";
 import * as path2 from "node:path";
 
@@ -2543,7 +2804,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, onSessionCatalogChanged) {
+  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, onGoalTurnEnded) {
     this.resolveEntry = resolveEntry;
     this.resolvePendingRestoreEvents = resolvePendingRestoreEvents;
     this.mediator = mediator;
@@ -2566,6 +2827,7 @@ var BridgeClient = class {
     this.externalToolGuard = externalToolGuard;
     this.onActiveWork = onActiveWork;
     this.onSessionCatalogChanged = onSessionCatalogChanged;
+    this.onGoalTurnEnded = onGoalTurnEnded;
   }
   static {
     __name(this, "BridgeClient");
@@ -2584,7 +2846,7 @@ var BridgeClient = class {
       options.map((o) => String(o.optionId ?? ""))
     );
     allowedOptionIds.delete("");
-    const requestId = randomUUID2();
+    const requestId = randomUUID();
     if (allowedOptionIds.has(CANCEL_VOTE_SENTINEL)) {
       throw new CancelSentinelCollisionError(requestId, CANCEL_VOTE_SENTINEL);
     }
@@ -2883,38 +3145,41 @@ var BridgeClient = class {
         );
       }
     }
-    const mediaMemo = /* @__PURE__ */ new Map();
-    const serializedMediaIds = /* @__PURE__ */ new Set();
+    const attachmentMemo = /* @__PURE__ */ new Map();
+    const serializedAttachmentIds = /* @__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)) {
+          if (!isSessionAttachmentReference(block)) return true;
+          if (serializedAttachmentIds.has(block.attachmentId)) {
             degraded += 1;
             return false;
           }
-          serializedMediaIds.add(block.mediaId);
+          serializedAttachmentIds.add(block.attachmentId);
           return true;
         });
         let resolvedBlocks;
-        let mediaReferences;
+        let attachmentReferences;
         try {
-          resolvedBlocks = await entry.media.resolveContent(planned, mediaMemo);
-          mediaReferences = planned.filter(isSessionMediaReference);
+          resolvedBlocks = await entry.attachments.resolveContent(
+            planned,
+            attachmentMemo
+          );
+          attachmentReferences = planned.filter(isSessionAttachmentReference);
         } catch (error) {
-          if (!(error instanceof SessionMediaReferenceError)) throw error;
+          if (!(error instanceof SessionAttachmentReferenceError)) 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))}`
+            `[mid-turn] session=${JSON.stringify(entry.sessionId)} degraded attachment for message ${JSON.stringify(item.messageId)}: ${JSON.stringify(error instanceof Error ? error.message : String(error))}`
           );
-          const perBlock = await entry.media.resolveContentDegrading(
+          const perBlock = await entry.attachments.resolveContentDegrading(
             planned,
-            mediaMemo
+            attachmentMemo
           );
           resolvedBlocks = perBlock.resolvedBlocks;
-          mediaReferences = perBlock.retainedBlocks.filter(
-            isSessionMediaReference
+          attachmentReferences = perBlock.retainedBlocks.filter(
+            isSessionAttachmentReference
           );
           degraded += perBlock.degraded;
         }
@@ -2922,12 +3187,12 @@ var BridgeClient = class {
           ...item.text ? [{ type: "text", text: item.text }] : [],
           ...resolvedBlocks
         ];
-        if (degraded > 0) content = withMediaDegradationMarker(content);
+        if (degraded > 0) content = withAttachmentDegradationMarker(content);
         items.push({
           messageId: item.messageId,
           displayText: item.text,
           content,
-          ...mediaReferences.length > 0 ? { mediaReferences } : {}
+          ...attachmentReferences.length > 0 ? { attachmentReferences } : {}
         });
       }
     } catch (error) {
@@ -3356,7 +3621,7 @@ var BridgeClient = class {
    * `qwen/notify/session/prompt-suggestion` (followup assist),
    * `qwen/notify/session/artifact-event` (hook artifacts),
    * `qwen/notify/session/terminal-sequence`, and
-   * `_qwencode/end_turn` (background-notification turns), and
+   * `_qwencode/end_turn` (background-notification and goal turns), and
    * `qwen/notify/session/mcp-budget-event` — each translated into a
    * session-scoped SSE frame. Unknown methods are dropped silently for
    * forward-compat.
@@ -3379,14 +3644,39 @@ var BridgeClient = class {
       }
       return;
     }
+    if (method === "_qwencode/start_turn") {
+      const sessionId2 = params["sessionId"];
+      if (typeof sessionId2 !== "string" || sessionId2.length === 0 || params["source"] !== "goal") {
+        return;
+      }
+      const entry = this.resolveEntry(sessionId2);
+      if (!entry || !this.ownsSession(sessionId2)) return;
+      entry.goalTurnActive = true;
+      return;
+    }
     if (method === "_qwencode/end_turn") {
       const sessionId2 = params["sessionId"];
       const reason = params["reason"];
-      if (typeof sessionId2 !== "string" || sessionId2.length === 0 || typeof reason !== "string" || reason.length === 0 || reason.length > 128 || params["source"] !== "background_notification") {
+      const source = params["source"];
+      if (typeof sessionId2 !== "string" || sessionId2.length === 0 || typeof reason !== "string" || reason.length === 0 || reason.length > 128 || source !== "background_notification" && source !== "goal") {
         return;
       }
       const entry = this.resolveEntry(sessionId2);
       if (!entry || !this.ownsSession(sessionId2)) return;
+      if (source === "goal") {
+        entry.goalTurnActive = false;
+        this.onGoalTurnEnded?.(sessionId2);
+        const promptId = params["promptId"];
+        if (typeof promptId !== "string" || promptId.length === 0 || promptId.length > 256) {
+          return;
+        }
+        entry.events.publish({
+          type: "turn_complete",
+          promptId,
+          data: { sessionId: sessionId2, stopReason: reason, promptId }
+        });
+        return;
+      }
       entry.events.publish({
         type: "background_notification_turn_complete",
         data: { sessionId: sessionId2, reason }
@@ -3947,7 +4237,7 @@ var BridgeClient = class {
       } catch {
       }
     }
-    const tmp = `${realTarget}.${process.pid}.${Date.now()}.${randomUUID2()}.tmp`;
+    const tmp = `${realTarget}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`;
     let preserveMode;
     try {
       const targetStat = await fs2.stat(realTarget);
@@ -7276,6 +7566,56 @@ function rememberEnrichedTerminalTurnStatus(entry, promptId, status) {
   }
 }
 __name(rememberEnrichedTerminalTurnStatus, "rememberEnrichedTerminalTurnStatus");
+function advanceTurnActivity(entry) {
+  const createdAtMs = Date.parse(entry.createdAt);
+  const previous = entry.lastTurnEndedAtMs ?? (Number.isFinite(createdAtMs) ? createdAtMs : void 0);
+  entry.lastTurnEndedAtMs = previous === void 0 ? Date.now() : Math.max(Date.now(), previous + 1);
+}
+__name(advanceTurnActivity, "advanceTurnActivity");
+function appendPromptLedgerBestEffort(entry, record) {
+  const ledger = entry.promptLedger;
+  if (!ledger) return;
+  try {
+    ledger.appendSync(entry.sessionId, record);
+  } catch (error) {
+    writeStderrLine(
+      `qwen serve: prompt ledger append failed for session=${entry.sessionId} promptId=${record.promptId}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+__name(appendPromptLedgerBestEffort, "appendPromptLedgerBestEffort");
+function promptLedgerTerminalRecord(pendingEntry, terminal) {
+  const at = Date.now();
+  if (terminal.kind === "complete") {
+    if (terminal.result.stopReason === "cancelled") {
+      return {
+        v: 1,
+        promptId: pendingEntry.promptId,
+        terminal: "cancelled",
+        at
+      };
+    }
+    return {
+      v: 1,
+      promptId: pendingEntry.promptId,
+      terminal: "completed",
+      ...terminal.result.stopReason !== void 0 ? { stopReason: terminal.result.stopReason } : {},
+      at
+    };
+  }
+  if (terminal.kind === "cancelled") {
+    return { v: 1, promptId: pendingEntry.promptId, terminal: "cancelled", at };
+  }
+  const normalized = normalizeTurnResultError(terminal.err);
+  return {
+    v: 1,
+    promptId: pendingEntry.promptId,
+    terminal: "error",
+    ...normalized.code !== void 0 ? { code: normalized.code } : {},
+    at
+  };
+}
+__name(promptLedgerTerminalRecord, "promptLedgerTerminalRecord");
 function publishPromptTerminal(entry, pendingEntry, terminal) {
   if (pendingEntry.terminalPublished) {
     writeServeDebugLine(
@@ -7284,9 +7624,16 @@ function publishPromptTerminal(entry, pendingEntry, terminal) {
     return;
   }
   pendingEntry.terminalPublished = true;
+  appendPromptLedgerBestEffort(
+    entry,
+    promptLedgerTerminalRecord(pendingEntry, terminal)
+  );
   rememberTerminalTurnStatus(entry, pendingEntry, terminal);
   const originatorClientId = pendingEntry.originatorClientId;
   const mutateTurnState = pendingEntry.state === "running";
+  if (mutateTurnState) {
+    advanceTurnActivity(entry);
+  }
   if (!mutateTurnState && entry.turnErrorEvent) {
     const journal = entry.events.liveJournalSnapshot() ?? [];
     if (journal.some(isRefreshAppendTurnContent)) {
@@ -7448,7 +7795,7 @@ function extractMediaBlocks(prompt) {
   const media = [];
   for (const block of prompt) {
     if (!block || typeof block !== "object") continue;
-    if (block.type === "image" || block.type === "audio") {
+    if (block.type === "image" || block.type === "audio" || block.type === "resource" && "attachmentId" in block) {
       media.push(block);
     }
   }
@@ -7472,15 +7819,22 @@ 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) => {
+var MAX_QUEUED_INLINE_ATTACHMENT_BYTES = 100 * 1024 * 1024;
+function inlineAttachmentBlockBytes(blocks) {
   let total = 0;
   for (const block of blocks) {
     if (block.type === "image" && "data" in block) {
-      total += block.data.length;
+      total += Buffer.byteLength(block.data);
+      continue;
     }
+    if (block.type !== "resource" || !("resource" in block)) continue;
+    const resource = block.resource;
+    if ("blob" in resource) total += Buffer.byteLength(resource.blob);
+    else if ("text" in resource) total += Buffer.byteLength(resource.text);
   }
   return total;
-}, "inlineMediaBlockBytes");
+}
+__name(inlineAttachmentBlockBytes, "inlineAttachmentBlockBytes");
 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;
@@ -7489,8 +7843,6 @@ 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;
@@ -7549,7 +7901,7 @@ function createAcpSessionBridge(opts) {
       );
     }
   }, "releaseFreshSessionReservation");
-  const sessionCatalogGeneration = randomUUID3();
+  const sessionCatalogGeneration = randomUUID2();
   let sessionCatalogRevision = 0;
   const getSessionCatalogVersion = /* @__PURE__ */ __name(() => ({
     generation: sessionCatalogGeneration,
@@ -7652,7 +8004,6 @@ function createAcpSessionBridge(opts) {
     DEFAULT_SESSION_IDLE_TIMEOUT_MS
   );
   let sessionReaper;
-  let mediaSweeper;
   let lastActivityTimestamp = null;
   let activePromptCounter = 0;
   function touchActivity() {
@@ -7969,34 +8320,8 @@ 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) {
-      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;
-    }
+    if (sessionReapIntervalMs <= 0) return;
     writeStderrLine(
       `qwen serve: session reaper started (interval ${sessionReapIntervalMs}ms, idle threshold ${sessionIdleTimeoutMs}ms)`
     );
@@ -8017,7 +8342,6 @@ function createAcpSessionBridge(opts) {
           closeReason: "idle_timeout"
         });
       }
-      sweepRetainedMedia();
     }, sessionReapIntervalMs);
     sessionReaper.unref();
   }
@@ -8027,29 +8351,11 @@ 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;
@@ -8121,12 +8427,13 @@ function createAcpSessionBridge(opts) {
       sessionId: entry.sessionId,
       workspaceCwd: entry.workspaceCwd,
       createdAt: entry.createdAt,
+      ...entry.lastTurnEndedAtMs !== void 0 ? { updatedAt: new Date(entry.lastTurnEndedAtMs).toISOString() } : {},
       displayName: entry.displayName,
       ...entry.parentSessionId ? { parentSessionId: entry.parentSessionId } : {},
       ...entry.sourceType ? { sourceType: entry.sourceType } : {},
       ...entry.sourceId !== void 0 ? { sourceId: entry.sourceId } : {},
       clientCount: entry.clientIds.size,
-      hasActivePrompt: entry.promptActive,
+      hasActivePrompt: entry.promptActive || entry.goalTurnActive === true,
       isWaitingForPermission,
       isWaitingForUserQuestion,
       pendingInteractionCount: entry.pendingInteractions.size,
@@ -8189,7 +8496,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_${randomUUID3()}`, "createClientId");
+  const createClientId = /* @__PURE__ */ __name(() => `client_${randomUUID2()}`, "createClientId");
   const registerClient = /* @__PURE__ */ __name((entry, requestedClientId) => {
     if (requestedClientId && entry.clientIds.has(requestedClientId)) {
       entry.clientIds.set(
@@ -8248,7 +8555,7 @@ function createAcpSessionBridge(opts) {
     if (inFlightChannelSpawn) return await inFlightChannelSpawn;
     const promise = (async () => {
       const privateParentCapability = randomBytes(32).toString("base64url");
-      const acpChannelId = randomUUID3();
+      const acpChannelId = randomUUID2();
       const channel = await telemetry.withSpan(
         "channel.spawn",
         {
@@ -8372,7 +8679,10 @@ function createAcpSessionBridge(opts) {
           },
           // Child-side automatic title updates change persisted catalog
           // metadata the bridge never sees; forward the catalog-clock mark.
-          markSessionCatalogChanged
+          markSessionCatalogChanged,
+          // A Goal turn drains the mid-turn queue but owns no prompt slot, so
+          // nothing else would settle what its last drain missed.
+          settleMidTurnQueueAfterGoalTurn
         );
         const rawConnection = new ClientSideConnection(
           () => channel.transportGuard ? createLogSafeAcpClient(client, channel.transportGuard) : client,
@@ -8510,9 +8820,11 @@ function createAcpSessionBridge(opts) {
             touchActivity();
           }
           byId.delete(sid);
-          if (retainedMedia.has(sid)) {
-            retainedMediaDetachedAt.set(sid, Date.now());
-          }
+          void sessEntry.attachments.close().catch((error) => {
+            writeStderrLine(
+              `qwen serve: failed to close attachments for closed channel session ${JSON.stringify(sid)}: ${error instanceof Error ? error.message : String(error)}`
+            );
+          });
           telemetry.metrics?.sessionLifecycle("die");
           emitSessionLifecycle({
             type: "removed",
@@ -9260,6 +9572,41 @@ function createAcpSessionBridge(opts) {
     }
     return response;
   }, "requestWorkspaceStatus");
+  const MAX_CHILD_HEAP_UNCLASSIFIED_NAMES = 64;
+  const MAX_CHILD_HEAP_SPACE_NAME_LENGTH = 64;
+  const parseChildHeapReport = /* @__PURE__ */ __name((value) => {
+    if (typeof value !== "object" || value === null) return void 0;
+    const raw = value;
+    const counts = [
+      "peakOldGenerationBytes",
+      "peakLiveSetBytes",
+      "peakTotalHeapBytes",
+      "majorGcCount",
+      "majorGcMs"
+    ];
+    const parsed = {};
+    for (const key of counts) {
+      const n = raw[key];
+      if (typeof n !== "number" || !Number.isFinite(n) || n < 0) {
+        return void 0;
+      }
+      parsed[key] = n;
+    }
+    const names = raw["unclassifiedSpaceNames"];
+    if (!Array.isArray(names) || names.length > MAX_CHILD_HEAP_UNCLASSIFIED_NAMES || names.some(
+      (name) => typeof name !== "string" || name.length > MAX_CHILD_HEAP_SPACE_NAME_LENGTH
+    )) {
+      return void 0;
+    }
+    return {
+      peakOldGenerationBytes: parsed["peakOldGenerationBytes"],
+      peakLiveSetBytes: parsed["peakLiveSetBytes"],
+      peakTotalHeapBytes: parsed["peakTotalHeapBytes"],
+      majorGcCount: parsed["majorGcCount"],
+      majorGcMs: parsed["majorGcMs"],
+      unclassifiedSpaceNames: names
+    };
+  }, "parseChildHeapReport");
   const STALE_CHILD_RESOURCE_MS = 3e4;
   let childResourceRefreshing = false;
   const refreshChildResource = /* @__PURE__ */ __name(async () => {
@@ -9276,6 +9623,8 @@ function createAcpSessionBridge(opts) {
       if (typeof res.cpuPercent === "number" && Number.isFinite(res.cpuPercent)) {
         info.childCpuPercent = Math.min(100, Math.max(0, res.cpuPercent));
       }
+      const heap = parseChildHeapReport(res.heap);
+      if (heap) info.childHeap = heap;
       info.childResourceAt = Date.now();
     } catch (err) {
       teeServeDebugLine(
@@ -9295,6 +9644,10 @@ function createAcpSessionBridge(opts) {
     return {
       rssBytes: info.childRssBytes ?? 0,
       cpuPercent: info.childCpuPercent ?? 0,
+      // Deliberately not defaulted. Unlike rss/cpu, where 0 is a plausible
+      // reading, a zeroed heap report would assert the child needed no old
+      // generation — the one conclusion that must never be manufactured.
+      heap: info.childHeap,
       // Bounded by the guard above, so a caller summing several children's
       // readings can say how far apart they were taken. Without it a sum of
       // readings up to `STALE_CHILD_RESOURCE_MS` apart looks instantaneous.
@@ -9550,13 +9903,17 @@ function createAcpSessionBridge(opts) {
         workspaceCwd,
         persistence: createSessionArtifactPersistence(ci.connection, sessionId)
       }),
-      media: retainSessionMedia(sessionId),
+      attachments: new SessionAttachmentStore(
+        opts.sessionAttachmentsRoot,
+        sessionId
+      ),
       recordingDegraded: false,
       closing: false,
       cwdChangeQueue: Promise.resolve(),
       promptQueue: Promise.resolve(),
       pendingPromptCount: 0,
       pendingAgentNotificationCount: 0,
+      ...opts.promptLedger ? { promptLedger: opts.promptLedger } : {},
       pendingPromptList: [],
       terminalTurnStatuses: /* @__PURE__ */ new Map(),
       enrichedTerminalPromptIds: /* @__PURE__ */ new Set(),
@@ -9974,7 +10331,7 @@ function createAcpSessionBridge(opts) {
         // Late attachers get the same ACP state the original restore
         // caller saw; spawn-only sessions don't carry a state payload.
         state: existing.restoreState ?? {},
-        hasActivePrompt: existing.promptActive,
+        hasActivePrompt: existing.promptActive || existing.goalTurnActive === true,
         ...replayFields,
         ...historyAnchorRecordId !== void 0 ? { historyAnchorRecordId } : {}
       };
@@ -10056,7 +10413,7 @@ function createAcpSessionBridge(opts) {
         attached: true,
         clientId,
         createdAt: entry.createdAt,
-        hasActivePrompt: entry.promptActive,
+        hasActivePrompt: entry.promptActive || entry.goalTurnActive === true,
         ...waiterReplayFields ?? {}
       };
     }
@@ -10419,7 +10776,7 @@ function createAcpSessionBridge(opts) {
           ...racedEntry.sourceType ? { sourceType: racedEntry.sourceType } : {},
           ...racedEntry.sourceId !== void 0 ? { sourceId: racedEntry.sourceId } : {},
           state: racedEntry.restoreState ?? {},
-          hasActivePrompt: racedEntry.promptActive,
+          hasActivePrompt: racedEntry.promptActive || racedEntry.goalTurnActive === true,
           ...replayFieldsFor(racedEntry, action, liveReplayMode)
         };
       }
@@ -10495,7 +10852,7 @@ function createAcpSessionBridge(opts) {
         ...entry.sourceId !== void 0 ? { sourceId: entry.sourceId } : {},
         state: publicState,
         ...artifactRestoreWarnings.length > 0 ? { artifactWarnings: artifactRestoreWarnings } : {},
-        hasActivePrompt: entry.promptActive,
+        hasActivePrompt: entry.promptActive || entry.goalTurnActive === true,
         ...replayFieldsFor(entry, action, liveReplayMode)
       };
     })().finally(async () => {
@@ -10510,9 +10867,11 @@ 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());
-          }
+          await restoreEntry.attachments.close().catch((error) => {
+            writeStderrLine(
+              `qwen serve: failed to close attachments after restoring session ${JSON.stringify(req.sessionId)}: ${error instanceof Error ? error.message : String(error)}`
+            );
+          });
           ci?.sessionIds.delete(req.sessionId);
           emitSessionLifecycle({
             type: "removed",
@@ -10676,15 +11035,11 @@ 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)}`
-        );
-      });
-    }
+    await entry.attachments.close().catch((error) => {
+      writeStderrLine(
+        `qwen serve: failed to close attachments for session ${JSON.stringify(sessionId)}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    });
     if (!agentSessionClosed) {
       try {
         await telemetry.withSpan(
@@ -10713,25 +11068,15 @@ function createAcpSessionBridge(opts) {
       ring.splice(0, ring.length - MID_TURN_RECONCILIATION_RING_SIZE);
     }
   }, "rememberMidTurnId");
-  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);
+        entry.attachments.assertReference(block);
         resolvableBlocks.push(block);
       } catch (error) {
-        if (!(error instanceof SessionMediaReferenceError)) throw error;
+        if (!(error instanceof SessionAttachmentReferenceError)) throw error;
         degraded += 1;
       }
     }
@@ -10740,7 +11085,7 @@ function createAcpSessionBridge(opts) {
       ...resolvableBlocks
     ];
     if (degraded > 0) {
-      prompt = withMediaDegradationMarker(prompt);
+      prompt = withAttachmentDegradationMarker(prompt);
     }
     const context = {
       promptId: messageId,
@@ -10753,7 +11098,7 @@ function createAcpSessionBridge(opts) {
       entry.sessionId,
       {
         sessionId: entry.sessionId,
-        prompt: withMediaDegradationMarker(
+        prompt: withAttachmentDegradationMarker(
           text ? [{ type: "text", text }] : []
         )
       },
@@ -10773,7 +11118,7 @@ function createAcpSessionBridge(opts) {
       );
     } catch (error) {
       try {
-        if (!(error instanceof SessionMediaReferenceError)) throw error;
+        if (!(error instanceof SessionAttachmentReferenceError)) throw error;
         result = sendFallback();
       } catch (fallbackError) {
         writeStderrLine(
@@ -10788,6 +11133,37 @@ function createAcpSessionBridge(opts) {
       );
     });
   }, "promoteMidTurnMessage");
+  const settleUndrainedMidTurnMessages = /* @__PURE__ */ __name((entry, messages) => {
+    for (const message of messages) {
+      if (message.queueOnly) {
+        try {
+          message.onSettledWithoutDrain?.();
+        } catch (error) {
+          writeStderrLine(
+            `[mid-turn] session=${JSON.stringify(entry.sessionId)} failed to hand undrained queue-only message ${JSON.stringify(message.messageId)} back to its caller: ${JSON.stringify(error instanceof Error ? error.message : String(error))}`
+          );
+        }
+        continue;
+      }
+      promoteMidTurnMessage(
+        entry,
+        message.messageId,
+        message.text,
+        message.originatorClientId,
+        message.content
+      );
+    }
+  }, "settleUndrainedMidTurnMessages");
+  const settleMidTurnQueueAfterGoalTurn = /* @__PURE__ */ __name((sessionId) => {
+    const entry = byId.get(sessionId);
+    if (!entry) return;
+    if (entry.goalTurnActive === true || entry.pendingPromptCount > 0 || entry.closing) {
+      return;
+    }
+    const undrained = entry.midTurnMessageQueue.splice(0);
+    if (undrained.length === 0) return;
+    settleUndrainedMidTurnMessages(entry, undrained);
+  }, "settleMidTurnQueueAfterGoalTurn");
   const bridgeApi = {
     setLiveScreenContextCaptureHandler(handler) {
       liveScreenContextCaptureHandler = handler;
@@ -10830,7 +11206,7 @@ function createAcpSessionBridge(opts) {
             attachCount: entry.attachCount,
             pendingPromptCount: entry.pendingPromptCount,
             pendingPermissionCount: entry.pendingPermissionIds.size,
-            hasActivePrompt: entry.promptActive,
+            hasActivePrompt: entry.promptActive || entry.goalTurnActive === true,
             lastEventId: entry.events.lastEventId,
             ...entry.sessionLastSeenAt !== void 0 ? { lastSeenAt: entry.sessionLastSeenAt } : {},
             ...entry.currentModelId ? { currentModelId: entry.currentModelId } : {},
@@ -10983,7 +11359,7 @@ function createAcpSessionBridge(opts) {
             createdAt: existing.createdAt,
             ...existing.sourceType ? { sourceType: existing.sourceType } : {},
             ...existing.sourceId !== void 0 ? { sourceId: existing.sourceId } : {},
-            hasActivePrompt: existing.promptActive
+            hasActivePrompt: existing.promptActive || existing.goalTurnActive === true
           };
         }
         const inFlight = inFlightSpawns.get(workspaceKey);
@@ -11034,7 +11410,7 @@ function createAcpSessionBridge(opts) {
             ...session,
             attached: true,
             clientId,
-            hasActivePrompt: attachedEntry.promptActive
+            hasActivePrompt: attachedEntry.promptActive || attachedEntry.goalTurnActive === true
           };
         }
       }
@@ -11102,7 +11478,7 @@ function createAcpSessionBridge(opts) {
         req.branch,
         req.sessionId
       );
-      const tracker = effectiveScope === "single" ? workspaceKey : `${workspaceKey}#${randomUUID3()}`;
+      const tracker = effectiveScope === "single" ? workspaceKey : `${workspaceKey}#${randomUUID2()}`;
       inFlightSpawns.set(tracker, promise);
       try {
         return await promise;
@@ -11140,7 +11516,7 @@ function createAcpSessionBridge(opts) {
       const promotedMidTurn = context?.promotedMidTurn;
       const isPromotedMidTurn = promotedMidTurn !== void 0;
       const originatorClientId = promotedMidTurn ? promotedMidTurn.originatorClientId : resolveTrustedClientId(entry, context?.clientId);
-      entry.media.assertReferences(req.prompt);
+      entry.attachments.assertReferences(req.prompt);
       const modelPrompt = context?.modelPrompt;
       if (modelPrompt !== void 0 && !isValidTrustedModelPrompt(modelPrompt)) {
         throw new TypeError(
@@ -11164,7 +11540,7 @@ function createAcpSessionBridge(opts) {
         promptSlotReleased = true;
         entry.pendingPromptCount = Math.max(0, entry.pendingPromptCount - 1);
       }, "releasePromptSlot");
-      const promptId = context?.promptId ?? randomUUID3();
+      const promptId = context?.promptId ?? randomUUID2();
       const invocationContext = Object.freeze({
         version: 1,
         sessionId,
@@ -11202,6 +11578,22 @@ function createAcpSessionBridge(opts) {
         state: isQueued ? "queued" : "running"
       };
       entry.pendingPromptList.push(pendingEntry);
+      let tailUuid;
+      try {
+        tailUuid = entry.promptLedger?.transcriptTailUuid?.(sessionId);
+      } catch (error) {
+        opts.onDiagnosticLine?.(
+          `qwen serve: prompt ledger dispatch marker failed for session=${sessionId}: ${error instanceof Error ? error.message : String(error)}`,
+          "warn"
+        );
+      }
+      appendPromptLedgerBestEffort(entry, {
+        v: 1,
+        promptId,
+        state: "in_flight",
+        ...tailUuid !== void 0 ? { tailUuid } : {},
+        at: queuedAt
+      });
       try {
         context?.onPromptAdmitted?.();
       } catch (error) {
@@ -11321,14 +11713,16 @@ function createAcpSessionBridge(opts) {
                 let dispatchBlocks = req.prompt;
                 let resolvedPrompt;
                 try {
-                  resolvedPrompt = await entry.media.resolveContent(dispatchBlocks);
+                  resolvedPrompt = await entry.attachments.resolveContent(dispatchBlocks);
                 } catch (error) {
-                  if (!isPromotedMidTurn || !(error instanceof SessionMediaReferenceError)) {
+                  if (!isPromotedMidTurn || !(error instanceof SessionAttachmentReferenceError)) {
                     throw error;
                   }
-                  const perBlock = await entry.media.resolveContentDegrading(dispatchBlocks);
+                  const perBlock = await entry.attachments.resolveContentDegrading(
+                    dispatchBlocks
+                  );
                   dispatchBlocks = perBlock.retainedBlocks;
-                  resolvedPrompt = withMediaDegradationMarker(
+                  resolvedPrompt = withAttachmentDegradationMarker(
                     perBlock.resolvedBlocks
                   );
                 }
@@ -11359,7 +11753,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[DAEMON_ATTACHMENT_REFERENCES_META_KEY];
                   delete meta[CHANNEL_PROMPT_META_KEY];
                   if (isRetry) {
                     meta[DAEMON_RETRY_META_KEY] = true;
@@ -11376,11 +11770,11 @@ function createAcpSessionBridge(opts) {
                   if (modelPrompt !== void 0) {
                     meta[DAEMON_MODEL_PROMPT_META_KEY] = modelPrompt;
                   }
-                  const mediaReferences = dispatchBlocks.filter(
-                    isSessionMediaReference
+                  const attachmentReferences = dispatchBlocks.filter(
+                    isSessionAttachmentReference
                   );
-                  if (mediaReferences.length > 0) {
-                    meta[DAEMON_MEDIA_REFERENCES_META_KEY] = mediaReferences;
+                  if (attachmentReferences.length > 0) {
+                    meta[DAEMON_ATTACHMENT_REFERENCES_META_KEY] = attachmentReferences;
                   }
                   if (context?.channelPrompt === true) {
                     meta[CHANNEL_PROMPT_META_KEY] = true;
@@ -11394,6 +11788,7 @@ function createAcpSessionBridge(opts) {
                   return copy;
                 })();
                 entry.promptActive = true;
+                entry.goalTurnActive = false;
                 entry.activePromptId = pendingEntry.promptId;
                 delete entry.cancelBroadcastWithoutPrompt;
                 delete entry.turnError;
@@ -11554,25 +11949,7 @@ function createAcpSessionBridge(opts) {
         const shouldSettleMidTurnQueue = entry.pendingPromptCount === 1 && !entry.closing && byId.get(entry.sessionId) === entry;
         const undrainedMessages = shouldSettleMidTurnQueue ? entry.midTurnMessageQueue.splice(0) : [];
         releasePromptSlot();
-        for (const message of undrainedMessages) {
-          if (message.queueOnly) {
-            try {
-              message.onSettledWithoutDrain?.();
-            } catch (error) {
-              writeStderrLine(
-                `[mid-turn] session=${JSON.stringify(entry.sessionId)} failed to hand undrained queue-only message ${JSON.stringify(message.messageId)} back to its caller: ${JSON.stringify(error instanceof Error ? error.message : String(error))}`
-              );
-            }
-            continue;
-          }
-          promoteMidTurnMessage(
-            entry,
-            message.messageId,
-            message.text,
-            message.originatorClientId,
-            message.content
-          );
-        }
+        settleUndrainedMidTurnMessages(entry, undrainedMessages);
         void maybeCloseIdleSession(entry, "prompt_settled");
       }).catch(() => {
       });
@@ -11818,6 +12195,21 @@ function createAcpSessionBridge(opts) {
             );
           }
           markSessionCatalogChanged();
+          if (opts.sessionAttachmentsRoot) {
+            const branchAttachments = new SessionAttachmentStore(
+              opts.sessionAttachmentsRoot,
+              result.newSessionId
+            );
+            try {
+              await branchAttachments.copyFrom(entry.attachments);
+            } catch (error) {
+              writeStderrLine(
+                `qwen serve: failed to copy attachments for branched session ${result.newSessionId}: ${error instanceof Error ? error.message : String(error)}`
+              );
+            } finally {
+              await branchAttachments.close();
+            }
+          }
           const rawBranchName = result.displayName ?? result.title;
           const branchDisplayName = typeof rawBranchName === "string" ? rawBranchName : result.newSessionId.slice(0, 8);
           if (!restoreBranch) {
@@ -11884,6 +12276,15 @@ function createAcpSessionBridge(opts) {
             throw restoreErr;
           }
           const newEntry = byId.get(result.newSessionId);
+          if (newEntry && !opts.sessionAttachmentsRoot) {
+            try {
+              await newEntry.attachments.copyFrom(entry.attachments);
+            } catch (error) {
+              writeStderrLine(
+                `qwen serve: failed to copy attachments for branched session ${result.newSessionId}: ${error instanceof Error ? error.message : String(error)}`
+              );
+            }
+          }
           if (newEntry) newEntry.displayName = branchDisplayName;
           let sourcePersisted;
           if (newEntry?.sourceType) {
@@ -12429,6 +12830,18 @@ function createAcpSessionBridge(opts) {
         { taskId, taskKind }
       );
     },
+    async controlSessionGoal(sessionId, request, context) {
+      const entry = byId.get(sessionId);
+      if (!entry) throw new SessionNotFoundError(sessionId);
+      const info = channelInfoForEntry(entry);
+      if (!info || info.isDying) throw new SessionNotFoundError(sessionId);
+      resolveTrustedClientId(entry, context?.clientId);
+      return requestSessionStatus(
+        sessionId,
+        SERVE_CONTROL_EXT_METHODS.sessionGoalControl,
+        { request }
+      );
+    },
     async clearSessionGoal(sessionId) {
       return requestSessionStatus(
         sessionId,
@@ -12805,7 +13218,7 @@ function createAcpSessionBridge(opts) {
       const info = channelInfoForEntry(entry);
       if (!info || info.isDying) throw new SessionNotFoundError(sessionId);
       resolveTrustedClientId(entry, context?.clientId);
-      const requestId = randomUUID3();
+      const requestId = randomUUID2();
       const queue = new GenerationStreamQueue(
         GENERATION_STREAM_QUEUE_CAPACITY
       );
@@ -12939,42 +13352,27 @@ function createAcpSessionBridge(opts) {
       }
       return { sessionId, state: "idle" };
     },
-    async storeSessionMedia(sessionId, data, mimeType, context) {
+    async storeSessionAttachment(sessionId, data, mimeType, context, name) {
       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;
+      return await entry.attachments.putAttachment(data, mimeType, name);
     },
-    async readSessionMedia(sessionId, mediaId, context) {
+    async readSessionAttachment(sessionId, attachmentId, context) {
       const entry = byId.get(sessionId);
       if (!entry) throw new SessionNotFoundError(sessionId);
       resolveTrustedClientId(entry, context?.clientId);
-      return await entry.media.read(mediaId);
+      return await entry.attachments.read(attachmentId);
     },
-    async removeSessionMedia(sessionId, mediaId, context) {
+    async removeSessionAttachment(sessionId, attachmentId, context) {
       const entry = byId.get(sessionId);
       if (!entry) throw new SessionNotFoundError(sessionId);
       resolveTrustedClientId(entry, context?.clientId);
-      return await entry.media.remove(mediaId);
+      return await entry.attachments.remove(attachmentId);
+    },
+    async deleteSessionAttachments(sessionId) {
+      const store = byId.get(sessionId)?.attachments ?? new SessionAttachmentStore(opts.sessionAttachmentsRoot, sessionId);
+      await store.delete();
     },
     removePendingPrompt(sessionId, promptId, context) {
       const entry = byId.get(sessionId);
@@ -12994,7 +13392,6 @@ function createAcpSessionBridge(opts) {
       );
       if (target.state === "queued") {
         entry.pendingPromptList.splice(idx, 1);
-        removeQueuedMedia(entry, target.content);
       } else {
         target.removed = true;
       }
@@ -13021,7 +13418,7 @@ function createAcpSessionBridge(opts) {
       );
       const trimmed = message.trim();
       const mediaBlocks = (options?.content ?? []).filter(
-        (block) => block.type === "image"
+        (block) => block.type === "image" || block.type === "resource"
       );
       if (trimmed.length === 0 && mediaBlocks.length === 0) {
         writeStderrLine(
@@ -13047,10 +13444,10 @@ function createAcpSessionBridge(opts) {
           (pending) => pending.promptId === requestedMessageId
         );
         if (promoted) {
-          const promotedImages = (promoted.content ?? []).filter(
-            (block) => block.type === "image"
+          const promotedMedia = (promoted.content ?? []).filter(
+            (block) => block.type === "image" || block.type === "resource"
           );
-          const sameMedia = JSON.stringify(promotedImages) === JSON.stringify(mediaBlocks);
+          const sameMedia = JSON.stringify(promotedMedia) === JSON.stringify(mediaBlocks);
           const promotedText = promoted.text === "[image]" && trimmed.length === 0 ? "" : promoted.text;
           if (promotedText === trimmed && sameMedia) {
             return { accepted: true, messageId: requestedMessageId };
@@ -13073,23 +13470,23 @@ function createAcpSessionBridge(opts) {
         );
         return { accepted: false };
       }
-      entry.media.assertReferences(mediaBlocks);
-      const inlineBytes = inlineMediaBlockBytes(mediaBlocks);
+      entry.attachments.assertReferences(mediaBlocks);
+      const inlineBytes = inlineAttachmentBlockBytes(mediaBlocks);
       if (inlineBytes > 0) {
         const queuedInlineBytes = entry.midTurnMessageQueue.reduce(
-          (total, queued) => total + inlineMediaBlockBytes(queued.content ?? []),
+          (total, queued) => total + inlineAttachmentBlockBytes(queued.content ?? []),
           0
         );
-        if (queuedInlineBytes + inlineBytes > SESSION_MEDIA_MAX_TOTAL_BYTES) {
+        if (queuedInlineBytes + inlineBytes > MAX_QUEUED_INLINE_ATTACHMENT_BYTES) {
           writeStderrLine(
-            `[mid-turn] session=${entry.sessionId} rejected: queued inline media exceeds the ${SESSION_MEDIA_MAX_TOTAL_BYTES}-byte session budget`
+            `[mid-turn] session=${entry.sessionId} rejected: queued inline attachments exceed the ${MAX_QUEUED_INLINE_ATTACHMENT_BYTES}-byte session budget`
           );
           return { accepted: false };
         }
       }
-      const messageId = requestedMessageId ?? randomUUID3();
-      if (entry.pendingPromptCount === 0) {
-        if (options?.queueOnly) {
+      const messageId = requestedMessageId ?? randomUUID2();
+      if (entry.pendingPromptCount === 0 && entry.goalTurnActive !== true) {
+        if (options?.queueOnly || options?.rejectIfIdle) {
           writeStderrLine(
             `[mid-turn] session=${JSON.stringify(entry.sessionId)} rejected id ${JSON.stringify(messageId)}: session idle`
           );
@@ -13173,7 +13570,6 @@ 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",
@@ -13735,7 +14131,7 @@ function createAcpSessionBridge(opts) {
       ]);
     },
     generateWorkspaceContent(prompt, signal, _originatorClientId) {
-      const requestId = randomUUID3();
+      const requestId = randomUUID2();
       const queue = new GenerationStreamQueue(
         GENERATION_STREAM_QUEUE_CAPACITY
       );
@@ -13914,9 +14310,9 @@ function createAcpSessionBridge(opts) {
           closingChannel,
           `force kill closing session ${JSON.stringify(sessionId)}`
         );
-        await releaseSessionMedia(sessionId).catch((releaseError) => {
+        await entry.attachments.close().catch((releaseError) => {
           writeStderrLine(
-            `qwen serve: failed to release media for killed session ${JSON.stringify(sessionId)}: ${releaseError instanceof Error ? releaseError.message : String(releaseError)}`
+            `qwen serve: failed to close attachments for killed session ${JSON.stringify(sessionId)}: ${releaseError instanceof Error ? releaseError.message : String(releaseError)}`
           );
         });
         return true;
@@ -13946,11 +14342,6 @@ function createAcpSessionBridge(opts) {
             ci,
             `force kill session ${JSON.stringify(sessionId)}`
           );
-          await releaseSessionMedia(sessionId).catch((releaseError) => {
-            writeStderrLine(
-              `qwen serve: failed to release media for killed session ${JSON.stringify(sessionId)}: ${releaseError instanceof Error ? releaseError.message : String(releaseError)}`
-            );
-          });
           return true;
         }
         entry.closing = false;
@@ -13987,9 +14378,9 @@ function createAcpSessionBridge(opts) {
       } catch {
       }
       entry.events.close();
-      await releaseSessionMedia(sessionId).catch((error) => {
+      await entry.attachments.close().catch((error) => {
         writeStderrLine(
-          `qwen serve: failed to release media for killed session ${JSON.stringify(sessionId)}: ${error instanceof Error ? error.message : String(error)}`
+          `qwen serve: failed to close attachments for killed session ${JSON.stringify(sessionId)}: ${error instanceof Error ? error.message : String(error)}`
         );
       });
       if (ci && hasNoChannelWork(ci)) {
@@ -14096,8 +14487,7 @@ function createAcpSessionBridge(opts) {
         ) : Promise.resolve();
         const teardownResults = await Promise.allSettled([
           ...channels.map((ci) => ci.channel.kill()),
-          ...[...retainedMedia.values()].map((store) => store.close()),
-          mediaPutQueue,
+          ...[...byId.values()].map((entry) => entry.attachments.close()),
           ...inFlightSessionAwaits,
           ...inFlightRestoreAwaits,
           inFlightChannelAwait