@qwen-code/qwen-code 0.20.0 → 0.20.1-nightly.20260724.7d17c44a3

package/chunks/{run-qwen-serve-OZGR3FQA.js → run-qwen-serve-XI4MCAFV.js}

@@ -4,6 +4,9 @@ import {
   DaemonMetricsRing,
   computeCpuPercent
 } from "./chunk-HGT6JR3U.js";
+import {
+  RUNTIME_STARTUP_CANCELLED_MESSAGE
+} from "./chunk-QUPXZXLV.js";
 import {
   ACCESS_LOG_CONTROLLER_LOCAL,
   CAPABILITIES_SCHEMA_VERSION,
@@ -23,31 +26,31 @@ import {
   hostAllowlist,
   isBrowserAutomationMcpAvailable,
   isDeepHealthQuery,
+  isManagedScratchChild,
   listenerMaxConnections,
   parseAllowOriginPatterns,
   parseDaemonStatusDetail,
   positiveFiniteOrNull,
+  prepareManagedScratchRoot,
   require_express,
   resolveWebShellDir,
   setDeferredRuntimeRequestTiming
-} from "./chunk-B3KGZCQN.js";
+} from "./chunk-IJTOWOD7.js";
 import {
   isLoopbackBind
 } from "./chunk-RXFQM6FQ.js";
 import {
-  RUNTIME_STARTUP_CANCELLED_MESSAGE
-} from "./chunk-QUPXZXLV.js";
+  LOAD_REPLAY_META_KEY
+} from "./chunk-3SJ43L4W.js";
 import {
   DEFAULT_COMPACTED_REPLAY_MAX_BYTES,
   normalizeCompactedReplayMaxBytes
 } from "./chunk-COH43MRJ.js";
-import {
-  LOAD_REPLAY_META_KEY
-} from "./chunk-QR6U5QPP.js";
 import "./chunk-WBL3FJEU.js";
+import "./chunk-T2NCM2ET.js";
 import {
   resolveChannelCwd
-} from "./chunk-4ODB7WIB.js";
+} from "./chunk-QAFKR7WR.js";
 import {
   loadServeFastPathSettings,
   preResolveServeFastPathHomeEnvOverrides
@@ -56,25 +59,30 @@ import {
   MAX_REGISTERED_WORKSPACES,
   resolveWorkspaceInputs,
   workspaceRegistrationId
-} from "./chunk-KQNM4EO7.js";
+} from "./chunk-HQCSRJ3P.js";
 import {
-  canonicalizeWorkspace
-} from "./chunk-W7FJ3N32.js";
-import "./chunk-OLMETXLX.js";
-import "./chunk-NBMIC7DR.js";
+  canonicalizeWorkspace,
+  translateAndCheckAbsoluteWorkspacePath
+} from "./chunk-2RFKHEXL.js";
+import "./chunk-PXHK5ONM.js";
+import "./chunk-SX4PK3FC.js";
 import {
+  ChannelDeliveryError,
   ChannelWebhookEnqueueError,
-  QWEN_SERVER_TOKEN_ENV
-} from "./chunk-Y2ENGUD6.js";
+  QWEN_SERVER_TOKEN_ENV,
+  isChannelDeliveryError,
+  normalizeWorkerDiagnostic,
+  sanitizeWorkerDiagnostic
+} from "./chunk-UPF7PTBI.js";
 import {
   channelSelectionNames
-} from "./chunk-TJTKSVIV.js";
+} from "./chunk-JLU636DO.js";
+import "./chunk-BK2UNYWD.js";
 import "./chunk-M5GB774H.js";
 import "./chunk-5HBA2Z7V.js";
