@zubriq/code 0.19.8-1 → 0.19.9-1

package/dist/chunks/{chunk-REPRY4F7.js → chunk-YCKKP4QA.js}

@@ -4,19 +4,19 @@ import {
   handleAtCommand,
   resolveAtCommandQuery,
   sanitizeDisplayText
-} from "./chunk-PWR5MVM3.js";
+} from "./chunk-SSP3UT5C.js";
 import {
   isAtCommand,
   isBtwCommand,
   isSlashCommand,
   normalizePartList,
   recordGoalStatusItem
-} from "./chunk-XKYOIERV.js";
+} from "./chunk-BN5VYAOZ.js";
 import {
   SHELL_COMMAND_NAME,
   fitPendingSlice,
   useSessionStats
-} from "./chunk-45YCXM2H.js";
+} from "./chunk-YZDBUH6S.js";
 import {
   require_react
 } from "./chunk-KYMBIKIW.js";
@@ -28,10 +28,10 @@ import {
 } from "./chunk-KHDZHZMH.js";
 import {
   isInlineModelOverrideAllowed
-} from "./chunk-4FQL7KUS.js";
+} from "./chunk-XWDHZP7P.js";
 import {
   t
-} from "./chunk-ENKWIF75.js";
+} from "./chunk-MA4AZNP7.js";
 import {
   AutonomousLoopTickResolver,
   CoreToolScheduler,
@@ -53,7 +53,7 @@ import {
   setActiveGoal,
   shouldRunVisionBridge,
   splitImageParts
-} from "./chunk-PDITONOB.js";
+} from "./chunk-5MRUKUOG.js";
 import {
   ApiCancelEvent,
   ConversationFinishedEvent,
@@ -63,17 +63,17 @@ import {
   logConversationFinishedEvent,
   logUserPrompt,
   logUserRetry
-} from "./chunk-YRM6BC6H.js";
+} from "./chunk-27AYMAL6.js";
 import {
   isAnyAutoMemPath
-} from "./chunk-4KJ2BPIT.js";
+} from "./chunk-OACJLMLD.js";
 import {
   ToolNames
 } from "./chunk-X3YGAX7V.js";
 import {
   getUnsupportedImageFormatWarning,
   isSupportedImageMimeType
-} from "./chunk-PIORL4OD.js";
+} from "./chunk-UKV3D7WB.js";
 import {
   FinishReason
 } from "./chunk-55ZMG67I.js";
@@ -1466,7 +1466,7 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
         );
         if (!clipped) break;
         let boundaryLine = -1;
-        for (let k = Math.min(keptLines, bufferLines.length) - 1; k >= 0; k--) {
+        for (let k = Math.min(keptLines, bufferLines.length - 1); k >= 0; k--) {
           if (bufferLines[k].trim() === "") {
             boundaryLine = k;
             break;

package/dist/chunks/{chunk-YNWQ3PUQ.js → chunk-YJWMOGGZ.js}

@@ -5,17 +5,17 @@ import {
 } from "./chunk-6IAWPIQ6.js";
 import {
   loadSettings
-} from "./chunk-ABANKQYY.js";
+} from "./chunk-WJAW2O5H.js";
 import {
   STATUS_SCHEMA_VERSION
-} from "./chunk-NHFBLJOI.js";
+} from "./chunk-Q3PQ5VGJ.js";
 import {
   writeStderrLine
 } from "./chunk-Y6Z2O3WR.js";
 import {
   SkillManager,
   isSafeModeEnv
-} from "./chunk-PDITONOB.js";
+} from "./chunk-5MRUKUOG.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/dist/chunks/{chunk-RFIL6REB.js → chunk-YKZIAK7C.js}

