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

package/chunks/{run-qwen-serve-3QSGRXAN.js → run-qwen-serve-DC5RXI6N.js}

@@ -36,10 +36,11 @@ import {
   resolveAcpHttpEnabled,
   setDeferredRuntimeRequestTiming,
   toDaemonStatusMemoryLimits
-} from "./chunk-O565M6A4.js";
+} from "./chunk-DRVS6K7A.js";
 import "./chunk-VGHZT6JR.js";
 import {
-  isLoopbackBind
+  isLoopbackBind,
+  normalizeSessionIdForLookup
 } from "./chunk-TQOF5KBL.js";
 import {
   formatMemoryBudgetStderr,
@@ -47,9 +48,16 @@ import {
   serveJournalGrowthPoolMb
 } from "./chunk-UXEO7E3V.js";
 import "./chunk-NYWWQ437.js";
+import {
+  require_express,
+  resolveWebShellDir
+} from "./chunk-O5Z7EB6Y.js";
 import {
   resolveSessionRestoreTimeoutMs
 } from "./chunk-4JRM2BSM.js";
+import {
+  LIVE_HOST_PROTOCOL_VERSION
+} from "./chunk-NKLP3DCK.js";
 import {
   DEFAULT_COMPACTED_REPLAY_MAX_BYTES,
   DEFAULT_MAX_JOURNAL_BYTES,
@@ -59,39 +67,25 @@ import {
   normalizeMaxJournalBytes,
   normalizeMaxJournalEvents
 } from "./chunk-WCCLLK7X.js";
-import {
-  require_express,
-  resolveWebShellDir
-} from "./chunk-GDXET5XU.js";
+import "./chunk-HMJ2P3SV.js";
 import {
   resolveChannelCwd
 } from "./chunk-45NQKMYB.js";
-import {
-  LIVE_HOST_PROTOCOL_VERSION
-} from "./chunk-NKLP3DCK.js";
-import "./chunk-K6KS3LTN.js";
-import "./chunk-FC4KQFCS.js";
-import "./chunk-T3CHYWJZ.js";
-import {
-  consumeServeFastPathRejectedLoaderKeys,
-  loadServeFastPathSettings,
-  preResolveServeFastPathHomeEnvOverrides
-} from "./chunk-M6NDLY2T.js";
 import {
   MAX_REGISTERED_WORKSPACES,
   resolveWorkspaceInputs,
   workspaceRegistrationId
-} from "./chunk-JNDY2MDR.js";
-import "./chunk-AA2BEKV3.js";
+} from "./chunk-TLDZKNZP.js";
+import "./chunk-CTAP6PO3.js";
 import {
   LOAD_REPLAY_META_KEY
-} from "./chunk-S5DWMTHO.js";
+} from "./chunk-QQUVPMMZ.js";
 import "./chunk-624NHDGB.js";
 import {
   canonicalizeWorkspace,
   translateAndCheckAbsoluteWorkspacePath
 } from "./chunk-6PLDPT2C.js";