-import "./chunk-T2NCM2ET.js";
 import {
   sanitizeLogText
-} from "./chunk-NIJEXGV6.js";
+} from "./chunk-ZXYUQXY5.js";
 import "./chunk-UDXSXLER.js";
 import "./chunk-GOXKNSDZ.js";
 import {
@@ -84,7 +92,7 @@ import {
 import "./chunk-QRUIS3DN.js";
 import {
   getCliVersion
-} from "./chunk-OWCALFEG.js";
+} from "./chunk-54R2CV2G.js";
 import "./chunk-VJNBRRZG.js";
 import "./chunk-ALGGS7UH.js";
 import {
@@ -95,11 +103,11 @@ import {
   writeStdoutLine
 } from "./chunk-OWAK7LMW.js";
 import "./chunk-5M6IDOMF.js";
-import "./chunk-T4TZQJ7W.js";
+import "./chunk-TWPJO254.js";
 import "./chunk-H6XPXXMH.js";
 import {
   require_proper_lockfile
-} from "./chunk-E2UVIFI2.js";
+} from "./chunk-KRXPRVGL.js";
 import "./chunk-CR3C7WXL.js";
 import "./chunk-XWRJCPHC.js";
 import {
@@ -2015,6 +2023,89 @@ function asRecord(value) {
 }
 __name(asRecord, "asRecord");
 
+// packages/cli/src/serve/channel-delivery-authorization.ts
+init_esbuild_shims();
+function authorizationKey(workspaceCwd, sessionId, id) {
+  return JSON.stringify([workspaceCwd, sessionId, id]);
+}
+__name(authorizationKey, "authorizationKey");
+function targetsEqual(left, right) {
+  return left.channelName === right.channelName && left.type === right.type && left.id === right.id;
+}
+__name(targetsEqual, "targetsEqual");
+var ChannelDeliveryAuthorizationStore = class {
+  static {
+    __name(this, "ChannelDeliveryAuthorizationStore");
+  }
+  #prompts = /* @__PURE__ */ new Map();
+  #scheduledTasks = /* @__PURE__ */ new Map();
+  authorizePrompt(workspaceCwd, authorization) {
+    this.#prompts.set(
+      authorizationKey(
+        workspaceCwd,
+        authorization.sessionId,
+        authorization.deliveryId
+      ),
+      authorization.target
+    );
+  }
+  revokePrompt(workspaceCwd, sessionId, deliveryId) {
+    this.#prompts.delete(authorizationKey(workspaceCwd, sessionId, deliveryId));
+  }
+  registerScheduledTask(workspaceCwd, authorization) {
+    const key = authorizationKey(
+      workspaceCwd,
+      authorization.sessionId,
+      authorization.taskId
+    );
+    const current = this.#scheduledTasks.get(key);
+    this.#scheduledTasks.set(key, {
+      sessionId: authorization.sessionId,
+      taskId: authorization.taskId,
+      target: authorization.target,
+      recurring: authorization.recurring,
+      lastConsumedAt: current?.lastConsumedAt ?? authorization.lastFiredAt ?? 0
+    });
+  }
+  revokeScheduledTask(workspaceCwd, sessionId, taskId) {
+    this.#scheduledTasks.delete(
+      authorizationKey(workspaceCwd, sessionId, taskId)
+    );
+  }
+  consume(workspaceCwd, request) {
+    if (request.source === "prompt") {
+      if (request.promptId !== request.deliveryId) return false;
+      const key2 = authorizationKey(
+        workspaceCwd,
+        request.sessionId,
+        request.deliveryId
+      );
+      const target = this.#prompts.get(key2);
+      if (!target || !targetsEqual(target, request.target)) return false;
+      this.#prompts.delete(key2);
+      return true;
+    }
+    if (typeof request.taskId !== "string" || typeof request.firedAt !== "number" || request.deliveryId !== `${request.taskId}:${request.firedAt}`) {
+      return false;
+    }
+    const key = authorizationKey(
+      workspaceCwd,
+      request.sessionId,
+      request.taskId
+    );
+    const authorization = this.#scheduledTasks.get(key);
+    if (!authorization || request.firedAt <= authorization.lastConsumedAt || !targetsEqual(authorization.target, request.target)) {
+      return false;
+    }
+    if (authorization.recurring) {
+      authorization.lastConsumedAt = request.firedAt;
+    } else {
+      this.#scheduledTasks.delete(key);
+    }
+    return true;
+  }
+};
+
 // packages/cli/src/serve/channel-workspace-grouping.ts
 init_esbuild_shims();
 function resolveChannelOwnerCwd(rawCwd, workspaceCwd) {
@@ -2136,6 +2227,90 @@ var QWEN_SERVE_PROMPT_DEADLINE_MS_ENV = "QWEN_SERVE_PROMPT_DEADLINE_MS";
 var QWEN_SERVE_WRITER_IDLE_TIMEOUT_MS_ENV = "QWEN_SERVE_WRITER_IDLE_TIMEOUT_MS";
 var SHUTDOWN_FORCE_CLOSE_MS = 5e3;
 var DAEMON_LOG_FORCED_FLUSH_BUDGET_MS = 250;
+function channelDeliveryPublicError(code) {
+  switch (code) {
+    case "channel_worker_unavailable":
+      return "Channel worker is unavailable.";
+    case "channel_delivery_timeout":
+      return "Channel delivery timed out.";
+    case "channel_delivery_invalid":
+      return "Channel delivery is invalid.";
+    case "channel_delivery_rejected":
+      return "Channel delivery was rejected.";
+    case "channel_delivery_queue_full":
+      return "Channel delivery queue is full.";
+    case "channel_delivery_failed":
+      return "Channel delivery failed.";
+    default:
+      return "Channel delivery failed.";
+  }
+}
+__name(channelDeliveryPublicError, "channelDeliveryPublicError");
+function createBoundChannelDeliveryHandler(boundWorkspace, getManager, authorizations, daemonLog, diagnosticRedaction = {
+  workerEnv: {}
+}) {
+  return async (info) => {
+    const failed = /* @__PURE__ */ __name((code, error, diagnostic) => {
+      writeDaemonLifecycleBestEffort(() => {
+        if (!daemonLog) return;
+        let diagnosticText;
+        if (diagnostic !== void 0) {
+          const message = diagnostic instanceof Error ? diagnostic.message : String(diagnostic);
+          const sanitized = sanitizeWorkerDiagnostic(
+            message,
+            512,
+            diagnosticRedaction
+          );
+          const targetId = normalizeWorkerDiagnostic(info.target.id);
+          diagnosticText = sanitizeLogText(
+            targetId.length > 0 ? sanitized.replaceAll(targetId, "<redacted>") : sanitized,
+            512
+          );
+        }
+        daemonLog.warn("channel delivery failed", {
+          sessionId: info.sessionId,
+          deliveryId: info.deliveryId,
+          source: info.source,
+          channelName: info.target.channelName,
+          code,
+          ...diagnosticText ? { diagnostic: diagnosticText } : {}
+        });
+      });
+      return { status: "failed", code, error };
+    }, "failed");
+    if (!authorizations.consume(boundWorkspace, info)) {
+      return failed(
+        "channel_delivery_invalid",
+        "Channel delivery is not authorized."
+      );
+    }
+    if (info.text.trim().length === 0) {
+      return { status: "skipped" };
+    }
+    const manager = getManager();
+    if (!manager) {
+      return failed(
+        "channel_worker_unavailable",
+        "Channel worker is not running."
+      );
+    }
+    try {
+      await manager.deliverChannelMessage(boundWorkspace, {
+        deliveryId: info.deliveryId,
+        channelName: info.target.channelName,
+        target: { type: info.target.type, id: info.target.id },
+        text: info.text
+      });
+      return { status: "delivered" };
+    } catch (err) {
+      if (isChannelDeliveryError(err)) {
+        return failed(err.code, channelDeliveryPublicError(err.code), err);
+      }
+      return failed("channel_delivery_failed", "Channel delivery failed.", err);
+    }
+  };
+}
+__name(createBoundChannelDeliveryHandler, "createBoundChannelDeliveryHandler");
 async function flushDaemonLogBounded(daemonLog, budgetMs) {
   let timer;
   try {
@@ -2357,12 +2532,12 @@ __name(withSettingsLock, "withSettingsLock");
 var channelWorkerRuntimePromise;
 async function loadChannelWorkerRuntime() {
   channelWorkerRuntimePromise ??= Promise.all([
-    import("./channel-worker-supervisor-ZGO2W2MD.js"),
-    import("./pidfile-UEHAT6DH.js"),
-    import("./runtime-SNVAP6EH.js"),
+    import("./channel-worker-supervisor-CXRCDA4Y.js"),
+    import("./pidfile-UCFCJOAP.js"),
+    import("./runtime-4CTBU5WX.js"),
     import("./cli-entry-path-4VJ3Y6T2.js"),
-    import("./channel-worker-group-53CMOPFT.js"),
-    import("./channel-worker-manager-UTXILKC2.js")
+    import("./channel-worker-group-MA3WXWYX.js"),
+    import("./channel-worker-manager-TIYYYBCT.js")
   ]).then(
     ([
       supervisor,
@@ -2467,7 +2642,7 @@ function shouldPreheatBridge(deps) {
 __name(shouldPreheatBridge, "shouldPreheatBridge");
 var coreRuntimePromise;
 function loadCoreRuntime() {
-  coreRuntimePromise ??= import("./src-43LM7JLB.js");
+  coreRuntimePromise ??= import("./src-LKKTJ4NG.js");
   return coreRuntimePromise;
 }
 __name(loadCoreRuntime, "loadCoreRuntime");
@@ -2497,10 +2672,10 @@ __name(resolveDaemonLogBaseDirForRun, "resolveDaemonLogBaseDirForRun");
 var settingsRuntimePromise;
 function loadSettingsRuntimeModules() {
   settingsRuntimePromise ??= Promise.all([
-    import("./settings-KITVOUSV.js"),
-    import("./environment-3OV7UQOT.js"),
-    import("./loadedSettingsAdapter-AO4YBRXZ.js"),
-    import("./trustedFolders-5XCVNEUU.js")
+    import("./settings-BXZHA6TZ.js"),
+    import("./environment-KS36ZHBE.js"),
+    import("./loadedSettingsAdapter-OZFNBRHE.js"),
+    import("./trustedFolders-Q7RALK4T.js")
   ]).then(([settings, environment, loadedSettingsAdapter, trustedFolders]) => ({
     settings,
     environment,
@@ -2513,8 +2688,8 @@ __name(loadSettingsRuntimeModules, "loadSettingsRuntimeModules");
 var channelWebhookConfigRuntimePromise;
 function loadChannelWebhookConfigRuntime() {
   channelWebhookConfigRuntimePromise ??= Promise.all([
-    import("./runtime-SNVAP6EH.js"),
-    import("./config-utils-AHQ6YZ66.js")
+    import("./runtime-4CTBU5WX.js"),
+    import("./config-utils-XQRXHAN3.js")
   ]).then(([channelRuntime, configUtils]) => ({
     loadChannelsConfig: channelRuntime.loadChannelsConfig,
     parseChannelWebhookConfig: configUtils.parseChannelWebhookConfig
@@ -2538,16 +2713,16 @@ async function loadServeRuntimeModules() {
     totalSessionAdmissionModule,
     workspaceRegistryModule
   ] = await Promise.all([
-    import("./server-SO64U3X5.js"),
-    import("./bridge-VL7ITBU5.js"),
-    import("./spawnChannel-2BU3AULL.js"),
-    import("./workspace-service-F3KIN2UN.js"),
+    import("./server-JD5PIE7A.js"),
+    import("./bridge-FFC4C6VD.js"),
+    import("./spawnChannel-IO4HQLFS.js"),
+    import("./workspace-service-BI4KDYPD.js"),
     import("./types-ML3TRJQ5.js"),
-    import("./daemon-status-provider-NL4IAG7B.js"),
-    import("./workspace-providers-status-EADV364W.js"),
-    import("./workspace-skills-status-YVICUR5Y.js"),
-    import("./total-session-admission-BJLDHKJN.js"),
-    import("./workspace-registry-W6VMFYZU.js")
+    import("./daemon-status-provider-6YNZ3UAE.js"),
+    import("./workspace-providers-status-WDLBDLPG.js"),
+    import("./workspace-skills-status-OVB4LPHA.js"),
+    import("./total-session-admission-NDF7EVG7.js"),
+    import("./workspace-registry-IABDATX3.js")
   ]);
   return {
     createServeApp: serverModule.createServeApp,
@@ -2599,6 +2774,7 @@ function currentServeFeaturesForRunQwenServe(opts, sessionShellCommandEnabled, s
     sessionShellCommandEnabled,
     sessionArtifactsPersistenceAvailable,
     sessionGenerationAvailable: true,
+    workspaceGenerationAvailable: true,
     rateLimit: opts.rateLimit === true,
     reloadAvailable: true,
     channelReloadAvailable: opts.channelSelection !== void 0,
@@ -3128,6 +3304,39 @@ function runSynchronousRequestGate(handler, req, res, next) {
   return passed;
 }
 __name(runSynchronousRequestGate, "runSynchronousRequestGate");
+function validateAndCanonicalizeWorkspaceInput(rawWorkspace) {
+  const workspace = translateAndCheckAbsoluteWorkspacePath(rawWorkspace);
+  if (workspace === null) {
+    throw new Error(
+      `Invalid --workspace "${rawWorkspace}": must be an absolute path.`
+    );
+  }
+  try {
+    const stats = fs.statSync(workspace);
+    if (!stats.isDirectory()) {
+      throw new Error(
+        `Invalid --workspace "${workspace}": exists but is not a directory.`
+      );
+    }
+  } catch (err) {
+    if (err && typeof err === "object" && "code" in err) {
+      const code = err.code;
+      if (code === "ENOENT") {
+        throw new Error(
+          `Invalid --workspace "${workspace}": directory does not exist.`
+        );
+      }
+      if (code === "EACCES" || code === "EPERM") {
+        throw new Error(
+          `Invalid --workspace "${workspace}": permission denied (${String(code)}). The path exists but cannot be stat'd by the current user.`
+        );
+      }
+    }
+    throw err;
+  }
+  return canonicalizeWorkspace(workspace);
+}
+__name(validateAndCanonicalizeWorkspaceInput, "validateAndCanonicalizeWorkspaceInput");
 async function runQwenServe(optsIn, deps = {}) {
   let daemonLog;
   let owner = "startup";
@@ -3160,6 +3369,7 @@ async function runQwenServe(optsIn, deps = {}) {
 __name(runQwenServe, "runQwenServe");
 async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
   const runStartedAt = performance2.now();
+  const channelDeliveryAuthorizations = new ChannelDeliveryAuthorizationStore();
   const shouldPreheat = !deps.bridge && shouldPreheatBridge(deps);
   const startup = {
     processStartedAt: new Date(
@@ -3175,6 +3385,10 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
   });
   const rawToken = optsIn.token ?? process.env[QWEN_SERVER_TOKEN_ENV];
   const token = typeof rawToken === "string" && rawToken.trim().length > 0 ? rawToken.trim() : void 0;
+  const channelDeliveryDiagnosticRedaction = {
+    workerEnv: daemonRuntimeBaseEnv,
+    ...token ? { daemonToken: token } : {}
+  };
   const sessionShellCommandEnabled = optsIn.enableSessionShell === true && token !== void 0;
   if (optsIn.enableSessionShell === true && token === void 0) {
     writeStderrLine(
@@ -3351,40 +3565,11 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       "qwen serve: --allow-private-auth-base-url enabled; /workspace/auth/provider may install localhost/private-network model endpoints. Use only for local development with trusted clients."
     );
   }
-  const validateAndCanonicalizeWorkspace = /* @__PURE__ */ __name((workspace) => {
-    if (!path.isAbsolute(workspace)) {
-      throw new Error(
-        `Invalid --workspace "${workspace}": must be an absolute path.`
-      );
-    }
-    try {
-      const stats = fs.statSync(workspace);
-      if (!stats.isDirectory()) {
-        throw new Error(
-          `Invalid --workspace "${workspace}": exists but is not a directory.`
-        );
-      }
-    } catch (err) {
-      if (err && typeof err === "object" && "code" in err) {
-        const code = err.code;
-        if (code === "ENOENT") {
-          throw new Error(
-            `Invalid --workspace "${workspace}": directory does not exist.`
-          );
-        }
-        if (code === "EACCES" || code === "EPERM") {
-          throw new Error(
-            `Invalid --workspace "${workspace}": permission denied (${String(code)}). The path exists but cannot be stat'd by the current user.`
-          );
-        }
-      }
-      throw err;
-    }
-    return canonicalizeWorkspace(workspace);
-  }, "validateAndCanonicalizeWorkspace");
+  const validateAndCanonicalizeWorkspace = validateAndCanonicalizeWorkspaceInput;
   const workspaceInputs = rawWorkspaces.map((workspace) => ({
     raw: workspace,
     cwd: validateAndCanonicalizeWorkspace(workspace),
+    displayName: void 0,
     removable: false,
     registrationIds: []
   }));
@@ -3425,7 +3610,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-F3ZX3YHT.js");
+    const { WorkspaceRegistrationStore } = await import("./workspace-registration-store-26Z6J6P5.js");
     workspaceRegistrationStore = new WorkspaceRegistrationStore(boundWorkspace);
   }
   if (workspaceRegistrationStore) {
@@ -3433,6 +3618,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       const stored = await workspaceRegistrationStore.read();
       for (const storedWorkspace of stored.workspaces) {
         const registrationId = workspaceRegistrationId(storedWorkspace);
+        const displayName = stored.displayNames?.[registrationId];
         let cwd;
         try {
           cwd = validateAndCanonicalizeWorkspace(storedWorkspace);
@@ -3449,6 +3635,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         );
         if (existingInput) {
           existingInput.registrationIds.push(registrationId);
+          existingInput.displayName ??= displayName;
           continue;
         }
         const nested = workspaceInputs.some(
@@ -3473,6 +3660,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         workspaceInputs.push({
           raw: storedWorkspace,
           cwd,
+          displayName,
           removable: true,
           registrationIds: [registrationId]
         });
@@ -3605,6 +3793,14 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       );
     }
   }
+  if (opts.initializeTimeoutMs !== void 0) {
+    if (!isPositiveIntegerMs(opts.initializeTimeoutMs)) {
+      throw new TypeError(
+        `Invalid initializeTimeoutMs: ${opts.initializeTimeoutMs}. Must be a positive integer (milliseconds).`
+      );
+    }
+    assertTimerDelayInRange("initializeTimeoutMs", opts.initializeTimeoutMs);
+  }
   if (opts.permissionResponseTimeoutMs !== void 0) {
     if (!Number.isFinite(opts.permissionResponseTimeoutMs) || !Number.isInteger(opts.permissionResponseTimeoutMs) || opts.permissionResponseTimeoutMs < 0) {
       throw new TypeError(
@@ -3906,6 +4102,17 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       cliVersionPromise
     ]);
     cliVersion = resolvedCliVersion;
+    let managedScratchRoot;
+    try {
+      managedScratchRoot = prepareManagedScratchRoot(
+        path.join(core.Storage.getGlobalQwenDir(), "scratch-workspaces"),
+        workspaceInputs.map((workspace) => workspace.cwd)
+      );
+    } catch (err) {
+      writeStderrLine(
+        `qwen serve: managed scratch workspaces are unavailable: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
     let runtimeBootSettings;
     try {
       runtimeBootSettings = settingsRuntime.settings.loadSettings(boundWorkspace);
@@ -3976,7 +4183,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       }
       throw err;
     }
-    core.initializeTelemetry(
+    await core.initializeTelemetry(
       createDaemonTelemetryRuntimeConfig(
         daemonTelemetrySettings,
         resolvedCliVersion,
@@ -4276,7 +4483,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         );
       }
     }), "persistSettingsFn");
-    const { createSubSessionLauncher } = await import("./create-sub-session-MGNX52P3.js");
+    const { createSubSessionLauncher } = await import("./create-sub-session-55F3GOLK.js");
     const subSessionLauncher = createSubSessionLauncher({
       getBridge: /* @__PURE__ */ __name(() => bridgeRef, "getBridge"),
       boundWorkspace
@@ -4286,6 +4493,13 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       // connection that hosts a named client MCP server (#5626).
       clientMcpSender: clientMcpSenderRegistry.lookup,
       onCreateSubSession: subSessionLauncher.launch,
+      onChannelDelivery: createBoundChannelDeliveryHandler(
+        boundWorkspace,
+        () => channelWorkerManager,
+        channelDeliveryAuthorizations,
+        daemonLog,
+        channelDeliveryDiagnosticRedaction
+      ),
       maxSessions: opts.maxSessions,
       freshSessionAdmission: totalSessionAdmission.admit,
       sessionLifecycle: sessionOwnerIndex.handleBridgeSessionLifecycle,
@@ -4293,6 +4507,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       ...opts.eventRingSize !== void 0 ? { eventRingSize: opts.eventRingSize } : {},
       ...opts.compactedReplayMaxBytes !== void 0 ? { compactedReplayMaxBytes: opts.compactedReplayMaxBytes } : {},
       ...opts.channelIdleTimeoutMs !== void 0 ? { channelIdleTimeoutMs: opts.channelIdleTimeoutMs } : {},
+      ...opts.initializeTimeoutMs !== void 0 ? { initializeTimeoutMs: opts.initializeTimeoutMs } : {},
       ...opts.sessionReapIntervalMs !== void 0 ? { sessionReapIntervalMs: opts.sessionReapIntervalMs } : {},
       ...opts.sessionIdleTimeoutMs !== void 0 ? { sessionIdleTimeoutMs: opts.sessionIdleTimeoutMs } : {},
       ...opts.permissionResponseTimeoutMs !== void 0 ? { permissionResponseTimeoutMs: opts.permissionResponseTimeoutMs } : {},
@@ -4406,6 +4621,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       {
         workspaceId: daemonWorkspaceHash,
         workspaceCwd: boundWorkspace,
+        ...workspaceInputs[0]?.displayName ? { displayName: workspaceInputs[0].displayName } : {},
         primary: true,
         trusted: trustedWorkspace,
         removable: false,
@@ -4518,6 +4734,13 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       const secondaryBridge = runtime.createAcpSessionBridge({
         clientMcpSender: secondaryClientMcpSenderRegistry.lookup,
         onCreateSubSession: secondarySubSessionLauncher.launch,
+        onChannelDelivery: createBoundChannelDeliveryHandler(
+          workspaceInput.cwd,
+          () => channelWorkerManager,
+          channelDeliveryAuthorizations,
+          daemonLog,
+          channelDeliveryDiagnosticRedaction
+        ),
         maxSessions: opts.maxSessions,
         freshSessionAdmission: totalSessionAdmission.admit,
         sessionLifecycle: sessionOwnerIndex.handleBridgeSessionLifecycle,
@@ -4525,6 +4748,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         ...opts.eventRingSize !== void 0 ? { eventRingSize: opts.eventRingSize } : {},
         ...opts.compactedReplayMaxBytes !== void 0 ? { compactedReplayMaxBytes: opts.compactedReplayMaxBytes } : {},
         ...opts.channelIdleTimeoutMs !== void 0 ? { channelIdleTimeoutMs: opts.channelIdleTimeoutMs } : {},
+        ...opts.initializeTimeoutMs !== void 0 ? { initializeTimeoutMs: opts.initializeTimeoutMs } : {},
         ...opts.sessionReapIntervalMs !== void 0 ? { sessionReapIntervalMs: opts.sessionReapIntervalMs } : {},
         ...opts.sessionIdleTimeoutMs !== void 0 ? { sessionIdleTimeoutMs: opts.sessionIdleTimeoutMs } : {},
         ...opts.permissionResponseTimeoutMs !== void 0 ? { permissionResponseTimeoutMs: opts.permissionResponseTimeoutMs } : {},
@@ -4624,6 +4848,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       workspaceRuntimes.push({
         workspaceId: secondaryWorkspaceHash,
         workspaceCwd: workspaceInput.cwd,
+        ...workspaceInput.displayName ? { displayName: workspaceInput.displayName } : {},
         primary: false,
         trusted: secondaryTrusted,
         removable: workspaceInput.removable,
@@ -4730,7 +4955,12 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         metricsLoopDelay.disable();
       }
     };
-    const createDynamicWorkspaceRuntime = /* @__PURE__ */ __name(async (cwd) => {
+    const createDynamicWorkspaceRuntime = /* @__PURE__ */ __name(async (cwd, options) => {
+      if (options.provenance === "managed-scratch" && (!managedScratchRoot || !isManagedScratchChild(cwd, managedScratchRoot.canonicalRoot))) {
+        throw new Error(
+          "Managed scratch runtime must use an accepted direct child directory"
+        );
+      }
       let wsSettings;
       try {
         wsSettings = settingsRuntime.settings.loadSettings(cwd);
@@ -4739,10 +4969,10 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
           `qwen serve: could not read full settings for dynamic workspace ${cwd} (${err instanceof Error ? err.message : String(err)}); falling back to defaults.`
         );
       }
-      const trusted = wsSettings ? settingsRuntime.trustedFolders.getWorkspaceTrustStatus(
+      const trusted = options.provenance === "managed-scratch" || (wsSettings ? settingsRuntime.trustedFolders.getWorkspaceTrustStatus(
         wsSettings.merged,
         cwd
-      ).effective.state === "trusted" : false;
+      ).effective.state === "trusted" : false);
       const wsEnv = createRuntimeEnvMetadata(cwd, wsSettings);
       const wsHash = core.hashDaemonWorkspace(cwd);
       const wsFsFactory = runtime.resolveBridgeFsFactory({
@@ -4777,6 +5007,13 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         wsBridge = runtime.createAcpSessionBridge({
           clientMcpSender: wsClientMcpRegistry.lookup,
           onCreateSubSession: wsSubSessionLauncher.launch,
+          onChannelDelivery: createBoundChannelDeliveryHandler(
+            cwd,
+            () => channelWorkerManager,
+            channelDeliveryAuthorizations,
+            daemonLog,
+            channelDeliveryDiagnosticRedaction
+          ),
           maxSessions: opts.maxSessions,
           freshSessionAdmission: totalSessionAdmission.admit,
           sessionLifecycle: sessionOwnerIndex.handleBridgeSessionLifecycle,
@@ -4784,6 +5021,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
           ...opts.eventRingSize !== void 0 ? { eventRingSize: opts.eventRingSize } : {},
           ...opts.compactedReplayMaxBytes !== void 0 ? { compactedReplayMaxBytes: opts.compactedReplayMaxBytes } : {},
           ...opts.channelIdleTimeoutMs !== void 0 ? { channelIdleTimeoutMs: opts.channelIdleTimeoutMs } : {},
+          ...opts.initializeTimeoutMs !== void 0 ? { initializeTimeoutMs: opts.initializeTimeoutMs } : {},
           ...opts.sessionReapIntervalMs !== void 0 ? { sessionReapIntervalMs: opts.sessionReapIntervalMs } : {},
           ...opts.sessionIdleTimeoutMs !== void 0 ? { sessionIdleTimeoutMs: opts.sessionIdleTimeoutMs } : {},
           ...opts.permissionResponseTimeoutMs !== void 0 ? { permissionResponseTimeoutMs: opts.permissionResponseTimeoutMs } : {},
@@ -5039,6 +5277,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
     const app2 = runtime.createServeApp(opts, () => actualPort, {
       workspaceRegistry,
       createWorkspaceRuntime: createDynamicWorkspaceRuntime,
+      managedScratchRoot,
       workspaceRegistrationStore,
       workspaceRuntimeRemoval,
       voiceCoordinator: workspaceVoiceCoordinator,
@@ -5077,6 +5316,19 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         }
         return channelWorkerManager.enqueueWebhookTask(task);
       }, "enqueueChannelWebhookTask"),
+      deliverChannelMessage: /* @__PURE__ */ __name(async (workspaceCwd, request) => {
+        if (!channelWorkerManager) {
+          throw new ChannelDeliveryError(
+            "channel_worker_unavailable",
+            "Channel worker is not running."
+          );
+        }
+        return channelWorkerManager.deliverChannelMessage(
+          workspaceCwd,
+          request
+        );
+      }, "deliverChannelMessage"),
+      channelDeliveryAuthorizations,
       reloadChannelWorker,
       getPerfSnapshot: /* @__PURE__ */ __name(() => ({
         eventLoop: currentDaemonEventLoopMonitor.snapshot(),
@@ -5268,7 +5520,8 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
     reserveChannelServicePidfile(opts.channelSelection);
   }
   return await new Promise((resolve, reject) => {
-    const onListening = /* @__PURE__ */ __name(() => {
+    const onListening = /* @__PURE__ */ __name((error) => {
+      if (error) return;
       startup.listenerReadyAt = (/* @__PURE__ */ new Date()).toISOString();
       startup.processToListenMs = Math.round(process.uptime() * 1e3);
       startup.runQwenServeToListenMs = Math.round(
@@ -5288,7 +5541,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         channelWorkspaceGroups = resolveChannelWorkspaceGroupsAtListen();
       } catch (err) {
         removeCurrentServePidfile();
-        const error = err instanceof Error ? err : new Error(String(err));
+        const error2 = err instanceof Error ? err : new Error(String(err));
         server.close((closeErr) => {
           if (closeErr) {
             daemonLog.error(
@@ -5296,7 +5549,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
               closeErr
             );
           }
-          reject(error);
+          reject(error2);
         });
         return;
       }
@@ -5366,9 +5619,9 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
           "deferred runtime: cancelled, server closed before startup"
         );
         runtimeStartupSettled = true;
-        const error = new Error(RUNTIME_STARTUP_CANCELLED_MESSAGE);
-        runtimeStartupError = error.message;
-        markRuntimeFailed(error);
+        const error2 = new Error(RUNTIME_STARTUP_CANCELLED_MESSAGE);
+        runtimeStartupError = error2.message;
+        markRuntimeFailed(error2);
       }, "cancelDeferredRuntimeStartup");
       const shutdownBridgeAfterFailedStartup = /* @__PURE__ */ __name(async (bridge) => {
         if (!bridge || deps.bridge) return;
@@ -5401,7 +5654,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         }
       }, "stopChannelWorkerAfterFailedStartup");
       const failRuntimeStartup = /* @__PURE__ */ __name(async (err, bridgeForCleanup) => {
-        const error = err instanceof Error ? err : new Error(String(err));
+        const error2 = err instanceof Error ? err : new Error(String(err));
         if (runtimeStartupSettled) {
           disposeRuntimeAppResources(runtimeApp ?? runtimeAppForCleanup);
           await shutdownBridgeAfterFailedStartup(bridgeForCleanup);
@@ -5411,15 +5664,15 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         disposeRuntimeAppResources(runtimeApp ?? runtimeAppForCleanup);
         runtimeApp = void 0;
         clearRuntimeStartupTimer();
-        const message = error.message;
+        const message = error2.message;
         runtimeStartupError = message;
         if (startup.preheat.status === "scheduled" || startup.preheat.status === "running") {
           startup.preheat.status = "failed";
           startup.preheat.error = message;
         }
         writeStderrLine(`qwen serve: runtime startup failed: ${message}`);
-        daemonLog.error("runtime startup failed", error);
-        markRuntimeFailed(error);
+        daemonLog.error("runtime startup failed", error2);
+        markRuntimeFailed(error2);
         if (closeServerAfterChannelWorkerStartupFailure && server.listening) {
           runtimeFailureListenerClose = new Promise((resolve2) => {
             server.close((closeErr) => {
@@ -6011,12 +6264,14 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
 __name(runQwenServeImpl, "runQwenServeImpl");
 export {
   InvalidPolicyConfigError,
+  createBoundChannelDeliveryHandler,
   createDisabledChannelWorkerSupervisor,
   createLazyBridgeProxy,
   extractContextFilename,
   formatChannelWorkerDaemonUrl,
   resolveRuntimeStartupTimeoutMs,
   runQwenServe,
+  validateAndCanonicalizeWorkspaceInput,
   validatePolicyConfig,
   waitForRuntimeStartingForShutdown
 };