@qwen-code/qwen-code 0.19.9 → 0.19.10-nightly.20260716.506ce0a1a

package/chunks/{chunk-KHUQZZJ6.js → chunk-IHDRJLLR.js}

@@ -6,21 +6,18 @@ import {
 import {
   CLIENT_MCP_OVER_WS_CONFIG_FLAG
 } from "./chunk-PZL23GTM.js";
-import {
-  MAX_WORKSPACE_PATH_LENGTH
-} from "./chunk-W7FJ3N32.js";
 import {
   require_lib
 } from "./chunk-WBL3FJEU.js";
+import {
+  MAX_WORKSPACE_PATH_LENGTH
+} from "./chunk-W7FJ3N32.js";
 import {
   require_mime_db
 } from "./chunk-T2NCM2ET.js";
 import {
   writeStderrLine
 } from "./chunk-YUZI3WAC.js";
-import {
-  require_once
-} from "./chunk-CU3L64TP.js";
 import {
   require_safer
 } from "./chunk-XWRJCPHC.js";
@@ -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) {
@@ -16451,6 +16528,7 @@ var SERVE_CAPABILITY_REGISTRY = {
   // the underlying ACP method from unstable_resumeSession to resumeSession.
   unstable_session_resume: { since: "v1" },
   session_list: { since: "v1" },
+  session_source_metadata: { since: "v1" },
   session_prompt: { since: "v1" },
   session_cancel: { since: "v1" },
   session_events: { since: "v1" },
@@ -16553,6 +16631,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
@@ -16598,6 +16677,9 @@ var SERVE_CAPABILITY_REGISTRY = {
   // may be `null` for too-short histories or transient model failures
   // (best-effort, never throws). SDK helper: `DaemonClient.recapSession`.
   session_recap: { since: "v1" },
+  // `POST /session/:id/generate` streams a stateless, tool-free model call.
+  // The ACP child prefers fastModel and falls back to the main session model.
+  session_generation: { since: "v1" },
   // Side question (/btw) against the session's conversation context.
   // Single-turn, tool-free LLM call via runForkedAgent (cache path).
   session_btw: { since: "v1" },
@@ -16674,20 +16756,57 @@ var SERVE_CAPABILITY_REGISTRY = {
   // `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 — only when the daemon was started with
-  // `--channel` (i.e. a channel worker exists to reload).
+  // 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, auth, voice, and extensions stay on their
-  // existing primary-workspace routes in this phase.
+  // 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 full session export from archived persisted storage.
+  // This remains independent from active export so older daemons cannot ignore
+  // archive intent and return an active transcript with the same session id.
+  workspace_archived_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,
@@ -16748,13 +16867,48 @@ var CONDITIONAL_SERVE_FEATURES = /* @__PURE__ */ new Map([
     "session_artifacts_persistence",
     (toggles) => toggles.sessionArtifactsPersistenceAvailable === true
   ],
+  [
+    "session_generation",
+    (toggles) => toggles.sessionGenerationAvailable === 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],
   [
@@ -16826,6 +16980,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 }`';
@@ -16928,7 +17083,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",
@@ -17024,7 +17180,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"))
@@ -17034,6 +17191,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";
@@ -17137,7 +17296,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;
@@ -17298,6 +17461,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;
@@ -17324,22 +17488,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);
@@ -17404,16 +17571,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: {
@@ -17550,7 +17718,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({
@@ -17575,12 +17743,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,
@@ -17610,6 +17785,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,
@@ -17628,8 +17813,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) {
@@ -17641,13 +17826,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") {
@@ -17865,20 +18050,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";
-var QWEN_SERVE_ACP_HTTP_ENV = "QWEN_SERVE_ACP_HTTP";
 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 && env[QWEN_SERVE_ACP_HTTP_ENV] !== "0" && resolveCdpMcpCommand(env) !== void 0;
+  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,
@@ -17909,6 +18251,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,
@@ -17931,10 +18274,13 @@ export {
   allowOriginMode,
   listenerMaxConnections,
   positiveFiniteOrNull,
+  resolveAcpHttpEnabled,
   QWEN_CDP_MCP_COMMAND_ENV,
-  QWEN_SERVE_ACP_HTTP_ENV,
   resolveCdpMcpCommand,
-  isBrowserAutomationMcpAvailable
+  isBrowserAutomationMcpAvailable,
+  MAX_CONCURRENT_VOICE_SESSIONS,
+  VoiceLeaseAbortError,
+  WorkspaceVoiceCoordinator
 };
 /**
  * @license