@qwen-code/qwen-code 0.19.6 → 0.19.7-nightly.20260708.394c1a289

package/chunks/{run-qwen-serve-FADLRJUN.js → run-qwen-serve-4JDO64RN.js}

@@ -1,5 +1,9 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  DaemonMetricsRing,
+  computeCpuPercent
+} from "./chunk-II73RK2S.js";
 import {
   findCliEntryPath
 } from "./chunk-AHNXYU4O.js";
@@ -9,6 +13,7 @@ import {
 import {
   CAPABILITIES_SCHEMA_VERSION,
   ClientMcpSenderRegistry,
+  PathMutexRegistry,
   SERVE_CAPABILITY_REGISTRY,
   allowOriginCors,
   allowOriginMode,
@@ -26,7 +31,7 @@ import {
   positiveFiniteOrNull,
   require_express,
   resolveWebShellDir
-} from "./chunk-N4YJQTRL.js";
+} from "./chunk-RFIL6REB.js";
 import {
   isLoopbackBind
 } from "./chunk-RNBYOUGV.js";
@@ -46,18 +51,23 @@ import {
   getGlobalQwenDirLite,
   resolveConfigPathLite
 } from "./chunk-4RQIB5UZ.js";
-import "./chunk-EWALXUAD.js";
+import {
+  LOAD_REPLAY_META_KEY
+} from "./chunk-AGHU5VRK.js";
 import {
   canonicalizeWorkspace
-} from "./chunk-SEZC2725.js";
+} from "./chunk-ER3BKOLB.js";
 import {
   getCliVersion
-} from "./chunk-SL2P3JUA.js";
+} from "./chunk-XUSONNJ4.js";
+import "./chunk-43W4YSO6.js";
 import {
   writeStderrLine,
   writeStdoutLine
 } from "./chunk-Y6Z2O3WR.js";
-import "./chunk-QYUE6W3T.js";
+import {
+  isWithinRoot
+} from "./chunk-QYUE6W3T.js";
 import "./chunk-5P5XGNYH.js";
 import "./chunk-SKAZWEV5.js";
 import "./chunk-UWCTAVOD.js";
@@ -84,7 +94,106 @@ import { X509Certificate } from "node:crypto";
 import * as fs from "node:fs";
 import * as https from "node:https";
 import * as path from "node:path";
-import { performance } from "node:perf_hooks";
+import * as os from "node:os";
+import { monitorEventLoopDelay, performance } from "node:perf_hooks";
+
+// packages/cli/src/serve/workspace-inputs.ts
+init_esbuild_shims();
+var DuplicateWorkspaceInputError = class extends Error {
+  static {
+    __name(this, "DuplicateWorkspaceInputError");
+  }
+  constructor(workspace) {
+    super(
+      `Duplicate --workspace value resolves to ${JSON.stringify(workspace)}. Multi-workspace serve is not enabled; pass one --workspace.`
+    );
+    this.name = "DuplicateWorkspaceInputError";
+  }
+};
+var NestedWorkspaceInputError = class extends Error {
+  static {
+    __name(this, "NestedWorkspaceInputError");
+  }
+  constructor(parent, child) {
+    super(
+      `Nested --workspace values are not supported yet: ${JSON.stringify(child)} is inside ${JSON.stringify(parent)}. Multi-workspace serve is not enabled; pass one --workspace.`
+    );
+    this.name = "NestedWorkspaceInputError";
+  }
+};
+var MultipleWorkspaceInputError = class extends Error {
+  static {
+    __name(this, "MultipleWorkspaceInputError");
+  }
+  constructor() {
+    super(
+      "Multiple --workspace values are not supported yet. Multi-workspace serve is not enabled; pass one --workspace."
+    );
+    this.name = "MultipleWorkspaceInputError";
+  }
+};
+var MissingWorkspaceInputError = class extends Error {
+  static {
+    __name(this, "MissingWorkspaceInputError");
+  }
+  constructor() {
+    super("--workspace requires a value.");
+    this.name = "MissingWorkspaceInputError";
+  }
+};
+function normalizeWorkspaceInputs(workspace) {
+  if (Array.isArray(workspace)) {
+    if (workspace.length === 0) {
+      throw new MissingWorkspaceInputError();
+    }
+    return workspace.map((value) => String(value));
+  }
+  if (workspace === void 0) return [process.cwd()];
+  return [String(workspace)];
+}
+__name(normalizeWorkspaceInputs, "normalizeWorkspaceInputs");
+function isNestedWorkspace(parent, child) {
+  return parent !== child && isWithinRoot(child, parent);
+}
+__name(isNestedWorkspace, "isNestedWorkspace");
+function rejectUnsupportedMultiWorkspaceInputs(workspaces) {
+  if (workspaces.length <= 1) return;
+  let canonicalWorkspaces;
+  try {
+    canonicalWorkspaces = workspaces.map(
+      (workspace) => canonicalizeWorkspace(workspace)
+    );
+  } catch {
+    throw new MultipleWorkspaceInputError();
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const workspace of canonicalWorkspaces) {
+    if (seen.has(workspace)) {
+      throw new DuplicateWorkspaceInputError(workspace);
+    }
+    seen.add(workspace);
+  }
+  for (let i = 0; i < canonicalWorkspaces.length; i++) {
+    for (let j = i + 1; j < canonicalWorkspaces.length; j++) {
+      const first = canonicalWorkspaces[i];
+      const second = canonicalWorkspaces[j];
+      if (isNestedWorkspace(first, second)) {
+        throw new NestedWorkspaceInputError(first, second);
+      }
+      if (isNestedWorkspace(second, first)) {
+        throw new NestedWorkspaceInputError(second, first);
+      }
+    }
+  }
+  throw new MultipleWorkspaceInputError();
+}
+__name(rejectUnsupportedMultiWorkspaceInputs, "rejectUnsupportedMultiWorkspaceInputs");
+function resolveSingleWorkspaceInput(workspace) {
+  const workspaces = normalizeWorkspaceInputs(workspace);
+  rejectUnsupportedMultiWorkspaceInputs(workspaces);
+  return workspaces[0];
+}
+__name(resolveSingleWorkspaceInput, "resolveSingleWorkspaceInput");
 
 // packages/cli/src/serve/permission-audit.ts
 init_esbuild_shims();