-import "./chunk-4W5U2TUT.js";
+import "./chunk-4F5WV4RF.js";
 import "./chunk-FYJ7W2PI.js";
 import "./chunk-Z7B6SRPM.js";
 import {
@@ -99,7 +93,7 @@ import {
   ChannelWebhookEnqueueError,
   QWEN_SERVER_TOKEN_ENV,
   isChannelDeliveryError
-} from "./chunk-YP5KH5Y7.js";
+} from "./chunk-ND7NOI4P.js";
 import {
   normalizeWorkerDiagnostic,
   sanitizeWorkerDiagnostic
@@ -107,8 +101,7 @@ import {
 import {
   channelSelectionNames
 } from "./chunk-ALMR3E6Q.js";
-import "./chunk-HIBNSEJE.js";
-import "./chunk-M5GB774H.js";
+import "./chunk-UDG5EZJI.js";
 import {
   EXTERNAL_TOOL_GUARD_PROVIDER_ATTACHED_VALUE,
   EXTERNAL_TOOL_GUARD_REQUIRED_VALUE,
@@ -116,13 +109,21 @@ import {
   PRIVATE_EXTERNAL_TOOL_GUARD_ENV,
   PRIVATE_EXTERNAL_TOOL_GUARD_PROVIDER_ENV
 } from "./chunk-3VUENPWF.js";
+import "./chunk-M5GB774H.js";
+import {
+  MAX_DAEMON_WORKSPACES
+} from "./chunk-5HBA2Z7V.js";
+import "./chunk-K6KS3LTN.js";
+import "./chunk-7E7UCJHS.js";
 import {
   sanitizeLogText
 } from "./chunk-AW27A43Y.js";
 import "./chunk-IW6RQPQB.js";
 import {
-  MAX_DAEMON_WORKSPACES
-} from "./chunk-5HBA2Z7V.js";
+  consumeServeFastPathRejectedLoaderKeys,
+  loadServeFastPathSettings,
+  preResolveServeFastPathHomeEnvOverrides
+} from "./chunk-LD5VIJ7S.js";
 import "./chunk-GOXKNSDZ.js";
 import {
   getGlobalQwenDirLite,
@@ -133,23 +134,23 @@ import {
   clearLoaderKeyRejectionReporterIfCurrent,
   scrubInheritedLoaderEnv,
   setLoaderKeyRejectionReporter
-} from "./chunk-MS7GNABG.js";
+} from "./chunk-CXJHQVEK.js";
 import {
   getCliVersion
-} from "./chunk-CU6GJD55.js";
+} from "./chunk-7WLFSDLG.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";
 import "./chunk-CQ35AJ4Z.js";
+import "./chunk-5M6IDOMF.js";
 import {
   require_proper_lockfile
 } from "./chunk-MLXTMF7H.js";
-import "./chunk-CR3C7WXL.js";
 import "./chunk-XWRJCPHC.js";
 import {
   finalizeStartupProfile,
@@ -167,7 +168,7 @@ import {
   init_esm,
   isSpanContextValid,
   trace
-} from "./chunk-QUGAUQGJ.js";
+} from "./chunk-TBWQLLFO.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -1388,7 +1389,7 @@ function createConcreteLogger(input) {
         }
       });
       let timeout;
