@qwen-code/qwen-code 0.22.0 → 0.22.2-nightly.20260828.7357136dd1

package/chunks/{run-qwen-serve-XJHOW2NY.js → run-qwen-serve-DXBCYW7V.js}

@@ -3,6 +3,9 @@
 import {
   computeCpuPercent
 } from "./chunk-LBOVL47Y.js";
+import {
+  resolveServeToken
+} from "./chunk-ZELCTN6Y.js";
 import {
   RUNTIME_STARTUP_CANCELLED_MESSAGE
 } from "./chunk-QUPXZXLV.js";
@@ -35,30 +38,38 @@ import {
   positiveFiniteOrNull,
   prepareManagedScratchRoot,
   resolveAcpHttpEnabled,
-  setDeferredRuntimeRequestTiming,
   toDaemonStatusMemoryLimits
-} from "./chunk-UUQFJILB.js";
-import "./chunk-VGHZT6JR.js";
+} from "./chunk-RFI4YGMR.js";
 import {
-  isLoopbackBind,
-  normalizeSessionIdForLookup
-} from "./chunk-TQOF5KBL.js";
+  ConversationDirectoryIdentityError,
+  assertExactConversationRootIdentity,
+  createConversationRootIdentity,
+  getConversationDirectoryName,
+  getConversationStagedDirectoryName,
+  inspectConversationDirectoryIdentity,
+  inspectConversationStagedDirectoryIdentity,
+  isSameConversationDirectoryObject,
+  materializeConversationDirectoryIdentity,
+  revalidateConversationRootIdentity
+} from "./chunk-U54AYGEC.js";
+import {
+  isLoopbackBind
+} from "./chunk-RXFQM6FQ.js";
 import {
   formatMemoryBudgetStderr,
   resolveDaemonMemoryBudget,
   serveJournalGrowthPoolMb
 } from "./chunk-UXEO7E3V.js";
-import "./chunk-NYWWQ437.js";
 import {
-  require_express,
-  resolveWebShellDir
-} from "./chunk-O5Z7EB6Y.js";
+  setDeferredRuntimeRequestTiming
+} from "./chunk-RNVFRIOO.js";
+import {
+  normalizeSessionIdForLookup
+} from "./chunk-ZEZKIS2K.js";
+import "./chunk-NYWWQ437.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,
@@ -68,40 +79,63 @@ import {
   normalizeMaxJournalBytes,
   normalizeMaxJournalEvents
 } from "./chunk-WCCLLK7X.js";
-import "./chunk-HMJ2P3SV.js";
+import {
+  require_express
+} from "./chunk-AYHQZBJ4.js";
+import {
+  resolveWebShellDir
+} from "./chunk-FBX2SDQ4.js";
 import {
   resolveChannelCwd
-} from "./chunk-45NQKMYB.js";
+} from "./chunk-HVC3PNVC.js";
+import {
+  LIVE_HOST_PROTOCOL_VERSION
+} from "./chunk-NKLP3DCK.js";
+import "./chunk-K6KS3LTN.js";
+import "./chunk-HMJ2P3SV.js";
+import "./chunk-7E7UCJHS.js";
+import {
+  consumeServeFastPathRejectedLoaderKeys,
+  loadServeFastPathSettings,
+  preResolveServeFastPathHomeEnvOverrides
+} from "./chunk-TWSKM647.js";
 import {
   MAX_REGISTERED_WORKSPACES,
   resolveWorkspaceInputs,
   workspaceRegistrationId
-} from "./chunk-BUGYW6FB.js";
-import "./chunk-IOSEW6KP.js";
+} from "./chunk-LEGTMYAE.js";
+import "./chunk-G6FECKTJ.js";
 import {
   LOAD_REPLAY_META_KEY
-} from "./chunk-LURJYO2T.js";
-import "./chunk-624NHDGB.js";
+} from "./chunk-OZ6KS6KW.js";
+import "./chunk-ERFDKH32.js";
 import {
   canonicalizeWorkspace,
   translateAndCheckAbsoluteWorkspacePath
 } from "./chunk-6PLDPT2C.js";
-import "./chunk-4F5WV4RF.js";
+import {
+  ExtraCaInspectionError,
+  loadableCertificates
+} from "./chunk-ISKH4QX3.js";
 import "./chunk-FYJ7W2PI.js";
 import "./chunk-Z7B6SRPM.js";
 import {
-  ChannelDeliveryError,
-  ChannelWebhookEnqueueError,
-  QWEN_SERVER_TOKEN_ENV,
-  isChannelDeliveryError
-} from "./chunk-ND7NOI4P.js";
+  ChannelWebhookEnqueueError
+} from "./chunk-STUJ7IMZ.js";
+import {
+  QWEN_SERVER_TOKEN_ENV
+} from "./chunk-GYTKQYDB.js";
 import {
   normalizeWorkerDiagnostic,
   sanitizeWorkerDiagnostic
-} from "./chunk-A6NRNRKE.js";
+} from "./chunk-RFIDDFAL.js";
 import {
   channelSelectionNames
 } from "./chunk-ALMR3E6Q.js";
+import {
+  ChannelDeliveryError,
+  isChannelDeliveryError
+} from "./chunk-RKFGE7JH.js";
 import "./chunk-UDG5EZJI.js";
 import {
   EXTERNAL_TOOL_GUARD_PROVIDER_ATTACHED_VALUE,
@@ -114,17 +148,10 @@ 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";
+} from "./chunk-ICURCKIU.js";
 import "./chunk-IW6RQPQB.js";
