@qwen-code/qwen-code 0.21.14 → 0.21.15

package/chunks/{run-qwen-serve-UR3DYDAF.js → run-qwen-serve-SQBF7QZM.js}

@@ -36,10 +36,11 @@ import {
   resolveAcpHttpEnabled,
   setDeferredRuntimeRequestTiming,
   toDaemonStatusMemoryLimits
-} from "./chunk-UYDGFWIJ.js";
+} from "./chunk-NYN4RD3K.js";
 import "./chunk-VGHZT6JR.js";
 import {
-  isLoopbackBind
+  isLoopbackBind,
+  normalizeSessionIdForLookup
 } from "./chunk-TQOF5KBL.js";
 import {
   formatMemoryBudgetStderr,
@@ -81,17 +82,17 @@ import {
   MAX_REGISTERED_WORKSPACES,
   resolveWorkspaceInputs,
   workspaceRegistrationId
-} from "./chunk-SFTKAX4O.js";
-import "./chunk-CH5OFRV7.js";
+} from "./chunk-OFJ6OFIT.js";
+import "./chunk-W4MLKRZD.js";
 import {
   LOAD_REPLAY_META_KEY
-} from "./chunk-WP4WIUOJ.js";
+} from "./chunk-QQUVPMMZ.js";
 import "./chunk-624NHDGB.js";
 import {
   canonicalizeWorkspace,
   translateAndCheckAbsoluteWorkspacePath
 } from "./chunk-6PLDPT2C.js";
-import "./chunk-4W5U2TUT.js";
+import "./chunk-NGY7B7VF.js";
 import "./chunk-FYJ7W2PI.js";
 import "./chunk-Z7B6SRPM.js";
 import {
@@ -99,7 +100,7 @@ import {
   ChannelWebhookEnqueueError,
   QWEN_SERVER_TOKEN_ENV,
   isChannelDeliveryError
-} from "./chunk-YP5KH5Y7.js";
+} from "./chunk-ND7NOI4P.js";
 import {
   normalizeWorkerDiagnostic,
   sanitizeWorkerDiagnostic
@@ -107,7 +108,7 @@ import {
 import {
   channelSelectionNames
 } from "./chunk-ALMR3E6Q.js";
-import "./chunk-HIBNSEJE.js";
+import "./chunk-UDG5EZJI.js";
 import "./chunk-M5GB774H.js";
 import {
   EXTERNAL_TOOL_GUARD_PROVIDER_ATTACHED_VALUE,
@@ -136,12 +137,13 @@ import {
 } from "./chunk-CXJHQVEK.js";
 import {
   getCliVersion
-} from "./chunk-PCETXVVV.js";
+} from "./chunk-3X6KVX37.js";
 import "./chunk-WZMH7II3.js";
 import "./chunk-NPQ5ZKRP.js";
 import {
   isWithinRoot
 } from "./chunk-MR3PXB6E.js";
+import "./chunk-LJZSMWOH.js";
 import "./chunk-GOFAQQZA.js";
 import "./chunk-5M6IDOMF.js";
 import "./chunk-TWPJO254.js";
@@ -167,7 +169,7 @@ import {
   init_esm,
   isSpanContextValid,
   trace
-} from "./chunk-QUGAUQGJ.js";
+} from "./chunk-GX2THELY.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -1388,7 +1390,7 @@ function createConcreteLogger(input) {
         }
       });
       let timeout;