@@ -16668,6 +16668,9 @@ var SERVE_CAPABILITY_REGISTRY = {
   session_branch: { since: "v1" },
   rate_limit: { since: "v1" },
   workspace_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" },
   // 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,
@@ -16720,6 +16723,10 @@ var CONDITIONAL_SERVE_FEATURES = /* @__PURE__ */ new Map([
   ],
   ["rate_limit", (toggles) => toggles.rateLimit === true],
   ["workspace_reload", (toggles) => toggles.reloadAvailable === true],
+  [
+    "multi_workspace_sessions",
+    (toggles) => toggles.multiWorkspaceSessionsEnabled === true
+  ],
   ["client_mcp_over_ws", (toggles) => toggles.clientMcpOverWsEnabled === true],
   ["cdp_tunnel_over_ws", (toggles) => toggles.cdpTunnelOverWsEnabled === true],
   [
@@ -17231,35 +17238,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 +17338,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 +17391,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 +17420,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 +17460,7 @@ async function buildFullStatus(input, bridgeSnapshot, acpSnapshot) {
     )
   ]);
   return {
-    sessions: bridgeSnapshot.sessions,
+    sessions,
     acpConnections: acpSnapshot?.connections ?? [],
     workspace: {
       mcp,
@@ -17452,13 +17518,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 +17550,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) {

package/dist/chunks/{chunk-45YCXM2H.js → chunk-YZDBUH6S.js}

@@ -2,19 +2,19 @@
 "use strict";
 import {
   getEffectiveSupportedModes
-} from "./chunk-4UC3U66K.js";
+} from "./chunk-6EUMFVPJ.js";
 import {
   require_jsx_runtime
-} from "./chunk-UE5TCZE6.js";
+} from "./chunk-5FAUIGXH.js";
 import {
   require_react
 } from "./chunk-KYMBIKIW.js";
 import {
   getCachedStringWidth
-} from "./chunk-536GZ6UF.js";
+} from "./chunk-2MDC5WDB.js";
 import {
   uiTelemetryService
-} from "./chunk-YRM6BC6H.js";
+} from "./chunk-27AYMAL6.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -376,6 +376,7 @@ __name(getCommandSubcommandNames, "getCommandSubcommandNames");
 // packages/cli/src/ui/utils/pending-rendered-height.ts
 init_esbuild_shims();
 var TABLE_CHROME_ROWS = 5;
+var TABLE_MAX_ROW_LINES = 4;
 var TABLE_ROW_RE = /^\s*\|(.+)\|\s*$/;
 var TABLE_SEPARATOR_RE = /^(?=.*\|)\s*\|?\s*(:?-+:?)\s*(\|\s*(:?-+:?)\s*)*\|?\s*$/;
 var CODE_FENCE_RE = /^ *(`{3,}|~{3,}) *([^`]*)$/;