@@ -295,26 +404,35 @@ function isOptedOut() {
   return ["0", "false", "off", "no"].includes(raw.trim().toLowerCase());
 }
 __name(isOptedOut, "isOptedOut");
-function computeDaemonId(pid, boundWorkspace) {
-  const hash = crypto.createHash("sha256").update(boundWorkspace).digest("hex").slice(0, 8);
-  return `serve-${pid}-${hash}`;
+function computeWorkspaceHash(boundWorkspace) {
+  return crypto.createHash("sha256").update(boundWorkspace).digest("hex").slice(0, 8);
+}
+__name(computeWorkspaceHash, "computeWorkspaceHash");
+function computeDaemonId(pid) {
+  return `daemon:${pid}`;
 }
 __name(computeDaemonId, "computeDaemonId");
+function computeDaemonLogFileName(pid) {
+  return `serve-${pid}.log`;
+}
+__name(computeDaemonLogFileName, "computeDaemonLogFileName");
 function initDaemonLogger(opts) {
   if (isOptedOut()) return NOOP_LOGGER;
   const pid = opts.pid ?? process.pid;
   const now = opts.now ?? (() => /* @__PURE__ */ new Date());
   const stderr = opts.stderr ?? writeStderrLine;
   const baseDir = opts.baseDir ?? resolveDaemonLogBaseDir();
-  const daemonId = computeDaemonId(pid, opts.boundWorkspace);
+  const daemonId = computeDaemonId(pid);
+  const workspaceHash = computeWorkspaceHash(opts.boundWorkspace);
   const daemonDir = nodePath.join(baseDir, "daemon");
-  const logPath = nodePath.join(daemonDir, `${daemonId}.log`);
+  const logPath = nodePath.join(daemonDir, computeDaemonLogFileName(pid));
   try {
     nodeFs.mkdirSync(daemonDir, { recursive: true });
     const firstLine = buildDaemonLogLine({
       level: "INFO",
-      message: `daemon started pid=${pid} workspace=${opts.boundWorkspace}`,
-      now: now()
+      message: `daemon started pid=${pid}`,
+      now: now(),
+      ctx: { workspace: opts.boundWorkspace, workspaceHash }
     });
     nodeFs.appendFileSync(logPath, firstLine);
   } catch (err) {
@@ -364,12 +482,445 @@ function initDaemonLogger(opts) {
 }
 __name(initDaemonLogger, "initDaemonLogger");
 
+// packages/cli/src/serve/large-pipe-frame-observer.ts
+init_esbuild_shims();
+var LARGE_PIPE_FRAME_THRESHOLD_BYTES = 256 * 1024;
+var LARGE_PIPE_FRAME_LOG_LIMIT = 50;
+var LARGE_PIPE_FRAME_LOG_WINDOW_MS = 6e4;
+var LARGE_PIPE_FRAME_EVENT_NAME = "qwen-code.daemon.pipe.large_frame";
+var MAX_ATTR_STRING_LENGTH = 128;
+var MAX_CONTENT_DEPTH = 32;
+var MAX_JSON_APPROX_DEPTH = 32;
+var MAX_RAW_OUTPUT_APPROX_BYTES = LARGE_PIPE_FRAME_THRESHOLD_BYTES;
+var MAX_SUMMARIZED_UPDATES = 500;
+var SUMMARIZED_UPDATE_PREFIX_COUNT = Math.ceil(MAX_SUMMARIZED_UPDATES / 2);
+var SUMMARIZED_UPDATE_SUFFIX_COUNT = MAX_SUMMARIZED_UPDATES - SUMMARIZED_UPDATE_PREFIX_COUNT;
+function createLargePipeFrameObserver(options) {
+  const thresholdBytes = options.thresholdBytes ?? LARGE_PIPE_FRAME_THRESHOLD_BYTES;
+  const windowMs = options.windowMs ?? LARGE_PIPE_FRAME_LOG_WINDOW_MS;
+  const logLimit = options.logLimit ?? LARGE_PIPE_FRAME_LOG_LIMIT;
+  const now = options.now ?? Date.now;
+  let windowStartedAt = now();
+  let emittedInWindow = 0;
+  let suppressedCount = 0;
+  let suppressedWindowStartMs;
+  return (observation) => {
+    try {
+      if (observation.bytes < thresholdBytes) return;
+      const currentTime = now();
+      if (currentTime - windowStartedAt >= windowMs) {
+        windowStartedAt = currentTime;
+        emittedInWindow = 0;
+      }
+      if (emittedInWindow >= logLimit) {
+        suppressedCount += 1;
+        suppressedWindowStartMs ??= windowStartedAt;
+        return;
+      }
+      const context = classifyLargePipeFrame(observation, thresholdBytes);
+      if (!context) return;
+      if (suppressedCount > 0) {
+        context["suppressedCount"] = suppressedCount;
+        if (suppressedWindowStartMs !== void 0) {
+          context["suppressedWindowStartMs"] = suppressedWindowStartMs;
+        }
+        suppressedCount = 0;
+        suppressedWindowStartMs = void 0;
+      }
+      emittedInWindow += 1;
+      try {
+        options.daemonLog.warn("large ACP pipe frame observed", context);
+      } catch {
+      }
+      try {
+        options.emitTelemetryLog?.("Large ACP pipe frame observed.", context, {
+          eventName: LARGE_PIPE_FRAME_EVENT_NAME
+        });
+      } catch {
+      }
+    } catch {
+    }
+  };
+}
+__name(createLargePipeFrameObserver, "createLargePipeFrameObserver");
+function classifyLargePipeFrame(observation, thresholdBytes = LARGE_PIPE_FRAME_THRESHOLD_BYTES) {
+  if (observation.bytes < thresholdBytes) return void 0;
+  const message = asRecord(observation.message);
+  const messageKind = message ? getMessageKind(message) : "unknown";
+  const method = message ? stringValue(message["method"]) : void 0;
+  const classification = classifySource(message, messageKind, method);
+  const context = {
+    direction: observation.direction,
+    bytes: observation.bytes,
+    thresholdBytes,
+    messageKind,
+    sourceClass: classification.sourceClass
+  };
+  addString(context, "method", method);
+  if (classification.sourceClass === "session_update_notification") {
+    addUpdateSummary(context, summarizeUpdate(classification.update));
+  } else if (classification.sourceClass === "load_session_bulk_replay_response") {
+    addUpdatesSummary(context, classification.replay?.["updates"]);
+  } else if (classification.sourceClass === "load_updates_response") {
+    addUpdatesSummary(context, classification.result?.["updates"]);
+  }
+  return context;
+}
+__name(classifyLargePipeFrame, "classifyLargePipeFrame");
+function classifySource(message, messageKind, method) {
+  if (!message) return { sourceClass: "unknown" };
+  const params = asRecord(message["params"]);
+  const update = asRecord(params?.["update"]);
+  if (messageKind === "notification" && method === "session/update" && update) {
+    return { sourceClass: "session_update_notification", update };
+  }
+  if (messageKind === "response") {
+    const replay = getBulkReplay(message);
+    if (replay) {
+      return { sourceClass: "load_session_bulk_replay_response", replay };
+    }
+    const result = asRecord(message["result"]);
+    if (isLoadUpdatesResult(result)) {
+      return { sourceClass: "load_updates_response", result };
+    }
+    return { sourceClass: "jsonrpc_response" };
+  }
+  if (method) return { sourceClass: "jsonrpc_request" };
+  return { sourceClass: "unknown" };
+}
+__name(classifySource, "classifySource");
+function getMessageKind(message) {
+  const method = stringValue(message["method"]);
+  const hasId = Object.hasOwn(message, "id");
+  if (method) return hasId ? "request" : "notification";
+  if (hasId && (Object.hasOwn(message, "result") || Object.hasOwn(message, "error"))) {
+    return "response";
+  }
+  return "unknown";
+}
+__name(getMessageKind, "getMessageKind");
+function getBulkReplay(message) {
+  const result = asRecord(message?.["result"]);
+  const meta = asRecord(result?.["_meta"]);
+  return asRecord(meta?.[LOAD_REPLAY_META_KEY]);
+}
+__name(getBulkReplay, "getBulkReplay");
+function isLoadUpdatesResult(result) {
+  if (!Array.isArray(result?.["updates"])) return false;
+  return typeof result["startTime"] === "string" || typeof result["lastUpdated"] === "string" || typeof result["replayError"] === "string" || typeof result["partial"] === "boolean";
+}
+__name(isLoadUpdatesResult, "isLoadUpdatesResult");
+function addUpdatesSummary(context, updates) {
+  if (!Array.isArray(updates)) return;
+  context["updateCount"] = updates.length;
+  const sampledIndexes = sampleUpdateIndexes(updates.length);
+  if (sampledIndexes.length < updates.length) {
+    context["summarizedUpdateCount"] = sampledIndexes.length;
+    context["summarizedUpdateStrategy"] = "prefix_and_suffix";
+  }
+  const summary = {};
+  for (const index of sampledIndexes) {
+    mergeUpdateSummary(summary, summarizeUpdate(asRecord(updates[index])));
+  }
+  addUpdateSummary(context, summary);
+}
+__name(addUpdatesSummary, "addUpdatesSummary");
+function sampleUpdateIndexes(updateCount) {
+  if (updateCount <= MAX_SUMMARIZED_UPDATES) {
+    return Array.from({ length: updateCount }, (_, index) => index);
+  }
+  const indexes = [];
+  for (let i = 0; i < SUMMARIZED_UPDATE_PREFIX_COUNT; i += 1) {
+    indexes.push(i);
+  }
+  for (let i = updateCount - SUMMARIZED_UPDATE_SUFFIX_COUNT; i < updateCount; i += 1) {
+    indexes.push(i);
+  }
+  return indexes;
+}
+__name(sampleUpdateIndexes, "sampleUpdateIndexes");
+function summarizeUpdate(update) {
+  if (!update) return {};
+  const meta = asRecord(update["_meta"]);
+  const summary = {};
+  summary.sessionUpdate = stringValue(update["sessionUpdate"]);
+  summary.toolName = stringValue(meta?.["toolName"]);
+  summary.toolProvenance = stringValue(meta?.["provenance"]);
+  const contentBytes = contentTextBytes(update["content"]);
+  if (contentBytes > 0) {
+    summary.maxContentTextBytes = contentBytes;
+  }
+  summary.maxObservedUpdateBytes = contentBytes;
+  if (Object.hasOwn(update, "rawOutput")) {
+    const rawOutput = update["rawOutput"];
+    summary.rawOutputKind = rawOutputKind(rawOutput);
+    if (typeof rawOutput === "string") {
+      const rawOutputTextBytes = Buffer.byteLength(rawOutput, "utf8");
+      summary.maxRawOutputTextBytes = rawOutputTextBytes;
+      summary.maxRawOutputObservedBytes = rawOutputTextBytes;
+      summary.maxObservedUpdateBytes = Math.max(
+        summary.maxObservedUpdateBytes,
+        rawOutputTextBytes
+      );
+    } else {
+      const rawOutputApprox = approximateJsonByteLength(rawOutput);
+      if (rawOutputApprox !== void 0) {
+        summary.maxRawOutputApproxBytes = rawOutputApprox.bytes;
+        if (rawOutputApprox.capped) {
+          summary.maxRawOutputApproxBytesCapped = true;
+        }
+        summary.maxRawOutputObservedBytes = rawOutputApprox.bytes;
+        summary.maxObservedUpdateBytes = Math.max(
+          summary.maxObservedUpdateBytes,
+          rawOutputApprox.bytes
+        );
+      }
+    }
+  }
+  return summary;
+}
+__name(summarizeUpdate, "summarizeUpdate");
+function mergeUpdateSummary(target, next) {
+  if (next.sessionUpdate && target.sessionUpdate && next.sessionUpdate !== target.sessionUpdate) {
+    target.mixedSessionUpdate = true;
+  }
+  if (next.mixedSessionUpdate) {
+    target.mixedSessionUpdate = true;
+  }
+  if (next.maxObservedUpdateBytes !== void 0 && (target.maxObservedUpdateBytes === void 0 || next.maxObservedUpdateBytes > target.maxObservedUpdateBytes)) {
+    target.maxObservedUpdateBytes = next.maxObservedUpdateBytes;
+    target.sessionUpdate = next.sessionUpdate ?? target.sessionUpdate;
+    target.toolName = next.toolName ?? target.toolName;
+    target.toolProvenance = next.toolProvenance ?? target.toolProvenance;
+  }
+  if (next.maxContentTextBytes !== void 0 && (target.maxContentTextBytes === void 0 || next.maxContentTextBytes > target.maxContentTextBytes)) {
+    target.maxContentTextBytes = next.maxContentTextBytes;
+  }
+  if (next.maxRawOutputTextBytes !== void 0 && (target.maxRawOutputTextBytes === void 0 || next.maxRawOutputTextBytes > target.maxRawOutputTextBytes)) {
+    target.maxRawOutputTextBytes = next.maxRawOutputTextBytes;
+  }
+  if (next.maxRawOutputApproxBytes !== void 0 && (target.maxRawOutputApproxBytes === void 0 || next.maxRawOutputApproxBytes > target.maxRawOutputApproxBytes)) {
+    target.maxRawOutputApproxBytes = next.maxRawOutputApproxBytes;
+  }
+  if (next.maxRawOutputApproxBytesCapped) {
+    target.maxRawOutputApproxBytesCapped = true;
+  }
+  if (next.maxRawOutputObservedBytes !== void 0 && (target.maxRawOutputObservedBytes === void 0 || next.maxRawOutputObservedBytes > target.maxRawOutputObservedBytes)) {
+    target.maxRawOutputObservedBytes = next.maxRawOutputObservedBytes;
+    target.rawOutputKind = next.rawOutputKind;
+  }
+}
+__name(mergeUpdateSummary, "mergeUpdateSummary");
+function addUpdateSummary(context, summary) {
+  addString(context, "sessionUpdate", summary.sessionUpdate);
+  addString(context, "toolName", summary.toolName);
+  addString(context, "toolProvenance", summary.toolProvenance);
+  if (summary.mixedSessionUpdate) context["mixedSessionUpdate"] = true;
+  addNumber(context, "maxContentTextBytes", summary.maxContentTextBytes);
+  addNumber(context, "maxRawOutputTextBytes", summary.maxRawOutputTextBytes);
+  addNumber(
+    context,
+    "maxRawOutputApproxBytes",
+    summary.maxRawOutputApproxBytes
+  );
+  if (summary.maxRawOutputApproxBytesCapped) {
+    context["maxRawOutputApproxBytesCapped"] = true;
+  }
+  addString(context, "rawOutputKind", summary.rawOutputKind);
+}
+__name(addUpdateSummary, "addUpdateSummary");
+function contentTextBytes(value, depth = 0) {
+  if (depth > MAX_CONTENT_DEPTH) return 0;
+  if (typeof value === "string") return Buffer.byteLength(value, "utf8");
+  if (Array.isArray(value)) {
+    return value.reduce(
+      (sum, item) => sum + contentTextBytes(item, depth + 1),
+      0
+    );
+  }
+  const record = asRecord(value);
+  if (!record) return 0;
+  let total = 0;
+  const text = stringValue(record["text"]);
+  if (text) total += Buffer.byteLength(text, "utf8");
+  if (Object.hasOwn(record, "content")) {
+    total += contentTextBytes(record["content"], depth + 1);
+  }
+  return total;
+}
+__name(contentTextBytes, "contentTextBytes");
+function approximateJsonByteLength(value) {
+  const state = {
+    budget: MAX_RAW_OUTPUT_APPROX_BYTES,
+    bytes: 0,
+    capped: false,
+    seen: /* @__PURE__ */ new WeakSet()
+  };
+  if (!addJsonValueBytes(value, state, 0)) return void 0;
+  return { bytes: state.bytes, capped: state.capped };
+}
+__name(approximateJsonByteLength, "approximateJsonByteLength");
+function addJsonValueBytes(value, state, depth) {
+  if (state.capped) return true;
+  switch (typeof value) {
+    case "string":
+      addJsonStringBytes(value, state);
+      return true;
+    case "number":
+      addJsonBytes(state, Number.isFinite(value) ? String(value).length : 4);
+      return true;
+    case "boolean":
+      addJsonBytes(state, value ? 4 : 5);
+      return true;
+    case "object":
+      if (value === null) {
+        addJsonBytes(state, 4);
+        return true;
+      }
+      if (depth >= MAX_JSON_APPROX_DEPTH) {
+        capJsonBytes(state);
+        return true;
+      }
+      if (Array.isArray(value)) {
+        addJsonArrayBytes(value, state, depth);
+      } else {
+        addJsonObjectBytes(value, state, depth);
+      }
+      return true;
+    default:
+      return false;
+  }
+}
+__name(addJsonValueBytes, "addJsonValueBytes");
+function addJsonArrayBytes(value, state, depth) {
+  if (state.seen.has(value)) {
+    capJsonBytes(state);
+    return;
+  }
+  state.seen.add(value);
+  addJsonBytes(state, 1);
+  for (let i = 0; i < value.length && !state.capped; i += 1) {
+    if (i > 0) addJsonBytes(state, 1);
+    if (!addJsonValueBytes(value[i], state, depth + 1)) {
+      addJsonBytes(state, 4);
+    }
+  }
+  addJsonBytes(state, 1);
+  state.seen.delete(value);
+}
+__name(addJsonArrayBytes, "addJsonArrayBytes");
+function addJsonObjectBytes(value, state, depth) {
+  if (state.seen.has(value)) {
+    capJsonBytes(state);
+    return;
+  }
+  state.seen.add(value);
+  addJsonBytes(state, 1);
+  const record = value;
+  let propertyCount = 0;
+  for (const key in record) {
+    if (state.capped) break;
+    if (!Object.hasOwn(record, key)) continue;
+    const item = record[key];
+    if (isOmittedJsonObjectValue(item)) continue;
+    if (propertyCount > 0) addJsonBytes(state, 1);
+    addJsonStringBytes(key, state);
+    addJsonBytes(state, 1);
+    if (!addJsonValueBytes(item, state, depth + 1)) {
+      addJsonBytes(state, 4);
+    }
+    propertyCount += 1;
+  }
+  addJsonBytes(state, 1);
+  state.seen.delete(value);
+}
+__name(addJsonObjectBytes, "addJsonObjectBytes");
+function addJsonStringBytes(value, state) {
+  addJsonBytes(state, 1);
+  if (state.capped) return;
+  const remainingForContent = Math.max(0, state.budget - state.bytes - 1);
+  const sampleLength = Math.min(value.length, remainingForContent);
+  const sample = sampleLength < value.length ? value.slice(0, sampleLength) : value;
+  addJsonBytes(state, Buffer.byteLength(sample, "utf8"));
+  if (sampleLength < value.length) {
+    capJsonBytes(state);
+    return;
+  }
+  addJsonBytes(state, 1);
+}
+__name(addJsonStringBytes, "addJsonStringBytes");
+function addJsonBytes(state, bytes) {
+  if (state.capped || bytes <= 0) return;
+  const nextBytes = state.bytes + bytes;
+  if (nextBytes >= state.budget) {
+    capJsonBytes(state);
+    return;
+  }
+  state.bytes = nextBytes;
+}
+__name(addJsonBytes, "addJsonBytes");
+function capJsonBytes(state) {
+  state.bytes = state.budget;
+  state.capped = true;
+}
+__name(capJsonBytes, "capJsonBytes");
+function isOmittedJsonObjectValue(value) {
+  return typeof value === "undefined" || typeof value === "function" || typeof value === "symbol";
+}
+__name(isOmittedJsonObjectValue, "isOmittedJsonObjectValue");
+function rawOutputKind(value) {
+  if (Array.isArray(value)) return "array";
+  if (value === null) return "null";
+  return typeof value;
+}
+__name(rawOutputKind, "rawOutputKind");
+function addString(context, key, value) {
+  if (value === void 0) return;
+  context[key] = value.length > MAX_ATTR_STRING_LENGTH ? value.slice(0, MAX_ATTR_STRING_LENGTH) : value;
+}
+__name(addString, "addString");
+function addNumber(context, key, value) {
+  if (value !== void 0) context[key] = value;
+}
+__name(addNumber, "addNumber");
+function stringValue(value) {
+  return typeof value === "string" ? value : void 0;
+}
+__name(stringValue, "stringValue");
+function asRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+__name(asRecord, "asRecord");
+
 // packages/cli/src/serve/run-qwen-serve.ts
 var QWEN_SERVE_CLIENT_MCP_OVER_WS_ENV = "QWEN_SERVE_CLIENT_MCP_OVER_WS";
 var QWEN_SERVE_CDP_TUNNEL_OVER_WS_ENV = "QWEN_SERVE_CDP_TUNNEL_OVER_WS";
 var QWEN_SERVE_PROMPT_DEADLINE_MS_ENV = "QWEN_SERVE_PROMPT_DEADLINE_MS";
 var QWEN_SERVE_WRITER_IDLE_TIMEOUT_MS_ENV = "QWEN_SERVE_WRITER_IDLE_TIMEOUT_MS";
 var SHUTDOWN_FORCE_CLOSE_MS = 5e3;
+function daemonPipeDirection(direction) {
+  switch (direction) {
+    case "sent":
+      return "outbound";
+    case "received":
+      return "inbound";
+    default: {
+      const exhaustive = direction;
+      return exhaustive;
+    }
+  }
+}
+__name(daemonPipeDirection, "daemonPipeDirection");
+var DAEMON_METRICS_SAMPLE_MS = 5e3;
+var DAEMON_METRICS_CAPACITY = 180;
+function safeCpuUsage() {
+  try {
+    return process.cpuUsage();
+  } catch {
+    return null;
+  }
+}
+__name(safeCpuUsage, "safeCpuUsage");
 var DEFAULT_RUNTIME_STARTUP_TIMEOUT_MS = 12e4;
 var FAST_PATH_RUNTIME_START_AFTER_HEALTH_MS = 50;
 var FAST_PATH_RUNTIME_START_FALLBACK_MS = 1e3;
@@ -531,8 +1082,8 @@ __name(withSettingsLock, "withSettingsLock");
 var channelWorkerRuntimePromise;
 async function loadChannelWorkerRuntime() {
   channelWorkerRuntimePromise ??= Promise.all([
-    import("./channel-worker-supervisor-JUYQ5Z4R.js"),
-    import("./pidfile-HFXSHR64.js")
+    import("./channel-worker-supervisor-CRCVYQIE.js"),
+    import("./pidfile-AN5JQJ2T.js")
   ]).then(([supervisor, pidfile]) => ({
     createChannelWorkerSupervisor: supervisor.createChannelWorkerSupervisor,
     channelServicePidfile: pidfile
@@ -603,7 +1154,7 @@ function shouldPreheatBridge(deps) {
 __name(shouldPreheatBridge, "shouldPreheatBridge");
 var coreRuntimePromise;
 function loadCoreRuntime() {
-  coreRuntimePromise ??= import("./src-HITDGVRM.js");
+  coreRuntimePromise ??= import("./src-NLEX4CUC.js");
   return coreRuntimePromise;
 }
 __name(loadCoreRuntime, "loadCoreRuntime");
@@ -633,9 +1184,9 @@ __name(resolveDaemonLogBaseDirForRun, "resolveDaemonLogBaseDirForRun");
 var settingsRuntimePromise;
 function loadSettingsRuntimeModules() {
   settingsRuntimePromise ??= Promise.all([
-    import("./settings-LC4CCWQQ.js"),
-    import("./loadedSettingsAdapter-XV74KOSR.js"),
-    import("./trustedFolders-JD4QX6UJ.js")
+    import("./settings-QBGGXANI.js"),
+    import("./loadedSettingsAdapter-GNGELH6Q.js"),
+    import("./trustedFolders-GAQM2GHB.js")
   ]).then(([settings, loadedSettingsAdapter, trustedFolders]) => ({
     settings,
     loadedSettingsAdapter,
@@ -655,18 +1206,19 @@ async function loadServeRuntimeModules() {
     workspaceProvidersStatusModule,
     workspaceSkillsStatusModule
   ] = await Promise.all([
-    import("./server-WKDQA6XR.js"),
-    import("./bridge-DF3IJQ5V.js"),
-    import("./spawnChannel-B6JJPBPV.js"),
-    import("./workspace-service-GX3GGZLU.js"),
+    import("./server-GEOYEPYT.js"),
+    import("./bridge-U6HXOHE7.js"),
+    import("./spawnChannel-3JYXY52G.js"),
+    import("./workspace-service-ZJHF22WA.js"),
     import("./types-QX5C3CHJ.js"),
-    import("./daemon-status-provider-2EWTHT7Y.js"),
-    import("./workspace-providers-status-XGW5OZTD.js"),
-    import("./workspace-skills-status-LFK5WV2V.js")
+    import("./daemon-status-provider-6A4QCG6Q.js"),
+    import("./workspace-providers-status-SC67GLMY.js"),
+    import("./workspace-skills-status-NJEK6P6Y.js")
   ]);
   return {
     createServeApp: serverModule.createServeApp,
     getActiveSseCount: serverModule.getActiveSseCount,
+    resolveBoundWorkspacesFromIdeEnv: serverModule.resolveBoundWorkspacesFromIdeEnv,
     resolveBridgeFsFactory: serverModule.resolveBridgeFsFactory,
     createAcpSessionBridge: bridgeModule.createAcpSessionBridge,
     createSpawnChannelFactory: spawnChannelModule.createSpawnChannelFactory,
@@ -1014,6 +1566,13 @@ function createBootstrapServeApp(input) {
             read: 0
           }
         },
+        activity: {
+          activePrompts: 0,
+          pendingPrompts: 0,
+          queuedPrompts: 0,
+          lastActivityAt: null,
+          idleSinceMs: null
+        },
         process: process.memoryUsage()
       },
       ...detail.detail === "full" ? {
@@ -1125,11 +1684,13 @@ async function runQwenServe(optsIn, deps = {}) {
   const chromeExtensionOriginAllowed = hasChromeExtensionOrigin(
     optsIn.allowOrigins
   );
+  const rawWorkspace = resolveSingleWorkspaceInput(optsIn.workspace);
   const opts = {
     ...optsIn,
     token,
     promptDeadlineMs,
     writerIdleTimeoutMs,
+    workspace: rawWorkspace,
     clientMcpOverWs: optsIn.clientMcpOverWs ?? (!envFlagDisabled(clientMcpOverWsEnv) && clientMcpOverWsEnv !== void 0),
     cdpTunnelOverWs: optsIn.cdpTunnelOverWs ?? (!envFlagDisabled(cdpTunnelOverWsEnv) && (cdpTunnelOverWsEnv !== void 0 || chromeExtensionOriginAllowed))
   };
@@ -1269,7 +1830,6 @@ async function runQwenServe(optsIn, deps = {}) {
       "qwen serve: --allow-private-auth-base-url enabled; /workspace/auth/provider may install localhost/private-network model endpoints. Use only for local development with trusted clients."
     );
   }
-  const rawWorkspace = opts.workspace ?? process.cwd();
   if (!path.isAbsolute(rawWorkspace)) {
     throw new Error(
       `Invalid --workspace "${rawWorkspace}": must be an absolute path.`
@@ -1446,6 +2006,7 @@ async function runQwenServe(optsIn, deps = {}) {
   let runtimeAppForCleanup;
   let bridgeRef = deps.bridge;
   let daemonEventLoopMonitor;
+  let daemonMetricsSampler;
   let runtimeStartupError;
   let runtimeStarting;
   let markRuntimeReady;
@@ -1463,6 +2024,8 @@ async function runQwenServe(optsIn, deps = {}) {
   const disposeDaemonEventLoopMonitor = /* @__PURE__ */ __name(() => {
     daemonEventLoopMonitor?.dispose();
     daemonEventLoopMonitor = void 0;
+    daemonMetricsSampler?.dispose();
+    daemonMetricsSampler = void 0;
   }, "disposeDaemonEventLoopMonitor");
   let channelWorker = createDisabledChannelWorkerSupervisor();
   const getChannelWorkerSnapshot = /* @__PURE__ */ __name(() => channelWorker.snapshot(), "getChannelWorkerSnapshot");
@@ -1529,7 +2092,7 @@ async function runQwenServe(optsIn, deps = {}) {
       createDaemonTelemetryRuntimeConfig(
         daemonTelemetrySettings,
         resolvedCliVersion,
-        `daemon:${daemonWorkspaceHash}:${process.pid}`,
+        `daemon:${process.pid}`,
         {
           otlpEndpoint: core.DEFAULT_OTLP_ENDPOINT,
           telemetryTarget: core.DEFAULT_TELEMETRY_TARGET
@@ -1547,17 +2110,41 @@ async function runQwenServe(optsIn, deps = {}) {
     core.registerDaemonEventLoopLagGauge(
       () => currentDaemonEventLoopMonitor.snapshot()
     );
+    const metricsRing = new DaemonMetricsRing({
+      capacity: DAEMON_METRICS_CAPACITY
+    });
     const pipeStats = {
       inbound: { count: 0, totalBytes: 0, maxBytes: 0 },
       outbound: { count: 0, totalBytes: 0, maxBytes: 0 }
     };
+    const promptQueueWaitStats = {
+      count: 0,
+      totalMs: 0,
+      maxMs: 0,
+      lastMs: null
+    };
     const recordPipeMessage = /* @__PURE__ */ __name((direction, bytes) => {
       const stats = pipeStats[direction];
       stats.count += 1;
       stats.totalBytes += bytes;
       stats.maxBytes = Math.max(stats.maxBytes, bytes);
       core.recordDaemonPipeMessage(direction, bytes);
+      metricsRing.recordPipe(direction, bytes);
     }, "recordPipeMessage");
+    const observeLargePipeFrame = createLargePipeFrameObserver({
+      daemonLog,
+      emitTelemetryLog: core.emitDaemonLog
+    });
+    const recordPromptQueueWait = /* @__PURE__ */ __name((durationMs) => {
+      promptQueueWaitStats.count += 1;
+      promptQueueWaitStats.totalMs += durationMs;
+      promptQueueWaitStats.maxMs = Math.max(
+        promptQueueWaitStats.maxMs,
+        durationMs
+      );
+      promptQueueWaitStats.lastMs = durationMs;
+      core.recordDaemonPromptQueueWait(durationMs);
+    }, "recordPromptQueueWait");
     const daemonTelemetry = core.createDaemonBridgeTelemetry();
     daemonTelemetry.metrics = {
       sessionLifecycle(action) {
@@ -1585,27 +2172,83 @@ async function runQwenServe(optsIn, deps = {}) {
           }
         );
       },
-      promptQueueWait: core.recordDaemonPromptQueueWait,
-      promptDuration: core.recordDaemonPromptDuration,
-      cancelled: core.recordDaemonCancel
+      promptQueueWait(durationMs) {
+        recordPromptQueueWait(durationMs);
+        metricsRing.recordPromptQueueWait(durationMs);
+      },
+      promptDuration(durationMs) {
+        core.recordDaemonPromptDuration(durationMs);
+        metricsRing.recordPromptDuration(durationMs);
+      },
+      cancelled: core.recordDaemonCancel,
+      // Per-round model token usage + LLM round-trip time sniffed off
+      // `agent_message_chunk._meta` (`usage` + `durationMs`) at the bridge's
+      // single session/update fan-in. Increments (not cumulative), so the ring
+      // sums tokens per window (token-burn chart) and pools the round-trip times
+      // for the LLM-latency percentiles.
+      tokenUsage(inputTokens, outputTokens, durationMs) {
+        metricsRing.recordTokens(inputTokens, outputTokens);
+        if (typeof durationMs === "number") {
+          metricsRing.recordLlmDuration(durationMs);
+        }
+      }
     };
     const permissionAuditRing = new PermissionAuditRing();
     const permissionAuditPublisher = createPermissionAuditPublisher({
       ring: permissionAuditRing
     });
     const customIgnoreFiles = runtimeBootSettings?.merged.context?.fileFiltering?.customIgnoreFiles;
-    const fsFactory = runtime.resolveBridgeFsFactory({
+    const boundWorkspaces = runtime.resolveBoundWorkspacesFromIdeEnv(
       boundWorkspace,
+      void 0,
+      (workspace, index) => {
+        if (index === 0) return true;
+        if (!runtimeBootSettings) {
+          daemonLog.warn(
+            "excluding secondary workspace root because trust settings are unavailable",
+            { workspace }
+          );
+          return false;
+        }
+        const trustedSecondary = settingsRuntime.trustedFolders.getWorkspaceTrustStatus(
+          runtimeBootSettings.merged,
+          workspace
+        ).effective.state === "trusted";
+        if (!trustedSecondary) {
+          daemonLog.warn(
+            "excluding untrusted secondary workspace root from file-system access",
+            { workspace }
+          );
+        }
+        return trustedSecondary;
+      }
+    );
+    daemonLog.info("daemon workspace roots initialized", {
+      primary: boundWorkspaces[0],
+      secondary: boundWorkspaces.slice(1),
+      ideEnvPresent: !!process.env["QWEN_CODE_IDE_WORKSPACE_PATH"]
+    });
+    const sharedPathLocks = new PathMutexRegistry();
+    const fsFactory = runtime.resolveBridgeFsFactory({
+      // Secondary roots share a write-capable factory only after their own
+      // folder trust check passes; untrusted secondary roots stay outside.
+      boundWorkspaces,
       injected: deps.fsFactory,
       trusted: trustedWorkspace,
       emit: deps.fsAuditEmit,
+      pathLocks: sharedPathLocks,
       ...customIgnoreFiles !== void 0 ? { customIgnoreFiles } : {}
     });
     const channelFactory = runtime.createSpawnChannelFactory({
       onDiagnosticLine: diagnosticSink,
       pipeHooks: {
         onMessageSent: /* @__PURE__ */ __name((bytes) => recordPipeMessage("outbound", bytes), "onMessageSent"),
-        onMessageReceived: /* @__PURE__ */ __name((bytes) => recordPipeMessage("inbound", bytes), "onMessageReceived")
+        onMessageReceived: /* @__PURE__ */ __name((bytes) => recordPipeMessage("inbound", bytes), "onMessageReceived"),
+        onMessageObserved: /* @__PURE__ */ __name(({ direction, bytes, message }) => observeLargePipeFrame({
+          direction: daemonPipeDirection(direction),
+          bytes,
+          message
+        }), "onMessageObserved")
       },
       ...opts.experimentalLsp === true ? { extraArgs: ["--experimental-lsp"] } : {}
     });
@@ -1718,22 +2361,123 @@ async function runQwenServe(optsIn, deps = {}) {
       sseCount: /* @__PURE__ */ __name(() => runtime.getActiveSseCount(), "sseCount"),
       heapUsed: /* @__PURE__ */ __name(() => process.memoryUsage().heapUsed, "heapUsed")
     });
+    daemonMetricsSampler?.dispose();
+    const metricsLoopDelay = monitorEventLoopDelay({ resolution: 20 });
+    metricsLoopDelay.enable();
+    const cpuCoreCount = os.availableParallelism?.() ?? os.cpus().length ?? 1;
+    let prevCpu = safeCpuUsage();
+    let prevCpuAt = Date.now();
+    let prevRateRejected;
+    const metricsSamplerTimer = setInterval(() => {
+      const nowMs = Date.now();
+      const eventLoopLagP99Ms = metricsLoopDelay.percentile(99) / 1e6;
+      try {
+        const mem = process.memoryUsage();
+        const cpu = safeCpuUsage();
+        const cpuPercent = computeCpuPercent(
+          prevCpu,
+          cpu,
+          nowMs - prevCpuAt,
+          cpuCoreCount
+        );
+        if (cpu) {
+          prevCpu = cpu;
+          prevCpuAt = nowMs;
+        }
+        const acp = app2.locals?.["acpHandle"]?.registry.getSnapshot();
+        const hits = getRateLimiter(app2)?.getHitCounts();
+        const rejectedTotal = hits ? hits.prompt + hits.mutation + hits.read : 0;
+        const rateLimitRejected = prevRateRejected === void 0 ? 0 : Math.max(0, rejectedTotal - prevRateRejected);
+        prevRateRejected = rejectedTotal;
+        const child = bridge.getChildResourceSnapshot?.();
+        if (runtime.getActiveSseCount() > 0 || (acp?.wsStreams ?? 0) > 0) {
+          void bridge.refreshChildResource?.();
+        }
+        metricsRing.sample(nowMs, {
+          cpuPercent,
+          rssBytes: mem.rss,
+          heapUsedBytes: mem.heapUsed,
+          activeSessions: bridge.sessionCount,
+          activePrompts: bridge.activePromptCount,
+          queuedPrompts: bridge.pendingPromptTotal ?? 0,
+          eventLoopLagP99Ms,
+          sseConnections: runtime.getActiveSseCount(),
+          wsConnections: acp?.wsStreams ?? 0,
+          acpConnections: acp?.connectionCount ?? 0,
+          rateLimitRejected,
+          childCpuPercent: child?.cpuPercent ?? 0,
+          childRssBytes: child?.rssBytes ?? 0
+        });
+      } catch (err) {
+        daemonLog.warn(
+          `metrics sampler tick failed: ${err instanceof Error ? err.message : String(err)}`
+        );
+        try {
+          metricsRing.sample(nowMs, {
+            cpuPercent: 0,
+            rssBytes: 0,
+            heapUsedBytes: 0,
+            activeSessions: 0,
+            activePrompts: 0,
+            queuedPrompts: 0,
+            eventLoopLagP99Ms,
+            sseConnections: 0,
+            wsConnections: 0,
+            acpConnections: 0,
+            rateLimitRejected: 0,
+            childCpuPercent: 0,
+            childRssBytes: 0
+          });
+        } catch {
+        }
+      } finally {
+        metricsLoopDelay.reset();
+      }
+    }, DAEMON_METRICS_SAMPLE_MS);
+    metricsSamplerTimer.unref();
+    daemonMetricsSampler = {
+      dispose() {
+        clearInterval(metricsSamplerTimer);
+        metricsLoopDelay.disable();
+      }
+    };
     const app2 = runtime.createServeApp(opts, () => actualPort, {
       bridge,
       webShellDir,
       boundWorkspace,
       qwenCodeVersion: resolvedCliVersion,
       startup,
-      fsFactory,
+      // The real long-running daemon keeps scheduled-task sessions resident
+      // (keepalive) and reloads them on boot (rehydration). Off by default so
+      // direct createServeApp embeds/tests don't spawn sessions.
+      manageScheduledTaskSessions: true,
+      fsFactory: runtime.resolveBridgeFsFactory({
+        // REST routes still return primary-relative paths, so keep their
+        // filesystem boundary primary-only until responses carry root IDs.
+        boundWorkspaces: [boundWorkspace],
+        trusted: trustedWorkspace,
+        emit: deps.fsAuditEmit,
+        pathLocks: sharedPathLocks,
+        ...customIgnoreFiles !== void 0 ? { customIgnoreFiles } : {}
+      }),
+      primaryWorkspaceTrusted: trustedWorkspace,
       daemonLog,
       getChannelWorkerSnapshot,
       getPerfSnapshot: /* @__PURE__ */ __name(() => ({
         eventLoop: currentDaemonEventLoopMonitor.snapshot(),
+        promptQueueWait: {
+          count: promptQueueWaitStats.count,
+          meanMs: promptQueueWaitStats.count === 0 ? 0 : promptQueueWaitStats.totalMs / promptQueueWaitStats.count,
+          maxMs: promptQueueWaitStats.maxMs,
+          lastMs: promptQueueWaitStats.lastMs
+        },
         pipe: {
           inbound: { ...pipeStats.inbound },
           outbound: { ...pipeStats.outbound }
         }
       }), "getPerfSnapshot"),
+      getMetricsSeries: /* @__PURE__ */ __name(() => metricsRing.snapshot(), "getMetricsSeries"),
+      recordDaemonRequest: /* @__PURE__ */ __name((durationMs, statusCode) => metricsRing.recordRequest(durationMs, statusCode), "recordDaemonRequest"),
       workspace: workspaceService,
       // Reverse tool channel (#5626): the SAME registry wired into `bridge` above,
       // so the WS provider and the child-answering bridge share one sender map.
@@ -1835,7 +2579,7 @@ async function runQwenServe(optsIn, deps = {}) {
         performance.now() - runStartedAt
       );
       profileCheckpoint("serve_listener_ready");
-      finalizeStartupProfile(daemonLog.getDaemonId() || "serve");
+      finalizeStartupProfile(`serve-${process.pid}`);
       const cap = opts.maxConnections ?? 256;
       if (cap > 0 && Number.isFinite(cap)) {
         server.maxConnections = cap;
@@ -2140,6 +2884,7 @@ async function runQwenServe(optsIn, deps = {}) {
           if (closePromise) return closePromise;
           closePromise = new Promise((res, rej) => {
             shuttingDown = true;
+            app.locals.stopScheduledTaskKeepalive?.();
             clearRuntimeStartAfterHealthTimer();
             clearRuntimeStartFallbackTimer();
             cancelDeferredRuntimeStartup();
@@ -2322,6 +3067,11 @@ export {
   validatePolicyConfig,
   waitForRuntimeStartingForShutdown
 };
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
 /**
  * @license
  * Copyright 2025 Qwen Team