@qwen-code/qwen-code 0.19.8 → 0.19.9-preview.0

package/chunks/{chunk-YKZIAK7C.js → chunk-MO7O5722.js}

@@ -2,37 +2,34 @@
 "use strict";
 import {
   isLoopbackBind
-} from "./chunk-RNBYOUGV.js";
-import {
-  require_lib
-} from "./chunk-3HX5LZ6R.js";
-import {
-  require_mime_db
-} from "./chunk-7RYW5LQV.js";
+} from "./chunk-RXFQM6FQ.js";
 import {
   CLIENT_MCP_OVER_WS_CONFIG_FLAG
-} from "./chunk-AGHU5VRK.js";
+} from "./chunk-PZL23GTM.js";
+import {
+  require_lib
+} from "./chunk-WBL3FJEU.js";
 import {
   MAX_WORKSPACE_PATH_LENGTH
-} from "./chunk-ER3BKOLB.js";
+} from "./chunk-W7FJ3N32.js";
 import {
-  writeStderrLine
-} from "./chunk-Y6Z2O3WR.js";
+  require_mime_db
+} from "./chunk-T2NCM2ET.js";
 import {
-  require_once
-} from "./chunk-5P5XGNYH.js";
+  writeStderrLine
+} from "./chunk-YUZI3WAC.js";
 import {
   require_safer
-} from "./chunk-SYCJMSIJ.js";
+} from "./chunk-XWRJCPHC.js";
 import {
   require_src
-} from "./chunk-QN5NZ3UQ.js";
+} from "./chunk-DMTGGOSA.js";
 import {
   require_ms
-} from "./chunk-BR4QREVK.js";
+} from "./chunk-YQ3U5MUC.js";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __commonJS,
   __name,
@@ -11322,6 +11319,86 @@ var require_utils2 = __commonJS({
   }
 });
 
