@qwen-code/qwen-code 0.21.7 → 0.21.8-nightly.20260810.55e20db328

package/chunks/{chunk-RGSBTHSU.js → chunk-KMS57JDD.js}

@@ -1,8 +1,9 @@
 // Force strict mode and setup for ESM
 "use strict";
 import {
-  isLoopbackBind
-} from "./chunk-RXFQM6FQ.js";
+  isLoopbackBind,
+  normalizeSessionIdForLookup
+} from "./chunk-TQOF5KBL.js";
 import {
   MAX_CHILD_HEAP_MB,
   MIN_CHILD_HEAP_MB,
@@ -10,7 +11,7 @@ import {
 } from "./chunk-HGCQ5SE7.js";
 import {
   CLIENT_MCP_OVER_WS_CONFIG_FLAG
-} from "./chunk-R574ATRM.js";
+} from "./chunk-M2PNLYGY.js";
 import {
   MAX_WORKSPACE_PATH_LENGTH,
   translateAndCheckAbsoluteWorkspacePath
@@ -1219,6 +1220,7 @@ var SERVE_CAPABILITY_REGISTRY = {
   daemon_status: { since: "v1" },
   capabilities: { since: "v1" },
   session_create: { since: "v1" },
+  session_id_override: { since: "v1" },
   session_scope_override: { since: "v1" },
   session_load: { since: "v1" },
   session_resume: { since: "v1" },
@@ -1355,6 +1357,7 @@ var SERVE_CAPABILITY_REGISTRY = {
   // (`tools.disabled` is consulted at `Config` construction time).
   workspace_tool_toggle: { since: "v1" },
   workspace_skill_toggle: { since: "v1" },
+  workspace_skill_batch_toggle: { since: "v1" },
   workspace_skill_manage: { since: "v1" },
   workspace_settings: { since: "v1" },
   // `GET /workspace/permissions` is always available when this tag is
@@ -1912,7 +1915,7 @@ function requireSessionId(req, res) {
     res.status(400).json({ error: "`sessionId` route parameter is required" });
     return null;
   }
-  return sessionId;
+  return normalizeSessionIdForLookup(sessionId);
 }
 __name(requireSessionId, "requireSessionId");
 function parseClientIdHeader(req, res) {
@@ -2304,13 +2307,75 @@ __name(resolveAcpHttpEnabled, "resolveAcpHttpEnabled");
 
 // packages/cli/src/serve/daemon-status.ts
 init_esbuild_shims();
+
+// packages/cli/src/serve/daemon-memory-pressure.ts
+init_esbuild_shims();
+import { getHeapStatistics } from "node:v8";
+var SOFT_PRESSURE_RATIO = 0.5;
+var HARD_PRESSURE_RATIO = 0.65;
+var CRITICAL_PRESSURE_RATIO = 0.8;
+function classify(ratio) {
+  if (ratio >= CRITICAL_PRESSURE_RATIO) return "critical";
+  if (ratio >= HARD_PRESSURE_RATIO) return "hard";
+  if (ratio >= SOFT_PRESSURE_RATIO) return "soft";
+  return "normal";
+}
+__name(classify, "classify");
+function computeDaemonMemoryPressure(input) {
+  const heapLimitBytes = usableDenominator(
+    input.heapLimitBytes ?? getHeapStatistics().heap_size_limit
+  );
+  const availableBytes = usableDenominator(input.availableBytes);
+  const rss = usableNumerator(input.rssBytes);
+  const heapUsed = usableNumerator(input.heapUsedBytes);
+  const rssBytes = rss ?? 0;
+  const heapUsedBytes = heapUsed ?? 0;
+  const rssMeasured = availableBytes > 0 && rss !== null;
+  const heapMeasured = heapLimitBytes > 0 && heapUsed !== null;
+  const rssRatio = rssMeasured ? rssBytes / availableBytes : 0;
+  const heapRatio = heapMeasured ? heapUsedBytes / heapLimitBytes : 0;
+  let source;
+  if (!rssMeasured && !heapMeasured) source = "unknown";
+  else if (!heapMeasured) source = "rss";
+  else if (!rssMeasured) source = "heap";
+  else source = rssRatio >= heapRatio ? "rss" : "heap";
+  const ratio = Math.max(rssRatio, heapRatio);
+  return {
+    level: classify(ratio),
+    ratio,
+    source,
+    rssBytes,
+    rssRatio,
+    availableBytes,
+    heapUsedBytes,
+    heapRatio,
+    heapLimitBytes
+  };
+}
+__name(computeDaemonMemoryPressure, "computeDaemonMemoryPressure");
+function usableDenominator(value) {
+  return Number.isFinite(value) && value > 0 ? value : 0;
+}
+__name(usableDenominator, "usableDenominator");
+function usableNumerator(value) {
+  return Number.isFinite(value) && value >= 0 ? value : null;
+}
+__name(usableNumerator, "usableNumerator");
+
+// packages/cli/src/serve/daemon-status.ts
 var DEFAULT_LISTENER_MAX_CONNECTIONS = 256;
 var SECTION_TIMEOUT_MS = 1e3;
 var CAPACITY_WARNING_RATIO = 0.8;
-function toDaemonStatusMemoryLimits(budget) {
+function toDaemonStatusMemoryLimits(budget, childHeap) {
   if (!budget) return null;
   return {
     enforced: false,
+    childHeap: childHeap ? {
+      mode: childHeap.mode,
+      maxConcurrentChildren: childHeap.maxConcurrentChildren,
+      perChildCeilingMb: childHeap.perChildCeilingMb,
+      refusals: childHeap.refusals
+    } : null,
     configuredBudgetMb: budget.configuredBudgetMb,
     effectiveBudgetMb: budget.effectiveBudgetMb,
     budgetSource: budget.budgetSource,
@@ -2379,13 +2444,52 @@ async function buildDaemonStatusResponse(detail, input) {
     const managedRuntimes = input.workspaceRegistry?.listManaged();
     const activeAcpChildCount = managedRuntimes ? managedRuntimes.filter((runtime) => runtime.bridge.isChannelLive()).length : workspaceSnapshots.filter((item) => item.snapshot.channelLive).length;
     const registeredWorkspaceCount = input.workspaceRegistry ? input.workspaceRegistry.listEntries().length : workspaceSnapshots.length;
+    let childRssBytesTotal = 0;
+    let childRssSampled = 0;
+    let oldestChildReadingAgeMs = null;
+    for (const runtime of managedRuntimes ?? []) {
+      if (!runtime.bridge.isChannelLive()) continue;
+      const snapshot = runtime.bridge.getChildResourceSnapshot?.();
+      if (!snapshot) continue;
+      childRssBytesTotal += snapshot.rssBytes;
+      childRssSampled += 1;
+      if (snapshot.ageMs !== void 0) {
+        oldestChildReadingAgeMs = Math.max(
+          oldestChildReadingAgeMs ?? 0,
+          snapshot.ageMs
+        );
+      }
+    }
+    const pressureMode = input.opts.memoryPressureMode ?? "observe";
+    const pressureMemory = process.memoryUsage();
     runtimeMemory = {
       registeredWorkspaces: registeredWorkspaceCount,
       activeAcpChildren: activeAcpChildCount,
-      childRssCoverage: "primary_only",
+      childRssCoverage: "active_children",
+      children: {
+        rssBytes: childRssBytesTotal,
+        sampled: childRssSampled,
+        oldestReadingAgeMs: oldestChildReadingAgeMs
+      },
       modeled: {
         recommendedShareAtRegisteredMb: registeredWorkspaceCount > 0 ? recommendedChildShareMb(memoryBudget, registeredWorkspaceCount) : null,
         recommendedShareAtActiveMb: activeAcpChildCount > 0 ? recommendedChildShareMb(memoryBudget, activeAcpChildCount) : null
+      },
+      pressure: {
+        ...computeDaemonMemoryPressure({
+          rssBytes: pressureMemory.rss,
+          heapUsedBytes: pressureMemory.heapUsed,
+          // `availableMemoryMb`, not `effectiveBudgetMb`: pressure asks how
+          // close this process is to being killed, and what kills it is the
+          // cgroup limit or host memory. An operator's budget is a policy
+          // number — exceeding it is not fatal, so classifying against it
+          // would report `critical` for a daemon in no danger.
+          // Note the unit change: the budget carries megabytes.
+          availableBytes: memoryBudget.availableMemoryMb * 1024 * 1024
+        }),
+        // After the spread, so the flag stays authoritative if the computed
+        // shape ever grows a field of this name.
+        mode: pressureMode
       }
     };
   }
@@ -2436,6 +2540,29 @@ async function buildDaemonStatusResponse(detail, input) {
     totalAdmissionSnapshot,
     workspaceSnapshots
   );
+  if (runtimeMemory && runtimeMemory.pressure.mode === "observe" && runtimeMemory.pressure.level !== "normal") {
+    const { level, ratio, source } = runtimeMemory.pressure;
+    issues.push({
+      code: "daemon_memory_pressure",
+      // `warning` at every level, including `critical`. An `error` severity
+      // makes `rollupStatus` return `error` for the whole daemon, which is a
+      // strong claim to stake on thresholds borrowed from an interactive-CLI
+      // monitor and not yet calibrated here. The level itself is reported in
+      // `runtime.memory.pressure`, so nothing is lost by keeping the rollup
+      // at `warning` until the numbers have been checked against real
+      // deployments — which is what this phase is for.
+      severity: "warning",
+      // Name the denominator, not the numerator: "% of the rss limit" would
+      // call the measured value a limit. `section` is omitted because every
+      // other use of it names a workspace status section, and this is a
+      // daemon-level concern — the same reason `daemon_log_degraded` omits it.
+      // One decimal, not zero: at 0 decimals a ratio of 0.795 rounds to "80%"
+      // while `level` still reads `hard`, and 80% is critical's documented
+      // threshold. An oncall engineer comparing the two sees a contradiction
+      // in the one feature whose whole purpose is trustworthy triage.
+      message: `Daemon memory pressure is ${level} at ${(ratio * 100).toFixed(1)}% of ${source === "heap" ? "the V8 heap limit" : "available memory"}.`
+    });
+  }
   if (daemonLogStatus?.health === "degraded") {
     issues.push({
       code: "daemon_log_degraded",
@@ -2499,7 +2626,10 @@ async function buildDaemonStatusResponse(detail, input) {
       channelIdleTimeoutMs: bridgeSnapshot.limits.channelIdleTimeoutMs,
       sessionIdleTimeoutMs: bridgeSnapshot.limits.sessionIdleTimeoutMs,
       acpConnectionCap: acpSnapshot?.connectionCap ?? null,
-      memory: toDaemonStatusMemoryLimits(memoryBudget)
+      memory: toDaemonStatusMemoryLimits(
+        memoryBudget,
+        input.getChildHeapPolicySnapshot?.()
+      )
     },
     ...workspaceRuntimes && workspaceRuntimes.length > 1 ? {
       workspaces: workspaceRuntimes.map((runtime) => ({

package/chunks/{chunk-VOARQPTA.js → chunk-KP25NJNM.js}

@@ -4,11 +4,15 @@ import {
   DEFAULT_EXCLUDED_ENV_VARS,
   HOME_ENV_BOOTSTRAP_KEYS,
   PROJECT_ENV_HARDCODED_EXCLUSIONS,
-  publishPendingCompileCache
-} from "./chunk-6PEXNQTX.js";
+  isHardcodedProjectEnvExclusion,
+  isLoaderEnvKey,
+  publishPendingCompileCache,
+  reportRejectedLoaderKeys,
+  resetLoaderKeyRejectionReportingForTesting
+} from "./chunk-R4ZA6GBK.js";
 import {
   isWorkspaceTrusted
-} from "./chunk-6XU3PH66.js";
+} from "./chunk-YR7ZQ4RD.js";
 import {
   require_main
 } from "./chunk-5M6IDOMF.js";
@@ -34,17 +38,18 @@ import * as os from "node:os";
 var SETTINGS_DIRECTORY_NAME = QWEN_DIR;
 var RELOAD_EXCLUDED_KEYS = /* @__PURE__ */ new Set([
   ...PROJECT_ENV_HARDCODED_EXCLUSIONS,
+  // The daemon auth token: the full loader never takes it from
+  // settings.env, and a mid-session .env edit must not rotate it. (The
+  // serve fast path consults only the hardcoded tier, so its documented
+  // workspace-settings.env token feature is unaffected.)
   "QWEN_SERVER_TOKEN",
-  "QWEN_CLI_ENTRY",
-  "NODE_OPTIONS",
-  "NODE_PATH",
-  "NODE_TLS_REJECT_UNAUTHORIZED",
-  "LD_PRELOAD",
-  "LD_AUDIT",
+  // Loader-class keys are rejected by the isLoaderEnvKey guard before this
+  // Set is consulted, so they are not spread here. These three keep their
+  // pre-denylist reload-only exclusion: too compatibility-heavy for the
+  // inherited-env scrub (mainstream toolchain/app conventions), but a
+  // mid-session .env edit must still not apply them.
   "LD_LIBRARY_PATH",
-  "DYLD_INSERT_LIBRARIES",
   "DYLD_LIBRARY_PATH",
-  "BASH_ENV",
   "ENV",
   "PATH",
   "HOME",
@@ -52,6 +57,13 @@ var RELOAD_EXCLUDED_KEYS = /* @__PURE__ */ new Set([
   "TMP",
   "TEMP"
 ]);
+var RELOAD_EXCLUDED_KEYS_CASEFOLDED = new Set(
+  [...RELOAD_EXCLUDED_KEYS].map((key) => key.toLowerCase())
+);
+function isReloadExcludedKey(key) {
+  return RELOAD_EXCLUDED_KEYS_CASEFOLDED.has(key.toLowerCase());
+}
+__name(isReloadExcludedKey, "isReloadExcludedKey");
 var dotEnvSourcedKeys = /* @__PURE__ */ new Set();
 var settingsEnvSourcedKeys = /* @__PURE__ */ new Set();
 var lastReloadSnapshot = /* @__PURE__ */ new Map();
@@ -101,7 +113,7 @@ function readHomeEnvInto(file) {
   }
   try {
     const parsed = dotenv.parse(fs.readFileSync(file, "utf-8"));
-    for (const key of PROJECT_ENV_HARDCODED_EXCLUSIONS) {
+    for (const key of HOME_ENV_BOOTSTRAP_KEYS) {
       if (parsed[key] && !Object.hasOwn(process.env, key)) {
         process.env[key] = parsed[key];
       }
@@ -115,6 +127,7 @@ function resetHomeEnvBootstrapForTesting() {
 }
 __name(resetHomeEnvBootstrapForTesting, "resetHomeEnvBootstrapForTesting");
 function resetEnvironmentTrackingForTesting() {
+  resetLoaderKeyRejectionReportingForTesting();
   dotEnvSourcedKeys.clear();
   settingsEnvSourcedKeys.clear();
   lastReloadSnapshot.clear();
@@ -246,6 +259,7 @@ function parseEnvFiles(envFilePaths, userLevelPaths) {
       const isHomeScopedEnvFile = userLevelPaths.has(normalizedEnvFilePath);
       const isQwenScopedEnvFile = isHomeScopedEnvFile || path.basename(path.dirname(normalizedEnvFilePath)) === QWEN_DIR;
       files.push({
+        path: envFilePath,
         parsedEnv,
         isHomeScopedEnvFile,
         isQwenScopedEnvFile
@@ -262,8 +276,9 @@ function parseEnvFiles(envFilePaths, userLevelPaths) {
 __name(parseEnvFiles, "parseEnvFiles");
 function canApplyParsedEnvKey(envFile, key, excludedVars, options = {}) {
   if (!Object.hasOwn(envFile.parsedEnv, key)) return false;
-  if (options.reload && RELOAD_EXCLUDED_KEYS.has(key)) return false;
-  if (!envFile.isHomeScopedEnvFile && PROJECT_ENV_HARDCODED_EXCLUSIONS.includes(key)) {
+  if (isLoaderEnvKey(key)) return false;
+  if (options.reload && isReloadExcludedKey(key)) return false;
+  if (!envFile.isHomeScopedEnvFile && isHardcodedProjectEnvExclusion(key)) {
     return false;
   }
   return envFile.isQwenScopedEnvFile || !excludedVars.includes(key);
@@ -301,16 +316,25 @@ function buildRuntimeEnvironment(settings, startDir = process.cwd(), baseEnv = p
       }
       setRuntimeEnvIfUnset(effectiveEnv, key, envFile.parsedEnv[key]);
     }
+    reportRejectedLoaderKeys(
+      `.env file ${envFile.path}`,
+      Object.keys(envFile.parsedEnv)
+    );
   }
   if (settings.env) {
     const excludedVars = settings?.advanced?.excludedEnvVars || DEFAULT_EXCLUDED_ENV_VARS;
     for (const [key, value] of Object.entries(settings.env)) {
-      if (RELOAD_EXCLUDED_KEYS.has(key)) continue;
-      if (PROJECT_ENV_HARDCODED_EXCLUSIONS.includes(key)) continue;
+      if (isLoaderEnvKey(key)) continue;
+      if (isReloadExcludedKey(key)) continue;
+      if (isHardcodedProjectEnvExclusion(key)) continue;
       if (excludedVars.includes(key)) continue;
       if (typeof value !== "string") continue;
       setRuntimeEnvIfUnset(effectiveEnv, key, value);
     }
+    reportRejectedLoaderKeys(
+      `settings.env (${startDir})`,
+      Object.keys(settings.env)
+    );
   }
   const overlayKeys = Object.keys(effectiveEnv).filter((key) => effectiveEnv[key] !== baseEnv[key]).sort();
   return {
@@ -343,13 +367,20 @@ function loadEnvironment(settings, startDir = process.cwd()) {
         lastReloadSnapshot.set(key, envFile.parsedEnv[key]);
       }
     }
+    reportRejectedLoaderKeys(
+      `.env file ${envFile.path}`,
+      Object.keys(envFile.parsedEnv)
+    );
   }
   if (settings.env) {
     for (const [key, value] of Object.entries(settings.env)) {
-      if (RELOAD_EXCLUDED_KEYS.has(key)) {
+      if (isLoaderEnvKey(key)) {
+        continue;
+      }
+      if (isReloadExcludedKey(key)) {
         continue;
       }
-      if (PROJECT_ENV_HARDCODED_EXCLUSIONS.includes(key)) {
+      if (isHardcodedProjectEnvExclusion(key)) {
         continue;
       }
       const existingValue = process.env[key];
@@ -362,6 +393,10 @@ function loadEnvironment(settings, startDir = process.cwd()) {
         lastReloadSnapshot.set(key, value);
       }
     }
+    reportRejectedLoaderKeys(
+      `settings.env (${startDir})`,
+      Object.keys(settings.env)
+    );
   }
   lastReloadSnapshotSeeded = true;
   publishPendingCompileCache();
@@ -392,17 +427,26 @@ function reloadEnvironment(settings, workspaceCwd, workspaceTrusted) {
         newDotEnvKeys.set(key, envFile.parsedEnv[key]);
       }
     }
+    reportRejectedLoaderKeys(
+      `.env file ${envFile.path}`,
+      Object.keys(envFile.parsedEnv)
+    );
   }
   if (settings.env) {
     for (const [key, value] of Object.entries(settings.env)) {
-      if (RELOAD_EXCLUDED_KEYS.has(key)) continue;
-      if (PROJECT_ENV_HARDCODED_EXCLUSIONS.includes(key)) continue;
+      if (isLoaderEnvKey(key)) continue;
+      if (isReloadExcludedKey(key)) continue;
+      if (isHardcodedProjectEnvExclusion(key)) continue;
       if (typeof value !== "string") continue;
       const dotEnvValue = newDotEnvKeys.get(key);
       if (dotEnvValue !== void 0 && dotEnvValue !== "") continue;
       if (dotEnvReadFailed && lastReloadSnapshot.has(key)) continue;
       newSettingsEnvKeys.set(key, value);
     }
+    reportRejectedLoaderKeys(
+      `settings.env (${workspaceCwd})`,
+      Object.keys(settings.env)
+    );
   }
   const allNewKeys = /* @__PURE__ */ new Set([
     ...newDotEnvKeys.keys(),
@@ -417,7 +461,7 @@ function reloadEnvironment(settings, workspaceCwd, workspaceTrusted) {
       ...settingsEnvSourcedKeys
     ]);
     for (const key of previouslyKnown) {
-      if (!allNewKeys.has(key) && !RELOAD_EXCLUDED_KEYS.has(key)) {
+      if (!allNewKeys.has(key) && !isReloadExcludedKey(key)) {
         delete process.env[key];
         removedKeys.push(key);
       }

package/chunks/{chunk-6M26GBKX.js → chunk-L2AFWWJE.js}

@@ -12,7 +12,7 @@ import {
   SPAN_TOOL_EXECUTION,
   TOOL_FAILURE_KIND_ATTRIBUTE,
   TOOL_FAILURE_KIND_CANCELLED
-} from "./chunk-LKRMNRSN.js";
+} from "./chunk-PDPFQ2FO.js";
 import {
   createDebugLogger,
   getCurrentSessionId,
@@ -44,6 +44,7 @@ init_esbuild_shims();
 init_esm();
 var TOOL_CALL_COUNT = `${SERVICE_NAME}.tool.call.count`;
 var TOOL_EXECUTION_COUNT = `${SERVICE_NAME}.tool.execution.count`;
+var REPEATED_TOOL_FAILURE_GUARD_COUNT = `${SERVICE_NAME}.repeated_tool_failure_guard.count`;
 var TOOL_CALL_LATENCY = `${SERVICE_NAME}.tool.call.latency`;
 var API_REQUEST_COUNT = `${SERVICE_NAME}.api.request.count`;
 var API_REQUEST_LATENCY = `${SERVICE_NAME}.api.request.latency`;
@@ -112,6 +113,12 @@ var COUNTER_DEFINITIONS = {
     assign: /* @__PURE__ */ __name((c) => toolExecutionCounter = c, "assign"),
     attributes: {}
   },
+  [REPEATED_TOOL_FAILURE_GUARD_COUNT]: {
+    description: "Counts privacy-safe repeated tool execution failure guard transitions.",
+    valueType: ValueType.INT,
+    assign: /* @__PURE__ */ __name((c) => repeatedToolFailureGuardCounter = c, "assign"),
+    attributes: {}
+  },
   [API_REQUEST_COUNT]: {
     description: "Counts API requests, tagged by model and status.",
     valueType: ValueType.INT,
@@ -272,6 +279,7 @@ var PERFORMANCE_HISTOGRAM_DEFINITIONS = {
 var cliMeter;
 var toolCallCounter;
 var toolExecutionCounter;
+var repeatedToolFailureGuardCounter;
 var toolCallLatencyHistogram;
 var apiRequestCounter;
 var apiRequestLatencyHistogram;
@@ -478,6 +486,11 @@ function recordToolExecutionMetrics(config, attributes) {
   });
 }
 __name(recordToolExecutionMetrics, "recordToolExecutionMetrics");
+function recordRepeatedToolFailureGuardMetrics(attributes) {
+  if (!repeatedToolFailureGuardCounter || !isMetricsInitialized) return;
+  repeatedToolFailureGuardCounter.add(1, attributes);
+}
+__name(recordRepeatedToolFailureGuardMetrics, "recordRepeatedToolFailureGuardMetrics");
 function recordTokenUsageMetrics(config, tokenCount, attributes) {
   if (!tokenUsageCounter || !isMetricsInitialized) return;
   tokenUsageCounter.add(tokenCount, {
@@ -852,6 +865,31 @@ var telemetryInitialized = false;
 var telemetryInitPromise;
 var telemetryShutdownPromise;
 var activeMetricReader;
+var OTEL_EXPORTER_ENV_VARS = [
+  "OTEL_TRACES_EXPORTER",
+  "OTEL_LOGS_EXPORTER",
+  "OTEL_METRICS_EXPORTER"
+];
+function startSdkWithExplicitExporters(currentSdk) {
+  const previousValues = /* @__PURE__ */ new Map();
+  for (const name of OTEL_EXPORTER_ENV_VARS) {
+    previousValues.set(name, process.env[name]);
+    delete process.env[name];
+  }
+  try {
+    currentSdk.start();
+  } finally {
+    for (const name of OTEL_EXPORTER_ENV_VARS) {
+      const previousValue = previousValues.get(name);
+      if (previousValue === void 0) {
+        delete process.env[name];
+      } else {
+        process.env[name] = previousValue;
+      }
+    }
+  }
+}
+__name(startSdkWithExplicitExporters, "startSdkWithExplicitExporters");
 function isTelemetrySdkInitialized() {
   return telemetryInitialized;
 }
@@ -863,12 +901,12 @@ function initializeTelemetry(config) {
   telemetryInitPromise ??= (async () => {
     const debugLogger3 = createDebugLogger("OTEL");
     try {
-      const { startTelemetrySdk } = await import("./sdk-impl-KD7FSTC3.js");
+      const { startTelemetrySdk } = await import("./sdk-impl-7W7AKCS4.js");
       if (telemetryInitialized) return;
       const started = await startTelemetrySdk(config);
       if (!started) return;
       sdk = started.sdk;
-      sdk.start();
+      startSdkWithExplicitExporters(sdk);
       debugLogger3.debug("OpenTelemetry SDK started successfully.");
       telemetryInitialized = true;
       activeMetricReader = started.metricReader;
@@ -1989,6 +2027,7 @@ export {
   recordChatCompressionMetrics,
   recordToolCallMetrics,
   recordToolExecutionMetrics,
+  recordRepeatedToolFailureGuardMetrics,
   recordTokenUsageMetrics,
   recordApiResponseMetrics,
   recordApiErrorMetrics,

package/chunks/{chunk-ZXU5UHMI.js → chunk-LHEC5V6G.js}

@@ -2,11 +2,11 @@
 "use strict";
 import {
   resolveChannelCwd
-} from "./chunk-VWOVHOTT.js";
+} from "./chunk-67EWJE77.js";
 import {
   getPlugin,
   supportedTypes
-} from "./chunk-IUFV6FYU.js";
+} from "./chunk-E2FPSSKP.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-J26HHFI5.js → chunk-LP2QGNSP.js}

@@ -90,6 +90,7 @@ var SessionArchivingError = class extends Error {
     this.lockKind = lockKind;
   }
 };
+var RESTORE_IN_PROGRESS_RETRY_AFTER_SECONDS = 5;
 var RestoreInProgressError = class extends Error {
   static {
     __name(this, "RestoreInProgressError");
@@ -97,14 +98,21 @@ var RestoreInProgressError = class extends Error {
   sessionId;
   activeAction;
   requestedAction;
-  constructor(sessionId, activeAction, requestedAction) {
+  reason;
+  retryAfterSeconds;
+  constructor(sessionId, activeAction, requestedAction, opts) {
+    const reason = opts?.reason ?? "restore_in_progress";
+    const retryTarget = requestedAction === "spawn" ? "the spawn" : `session/${requestedAction}`;
+    const activeTarget = activeAction === "spawn" ? "a caller-supplied-id spawn" : `session/${activeAction}`;
     super(
-      `Session "${sessionId}" is already being restored via session/${activeAction}; retry session/${requestedAction} after it completes`
+      reason === "awaiting_abandoned_cleanup" ? `Session "${sessionId}" timed out during ${activeTarget} and its abandoned restore has not settled yet; retry ${retryTarget} once cleanup completes` : activeAction === "spawn" ? `Session "${sessionId}" is already being registered by ${activeTarget}; retry ${retryTarget} after it completes` : `Session "${sessionId}" is already being restored via ${activeTarget}; retry ${retryTarget} after it completes`
     );
     this.name = "RestoreInProgressError";
     this.sessionId = sessionId;
     this.activeAction = activeAction;
     this.requestedAction = requestedAction;
+    this.reason = reason;
+    this.retryAfterSeconds = opts?.retryAfterSeconds ?? RESTORE_IN_PROGRESS_RETRY_AFTER_SECONDS;
   }
 };
 var InvalidSessionScopeError = class extends Error {
@@ -394,6 +402,27 @@ var WorkspaceDrainingError = class extends Error {
     this.workspaceCwd = workspaceCwd;
   }
 };
+var BridgeChannelQuarantinedError = class extends Error {
+  static {
+    __name(this, "BridgeChannelQuarantinedError");
+  }
+  reason;
+  /**
+   * How long the caller should wait before retrying fresh session work. This
+   * state persists until the workspace channel drains, which is at least a
+   * restore budget away — the ordinary 5-second cadence would poll identical
+   * 503s, and a fresh id never reaches the 409 that carries the real hint.
+   */
+  retryAfterSeconds;
+  constructor(reason = "restore_cleanup_failed", retryAfterSeconds = RESTORE_IN_PROGRESS_RETRY_AFTER_SECONDS) {
+    super(
+      reason === "restore_settlement_overdue" ? "The ACP channel is unavailable for new sessions while an abandoned session restore has not settled" : "The ACP channel is unavailable for new sessions while timed-out restore cleanup is pending"
+    );
+    this.name = "BridgeChannelQuarantinedError";
+    this.reason = reason;
+    this.retryAfterSeconds = retryAfterSeconds;
+  }
+};
 var InvalidRewindTargetError = class extends Error {
   static {
     __name(this, "InvalidRewindTargetError");
@@ -463,6 +492,7 @@ export {
   McpServerRestartFailedError,
   SessionBusyError,
   WorkspaceDrainingError,
+  BridgeChannelQuarantinedError,
   InvalidRewindTargetError,
   BranchWhilePromptActiveError,
   CdWhilePromptActiveError

package/chunks/{chunk-R574ATRM.js → chunk-M2PNLYGY.js}

@@ -18,7 +18,36 @@ var LOAD_REPLAY_VERSION = 1;
 var REQUESTED_SESSION_ID_META_KEY = "qwen-code/sessionId";
 var CHANNEL_STARTUP_PROFILE_META_KEY = "qwen.daemon.channelStartupProfile";
 var CHANNEL_STARTUP_PROFILE_VERSION = 1;
+var ACTIVE_WORK_HEARTBEAT_META_KEY = "qwen.daemon.activeWorkHeartbeat";
+var ACTIVE_WORK_HEARTBEAT_VERSION = 1;
+var ACTIVE_WORK_HEARTBEAT_INTERVAL_MS = 15e3;
+var ACTIVE_WORK_HEARTBEAT_MIN_INTERVAL_MS = 5e3;
+var ACTIVE_WORK_HEARTBEAT_MAX_INTERVAL_MS = 6e4;
+var ACTIVE_WORK_STALE_INTERVALS = 3;
+var ACTIVE_WORK_NOTIFICATION_METHOD = "qwen/notify/channel/active-work";
+var ACTIVE_WORK_CLOSE_IF_UNHELD_PARAM = "onlyIfUnheld";
+var ACTIVE_WORK_CLOSE_TIMEOUT_MS = 1e4;
+var ACTIVE_WORK_MAX_SNAPSHOT_SESSIONS = 1024;
+var ACTIVE_WORK_MAX_SESSION_HOLDS = 1024;
 var WORKTREE_MCP_DEFER_META_KEY = "qwen.session.deferMcpDiscovery";
+var ACTIVE_WORK_HOLD_CATEGORIES = [
+  "agent",
+  "notification"
+];
+function clampActiveWorkIntervalMs(raw) {
+  const value = typeof raw === "number" && Number.isFinite(raw) ? raw : NaN;
+  if (Number.isNaN(value)) return ACTIVE_WORK_HEARTBEAT_INTERVAL_MS;
+  return Math.min(
+    ACTIVE_WORK_HEARTBEAT_MAX_INTERVAL_MS,
+    Math.max(ACTIVE_WORK_HEARTBEAT_MIN_INTERVAL_MS, Math.round(value))
+  );
+}
+__name(clampActiveWorkIntervalMs, "clampActiveWorkIntervalMs");
+function gradeActiveWorkCoverage(totals) {
+  if (totals.total === 0 || totals.covered === totals.total) return "full";
+  return totals.onNegotiatedChannel === 0 ? "none" : "partial";
+}
+__name(gradeActiveWorkCoverage, "gradeActiveWorkCoverage");
 var DAEMON_MODEL_PROMPT_META_KEY = "qwen.daemon.modelPrompt";
 var MAX_TRUSTED_MODEL_PROMPT_CHARS = 64 * 1024;
 function isValidTrustedModelPrompt(value) {
@@ -42,7 +71,19 @@ export {
   REQUESTED_SESSION_ID_META_KEY,
   CHANNEL_STARTUP_PROFILE_META_KEY,
   CHANNEL_STARTUP_PROFILE_VERSION,
+  ACTIVE_WORK_HEARTBEAT_META_KEY,
+  ACTIVE_WORK_HEARTBEAT_VERSION,
+  ACTIVE_WORK_HEARTBEAT_INTERVAL_MS,
+  ACTIVE_WORK_STALE_INTERVALS,
+  ACTIVE_WORK_NOTIFICATION_METHOD,
+  ACTIVE_WORK_CLOSE_IF_UNHELD_PARAM,
+  ACTIVE_WORK_CLOSE_TIMEOUT_MS,
+  ACTIVE_WORK_MAX_SNAPSHOT_SESSIONS,
+  ACTIVE_WORK_MAX_SESSION_HOLDS,
   WORKTREE_MCP_DEFER_META_KEY,
+  ACTIVE_WORK_HOLD_CATEGORIES,
+  clampActiveWorkIntervalMs,
+  gradeActiveWorkCoverage,
   DAEMON_MODEL_PROMPT_META_KEY,
   isValidTrustedModelPrompt,
   DAEMON_CHANNEL_DELIVERY_META_KEY,

package/chunks/{chunk-MKVZE4ZJ.js → chunk-MFDYOYZZ.js}

@@ -35,7 +35,7 @@ import {
   createWorkerDiagnosticRedactor,
   normalizeWorkerDiagnostic,
   sanitizeWorkerDiagnostic
-} from "./chunk-24ER7UV4.js";
+} from "./chunk-PBRVUF5B.js";
 import {
   channelSelectionNames
 } from "./chunk-ALMR3E6Q.js";
@@ -49,7 +49,7 @@ import {
 } from "./chunk-5HBA2Z7V.js";
 import {
   sanitizeLogText
-} from "./chunk-DIEFUBV6.js";
+} from "./chunk-DX3RGJMS.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -180,6 +180,7 @@ __name(hasObservedExit, "hasObservedExit");
 function createWorkerEnv(opts) {
   const env = { ...opts.baseEnv ?? process.env };
   env["QWEN_CODE_NO_RELAUNCH"] = "true";
+  env["QWEN_CODE_SERVE"] = "1";
   env[CHANNEL_DAEMON_WORKER_SENTINEL] = randomUUID();
   env[QWEN_DAEMON_URL_ENV] = opts.daemonUrl;
   env[QWEN_DAEMON_WORKSPACE_ENV] = opts.workspace;