@qwen-code/qwen-code 0.21.13 → 0.21.14-nightly.20260822.7a4566cb3b

package/chunks/{chunk-LJQAUZMR.js → chunk-7CPJMZVJ.js}

@@ -19,7 +19,7 @@ import {
 } from "./chunk-OCPBI7J5.js";
 import {
   defaultSpawnChannelFactory
-} from "./chunk-NHDR76JX.js";
+} from "./chunk-VMJL7RH6.js";
 import {
   BridgeChannelClosedError,
   BridgeTimeoutError,
@@ -29,7 +29,7 @@ import {
   SessionRestoreTimeoutError,
   createIdleWorkspaceExtensionsStatus,
   createIdleWorkspaceHooksStatus
-} from "./chunk-QNQAPSN2.js";
+} from "./chunk-URN2JIAQ.js";
 import {
   ACTIVE_WORK_CLOSE_IF_UNHELD_PARAM,
   ACTIVE_WORK_CLOSE_TIMEOUT_MS,
@@ -44,6 +44,7 @@ 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_MODEL_PROMPT_META_KEY,
   DAEMON_PROMPT_DISPLAY_TEXT_META_KEY,
@@ -64,7 +65,7 @@ import {
   clampActiveWorkIntervalMs,
   isValidTrustedModelPrompt,
   sessionCloseDrainBudgetMs
-} from "./chunk-S5DWMTHO.js";
+} from "./chunk-QQUVPMMZ.js";
 import {
   BranchWhilePromptActiveError,
   BridgeChannelQuarantinedError,
@@ -96,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,
@@ -109,10 +109,15 @@ 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,
   ShellExecutionService,
+  TURN_RESULT_CODE_TEXT_TRUNCATED,
+  TURN_RESULT_TEXT_MAX_CHARS,
   TrustGateError,
   WORKSPACE_CONTENT_MTIME_MS_METADATA_KEY,
   WORKSPACE_CONTENT_SHA256_METADATA_KEY,
@@ -120,17 +125,29 @@ import {
   isReservedWorkspaceMetadataKey,
   metadataBudgetBytes,
   normalizeSnapshotPayload,
+  normalizeTurnResultError,
   stableSessionArtifactId
-} from "./chunk-4S5337WV.js";
+} from "./chunk-SVU5KGR7.js";
+import {
+  MAX_DIRECTORY_ARTIFACT_DEPTH,
+  MAX_DIRECTORY_ARTIFACT_FILES,
+  collectRecordableWorkspaceFiles,
+  isOfficeDocumentExtension,
+  isRecordableDerivedChild,
+  pathHasSkippedDirectoryComponent
+} from "./chunk-TBVSALA3.js";
 import {
   DAEMON_TRACEPARENT_META_KEY,
   DAEMON_TRACESTATE_META_KEY
-} from "./chunk-TIGA2IVL.js";
+} from "./chunk-6S2OXVJT.js";
 import {
   INVOCATION_CONTEXT_META_KEY,
   PRIVATE_ACP_CAPABILITY_ENV,
   PRIVATE_PARENT_CAPABILITY_META_KEY
-} from "./chunk-RVOJ2FBP.js";
+} from "./chunk-RPJOOK6N.js";
+import {
+  getSpecificMimeType
+} from "./chunk-IWOWEENB.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -141,7 +158,7 @@ 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 * as path4 from "node:path";
 import { inspect } from "node:util";
 
 // packages/acp-bridge/src/compactionEngine.ts
@@ -1280,6 +1297,523 @@ function getChannelStartupProfileAttributes(response, receivedAtEpochMs, initial
 }
 __name(getChannelStartupProfileAttributes, "getChannelStartupProfileAttributes");
 