-      const deadline = new Promise((resolve3) => {
+      const deadline = new Promise((resolve4) => {
         timeout = setTimeout(() => {
           try {
             input.warnOnce(
@@ -1397,7 +1399,7 @@ function createConcreteLogger(input) {
             );
           } catch {
           } finally {
-            resolve3();
+            resolve4();
           }
         }, input.policy.closeDrainBudgetMs);
         timeout.unref();
@@ -1743,61 +1745,81 @@ __name(initDaemonLogger, "initDaemonLogger");
 
 // packages/cli/src/serve/conversations/conversation-workspace.ts
 init_esbuild_shims();
-import { createHash as createHash2 } from "node:crypto";
-import { lstat, mkdir, realpath, rmdir } from "node:fs/promises";
+import { readdir, rmdir } from "node:fs/promises";
 import { homedir } from "node:os";
+import { resolve as resolve2 } from "node:path";
+
+// packages/cli/src/utils/conversation-directory-identity.ts
+init_esbuild_shims();
+import { createHash as createHash2 } from "node:crypto";
+import { lstat, mkdir, realpath } from "node:fs/promises";
 import { isAbsolute, join as join2, relative as relative2, resolve, sep } from "node:path";
-var isSamePath = /* @__PURE__ */ __name((left, right) => process.platform === "win32" ? left.toLowerCase() === right.toLowerCase() : left === right, "isSamePath");
-function conversationDirectoryName(sessionId) {
-  if (sessionId.length === 0 || sessionId.length > 256) {
-    throw new Error("Live conversation session id is invalid");
+function hasVerifiableInode(ino) {
+  return Number(ino) !== 0;
+}
+__name(hasVerifiableInode, "hasVerifiableInode");
+var ConversationDirectoryIdentityError = class extends Error {
+  constructor(scope, reason, cause) {
+    super(
+      `Conversation ${scope} identity validation failed: ${reason}`,
+      cause !== void 0 ? { cause } : void 0
+    );
+    this.scope = scope;
+    this.reason = reason;
   }
-  return `conversation-${createHash2("sha256").update(sessionId).digest("hex")}`;
+  static {
+    __name(this, "ConversationDirectoryIdentityError");
+  }
+  name = "ConversationDirectoryIdentityError";
+};
+function throwIdentityIoError(scope, cause) {
+  throw new ConversationDirectoryIdentityError(scope, "io_error", cause);
 }
-__name(conversationDirectoryName, "conversationDirectoryName");
-function validateRootStats(stats, label = "root") {
+__name(throwIdentityIoError, "throwIdentityIoError");
+var isSameConversationPath = /* @__PURE__ */ __name((left, right) => process.platform === "win32" ? left.toLowerCase() === right.toLowerCase() : left === right, "isSameConversationPath");
+function getConversationDirectoryName(storageSessionId) {
+  if (storageSessionId.length === 0 || storageSessionId.length > 256) {
+    throw new ConversationDirectoryIdentityError("child", "invalid_session_id");
+  }
+  return `conversation-${createHash2("sha256").update(storageSessionId).digest("hex")}`;
+}
+__name(getConversationDirectoryName, "getConversationDirectoryName");
+function validateDirectoryStats(stats, scope) {
   if (stats.isSymbolicLink() || !stats.isDirectory()) {
-    throw new Error(
-      `Live conversation ${label} must be a non-symlink directory`
-    );
+    throw new ConversationDirectoryIdentityError(scope, "not_directory");
   }
   if (process.platform !== "win32" && typeof process.getuid === "function" && stats.uid !== process.getuid()) {
-    throw new Error(
-      `Live conversation ${label} must be owned by the daemon user`
-    );
+    throw new ConversationDirectoryIdentityError(scope, "wrong_owner");
   }
   if (process.platform !== "win32" && (stats.mode & 63) !== 0) {
-    throw new Error(
-      `Live conversation ${label} must be accessible only to its owner`
-    );
-  }
-}
-__name(validateRootStats, "validateRootStats");
-function hasIdentity(stats, root) {
-  return stats.dev === root.device && stats.ino === root.inode;
-}
-__name(hasIdentity, "hasIdentity");
-async function validateConversationDirectory(root, name, candidate, parent = root.canonicalRoot) {
-  const before = await lstat(candidate);
-  validateRootStats(before, "directory");
-  const canonical = await realpath(candidate);
-  const after = await lstat(canonical);
-  validateRootStats(after, "directory");
-  const child = relative2(parent, canonical);
-  if (child !== name || child.includes(sep) || child.startsWith("..") || isAbsolute(child) || before.dev !== after.dev || before.ino !== after.ino) {
-    throw new Error(
-      "Live conversation directory must be an owned direct child"
-    );
-  }
-  await revalidateConversationRoot(root);
-  return canonical;
-}
-__name(validateConversationDirectory, "validateConversationDirectory");
-function getConversationRootPath(homeDir = homedir()) {
-  return resolve(homeDir, "Documents", "Qwen Code", "Conversations");
-}
-__name(getConversationRootPath, "getConversationRootPath");
-async function createRoot(configuredRoot) {
+    throw new ConversationDirectoryIdentityError(scope, "wrong_mode");
+  }
+}
+__name(validateDirectoryStats, "validateDirectoryStats");
+function hasRootIdentity(stats, root) {
+  if (!root.inodeVerifiable) return stats.dev === root.device;
+  return hasVerifiableInode(stats.ino) && stats.dev === root.device && stats.ino === root.inode;
+}
+__name(hasRootIdentity, "hasRootIdentity");
+function isSameDirectoryIdentity(before, after) {
+  if (!hasVerifiableInode(before.ino) || !hasVerifiableInode(after.ino)) {
+    return before.dev === after.dev;
+  }
+  return before.dev === after.dev && before.ino === after.ino;
+}
+__name(isSameDirectoryIdentity, "isSameDirectoryIdentity");
+function hasExpectedDirectoryIdentity(identity, expected) {
+  const inodesProvable = hasVerifiableInode(identity.inode) && hasVerifiableInode(expected.inode);
+  return identity.storageSessionId === expected.storageSessionId && identity.name === expected.name && isSameConversationPath(identity.canonicalPath, expected.canonicalPath) && identity.device === expected.device && (!inodesProvable || identity.inode === expected.inode) && isSameConversationPath(
+    identity.root.configuredRoot,
+    expected.root.configuredRoot
+  ) && isSameConversationPath(
+    identity.root.canonicalRoot,
+    expected.root.canonicalRoot
+  ) && identity.root.device === expected.root.device && (!identity.root.inodeVerifiable || !expected.root.inodeVerifiable || identity.root.inode === expected.root.inode);
+}
+__name(hasExpectedDirectoryIdentity, "hasExpectedDirectoryIdentity");
+async function createConversationRootIdentity(configuredRoot) {
   try {
     await mkdir(configuredRoot, { recursive: true, mode: 448 });
   } catch (error) {
@@ -1805,61 +1827,246 @@ async function createRoot(configuredRoot) {
     try {
       existing = await lstat(configuredRoot);
     } catch {
-      throw error;
+      throwIdentityIoError("root", error);
     }
-    validateRootStats(existing);
-    throw error;
+    validateDirectoryStats(existing, "root");
+    throwIdentityIoError("root", error);
   }
-  const before = await lstat(configuredRoot);
-  validateRootStats(before);
-  const canonicalRoot = await realpath(configuredRoot);
-  const after = await lstat(canonicalRoot);
-  validateRootStats(after);
-  if (before.dev !== after.dev || before.ino !== after.ino) {
-    throw new Error(
-      "Live conversation root identity changed during validation"
-    );
+  let before;
+  try {
+    before = await lstat(configuredRoot);
+  } catch (error) {
+    throwIdentityIoError("root", error);
+  }
+  validateDirectoryStats(before, "root");
+  let canonicalRoot;
+  let after;
+  try {
+    canonicalRoot = await realpath(configuredRoot);
+    after = await lstat(canonicalRoot);
+  } catch (error) {
+    throwIdentityIoError("root", error);
+  }
+  validateDirectoryStats(after, "root");
+  if (!isSameDirectoryIdentity(before, after)) {
+    throw new ConversationDirectoryIdentityError("root", "identity_changed");
   }
   return {
     configuredRoot,
     canonicalRoot,
     device: after.dev,
-    inode: after.ino
+    inode: after.ino,
+    inodeVerifiable: hasVerifiableInode(after.ino)
   };
 }
-__name(createRoot, "createRoot");
-async function revalidateConversationRoot(root) {
-  const configuredStats = await lstat(root.configuredRoot);
-  validateRootStats(configuredStats);
-  if (!hasIdentity(configuredStats, root)) {
-    throw new Error("Live conversation root identity changed");
+__name(createConversationRootIdentity, "createConversationRootIdentity");
+async function revalidateConversationRootIdentity(root) {
+  let configuredStats;
+  try {
+    configuredStats = await lstat(root.configuredRoot);
+  } catch (error) {
+    throwIdentityIoError("root", error);
+  }
+  validateDirectoryStats(configuredStats, "root");
+  if (!hasRootIdentity(configuredStats, root)) {
+    throw new ConversationDirectoryIdentityError("root", "identity_changed");
+  }
+  let canonical;
+  try {
+    canonical = await realpath(root.configuredRoot);
+  } catch (error) {
+    throwIdentityIoError("root", error);
+  }
+  if (!isSameConversationPath(canonical, root.canonicalRoot)) {
+    throw new ConversationDirectoryIdentityError(
+      "root",
+      "canonical_path_changed"
+    );
   }
-  const canonical = await realpath(root.configuredRoot);
-  if (!isSamePath(canonical, root.canonicalRoot)) {
-    throw new Error("Live conversation root canonical path changed");
+  let canonicalStats;
+  try {
+    canonicalStats = await lstat(root.canonicalRoot);
+  } catch (error) {
+    throwIdentityIoError("root", error);
   }
-  const canonicalStats = await lstat(root.canonicalRoot);
-  validateRootStats(canonicalStats);
-  if (!hasIdentity(canonicalStats, root)) {
-    throw new Error("Live conversation root identity changed");
+  validateDirectoryStats(canonicalStats, "root");
+  if (!hasRootIdentity(canonicalStats, root)) {
+    throw new ConversationDirectoryIdentityError("root", "identity_changed");
   }
   return root;
 }
-__name(revalidateConversationRoot, "revalidateConversationRoot");
-async function assertExactConversationRoot(root, candidate) {
-  await revalidateConversationRoot(root);
+__name(revalidateConversationRootIdentity, "revalidateConversationRootIdentity");
+async function assertExactConversationRootIdentity(root, candidate) {
+  await revalidateConversationRootIdentity(root);
   const resolvedCandidate = resolve(candidate);
-  if (!isSamePath(resolvedCandidate, root.configuredRoot) && !isSamePath(resolvedCandidate, root.canonicalRoot)) {
-    throw new Error("Workspace must be the exact Live conversation root");
+  if (!isSameConversationPath(resolvedCandidate, root.configuredRoot) && !isSameConversationPath(resolvedCandidate, root.canonicalRoot)) {
+    throw new ConversationDirectoryIdentityError("root", "unexpected_identity");
   }
-  const stats = await lstat(resolvedCandidate);
-  validateRootStats(stats);
-  const canonical = await realpath(resolvedCandidate);
-  if (!isSamePath(canonical, root.canonicalRoot) || !hasIdentity(stats, root)) {
-    throw new Error("Workspace must be the exact Live conversation root");
+  let stats;
+  let canonical;
+  try {
+    stats = await lstat(resolvedCandidate);
+    validateDirectoryStats(stats, "root");
+    canonical = await realpath(resolvedCandidate);
+  } catch (error) {
+    if (error instanceof ConversationDirectoryIdentityError) throw error;
+    throwIdentityIoError("root", error);
+  }
+  if (!isSameConversationPath(canonical, root.canonicalRoot) || !hasRootIdentity(stats, root)) {
+    throw new ConversationDirectoryIdentityError("root", "unexpected_identity");
   }
   return root;
 }
+__name(assertExactConversationRootIdentity, "assertExactConversationRootIdentity");
+async function inspectConversationDirectoryIdentity(root, storageSessionId, expected) {
+  await revalidateConversationRootIdentity(root);
+  const name = getConversationDirectoryName(storageSessionId);
+  const candidate = join2(root.canonicalRoot, name);
+  let before;
+  try {
+    before = await lstat(candidate);
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throwIdentityIoError("child", error);
+  }
+  validateDirectoryStats(before, "child");
+  let canonical;
+  let after;
+  try {
+    canonical = await realpath(candidate);
+    after = await lstat(canonical);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new ConversationDirectoryIdentityError("child", "identity_changed");
+    }
+    throwIdentityIoError("child", error);
+  }
+  validateDirectoryStats(after, "child");
+  const child = relative2(root.canonicalRoot, canonical);
+  if (child !== name || child.includes(sep) || child.startsWith("..") || isAbsolute(child)) {
+    throw new ConversationDirectoryIdentityError("child", "not_direct_child");
+  }
+  if (!isSameDirectoryIdentity(before, after)) {
+    throw new ConversationDirectoryIdentityError("child", "identity_changed");
+  }
+  await revalidateConversationRootIdentity(root);
+  const identity = {
+    root,
+    storageSessionId,
+    name,
+    canonicalPath: canonical,
+    device: after.dev,
+    inode: after.ino
+  };
+  if (expected && !hasExpectedDirectoryIdentity(identity, expected)) {
+    throw new ConversationDirectoryIdentityError(
+      "child",
+      "unexpected_identity"
+    );
+  }
+  return identity;
+}
+__name(inspectConversationDirectoryIdentity, "inspectConversationDirectoryIdentity");
+async function materializeConversationDirectoryIdentity(root, storageSessionId) {
+  await revalidateConversationRootIdentity(root);
+  const name = getConversationDirectoryName(storageSessionId);
+  const candidate = join2(root.canonicalRoot, name);
+  let created = false;
+  try {
+    await mkdir(candidate, { mode: 448 });
+    created = true;
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      throwIdentityIoError("child", error);
+    }
+  }
+  const identity = await inspectConversationDirectoryIdentity(
+    root,
+    storageSessionId
+  );
+  if (!identity) {
+    throw new ConversationDirectoryIdentityError("child", "identity_changed");
+  }
+  return { identity, created };
+}
+__name(materializeConversationDirectoryIdentity, "materializeConversationDirectoryIdentity");
+
+// packages/cli/src/serve/conversations/conversation-workspace.ts
+function liveIdentityError(error, exactRoot = false, creatingRoot = false) {
+  if (!(error instanceof ConversationDirectoryIdentityError)) throw error;
+  if (error.reason === "io_error" && error.cause !== void 0) {
+    throw error.cause;
+  }
+  if (error.scope === "root") {
+    switch (error.reason) {
+      case "not_directory":
+        throw new Error(
+          "Live conversation root must be a non-symlink directory"
+        );
+      case "wrong_owner":
+        throw new Error(
+          "Live conversation root must be owned by the daemon user"
+        );
+      case "wrong_mode":
+        throw new Error(
+          "Live conversation root must be accessible only to its owner"
+        );
+      case "canonical_path_changed":
+        throw new Error("Live conversation root canonical path changed");
+      case "identity_changed":
+        throw new Error(
+          creatingRoot ? "Live conversation root identity changed during validation" : "Live conversation root identity changed"
+        );
+      case "unexpected_identity":
+        if (exactRoot) {
+          throw new Error("Workspace must be the exact Live conversation root");
+        }
+        throw new Error("Live conversation root identity changed");
+      default:
+        throw new Error("Live conversation root identity changed");
+    }
+  }
+  switch (error.reason) {
+    case "invalid_session_id":
+      throw new Error("Live conversation session id is invalid");
+    case "not_directory":
+      throw new Error(
+        "Live conversation directory must be a non-symlink directory"
+      );
+    case "wrong_owner":
+      throw new Error(
+        "Live conversation directory must be owned by the daemon user"
+      );
+    case "wrong_mode":
+      throw new Error(
+        "Live conversation directory must be accessible only to its owner"
+      );
+    default:
+      throw new Error(
+        "Live conversation directory must be an owned direct child"
+      );
+  }
+}
+__name(liveIdentityError, "liveIdentityError");
+function getConversationRootPath(homeDir = homedir()) {
+  return resolve2(homeDir, "Documents", "Qwen Code", "Conversations");
+}
+__name(getConversationRootPath, "getConversationRootPath");
+async function revalidateConversationRoot(root) {
+  try {
+    return await revalidateConversationRootIdentity(root);
+  } catch (error) {
+    liveIdentityError(error);
+  }
+}
+__name(revalidateConversationRoot, "revalidateConversationRoot");
+async function assertExactConversationRoot(root, candidate) {
+  try {
+    return await assertExactConversationRootIdentity(root, candidate);
+  } catch (error) {
+    liveIdentityError(error, true);
+  }
+}
 __name(assertExactConversationRoot, "assertExactConversationRoot");
 var ConversationWorkspace = class {
   static {
@@ -1870,9 +2077,9 @@ var ConversationWorkspace = class {
   constructor(options = {}) {
     this.rootPath = getConversationRootPath(options.homeDir);
   }
-  async getRoot() {
+  getRootIdentity() {
     if (!this.rootPromise) {
-      const pending = createRoot(this.rootPath);
+      const pending = createConversationRootIdentity(this.rootPath);
       this.rootPromise = pending;
       void pending.catch(() => {
         if (this.rootPromise === pending) this.rootPromise = void 0;
@@ -1880,42 +2087,61 @@ var ConversationWorkspace = class {
     }
     return this.rootPromise;
   }
+  async getRoot() {
+    try {
+      return await this.getRootIdentity();
+    } catch (error) {
+      liveIdentityError(error, false, true);
+    }
+  }
+  async revalidateStandaloneRoot() {
+    return revalidateConversationRootIdentity(await this.getRootIdentity());
+  }
   async revalidate() {
     return revalidateConversationRoot(await this.getRoot());
   }
   async assertExactRoot(candidate) {
     return assertExactConversationRoot(await this.getRoot(), candidate);
   }
+  /**
+   * The private directory is derived from the canonical session id, not from
+   * whatever spelling a caller happens to hold.
+   *
+   * `getConversationDirectoryName()` is a case-sensitive hash, and callers reach
+   * these methods with a mix of request ids, live-entry ids and ids echoed back
+   * from tool arguments. Canonicalizing here makes one session resolve to one
+   * directory by construction instead of leaving it to every call site.
+   */
+  directoryKey(sessionId) {
+    return normalizeSessionIdForLookup(sessionId);
+  }
   async materializeConversationDirectory(sessionId) {
     const root = await this.revalidate();
-    const name = conversationDirectoryName(sessionId);
-    const candidate = join2(root.canonicalRoot, name);
     try {
-      await mkdir(candidate, { mode: 448 });
+      return (await materializeConversationDirectoryIdentity(
+        root,
+        this.directoryKey(sessionId)
+      )).identity.canonicalPath;
     } catch (error) {
-      if (!error || typeof error !== "object" || error.code !== "EEXIST") {
-        throw error;
-      }
+      liveIdentityError(error);
     }
-    return validateConversationDirectory(root, name, candidate);
   }
   async discardEmptyConversationDirectory(sessionId) {
     const root = await this.revalidate();
-    const name = conversationDirectoryName(sessionId);
-    const candidate = join2(root.canonicalRoot, name);
-    let canonical;
+    let identity;
     try {
-      canonical = await validateConversationDirectory(root, name, candidate);
+      identity = await inspectConversationDirectoryIdentity(
+        root,
+        this.directoryKey(sessionId)
+      );
     } catch (error) {
-      if (error && typeof error === "object" && error.code === "ENOENT") {
-        return false;
-      }
-      throw error;
+      liveIdentityError(error);
     }
+    if (!identity) return false;
     try {
-      await rmdir(canonical);
+      await rmdir(identity.canonicalPath);
     } catch (error) {
-      if (error && typeof error === "object" && (error.code === "ENOENT" || error.code === "ENOTEMPTY")) {
+      if (error.code === "ENOENT" || error.code === "ENOTEMPTY") {
         return false;
       }
       throw error;
@@ -1923,6 +2149,87 @@ var ConversationWorkspace = class {
     await revalidateConversationRoot(root);
     return true;
   }
+  async prepareStandaloneDirectory(storageSessionId) {
+    const root = await this.revalidateStandaloneRoot();
+    const prepared = await materializeConversationDirectoryIdentity(
+      root,
+      storageSessionId
+    );
+    const identity = await inspectConversationDirectoryIdentity(
+      root,
+      storageSessionId,
+      prepared.identity
+    );
+    if (!identity) {
+      throw new ConversationDirectoryIdentityError("child", "identity_changed");
+    }
+    let entries;
+    try {
+      entries = await readdir(identity.canonicalPath);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        throw new ConversationDirectoryIdentityError(
+          "child",
+          "identity_changed"
+        );
+      }
+      throw new ConversationDirectoryIdentityError("child", "io_error", error);
+    }
+    if (entries.length > 0) {
+      throw new ConversationDirectoryIdentityError("child", "not_empty");
+    }
+    return { identity, created: prepared.created };
+  }
+  async inspectStandaloneDirectory(storageSessionId, expected) {
+    const root = await this.revalidateStandaloneRoot();
+    try {
+      const identity = await inspectConversationDirectoryIdentity(
+        root,
+        storageSessionId,
+        expected
+      );
+      return identity ? { status: "ready", identity } : { status: "missing" };
+    } catch (error) {
+      if (error instanceof ConversationDirectoryIdentityError && error.scope === "child") {
+        return { status: "compromised", error };
+      }
+      throw error;
+    }
+  }
+  async ensureStandaloneDirectory(storageSessionId, expected) {
+    const inspected = await this.inspectStandaloneDirectory(
+      storageSessionId,
+      expected
+    );
+    if (inspected.status !== "missing") return inspected;
+    const root = await this.revalidateStandaloneRoot();
+    try {
+      const materialized = await materializeConversationDirectoryIdentity(
+        root,
+        storageSessionId
+      );
+      if (!materialized.created) {
+        const raced = await this.inspectStandaloneDirectory(
+          storageSessionId,
+          expected
+        );
+        if (raced.status !== "missing") return raced;
+        throw new ConversationDirectoryIdentityError(
+          "child",
+          "identity_changed"
+        );
+      }
+      return {
+        status: expected ? "recreated" : "created",
+        identity: materialized.identity
+      };
+    } catch (error) {
+      if (error instanceof ConversationDirectoryIdentityError && error.scope === "child") {
+        return { status: "compromised", error };
+      }
+      throw error;
+    }
+  }
 };
 
 // packages/cli/src/serve/daemon-metrics-ring.ts
@@ -2783,8 +3090,8 @@ async function flushDaemonLogBounded(daemonLog, budgetMs) {
     await Promise.race([
       daemonLog.flush().catch(() => {
       }),
-      new Promise((resolve3) => {
-        timer = setTimeout(resolve3, budgetMs);
+      new Promise((resolve4) => {
+        timer = setTimeout(resolve4, budgetMs);
         timer.unref();
       })
     ]);
@@ -3038,12 +3345,12 @@ __name(hasRetryableChannelWorkerShutdownError, "hasRetryableChannelWorkerShutdow
 var channelWorkerRuntimePromise;
 async function loadChannelWorkerRuntime() {
   channelWorkerRuntimePromise ??= Promise.all([
-    import("./channel-worker-supervisor-OEVWBHGT.js"),
-    import("./pidfile-5G42YSTP.js"),
-    import("./runtime-PR5RKGNH.js"),
+    import("./channel-worker-supervisor-CPPSL7ZH.js"),
+    import("./pidfile-WDSDXBY3.js"),
+    import("./runtime-7QGB6SY4.js"),
     import("./cli-entry-path-4VJ3Y6T2.js"),
-    import("./channel-worker-group-TJ35JDPE.js"),
-    import("./channel-worker-manager-G5LKWGOG.js")
+    import("./channel-worker-group-IN2UPYHP.js"),
+    import("./channel-worker-manager-4CQPHVD4.js")
   ]).then(
     ([
       supervisor,
@@ -3148,7 +3455,7 @@ function shouldPreheatBridge(deps) {
 __name(shouldPreheatBridge, "shouldPreheatBridge");
 var coreRuntimePromise;
 function loadCoreRuntime() {
-  coreRuntimePromise ??= import("./core-runtime-6HD5DSPX.js");
+  coreRuntimePromise ??= import("./core-runtime-TIWTFHOR.js");
   return coreRuntimePromise;
 }
 __name(loadCoreRuntime, "loadCoreRuntime");
@@ -3184,10 +3491,10 @@ __name(resolveDaemonLogBaseDirForRun, "resolveDaemonLogBaseDirForRun");
 var settingsRuntimePromise;
 function loadSettingsRuntimeModules() {
   settingsRuntimePromise ??= Promise.all([
-    import("./settings-ESZ3NWAP.js"),
-    import("./environment-7QRYIEBA.js"),
-    import("./loadedSettingsAdapter-SJ2MJF35.js"),
-    import("./trustedFolders-QMH25GOX.js")
+    import("./settings-GBBVKBQ2.js"),
+    import("./environment-6IEK2353.js"),
+    import("./loadedSettingsAdapter-X7FC5332.js"),
+    import("./trustedFolders-FDJ2Q4ZK.js")
   ]).then(([settings, environment, loadedSettingsAdapter, trustedFolders]) => ({
     settings,
     environment,
@@ -3200,8 +3507,8 @@ __name(loadSettingsRuntimeModules, "loadSettingsRuntimeModules");
 var channelWebhookConfigRuntimePromise;
 function loadChannelWebhookConfigRuntime() {
   channelWebhookConfigRuntimePromise ??= Promise.all([
-    import("./runtime-PR5RKGNH.js"),
-    import("./config-utils-NJQA5YLJ.js")
+    import("./runtime-7QGB6SY4.js"),
+    import("./config-utils-XJTGZVY3.js")
   ]).then(([channelRuntime, configUtils]) => ({
     loadChannelsConfig: channelRuntime.loadChannelsConfig,
     parseChannelWebhookConfig: configUtils.parseChannelWebhookConfig
@@ -3224,19 +3531,21 @@ async function loadServeRuntimeModules() {
     workspaceProvidersStatusModule,
     workspaceSkillsStatusModule,
     totalSessionAdmissionModule,
-    workspaceRegistryModule
+    workspaceRegistryModule,
+    promptLedgerModule
   ] = await Promise.all([
-    import("./server-YXB3DBN7.js"),
-    import("./bridge-WQ4IL2RF.js"),
-    import("./spawnChannel-S63APBZZ.js"),
+    import("./server-ZMZPHJEC.js"),
+    import("./bridge-MG4F5NOH.js"),
+    import("./spawnChannel-TVKIFXXA.js"),
     import("./process-registry-PMJOA5CO.js"),
-    import("./workspace-service-6RLSGUB5.js"),
+    import("./workspace-service-RWB4KMY3.js"),
     import("./types-WYCFCEHR.js"),
-    import("./daemon-status-provider-SXS66ZIR.js"),
-    import("./workspace-providers-status-OXGV4EFF.js"),
-    import("./workspace-skills-status-BHFEPDGH.js"),
-    import("./total-session-admission-DQVW2LIP.js"),
-    import("./workspace-registry-KJVIYTF5.js")
+    import("./daemon-status-provider-JBEST4SF.js"),
+    import("./workspace-providers-status-LNMP7NED.js"),
+    import("./workspace-skills-status-P3XXZY7C.js"),
+    import("./total-session-admission-NZNCU5NU.js"),
+    import("./workspace-registry-KWPGC2LG.js"),
+    import("./prompt-terminal-ledger-RW62JIPP.js")
   ]);
   return {
     createServeApp: serverModule.createServeApp,
@@ -3256,7 +3565,8 @@ async function loadServeRuntimeModules() {
     createTotalSessionAdmissionController: totalSessionAdmissionModule.createTotalSessionAdmissionController,
     createWorkspaceRegistry: workspaceRegistryModule.createWorkspaceRegistry,
     createWorkspaceSessionOwnerIndex: workspaceRegistryModule.createWorkspaceSessionOwnerIndex,
-    createWorkspaceGenerationGuard: workspaceRegistryModule.createWorkspaceGenerationGuard
+    createWorkspaceGenerationGuard: workspaceRegistryModule.createWorkspaceGenerationGuard,
+    createPromptLedgerSink: promptLedgerModule.createPromptLedgerSink
   };
 }
 __name(loadServeRuntimeModules, "loadServeRuntimeModules");
@@ -3433,12 +3743,12 @@ async function waitForRuntimeStartingForShutdown(runtimeStarting, daemonLog, tim
   let timer;
   await Promise.race([
     runtimeStarting,
-    new Promise((resolve3) => {
+    new Promise((resolve4) => {
       timer = setTimeout(() => {
         daemonLog.warn(
           `${timeoutMs}ms runtime-startup wait reached during shutdown; continuing listener close`
         );
-        resolve3();
+        resolve4();
       }, timeoutMs);
       timer.unref();
     })
@@ -4275,7 +4585,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
   }
   let workspaceRegistrationStore = deps.workspaceRegistrationStore;
   if (workspaceRegistrationStore === void 0 && process.env["QWEN_SERVE_NO_PERSISTENT_REGISTRATION"] !== "1") {
-    const { WorkspaceRegistrationStore } = await import("./workspace-registration-store-V5EGKLBH.js");
+    const { WorkspaceRegistrationStore } = await import("./workspace-registration-store-QZ3P3ILN.js");
     workspaceRegistrationStore = new WorkspaceRegistrationStore(boundWorkspace);
   }
   if (workspaceRegistrationStore) {
@@ -4559,7 +4869,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       "qwen serve: required external tool guard handshake succeeded."
     );
   }
-  const { createDaemonToolGuard } = await import("./daemon-git-worktree-guard-6P27GKSU.js");
+  const { createDaemonToolGuard } = await import("./daemon-git-worktree-guard-XSZ3362V.js");
   const daemonToolGuardHandler = createDaemonToolGuard(
     externalToolGuardHandler
   );
@@ -4602,8 +4912,8 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
   let resolveServeAppStartup;
   let rejectServeAppStartup;
   let serveAppStartupSettled = false;
-  const serveAppStartupReady = new Promise((resolve3, reject) => {
-    resolveServeAppStartup = resolve3;
+  const serveAppStartupReady = new Promise((resolve4, reject) => {
+    resolveServeAppStartup = resolve4;
     rejectServeAppStartup = reject;
   });
   void serveAppStartupReady.catch(() => void 0);
@@ -4633,8 +4943,8 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
   let startRuntimeAfterHealth;
   let startRuntimeForRequest;
   const deferRuntimeUntilFirstHealth = deps.resolveOnListen === true && deps.deferRuntimeUntilFirstHealth === true;
-  const runtimeReady = new Promise((resolve3, reject) => {
-    markRuntimeReady = resolve3;
+  const runtimeReady = new Promise((resolve4, reject) => {
+    markRuntimeReady = resolve4;
     markRuntimeFailed = reject;
   });
   void runtimeReady.catch(() => {
@@ -4895,7 +5205,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       loadCoreRuntime(),
       loadSettingsRuntimeModules(),
       cliVersionPromise,
-      import("./daemon-trust-policy-5QJHAS3N.js")
+      import("./daemon-trust-policy-S6LBG4WN.js")
     ]);
     cliVersion = resolvedCliVersion;
     settingsRuntime.environment.preResolveHomeEnvOverrides();
@@ -4988,6 +5298,10 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       runtimeBootSettings,
       runtimeEnvSnapshot.effectiveEnv
     );
+    const sessionAttachmentsRoot = /* @__PURE__ */ __name((workspace, runtimeBaseDir) => path.join(
+      new core.Storage(workspace, runtimeBaseDir).getProjectTempDir(),
+      "attachments"
+    ), "sessionAttachmentsRoot");
     const runtimeEffectiveEnv = {
       ...runtimeEnvSnapshot.effectiveEnv,
       QWEN_RUNTIME_DIR: primarySessionRuntimeBaseDir
@@ -5267,7 +5581,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         resolveSkillSettings,
         skillSettingStrings,
         updateWorkspaceSkillSettingLists
-      } = await import("./skill-settings-V64NIOTI.js");
+      } = await import("./skill-settings-VEC7C44Z.js");
       const fresh = loadSettingsForPersistence(workspace);
       const normalizedName = skillName.trim().toLowerCase();
       const resolved = resolveSkillSettings(fresh);
@@ -5332,7 +5646,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         resolveSkillSettings,
         skillSettingStrings,
         updateWorkspaceSkillSettingLists
-      } = await import("./skill-settings-V64NIOTI.js");
+      } = await import("./skill-settings-VEC7C44Z.js");
       const fresh = loadSettingsForPersistence(workspace);
       const resolved = resolveSkillSettings(fresh);
       const initialDisabled = skillSettingStrings(
@@ -5437,7 +5751,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         );
       }
     }), "persistSettingsFn");
-    const { createSubSessionLauncher } = await import("./create-sub-session-IQFIPUQA.js");
+    const { createSubSessionLauncher } = await import("./create-sub-session-DPEBT657.js");
     const subSessionLauncher = createSubSessionLauncher({
       getBridge: /* @__PURE__ */ __name(() => bridgeRef, "getBridge"),
       boundWorkspace,
@@ -5446,6 +5760,10 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       )
     });
     const bridge = deps.bridge ?? runtime.createAcpSessionBridge({
+      sessionAttachmentsRoot: sessionAttachmentsRoot(
+        boundWorkspace,
+        primarySessionRuntimeBaseDir
+      ),
       // Reverse tool channel: let `BridgeClient.extMethod` reach the WS
       // connection that hosts a named client MCP server (#5626).
       clientMcpSender: clientMcpSenderRegistry.lookup,
@@ -5482,6 +5800,12 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       ...opts.sessionIdleTimeoutMs !== void 0 ? { sessionIdleTimeoutMs: opts.sessionIdleTimeoutMs } : {},
       ...opts.permissionResponseTimeoutMs !== void 0 ? { permissionResponseTimeoutMs: opts.permissionResponseTimeoutMs } : {},
       boundWorkspace,
+      // Prompt terminal ledger: persisted beside the transcript so a
+      // restarted daemon can reconcile dangling prompts on cold load.
+      promptLedger: runtime.createPromptLedgerSink(
+        boundWorkspace,
+        primarySessionRuntimeBaseDir
+      ),
       sessionShellCommandEnabled,
       childEnvOverrides,
       channelFactory,
@@ -5761,6 +6085,10 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         )
       });
       const secondaryBridge = runtime.createAcpSessionBridge({
+        sessionAttachmentsRoot: sessionAttachmentsRoot(
+          workspaceInput.cwd,
+          secondaryEnv.sessionRuntimeBaseDir
+        ),
         clientMcpSender: secondaryClientMcpSenderRegistry.lookup,
         onCreateSubSession: secondarySubSessionLauncher.launch,
         onChannelDelivery: createBoundChannelDeliveryHandler(
@@ -5795,6 +6123,10 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         ...opts.sessionIdleTimeoutMs !== void 0 ? { sessionIdleTimeoutMs: opts.sessionIdleTimeoutMs } : {},
         ...opts.permissionResponseTimeoutMs !== void 0 ? { permissionResponseTimeoutMs: opts.permissionResponseTimeoutMs } : {},
         boundWorkspace: workspaceInput.cwd,
+        promptLedger: runtime.createPromptLedgerSink(
+          workspaceInput.cwd,
+          secondaryEnv.sessionRuntimeBaseDir
+        ),
         sessionShellCommandEnabled,
         childEnvOverrides,
         channelFactory: secondaryChannelFactory,
@@ -6133,6 +6465,10 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       let wsBridge;
       try {
         wsBridge = runtime.createAcpSessionBridge({
+          sessionAttachmentsRoot: sessionAttachmentsRoot(
+            cwd,
+            wsEnv.sessionRuntimeBaseDir
+          ),
           clientMcpSender: wsClientMcpRegistry.lookup,
           onCreateSubSession: wsSubSessionLauncher.launch,
           onChannelDelivery: createBoundChannelDeliveryHandler(
@@ -6165,6 +6501,14 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
           ...opts.sessionIdleTimeoutMs !== void 0 ? { sessionIdleTimeoutMs: opts.sessionIdleTimeoutMs } : {},
           ...opts.permissionResponseTimeoutMs !== void 0 ? { permissionResponseTimeoutMs: opts.permissionResponseTimeoutMs } : {},
           boundWorkspace: cwd,
+          // Live-conversation workspaces keep transcripts outside the
+          // runtime storage layout, so no ledger sink is wired there.
+          ...provenance === "live-conversation" ? {} : {
+            promptLedger: runtime.createPromptLedgerSink(
+              cwd,
+              wsEnv.sessionRuntimeBaseDir
+            )
+          },
           sessionShellCommandEnabled,
           childEnvOverrides,
           channelFactory: wsChannelFactory,
@@ -6612,8 +6956,8 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
           { createChannelManagementService },
           { WorkspaceChannelSettingsStore }
         ] = await Promise.all([
-          import("./channel-management-service-X6LCQUAD.js"),
-          import("./channel-settings-store-ZDFXY7VY.js")
+          import("./channel-management-service-KHPAWCX7.js"),
+          import("./channel-settings-store-GQUCL2YM.js")
         ]);
         return createChannelManagementService({
           workspaceCwd: targetRuntime.workspaceCwd,
@@ -6816,8 +7160,8 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         { createWorkspaceTrustReconciler },
         { createDaemonTrustPolicyMonitor }
       ] = await Promise.all([
-        import("./workspace-trust-reconciler-DB5ERSUN.js"),
-        import("./daemon-trust-policy-monitor-JA2WZRZ3.js")
+        import("./workspace-trust-reconciler-XU6WB2MF.js"),
+        import("./daemon-trust-policy-monitor-NFO3OIBN.js")
       ]);
       const materializationFor = /* @__PURE__ */ __name((entry, snapshot, decision) => {
         const boundWorkspaces2 = entry.primary && decision.targetTrusted ? runtime.resolveBoundWorkspacesFromIdeEnv(
@@ -6912,7 +7256,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
             handle?.disposeWorkspace(runtimeToDispose.workspaceId);
             const deadline = Date.now() + 1e3;
             while ((handle?.getWorkspaceActivity(runtimeToDispose.workspaceId).memoryTasks ?? 0) > 0 && Date.now() < deadline) {
-              await new Promise((resolve3) => setTimeout(resolve3, 25));
+              await new Promise((resolve4) => setTimeout(resolve4, 25));
             }
             if ((handle?.getWorkspaceActivity(runtimeToDispose.workspaceId).memoryTasks ?? 0) > 0) {
               throw new Error(
@@ -7032,7 +7376,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
     );
   }
   const channelValidationSettingsRuntime = opts.channelSelection ? await loadSettingsRuntimeModules() : void 0;
-  const channelValidationTrustPolicy = opts.channelSelection ? await import("./daemon-trust-policy-5QJHAS3N.js") : void 0;
+  const channelValidationTrustPolicy = opts.channelSelection ? await import("./daemon-trust-policy-S6LBG4WN.js") : void 0;
   const channelValidationTrustSnapshot = channelValidationTrustPolicy ? await channelValidationTrustPolicy.readDaemonTrustPolicySnapshot() : void 0;
   const resolveChannelWorkspaceGroupsAtListen = /* @__PURE__ */ __name(() => {
     if (!opts.channelSelection || !channelValidationSettingsRuntime || !channelRuntime) {
@@ -7138,7 +7482,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
   if (opts.channelSelection) {
     reserveChannelServicePidfile(opts.channelSelection);
   }
-  return await new Promise((resolve3, reject) => {
+  return await new Promise((resolve4, reject) => {
     let closeHost;
     const onListening = /* @__PURE__ */ __name((error) => {
       if (error) return;
@@ -8108,7 +8452,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         loggerPublished = true;
         loggerLifecycle.published();
         void (liveDiscoveryPublish ?? Promise.resolve()).then(
-          () => resolve3(handle)
+          () => resolve4(handle)
         );
       } else {
         void runtimeReady.then(
@@ -8116,7 +8460,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
             await liveDiscoveryPublish;
             loggerPublished = true;
             loggerLifecycle.published();
-            resolve3(handle);
+            resolve4(handle);
           },
           (err) => {
             void handle.close().then(
@@ -8165,10 +8509,10 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       drainHost: /* @__PURE__ */ __name(() => {
         if (closeHost) return closeHost();
         if (!server.listening) return Promise.resolve();
-        return new Promise((resolve4, rejectClose) => {
+        return new Promise((resolve5, rejectClose) => {
           server.close((error) => {
             if (error) rejectClose(error);
-            else resolve4();
+            else resolve5();
           });
         });
       }, "drainHost")