@qwen-code/qwen-code 0.19.7 → 0.19.8-nightly.20260710.205430235

package/chunks/{chunk-YDSYD7UI.js → chunk-E3SA2LY4.js}

@@ -2,10 +2,10 @@
 "use strict";
 import {
   functionResponsePartsToString
-} from "./chunk-OWVIH4HY.js";
+} from "./chunk-B5OAMPJ5.js";
 import {
   parseAndFormatApiError
-} from "./chunk-YEGT55NW.js";
+} from "./chunk-ZDAZSR2O.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-6IAWPIQ6.js → chunk-EDM5O3SX.js}

@@ -9,12 +9,12 @@ import {
 
 // packages/cli/src/serve/workspace-skills-mapping.ts
 init_esbuild_shims();
-function mapSkillConfigToStatus(skill, disabledSkillNames = /* @__PURE__ */ new Set()) {
+function mapSkillConfigToStatus(skill, disabledSkillNames = /* @__PURE__ */ new Set(), opts = {}) {
   const userDisabled = disabledSkillNames.has(skill.name.toLowerCase());
   const modelInvocable = skill.disableModelInvocation !== true;
   return {
     kind: "skill",
-    status: userDisabled ? "disabled" : "ok",
+    status: opts.disabled || userDisabled ? "disabled" : "ok",
     name: skill.name,
     description: skill.description,
     level: skill.level,

package/chunks/{chunk-CISB3IQF.js → chunk-FONJQQWI.js}

@@ -5,10 +5,10 @@ import {
   TaggedThinkingParser,
   getRateLimitErrorDetails,
   openaiRequestCaptureContext
-} from "./chunk-GMOWQOQQ.js";
+} from "./chunk-5ZVIYNLN.js";
 import {
   RequestTokenizer
-} from "./chunk-44NROQYV.js";
+} from "./chunk-JOQMY62N.js";
 import {
   DASHSCOPE_PROXY_BASE_URL,
   DEFAULT_DASHSCOPE_BASE_URL,
@@ -24,7 +24,7 @@ import {
 import {
   runtimeDiagnostics,
   safeJsonParse
-} from "./chunk-CCGOFQV3.js";
+} from "./chunk-SS5P6JM6.js";
 import {
   GenerateContentResponse
 } from "./chunk-55ZMG67I.js";
@@ -8154,6 +8154,33 @@ var StreamInactivityTimeoutError = class extends Error {
   }
   code = "ETIMEDOUT";
 };
+var NON_SSE_BODY_PREFIX_LIMIT = 512;
+function isSSECompatibleContentType(contentType) {
+  if (!contentType) return true;
+  const mediaType = (contentType.split(";")[0] ?? "").trim().toLowerCase();
+  return mediaType === "text/event-stream" || mediaType === "application/x-ndjson" || mediaType === "application/stream+json";
+}
+__name(isSSECompatibleContentType, "isSSECompatibleContentType");
+var NonSSEResponseError = class extends Error {
+  constructor(contentType, httpStatus, bodyPrefix, requestId) {
+    const preview = bodyPrefix.length > 0 ? ` Body prefix: ${bodyPrefix}` : "";
+    super(
+      `Streaming request received a non-SSE response (HTTP ${httpStatus}, Content-Type: ${contentType || "unknown"}).${preview}`
+    );
+    this.contentType = contentType;
+    this.httpStatus = httpStatus;
+    this.bodyPrefix = bodyPrefix;
+    this.requestId = requestId;
+    this.name = "NonSSEResponseError";
+    this.status = httpStatus;
+    this.request_id = requestId;
+  }
+  static {
+    __name(this, "NonSSEResponseError");
+  }
+  status;
+  request_id;
+};
 function resolveStreamIdleTimeoutMs(config) {
   const fromConfig = config.streamIdleTimeoutMs;
   if (typeof fromConfig === "number") {
@@ -8283,9 +8310,41 @@ var ContentGenerationPipeline = class {
         const perRequestAc = createChildAbortController(parentSignal);
         let stream;
         try {
-          stream = await this.client.chat.completions.create(openaiRequest, {
-            signal: perRequestAc.signal
-          });
+          const createPromise = this.client.chat.completions.create(
+            openaiRequest,
+            { signal: perRequestAc.signal }
+          );
+          if (typeof createPromise.withResponse === "function") {
+            const {
+              data,
+              response: httpResponse,
+              request_id
+            } = await createPromise.withResponse();
+            stream = data;
+            const contentType = httpResponse.headers.get("content-type") ?? null;
+            if (!isSSECompatibleContentType(contentType)) {
+              let bodyPrefix = "";
+              try {
+                if (httpResponse.body) {
+                  const reader = httpResponse.body.getReader();
+                  const { value } = await reader.read();
+                  reader.releaseLock();
+                  if (value) {
+                    bodyPrefix = new TextDecoder().decode(value).slice(0, NON_SSE_BODY_PREFIX_LIMIT);
+                  }
+                }
+              } catch {
+              }
+              throw new NonSSEResponseError(
+                contentType,
+                httpResponse.status,
+                bodyPrefix,
+                request_id
+              );
+            }
+          } else {
+            stream = await createPromise;
+          }
         } catch (e) {
           perRequestAc.abort();
           throw e;

package/chunks/{chunk-FRFFNYUY.js → chunk-G3WIMNL4.js}

@@ -2,11 +2,11 @@
 "use strict";
 import {
   writeStderrLine
-} from "./chunk-Y6Z2O3WR.js";
+} from "./chunk-JM7BYJO5.js";
 import {
   JsonFormatter,
   parseAndFormatApiError
-} from "./chunk-YEGT55NW.js";
+} from "./chunk-ZDAZSR2O.js";
 import {
   FatalBudgetExceededError,
   FatalCancellationError,
@@ -15,7 +15,7 @@ import {
 } from "./chunk-22MNNNXE.js";
 import {
   runExitCleanup
-} from "./chunk-4UCTWSTP.js";
+} from "./chunk-34UUM3IN.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-B34OV7K2.js → chunk-GGQQA4JW.js}

@@ -118,6 +118,18 @@ var SessionLimitExceededError = class extends Error {
     this.limit = limit;
   }
 };
+var TotalSessionLimitExceededError = class extends Error {
+  static {
+    __name(this, "TotalSessionLimitExceededError");
+  }
+  limit;
+  scope = "total";
+  constructor(limit) {
+    super(`Total session limit reached (${limit})`);
+    this.name = "TotalSessionLimitExceededError";
+    this.limit = limit;
+  }
+};
 var PromptQueueFullError = class extends Error {
   static {
     __name(this, "PromptQueueFullError");
@@ -394,6 +406,7 @@ export {
   RestoreInProgressError,
   InvalidSessionScopeError,
   SessionLimitExceededError,
+  TotalSessionLimitExceededError,
   PromptQueueFullError,
   WorkspaceMismatchError,
   InvalidClientIdError,

package/chunks/chunk-GLE2YUPU.js

@@ -0,0 +1,34 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/acp-bridge/src/replayWindowLimits.ts
+init_esbuild_shims();
+var DEFAULT_COMPACTED_REPLAY_MAX_BYTES = 4 * 1024 * 1024;
+var MAX_COMPACTED_REPLAY_MAX_BYTES = 256 * 1024 * 1024;
+function normalizeCompactedReplayMaxBytes(value) {
+  if (value === void 0) return DEFAULT_COMPACTED_REPLAY_MAX_BYTES;
+  if (!Number.isSafeInteger(value) || value < 1 || value > MAX_COMPACTED_REPLAY_MAX_BYTES) {
+    throw new TypeError(
+      `Invalid compactedReplayMaxBytes: ${value}. Must be a positive safe integer in [1, ${MAX_COMPACTED_REPLAY_MAX_BYTES}].`
+    );
+  }
+  return value;
+}
+__name(normalizeCompactedReplayMaxBytes, "normalizeCompactedReplayMaxBytes");
+
+export {
+  DEFAULT_COMPACTED_REPLAY_MAX_BYTES,
+  MAX_COMPACTED_REPLAY_MAX_BYTES,
+  normalizeCompactedReplayMaxBytes
+};
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-MJI36HER.js → chunk-GOTMC3BX.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   registerCleanup
-} from "./chunk-4UCTWSTP.js";
+} from "./chunk-34UUM3IN.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-RFIL6REB.js → chunk-GRB4QSBD.js}

@@ -17,7 +17,7 @@ import {
 } from "./chunk-ER3BKOLB.js";
 import {
   writeStderrLine
-} from "./chunk-Y6Z2O3WR.js";
+} from "./chunk-JM7BYJO5.js";
 import {
   require_once
 } from "./chunk-5P5XGNYH.js";
@@ -16455,6 +16455,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
@@ -16668,6 +16669,24 @@ 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 — only when the daemon was started with
+  // `--channel` (i.e. a channel worker exists to reload).
+  channel_reload: { 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" },
+  // 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.
+  workspace_qualified_rest_core: { 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,
@@ -16684,6 +16703,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
@@ -16718,10 +16743,23 @@ 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],
+  [
+    "multi_workspace_sessions",
+    (toggles) => 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
@@ -17231,35 +17269,78 @@ __name(parseDaemonStatusDetail, "parseDaemonStatusDetail");
 async function buildDaemonStatusResponse(detail, input) {
   const bridgeSnapshot = input.bridge.getDaemonStatusSnapshot();
   const lastActivity = input.bridge.lastActivityAt ?? null;
+  const workspaceRuntimes = input.workspaceRegistry?.list();
+  const workspaceSnapshots = workspaceRuntimes?.map((runtime) => ({
+    workspaceCwd: runtime.workspaceCwd,
+    snapshot: runtime.bridge === input.bridge ? bridgeSnapshot : runtime.bridge.getDaemonStatusSnapshot(),
+    lastActivity: runtime.bridge === input.bridge ? lastActivity : runtime.bridge.lastActivityAt ?? null
+  })) ?? [
+    {
+      workspaceCwd: input.boundWorkspace,
+      snapshot: bridgeSnapshot,
+      lastActivity
+    }
+  ];
+  const aggregatedSessionCount = workspaceSnapshots.reduce(
+    (sum, item) => sum + item.snapshot.sessionCount,
+    0
+  );
+  const aggregatedPendingPermissionCount = workspaceSnapshots.reduce(
+    (sum, item) => sum + item.snapshot.pendingPermissionCount,
+    0
+  );
+  const aggregatedChannelLive = workspaceSnapshots.some(
+    (item) => item.snapshot.channelLive
+  );
+  const aggregatedLastActivity = workspaceSnapshots.reduce(
+    (latest, item) => item.lastActivity !== null && (latest === null || item.lastActivity > latest) ? item.lastActivity : latest,
+    null
+  );
   const acpSnapshot = input.acpHandle?.registry.getSnapshot();
   const rateLimitHits = input.rateLimiter?.getHitCounts() ?? zeroRateHits();
   let pendingPrompts = 0;
   let derivedQueuedPrompts = 0;
-  for (const session of bridgeSnapshot.sessions) {
-    pendingPrompts += session.pendingPromptCount;
-    derivedQueuedPrompts += Math.max(
-      0,
-      session.pendingPromptCount - (session.hasActivePrompt ? 1 : 0)
-    );
+  const derivedQueuedPromptsByWorkspace = [];
+  for (const [index, { snapshot }] of workspaceSnapshots.entries()) {
+    let derivedQueuedPromptsForWorkspace = 0;
+    for (const session of snapshot.sessions) {
+      pendingPrompts += session.pendingPromptCount;
+      const sessionQueuedPrompts = Math.max(
+        0,
+        session.pendingPromptCount - (session.hasActivePrompt ? 1 : 0)
+      );
+      derivedQueuedPrompts += sessionQueuedPrompts;
+      derivedQueuedPromptsForWorkspace += sessionQueuedPrompts;
+    }
+    derivedQueuedPromptsByWorkspace[index] = derivedQueuedPromptsForWorkspace;
   }
-  const queuedPrompts = input.bridge.pendingPromptTotal ?? derivedQueuedPrompts;
+  const queuedPrompts = workspaceRuntimes?.reduce(
+    (sum, runtime, index) => sum + (runtime.bridge.pendingPromptTotal ?? derivedQueuedPromptsByWorkspace[index] ?? 0),
+    0
+  ) ?? input.bridge.pendingPromptTotal ?? derivedQueuedPrompts;
   const channelWorker = input.getChannelWorkerSnapshot?.() ?? {
     enabled: false,
     state: "disabled",
     channels: []
   };
+  const totalAdmissionSnapshot = input.getTotalSessionAdmissionSnapshot?.();
   const issues = [];
   let full;
   pushRuntimeIssues(
     issues,
-    bridgeSnapshot,
     acpSnapshot,
     rateLimitHits,
     input,
-    channelWorker
+    channelWorker,
+    totalAdmissionSnapshot,
+    workspaceSnapshots
   );
   if (detail === "full") {
-    full = await buildFullStatus(input, bridgeSnapshot, acpSnapshot);
+    full = await buildFullStatus(
+      input,
+      acpSnapshot,
+      workspaceSnapshots.flatMap((item) => item.snapshot.sessions)
+    );
     pushFullIssues(issues, full);
   }
   return {
@@ -17288,26 +17369,39 @@ async function buildDaemonStatusResponse(detail, input) {
     },
     limits: {
       maxSessions: bridgeSnapshot.limits.maxSessions,
+      maxTotalSessions: positiveFiniteOrNull(input.opts.maxTotalSessions),
       maxPendingPromptsPerSession: bridgeSnapshot.limits.maxPendingPromptsPerSession,
       listenerMaxConnections: listenerMaxConnections(input.opts.maxConnections),
       eventRingSize: bridgeSnapshot.limits.eventRingSize,
+      compactedReplayMaxBytes: bridgeSnapshot.limits.compactedReplayMaxBytes,
       promptDeadlineMs: positiveFiniteOrNull(input.opts.promptDeadlineMs),
       writerIdleTimeoutMs: positiveFiniteOrNull(input.opts.writerIdleTimeoutMs),
       channelIdleTimeoutMs: bridgeSnapshot.limits.channelIdleTimeoutMs,
       sessionIdleTimeoutMs: bridgeSnapshot.limits.sessionIdleTimeoutMs,
       acpConnectionCap: acpSnapshot?.connectionCap ?? null
     },
+    ...workspaceRuntimes && workspaceRuntimes.length > 1 ? {
+      workspaces: workspaceRuntimes.map((runtime) => ({
+        id: runtime.workspaceId,
+        cwd: runtime.workspaceCwd,
+        primary: runtime.primary,
+        trusted: runtime.trusted
+      }))
+    } : {},
     capabilities: {
       protocolVersions: input.protocolVersions,
       features: [...input.features]
     },
     runtime: {
-      sessions: { active: bridgeSnapshot.sessionCount },
+      sessions: {
+        active: aggregatedSessionCount,
+        ...totalAdmissionSnapshot ? { admissionInFlight: totalAdmissionSnapshot.inFlight } : {}
+      },
       permissions: {
-        pending: bridgeSnapshot.pendingPermissionCount,
+        pending: aggregatedPendingPermissionCount,
         policy: bridgeSnapshot.permissionPolicy
       },
-      channel: { live: bridgeSnapshot.channelLive },
+      channel: { live: aggregatedChannelLive },
       channelWorker,
       transport: {
         restSseActive: input.getRestSseActive(),
@@ -17328,11 +17422,14 @@ async function buildDaemonStatusResponse(detail, input) {
       ...input.getPerfSnapshot ? { perf: input.getPerfSnapshot() } : {},
       ...input.getMetricsSeries ? { metrics: { series: input.getMetricsSeries() } } : {},
       activity: {
-        activePrompts: input.bridge.activePromptCount ?? 0,
+        activePrompts: workspaceRuntimes?.reduce(
+          (sum, runtime) => sum + (runtime.bridge.activePromptCount ?? 0),
+          0
+        ) ?? input.bridge.activePromptCount ?? 0,
         pendingPrompts,
         queuedPrompts,
-        lastActivityAt: lastActivity !== null ? new Date(lastActivity).toISOString() : null,
-        idleSinceMs: lastActivity !== null ? Date.now() - lastActivity : null
+        lastActivityAt: aggregatedLastActivity !== null ? new Date(aggregatedLastActivity).toISOString() : null,
+        idleSinceMs: aggregatedLastActivity !== null ? Date.now() - aggregatedLastActivity : null
       },
       process: process.memoryUsage()
     },
@@ -17354,7 +17451,7 @@ function cloneStartup(startup) {
   };
 }
 __name(cloneStartup, "cloneStartup");
-async function buildFullStatus(input, bridgeSnapshot, acpSnapshot) {
+async function buildFullStatus(input, acpSnapshot, sessions) {
   const ctx = {
     route: "GET /daemon/status",
     workspaceCwd: input.boundWorkspace
@@ -17394,7 +17491,7 @@ async function buildFullStatus(input, bridgeSnapshot, acpSnapshot) {
     )
   ]);
   return {
-    sessions: bridgeSnapshot.sessions,
+    sessions,
     acpConnections: acpSnapshot?.connections ?? [],
     workspace: {
       mcp,
@@ -17452,13 +17549,30 @@ async function withTimeout(promise, section, timeoutMs) {
   }
 }
 __name(withTimeout, "withTimeout");
-function pushRuntimeIssues(issues, bridgeSnapshot, acpSnapshot, rateLimitHits, input, channelWorker) {
-  if (bridgeSnapshot.limits.maxSessions !== null && bridgeSnapshot.limits.maxSessions > 0 && bridgeSnapshot.sessionCount / bridgeSnapshot.limits.maxSessions >= CAPACITY_WARNING_RATIO) {
-    issues.push({
-      code: "session_capacity_high",
-      severity: "warning",
-      message: `Active sessions are at ${bridgeSnapshot.sessionCount}/${bridgeSnapshot.limits.maxSessions}.`
-    });
+function pushRuntimeIssues(issues, acpSnapshot, rateLimitHits, input, channelWorker, 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({
+        code: "session_capacity_high",
+        severity: "warning",
+        message: workspaceSnapshots.length > 1 ? `Workspace ${workspaceCwd} active sessions are at ${snapshot.sessionCount}/${snapshot.limits.maxSessions}.` : `Active sessions are at ${snapshot.sessionCount}/${snapshot.limits.maxSessions}.`
+      });
+    }
+  }
+  const maxTotalSessions = positiveFiniteOrNull(input.opts.maxTotalSessions);
+  if (maxTotalSessions !== null) {
+    const fallbackLiveCount = workspaceSnapshots.reduce(
+      (sum, item) => sum + item.snapshot.sessionCount,
+      0
+    );
+    const totalActive = (totalAdmissionSnapshot?.liveCount ?? fallbackLiveCount) + (totalAdmissionSnapshot?.inFlight ?? 0);
+    if (totalActive / maxTotalSessions >= CAPACITY_WARNING_RATIO) {
+      issues.push({
+        code: "total_session_capacity_high",
+        severity: "warning",
+        message: `Total active and in-flight sessions are at ${totalActive}/${maxTotalSessions}.`
+      });
+    }
   }
   if (acpSnapshot !== void 0 && acpSnapshot.connectionCap !== null && acpSnapshot.connectionCap > 0 && acpSnapshot.connectionCount / acpSnapshot.connectionCap >= CAPACITY_WARNING_RATIO) {
     issues.push({
@@ -17467,18 +17581,25 @@ function pushRuntimeIssues(issues, bridgeSnapshot, acpSnapshot, rateLimitHits, i
       message: `ACP connections are at ${acpSnapshot.connectionCount}/${acpSnapshot.connectionCap}.`
     });
   }
-  if (bridgeSnapshot.pendingPermissionCount > 0) {
+  const pendingPermissionCount = workspaceSnapshots.reduce(
+    (sum, item) => sum + item.snapshot.pendingPermissionCount,
+    0
+  );
+  if (pendingPermissionCount > 0) {
     issues.push({
       code: "pending_permissions",
       severity: "warning",
-      message: `${bridgeSnapshot.pendingPermissionCount} permission request(s) are pending.`
+      message: `${pendingPermissionCount} permission request(s) are pending.`
     });
   }
-  if (bridgeSnapshot.sessionCount > 0 && !bridgeSnapshot.channelLive) {
+  const downWorkspaces = workspaceSnapshots.filter(
+    (item) => item.snapshot.sessionCount > 0 && !item.snapshot.channelLive
+  );
+  if (downWorkspaces.length > 0) {
     issues.push({
       code: "acp_channel_down",
       severity: "error",
-      message: "Active sessions exist but the ACP channel is not live."
+      message: downWorkspaces.length === 1 ? `Active sessions exist but the ACP channel is not live for ${downWorkspaces[0].workspaceCwd}.` : `Active sessions exist but the ACP channel is not live for ${downWorkspaces.length} workspace(s).`
     });
   }
   if (input.opts.rateLimit === true && sumRateHits(rateLimitHits) > 0) {
@@ -17743,6 +17864,19 @@ function copyNumber(from, to, key) {
 }
 __name(copyNumber, "copyNumber");
 
+// 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 && env["QWEN_SERVE_ACP_HTTP"] !== "0" && resolveCdpMcpCommand(env) !== void 0;
+}
+__name(isBrowserAutomationMcpAvailable, "isBrowserAutomationMcpAvailable");
+
 export {
   require_express2 as require_express,
   sanitizeForStderr,
@@ -17794,7 +17928,10 @@ export {
   buildDaemonStatusResponse,
   allowOriginMode,
   listenerMaxConnections,
-  positiveFiniteOrNull
+  positiveFiniteOrNull,
+  QWEN_CDP_MCP_COMMAND_ENV,
+  resolveCdpMcpCommand,
+  isBrowserAutomationMcpAvailable
 };
 /**
  * @license

package/chunks/chunk-GVVY7GSP.js

@@ -0,0 +1,38 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  t
+} from "./chunk-UOXLB2LY.js";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/ui/utils/history-gap-notice.ts
+init_esbuild_shims();
+function formatHistoryGapNotice(_gap) {
+  return t(
+    "\u26A0\uFE0F History gap: earlier conversation was lost before this point (storage interruption) and could not be recovered."
+  );
+}
+__name(formatHistoryGapNotice, "formatHistoryGapNotice");
+function indexGapsByChild(gaps) {
+  const byChild = /* @__PURE__ */ new Map();
+  for (const gap of gaps ?? []) {
+    byChild.set(gap.childUuid, gap);
+  }
+  return byChild;
+}
+__name(indexGapsByChild, "indexGapsByChild");
+
+export {
+  formatHistoryGapNotice,
+  indexGapsByChild
+};
+/**
+ * @license
+ * Copyright 2025 Qwen Code
+ * SPDX-License-Identifier: Apache-2.0
+ */