-import {
-  consumeServeFastPathRejectedLoaderKeys,
-  loadServeFastPathSettings,
-  preResolveServeFastPathHomeEnvOverrides
-} from "./chunk-LD5VIJ7S.js";
 import "./chunk-GOXKNSDZ.js";
 import {
   getGlobalQwenDirLite,
@@ -135,20 +162,20 @@ import {
   clearLoaderKeyRejectionReporterIfCurrent,
   scrubInheritedLoaderEnv,
   setLoaderKeyRejectionReporter
-} from "./chunk-CXJHQVEK.js";
+} from "./chunk-5PA6UEYA.js";
 import {
   getCliVersion
-} from "./chunk-RDG44S5I.js";
-import "./chunk-YLFLHKDL.js";
+} from "./chunk-GGNE3JAW.js";
+import "./chunk-W3N5XAZ6.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";
@@ -181,10 +208,12 @@ import {
 // packages/cli/src/serve/run-qwen-serve.ts
 init_esbuild_shims();
 var import_express = __toESM(require_express(), 1);
-import { X509Certificate, createHash as createHash3, timingSafeEqual } from "node:crypto";
+import { X509Certificate, createHash as createHash2, timingSafeEqual } from "node:crypto";
+import { execFile } from "node:child_process";
 import * as fs from "node:fs";
 import { createServer } from "node:http";
 import * as https from "node:https";
+import { isIP } from "node:net";
 import * as path from "node:path";
 import * as os from "node:os";
 import { monitorEventLoopDelay, performance as performance2 } from "node:perf_hooks";
@@ -597,11 +626,11 @@ async function ensureRealDirectory(fs2, dirPath, mutationAllowed = () => true) {
 __name(ensureRealDirectory, "ensureRealDirectory");
 async function activeFileSize(fs2, activePath) {
   try {
-    const stat = await fs2.lstat(activePath);
-    if (!stat.isFile() || stat.isSymbolicLink()) {
+    const stat2 = await fs2.lstat(activePath);
+    if (!stat2.isFile() || stat2.isSymbolicLink()) {
       throw new Error(`${activePath} is not a regular file`);
     }
-    return stat.size;
+    return stat2.size;
   } catch (error) {
     if (isErrno(error, "ENOENT")) return 0;
     throw error;
@@ -1022,8 +1051,8 @@ __name(closeFallbackFamily, "closeFallbackFamily");
 async function cleanupFallbacksBestEffort(input) {
   const runsDir = nodePath.join(input.daemonDir, "runs");
   try {
-    const stat = await input.fs.lstat(runsDir);
-    if (!stat.isDirectory() || stat.isSymbolicLink()) {
+    const stat2 = await input.fs.lstat(runsDir);
+    if (!stat2.isDirectory() || stat2.isSymbolicLink()) {
       throw new Error(`${runsDir} is not a real directory`);
     }
   } catch (error) {
@@ -1390,7 +1419,7 @@ function createConcreteLogger(input) {
         }
       });
       let timeout;
-      const deadline = new Promise((resolve4) => {
+      const deadline = new Promise((resolve3) => {
         timeout = setTimeout(() => {
           try {
             input.warnOnce(
@@ -1399,7 +1428,7 @@ function createConcreteLogger(input) {
             );
           } catch {
           } finally {
-            resolve4();
+            resolve3();
           }
         }, input.policy.closeDrainBudgetMs);
         timeout.unref();
@@ -1745,251 +1774,10 @@ __name(initDaemonLogger, "initDaemonLogger");
 
 // packages/cli/src/serve/conversations/conversation-workspace.ts
 init_esbuild_shims();
-import { readdir, rmdir } from "node:fs/promises";
+import { constants as fsConstants } from "node:fs";
+import { open, readdir, rename, rm, rmdir, stat } 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";
-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(storageSessionId).digest("hex")}`;
-}
-__name(getConversationDirectoryName, "getConversationDirectoryName");
-function validateDirectoryStats(stats, scope) {
-  if (stats.isSymbolicLink() || !stats.isDirectory()) {
-    throw new ConversationDirectoryIdentityError(scope, "not_directory");
-  }
-  if (process.platform !== "win32" && typeof process.getuid === "function" && stats.uid !== process.getuid()) {
-    throw new ConversationDirectoryIdentityError(scope, "wrong_owner");
-  }
-  if (process.platform !== "win32" && (stats.mode & 63) !== 0) {
-    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) {
-    let existing;
-    try {
-      existing = await lstat(configuredRoot);
-    } catch {
-      throwIdentityIoError("root", error);
-    }
-    validateDirectoryStats(existing, "root");
-    throwIdentityIoError("root", error);
-  }
-  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,
-    inodeVerifiable: hasVerifiableInode(after.ino)
-  };
-}
-__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"
-    );
-  }
-  let canonicalStats;
-  try {
-    canonicalStats = await lstat(root.canonicalRoot);
-  } catch (error) {
-    throwIdentityIoError("root", error);
-  }
-  validateDirectoryStats(canonicalStats, "root");
-  if (!hasRootIdentity(canonicalStats, root)) {
-    throw new ConversationDirectoryIdentityError("root", "identity_changed");
-  }
-  return root;
-}
-__name(revalidateConversationRootIdentity, "revalidateConversationRootIdentity");
-async function assertExactConversationRootIdentity(root, candidate) {
-  await revalidateConversationRootIdentity(root);
-  const resolvedCandidate = resolve(candidate);
-  if (!isSameConversationPath(resolvedCandidate, root.configuredRoot) && !isSameConversationPath(resolvedCandidate, root.canonicalRoot)) {
-    throw new ConversationDirectoryIdentityError("root", "unexpected_identity");
-  }
-  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") return void 0;
-    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
+import { join as join2, resolve } from "node:path";
 function liveIdentityError(error, exactRoot = false, creatingRoot = false) {
   if (!(error instanceof ConversationDirectoryIdentityError)) throw error;
   if (error.reason === "io_error" && error.cause !== void 0) {
@@ -2047,7 +1835,7 @@ function liveIdentityError(error, exactRoot = false, creatingRoot = false) {
 }
 __name(liveIdentityError, "liveIdentityError");
 function getConversationRootPath(homeDir = homedir()) {
-  return resolve2(homeDir, "Documents", "Qwen Code", "Conversations");
+  return resolve(homeDir, "Documents", "Qwen Code", "Conversations");
 }
 __name(getConversationRootPath, "getConversationRootPath");
 async function revalidateConversationRoot(root) {
@@ -2231,6 +2019,171 @@ var ConversationWorkspace = class {
       throw error;
     }
   }
+  async inspectStandaloneDeletionPaths(storageSessionId, expected) {
+    const root = await this.revalidateStandaloneRoot();
+    try {
+      const normal = await inspectConversationDirectoryIdentity(
+        root,
+        storageSessionId
+      );
+      const staged = await inspectConversationStagedDirectoryIdentity(
+        root,
+        storageSessionId
+      );
+      if (normal && staged) {
+        throw new ConversationDirectoryIdentityError(
+          "child",
+          "unexpected_identity"
+        );
+      }
+      const identity = normal ?? staged;
+      if (identity && expected && !isSameConversationDirectoryObject(identity, expected)) {
+        throw new ConversationDirectoryIdentityError(
+          "child",
+          "unexpected_identity"
+        );
+      }
+      if (normal) return { status: "normal", identity: normal };
+      if (staged) return { status: "staged", identity: staged };
+      return { status: "absent" };
+    } catch (error) {
+      if (error instanceof ConversationDirectoryIdentityError && error.scope === "child") {
+        return { status: "compromised", error };
+      }
+      throw error;
+    }
+  }
+  async createStandaloneDeletionExpectation(storageSessionId, recorded) {
+    if (recorded.inodeVerifiable !== (recorded.inode !== 0)) {
+      throw new ConversationDirectoryIdentityError(
+        "child",
+        "unexpected_identity"
+      );
+    }
+    const root = await this.revalidateStandaloneRoot();
+    const name = getConversationDirectoryName(storageSessionId);
+    return {
+      root,
+      storageSessionId,
+      name,
+      canonicalPath: join2(root.canonicalRoot, name),
+      device: recorded.device,
+      inode: recorded.inode
+    };
+  }
+  async stageStandaloneDirectory(storageSessionId, expected) {
+    const inspected = await this.inspectStandaloneDeletionPaths(
+      storageSessionId,
+      expected
+    );
+    if (inspected.status === "compromised") throw inspected.error;
+    if (inspected.status !== "normal") {
+      throw new ConversationDirectoryIdentityError("child", "identity_changed");
+    }
+    const root = await this.revalidateStandaloneRoot();
+    await rename(
+      inspected.identity.canonicalPath,
+      join2(
+        root.canonicalRoot,
+        getConversationStagedDirectoryName(storageSessionId)
+      )
+    );
+    await revalidateConversationRootIdentity(root);
+    const staged = await inspectConversationStagedDirectoryIdentity(
+      root,
+      storageSessionId
+    );
+    if (!staged || !isSameConversationDirectoryObject(staged, inspected.identity)) {
+      throw new ConversationDirectoryIdentityError("child", "identity_changed");
+    }
+    await this.syncStandaloneRoot(root);
+    return staged;
+  }
+  async restoreStagedStandaloneDirectory(storageSessionId, expected) {
+    const inspected = await this.inspectStandaloneDeletionPaths(
+      storageSessionId,
+      expected
+    );
+    if (inspected.status === "compromised") throw inspected.error;
+    if (inspected.status !== "staged") {
+      throw new ConversationDirectoryIdentityError("child", "identity_changed");
+    }
+    const root = await this.revalidateStandaloneRoot();
+    await rename(
+      inspected.identity.canonicalPath,
+      join2(root.canonicalRoot, getConversationDirectoryName(storageSessionId))
+    );
+    await revalidateConversationRootIdentity(root);
+    const restored = await inspectConversationDirectoryIdentity(
+      root,
+      storageSessionId
+    );
+    if (!restored || !isSameConversationDirectoryObject(restored, inspected.identity)) {
+      throw new ConversationDirectoryIdentityError("child", "identity_changed");
+    }
+    await this.syncStandaloneRoot(root);
+    return restored;
+  }
+  async removeStagedStandaloneDirectory(storageSessionId, expected) {
+    const inspected = await this.inspectStandaloneDeletionPaths(
+      storageSessionId,
+      expected
+    );
+    if (inspected.status === "compromised") throw inspected.error;
+    if (inspected.status !== "staged") {
+      throw new ConversationDirectoryIdentityError("child", "identity_changed");
+    }
+    const confirmed = await inspectConversationStagedDirectoryIdentity(
+      inspected.identity.root,
+      storageSessionId
+    );
+    if (!confirmed || !isSameConversationDirectoryObject(confirmed, inspected.identity)) {
+      throw new ConversationDirectoryIdentityError("child", "identity_changed");
+    }
+    await rm(confirmed.canonicalPath, { recursive: true });
+    await this.syncStandaloneRoot(confirmed.root);
+  }
+  async confirmStandaloneRootDurability(root) {
+    await this.syncStandaloneRoot(root);
+  }
+  async syncStandaloneRoot(root) {
+    await revalidateConversationRootIdentity(root);
+    let handle;
+    try {
+      handle = await open(
+        root.canonicalRoot,
+        fsConstants.O_RDONLY | (process.platform === "win32" ? 0 : fsConstants.O_NOFOLLOW ?? 0)
+      );
+      const stats = await handle.stat();
+      const inodeVerifiable = Number.isSafeInteger(stats.ino) && stats.ino > 0;
+      if (!stats.isDirectory() || stats.dev !== root.device || inodeVerifiable !== root.inodeVerifiable || root.inodeVerifiable && stats.ino !== root.inode) {
+        throw new ConversationDirectoryIdentityError(
+          "root",
+          "identity_changed"
+        );
+      }
+      try {
+        await handle.sync();
+      } catch (error) {
+        if (process.platform !== "win32" || !["EACCES", "EINVAL", "EPERM"].includes(
+          error.code ?? ""
+        )) {
+          throw error;
+        }
+      }
+      const current = await stat(root.canonicalRoot);
+      const currentInodeVerifiable = Number.isSafeInteger(current.ino) && current.ino > 0;
+      if (!current.isDirectory() || current.dev !== root.device || currentInodeVerifiable !== root.inodeVerifiable || root.inodeVerifiable && current.ino !== root.inode) {
+        throw new ConversationDirectoryIdentityError(
+          "root",
+          "identity_changed"
+        );
+      }
+    } finally {
+      await handle?.close().catch(() => void 0);
+    }
+    await revalidateConversationRootIdentity(root);
+  }
 };
 
 // packages/cli/src/serve/daemon-metrics-ring.ts
@@ -3091,8 +3044,8 @@ async function flushDaemonLogBounded(daemonLog, budgetMs) {
     await Promise.race([
       daemonLog.flush().catch(() => {
       }),
-      new Promise((resolve4) => {
-        timer = setTimeout(resolve4, budgetMs);
+      new Promise((resolve3) => {
+        timer = setTimeout(resolve3, budgetMs);
         timer.unref();
       })
     ]);
@@ -3273,14 +3226,453 @@ function workspaceRuntimeEffectiveEnv(runtime, daemonEnv) {
   return runtime.env.effectiveEnv ?? daemonEnv;
 }
 __name(workspaceRuntimeEffectiveEnv, "workspaceRuntimeEffectiveEnv");
-function formatChannelWorkerDaemonUrl(host, port) {
+function formatChannelWorkerDaemonUrl(host, port, tls = false) {
+  const scheme = tls ? "https" : "http";
   const normalized = host.trim().toLowerCase();
   if (normalized === "" || normalized === "0.0.0.0" || normalized === "::" || normalized === "[::]") {
-    return `http://127.0.0.1:${port}`;
+    return `${scheme}://127.0.0.1:${port}`;
   }
-  return `http://${formatHostForUrl(host)}:${port}`;
+  return `${scheme}://${formatHostForUrl(host)}:${port}`;
 }
 __name(formatChannelWorkerDaemonUrl, "formatChannelWorkerDaemonUrl");
+var WORKER_TLS_TRUST_PROBE = `
+import { isIP } from 'node:net';
+import * as tls from 'node:tls';
+const url = new URL(process.argv[1]);
+const timeoutMs = Number(process.argv[2]);
+const hostname = url.hostname.replace(/^\\[|\\]$/g, '');
+let socket;
+let settled = false;
+const finish = (result) => {
+  if (settled) return;
+  settled = true;
+  process.stdout.write(JSON.stringify(result));
+  socket?.destroy();
+};
+try {
+  socket = tls.connect({
+    host: hostname,
+    port: Number(url.port || '443'),
+    rejectUnauthorized: true,
+    ...(isIP(hostname) === 0 ? { servername: hostname } : {}),
+  }, () => finish({ ok: true }));
+  socket.once('error', (error) => finish({
+    ok: false,
+    code: error.code ?? 'WORKER_TLS_VERIFY_FAILED',
+    message: error.message,
+  }));
+  socket.setTimeout(timeoutMs, () => finish({
+    ok: false,
+    code: 'WORKER_TLS_VERIFY_TIMEOUT',
+    message: 'TLS verification probe timed out.',
+  }));
+} catch (error) {
+  finish({
+    ok: false,
+    code: error.code ?? 'WORKER_TLS_VERIFY_FAILED',
+    message: error.message,
+  });
+}
+`;
+async function verifyWorkerTlsTrust(opts) {
+  const timeoutMs = opts.timeoutMs ?? 5e3;
+  return new Promise((resolve3) => {
+    execFile(
+      process.execPath,
+      [
+        "--input-type=module",
+        "--eval",
+        WORKER_TLS_TRUST_PROBE,
+        opts.daemonUrl,
+        String(timeoutMs)
+      ],
+      {
+        env: {
+          ...process.env,
+          NODE_EXTRA_CA_CERTS: opts.caCertPath
+        },
+        encoding: "utf8",
+        timeout: timeoutMs + 1e3
+      },
+      (error, stdout) => {
+        try {
+          const result = JSON.parse(stdout);
+          resolve3(result.ok ? void 0 : result);
+        } catch {
+          const failure = error;
+          resolve3({
+            code: failure?.code != null ? String(failure.code) : "WORKER_TLS_VERIFY_FAILED",
+            message: failure?.message ?? "TLS verification probe failed."
+          });
+        }
+      }
+    );
+  });
+}
+__name(verifyWorkerTlsTrust, "verifyWorkerTlsTrust");
+function describeWorkerTlsTrustGaps(opts) {
+  const chain = parseCertChain(opts.cert);
+  const x509 = bootParsedLeaf(opts.cert);
+  if (!x509) {
+    return [];
+  }
+  const gaps = [];
+  const operatorChain = opts.operatorCaCert ? loadableCertificates(
+    opts.operatorCaCert.toString("utf8"),
+    opts.operatorCaCertSourcePath
+  ) : void 0;
+  const servingBlocks = loadableCertificates(
+    opts.cert.toString("utf8"),
+    opts.certSourcePath
+  );
+  const operatorDiscarded = !servingBlocks && operatorChain !== void 0;
+  const servingChain = servingBlocks === void 0 ? [
+    x509,
+    ...chain.filter(
+      (member) => member.fingerprint256 !== x509.fingerprint256
+    )
+  ] : (
+    // The loader can read blocks out of the file and still not read the
+    // block the daemon SERVES — a leaf exported by `openssl x509
+    // -trustout` carries the `TRUSTED CERTIFICATE` label, which is not one
+    // the loader takes a certificate from, so a `trusted leaf + plain root`
+    // serving file yields `servingBlocks = [root]`. Starting the walk at
+    // that root put it at depth 0, where the leaf-depth exemption below
+    // waives the CA-capability check, and the walk returned anchored with
+    // zero gaps: measured `gaps: []` at boot for a CA:FALSE root
+    // (handshake INVALID_PURPOSE) and for a CA:TRUE root without
+    // keyCertSign (handshake UNSPECIFIED), while `createSecureContext`
+    // accepts the file and the daemon boots green and silent.
+    //
+    // So anchor the walk at the certificate boot parsed, the way the
+    // `servingBlocks === undefined` fallback above already does; the
+    // remaining blocks supply the rest of the chain.
+    servingBlocks.some(
+      (block) => block.fingerprint256 === x509.fingerprint256
+    ) ? servingBlocks : [x509, ...servingBlocks]
+  );
+  const leafHeldByWorkers = servingBlocks !== void 0 && servingBlocks.some((block) => block.fingerprint256 === x509.fingerprint256);
+  const workerTrustStore = operatorChain && servingBlocks ? [...operatorChain, ...servingChain] : servingChain;
+  const anchorPath = walkWorkerAnchorPath(
+    x509,
+    workerTrustStore,
+    // The `servingBlocks === undefined` fallback prepends the leaf too, but
+    // that file already reports its own gap below and the workers receive it
+    // verbatim; only the partial-read case needs the distinction.
+    servingBlocks === void 0 || leafHeldByWorkers
+  );
+  if (opts.operatorCaCertReadError !== void 0) {
+    const servingFallbackAnchors = anchorPath.anchored && servingBlocks !== void 0;
+    gaps.push(
+      `NODE_EXTRA_CA_CERTS "${opts.operatorCaCertPath}" could not be read by the daemon (${opts.operatorCaCertReadError}), so channel workers receive no CA from it \u2014 a root-owned or mode-600 file is the usual cause, and its contents are not the problem. ` + (servingFallbackAnchors ? `--tls-cert "${opts.certPath}" carries an anchor of its own, and that file is what the workers fall back to, so their trust does not rest on this one today \u2014 whatever it was meant to add reaches nobody. Fix that file's permissions or path and restart.` : servingBlocks === void 0 ? `--tls-cert "${opts.certPath}" itself holds no block the workers' loader can read, so their fallback bundle is that file alone and it anchors nothing \u2014 fixing this CA file's permissions changes nothing; re-export the serving file as the gap below describes and restart.` : `Every worker handshake to the daemon will fail UNABLE_TO_VERIFY_LEAF_SIGNATURE unless the issuing CA is already in the workers' default trust store. Fix that file's permissions or path and restart.`)
+    );
+  } else if (opts.operatorCaCert && !operatorChain) {
+    gaps.push(
+      `NODE_EXTRA_CA_CERTS "${opts.operatorCaCertPath}" holds no PEM certificate block Node's loader can read \u2014 every -----BEGIN/END CERTIFICATE----- marker must sit alone on its own line and every block must decode, and a DER file is never read at all. Channel workers therefore receive the daemon cert alone and anchor nothing through this file. Re-export it as PEM and restart.`
+    );
+  }
+  if (!servingBlocks) {
+    gaps.push(
+      `--tls-cert "${opts.certPath}" holds no PEM certificate block Node's loader can read, so ` + (operatorDiscarded ? `the channel workers' bundle cannot be merged: they receive that file alone and NODE_EXTRA_CA_CERTS "${opts.operatorCaCertPath}" is discarded. ` : `the channel workers receive a bundle their loader takes nothing from. `) + `Every worker handshake to the daemon will fail UNABLE_TO_VERIFY_LEAF_SIGNATURE. Re-export --tls-cert as PEM with every -----BEGIN/END CERTIFICATE----- marker alone on its own line and restart.`
+    );
+  }
+  const leafPurposeDefect = tlsServerPurposeDefect(x509);
+  if (leafPurposeDefect) {
+    gaps.push(
+      `--tls-cert "${opts.certPath}" cannot be used as a TLS server certificate because ${leafPurposeDefect}. Every worker handshake to the daemon will fail INVALID_PURPOSE. Reissue the leaf with a TLS-server keyUsage and serverAuth extendedKeyUsage, then restart.`
+    );
+  }
+  if (anchorPath.nonCaTerminator) {
+    const terminatorSubject = anchorPath.nonCaTerminator.subject.replace(
+      /\r?\n/g,
+      ", "
+    );
+    gaps.push(
+      issuerRefusedForKeyUsage(anchorPath.nonCaTerminator) ? `--tls-cert "${opts.certPath}" chains up to "${terminatorSubject}", which is self-signed but whose keyUsage does not include keyCertSign, so OpenSSL refuses to let it issue the certificates below it however its basicConstraints reads. Every worker handshake to the daemon will fail "key usage does not include certificate signing" even though the chain terminates on a self-signed certificate. Reissue that certificate with keyCertSign in its keyUsage and restart \u2014 CA:TRUE alone does not fix it, and no NODE_EXTRA_CA_CERTS can anchor a self-signed certificate through anything but itself.` : `--tls-cert "${opts.certPath}" chains up to "${terminatorSubject}", which is self-signed but is not a CA \u2014 it carries basicConstraints CA:FALSE or, as an X.509 v3 certificate, no basicConstraints at all, and OpenSSL refuses to let it issue the certificates below it, so every worker handshake to the daemon will fail INVALID_PURPOSE ("unsuitable certificate purpose"). Reissue that certificate with CA:TRUE, or point NODE_EXTRA_CA_CERTS at a real CA that anchors the chain, and restart.`
+    );
+  } else if (anchorPath.incapableIssuer) {
+    const keyUsageIsTheCause = issuerRefusedForKeyUsage(
+      anchorPath.incapableIssuer
+    );
+    gaps.push(
+      `--tls-cert "${opts.certPath}" chains through "${anchorPath.incapableIssuer.subject.replace(/\r?\n/g, ", ")}", ` + (keyUsageIsTheCause ? `whose keyUsage does not include keyCertSign, so OpenSSL refuses to let it issue the certificate below it however its basicConstraints reads. Every worker handshake to the daemon will fail with an invalid-CA error even though the chain looks complete, and the issuing CA IS in their bundle. Reissue that intermediate with keyCertSign in its keyUsage and restart \u2014 pointing NODE_EXTRA_CA_CERTS elsewhere cannot fix it.` : `which is not a CA \u2014 it carries basicConstraints CA:FALSE or, as an X.509 v3 certificate, no basicConstraints at all, and OpenSSL refuses to let it issue the certificate below it. Every worker handshake to the daemon will fail INVALID_PURPOSE or INVALID_CA even though the chain looks complete. Reissue that intermediate with CA:TRUE, or point NODE_EXTRA_CA_CERTS at a chain whose intermediates are real CAs, and restart.`)
+    );
+  } else if (anchorPath.pathLengthViolation) {
+    const { cert, constraint } = anchorPath.pathLengthViolation;
+    gaps.push(
+      `--tls-cert "${opts.certPath}" chains through "${cert.subject.replace(/\r?\n/g, ", ")}", whose basicConstraints carries pathlen:${constraint} \u2014 it permits at most ${constraint} intermediate CA${constraint === 1 ? "" : "s"} below it, and this chain has more. Every worker handshake to the daemon will fail PATH_LENGTH_EXCEEDED even though every certificate in the bundle verifies. Reissue that CA with a pathlen that covers the chain, or shorten the chain, and restart.`
+    );
+  } else if (anchorPath.unheldSelfSignedLeaf) {
+    gaps.push(
+      `--tls-cert "${opts.certPath}" serves a self-signed certificate whose own PEM block is not one Node's NODE_EXTRA_CA_CERTS loader takes (a -----BEGIN TRUSTED CERTIFICATE----- block, as \`openssl x509 -trustout\` writes, is the usual cause), so the channel workers never receive that certificate \u2014 and a self-signed certificate verifies only when it is itself in the trust store. The daemon serves it fine, but every worker handshake will fail DEPTH_ZERO_SELF_SIGNED_CERT with nothing logged. Re-export --tls-cert with a plain -----BEGIN CERTIFICATE----- block and restart.`
+    );
+  } else if (!anchorPath.anchored) {
+    gaps.push(
+      `--tls-cert "${opts.certPath}" is issued by another CA (${x509.issuer.replace(/\r?\n/g, ", ")}), not self-signed, and ${!opts.operatorCaCertPath ? `no NODE_EXTRA_CA_CERTS is set` : opts.operatorCaCertReadError !== void 0 ? `NODE_EXTRA_CA_CERTS "${opts.operatorCaCertPath}" could not be read, so whatever it carries reached nobody` : operatorDiscarded ? `NODE_EXTRA_CA_CERTS "${opts.operatorCaCertPath}" was discarded together with the unloadable serving file above, whatever it carries` : `NODE_EXTRA_CA_CERTS "${opts.operatorCaCertPath}" does not carry a certificate that anchors it`}, so nothing in the channel workers' bundle anchors their trust \u2014 every worker handshake to the daemon will fail UNABLE_TO_VERIFY_LEAF_SIGNATURE unless the issuing CA is already in the workers' default trust store. ` + (operatorDiscarded ? `Re-export --tls-cert as described above and restart; NODE_EXTRA_CA_CERTS is not the file to change.` : opts.operatorCaCertReadError !== void 0 ? `Make NODE_EXTRA_CA_CERTS readable by the daemon as described above and restart.` : `Point NODE_EXTRA_CA_CERTS at the issuing CA (for mkcert: "$(mkcert -CAROOT)/rootCA.pem") and restart.`)
+    );
+  }
+  const now = Date.now();
+  for (const member of anchorPath.path) {
+    if (member.fingerprint256 === x509.fingerprint256) continue;
+    const subject = member.subject.replace(/\r?\n/g, ", ");
+    if (member.keyUsage && !member.keyUsage.includes(TLS_SERVER_AUTH_OID)) {
+      gaps.push(
+        `--tls-cert "${opts.certPath}" chains through "${subject}", whose extendedKeyUsage does not include serverAuth \u2014 every worker handshake to the daemon will fail INVALID_PURPOSE. Reissue that chain member with serverAuth in its extendedKeyUsage and restart.`
+      );
+      continue;
+    }
+    if (new Date(member.validTo).getTime() < now) {
+      gaps.push(
+        `--tls-cert "${opts.certPath}" chains through "${subject}", which expired on ${member.validTo} \u2014 every worker handshake to the daemon will fail CERT_HAS_EXPIRED. Renew that chain member and restart.`
+      );
+    } else if (new Date(member.validFrom).getTime() > now) {
+      gaps.push(
+        `--tls-cert "${opts.certPath}" chains through "${subject}", which is not yet valid (validFrom: ${member.validFrom}) \u2014 every worker handshake to the daemon will fail CERT_NOT_YET_VALID. Check that chain member's notBefore date or the system clock.`
+      );
+    }
+  }
+  const host = workerDialHost(opts.daemonUrl);
+  if (host && !certCoversHost(x509, host)) {
+    gaps.push(
+      `--tls-cert "${opts.certPath}" has no subjectAltName covering "${host}", the host channel workers dial \u2014 every worker handshake will fail ERR_TLS_CERT_ALTNAME_INVALID. Reissue the certificate with that host in its SANs and restart.`
+    );
+  }
+  return gaps;
+}
+__name(describeWorkerTlsTrustGaps, "describeWorkerTlsTrustGaps");
+var BASIC_CONSTRAINTS_OID = Buffer.from([85, 29, 19]);
+var KEY_USAGE_OID = Buffer.from([85, 29, 15]);
+var KEY_CERT_SIGN_MASK = 4;
+var TLS_SERVER_KEY_USAGE_MASK = 168;
+var TLS_SERVER_AUTH_OID = "1.3.6.1.5.5.7.3.1";
+var VERSION_TAG = 160;
+var EXTENSIONS_TAG = 163;
+var SEQUENCE_TAG = 48;
+var BOOLEAN_TAG = 1;
+var INTEGER_TAG = 2;
+function derElementAt(der, at) {
+  const tag = der[at];
+  const header = der[at + 1];
+  if (tag === void 0 || header === void 0) return void 0;
+  let start = at + 2;
+  let length = header & 127;
+  if ((header & 128) !== 0) {
+    if (length === 0 || length > 4) return void 0;
+    let value = 0;
+    for (let index = 0; index < length; index += 1) {
+      const byte = der[start + index];
+      if (byte === void 0) return void 0;
+      value = value * 256 + byte;
+    }
+    start += length;
+    length = value;
+  }
+  const end = start + length;
+  return end <= der.length ? { tag, start, end } : void 0;
+}
+__name(derElementAt, "derElementAt");
+function tbsCertificateOf(cert) {
+  const certificate = derElementAt(cert.raw, 0);
+  if (certificate?.tag !== SEQUENCE_TAG) return void 0;
+  const tbs = derElementAt(cert.raw, certificate.start);
+  return tbs?.tag === SEQUENCE_TAG ? tbs : void 0;
+}
+__name(tbsCertificateOf, "tbsCertificateOf");
+function certificateExtension(cert, oid) {
+  const der = cert.raw;
+  const tbs = tbsCertificateOf(cert);
+  if (!tbs) return void 0;
+  let at = tbs.start;
+  while (at < tbs.end) {
+    const member = derElementAt(der, at);
+    if (!member) return void 0;
+    if (member.tag !== EXTENSIONS_TAG) {
+      at = member.end;
+      continue;
+    }
+    const list = derElementAt(der, member.start);
+    if (list?.tag !== SEQUENCE_TAG) return void 0;
+    let entry = list.start;
+    while (entry < list.end) {
+      const extension = derElementAt(der, entry);
+      if (extension?.tag !== SEQUENCE_TAG) return void 0;
+      const id = derElementAt(der, extension.start);
+      if (!id) return void 0;
+      let valueAt = id.end;
+      const critical = derElementAt(der, valueAt);
+      if (critical?.tag === BOOLEAN_TAG) valueAt = critical.end;
+      const value = derElementAt(der, valueAt);
+      if (!value) return void 0;
+      if (der.subarray(id.start, id.end).equals(oid)) {
+        return der.subarray(value.start, value.end);
+      }
+      entry = extension.end;
+    }
+    return void 0;
+  }
+  return void 0;
+}
+__name(certificateExtension, "certificateExtension");
+function keyUsageAllowsCertSign(der) {
+  const bits = derElementAt(der, 0);
+  if (!bits) return false;
+  const first = der[bits.start + 1];
+  return first !== void 0 && (first & KEY_CERT_SIGN_MASK) !== 0;
+}
+__name(keyUsageAllowsCertSign, "keyUsageAllowsCertSign");
+function tlsServerPurposeDefect(cert) {
+  const keyUsage = certificateExtension(cert, KEY_USAGE_OID);
+  if (keyUsage !== void 0) {
+    const bits = derElementAt(keyUsage, 0);
+    const first = bits ? keyUsage[bits.start + 1] : void 0;
+    if (first === void 0 || (first & TLS_SERVER_KEY_USAGE_MASK) === 0) {
+      return "its keyUsage permits none of digitalSignature, keyEncipherment, or keyAgreement";
+    }
+  }
+  if (cert.keyUsage && !cert.keyUsage.includes(TLS_SERVER_AUTH_OID)) {
+    return "its extendedKeyUsage does not include serverAuth";
+  }
+  return void 0;
+}
+__name(tlsServerPurposeDefect, "tlsServerPurposeDefect");
+function isV1Certificate(cert) {
+  const tbs = tbsCertificateOf(cert);
+  return tbs !== void 0 && cert.raw[tbs.start] !== VERSION_TAG;
+}
+__name(isV1Certificate, "isV1Certificate");
+function cannotIssueCertificates(cert) {
+  const keyUsage = certificateExtension(cert, KEY_USAGE_OID);
+  if (keyUsage !== void 0 && !keyUsageAllowsCertSign(keyUsage)) return true;
+  if (certificateExtension(cert, BASIC_CONSTRAINTS_OID) !== void 0) {
+    return !cert.ca;
+  }
+  return !isV1Certificate(cert) && keyUsage === void 0;
+}
+__name(cannotIssueCertificates, "cannotIssueCertificates");
+function isSelfSignedCert(x509) {
+  if (x509.subject !== x509.issuer) return false;
+  try {
+    return x509.verify(x509.publicKey);
+  } catch {
+    return true;
+  }
+}
+__name(isSelfSignedCert, "isSelfSignedCert");
+var PEM_CERTIFICATE_BLOCK = /-----BEGIN CERTIFICATE-----[^-]*-----END CERTIFICATE-----/g;
+function parseCertChain(cert) {
+  const blocks = cert.toString("utf8").match(PEM_CERTIFICATE_BLOCK);
+  if (!blocks) {
+    try {
+      return [new X509Certificate(cert)];
+    } catch {
+      return [];
+    }
+  }
+  const chain = [];
+  for (const block of blocks) {
+    try {
+      chain.push(new X509Certificate(block));
+    } catch {
+    }
+  }
+  return chain;
+}
+__name(parseCertChain, "parseCertChain");
+function bootParsedLeaf(cert) {
+  try {
+    return new X509Certificate(cert);
+  } catch {
+    return void 0;
+  }
+}
+__name(bootParsedLeaf, "bootParsedLeaf");
+function certIssuedBy(cert, issuer) {
+  try {
+    return cert.issuer === issuer.subject && cert.verify(issuer.publicKey);
+  } catch {
+    return false;
+  }
+}
+__name(certIssuedBy, "certIssuedBy");
+function issuerRefusedForKeyUsage(cert) {
+  const keyUsage = certificateExtension(cert, KEY_USAGE_OID);
+  return keyUsage !== void 0 && !keyUsageAllowsCertSign(keyUsage);
+}
+__name(issuerRefusedForKeyUsage, "issuerRefusedForKeyUsage");
+function pathLengthConstraint(cert) {
+  const value = certificateExtension(cert, BASIC_CONSTRAINTS_OID);
+  if (!value) return void 0;
+  const sequence = derElementAt(value, 0);
+  if (sequence?.tag !== SEQUENCE_TAG) return void 0;
+  let at = sequence.start;
+  const first = derElementAt(value, at);
+  if (!first) return void 0;
+  if (first.tag === BOOLEAN_TAG) at = first.end;
+  const integer = derElementAt(value, at);
+  if (integer?.tag !== INTEGER_TAG) return void 0;
+  let length = 0;
+  for (let index = integer.start; index < integer.end; index += 1) {
+    const byte = value[index];
+    if (byte === void 0) return void 0;
+    length = length * 256 + byte;
+  }
+  return length;
+}
+__name(pathLengthConstraint, "pathLengthConstraint");
+function walkWorkerAnchorPath(leaf, chain, leafHeldByWorkers = true) {
+  let next = leaf;
+  const walked = /* @__PURE__ */ new Set();
+  const path2 = [];
+  let pathLengthViolation;
+  while (next) {
+    const current = next;
+    path2.push(current);
+    if (path2.length > 1 && pathLengthViolation === void 0) {
+      const constraint = pathLengthConstraint(current);
+      const intermediatesBelow = path2.length - 2;
+      if (constraint !== void 0 && intermediatesBelow > constraint) {
+        pathLengthViolation = { cert: current, constraint };
+      }
+    }
+    if (isSelfSignedCert(current)) {
+      if (path2.length > 1 && cannotIssueCertificates(current)) {
+        return { anchored: false, path: path2, nonCaTerminator: current };
+      }
+      if (path2.length === 1 && !leafHeldByWorkers) {
+        return { anchored: false, path: path2, unheldSelfSignedLeaf: current };
+      }
+      return pathLengthViolation ? { anchored: false, path: path2, pathLengthViolation } : { anchored: true, path: path2 };
+    }
+    walked.add(current.fingerprint256);
+    const issuer = chain.find(
+      (candidate) => !walked.has(candidate.fingerprint256) && certIssuedBy(current, candidate)
+    );
+    if (issuer && !isSelfSignedCert(issuer) && !issuer.ca) {
+      return { anchored: false, path: path2, incapableIssuer: issuer };
+    }
+    next = issuer;
+  }
+  return pathLengthViolation ? { anchored: false, path: path2, pathLengthViolation } : { anchored: false, path: path2 };
+}
+__name(walkWorkerAnchorPath, "walkWorkerAnchorPath");
+function workerDialHost(daemonUrl) {
+  try {
+    const hostname = new URL(daemonUrl).hostname;
+    if (!hostname) return void 0;
+    return hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
+  } catch {
+    return void 0;
+  }
+}
+__name(workerDialHost, "workerDialHost");
+function certCoversHost(x509, host) {
+  try {
+    return isIP(host) ? Boolean(x509.checkIP(host)) : Boolean(x509.checkHost(host));
+  } catch {
+    return true;
+  }
+}
+__name(certCoversHost, "certCoversHost");
 function extractContextFilename(value) {
   if (typeof value === "string") {
     const trimmed = value.trim();
@@ -3346,12 +3738,12 @@ __name(hasRetryableChannelWorkerShutdownError, "hasRetryableChannelWorkerShutdow
 var channelWorkerRuntimePromise;
 async function loadChannelWorkerRuntime() {
   channelWorkerRuntimePromise ??= Promise.all([
-    import("./channel-worker-supervisor-F6I6WSWW.js"),
-    import("./pidfile-IO7ALSZF.js"),
-    import("./runtime-J4SPTJRQ.js"),
+    import("./channel-worker-supervisor-FKU7DIHJ.js"),
+    import("./pidfile-P25DWA5Q.js"),
+    import("./runtime-RUSPD35D.js"),
     import("./cli-entry-path-4VJ3Y6T2.js"),
-    import("./channel-worker-group-BJNMR2MP.js"),
-    import("./channel-worker-manager-EMA7CQDJ.js")
+    import("./channel-worker-group-6NA6BBZV.js"),
+    import("./channel-worker-manager-NEZ2J6RK.js")
   ]).then(
     ([
       supervisor,
@@ -3362,6 +3754,7 @@ async function loadChannelWorkerRuntime() {
       workerManager
     ]) => ({
       createChannelWorkerSupervisor: supervisor.createChannelWorkerSupervisor,
+      resolveWorkerCaCertPath: supervisor.resolveWorkerCaCertPath,
       channelServicePidfile: pidfile,
       loadChannelsConfig: channelRuntime.loadChannelsConfig,
       createChannelWorkerGroup: workerGroup.createChannelWorkerGroup,
@@ -3456,7 +3849,7 @@ function shouldPreheatBridge(deps) {
 __name(shouldPreheatBridge, "shouldPreheatBridge");
 var coreRuntimePromise;
 function loadCoreRuntime() {
-  coreRuntimePromise ??= import("./core-runtime-CES6JSVV.js");
+  coreRuntimePromise ??= import("./core-runtime-XHYA2RH7.js");
   return coreRuntimePromise;
 }
 __name(loadCoreRuntime, "loadCoreRuntime");
@@ -3492,10 +3885,10 @@ __name(resolveDaemonLogBaseDirForRun, "resolveDaemonLogBaseDirForRun");
 var settingsRuntimePromise;
 function loadSettingsRuntimeModules() {
   settingsRuntimePromise ??= Promise.all([
-    import("./settings-35QZNFDG.js"),
-    import("./environment-WUPHLPKZ.js"),
-    import("./loadedSettingsAdapter-F3T2EQ5J.js"),
-    import("./trustedFolders-7XMJWGQ3.js")
+    import("./settings-YXZ4XBKK.js"),
+    import("./environment-CKWHBC5T.js"),
+    import("./loadedSettingsAdapter-7JOCVOKV.js"),
+    import("./trustedFolders-V6Y4CU3F.js")
   ]).then(([settings, environment, loadedSettingsAdapter, trustedFolders]) => ({
     settings,
     environment,
@@ -3508,8 +3901,8 @@ __name(loadSettingsRuntimeModules, "loadSettingsRuntimeModules");
 var channelWebhookConfigRuntimePromise;
 function loadChannelWebhookConfigRuntime() {
   channelWebhookConfigRuntimePromise ??= Promise.all([
-    import("./runtime-J4SPTJRQ.js"),
-    import("./config-utils-WZ43VOBS.js")
+    import("./runtime-RUSPD35D.js"),
+    import("./config-utils-JVGAP34H.js")
   ]).then(([channelRuntime, configUtils]) => ({
     loadChannelsConfig: channelRuntime.loadChannelsConfig,
     parseChannelWebhookConfig: configUtils.parseChannelWebhookConfig
@@ -3535,18 +3928,18 @@ async function loadServeRuntimeModules() {
     workspaceRegistryModule,
     promptLedgerModule
   ] = await Promise.all([
-    import("./server-74ONDK62.js"),
-    import("./bridge-EBYO4SYM.js"),
-    import("./spawnChannel-2K6NKWM5.js"),
-    import("./process-registry-PMJOA5CO.js"),
-    import("./workspace-service-LLY6HCUC.js"),
+    import("./server-THCOMUC2.js"),
+    import("./bridge-5LR2F2ND.js"),
+    import("./spawnChannel-BPMIXRBI.js"),
+    import("./process-registry-OAEG6WGC.js"),
+    import("./workspace-service-7PXDM6EB.js"),
     import("./types-WYCFCEHR.js"),
-    import("./daemon-status-provider-EYMLPYJU.js"),
-    import("./workspace-providers-status-GPGU5YMT.js"),
-    import("./workspace-skills-status-L5N2Y3ZP.js"),
-    import("./total-session-admission-NSCFWGJH.js"),
-    import("./workspace-registry-BQISXT6Y.js"),
-    import("./prompt-terminal-ledger-TCE7PMCE.js")
+    import("./daemon-status-provider-KKU7ZTLM.js"),
+    import("./workspace-providers-status-525ORQBH.js"),
+    import("./workspace-skills-status-FMJGC2XI.js"),
+    import("./total-session-admission-PWXZBOVX.js"),
+    import("./workspace-registry-HS4RWUSQ.js"),
+    import("./prompt-terminal-ledger-AJ7T7OIV.js")
   ]);
   return {
     createServeApp: serverModule.createServeApp,
@@ -3591,7 +3984,7 @@ function sessionIdleTimeoutMs(value) {
   return value !== void 0 ? channelIdleTimeoutMs(value) : DEFAULT_SESSION_IDLE_TIMEOUT_MS;
 }
 __name(sessionIdleTimeoutMs, "sessionIdleTimeoutMs");
-function currentServeFeaturesForRunQwenServe(opts, sessionShellCommandEnabled, sessionArtifactsPersistenceAvailable, env) {
+function currentServeFeaturesForRunQwenServe(opts, sessionShellCommandEnabled, sessionArtifactsPersistenceAvailable, currentSessionSchedulingAvailable, env) {
   return getAdvertisedServeFeatures(void 0, {
     requireAuth: opts.requireAuth === true,
     mcpPoolActive: opts.mcpPoolActive !== false,
@@ -3603,6 +3996,7 @@ function currentServeFeaturesForRunQwenServe(opts, sessionShellCommandEnabled, s
     sessionShellCommandEnabled,
     sessionArtifactsPersistenceAvailable,
     sessionGenerationAvailable: true,
+    currentSessionSchedulingAvailable,
     workspaceGenerationAvailable: true,
     rateLimit: opts.rateLimit === true,
     reloadAvailable: true,
@@ -3629,6 +4023,7 @@ function createBootstrapCapabilities(input) {
       input.opts,
       input.sessionShellCommandEnabled,
       input.sessionArtifactsPersistenceAvailable,
+      input.currentSessionSchedulingAvailable,
       input.env
     ),
     modelServices: [],
@@ -3744,12 +4139,12 @@ async function waitForRuntimeStartingForShutdown(runtimeStarting, daemonLog, tim
   let timer;
   await Promise.race([
     runtimeStarting,
-    new Promise((resolve4) => {
+    new Promise((resolve3) => {
       timer = setTimeout(() => {
         daemonLog.warn(
           `${timeoutMs}ms runtime-startup wait reached during shutdown; continuing listener close`
         );
-        resolve4();
+        resolve3();
       }, timeoutMs);
       timer.unref();
     })
@@ -3788,6 +4183,7 @@ function createBootstrapServeApp(input) {
     qwenCodeVersion,
     sessionShellCommandEnabled,
     sessionArtifactsPersistenceAvailable,
+    currentSessionSchedulingAvailable,
     permissionPolicy,
     multiWorkspaceCapabilitiesRequireRuntime,
     getRuntimeError,
@@ -3847,6 +4243,7 @@ function createBootstrapServeApp(input) {
         qwenCodeVersion,
         sessionShellCommandEnabled,
         sessionArtifactsPersistenceAvailable,
+        currentSessionSchedulingAvailable,
         permissionPolicy,
         env: process.env
       })
@@ -3964,6 +4361,7 @@ function createBootstrapServeApp(input) {
           opts,
           sessionShellCommandEnabled,
           sessionArtifactsPersistenceAvailable,
+          currentSessionSchedulingAvailable,
           process.env
         )
       },
@@ -4160,8 +4558,8 @@ function matchesWebhookSecret(candidate, expected) {
   if (typeof candidate !== "string" || typeof expected !== "string" || expected.length === 0) {
     return false;
   }
-  const expectedDigest = createHash3("sha256").update(expected).digest();
-  const candidateDigest = createHash3("sha256").update(candidate).digest();
+  const expectedDigest = createHash2("sha256").update(expected).digest();
+  const candidateDigest = createHash2("sha256").update(candidate).digest();
   return timingSafeEqual(expectedDigest, candidateDigest);
 }
 __name(matchesWebhookSecret, "matchesWebhookSecret");
@@ -4302,8 +4700,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
     loaderEnvScrub.release();
   }, "restoreScrubbedLoaderEnv");
   loggerLifecycle.scrubApplied(restoreScrubbedLoaderEnv);
-  const rawToken = optsIn.token ?? process.env[QWEN_SERVER_TOKEN_ENV];
-  const token = typeof rawToken === "string" && rawToken.trim().length > 0 ? rawToken.trim() : void 0;
+  const token = resolveServeToken(optsIn.token);
   const channelDeliveryDiagnosticRedaction = {
     workerEnv: daemonRuntimeBaseEnv,
     ...token ? { daemonToken: token } : {}
@@ -4415,6 +4812,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
     );
   }
   let tlsOptions;
+  let tlsCertPath;
   if (opts.tlsCert && !opts.tlsKey || !opts.tlsCert && opts.tlsKey) {
     throw new Error(
       `--tls-cert and --tls-key must be provided together (got only --tls-${opts.tlsCert ? "cert" : "key"}).`
@@ -4457,6 +4855,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       );
     }
     tlsOptions = { cert, key };
+    tlsCertPath = path.resolve(opts.tlsCert);
   }
   if (!isLoopbackBind(opts.hostname) && !token) {
     throw new Error(
@@ -4586,7 +4985,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-SU4EJKSD.js");
+    const { WorkspaceRegistrationStore } = await import("./workspace-registration-store-7Y44R4LV.js");
     workspaceRegistrationStore = new WorkspaceRegistrationStore(boundWorkspace);
   }
   if (workspaceRegistrationStore) {
@@ -4870,7 +5269,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       "qwen serve: required external tool guard handshake succeeded."
     );
   }
-  const { createDaemonToolGuard } = await import("./daemon-git-worktree-guard-3QY2BQYB.js");
+  const { createDaemonToolGuard } = await import("./daemon-git-worktree-guard-V3P5XLHB.js");
   const daemonToolGuardHandler = createDaemonToolGuard(
     externalToolGuardHandler
   );
@@ -4886,6 +5285,9 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
   const diagnosticSink = /* @__PURE__ */ __name((line, level) => daemonLog.raw(line, level), "diagnosticSink");
   let actualPort = opts.port;
   const webShellDir = opts.serveWebShell === false ? void 0 : resolveWebShellDir();
+  if (optsIn.requireWebShell && !webShellDir) {
+    throw new Error("--open-with-auth requires built Web Shell assets.");
+  }
   if (opts.serveWebShell !== false) {
     if (!webShellDir) {
       writeStderrLine(
@@ -4913,8 +5315,8 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
   let resolveServeAppStartup;
   let rejectServeAppStartup;
   let serveAppStartupSettled = false;
-  const serveAppStartupReady = new Promise((resolve4, reject) => {
-    resolveServeAppStartup = resolve4;
+  const serveAppStartupReady = new Promise((resolve3, reject) => {
+    resolveServeAppStartup = resolve3;
     rejectServeAppStartup = reject;
   });
   void serveAppStartupReady.catch(() => void 0);
@@ -4936,6 +5338,8 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
   const internalRuntimeBridgesForCleanup = [];
   let daemonEventLoopMonitor;
   let daemonMetricsSampler;
+  let sessionPrRefreshTimer;
+  let sessionPrRefreshGeneration = 0;
   let runtimeStartupError;
   let runtimeStarting;
   let markRuntimeReady;
@@ -4944,8 +5348,8 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
   let startRuntimeAfterHealth;
   let startRuntimeForRequest;
   const deferRuntimeUntilFirstHealth = deps.resolveOnListen === true && deps.deferRuntimeUntilFirstHealth === true;
-  const runtimeReady = new Promise((resolve4, reject) => {
-    markRuntimeReady = resolve4;
+  const runtimeReady = new Promise((resolve3, reject) => {
+    markRuntimeReady = resolve3;
     markRuntimeFailed = reject;
   });
   void runtimeReady.catch(() => {
@@ -4955,6 +5359,10 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
     daemonEventLoopMonitor = void 0;
     const metricsSampler = daemonMetricsSampler;
     daemonMetricsSampler = void 0;
+    const prRefreshTimer = sessionPrRefreshTimer;
+    sessionPrRefreshTimer = void 0;
+    sessionPrRefreshGeneration += 1;
+    prRefreshTimer?.dispose();
     try {
       eventLoopMonitor?.dispose();
     } catch (err) {
@@ -5206,7 +5614,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       loadCoreRuntime(),
       loadSettingsRuntimeModules(),
       cliVersionPromise,
-      import("./daemon-trust-policy-CQYKZ7VO.js")
+      import("./daemon-trust-policy-TZGK34DW.js")
     ]);
     cliVersion = resolvedCliVersion;
     settingsRuntime.environment.preResolveHomeEnvOverrides();
@@ -5582,7 +5990,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         resolveSkillSettings,
         skillSettingStrings,
         updateWorkspaceSkillSettingLists
-      } = await import("./skill-settings-TCKLXIXM.js");
+      } = await import("./skill-settings-7SG4YA2W.js");
       const fresh = loadSettingsForPersistence(workspace);
       const normalizedName = skillName.trim().toLowerCase();
       const resolved = resolveSkillSettings(fresh);
@@ -5647,7 +6055,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         resolveSkillSettings,
         skillSettingStrings,
         updateWorkspaceSkillSettingLists
-      } = await import("./skill-settings-TCKLXIXM.js");
+      } = await import("./skill-settings-7SG4YA2W.js");
       const fresh = loadSettingsForPersistence(workspace);
       const resolved = resolveSkillSettings(fresh);
       const initialDisabled = skillSettingStrings(
@@ -5752,7 +6160,43 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         );
       }
     }), "persistSettingsFn");
-    const { createSubSessionLauncher } = await import("./create-sub-session-UJTPMVOG.js");
+    const [{ createSubSessionLauncher }, scheduledTaskRoutes] = await Promise.all([
+      import("./create-sub-session-MHYCFNCM.js"),
+      import("./scheduled-tasks-DVRJZO6I.js")
+    ]);
+    const createCurrentSessionScheduledTaskHandler = /* @__PURE__ */ __name((workspaceCwd, runtimeBaseDir, getBridge, assertGenerationOpen) => async ({
+      callerSessionId,
+      cron,
+      prompt,
+      recurring,
+      assertCallerPromptActive
+    }) => {
+      const targetBridge = getBridge();
+      if (!targetBridge) {
+        throw new Error(
+          "Current-session scheduling is unavailable while the workspace runtime is starting."
+        );
+      }
+      const task = await scheduledTaskRoutes.createScheduledTaskWithExistingSession(
+        {
+          workspaceCwd,
+          runtimeBaseDir,
+          bridge: targetBridge,
+          assertGenerationOpen,
+          resolveLiveSessionOwner: /* @__PURE__ */ __name((sessionId) => workspaceRegistryForPersistence.current === void 0 ? { kind: "unavailable" } : workspaceRegistryForPersistence.current.resolveLiveSessionOwner(
+            sessionId
+          ), "resolveLiveSessionOwner")
+        },
+        {
+          sessionId: callerSessionId,
+          cron,
+          prompt,
+          recurring
+        },
+        { source: "cron-tool", assertCallerPromptActive }
+      );
+      return { id: task.id, cron: task.cron };
+    }, "createCurrentSessionScheduledTaskHandler");
     const subSessionLauncher = createSubSessionLauncher({
       getBridge: /* @__PURE__ */ __name(() => bridgeRef, "getBridge"),
       boundWorkspace,
@@ -5769,6 +6213,12 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       // connection that hosts a named client MCP server (#5626).
       clientMcpSender: clientMcpSenderRegistry.lookup,
       onCreateSubSession: subSessionLauncher.launch,
+      onCreateCurrentSessionScheduledTask: createCurrentSessionScheduledTaskHandler(
+        boundWorkspace,
+        primarySessionRuntimeBaseDir,
+        () => bridgeRef,
+        () => primaryGenerationGuard.assertOpen()
+      ),
       onChannelDelivery: createBoundChannelDeliveryHandler(
         boundWorkspace,
         () => channelWorkerManager,
@@ -6004,6 +6454,27 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         }
       };
     }, "createRuntimeEnvMetadata");
+    const readLiveConversationScheduledTasks = /* @__PURE__ */ __name(async () => {
+      if (!fs.existsSync(liveConversationWorkspace.rootPath)) return [];
+      const { canonicalRoot } = await liveConversationWorkspace.revalidate();
+      let settings;
+      try {
+        settings = settingsRuntime.settings.loadSettings(canonicalRoot, {
+          skipLoadEnvironment: true,
+          skipWorkspaceSettings: false,
+          workspaceTrusted: true
+        });
+      } catch (err) {
+        writeStderrLine(
+          `qwen serve: could not read full settings for Conversations (${err instanceof Error ? err.message : String(err)}); falling back to defaults.`
+        );
+      }
+      const env = createRuntimeEnvMetadata(canonicalRoot, settings, true);
+      return core.Storage.runWithResolvedRuntimeBaseDir(
+        env.sessionRuntimeBaseDir,
+        () => core.readCronTasks(canonicalRoot)
+      );
+    }, "readLiveConversationScheduledTasks");
     const subSessionStoppers = [];
     const subSessionStoppersByRuntime = /* @__PURE__ */ new WeakMap();
     const runtimeCleanupPromises = /* @__PURE__ */ new WeakMap();
@@ -6093,6 +6564,12 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         ),
         clientMcpSender: secondaryClientMcpSenderRegistry.lookup,
         onCreateSubSession: secondarySubSessionLauncher.launch,
+        onCreateCurrentSessionScheduledTask: createCurrentSessionScheduledTaskHandler(
+          workspaceInput.cwd,
+          secondaryEnv.sessionRuntimeBaseDir,
+          () => secondaryBridgeRef,
+          () => secondaryGenerationGuard.assertOpen()
+        ),
         onChannelDelivery: createBoundChannelDeliveryHandler(
           workspaceInput.cwd,
           () => channelWorkerManager,
@@ -6381,6 +6858,22 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         metricsLoopDelay.disable();
       }
     };
+    sessionPrRefreshTimer?.dispose();
+    const refreshGeneration = ++sessionPrRefreshGeneration;
+    void import("./session-pr-refresh-KRBH7KDA.js").then((mod) => {
+      if (refreshGeneration !== sessionPrRefreshGeneration) return;
+      sessionPrRefreshTimer = mod.startSessionPrRefreshTimer({
+        workspaceRegistry,
+        // The coordinator lives on the serve app (createServeApp below),
+        // which is built after this timer starts; read it per tick like
+        // the metrics sampler reads `acpHandle`.
+        getArchiveCoordinator: /* @__PURE__ */ __name(() => app2.locals.sessionArchiveCoordinator, "getArchiveCoordinator")
+      });
+    }).catch((error) => {
+      daemonLog.warn(
+        `session-pr-refresh load failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    });
     const createDynamicWorkspaceRuntime = /* @__PURE__ */ __name(async (cwd, buildOptions) => {
       const provenance = buildOptions?.provenance ?? "existing";
       if (provenance === "managed-scratch" && (!managedScratchRoot || !isManagedScratchChild(cwd, managedScratchRoot.canonicalRoot))) {
@@ -6452,6 +6945,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         boundWorkspace: cwd,
         ...provenance === "live-conversation" ? {
           notifySentCompletion: true,
+          getStandaloneSessionService: /* @__PURE__ */ __name(() => (runtimeApp ?? runtimeAppForCleanup)?.locals?.["standaloneSessionService"], "getStandaloneSessionService"),
           isolatedWorkspace: {
             materializeDirectory: /* @__PURE__ */ __name((sessionId) => liveConversationWorkspace.materializeConversationDirectory(
               sessionId
@@ -6474,6 +6968,12 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
           ),
           clientMcpSender: wsClientMcpRegistry.lookup,
           onCreateSubSession: wsSubSessionLauncher.launch,
+          onCreateCurrentSessionScheduledTask: createCurrentSessionScheduledTaskHandler(
+            cwd,
+            wsEnv.sessionRuntimeBaseDir,
+            () => wsBridgeRef,
+            () => generationGuard.assertOpen()
+          ),
           onChannelDelivery: createBoundChannelDeliveryHandler(
             cwd,
             () => channelWorkerManager,
@@ -6711,6 +7211,9 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
     const serveAppForRuntimeLifecycle = { current: void 0 };
     const workspaceRuntimeRemoval = {
       async runtimeAdded(runtimeAdded) {
+        const app3 = serveAppForRuntimeLifecycle.current ?? runtimeApp ?? runtimeAppForCleanup;
+        const startScheduledTaskKeepaliveForWorkspace = app3?.locals?.["startScheduledTaskKeepaliveForWorkspace"];
+        startScheduledTaskKeepaliveForWorkspace?.(runtimeAdded);
         if (runtimeAdded.provenance === "live-conversation") return;
         channelWebhookEnvByWorkspace.set(
           runtimeAdded.workspaceCwd,
@@ -6718,9 +7221,6 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         );
         channelWebhookConfigVersion += 1;
         refreshChannelWebhookConfigs?.();
-        const app3 = serveAppForRuntimeLifecycle.current ?? runtimeApp ?? runtimeAppForCleanup;
-        const startScheduledTaskKeepaliveForWorkspace = app3?.locals?.["startScheduledTaskKeepaliveForWorkspace"];
-        startScheduledTaskKeepaliveForWorkspace?.(runtimeAdded);
         if (!channelWorkerManager) return;
         try {
           if (runtimeAdded.trusted) {
@@ -6960,8 +7460,8 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
           { createChannelManagementService },
           { WorkspaceChannelSettingsStore }
         ] = await Promise.all([
-          import("./channel-management-service-IRTT7RNE.js"),
-          import("./channel-settings-store-5VP2Y2YM.js")
+          import("./channel-management-service-KHR3N6CH.js"),
+          import("./channel-settings-store-4FOAZW72.js")
         ]);
         return createChannelManagementService({
           workspaceCwd: targetRuntime.workspaceCwd,
@@ -7027,6 +7527,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       } : {},
       managedScratchRoot,
       liveConversationWorkspace,
+      readLiveConversationScheduledTasks,
       workspaceRegistrationStore,
       workspaceRuntimeRemoval,
       workspaceTrustHotReloadAvailable,
@@ -7040,6 +7541,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       // (keepalive) and reloads them on boot (rehydration). Off by default so
       // direct createServeApp embeds/tests don't spawn sessions.
       manageScheduledTaskSessions: true,
+      currentSessionSchedulingAvailable: deps.bridge === void 0,
       fsFactory: routeFsFactory,
       primaryWorkspaceTrusted: trustedWorkspace,
       primaryRuntimeEnv,
@@ -7164,8 +7666,8 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         { createWorkspaceTrustReconciler },
         { createDaemonTrustPolicyMonitor }
       ] = await Promise.all([
-        import("./workspace-trust-reconciler-4Y4F7XIX.js"),
-        import("./daemon-trust-policy-monitor-TK4K7M63.js")
+        import("./workspace-trust-reconciler-3YTWSQBY.js"),
+        import("./daemon-trust-policy-monitor-F23DD2M4.js")
       ]);
       const materializationFor = /* @__PURE__ */ __name((entry, snapshot, decision) => {
         const boundWorkspaces2 = entry.primary && decision.targetTrusted ? runtime.resolveBoundWorkspacesFromIdeEnv(
@@ -7260,7 +7762,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((resolve4) => setTimeout(resolve4, 25));
+              await new Promise((resolve3) => setTimeout(resolve3, 25));
             }
             if ((handle?.getWorkspaceActivity(runtimeToDispose.workspaceId).memoryTasks ?? 0) > 0) {
               throw new Error(
@@ -7337,6 +7839,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
     qwenCodeVersion: cliVersion,
     sessionShellCommandEnabled,
     sessionArtifactsPersistenceAvailable,
+    currentSessionSchedulingAvailable: false,
     permissionPolicy,
     multiWorkspaceCapabilitiesRequireRuntime: workspaceInputs.length > 1,
     getRuntimeError: /* @__PURE__ */ __name(() => runtimeStartupError, "getRuntimeError"),
@@ -7360,7 +7863,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-3NUTRHAH.js").then(
+    isPreAuthRequest: webShellMounted ? (req) => import("./web-shell-static-A6QMUNNV.js").then(
       (webShellStatic) => webShellStatic.isPreAuthWebShellRequest(req)
     ) : void 0
   });
@@ -7380,7 +7883,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
     );
   }
   const channelValidationSettingsRuntime = opts.channelSelection ? await loadSettingsRuntimeModules() : void 0;
-  const channelValidationTrustPolicy = opts.channelSelection ? await import("./daemon-trust-policy-CQYKZ7VO.js") : void 0;
+  const channelValidationTrustPolicy = opts.channelSelection ? await import("./daemon-trust-policy-TZGK34DW.js") : void 0;
   const channelValidationTrustSnapshot = channelValidationTrustPolicy ? await channelValidationTrustPolicy.readDaemonTrustPolicySnapshot() : void 0;
   const resolveChannelWorkspaceGroupsAtListen = /* @__PURE__ */ __name(() => {
     if (!opts.channelSelection || !channelValidationSettingsRuntime || !channelRuntime) {
@@ -7486,7 +7989,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
   if (opts.channelSelection) {
     reserveChannelServicePidfile(opts.channelSelection);
   }
-  return await new Promise((resolve4, reject) => {
+  return await new Promise((resolve3, reject) => {
     let closeHost;
     const onListening = /* @__PURE__ */ __name((error) => {
       if (error) return;
@@ -7933,6 +8436,69 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
             );
           }
           const workerRuntime = await ensureChannelRuntime();
+          const workerDaemonUrl = formatChannelWorkerDaemonUrl(
+            opts.hostname,
+            actualPort,
+            tlsOptions !== void 0
+          );
+          if (tlsOptions && tlsCertPath && process.env["NODE_TLS_REJECT_UNAUTHORIZED"] === "0") {
+            daemonLog.warn(
+              `NODE_TLS_REJECT_UNAUTHORIZED=0 disables certificate verification for channel workers; skipping the worker TLS trust check.`
+            );
+          } else if (tlsOptions && tlsCertPath) {
+            const operatorCaCertPath = process.env["NODE_EXTRA_CA_CERTS"];
+            let operatorCaCert;
+            let operatorCaCertReadError;
+            if (operatorCaCertPath) {
+              try {
+                operatorCaCert = fs.readFileSync(operatorCaCertPath);
+              } catch (error2) {
+                operatorCaCertReadError = error2?.code ?? "read failed";
+              }
+            }
+            let predictedGaps = [];
+            try {
+              predictedGaps = describeWorkerTlsTrustGaps({
+                cert: tlsOptions.cert,
+                certPath: tlsCertPath,
+                certSourcePath: tlsCertPath,
+                daemonUrl: workerDaemonUrl,
+                ...operatorCaCertPath ? { operatorCaCertPath } : {},
+                ...operatorCaCert ? {
+                  operatorCaCert,
+                  operatorCaCertSourcePath: operatorCaCertPath
+                } : {},
+                ...operatorCaCertReadError ? { operatorCaCertReadError } : {}
+              });
+            } catch (error2) {
+              if (!(error2 instanceof ExtraCaInspectionError)) throw error2;
+              daemonLog.warn(
+                `Channel worker TLS trust-gap inspection could not run: ${error2.message} Continuing with the live handshake probe only.`
+              );
+            }
+            const workerCaCertPath = workerRuntime.resolveWorkerCaCertPath(
+              tlsCertPath,
+              operatorCaCertPath
+            );
+            const trustFailure = await (deps.workerTlsTrustVerifier ?? verifyWorkerTlsTrust)({
+              daemonUrl: workerDaemonUrl,
+              caCertPath: workerCaCertPath
+            });
+            if (shuttingDown || runtimeStartupError !== void 0) {
+              throw new Error(
+                "Daemon stopped while the channel worker TLS trust check was running."
+              );
+            }
+            if (trustFailure) {
+              if (predictedGaps.length > 0) {
+                for (const gap of predictedGaps) daemonLog.warn(gap);
+              } else {
+                daemonLog.warn(
+                  `Channel worker TLS verification failed against the exact CA bundle workers receive (${sanitizeLogText(normalizeWorkerDiagnostic(trustFailure.code), 80)}): ${sanitizeLogText(normalizeWorkerDiagnostic(trustFailure.message), 300)}`
+                );
+              }
+            }
+          }
           const createSupervisor = deps.channelWorkerSupervisorFactory ?? workerRuntime.createChannelWorkerSupervisor;
           const createGroup = /* @__PURE__ */ __name((groups) => workerRuntime.createChannelWorkerGroup({
             groups,
@@ -7940,11 +8506,9 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
             createSupervisor,
             shared: {
               cliEntryPath: workerRuntime.findCliEntryPath(),
-              daemonUrl: formatChannelWorkerDaemonUrl(
-                opts.hostname,
-                actualPort
-              ),
-              ...token ? { daemonToken: token } : {}
+              daemonUrl: workerDaemonUrl,
+              ...token ? { daemonToken: token } : {},
+              ...tlsCertPath ? { workerTlsCaCertPath: tlsCertPath } : {}
             },
             onReady: /* @__PURE__ */ __name((snapshot) => {
               if (runtimeStartupError !== void 0) return;
@@ -8207,6 +8771,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
               if (!preserveSignalHandlers) {
                 process.removeListener("SIGINT", onSignal);
                 process.removeListener("SIGTERM", onSignal);
+                process.removeListener("SIGHUP", onSignal);
               }
               process.removeListener(
                 "uncaughtExceptionMonitor",
@@ -8426,6 +8991,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       }
       process.on("SIGINT", onSignal);
       process.on("SIGTERM", onSignal);
+      process.on("SIGHUP", onSignal);
       process.on("uncaughtExceptionMonitor", onUncaughtExceptionMonitor);
       server.on("error", (err) => {
         daemonLog.error("server error", err instanceof Error ? err : null);
@@ -8456,7 +9022,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         loggerPublished = true;
         loggerLifecycle.published();
         void (liveDiscoveryPublish ?? Promise.resolve()).then(
-          () => resolve4(handle)
+          () => resolve3(handle)
         );
       } else {
         void runtimeReady.then(
@@ -8464,7 +9030,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
             await liveDiscoveryPublish;
             loggerPublished = true;
             loggerLifecycle.published();
-            resolve4(handle);
+            resolve3(handle);
           },
           (err) => {
             void handle.close().then(
@@ -8513,10 +9079,10 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       drainHost: /* @__PURE__ */ __name(() => {
         if (closeHost) return closeHost();
         if (!server.listening) return Promise.resolve();
-        return new Promise((resolve5, rejectClose) => {
+        return new Promise((resolve4, rejectClose) => {
           server.close((error) => {
             if (error) rejectClose(error);
-            else resolve5();
+            else resolve4();
           });
         });
       }, "drainHost")
@@ -8578,6 +9144,7 @@ export {
   createBoundChannelDeliveryHandler,
   createDisabledChannelWorkerSupervisor,
   createLazyBridgeProxy,
+  describeWorkerTlsTrustGaps,
   extractContextFilename,
   formatChannelWorkerDaemonUrl,
   resolveRuntimeStartupTimeoutMs,
@@ -8585,6 +9152,7 @@ export {
   subSessionConcurrencyCapsFromSettings,
   validateAndCanonicalizeWorkspaceInput,
   validatePolicyConfig,
+  verifyWorkerTlsTrust,
   waitForRuntimeStartingForShutdown
 };
 /**