+// packages/acp-bridge/src/sessionAttachments.ts
+init_esbuild_shims();
+import { promises as fs, statSync } from "node:fs";
+import { tmpdir } from "node:os";
+import * as path from "node:path";
+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 = "SessionAttachmentReferenceError";
+  }
+  static {
+    __name(this, "SessionAttachmentReferenceError");
+  }
+};
+function isSessionAttachmentReference(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  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(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_ATTACHMENT_UNAVAILABLE_TEXT)) {
+        return [...blocks];
+      }
+      const next = [...blocks];
+      next[i] = {
+        type: "text",
+        text: `${block.text}
+${SESSION_ATTACHMENT_UNAVAILABLE_TEXT}`
+      };
+      return next;
+    }
+  }
+  return [
+    ...blocks,
+    { type: "text", text: SESSION_ATTACHMENT_UNAVAILABLE_TEXT }
+  ];
+}
+__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, "SessionAttachmentStore");
+  }
+  directoryPromise;
+  persistentDirectory;
+  activeDirectory;
+  pendingItems = 0;
+  pendingNames = /* @__PURE__ */ new Map();
+  pendingDrainWaiters = [];
+  copyDrainWaiters = [];
+  copying = false;
+  closing = false;
+  closed = false;
+  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");
+    }
+    const storedMimeType = mimeTypeForName(safeName);
+    if (isImage && storedMimeType !== mimeType || isSupportedImageMimeType(storedMimeType) && !isImage) {
+      throw new TypeError("Attachment name and Content-Type do not match");
+    }
+    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 (isImage && data.byteLength === 0 || data.byteLength > SESSION_ATTACHMENT_MAX_ITEM_BYTES) {
+      throw new RangeError(
+        `Session attachment must be at most ${SESSION_ATTACHMENT_MAX_ITEM_BYTES} bytes and images cannot be empty`
+      );
+    }
+    let filePath;
+    let pendingName = safeName;
+    let removeFileOnFailure = false;
+    this.pendingItems += 1;
+    this.reservePendingName(safeName);
+    try {
+      const directory = await this.directory();
+      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
+      };
+      return reference;
+    } catch (error) {
+      if (removeFileOnFailure && filePath) {
+        await fs.rm(filePath, { force: true }).catch(() => {
+        });
+      }
+      throw error;
+    } finally {
+      if (pendingName) this.releasePendingName(pendingName);
+      if (!this.closed) {
+        this.pendingItems -= 1;
+        if (this.pendingItems === 0) {
+          this.resolvePendingDrainWaiters();
+        }
+      }
+    }
+  }
+  // Validate one block against the store. Ordinary ACP content passes through
+  // untouched, matching `assertReferences`.
+  assertReference(block) {
+    if (!block || typeof block !== "object" || Array.isArray(block) || !("attachmentId" in block)) {
+      return;
+    }
+    if (!isSessionAttachmentReference(block)) {
+      throw new SessionAttachmentReferenceError(
+        "Invalid session attachment reference",
+        "invalid_session_attachment_reference"
+      );
+    }
+    this.assertStored(block);
+  }
+  assertReferences(content) {
+    const seenIds = /* @__PURE__ */ new Set();
+    for (const block of content) {
+      if (!block || typeof block !== "object" || Array.isArray(block) || !("attachmentId" in block)) {
+        continue;
+      }
+      if (!isSessionAttachmentReference(block)) {
+        throw new SessionAttachmentReferenceError(
+          "Invalid session attachment reference",
+          "invalid_session_attachment_reference"
+        );
+      }
+      const id = block.attachmentId;
+      if (seenIds.has(id)) {
+        throw new SessionAttachmentReferenceError(
+          `Session attachment referenced more than once: ${id}`,
+          "invalid_session_attachment_reference"
+        );
+      }
+      seenIds.add(id);
+      this.assertStored(block);
+    }
+  }
+  async resolveContent(content, memo) {
+    const pendingById = memo ?? /* @__PURE__ */ new Map();
+    return await Promise.all(
+      content.map(async (block) => {
+        if (!isSessionAttachmentReference(block)) return block;
+        const id = block.attachmentId;
+        let pending = pendingById.get(id);
+        if (!pending) {
+          const created = this.resolve(block);
+          pendingById.set(id, created);
+          void created.catch(() => {
+            if (pendingById.get(id) === created) {
+              pendingById.delete(id);
+            }
+          });
+          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. Other errors still propagate.
+  async resolveContentDegrading(content, memo) {
+    const retainedBlocks = [];
+    const resolvedBlocks = [];
+    let degraded = 0;
+    for (const block of content) {
+      if (!isSessionAttachmentReference(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 SessionAttachmentReferenceError)) throw error;
+        degraded += 1;
+      }
+    }
+    return { retainedBlocks, resolvedBlocks, degraded };
+  }
+  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(filePath),
+        mimeType: mimeTypeForName(name)
+      };
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return void 0;
+      }
+      throw error;
+    }
+  }
+  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();
+    }
+  }
+  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.pendingItems = 0;
+    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 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 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: "image",
+      data: attachment.data.toString("base64"),
+      mimeType: attachment.mimeType
+    };
+  }
+  async directory() {
+    if (!this.directoryPromise) {
+      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;
+      });
+    }
+    return await this.directoryPromise;
+  }
+};
+
 // packages/acp-bridge/src/internal/stderrLine.ts
 init_esbuild_shims();
 function writeStderrLine(message) {
@@ -1291,8 +1825,8 @@ __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 { promises as fs2 } from "node:fs";
+import * as path2 from "node:path";
 
 // packages/acp-bridge/src/daemonEventTypes.ts
 init_esbuild_shims();
@@ -2278,7 +2812,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, onGoalTurnEnded) {
     this.resolveEntry = resolveEntry;
     this.resolvePendingRestoreEvents = resolvePendingRestoreEvents;
     this.mediator = mediator;
@@ -2300,6 +2834,8 @@ var BridgeClient = class {
     this.getLiveSpeakToUserHandler = getLiveSpeakToUserHandler;
     this.externalToolGuard = externalToolGuard;
     this.onActiveWork = onActiveWork;
+    this.onSessionCatalogChanged = onSessionCatalogChanged;
+    this.onGoalTurnEnded = onGoalTurnEnded;
   }
   static {
     __name(this, "BridgeClient");
@@ -2564,8 +3100,8 @@ var BridgeClient = class {
    * between tool batches to pull any messages the browser queued mid-turn. We splice the per-session
    * queue, return them to the child as the response, and — when non-empty —
    * publish a `mid_turn_message_injected` SSE frame so the browser can move
-   * those messages out of its pending queue (a dedupe signal, not a transcript
-   * render). Unknown methods reject with ACP `methodNotFound` (-32601), matching
+   * those messages out of its pending queue and render the immediate echo.
+   * Unknown methods reject with ACP `methodNotFound` (-32601), matching
    * the SDK's
    * default for an unimplemented client surface; the child's drain caller
    * treats that as "drain unsupported" and stops asking.
@@ -2599,9 +3135,12 @@ var BridgeClient = class {
       throw RequestError.methodNotFound(method);
     }
     const sessionId = typeof params["sessionId"] === "string" ? params["sessionId"] : void 0;
-    if (!sessionId) return { messages: [], hasQueuedPrompt: false };
+    if (!sessionId) return { messages: [], items: [], hasQueuedPrompt: false };
+    if (!this.ownsSession(sessionId)) {
+      return { messages: [], items: [], hasQueuedPrompt: false };
+    }
     const entry = this.resolveEntry(sessionId);
-    if (!entry) return { messages: [], hasQueuedPrompt: false };
+    if (!entry) return { messages: [], items: [], hasQueuedPrompt: false };
     const drained = entry.midTurnMessageQueue.splice(0);
     if (drained.length > 0) {
       for (const item of drained) {
@@ -2614,6 +3153,67 @@ var BridgeClient = class {
         );
       }
     }
+    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 (!isSessionAttachmentReference(block)) return true;
+          if (serializedAttachmentIds.has(block.attachmentId)) {
+            degraded += 1;
+            return false;
+          }
+          serializedAttachmentIds.add(block.attachmentId);
+          return true;
+        });
+        let resolvedBlocks;
+        let attachmentReferences;
+        try {
+          resolvedBlocks = await entry.attachments.resolveContent(
+            planned,
+            attachmentMemo
+          );
+          attachmentReferences = planned.filter(isSessionAttachmentReference);
+        } catch (error) {
+          if (!(error instanceof SessionAttachmentReferenceError)) throw error;
+          writeStderrLine(
+            `[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.attachments.resolveContentDegrading(
+            planned,
+            attachmentMemo
+          );
+          resolvedBlocks = perBlock.resolvedBlocks;
+          attachmentReferences = perBlock.retainedBlocks.filter(
+            isSessionAttachmentReference
+          );
+          degraded += perBlock.degraded;
+        }
+        let content = [
+          ...item.text ? [{ type: "text", text: item.text }] : [],
+          ...resolvedBlocks
+        ];
+        if (degraded > 0) content = withAttachmentDegradationMarker(content);
+        items.push({
+          messageId: item.messageId,
+          displayText: item.text,
+          content,
+          ...attachmentReferences.length > 0 ? { attachmentReferences } : {}
+        });
+      }
+    } catch (error) {
+      const requeued = new Set(drained.map((queued) => queued.messageId));
+      const ring = entry.settledMidTurnMessageIds;
+      const kept = ring.filter((id) => !requeued.has(id));
+      ring.splice(0, ring.length, ...kept);
+      entry.midTurnMessageQueue.unshift(...drained);
+      writeStderrLine(
+        `[mid-turn] session=${JSON.stringify(entry.sessionId)} drain failed, requeued ${drained.length} message(s): ${JSON.stringify(error instanceof Error ? error.message : String(error))}`
+      );
+      throw error;
+    }
     const echoed = drained.filter((item) => !item.queueOnly);
     const messages = drained.map((item) => item.text);
     const hasQueuedPrompt = entry.pendingPromptList.some(
@@ -2626,14 +3226,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) {
@@ -3022,7 +3629,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.
@@ -3045,14 +3652,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 }
@@ -3160,6 +3792,7 @@ var BridgeClient = class {
         return;
       const entry = this.resolveEntry(sessionId2);
       if (!entry) return;
+      this.onSessionCatalogChanged?.();
       try {
         entry.events.publish({
           type: "session_metadata_updated",
@@ -3291,6 +3924,13 @@ var BridgeClient = class {
   async upsertAndPublishArtifacts(entry, artifacts, options, turn = {}) {
     try {
       const result = await entry.artifacts.upsertMany(artifacts, options);
+      for (const warning of result.warnings ?? []) {
+        writeStderrLine(
+          `[artifacts] session=${entry.sessionId} action=warning reason=${JSON.stringify(
+            warning
+          )}`
+        );
+      }
       this.publishArtifactChanges(entry, result.changes, turn);
     } catch (error) {
       writeStderrLine(
@@ -3602,20 +4242,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`;
     let preserveMode;
     try {
-      const targetStat = await fs.stat(realTarget);
+      const targetStat = await fs2.stat(realTarget);
       preserveMode = {
         mode: targetStat.mode & 4095,
         uid: targetStat.uid,
@@ -3626,20 +4266,20 @@ var BridgeClient = class {
       if (code !== "ENOENT") throw err;
     }
     try {
-      await fs.writeFile(tmp, params.content, {
+      await fs2.writeFile(tmp, params.content, {
         encoding: "utf8",
         flag: "wx",
         mode: preserveMode?.mode ?? 384
       });
       if (preserveMode) {
-        await fs.chmod(tmp, preserveMode.mode).catch(() => {
+        await fs2.chmod(tmp, preserveMode.mode).catch(() => {
         });
-        await fs.chown(tmp, preserveMode.uid, preserveMode.gid).catch(() => {
+        await fs2.chown(tmp, preserveMode.uid, preserveMode.gid).catch(() => {
         });
       }
-      await fs.rename(tmp, realTarget);
+      await fs2.rename(tmp, realTarget);
     } catch (err) {
-      await fs.unlink(tmp).catch(() => {
+      await fs2.unlink(tmp).catch(() => {
       });
       throw err;
     }
@@ -3669,7 +4309,7 @@ var BridgeClient = class {
       );
     }
     const READ_FILE_SIZE_CAP = 100 * 1024 * 1024;
-    const stats = await fs.stat(params.path);
+    const stats = await fs2.stat(params.path);
     if (!stats.isFile()) {
       throw new Error(
         `readTextFile: ${params.path} is not a regular file (reported as ${describeStatKind(stats)}). Pipe / device / proc-like inputs can produce unbounded data and aren't supported by the bridge fs proxy.`
@@ -3680,7 +4320,7 @@ var BridgeClient = class {
         `readTextFile: ${params.path} is ${stats.size} bytes, exceeds the ${READ_FILE_SIZE_CAP}-byte daemon cap. Tail/grep externally and feed the relevant slice instead.`
       );
     }
-    const content = await fs.readFile(params.path, "utf8");
+    const content = await fs2.readFile(params.path, "utf8");
     if (typeof params.line === "number" || typeof params.limit === "number") {
       const startLine = params.line ?? 1;
       const start = startLine > 0 ? startLine - 1 : 0;
@@ -3882,8 +4522,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,
@@ -3993,13 +4633,31 @@ var SessionArtifactStore = class {
       const warningDetails = [];
       for (const input of inputs) {
         try {
-          normalizedResults.push(
-            await this.normalizeInput(
-              input,
-              ++this.receivedSeq,
-              options.trustedPublisher === true
-            )
-          );
+          const expanded = await this.expandWorkspaceDirectoryInput(input);
+          for (const item of expanded.inputs) {
+            try {
+              normalizedResults.push(
+                await this.normalizeInput(
+                  item,
+                  ++this.receivedSeq,
+                  options.trustedPublisher === true
+                )
+              );
+            } catch (error) {
+              if (validationStrict) {
+                throw error;
+              }
+              const message = error instanceof Error ? error.message : String(error);
+              writeStderrLine(
+                `[artifacts] session=${this.sessionId} action=dropped reason=${JSON.stringify(
+                  message
+                )}`
+              );
+            }
+          }
+          if (expanded.warning) {
+            warnings.push(expanded.warning);
+          }
         } catch (error) {
           if (validationStrict) {
             throw error;
@@ -4083,9 +4741,17 @@ var SessionArtifactStore = class {
         const createdIds = new Set(
           changes.filter((change) => change.action === "created").map((change) => change.artifactId)
         );
-        changes.push(
-          ...await this.evictOverflow(createdIds, changes, persistenceStrict)
+        const overflowRemoved = await this.evictOverflow(
+          createdIds,
+          changes,
+          persistenceStrict
         );
+        changes.push(...overflowRemoved.removed);
+        if (overflowRemoved.droppedCreated > 0) {
+          warnings.push(
+            `dropped ${overflowRemoved.droppedCreated} newly created artifacts because the store is full`
+          );
+        }
         const hasStrictDurableTransition = changes.some(
           shouldCommitBeforeDurablePersistence
         );
@@ -4371,9 +5037,9 @@ var SessionArtifactStore = class {
         });
       }
       const evicted = await this.evictOverflow(/* @__PURE__ */ new Set(), []);
-      if (evicted.length > 0) {
+      if (evicted.removed.length > 0) {
         warnings.push("restored artifact list pruned to live limit");
-        warnings.push(...await this.persistChanges(evicted, false));
+        warnings.push(...await this.persistChanges(evicted.removed, false));
       }
       this.setLastRestoreWarnings(warnings);
       return warnings;
@@ -4758,6 +5424,171 @@ var SessionArtifactStore = class {
       options?.clientId
     );
   }
+  async expandWorkspaceDirectoryInput(input) {
+    const workspacePath = typeof input.workspacePath === "string" ? input.workspacePath.trim() : void 0;
+    if (!workspacePath) {
+      return { inputs: [input] };
+    }
+    const realWorkspace = await this.getRealWorkspaceCwdForValidation();
+    const normalizedPath = normalizeWorkspacePath(workspacePath, realWorkspace);
+    const absolutePath = path3.resolve(realWorkspace, normalizedPath);
+    let stat;
+    try {
+      stat = await fs3.lstat(absolutePath);
+    } catch (error) {
+      if (isNotFoundError(error)) {
+        return { inputs: [input] };
+      }
+      const reason = error instanceof Error ? error.message : String(error);
+      throw new SessionArtifactValidationError(
+        `workspacePath could not be inspected: ${reason}`,
+        "workspacePath"
+      );
+    }
+    let walkDir = absolutePath;
+    let walkRelative = normalizedPath;
+    if (stat.isSymbolicLink()) {
+      let realPath;
+      try {
+        realPath = await fs3.realpath(absolutePath);
+      } catch {
+        return { inputs: [input] };
+      }
+      let realStat;
+      try {
+        realStat = await fs3.lstat(realPath);
+      } catch (error) {
+        if (isNotFoundError(error)) {
+          return { inputs: [input] };
+        }
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new SessionArtifactValidationError(
+          `workspacePath could not be inspected: ${reason}`,
+          "workspacePath"
+        );
+      }
+      if (!realStat.isDirectory()) {
+        return { inputs: [input] };
+      }
+      walkDir = realPath;
+      walkRelative = normalizedPath;
+    } else if (!stat.isDirectory()) {
+      return { inputs: [input] };
+    } else {
+      try {
+        walkDir = await fs3.realpath(absolutePath);
+      } catch (error) {
+        if (isNotFoundError(error)) {
+          return { inputs: [input] };
+        }
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new SessionArtifactValidationError(
+          `workspacePath could not be inspected: ${reason}`,
+          "workspacePath"
+        );
+      }
+    }
+    const resolvedRelative = path3.relative(realWorkspace, walkDir);
+    if (!resolvedRelative || isOutsidePath(resolvedRelative)) {
+      throw new SessionArtifactValidationError(
+        "workspacePath must stay inside the workspace",
+        "workspacePath"
+      );
+    }
+    if (pathHasSkippedDirectoryComponent(
+      resolvedRelative.split(path3.sep).join("/")
+    ) || walkRelative && pathHasSkippedDirectoryComponent(walkRelative)) {
+      throw new SessionArtifactValidationError(
+        "workspacePath is a skipped directory and cannot be recorded",
+        "workspacePath"
+      );
+    }
+    if (input.metadata !== void 0 && !isPlainMetadataObject(input.metadata)) {
+      throw new SessionArtifactValidationError(
+        "metadata must be an object",
+        "metadata"
+      );
+    }
+    const childMetadata = {
+      ...isPlainMetadataObject(input.metadata) ? input.metadata : {},
+      expandedFromDirectory: true
+    };
+    if (Buffer.byteLength(JSON.stringify(childMetadata), "utf8") > 4096) {
+      throw new SessionArtifactValidationError(
+        "metadata is too large to expand a directory",
+        "metadata"
+      );
+    }
+    const parentTitle = normalizeString(input.title, "title", 200, true);
+    const parentDescription = normalizeString(
+      input.description,
+      "description",
+      1e3,
+      false
+    );
+    let collected;
+    try {
+      collected = await collectRecordableWorkspaceFiles(
+        walkDir,
+        walkRelative,
+        realWorkspace,
+        (filePath) => isRecordableDerivedChild(path3.posix.basename(filePath), filePath)
+      );
+    } catch (error) {
+      if (isNotFoundError(error)) {
+        return { inputs: [input] };
+      }
+      const reason = error instanceof Error ? error.message : String(error);
+      throw new SessionArtifactValidationError(
+        `workspacePath could not be inspected: ${reason}`,
+        "workspacePath"
+      );
+    }
+    if (collected.files.length === 0) {
+      throw new SessionArtifactValidationError(
+        collected.depthLimited ? `workspacePath is a directory whose recordable files are deeper than ${MAX_DIRECTORY_ARTIFACT_DEPTH} levels` : "workspacePath is a directory with no recordable files",
+        "workspacePath"
+      );
+    }
+    const warnings = [];
+    if (collected.truncated) {
+      warnings.push(
+        `workspacePath "${normalizedPath}" contained more than ${MAX_DIRECTORY_ARTIFACT_FILES} files; recorded the first ${collected.files.length}`
+      );
+    }
+    if (collected.depthLimited) {
+      warnings.push(
+        `workspacePath "${normalizedPath}" exceeded ${MAX_DIRECTORY_ARTIFACT_DEPTH} directory levels; some files were not recorded`
+      );
+    }
+    if (collected.unreadable) {
+      warnings.push(
+        `workspacePath "${normalizedPath}" contained subdirectories that could not be read`
+      );
+    }
+    if (collected.skippedUnrecordable > 0) {
+      warnings.push(
+        `workspacePath "${normalizedPath}" skipped ${collected.skippedUnrecordable} files whose names cannot be recorded as artifact titles`
+      );
+    }
+    return {
+      inputs: collected.files.map((filePath) => {
+        const title = path3.posix.basename(filePath).trim();
+        const description = parentDescription || (parentTitle && parentTitle !== title ? parentTitle : void 0);
+        return {
+          ...input,
+          title,
+          workspacePath: filePath,
+          kind: void 0,
+          mimeType: void 0,
+          sizeBytes: void 0,
+          metadata: childMetadata,
+          ...description ? { description } : { description: void 0 }
+        };
+      }),
+      ...warnings.length > 0 ? { warning: warnings.join("; ") } : {}
+    };
+  }
   async normalizeInput(input, receivedSeq, trustedPublisherFromCaller, options = {}) {
     if (!input || typeof input !== "object") {
       throw new SessionArtifactValidationError("Artifact must be an object");
@@ -4954,7 +5785,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;
         }
@@ -4978,7 +5809,7 @@ var SessionArtifactStore = class {
   async evictOverflow(createdIds, changes, strict = false) {
     const removed = [];
     if (this.artifacts.size <= this.maxArtifacts) {
-      return removed;
+      return { removed, droppedCreated: 0 };
     }
     const createdInThisBatch = new Set(createdIds);
     const candidates = Array.from(this.artifacts.values()).filter(
@@ -5014,17 +5845,19 @@ var SessionArtifactStore = class {
         "artifactId"
       );
     }
+    let droppedCreated = 0;
     for (const artifact of overflowCreated) {
       if (this.artifacts.size <= this.maxArtifacts) {
         break;
       }
       this.artifacts.delete(artifact.id);
+      droppedCreated++;
       writeStderrLine(
         `[artifacts] session=${this.sessionId} action=dropped reason="max artifacts exceeded" artifactId=${artifact.id}`
       );
       removePriorChange(changes, artifact.id);
     }
-    return removed;
+    return { removed, droppedCreated };
   }
 };
 function coalesceByIdentity(artifacts) {
@@ -5074,11 +5907,19 @@ function mergeBatchArtifact(existing, next) {
     delete merged.workspacePath;
     return merged;
   }
+  const refreshDisplay = existing.storage === "workspace" && next.storage === "workspace" && shouldRefreshWorkspaceDisplay(next, existing);
+  const metadata = mergeMetadata(existing, next);
   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),
+    metadata: refreshDisplay ? stripExpandedFromDirectoryMarker(metadata) : metadata,
     clientRetained: existing.clientRetained || next.clientRetained,
     trustedPublisher: existing.trustedPublisher || next.trustedPublisher,
     retentionExplicit: existing.retentionExplicit || next.retentionExplicit,
@@ -5122,6 +5963,14 @@ 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;
+    next.metadata = stripExpandedFromDirectoryMarker(next.metadata);
   }
   const changed = !publicArtifactsEqual(
     toPublicArtifact(existing),
@@ -5130,13 +5979,34 @@ function mergeArtifact(existing, incoming) {
   if (changed) {
     next.updatedAt = now;
   }
-  return { artifact: changed ? next : existing, changed };
-}
-__name(mergeArtifact, "mergeArtifact");
-function shouldRecordEphemeralUnpin(existing, incoming) {
-  return incoming.retentionExplicit && incoming.retention === "ephemeral" && (existing.retention !== "ephemeral" || existing.persistedAt !== void 0 || existing.durableTombstoneRequired === true);
+  return { artifact: changed ? next : existing, changed };
+}
+__name(mergeArtifact, "mergeArtifact");
+function shouldRecordEphemeralUnpin(existing, incoming) {
+  return incoming.retentionExplicit && incoming.retention === "ephemeral" && (existing.retention !== "ephemeral" || existing.persistedAt !== void 0 || existing.durableTombstoneRequired === true);
+}
+__name(shouldRecordEphemeralUnpin, "shouldRecordEphemeralUnpin");
+function stripExpandedFromDirectoryMarker(metadata) {
+  if (metadata?.["expandedFromDirectory"] !== true) {
+    return metadata;
+  }
+  const { expandedFromDirectory: _dropped, ...rest } = metadata;
+  return Object.keys(rest).length > 0 ? rest : void 0;
+}
+__name(stripExpandedFromDirectoryMarker, "stripExpandedFromDirectoryMarker");
+function shouldRefreshWorkspaceDisplay(incoming, existing) {
+  if (incoming.metadata?.["expandedFromDirectory"] === true) {
+    return false;
+  }
+  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(shouldRecordEphemeralUnpin, "shouldRecordEphemeralUnpin");
+__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;
 }
@@ -5518,7 +6388,7 @@ function inferStorage(requested, locators) {
 }
 __name(inferStorage, "inferStorage");
 function normalizeKind(kind) {
-  if (kind === "file" || kind === "link" || kind === "html" || kind === "image" || kind === "video" || kind === "audio" || kind === "pdf" || kind === "notebook" || kind === "other") {
+  if (kind === "file" || kind === "link" || kind === "html" || kind === "image" || kind === "video" || kind === "audio" || kind === "pdf" || kind === "notebook" || kind === "document" || kind === "other") {
     return kind;
   }
   throw new SessionArtifactValidationError(
@@ -5589,7 +6459,7 @@ function buildIdentityKey(input) {
 }
 __name(buildIdentityKey, "buildIdentityKey");
 function managedIdForWorkspacePath(workspaceCwd, workspacePath) {
-  return createHash("sha1").update(path2.resolve(workspaceCwd, workspacePath)).digest("hex").slice(0, 16);
+  return createHash("sha1").update(path3.resolve(workspaceCwd, workspacePath)).digest("hex").slice(0, 16);
 }
 __name(managedIdForWorkspacePath, "managedIdForWorkspacePath");
 function normalizeString(value, field, maxLength, required) {
@@ -5636,7 +6506,7 @@ __name(normalizeString, "normalizeString");
 function normalizeManagedId(value) {
   const managedId = normalizeString(value, "managedId", 200, false);
   if (!managedId) return void 0;
-  if (managedId.includes("/") || managedId.includes("\\") || managedId.includes("..") || path2.isAbsolute(managedId) || path2.win32.isAbsolute(managedId)) {
+  if (managedId.includes("/") || managedId.includes("\\") || managedId.includes("..") || path3.isAbsolute(managedId) || path3.win32.isAbsolute(managedId)) {
     throw new SessionArtifactValidationError(
       "managedId must be an opaque managed resource id",
       "managedId"
@@ -5670,21 +6540,21 @@ function hasUnsafeDisplayPayload(value) {
 __name(hasUnsafeDisplayPayload, "hasUnsafeDisplayPayload");
 function normalizeWorkspacePath(raw, workspaceCwd) {
   const trimmed = normalizeString(raw, "workspacePath", 500, true);
-  if (path2.isAbsolute(trimmed)) {
+  if (path3.isAbsolute(trimmed)) {
     throw new SessionArtifactValidationError(
       "workspacePath must be relative to the workspace",
       "workspacePath"
     );
   }
-  const absolute = path2.resolve(workspaceCwd, trimmed);
-  const relative = path2.relative(workspaceCwd, absolute);
+  const absolute = path3.resolve(workspaceCwd, trimmed);
+  const relative = path3.relative(workspaceCwd, absolute);
   if (!relative || isOutsidePath(relative)) {
     throw new SessionArtifactValidationError(
       "workspacePath must stay inside the workspace",
       "workspacePath"
     );
   }
-  return relative.split(path2.sep).join("/");
+  return relative.split(path3.sep).join("/");
 }
 __name(normalizeWorkspacePath, "normalizeWorkspacePath");
 function normalizeArtifactUrl(raw, allowFile) {
@@ -5885,7 +6755,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";
@@ -5894,20 +6764,21 @@ function inferKind(input) {
   if ([".mp3", ".wav", ".m4a", ".ogg"].includes(ext)) return "audio";
   if (ext === ".pdf") return "pdf";
   if (ext === ".ipynb") return "notebook";
+  if (isOfficeDocumentExtension(ext)) return "document";
   return input.workspacePath ? "file" : "other";
 }
 __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
     );
@@ -5916,56 +6787,54 @@ async function getWorkspaceStatus(workspacePath, realWorkspaceCwd, expected, opt
       if (!isSameFile(preOpenStat, stat)) {
         return { status: "missing", escaped: true };
       }
-      if (stat.isFile()) {
-        const expectedMtimeMs = typeof expected?.mtimeMs === "number" ? expected.mtimeMs : void 0;
-        const expectedSha256 = typeof expected?.sha256 === "string" ? expected.sha256 : void 0;
-        const unchanged = expected?.sizeBytes === stat.size && expectedMtimeMs === stat.mtimeMs;
-        const sizeChanged = expected?.sizeBytes !== void 0 && expected.sizeBytes !== stat.size;
-        if (sizeChanged) {
-          return {
-            status: "changed",
-            sizeBytes: stat.size,
-            mtimeMs: stat.mtimeMs
-          };
-        }
-        if (unchanged) {
-          return {
-            status: "available",
-            sizeBytes: stat.size,
-            mtimeMs: stat.mtimeMs
-          };
-        }
-        if (stat.size > MAX_WORKSPACE_HASH_BYTES) {
-          return {
-            status: expectedSha256 ? "changed" : "available",
-            sizeBytes: stat.size,
-            mtimeMs: stat.mtimeMs
-          };
-        }
-        if (!options.hashContent) {
-          return {
-            status: expectedSha256 ? "changed" : "available",
-            sizeBytes: stat.size,
-            mtimeMs: stat.mtimeMs
-          };
-        }
-        const sha256 = await hashFile(handle);
-        if (expectedSha256 && sha256 !== expectedSha256) {
-          return {
-            status: "changed",
-            sizeBytes: stat.size,
-            mtimeMs: stat.mtimeMs
-          };
-        }
+      if (!stat.isFile()) {
+        throw new Error("path is not a regular file");
+      }
+      const expectedMtimeMs = typeof expected?.mtimeMs === "number" ? expected.mtimeMs : void 0;
+      const expectedSha256 = typeof expected?.sha256 === "string" ? expected.sha256 : void 0;
+      const unchanged = expected?.sizeBytes === stat.size && expectedMtimeMs === stat.mtimeMs;
+      const sizeChanged = expected?.sizeBytes !== void 0 && expected.sizeBytes !== stat.size;
+      if (sizeChanged) {
+        return {
+          status: "changed",
+          sizeBytes: stat.size,
+          mtimeMs: stat.mtimeMs
+        };
+      }
+      if (unchanged) {
         return {
           status: "available",
           sizeBytes: stat.size,
-          mtimeMs: stat.mtimeMs,
-          sha256
+          mtimeMs: stat.mtimeMs
+        };
+      }
+      if (stat.size > MAX_WORKSPACE_HASH_BYTES) {
+        return {
+          status: expectedSha256 ? "changed" : "available",
+          sizeBytes: stat.size,
+          mtimeMs: stat.mtimeMs
+        };
+      }
+      if (!options.hashContent) {
+        return {
+          status: expectedSha256 ? "changed" : "available",
+          sizeBytes: stat.size,
+          mtimeMs: stat.mtimeMs
+        };
+      }
+      const sha256 = await hashFile(handle);
+      if (expectedSha256 && sha256 !== expectedSha256) {
+        return {
+          status: "changed",
+          sizeBytes: stat.size,
+          mtimeMs: stat.mtimeMs
         };
       }
       return {
-        status: "available"
+        status: "available",
+        sizeBytes: stat.size,
+        mtimeMs: stat.mtimeMs,
+        sha256
       };
     } finally {
       await handle.close();
@@ -6021,14 +6890,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;
@@ -6051,6 +6920,10 @@ function isNotFoundError(error) {
   return code === "ENOENT" || code === "ENOTDIR";
 }
 __name(isNotFoundError, "isNotFoundError");
+function isPlainMetadataObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isPlainMetadataObject, "isPlainMetadataObject");
 function isNoFollowSymlinkError(error) {
   if (typeof error !== "object" || error === null || !("code" in error)) {
     return false;
@@ -6059,7 +6932,7 @@ function isNoFollowSymlinkError(error) {
 }
 __name(isNoFollowSymlinkError, "isNoFollowSymlinkError");
 function isOutsidePath(relative) {
-  return relative === ".." || relative.startsWith(`..${path2.sep}`) || path2.isAbsolute(relative);
+  return relative === ".." || relative.startsWith(`..${path3.sep}`) || path3.isAbsolute(relative);
 }
 __name(isOutsidePath, "isOutsidePath");
 
@@ -6866,6 +7739,107 @@ 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 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(
@@ -6874,8 +7848,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)) {
@@ -6941,16 +7923,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" || block.type === "resource" && "attachmentId" in block) {
+      media.push(block);
+    }
+  }
+  return media.length > 0 ? media : void 0;
+}
+__name(extractMediaBlocks, "extractMediaBlocks");
 var DEFAULT_INIT_TIMEOUT_MS = 1e4;
 var PERSIST_TIMEOUT_MS = 5e3;
 var MAX_PARENT_PERSIST_ATTEMPTS = 3;
@@ -6968,6 +8043,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 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 += 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;
+}
+__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;
@@ -7034,7 +8125,17 @@ function createAcpSessionBridge(opts) {
       );
     }
   }, "releaseFreshSessionReservation");
+  const sessionCatalogGeneration = randomUUID2();
+  let sessionCatalogRevision = 0;
+  const getSessionCatalogVersion = /* @__PURE__ */ __name(() => ({
+    generation: sessionCatalogGeneration,
+    revision: sessionCatalogRevision
+  }), "getSessionCatalogVersion");
+  const markSessionCatalogChanged = /* @__PURE__ */ __name(() => {
+    sessionCatalogRevision += 1;
+  }, "markSessionCatalogChanged");
   const emitSessionLifecycle = /* @__PURE__ */ __name((event) => {
+    markSessionCatalogChanged();
     try {
       opts.sessionLifecycle?.(event);
     } catch (err) {
@@ -7104,7 +8205,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.`
     );
@@ -7444,10 +8545,7 @@ function createAcpSessionBridge(opts) {
   }
   __name(withWorkspaceControl, "withWorkspaceControl");
   function startSessionReaper() {
-    if (sessionReapIntervalMs <= 0 || sessionIdleTimeoutMs <= 0) {
-      writeStderrLine("qwen serve: session reaper disabled");
-      return;
-    }
+    if (sessionReapIntervalMs <= 0) return;
     writeStderrLine(
       `qwen serve: session reaper started (interval ${sessionReapIntervalMs}ms, idle threshold ${sessionIdleTimeoutMs}ms)`
     );
@@ -7455,6 +8553,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;
@@ -7552,12 +8651,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,
@@ -7800,7 +8900,13 @@ 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,
+          // 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,
@@ -7938,6 +9044,11 @@ function createAcpSessionBridge(opts) {
             touchActivity();
           }
           byId.delete(sid);
+          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",
@@ -8685,6 +9796,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 () => {
@@ -8701,6 +9847,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(
@@ -8720,6 +9868,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.
@@ -8975,13 +10127,21 @@ function createAcpSessionBridge(opts) {
         workspaceCwd,
         persistence: createSessionArtifactPersistence(ci.connection, 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(),
+      rewindGeneration: 0,
       midTurnMessageQueue: [],
       settledMidTurnMessageIds: [],
       promotedMidTurnMessageIds: [],
@@ -9395,7 +10555,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 } : {}
       };
@@ -9477,7 +10637,7 @@ function createAcpSessionBridge(opts) {
         attached: true,
         clientId,
         createdAt: entry.createdAt,
-        hasActivePrompt: entry.promptActive,
+        hasActivePrompt: entry.promptActive || entry.goalTurnActive === true,
         ...waiterReplayFields ?? {}
       };
     }
@@ -9840,7 +11000,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)
         };
       }
@@ -9916,7 +11076,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 () => {
@@ -9931,6 +11091,11 @@ function createAcpSessionBridge(opts) {
         const restoreEntry = byId.get(req.sessionId);
         if (restoreEntry?.events === restoreEvents) {
           byId.delete(req.sessionId);
+          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",
@@ -10094,6 +11259,11 @@ function createAcpSessionBridge(opts) {
     } catch {
     }
     entry.events.close();
+    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(
@@ -10122,30 +11292,102 @@ 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 promoteMidTurnMessage = /* @__PURE__ */ __name((entry, messageId, text, originatorClientId, content) => {
+    const resolvableBlocks = [];
+    let degraded = 0;
+    for (const block of content ?? []) {
+      try {
+        entry.attachments.assertReference(block);
+        resolvableBlocks.push(block);
+      } catch (error) {
+        if (!(error instanceof SessionAttachmentReferenceError)) throw error;
+        degraded += 1;
+      }
+    }
+    let prompt = [
+      ...text ? [{ type: "text", text }] : [],
+      ...resolvableBlocks
+    ];
+    if (degraded > 0) {
+      prompt = withAttachmentDegradationMarker(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: withAttachmentDegradationMarker(
+          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 SessionAttachmentReferenceError)) 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))}`
       );
     });
   }, "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;
@@ -10188,7 +11430,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 } : {},
@@ -10341,7 +11583,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);
@@ -10392,7 +11634,7 @@ function createAcpSessionBridge(opts) {
             ...session,
             attached: true,
             clientId,
-            hasActivePrompt: attachedEntry.promptActive
+            hasActivePrompt: attachedEntry.promptActive || attachedEntry.goalTurnActive === true
           };
         }
       }
@@ -10490,9 +11732,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.attachments.assertReferences(req.prompt);
       const modelPrompt = context?.modelPrompt;
       if (modelPrompt !== void 0 && !isValidTrustedModelPrompt(modelPrompt)) {
         throw new TypeError(
@@ -10549,10 +11797,27 @@ function createAcpSessionBridge(opts) {
         ...originatorClientId !== void 0 ? { originatorClientId } : {},
         ...isPromotedMidTurn ? { promotedMidTurn: true } : {},
         text: pendingText,
+        content: extractMediaBlocks(req.prompt),
         abortController: pendingAbort,
         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) {
@@ -10641,6 +11906,7 @@ function createAcpSessionBridge(opts) {
             }
             throw new DOMException("Prompt aborted", "AbortError");
           }
+          pendingEntry.startedAt = Date.now();
           if (pendingEntry.state === "queued" || isPromotedMidTurn) {
             if (pendingEntry.state === "queued") {
               delete entry.todoStopGuardAwaitingQueuedPromptOwnerPromptId;
@@ -10668,10 +11934,27 @@ function createAcpSessionBridge(opts) {
                 ...context?.clientId ? { "qwen-code.client_id": context.clientId } : {}
               },
               async () => {
+                let dispatchBlocks = req.prompt;
+                let resolvedPrompt;
+                try {
+                  resolvedPrompt = await entry.attachments.resolveContent(dispatchBlocks);
+                } catch (error) {
+                  if (!isPromotedMidTurn || !(error instanceof SessionAttachmentReferenceError)) {
+                    throw error;
+                  }
+                  const perBlock = await entry.attachments.resolveContentDegrading(
+                    dispatchBlocks
+                  );
+                  dispatchBlocks = perBlock.retainedBlocks;
+                  resolvedPrompt = withAttachmentDegradationMarker(
+                    perBlock.resolvedBlocks
+                  );
+                }
                 const normalized = telemetry.injectPromptContext(
                   {
                     ...req,
-                    sessionId
+                    sessionId,
+                    prompt: resolvedPrompt
                   }
                 );
                 assertLivePromptEntry(sessionId, entry);
@@ -10694,6 +11977,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_ATTACHMENT_REFERENCES_META_KEY];
                   delete meta[CHANNEL_PROMPT_META_KEY];
                   if (isRetry) {
                     meta[DAEMON_RETRY_META_KEY] = true;
@@ -10710,6 +11994,12 @@ function createAcpSessionBridge(opts) {
                   if (modelPrompt !== void 0) {
                     meta[DAEMON_MODEL_PROMPT_META_KEY] = modelPrompt;
                   }
+                  const attachmentReferences = dispatchBlocks.filter(
+                    isSessionAttachmentReference
+                  );
+                  if (attachmentReferences.length > 0) {
+                    meta[DAEMON_ATTACHMENT_REFERENCES_META_KEY] = attachmentReferences;
+                  }
                   if (context?.channelPrompt === true) {
                     meta[CHANNEL_PROMPT_META_KEY] = true;
                   }
@@ -10722,6 +12012,7 @@ function createAcpSessionBridge(opts) {
                   return copy;
                 })();
                 entry.promptActive = true;
+                entry.goalTurnActive = false;
                 entry.activePromptId = pendingEntry.promptId;
                 delete entry.cancelBroadcastWithoutPrompt;
                 delete entry.turnError;
@@ -10738,7 +12029,10 @@ function createAcpSessionBridge(opts) {
                   if (!isRetry && !isContinue) {
                     echoPromptToSessionBus(
                       entry,
-                      promptRequest,
+                      {
+                        ...promptRequest,
+                        prompt: dispatchBlocks
+                      },
                       pendingEntry.promptId,
                       originatorClientId,
                       channelDisplayText
@@ -10879,24 +12173,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
-          );
-        }
+        settleUndrainedMidTurnMessages(entry, undrainedMessages);
         void maybeCloseIdleSession(entry, "prompt_settled");
       }).catch(() => {
       });
@@ -11141,6 +12418,22 @@ function createAcpSessionBridge(opts) {
               `branchSession: agent returned invalid response: ${JSON.stringify(result)}`
             );
           }
+          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) {
@@ -11207,6 +12500,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) {
@@ -11334,6 +12636,7 @@ function createAcpSessionBridge(opts) {
       const entry = byId.get(sessionId);
       if (entry) {
         entry.worktree = worktree;
+        markSessionCatalogChanged();
       }
     },
     async closeSession(sessionId, context, closeOpts) {
@@ -11359,6 +12662,7 @@ function createAcpSessionBridge(opts) {
         const nextDisplayName = metadata.displayName || void 0;
         if (entry.displayName !== nextDisplayName) {
           entry.displayName = nextDisplayName;
+          markSessionCatalogChanged();
           writeStderrLine(
             `qwen serve: updated session metadata ${JSON.stringify(sessionId)} displayName=${entry.displayName === void 0 ? "cleared" : "set"}` + (context?.clientId ? ` by client ${JSON.stringify(context.clientId)}` : "")
           );
@@ -11421,7 +12725,7 @@ function createAcpSessionBridge(opts) {
       return warnings.length > 0 ? { ...result, warnings } : result;
     },
     listWorkspaceSessions(workspaceCwd) {
-      if (!path3.isAbsolute(workspaceCwd)) return [];
+      if (!path4.isAbsolute(workspaceCwd)) return [];
       const key = workspaceCwd === boundWorkspace ? boundWorkspace : canonicalizeWorkspace(workspaceCwd);
       if (key !== boundWorkspace) return [];
       const out = [];
@@ -11432,6 +12736,8 @@ function createAcpSessionBridge(opts) {
       }
       return out;
     },
+    getSessionCatalogVersion,
+    markSessionCatalogChanged,
     getSessionSummary(sessionId) {
       const entry = byId.get(sessionId);
       if (!entry) throw new SessionNotFoundError(sessionId);
@@ -11748,6 +13054,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,
@@ -12191,14 +13509,95 @@ 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 storeSessionAttachment(sessionId, data, mimeType, context, name) {
+      const entry = byId.get(sessionId);
+      if (!entry) throw new SessionNotFoundError(sessionId);
+      resolveTrustedClientId(entry, context?.clientId);
+      return await entry.attachments.putAttachment(data, mimeType, name);
+    },
+    async readSessionAttachment(sessionId, attachmentId, context) {
+      const entry = byId.get(sessionId);
+      if (!entry) throw new SessionNotFoundError(sessionId);
+      resolveTrustedClientId(entry, context?.clientId);
+      return await entry.attachments.read(attachmentId);
+    },
+    async removeSessionAttachment(sessionId, attachmentId, context) {
+      const entry = byId.get(sessionId);
+      if (!entry) throw new SessionNotFoundError(sessionId);
+      resolveTrustedClientId(entry, context?.clientId);
+      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);
       if (!entry) throw new SessionNotFoundError(sessionId);
@@ -12242,7 +13641,10 @@ function createAcpSessionBridge(opts) {
         context?.clientId
       );
       const trimmed = message.trim();
-      if (trimmed.length === 0) {
+      const mediaBlocks = (options?.content ?? []).filter(
+        (block) => block.type === "image" || block.type === "resource"
+      );
+      if (trimmed.length === 0 && mediaBlocks.length === 0) {
         writeStderrLine(
           `[mid-turn] session=${entry.sessionId} rejected: empty`
         );
@@ -12253,11 +13655,12 @@ function createAcpSessionBridge(opts) {
           (queued) => queued.messageId === requestedMessageId
         );
         if (existing) {
-          if (existing.text === trimmed) {
+          const sameMedia = JSON.stringify(existing.content ?? []) === JSON.stringify(mediaBlocks);
+          if (existing.text === trimmed && sameMedia) {
             return { accepted: true, messageId: requestedMessageId };
           }
           writeStderrLine(
-            `[mid-turn] session=${JSON.stringify(entry.sessionId)} rejected id ${JSON.stringify(requestedMessageId)}: text mismatch`
+            `[mid-turn] session=${JSON.stringify(entry.sessionId)} rejected id ${JSON.stringify(requestedMessageId)}: text or content mismatch`
           );
           return { accepted: false };
         }
@@ -12265,11 +13668,16 @@ function createAcpSessionBridge(opts) {
           (pending) => pending.promptId === requestedMessageId
         );
         if (promoted) {
-          if (promoted.text === trimmed) {
+          const promotedMedia = (promoted.content ?? []).filter(
+            (block) => block.type === "image" || block.type === "resource"
+          );
+          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 };
           }
           writeStderrLine(
-            `[mid-turn] session=${JSON.stringify(entry.sessionId)} rejected promoted id ${JSON.stringify(requestedMessageId)}: text mismatch`
+            `[mid-turn] session=${JSON.stringify(entry.sessionId)} rejected promoted id ${JSON.stringify(requestedMessageId)}: text or content mismatch`
           );
           return { accepted: false };
         }
@@ -12286,15 +13694,35 @@ function createAcpSessionBridge(opts) {
         );
         return { accepted: false };
       }
+      entry.attachments.assertReferences(mediaBlocks);
+      const inlineBytes = inlineAttachmentBlockBytes(mediaBlocks);
+      if (inlineBytes > 0) {
+        const queuedInlineBytes = entry.midTurnMessageQueue.reduce(
+          (total, queued) => total + inlineAttachmentBlockBytes(queued.content ?? []),
+          0
+        );
+        if (queuedInlineBytes + inlineBytes > MAX_QUEUED_INLINE_ATTACHMENT_BYTES) {
+          writeStderrLine(
+            `[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 ?? randomUUID2();
-      if (entry.pendingPromptCount === 0) {
-        if (options?.queueOnly) {
+      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`
           );
           return { accepted: false };
         }
-        promoteMidTurnMessage(entry, messageId, trimmed, originatorClientId);
+        promoteMidTurnMessage(
+          entry,
+          messageId,
+          trimmed,
+          originatorClientId,
+          mediaBlocks.length > 0 ? mediaBlocks : void 0
+        );
         return { accepted: true, messageId };
       }
       if (entry.midTurnMessageQueue.length >= MAX_MID_TURN_QUEUE_DEPTH) {
@@ -12306,6 +13734,7 @@ function createAcpSessionBridge(opts) {
       const queuedMessage = {
         messageId,
         text: trimmed,
+        ...mediaBlocks.length > 0 ? { content: mediaBlocks } : {},
         originatorClientId,
         ...options?.queueOnly ? {
           queueOnly: true,
@@ -12414,7 +13843,11 @@ function createAcpSessionBridge(opts) {
         // should restore into their queue views.
         messages: entry.midTurnMessageQueue.filter((message) => message.originatorClientId !== void 0).map((message) => ({
           messageId: message.messageId,
-          text: message.text
+          text: message.text,
+          // Carry the media blocks so a refreshed client can rebuild the
+          // queued row with its attachments (the snapshot is the only
+          // recovery source once the client's in-memory copy is gone).
+          ...message.content ? { content: message.content } : {}
         })),
         settledMessageIds: [...entry.settledMidTurnMessageIds],
         promotedMessageIds: [...entry.promotedMidTurnMessageIds]
@@ -12716,6 +14149,9 @@ function createAcpSessionBridge(opts) {
           }
           throw err;
         }
+        entry.terminalTurnStatuses.clear();
+        entry.enrichedTerminalPromptIds.clear();
+        entry.rewindGeneration += 1;
         const targetTurnIndex = response["targetTurnIndex"] ?? 0;
         const filesChanged = response["filesChanged"] ?? [];
         const filesFailed = response["filesFailed"] ?? [];
@@ -13098,6 +14534,11 @@ function createAcpSessionBridge(opts) {
           closingChannel,
           `force kill closing session ${JSON.stringify(sessionId)}`
         );
+        await entry.attachments.close().catch((releaseError) => {
+          writeStderrLine(
+            `qwen serve: failed to close attachments for killed session ${JSON.stringify(sessionId)}: ${releaseError instanceof Error ? releaseError.message : String(releaseError)}`
+          );
+        });
         return true;
       }
       entry.closing = true;
@@ -13161,6 +14602,11 @@ function createAcpSessionBridge(opts) {
       } catch {
       }
       entry.events.close();
+      await entry.attachments.close().catch((error) => {
+        writeStderrLine(
+          `qwen serve: failed to close attachments for killed session ${JSON.stringify(sessionId)}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      });
       if (ci && hasNoChannelWork(ci)) {
         await reapPendingEmptyChannel(ci);
         if (!ci.isDying) {
@@ -13265,6 +14711,7 @@ function createAcpSessionBridge(opts) {
         ) : Promise.resolve();
         const teardownResults = await Promise.allSettled([
           ...channels.map((ci) => ci.channel.kill()),
+          ...[...byId.values()].map((entry) => entry.attachments.close()),
           ...inFlightSessionAwaits,
           ...inFlightRestoreAwaits,
           inFlightChannelAwait