-      const deadline = new Promise((resolve3) => {
+      const deadline = new Promise((resolve4) => {
         timeout = setTimeout(() => {
           try {
             input.warnOnce(
@@ -1397,7 +1398,7 @@ function createConcreteLogger(input) {
             );
           } catch {
           } finally {
-            resolve3();
+            resolve4();
           }
         }, input.policy.closeDrainBudgetMs);
         timeout.unref();
@@ -1743,61 +1744,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;
+  }
+  static {
+    __name(this, "ConversationDirectoryIdentityError");
+  }
+  name = "ConversationDirectoryIdentityError";
+};
+function throwIdentityIoError(scope, cause) {
+  throw new ConversationDirectoryIdentityError(scope, "io_error", cause);
+}
+__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(sessionId).digest("hex")}`;
+  return `conversation-${createHash2("sha256").update(storageSessionId).digest("hex")}`;
 }
-__name(conversationDirectoryName, "conversationDirectoryName");
-function validateRootStats(stats, label = "root") {
+__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 +1826,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");
   }
-  const canonical = await realpath(root.configuredRoot);
-  if (!isSamePath(canonical, root.canonicalRoot)) {
-    throw new Error("Live conversation root canonical path 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"
+    );
+  }
+  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 +2076,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 +2086,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 +2148,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 +3089,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 +3344,12 @@ __name(hasRetryableChannelWorkerShutdownError, "hasRetryableChannelWorkerShutdow
 var channelWorkerRuntimePromise;
 async function loadChannelWorkerRuntime() {
   channelWorkerRuntimePromise ??= Promise.all([
-    import("./channel-worker-supervisor-OEVWBHGT.js"),
-    import("./pidfile-4XSFLYBZ.js"),
-    import("./runtime-5MLLZ7DC.js"),
+    import("./channel-worker-supervisor-F6I6WSWW.js"),
+    import("./pidfile-EBKS2HBK.js"),
+    import("./runtime-UVEETF54.js"),
     import("./cli-entry-path-4VJ3Y6T2.js"),
-    import("./channel-worker-group-7LXCMZ77.js"),
-    import("./channel-worker-manager-RYEME4ZZ.js")
+    import("./channel-worker-group-CTE54QL6.js"),
+    import("./channel-worker-manager-4EHTD3T4.js")
   ]).then(
     ([
       supervisor,
@@ -3148,13 +3454,13 @@ function shouldPreheatBridge(deps) {
 __name(shouldPreheatBridge, "shouldPreheatBridge");
 var coreRuntimePromise;
 function loadCoreRuntime() {
-  coreRuntimePromise ??= import("./core-runtime-7VMIKUTG.js");
+  coreRuntimePromise ??= import("./core-runtime-JWFNKO2S.js");
   return coreRuntimePromise;
 }
 __name(loadCoreRuntime, "loadCoreRuntime");
 var liveDiscoveryRuntimePromise;
 function loadLiveDiscoveryRuntime() {
-  liveDiscoveryRuntimePromise ??= import("./discovery-ORA5J7YP.js");
+  liveDiscoveryRuntimePromise ??= import("./discovery-X2NV535U.js");
   return liveDiscoveryRuntimePromise;
 }
 __name(loadLiveDiscoveryRuntime, "loadLiveDiscoveryRuntime");
@@ -3184,10 +3490,10 @@ __name(resolveDaemonLogBaseDirForRun, "resolveDaemonLogBaseDirForRun");
 var settingsRuntimePromise;
 function loadSettingsRuntimeModules() {
   settingsRuntimePromise ??= Promise.all([
-    import("./settings-D5644OM5.js"),
-    import("./environment-S7CTIHMX.js"),
-    import("./loadedSettingsAdapter-T6TV4YJ7.js"),
-    import("./trustedFolders-LK6T4XC7.js")
+    import("./settings-NS3PXZDP.js"),
+    import("./environment-C2CZN7CB.js"),
+    import("./loadedSettingsAdapter-47DG424L.js"),
+    import("./trustedFolders-7GEI2NYC.js")
   ]).then(([settings, environment, loadedSettingsAdapter, trustedFolders]) => ({
     settings,
     environment,
@@ -3200,8 +3506,8 @@ __name(loadSettingsRuntimeModules, "loadSettingsRuntimeModules");
 var channelWebhookConfigRuntimePromise;
 function loadChannelWebhookConfigRuntime() {
   channelWebhookConfigRuntimePromise ??= Promise.all([
-    import("./runtime-5MLLZ7DC.js"),
-    import("./config-utils-IVHRSXWI.js")
+    import("./runtime-UVEETF54.js"),
+    import("./config-utils-3DY73VIJ.js")
   ]).then(([channelRuntime, configUtils]) => ({
     loadChannelsConfig: channelRuntime.loadChannelsConfig,
     parseChannelWebhookConfig: configUtils.parseChannelWebhookConfig
@@ -3224,19 +3530,21 @@ async function loadServeRuntimeModules() {
     workspaceProvidersStatusModule,
     workspaceSkillsStatusModule,
     totalSessionAdmissionModule,
-    workspaceRegistryModule
+    workspaceRegistryModule,
+    promptLedgerModule
   ] = await Promise.all([
-    import("./server-TC4A7AAZ.js"),
-    import("./bridge-YNQBAA4Z.js"),
-    import("./spawnChannel-IYGXRHSQ.js"),
+    import("./server-KU7XIDVT.js"),
+    import("./bridge-2CGOUO25.js"),
+    import("./spawnChannel-FCP44P4V.js"),
     import("./process-registry-PMJOA5CO.js"),
-    import("./workspace-service-XCDQLE2Y.js"),
+    import("./workspace-service-JJZFPKM4.js"),
     import("./types-WYCFCEHR.js"),
-    import("./daemon-status-provider-ZDOYJCU6.js"),
-    import("./workspace-providers-status-2ZPZPUPZ.js"),
-    import("./workspace-skills-status-RS4O7AIJ.js"),
-    import("./total-session-admission-4KBHMQQ2.js"),
-    import("./workspace-registry-34GTUUHB.js")
+    import("./daemon-status-provider-3EI2KALQ.js"),
+    import("./workspace-providers-status-R5QTZFK3.js"),
+    import("./workspace-skills-status-DRIOZRIA.js"),
+    import("./total-session-admission-NIBNWXHE.js"),
+    import("./workspace-registry-J3RUCXH6.js"),
+    import("./prompt-terminal-ledger-5JYOPOII.js")
   ]);
   return {
     createServeApp: serverModule.createServeApp,
@@ -3256,7 +3564,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 +3742,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 +4584,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-CYNY6IP6.js");
+    const { WorkspaceRegistrationStore } = await import("./workspace-registration-store-WMSLM36M.js");
     workspaceRegistrationStore = new WorkspaceRegistrationStore(boundWorkspace);
   }
   if (workspaceRegistrationStore) {
@@ -4559,7 +4868,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       "qwen serve: required external tool guard handshake succeeded."
     );
   }
-  const { createDaemonToolGuard } = await import("./daemon-git-worktree-guard-DXYIMWFT.js");
+  const { createDaemonToolGuard } = await import("./daemon-git-worktree-guard-6233JAPJ.js");
   const daemonToolGuardHandler = createDaemonToolGuard(
     externalToolGuardHandler
   );
@@ -4602,8 +4911,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 +4942,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(() => {
@@ -4848,6 +5157,14 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         );
       }
     }
+    const localControlService = app2.locals?.["localControlService"];
+    if (localControlService) {
+      void localControlService.dispose().catch((err) => {
+        daemonLog.warn(
+          `Local Control dispose error: ${err instanceof Error ? err.message : String(err)}`
+        );
+      });
+    }
     const acpHandle = app2.locals?.["acpHandle"];
     if (acpHandle?.dispose) {
       try {
@@ -4887,7 +5204,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       loadCoreRuntime(),
       loadSettingsRuntimeModules(),
       cliVersionPromise,
-      import("./daemon-trust-policy-E67OYUK2.js")
+      import("./daemon-trust-policy-QWWU7CON.js")
     ]);
     cliVersion = resolvedCliVersion;
     settingsRuntime.environment.preResolveHomeEnvOverrides();
@@ -4980,6 +5297,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
@@ -5259,7 +5580,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         resolveSkillSettings,
         skillSettingStrings,
         updateWorkspaceSkillSettingLists
-      } = await import("./skill-settings-J65JKKES.js");
+      } = await import("./skill-settings-EXW7ESWJ.js");
       const fresh = loadSettingsForPersistence(workspace);
       const normalizedName = skillName.trim().toLowerCase();
       const resolved = resolveSkillSettings(fresh);
@@ -5324,7 +5645,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         resolveSkillSettings,
         skillSettingStrings,
         updateWorkspaceSkillSettingLists
-      } = await import("./skill-settings-J65JKKES.js");
+      } = await import("./skill-settings-EXW7ESWJ.js");
       const fresh = loadSettingsForPersistence(workspace);
       const resolved = resolveSkillSettings(fresh);
       const initialDisabled = skillSettingStrings(
@@ -5429,7 +5750,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         );
       }
     }), "persistSettingsFn");
-    const { createSubSessionLauncher } = await import("./create-sub-session-2L5MQRN4.js");
+    const { createSubSessionLauncher } = await import("./create-sub-session-33HIYIJE.js");
     const subSessionLauncher = createSubSessionLauncher({
       getBridge: /* @__PURE__ */ __name(() => bridgeRef, "getBridge"),
       boundWorkspace,
@@ -5438,6 +5759,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,
@@ -5474,6 +5799,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,
@@ -5753,6 +6084,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(
@@ -5787,6 +6122,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,
@@ -6125,6 +6464,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(
@@ -6157,6 +6500,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,
@@ -6604,8 +6955,8 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
           { createChannelManagementService },
           { WorkspaceChannelSettingsStore }
         ] = await Promise.all([
-          import("./channel-management-service-GWY2GAIC.js"),
-          import("./channel-settings-store-WNWYFHG7.js")
+          import("./channel-management-service-FUJ2EFTF.js"),
+          import("./channel-settings-store-AZKNHHDC.js")
         ]);
         return createChannelManagementService({
           workspaceCwd: targetRuntime.workspaceCwd,
@@ -6808,8 +7159,8 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         { createWorkspaceTrustReconciler },
         { createDaemonTrustPolicyMonitor }
       ] = await Promise.all([
-        import("./workspace-trust-reconciler-AYGXC7A3.js"),
-        import("./daemon-trust-policy-monitor-RYYGCQ3J.js")
+        import("./workspace-trust-reconciler-YAYSN6CX.js"),
+        import("./daemon-trust-policy-monitor-FH7GBAKN.js")
       ]);
       const materializationFor = /* @__PURE__ */ __name((entry, snapshot, decision) => {
         const boundWorkspaces2 = entry.primary && decision.targetTrusted ? runtime.resolveBoundWorkspacesFromIdeEnv(
@@ -6904,7 +7255,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(
@@ -7004,7 +7355,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
     // through (and start the runtime) exactly like the warm app would.
     // Dynamic import keeps web-shell-static out of the serve fast-path
     // static closure (see the import-boundary guards in fast-path.test.ts).
-    isPreAuthRequest: webShellMounted ? (req) => import("./web-shell-static-O73YPVVC.js").then(
+    isPreAuthRequest: webShellMounted ? (req) => import("./web-shell-static-3NUTRHAH.js").then(
       (webShellStatic) => webShellStatic.isPreAuthWebShellRequest(req)
     ) : void 0
   });
@@ -7024,7 +7375,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
     );
   }
   const channelValidationSettingsRuntime = opts.channelSelection ? await loadSettingsRuntimeModules() : void 0;
-  const channelValidationTrustPolicy = opts.channelSelection ? await import("./daemon-trust-policy-E67OYUK2.js") : void 0;
+  const channelValidationTrustPolicy = opts.channelSelection ? await import("./daemon-trust-policy-QWWU7CON.js") : void 0;
   const channelValidationTrustSnapshot = channelValidationTrustPolicy ? await channelValidationTrustPolicy.readDaemonTrustPolicySnapshot() : void 0;
   const resolveChannelWorkspaceGroupsAtListen = /* @__PURE__ */ __name(() => {
     if (!opts.channelSelection || !channelValidationSettingsRuntime || !channelRuntime) {
@@ -7130,7 +7481,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;
@@ -7811,6 +8162,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         webShellMounted,
         resolvedToken: token,
         runtimeReady,
+        getLocalControl: /* @__PURE__ */ __name(() => (runtimeApp ?? runtimeAppForCleanup)?.locals?.["localControlService"], "getLocalControl"),
         close: /* @__PURE__ */ __name(() => {
           if (closePromise) return closePromise;
           closePromise = new Promise((res, rej) => {
@@ -8099,7 +8451,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         loggerPublished = true;
         loggerLifecycle.published();
         void (liveDiscoveryPublish ?? Promise.resolve()).then(
-          () => resolve3(handle)
+          () => resolve4(handle)
         );
       } else {
         void runtimeReady.then(
@@ -8107,7 +8459,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
             await liveDiscoveryPublish;
             loggerPublished = true;
             loggerLifecycle.published();
-            resolve3(handle);
+            resolve4(handle);
           },
           (err) => {
             void handle.close().then(
@@ -8156,10 +8508,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")
@@ -8172,7 +8524,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       const handleError = /* @__PURE__ */ __name((err) => {
         server.removeListener("listening", handleListening);
         const nextPort = attemptPort + 1;
-        if (err.code === "EADDRINUSE" && opts.strictPort !== true && opts.port !== 0 && nextPort <= 65535 && attempt < MAX_PORT_ATTEMPTS - 1) {
+        if (err.code === "EADDRINUSE" && opts.port !== 0 && nextPort <= 65535 && attempt < MAX_PORT_ATTEMPTS - 1) {
           writeStderrLine(
             `qwen serve: port ${attemptPort} is in use, trying ${nextPort}...`
           );