+// node_modules/wrappy/wrappy.js
+var require_wrappy = __commonJS({
+  "node_modules/wrappy/wrappy.js"(exports, module) {
+    init_esbuild_shims();
+    module.exports = wrappy;
+    function wrappy(fn, cb) {
+      if (fn && cb) return wrappy(fn)(cb);
+      if (typeof fn !== "function")
+        throw new TypeError("need wrapper function");
+      Object.keys(fn).forEach(function(k) {
+        wrapper[k] = fn[k];
+      });
+      return wrapper;
+      function wrapper() {
+        var args = new Array(arguments.length);
+        for (var i = 0; i < args.length; i++) {
+          args[i] = arguments[i];
+        }
+        var ret = fn.apply(this, args);
+        var cb2 = args[args.length - 1];
+        if (typeof ret === "function" && ret !== cb2) {
+          Object.keys(cb2).forEach(function(k) {
+            ret[k] = cb2[k];
+          });
+        }
+        return ret;
+      }
+      __name(wrapper, "wrapper");
+    }
+    __name(wrappy, "wrappy");
+  }
+});
+
+// node_modules/once/once.js
+var require_once = __commonJS({
+  "node_modules/once/once.js"(exports, module) {
+    init_esbuild_shims();
+    var wrappy = require_wrappy();
+    module.exports = wrappy(once);
+    module.exports.strict = wrappy(onceStrict);
+    once.proto = once(function() {
+      Object.defineProperty(Function.prototype, "once", {
+        value: /* @__PURE__ */ __name(function() {
+          return once(this);
+        }, "value"),
+        configurable: true
+      });
+      Object.defineProperty(Function.prototype, "onceStrict", {
+        value: /* @__PURE__ */ __name(function() {
+          return onceStrict(this);
+        }, "value"),
+        configurable: true
+      });
+    });
+    function once(fn) {
+      var f = /* @__PURE__ */ __name(function() {
+        if (f.called) return f.value;
+        f.called = true;
+        return f.value = fn.apply(this, arguments);
+      }, "f");
+      f.called = false;
+      return f;
+    }
+    __name(once, "once");
+    function onceStrict(fn) {
+      var f = /* @__PURE__ */ __name(function() {
+        if (f.called)
+          throw new Error(f.onceError);
+        f.called = true;
+        return f.value = fn.apply(this, arguments);
+      }, "f");
+      var name = fn.name || "Function wrapped with `once`";
+      f.onceError = name + " shouldn't be called more than once";
+      f.called = false;
+      return f;
+    }
+    __name(onceStrict, "onceStrict");
+  }
+});
+
 // node_modules/is-promise/index.js
 var require_is_promise = __commonJS({
   "node_modules/is-promise/index.js"(exports, module) {
@@ -16455,6 +16532,7 @@ var SERVE_CAPABILITY_REGISTRY = {
   session_cancel: { since: "v1" },
   session_events: { since: "v1" },
   session_artifacts: { since: "v1" },
+  session_artifacts_persistence: { since: "v1" },
   // Daemon emits `slow_client_warning` synthetic frames at 75% queue
   // fill and honors `?maxQueued=N` (range [16, 2048]) on
   // `GET /session/:id/events`. Old daemons silently lack both — SDK
@@ -16505,6 +16583,7 @@ var SERVE_CAPABILITY_REGISTRY = {
   session_metadata: { since: "v1" },
   session_organization: { since: "v1" },
   session_export: { since: "v1" },
+  session_transcript: { since: "v1" },
   // Daemon supports the MCP client guardrail surface: an in-process
   // counter exposed on `GET /workspace/mcp`, a `--mcp-client-budget=N`
   // flag with `--mcp-budget-mode={enforce, warn, off}`, and a
@@ -16551,6 +16630,7 @@ var SERVE_CAPABILITY_REGISTRY = {
   // unregistered — the toggle takes effect on the next ACP child spawn
   // (`tools.disabled` is consulted at `Config` construction time).
   workspace_tool_toggle: { since: "v1" },
+  workspace_skill_toggle: { since: "v1" },
   workspace_settings: { since: "v1" },
   // `GET /workspace/permissions` is always available when this tag is
   // advertised. `POST /workspace/permissions` updates the active ACP
@@ -16668,9 +16748,57 @@ var SERVE_CAPABILITY_REGISTRY = {
   session_branch: { since: "v1" },
   rate_limit: { since: "v1" },
   workspace_reload: { since: "v1" },
+  // Daemon supports reloading its daemon-managed channel worker via
+  // `POST /workspace/channel/reload`. The worker is stopped and relaunched;
+  // on relaunch it re-reads settings.json (channels / proxy / per-channel
+  // model), so channel settings changes apply without a full daemon restart.
+  // Advertised CONDITIONALLY while the runtime manager has a committed or
+  // recoverable channel worker selection.
+  channel_reload: { since: "v1" },
+  // Runtime GET/PUT/DELETE control for daemon-managed channel selection.
+  // The route exists even when no selection was supplied at daemon boot.
+  channel_control: { since: "v1" },
   // Multi-workspace sessions closed loop (issue #6378 Phase 2a). Advertised
   // only when one daemon hosts more than one registered workspace runtime.
   multi_workspace_sessions: { since: "v1" },
+  // Singular session rewind routes resolve the owning live workspace runtime.
+  multi_workspace_session_rewind: { since: "v1" },
+  // Singular session shell routes resolve the owning live workspace runtime.
+  multi_workspace_session_shell: { since: "v1" },
+  persistent_workspace_registration: { since: "v1" },
+  workspace_runtime_removal: { since: "v1" },
+  // Workspace-qualified core REST routes under `/workspaces/:workspace/...`.
+  // Covers core file/status/permissions/trust/lifecycle/MCP/tool, memory,
+  // workspace agent CRUD, and persisted session organization surfaces.
+  // Workspace-qualified settings also require the existing
+  // `workspace_settings` tag because that surface depends on settings
+  // persistence. ACP/WebSocket and auth stay outside this core tag;
+  // workspace-qualified Voice REST/WebSocket routes use their separate
+  // `workspace_qualified_voice` capability below. V2 extension management
+  // is advertised separately via `extension_management_v2`.
+  workspace_qualified_rest_core: { since: "v1" },
+  // Workspace-qualified Voice REST and WebSocket routes. This tag is enough
+  // to discover plural modalities because legacy Voice tags describe only
+  // the primary runtime and may be absent for a secondary-only setup.
+  workspace_qualified_voice: { since: "v1" },
+  // Global extension catalog/mutations plus workspace-qualified activation
+  // projections. This is additive to the legacy primary-workspace
+  // `workspace_extensions` contract.
+  extension_management_v2: { since: "v1" },
+  // Workspace-qualified, daemon-local persisted transcript paging. The tag is
+  // unconditional because the route also serves a trusted single-workspace
+  // primary; authorization is evaluated for the selected runtime per request.
+  workspace_persisted_transcript: { since: "v1" },
+  // Workspace-qualified full session export from active persisted storage.
+  // This is separate from `session_export` so clients do not infer the plural
+  // route from the legacy primary-workspace export capability.
+  workspace_session_export: { since: "v1" },
+  // Workspace-qualified ACP transport (issue #6378 Phase 4):
+  // `/workspaces/:workspace/acp` mounts a per-runtime ACP dispatcher (HTTP +
+  // WebSocket) for each registered workspace, with per-runtime device-flow and
+  // reverse client-MCP. Legacy `/acp` stays bound to the primary runtime.
+  // Advertised only when the daemon hosts more than one workspace runtime.
+  workspace_qualified_acp: { since: "v1" },
   // Phase 2 "reverse tool channel" (issue #5626). A connected WS client (e.g.
   // the Chrome extension) can host an MCP server that the daemon's agent
   // calls by carrying `mcp_message` JSON-RPC frames over the daemon WS,
@@ -16687,6 +16815,12 @@ var SERVE_CAPABILITY_REGISTRY = {
   // frames. Advertised when explicitly enabled or when the daemon is serving a
   // Chrome extension origin.
   cdp_tunnel_over_ws: { since: "v1" },
+  // Browser automation MCP tools are available only when the CDP tunnel is on
+  // and the operator has configured an external stdio adapter via
+  // QWEN_CDP_MCP_COMMAND. This is separate from `cdp_tunnel_over_ws`: a daemon
+  // may expose the tunnel while intentionally not bundling/registering a
+  // chrome-devtools MCP adapter.
+  browser_automation_mcp: { since: "v1" },
   // Daemon hosts the `/voice/stream` WebSocket: the browser captures audio and
   // streams raw PCM, the daemon transcribes server-side via the configured
   // `voiceModel` (credentials never reach the client). Advertised
@@ -16721,14 +16855,54 @@ var CONDITIONAL_SERVE_FEATURES = /* @__PURE__ */ new Map([
     "session_shell_command",
     (toggles) => toggles.sessionShellCommandEnabled === true
   ],
+  [
+    "session_artifacts_persistence",
+    (toggles) => toggles.sessionArtifactsPersistenceAvailable === true
+  ],
   ["rate_limit", (toggles) => toggles.rateLimit === true],
   ["workspace_reload", (toggles) => toggles.reloadAvailable === true],
+  ["channel_reload", (toggles) => toggles.channelReloadAvailable === true],
+  ["channel_control", (toggles) => toggles.channelControlAvailable === true],
   [
     "multi_workspace_sessions",
     (toggles) => toggles.multiWorkspaceSessionsEnabled === true
   ],
+  [
+    "multi_workspace_session_rewind",
+    (toggles) => toggles.multiWorkspaceSessionsEnabled === true
+  ],
+  [
+    "multi_workspace_session_shell",
+    (toggles) => toggles.multiWorkspaceSessionsEnabled === true && toggles.sessionShellCommandEnabled === true
+  ],
+  [
+    "persistent_workspace_registration",
+    (toggles) => toggles.persistentWorkspaceRegistrationAvailable === true
+  ],
+  [
+    "workspace_runtime_removal",
+    (toggles) => toggles.workspaceRuntimeRemovalAvailable === true
+  ],
+  [
+    "workspace_qualified_acp",
+    // The plural routes are pre-mounted for workspaces registered after app
+    // creation, but the capability becomes meaningful only once a secondary
+    // runtime exists. Until then the qualified primary route is only an alias
+    // for the always-available legacy `/acp` surface.
+    (toggles) => toggles.acpHttpEnabled === true && toggles.multiWorkspaceSessionsEnabled === true
+  ],
+  [
+    "workspace_qualified_voice",
+    // Like qualified ACP, the plural Voice surface is mounted ahead of time
+    // but only becomes useful once the daemon has a secondary runtime.
+    (toggles) => toggles.acpHttpEnabled === true && toggles.multiWorkspaceSessionsEnabled === true
+  ],
   ["client_mcp_over_ws", (toggles) => toggles.clientMcpOverWsEnabled === true],
   ["cdp_tunnel_over_ws", (toggles) => toggles.cdpTunnelOverWsEnabled === true],
+  [
+    "browser_automation_mcp",
+    (toggles) => toggles.browserAutomationMcpAvailable === true
+  ],
   [
     // Advertised whenever the `/voice/stream` WS endpoint exists. A configured
     // token (or `--require-auth`) no longer suppresses it: browsers can't set
@@ -16794,6 +16968,7 @@ var PROTOTYPE_POLLUTION_KEYS = /* @__PURE__ */ new Set([
 var CLIENT_ID_HEADER = "x-qwen-client-id";
 var MAX_CLIENT_ID_LENGTH = 128;
 var MAX_TOOL_NAME_LENGTH = 256;
+var MAX_SKILL_NAME_LENGTH = 256;
 var MAX_SERVER_NAME_LENGTH = 256;
 var CLIENT_ID_RE = /^[A-Za-z0-9._:-]+$/;
 var INVALID_PERMISSION_OUTCOME_ERROR = '`outcome` must be `{ outcome: "cancelled" }` or `{ outcome: "selected", optionId: string }`';
@@ -16896,7 +17071,8 @@ __name(validateMcpRuntimeServerName, "validateMcpRuntimeServerName");
 function parseAndValidateWorkspaceClientId(req, res, bridge) {
   const raw = parseClientIdHeader(req, res);
   if (raw === null || raw === void 0) return raw;
-  if (!bridge.knownClientIds().has(raw)) {
+  const bridges = Array.isArray(bridge) ? bridge : [bridge];
+  if (!bridges.some((candidate) => candidate.knownClientIds().has(raw))) {
     res.status(400).json({
       error: `Client id "${raw}" is not registered for this workspace`,
       code: "invalid_client_id",
@@ -16992,7 +17168,8 @@ init_esbuild_shims();
 var MAX_BUCKETS = 1e4;
 var GC_REQUEST_INTERVAL = 1e3;
 var GC_TIMER_INTERVAL_MS = 5 * 60 * 1e3;
-function resolveTier(method, path3) {
+var WORKSPACE_QUALIFIED_ACP_PATH = /^\/workspaces\/[^/]+\/acp$/i;
+function resolveTier(method, path3, workspaceQualifiedAcpEnabled) {
   const p = path3.endsWith("/") && path3.length > 1 ? path3.slice(0, -1) : path3;
   if (method === "OPTIONS") return null;
   if ((method === "GET" || method === "HEAD") && (p === "/health" || p === "/demo"))
@@ -17002,6 +17179,8 @@ function resolveTier(method, path3) {
   if (method === "GET" && p.startsWith("/session/") && p.endsWith("/events"))
     return null;
   if (p === "/acp" || p.startsWith("/acp/")) return null;
+  if (workspaceQualifiedAcpEnabled && WORKSPACE_QUALIFIED_ACP_PATH.test(p))
+    return null;
   if (method === "POST" && p.startsWith("/session/") && p.endsWith("/prompt"))
     return "prompt";
   if (method !== "GET" && method !== "HEAD") return "mutation";
@@ -17105,7 +17284,11 @@ function createRateLimiter(config) {
         next();
         return;
       }
-      const tier = resolveTier(req.method, req.path);
+      const tier = resolveTier(
+        req.method,
+        req.path,
+        config.workspaceQualifiedAcpEnabled === true
+      );
       if (tier === null) {
         next();
         return;
@@ -17266,6 +17449,7 @@ async function buildDaemonStatusResponse(detail, input) {
     null
   );
   const acpSnapshot = input.acpHandle?.registry.getSnapshot();
+  const acpAggregate = input.acpHandle?.getSnapshot();
   const rateLimitHits = input.rateLimiter?.getHitCounts() ?? zeroRateHits();
   let pendingPrompts = 0;
   let derivedQueuedPrompts = 0;
@@ -17292,22 +17476,25 @@ async function buildDaemonStatusResponse(detail, input) {
     state: "disabled",
     channels: []
   };
+  const channelWorkers = (workspaceRuntimes?.length ?? 1) > 1 ? input.getChannelWorkerSnapshots?.() : void 0;
   const totalAdmissionSnapshot = input.getTotalSessionAdmissionSnapshot?.();
   const issues = [];
   let full;
   pushRuntimeIssues(
     issues,
     acpSnapshot,
+    acpAggregate,
     rateLimitHits,
     input,
     channelWorker,
+    channelWorkers,
     totalAdmissionSnapshot,
     workspaceSnapshots
   );
   if (detail === "full") {
     full = await buildFullStatus(
       input,
-      acpSnapshot,
+      acpAggregate,
       workspaceSnapshots.flatMap((item) => item.snapshot.sessions)
     );
     pushFullIssues(issues, full);
@@ -17372,16 +17559,17 @@ async function buildDaemonStatusResponse(detail, input) {
       },
       channel: { live: aggregatedChannelLive },
       channelWorker,
+      ...channelWorkers && channelWorkers.length > 0 ? { channelWorkers } : {},
       transport: {
         restSseActive: input.getRestSseActive(),
         acp: {
           enabled: acpSnapshot !== void 0,
-          connections: acpSnapshot?.connectionCount ?? 0,
-          connectionStreams: acpSnapshot?.connectionStreams ?? 0,
-          sessionStreams: acpSnapshot?.sessionStreams ?? 0,
-          sseStreams: acpSnapshot?.sseStreams ?? 0,
-          wsStreams: acpSnapshot?.wsStreams ?? 0,
-          pendingClientRequests: acpSnapshot?.pendingClientRequests ?? 0
+          connections: acpAggregate?.connectionCount ?? 0,
+          connectionStreams: acpAggregate?.connectionStreams ?? 0,
+          sessionStreams: acpAggregate?.sessionStreams ?? 0,
+          sseStreams: acpAggregate?.sseStreams ?? 0,
+          wsStreams: acpAggregate?.wsStreams ?? 0,
+          pendingClientRequests: acpAggregate?.pendingClientRequests ?? 0
         }
       },
       rateLimit: {
@@ -17518,7 +17706,7 @@ async function withTimeout(promise, section, timeoutMs) {
   }
 }
 __name(withTimeout, "withTimeout");
-function pushRuntimeIssues(issues, acpSnapshot, rateLimitHits, input, channelWorker, totalAdmissionSnapshot, workspaceSnapshots) {
+function pushRuntimeIssues(issues, acpSnapshot, acpAggregate, rateLimitHits, input, channelWorker, channelWorkers, totalAdmissionSnapshot, workspaceSnapshots) {
   for (const { workspaceCwd, snapshot } of workspaceSnapshots) {
     if (snapshot.limits.maxSessions !== null && snapshot.limits.maxSessions > 0 && snapshot.sessionCount / snapshot.limits.maxSessions >= CAPACITY_WARNING_RATIO) {
       issues.push({
@@ -17543,12 +17731,19 @@ function pushRuntimeIssues(issues, acpSnapshot, rateLimitHits, input, channelWor
       });
     }
   }
-  if (acpSnapshot !== void 0 && acpSnapshot.connectionCap !== null && acpSnapshot.connectionCap > 0 && acpSnapshot.connectionCount / acpSnapshot.connectionCap >= CAPACITY_WARNING_RATIO) {
-    issues.push({
-      code: "connection_capacity_high",
-      severity: "warning",
-      message: `ACP connections are at ${acpSnapshot.connectionCount}/${acpSnapshot.connectionCap}.`
-    });
+  if (acpSnapshot !== void 0 && acpSnapshot.connectionCap !== null && acpSnapshot.connectionCap > 0) {
+    const cap = acpSnapshot.connectionCap;
+    const busiest = (acpAggregate?.mounts ?? []).reduce(
+      (max, m) => Math.max(max, m.connectionCount),
+      acpSnapshot.connectionCount
+    );
+    if (busiest / cap >= CAPACITY_WARNING_RATIO) {
+      issues.push({
+        code: "connection_capacity_high",
+        severity: "warning",
+        message: `ACP connections are at ${busiest}/${cap} on the busiest workspace mount.`
+      });
+    }
   }
   const pendingPermissionCount = workspaceSnapshots.reduce(
     (sum, item) => sum + item.snapshot.pendingPermissionCount,
@@ -17578,6 +17773,16 @@ function pushRuntimeIssues(issues, acpSnapshot, rateLimitHits, input, channelWor
       message: `${sumRateHits(rateLimitHits)} request(s) have been rejected by rate limiting since start.`
     });
   }
+  const groupedWorkers = channelWorkers && channelWorkers.length > 0 ? channelWorkers : void 0;
+  const workers = groupedWorkers ?? [channelWorker];
+  for (const worker of workers) {
+    pushChannelWorkerIssues(issues, worker, groupedWorkers !== void 0);
+  }
+}
+__name(pushRuntimeIssues, "pushRuntimeIssues");
+function pushChannelWorkerIssues(issues, channelWorker, grouped) {
+  const workspace = "workspaceCwd" in channelWorker ? ` for workspace ${channelWorker.workspaceCwd}` : "";
+  const section = grouped ? "runtime.channelWorkers" : "runtime.channelWorker";
   if (channelWorker.enabled && (channelWorker.state === "exited" || channelWorker.state === "failed")) {
     const detailParts = [
       channelWorker.pid !== void 0 ? `pid=${channelWorker.pid}` : void 0,
@@ -17596,8 +17801,8 @@ function pushRuntimeIssues(issues, acpSnapshot, rateLimitHits, input, channelWor
     issues.push({
       code: "channel_worker_exited",
       severity: isPermanentFailure ? "error" : "warning",
-      message: `Channel worker is ${channelWorker.state}${details}${error}.`,
-      section: "runtime.channelWorker"
+      message: `Channel worker${workspace} is ${channelWorker.state}${details}${error}.`,
+      section
     });
   }
   if (channelWorker.enabled && channelWorker.state === "running" && channelWorker.requestedChannels !== void 0) {
@@ -17609,13 +17814,13 @@ function pushRuntimeIssues(issues, acpSnapshot, rateLimitHits, input, channelWor
       issues.push({
         code: "channel_worker_partial_connect",
         severity: "warning",
-        message: `Channel worker connected ${channelWorker.channels.length}/${channelWorker.requestedChannels.length} channel(s). Failed: ${failed.join(", ")}.`,
-        section: "runtime.channelWorker"
+        message: `Channel worker${workspace} connected ${channelWorker.channels.length}/${channelWorker.requestedChannels.length} channel(s). Failed: ${failed.join(", ")}.`,
+        section
       });
     }
   }
 }
-__name(pushRuntimeIssues, "pushRuntimeIssues");
+__name(pushChannelWorkerIssues, "pushChannelWorkerIssues");
 function pushFullIssues(issues, full) {
   for (const [name, section] of Object.entries(full.workspace)) {
     if (section.status === "unavailable") {
@@ -17833,6 +18038,177 @@ function copyNumber(from, to, key) {
 }
 __name(copyNumber, "copyNumber");
 
+// packages/cli/src/serve/acp-http-enabled.ts
+init_esbuild_shims();
+function resolveAcpHttpEnabled(env = process.env) {
+  return env["QWEN_SERVE_ACP_HTTP"] !== "0";
+}
+__name(resolveAcpHttpEnabled, "resolveAcpHttpEnabled");
+
+// packages/cli/src/serve/cdp-mcp-command.ts
+init_esbuild_shims();
+var QWEN_CDP_MCP_COMMAND_ENV = "QWEN_CDP_MCP_COMMAND";
+function resolveCdpMcpCommand(env) {
+  const command = env[QWEN_CDP_MCP_COMMAND_ENV]?.trim();
+  return command ? command : void 0;
+}
+__name(resolveCdpMcpCommand, "resolveCdpMcpCommand");
+function isBrowserAutomationMcpAvailable(opts, env) {
+  return opts.cdpTunnelOverWs === true && !opts.token && resolveAcpHttpEnabled(env) && resolveCdpMcpCommand(env) !== void 0;
+}
+__name(isBrowserAutomationMcpAvailable, "isBrowserAutomationMcpAvailable");
+
+// packages/cli/src/serve/voice/workspace-voice-coordinator.ts
+init_esbuild_shims();
+var MAX_CONCURRENT_VOICE_SESSIONS = 8;
+var DISPOSE_WAIT_MS = 5e3;
+var VoiceLeaseAbortError = class extends Error {
+  constructor(kind, message) {
+    super(message);
+    this.kind = kind;
+    this.name = "VoiceLeaseAbortError";
+  }
+  static {
+    __name(this, "VoiceLeaseAbortError");
+  }
+};
+var Lease = class {
+  constructor(onRelease) {
+    this.onRelease = onRelease;
+  }
+  static {
+    __name(this, "Lease");
+  }
+  controller = new AbortController();
+  signal = this.controller.signal;
+  released = false;
+  release() {
+    if (this.released) return;
+    this.released = true;
+    this.onRelease(this);
+  }
+  abort(reason) {
+    if (!this.signal.aborted) this.controller.abort(reason);
+  }
+};
+var WorkspaceVoiceCoordinator = class {
+  static {
+    __name(this, "WorkspaceVoiceCoordinator");
+  }
+  states = /* @__PURE__ */ new Map();
+  disposed = /* @__PURE__ */ new WeakSet();
+  active = 0;
+  acquire(runtime) {
+    if (this.disposed.has(runtime)) {
+      return { kind: "rejected", reason: "draining" };
+    }
+    const state = this.stateFor(runtime);
+    if (state.draining) return { kind: "rejected", reason: "draining" };
+    if (this.active >= MAX_CONCURRENT_VOICE_SESSIONS) {
+      return { kind: "rejected", reason: "capacity" };
+    }
+    const lease = new Lease((current) => this.release(runtime, current));
+    state.leases.add(lease);
+    this.active++;
+    return { kind: "admitted", lease };
+  }
+  beginWorkspaceDrain(runtime) {
+    this.stateFor(runtime).draining = true;
+  }
+  cancelWorkspaceDrain(runtime) {
+    const state = this.states.get(runtime);
+    if (!state || state.completed) return;
+    state.draining = false;
+    if (state.leases.size === 0) this.states.delete(runtime);
+  }
+  completeWorkspaceDrain(runtime) {
+    this.disposed.add(runtime);
+    const state = this.states.get(runtime);
+    if (!state) return;
+    state.draining = true;
+    state.completed = true;
+    const abortReason = new VoiceLeaseAbortError(
+      "workspace_removed",
+      "Workspace drain completed"
+    );
+    for (const lease of state.leases) lease.abort(abortReason);
+    this.deleteIfIdle(runtime, state);
+  }
+  getWorkspaceActivity(runtime) {
+    return this.states.get(runtime)?.leases.size ?? 0;
+  }
+  async disposeRuntime(runtime, reason) {
+    this.disposed.add(runtime);
+    const state = this.states.get(runtime);
+    if (!state) return;
+    state.draining = true;
+    state.completed = true;
+    const abortReason = new VoiceLeaseAbortError(
+      reason,
+      reason === "workspace_removed" ? "Workspace runtime was removed" : "Daemon is shutting down"
+    );
+    for (const lease of state.leases) lease.abort(abortReason);
+    if (state.leases.size === 0) {
+      this.deleteIfIdle(runtime, state);
+      return;
+    }
+    let resolveIdle;
+    const idle = new Promise((resolve) => {
+      resolveIdle = resolve;
+      state.idleWaiters.add(resolve);
+    });
+    let timeout;
+    let timedOut = false;
+    try {
+      await Promise.race([
+        idle,
+        new Promise((resolve) => {
+          timeout = setTimeout(() => {
+            timedOut = true;
+            resolve();
+          }, DISPOSE_WAIT_MS);
+          timeout.unref?.();
+        })
+      ]);
+    } finally {
+      if (timeout) clearTimeout(timeout);
+      if (resolveIdle) state.idleWaiters.delete(resolveIdle);
+    }
+    if (timedOut && state.leases.size > 0) {
+      process.stderr.write(
+        `qwen serve: Voice runtime disposal timed out with ${state.leases.size} active lease(s).
+`
+      );
+    }
+  }
+  stateFor(runtime) {
+    let state = this.states.get(runtime);
+    if (!state) {
+      state = {
+        draining: false,
+        completed: false,
+        leases: /* @__PURE__ */ new Set(),
+        idleWaiters: /* @__PURE__ */ new Set()
+      };
+      this.states.set(runtime, state);
+    }
+    return state;
+  }
+  release(runtime, lease) {
+    const state = this.states.get(runtime);
+    if (!state || !state.leases.delete(lease)) return;
+    this.active--;
+    if (state.leases.size === 0) {
+      for (const resolve of state.idleWaiters) resolve();
+      state.idleWaiters.clear();
+    }
+    this.deleteIfIdle(runtime, state);
+  }
+  deleteIfIdle(runtime, state) {
+    if (state.completed && state.leases.size === 0) this.states.delete(runtime);
+  }
+};
+
 export {
   require_express2 as require_express,
   sanitizeForStderr,
@@ -17863,6 +18239,7 @@ export {
   CLIENT_ID_HEADER,
   MAX_CLIENT_ID_LENGTH,
   MAX_TOOL_NAME_LENGTH,
+  MAX_SKILL_NAME_LENGTH,
   MAX_SERVER_NAME_LENGTH,
   CLIENT_ID_RE,
   safeBody,
@@ -17884,7 +18261,14 @@ export {
   buildDaemonStatusResponse,
   allowOriginMode,
   listenerMaxConnections,
-  positiveFiniteOrNull
+  positiveFiniteOrNull,
+  resolveAcpHttpEnabled,
+  QWEN_CDP_MCP_COMMAND_ENV,
+  resolveCdpMcpCommand,
+  isBrowserAutomationMcpAvailable,
+  MAX_CONCURRENT_VOICE_SESSIONS,
+  VoiceLeaseAbortError,
+  WorkspaceVoiceCoordinator
 };
 /**
  * @license