@@ -490,13 +491,47 @@ function fitPendingSlice(allLines, contentWidth, budget, tableClampRows) {
       let j = i + 2;
       while (j < allLines.length && TABLE_ROW_RE.test(allLines[j])) j++;
       const dataRows = j - (i + 2);
-      const colCount = splitMarkdownTableRow(
+      const headerCells = splitMarkdownTableRow(
         TABLE_ROW_RE.exec(allLines[i])[1]
-      ).length;
+      );
+      const colCount = headerCells.length;
       const minHorizontalWidth = Math.max(24, 6 * colCount + 5);
-      const usesVertical = contentWidth < minHorizontalWidth;
-      const rows = usesVertical ? dataRows * colCount + Math.max(0, dataRows - 1) + 2 : 2 * dataRows + TABLE_CHROME_ROWS;
-      const cost = Math.min(rows, tableClampRows);
+      const perColWidth = Math.max(
+        3,
+        Math.floor((contentWidth - (1 + 3 * colCount) - 4) / colCount)
+      );
+      let contentRows = 0;
+      let verticalRows = 0;
+      let maxRowLines = 1;
+      for (const label of headerCells) {
+        maxRowLines = Math.max(
+          maxRowLines,
+          estimateWrappedRows(label, perColWidth)
+        );
+      }
+      contentRows += maxRowLines;
+      for (let r = i + 2; r < j; r++) {
+        const cells = splitMarkdownTableRow(
+          TABLE_ROW_RE.exec(allLines[r])[1]
+        );
+        let rowMax = 1;
+        for (let colIdx = 0; colIdx < cells.length; colIdx++) {
+          const value = cells[colIdx];
+          rowMax = Math.max(rowMax, estimateWrappedRows(value, perColWidth));
+          const label = headerCells[colIdx] ?? "";
+          verticalRows += estimateWrappedRows(
+            label ? `${label}: ${value}` : value,
+            contentWidth
+          );
+        }
+        contentRows += rowMax;
+        if (r === i + 2) {
+          maxRowLines = Math.max(maxRowLines, rowMax);
+        }
+      }
+      const usesVertical = dataRows > 0 && (contentWidth < minHorizontalWidth || maxRowLines > TABLE_MAX_ROW_LINES);
+      const rows = usesVertical ? verticalRows + Math.max(0, dataRows - 1) + 2 : contentRows + Math.max(0, dataRows - 1) + TABLE_CHROME_ROWS;
+      const cost = Math.min(rows, tableClampRows + 2);
       if (rendered + cost > budget && i > 0) {
         kept = i;
         break;
@@ -538,6 +573,7 @@ var TOOL_STATUS = {
 };
 
 export {
+  TABLE_MAX_ROW_LINES,
   TABLE_ROW_RE,
   TABLE_SEPARATOR_RE,
   CODE_FENCE_RE,

package/dist/chunks/chunk-Z3I3QJK3.js

@@ -0,0 +1,47 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+
+// packages/cli/src/config/shared-env-keys.ts
+init_esbuild_shims();
+var DEFAULT_EXCLUDED_ENV_VARS = ["DEBUG", "DEBUG_MODE"];
+var ENV_CORRUPTED_PATH = "QWEN_CODE_SETTINGS_CORRUPTED_PATH";
+var ENV_WAS_RECOVERED = "QWEN_CODE_SETTINGS_WAS_RECOVERED";
+var PROJECT_ENV_HARDCODED_EXCLUSIONS = [
+  "QWEN_HOME",
+  "QWEN_RUNTIME_DIR",
+  "QWEN_CODE_MCP_APPROVALS_PATH",
+  "QWEN_CODE_TRUSTED_FOLDERS_PATH",
+  ENV_CORRUPTED_PATH,
+  ENV_WAS_RECOVERED,
+  // QWEN_TLS_INSECURE (and NODE_TLS_REJECT_UNAUTHORIZED, which it mirrors)
+  // disable TLS certificate verification for all outbound API connections. A
+  // project `.env` must never enable either — that would let an untrusted repo
+  // silently turn off MITM protection. Opt-in stays with the user via the
+  // `--insecure` flag, the shell environment, or a home `.env`. The initial
+  // `.env` load only consults this list, so both keys must be here (not just
+  // RELOAD_EXCLUDED_KEYS, which only applies on reload).
+  "QWEN_TLS_INSECURE",
+  "NODE_TLS_REJECT_UNAUTHORIZED"
+];
+var HOME_ENV_BOOTSTRAP_KEYS = [
+  "QWEN_HOME",
+  "QWEN_RUNTIME_DIR",
+  "QWEN_CODE_MCP_APPROVALS_PATH",
+  "QWEN_CODE_TRUSTED_FOLDERS_PATH"
+];
+
+export {
+  DEFAULT_EXCLUDED_ENV_VARS,
+  ENV_CORRUPTED_PATH,
+  ENV_WAS_RECOVERED,
+  PROJECT_ENV_HARDCODED_EXCLUSIONS,
+  HOME_ENV_BOOTSTRAP_KEYS
+};
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/chunks/{chunk-G23FFNLT.js → chunk-ZDGPPCTW.js}

@@ -3,22 +3,25 @@
 import {
   HEADLESS_YOLO_NO_SANDBOX_WARNING
 } from "./chunk-BJBWRCSK.js";
+import {
+  DEFAULT_RING_SIZE
+} from "./chunk-3UP777ZS.js";
+import {
+  DEFAULT_COMPACTED_REPLAY_MAX_BYTES
+} from "./chunk-GLE2YUPU.js";
 import {
   normalizeServeChannelSelection
 } from "./chunk-MX2YXRER.js";
 import {
   loadSettings
-} from "./chunk-ABANKQYY.js";
-import {
-  DEFAULT_RING_SIZE
-} from "./chunk-G7ZG7CA6.js";
+} from "./chunk-WJAW2O5H.js";
 import {
   writeStderrLine
 } from "./chunk-Y6Z2O3WR.js";
 import {
   MCP_BUDGET_WARN_FRACTION,
   parsePositiveIntegerEnv
-} from "./chunk-PDITONOB.js";
+} from "./chunk-5MRUKUOG.js";
 import {
   openBrowserSecurely,
   shouldLaunchBrowser
@@ -88,6 +91,9 @@ var serveCommand = {
     type: "number",
     default: 20,
     description: "Cap on concurrent live sessions. New spawn requests beyond this return 503; attach to existing sessions still works. Set to 0 to disable."
+  }).option("max-total-sessions", {
+    type: "number",
+    description: "Non-negative integer cap on concurrent live sessions across all workspace runtimes. Set to 0 to disable."
   }).option("max-pending-prompts-per-session", {
     type: "number",
     default: 5,
@@ -96,7 +102,7 @@ var serveCommand = {
     type: "string",
     array: true,
     requiresArg: true,
-    description: "Absolute workspace path this daemon binds to. POST /session requests with a mismatched cwd return 400 workspace_mismatch. Defaults to process.cwd() when omitted. For multi-workspace deployments, run one `qwen serve` per workspace on separate ports (or behind an external orchestrator)."
+    description: "Absolute workspace path this daemon binds to. POST /session requests with a mismatched cwd return 400 workspace_mismatch. Defaults to process.cwd() when omitted. Repeat for sessions-only multi-workspace mode; legacy workspace APIs remain primary-workspace only."
   }).option("max-connections", {
     type: "number",
     default: 256,
@@ -139,10 +145,14 @@ var serveCommand = {
     // one place rather than drifting between CLI and bus.
     default: DEFAULT_RING_SIZE,
     description: "Per-session SSE replay ring depth. Sets the replay backlog available to `GET /session/:id/events` reconnects that send a `Last-Event-ID: N` header. Larger = more reconnect headroom at the cost of a few hundred KB extra RAM per session. Must be a positive finite integer."
+  }).option("compacted-replay-max-bytes", {
+    type: "number",
+    default: DEFAULT_COMPACTED_REPLAY_MAX_BYTES,
+    description: "Per-session in-memory compacted replay snapshot byte cap for `POST /session/:id/load` late attaches. Larger = more recent history in load snapshots at higher heap cost. Must be a positive safe integer no larger than 256 MiB."
   }).option("http-bridge", {
     type: "boolean",
     default: true,
-    description: "Stage 1 mode: one `qwen --acp` child per daemon (the daemon binds to one workspace at boot, multiplexing N sessions onto that child via the agent's native `newSession()`). Stage 2 native in-process mode is not yet implemented; this flag will become opt-in then."
+    description: "HTTP bridge mode: one `qwen --acp` child per registered workspace (sessions-only multi-workspace routing is enabled when multiple --workspace values are supplied). Stage 2 native in-process mode is not yet implemented; this flag will become opt-in then."
   }).option("mcp-client-budget", {
     type: "number",
     description: "Cap on live MCP clients spawned inside the ACP child for the bound workspace. Positive integer. Combine with --mcp-budget-mode to control behavior at the cap. When unset, mode defaults to off (no accounting-driven enforcement, but GET /workspace/mcp still reports `clientCount`). Distinct from claude-code MCP_SERVER_CONNECTION_BATCH_SIZE which gates startup concurrency, not the total client count."
@@ -287,7 +297,7 @@ var serveCommand = {
         process.exit(1);
       }
     }
-    const { runQwenServe } = await import("./run-qwen-serve-XGJSNF6S.js");
+    const { runQwenServe } = await import("./run-qwen-serve-WUEHQROF.js");
     try {
       const handle = await runQwenServe({
         port: argv.port,
@@ -295,9 +305,11 @@ var serveCommand = {
         token: argv.token,
         mode: "http-bridge",
         maxSessions: argv["max-sessions"],
+        ...argv["max-total-sessions"] !== void 0 ? { maxTotalSessions: argv["max-total-sessions"] } : {},
         maxPendingPromptsPerSession,
         maxConnections: argv["max-connections"],
         eventRingSize: argv["event-ring-size"],
+        compactedReplayMaxBytes: argv["compacted-replay-max-bytes"],
         workspace: argv.workspace,
         requireAuth: argv["require-auth"],
         enableSessionShell: argv["enable-session-shell"],

package/dist/chunks/chunk-ZL5HN75Q.js

@@ -0,0 +1,61 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  TotalSessionLimitExceededError
+} from "./chunk-GGQQA4JW.js";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/serve/total-session-admission.ts
+init_esbuild_shims();
+function createTotalSessionAdmissionController({
+  maxTotalSessions,
+  getBridges
+}) {
+  let inFlight = 0;
+  const limit = maxTotalSessions === void 0 || maxTotalSessions === 0 || maxTotalSessions === Number.POSITIVE_INFINITY ? Number.POSITIVE_INFINITY : maxTotalSessions;
+  return {
+    admit(context) {
+      if (limit !== Number.POSITIVE_INFINITY) {
+        if (getLiveCount(getBridges()) + inFlight >= limit) {
+          throw Object.assign(new TotalSessionLimitExceededError(limit), {
+            operation: context.operation,
+            workspaceCwd: context.workspaceCwd,
+            ...context.sessionId ? { sessionId: context.sessionId } : {},
+            ...context.sourceSessionId ? { sourceSessionId: context.sourceSessionId } : {}
+          });
+        }
+      }
+      inFlight++;
+      let released = false;
+      return {
+        release() {
+          if (released) return;
+          released = true;
+          inFlight--;
+        }
+      };
+    },
+    snapshot() {
+      return { liveCount: getLiveCount(getBridges()), inFlight };
+    }
+  };
+}
+__name(createTotalSessionAdmissionController, "createTotalSessionAdmissionController");
+function getLiveCount(bridges) {
+  return bridges.reduce((sum, bridge) => sum + bridge.sessionCount, 0);
+}
+__name(getLiveCount, "getLiveCount");
+
+export {
+  createTotalSessionAdmissionController
+};
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */