@qwen-code/qwen-code 0.21.1 → 0.21.2-nightly.20260801.bc382c3ff

package/chunks/{run-qwen-serve-TSTCO4XE.js → run-qwen-serve-TI2HGLLU.js}

@@ -1,9 +1,8 @@
 // Force strict mode and setup for ESM
 "use strict";
 import {
-  DaemonMetricsRing,
   computeCpuPercent
-} from "./chunk-HGT6JR3U.js";
+} from "./chunk-LBOVL47Y.js";
 import {
   RUNTIME_STARTUP_CANCELLED_MESSAGE
 } from "./chunk-QUPXZXLV.js";
@@ -35,7 +34,7 @@ import {
   require_express,
   resolveWebShellDir,
   setDeferredRuntimeRequestTiming
-} from "./chunk-YGF33UXG.js";
+} from "./chunk-H6MC6VQX.js";
 import {
   isLoopbackBind
 } from "./chunk-RXFQM6FQ.js";
@@ -47,72 +46,70 @@ import {
   normalizeMaxJournalBytes,
   normalizeMaxJournalEvents
 } from "./chunk-XCGIMOLN.js";
-import "./chunk-WBL3FJEU.js";
+import "./chunk-FC4KQFCS.js";
 import {
   resolveChannelCwd
-} from "./chunk-TFRMVU6R.js";
+} from "./chunk-K4CGQN4Q.js";
+import {
+  loadServeFastPathSettings,
+  preResolveServeFastPathHomeEnvOverrides
+} from "./chunk-D3UEZIQH.js";
 import {
   MAX_REGISTERED_WORKSPACES,
   resolveWorkspaceInputs,
   workspaceRegistrationId
-} from "./chunk-AQIDMUGU.js";
-import "./chunk-T2QMKU3R.js";
+} from "./chunk-2PNQQ4UR.js";
+import "./chunk-DVGTU5TC.js";
 import {
   LOAD_REPLAY_META_KEY
-} from "./chunk-XZC5VLBZ.js";
-import "./chunk-B4AJNNOL.js";
+} from "./chunk-UKZEXS6K.js";
+import "./chunk-J26HHFI5.js";
 import {
   canonicalizeWorkspace,
   translateAndCheckAbsoluteWorkspacePath
-} from "./chunk-2RFKHEXL.js";
-import "./chunk-GNR2RNMP.js";
+} from "./chunk-6PLDPT2C.js";
+import "./chunk-5UZITEHA.js";
 import "./chunk-FYJ7W2PI.js";
 import {
   ChannelDeliveryError,
   ChannelWebhookEnqueueError,
   QWEN_SERVER_TOKEN_ENV,
   isChannelDeliveryError
-} from "./chunk-U4VTUMMK.js";
+} from "./chunk-QONSRAEV.js";
 import {
   normalizeWorkerDiagnostic,
   sanitizeWorkerDiagnostic
-} from "./chunk-GZ3RCT54.js";
+} from "./chunk-UHTJC7O3.js";
 import {
   channelSelectionNames
 } from "./chunk-ALMR3E6Q.js";
 import "./chunk-BK2UNYWD.js";
 import "./chunk-M5GB774H.js";
 import "./chunk-5HBA2Z7V.js";
-import "./chunk-T2NCM2ET.js";
+import "./chunk-K6KS3LTN.js";
+import "./chunk-T3CHYWJZ.js";
 import {
   sanitizeLogText
-} from "./chunk-7I5GTCT4.js";
+} from "./chunk-GB3AB7TR.js";
 import "./chunk-UDXSXLER.js";
-import {
-  loadServeFastPathSettings,
-  preResolveServeFastPathHomeEnvOverrides
-} from "./chunk-D3UEZIQH.js";
 import "./chunk-GOXKNSDZ.js";
 import {
   getGlobalQwenDirLite,
   resolveConfigPathLite
 } from "./chunk-IDS7MSUP.js";
 import "./chunk-6PEXNQTX.js";
-import {
-  getCliVersion
-} from "./chunk-VYOXCEPJ.js";
-import "./chunk-VJNBRRZG.js";
 import "./chunk-ALGGS7UH.js";
 import {
   isWithinRoot
 } from "./chunk-MR3PXB6E.js";
 import {
-  writeStderrLine,
-  writeStdoutLine
-} from "./chunk-OWAK7LMW.js";
+  getCliVersion
+} from "./chunk-MBKPUM5Y.js";
+import "./chunk-VJNBRRZG.js";
+import "./chunk-GOFAQQZA.js";
+import "./chunk-5M6IDOMF.js";
 import "./chunk-TWPJO254.js";
 import "./chunk-H6XPXXMH.js";
-import "./chunk-5M6IDOMF.js";
 import {
   require_proper_lockfile
 } from "./chunk-KRXPRVGL.js";
@@ -123,6 +120,10 @@ import {
   profileCheckpoint
 } from "./chunk-QSWDGAIC.js";
 import "./chunk-Q7YDKOGY.js";
+import {
+  writeStderrLine,
+  writeStdoutLine
+} from "./chunk-OWAK7LMW.js";
 import "./chunk-DMTGGOSA.js";
 import "./chunk-YQ3U5MUC.js";
 import {
@@ -143,6 +144,10 @@ import * as path from "node:path";
 import * as os from "node:os";
 import { monitorEventLoopDelay, performance as performance2 } from "node:perf_hooks";
 
+// packages/core/dist/src/memory/scopes.js
+init_esbuild_shims();
+var MEMORY_PROJECT_SCOPES = ["git-root", "workspace"];
+
 // packages/cli/src/serve/permission-audit.ts
 init_esbuild_shims();
 var DEFAULT_PERMISSION_AUDIT_RING_SIZE = 512;
@@ -1268,7 +1273,7 @@ function createConcreteLogger(input) {
         }
       });
       let timeout;
-      const deadline = new Promise((resolve) => {
+      const deadline = new Promise((resolve2) => {
         timeout = setTimeout(() => {
           try {
             input.warnOnce(
@@ -1277,7 +1282,7 @@ function createConcreteLogger(input) {
             );
           } catch {
           } finally {
-            resolve();
+            resolve2();
           }
         }, input.policy.closeDrainBudgetMs);
         timeout.unref();
@@ -1621,6 +1626,156 @@ ${capUtf8Record(
 }
 __name(initDaemonLogger, "initDaemonLogger");
 
+// packages/cli/src/serve/daemon-metrics-ring.ts
+init_esbuild_shims();
+var MAX_SAMPLES_PER_WINDOW = 4096;
+var DaemonMetricsRing = class {
+  static {
+    __name(this, "DaemonMetricsRing");
+  }
+  capacity;
+  buckets = [];
+  curRequests = 0;
+  curErrors = 0;
+  curDurations = [];
+  curPromptsCompleted = 0;
+  curQueueWaits = [];
+  curPromptDurations = [];
+  curLlmDurations = [];
+  curLlmApiErrors = 0;
+  curLlmApiRetries = 0;
+  curPipeInBytes = 0;
+  curPipeOutBytes = 0;
+  curTokensIn = 0;
+  curTokensOut = 0;
+  constructor(options) {
+    this.capacity = Math.max(1, Math.floor(options.capacity));
+  }
+  /** Fold one completed HTTP request into the open window. */
+  recordRequest(durationMs, statusCode) {
+    this.curRequests += 1;
+    if (statusCode >= 400) this.curErrors += 1;
+    pushCapped(this.curDurations, durationMs);
+  }
+  /** Fold one prompt's queue wait (dispatched from the per-session FIFO). */
+  recordPromptQueueWait(durationMs) {
+    pushCapped(this.curQueueWaits, durationMs);
+  }
+  /** Fold one finished prompt's end-to-end duration (also counts throughput). */
+  recordPromptDuration(durationMs) {
+    this.curPromptsCompleted += 1;
+    pushCapped(this.curPromptDurations, durationMs);
+  }
+  /** Fold one model round's LLM API round-trip time (from the token frame). */
+  recordLlmDuration(durationMs) {
+    pushCapped(this.curLlmDurations, durationMs);
+  }
+  /**
+   * Fold one model round's per-round model-API-error and automatic-retry
+   * increments (from the same token frame) into the open window. Both are
+   * plain counters — a burst in one window accrues exactly, past the sample
+   * cap that only bounds the percentile arrays. Non-finite / negative inputs
+   * are ignored so a malformed frame cannot poison the totals.
+   */
+  recordApiActivity(errors, retries) {
+    if (Number.isFinite(errors) && errors > 0) this.curLlmApiErrors += errors;
+    if (Number.isFinite(retries) && retries > 0) {
+      this.curLlmApiRetries += retries;
+    }
+  }
+  /** Fold one ACP-child pipe message's payload size into the open window. */
+  recordPipe(direction, bytes) {
+    if (!Number.isFinite(bytes) || bytes < 0) return;
+    if (direction === "inbound") this.curPipeInBytes += bytes;
+    else this.curPipeOutBytes += bytes;
+  }
+  /** Fold one model turn's token usage into the open window. */
+  recordTokens(inputTokens, outputTokens) {
+    if (Number.isFinite(inputTokens) && inputTokens > 0) {
+      this.curTokensIn += inputTokens;
+    }
+    if (Number.isFinite(outputTokens) && outputTokens > 0) {
+      this.curTokensOut += outputTokens;
+    }
+  }
+  /**
+   * Seal the open window into a bucket stamped at `now` (folding in the
+   * gauges), append it, evict the oldest past capacity, then reset the
+   * accumulators for the next window.
+   */
+  sample(now, gauges) {
+    this.buckets.push({
+      t: now,
+      activeSessions: finiteGauge(gauges.activeSessions),
+      activePrompts: finiteGauge(gauges.activePrompts),
+      queuedPrompts: finiteGauge(gauges.queuedPrompts),
+      requests: this.curRequests,
+      errors: this.curErrors,
+      latencyP50Ms: percentile(this.curDurations, 0.5),
+      latencyP95Ms: percentile(this.curDurations, 0.95),
+      promptsCompleted: this.curPromptsCompleted,
+      promptQueueWaitP95Ms: percentile(this.curQueueWaits, 0.95),
+      promptDurationP95Ms: percentile(this.curPromptDurations, 0.95),
+      llmApiP50Ms: percentile(this.curLlmDurations, 0.5),
+      llmApiP95Ms: percentile(this.curLlmDurations, 0.95),
+      llmApiErrors: this.curLlmApiErrors,
+      llmApiRetries: this.curLlmApiRetries,
+      cpuPercent: finiteGauge(gauges.cpuPercent),
+      rssBytes: finiteGauge(gauges.rssBytes),
+      heapUsedBytes: finiteGauge(gauges.heapUsedBytes),
+      eventLoopLagP99Ms: finiteGauge(gauges.eventLoopLagP99Ms),
+      pipeInBytes: this.curPipeInBytes,
+      pipeOutBytes: this.curPipeOutBytes,
+      sseConnections: finiteGauge(gauges.sseConnections),
+      wsConnections: finiteGauge(gauges.wsConnections),
+      acpConnections: finiteGauge(gauges.acpConnections),
+      rateLimitRejected: finiteGauge(gauges.rateLimitRejected),
+      tokensIn: this.curTokensIn,
+      tokensOut: this.curTokensOut,
+      childCpuPercent: finiteGauge(gauges.childCpuPercent),
+      childRssBytes: finiteGauge(gauges.childRssBytes)
+    });
+    if (this.buckets.length > this.capacity) {
+      this.buckets.splice(0, this.buckets.length - this.capacity);
+    }
+    this.curRequests = 0;
+    this.curErrors = 0;
+    this.curDurations.length = 0;
+    this.curPromptsCompleted = 0;
+    this.curQueueWaits.length = 0;
+    this.curPromptDurations.length = 0;
+    this.curLlmDurations.length = 0;
+    this.curLlmApiErrors = 0;
+    this.curLlmApiRetries = 0;
+    this.curPipeInBytes = 0;
+    this.curPipeOutBytes = 0;
+    this.curTokensIn = 0;
+    this.curTokensOut = 0;
+  }
+  /** Oldest→newest copy of the retained buckets (safe to serialize). */
+  snapshot() {
+    return this.buckets.slice();
+  }
+};
+function finiteGauge(value) {
+  return Number.isFinite(value) ? value : 0;
+}
+__name(finiteGauge, "finiteGauge");
+function pushCapped(target, value) {
+  if (Number.isFinite(value) && value >= 0 && target.length < MAX_SAMPLES_PER_WINDOW) {
+    target.push(value);
+  }
+}
+__name(pushCapped, "pushCapped");
+function percentile(samples, q) {
+  if (samples.length === 0) return 0;
+  const sorted = samples.slice().sort((a, b) => a - b);
+  const rank = Math.ceil(q * sorted.length);
+  const idx = Math.min(sorted.length - 1, Math.max(0, rank - 1));
+  return sorted[idx];
+}
+__name(percentile, "percentile");
+
 // packages/cli/src/serve/large-pipe-frame-observer.ts
 init_esbuild_shims();
 var LARGE_PIPE_FRAME_THRESHOLD_BYTES = 256 * 1024;
@@ -2325,8 +2480,8 @@ async function flushDaemonLogBounded(daemonLog, budgetMs) {
     await Promise.race([
       daemonLog.flush().catch(() => {
       }),
-      new Promise((resolve) => {
-        timer = setTimeout(resolve, budgetMs);
+      new Promise((resolve2) => {
+        timer = setTimeout(resolve2, budgetMs);
         timer.unref();
       })
     ]);
@@ -2370,7 +2525,7 @@ var FAST_PATH_RUNTIME_START_AFTER_HEALTH_MS = 50;
 var FAST_PATH_RUNTIME_START_FALLBACK_MS = 1e3;
 var RUNTIME_STARTUP_TIMEOUT_ENV = "QWEN_SERVE_RUNTIME_STARTUP_TIMEOUT_MS";
 var MAX_EVENT_RING_SIZE = 1e6;
-var DEFAULT_MAX_SESSIONS = 20;
+var DEFAULT_MAX_SESSIONS = 32;
 var DEFAULT_MAX_PENDING_PROMPTS_PER_SESSION = 5;
 var DEFAULT_EVENT_RING_SIZE = 8e3;
 var DEFAULT_SESSION_IDLE_TIMEOUT_MS = 30 * 6e4;
@@ -2548,12 +2703,12 @@ var retryableChannelWorkerShutdownErrors = /* @__PURE__ */ new WeakSet();
 var channelWorkerRuntimePromise;
 async function loadChannelWorkerRuntime() {
   channelWorkerRuntimePromise ??= Promise.all([
-    import("./channel-worker-supervisor-74HTWA2G.js"),
-    import("./pidfile-6ERW3DF4.js"),
-    import("./runtime-DAUPSUKI.js"),
+    import("./channel-worker-supervisor-ORJIEEPP.js"),
+    import("./pidfile-ZMOIUGG6.js"),
+    import("./runtime-WCWM3DO7.js"),
     import("./cli-entry-path-4VJ3Y6T2.js"),
-    import("./channel-worker-group-XDPTDWTX.js"),
-    import("./channel-worker-manager-YYEHVRRE.js")
+    import("./channel-worker-group-ERSUOPIR.js"),
+    import("./channel-worker-manager-X247YDQ7.js")
   ]).then(
     ([
       supervisor,
@@ -2658,7 +2813,7 @@ function shouldPreheatBridge(deps) {
 __name(shouldPreheatBridge, "shouldPreheatBridge");
 var coreRuntimePromise;
 function loadCoreRuntime() {
-  coreRuntimePromise ??= import("./core-runtime-3XEYLQFK.js");
+  coreRuntimePromise ??= import("./core-runtime-NL3ZBHBU.js");
   return coreRuntimePromise;
 }
 __name(loadCoreRuntime, "loadCoreRuntime");
@@ -2688,10 +2843,10 @@ __name(resolveDaemonLogBaseDirForRun, "resolveDaemonLogBaseDirForRun");
 var settingsRuntimePromise;
 function loadSettingsRuntimeModules() {
   settingsRuntimePromise ??= Promise.all([
-    import("./settings-DJDXFDZ3.js"),
-    import("./environment-XXQ75D2Q.js"),
-    import("./loadedSettingsAdapter-SPUTNKAV.js"),
-    import("./trustedFolders-X2JEIO57.js")
+    import("./settings-CUN3SELH.js"),
+    import("./environment-DXJTXSVT.js"),
+    import("./loadedSettingsAdapter-OK6GK2GE.js"),
+    import("./trustedFolders-EVCN36O5.js")
   ]).then(([settings, environment, loadedSettingsAdapter, trustedFolders]) => ({
     settings,
     environment,
@@ -2704,8 +2859,8 @@ __name(loadSettingsRuntimeModules, "loadSettingsRuntimeModules");
 var channelWebhookConfigRuntimePromise;
 function loadChannelWebhookConfigRuntime() {
   channelWebhookConfigRuntimePromise ??= Promise.all([
-    import("./runtime-DAUPSUKI.js"),
-    import("./config-utils-NYSXDMEQ.js")
+    import("./runtime-WCWM3DO7.js"),
+    import("./config-utils-64LM6OEQ.js")
   ]).then(([channelRuntime, configUtils]) => ({
     loadChannelsConfig: channelRuntime.loadChannelsConfig,
     parseChannelWebhookConfig: configUtils.parseChannelWebhookConfig
@@ -2730,17 +2885,17 @@ async function loadServeRuntimeModules() {
     totalSessionAdmissionModule,
     workspaceRegistryModule
   ] = await Promise.all([
-    import("./server-WEH7DVCH.js"),
-    import("./bridge-3KJEWDNE.js"),
-    import("./spawnChannel-ETMJW7YX.js"),
+    import("./server-N4AJRKIQ.js"),
+    import("./bridge-JNEW6FES.js"),
+    import("./spawnChannel-RILO4YY3.js"),
     import("./process-registry-2CHQBXH5.js"),
-    import("./workspace-service-M6LLHKJ5.js"),
+    import("./workspace-service-VH6IWADT.js"),
     import("./types-ML3TRJQ5.js"),
-    import("./daemon-status-provider-3XJI6CAL.js"),
-    import("./workspace-providers-status-S35YAIUS.js"),
-    import("./workspace-skills-status-C2V7BAIS.js"),
-    import("./total-session-admission-44JKRWQD.js"),
-    import("./workspace-registry-O63R6IZ4.js")
+    import("./daemon-status-provider-XD23SNAM.js"),
+    import("./workspace-providers-status-O3HUZGGR.js"),
+    import("./workspace-skills-status-XANARSZS.js"),
+    import("./total-session-admission-3ZTAXVUK.js"),
+    import("./workspace-registry-U7ISW23N.js")
   ]);
   return {
     createServeApp: serverModule.createServeApp,
@@ -2934,12 +3089,12 @@ async function waitForRuntimeStartingForShutdown(runtimeStarting, daemonLog, tim
   let timer;
   await Promise.race([
     runtimeStarting,
-    new Promise((resolve) => {
+    new Promise((resolve2) => {
       timer = setTimeout(() => {
         daemonLog.warn(
           `${timeoutMs}ms runtime-startup wait reached during shutdown; continuing listener close`
         );
-        resolve();
+        resolve2();
       }, timeoutMs);
       timer.unref();
     })
@@ -3402,9 +3557,19 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       status: deps.bridge ? "external_bridge" : shouldPreheat ? "scheduled" : "not_scheduled"
     }
   };
+  if (optsIn.memoryProjectScope !== void 0 && !MEMORY_PROJECT_SCOPES.includes(
+    optsIn.memoryProjectScope
+  )) {
+    throw new TypeError(
+      `Invalid memoryProjectScope: ${String(optsIn.memoryProjectScope)}. Must be "git-root" or "workspace".`
+    );
+  }
   preResolveServeFastPathHomeEnvOverrides();
   const daemonRuntimeBaseEnv = Object.freeze({
-    ...process.env
+    ...process.env,
+    ...optsIn.memoryProjectScope !== void 0 ? {
+      QWEN_CODE_MEMORY_PROJECT_SCOPE: optsIn.memoryProjectScope
+    } : {}
   });
   const rawToken = optsIn.token ?? process.env[QWEN_SERVER_TOKEN_ENV];
   const token = typeof rawToken === "string" && rawToken.trim().length > 0 ? rawToken.trim() : void 0;
@@ -3633,7 +3798,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
   }
   let workspaceRegistrationStore = deps.workspaceRegistrationStore;
   if (workspaceRegistrationStore === void 0 && process.env["QWEN_SERVE_NO_PERSISTENT_REGISTRATION"] !== "1") {
-    const { WorkspaceRegistrationStore } = await import("./workspace-registration-store-OTMS3H4C.js");
+    const { WorkspaceRegistrationStore } = await import("./workspace-registration-store-M3FJ74RS.js");
     workspaceRegistrationStore = new WorkspaceRegistrationStore(boundWorkspace);
   }
   if (workspaceRegistrationStore) {
@@ -3890,8 +4055,8 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
   let startRuntimeAfterHealth;
   let startRuntimeForRequest;
   const deferRuntimeUntilFirstHealth = deps.resolveOnListen === true && deps.deferRuntimeUntilFirstHealth === true;
-  const runtimeReady = new Promise((resolve, reject) => {
-    markRuntimeReady = resolve;
+  const runtimeReady = new Promise((resolve2, reject) => {
+    markRuntimeReady = resolve2;
     markRuntimeFailed = reject;
   });
   void runtimeReady.catch(() => {
@@ -4144,7 +4309,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       loadCoreRuntime(),
       loadSettingsRuntimeModules(),
       cliVersionPromise,
-      import("./daemon-trust-policy-ILUDTLHD.js")
+      import("./daemon-trust-policy-NOHK7IW5.js")
     ]);
     cliVersion = resolvedCliVersion;
     settingsRuntime.environment.preResolveHomeEnvOverrides();
@@ -4200,6 +4365,29 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       envFileReadFailed: false,
       envFileReadFailures: Object.freeze([])
     };
+    const resolveSessionRuntimeBaseDir = /* @__PURE__ */ __name((workspace, settings, effectiveEnv) => {
+      const resolveConfiguredPath = /* @__PURE__ */ __name((configuredPath, relativeTo) => {
+        const expanded = configuredPath === "~" ? os.homedir() : configuredPath.startsWith("~/") || configuredPath.startsWith("~\\") ? path.join(
+          os.homedir(),
+          ...configuredPath.slice(2).split(/[/\\]+/).filter(Boolean)
+        ) : configuredPath;
+        return path.resolve(relativeTo, expanded);
+      }, "resolveConfiguredPath");
+      const runtimeDir = effectiveEnv["QWEN_RUNTIME_DIR"];
+      if (runtimeDir) {
+        return resolveConfiguredPath(runtimeDir, process.cwd());
+      }
+      const settingsDir = settings?.merged.advanced?.runtimeOutputDir;
+      if (settingsDir) {
+        return resolveConfiguredPath(settingsDir, workspace);
+      }
+      const qwenHome = effectiveEnv["QWEN_HOME"];
+      if (qwenHome) {
+        return resolveConfiguredPath(qwenHome, process.cwd());
+      }
+      const homeDir = os.homedir();
+      return homeDir ? path.join(homeDir, ".qwen") : path.join(os.tmpdir(), ".qwen");
+    }, "resolveSessionRuntimeBaseDir");
     const logRuntimeEnvFileReadFailures = /* @__PURE__ */ __name((workspace, snapshot) => {
       if (!snapshot.envFileReadFailed) return;
       const failedFiles = snapshot.envFileReadFailures ?? [];
@@ -4209,14 +4397,21 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       });
     }, "logRuntimeEnvFileReadFailures");
     logRuntimeEnvFileReadFailures(boundWorkspace, runtimeEnvSnapshot);
+    const primarySessionRuntimeBaseDir = resolveSessionRuntimeBaseDir(
+      boundWorkspace,
+      runtimeBootSettings,
+      runtimeEnvSnapshot.effectiveEnv
+    );
     const runtimeEffectiveEnv = {
-      ...runtimeEnvSnapshot.effectiveEnv
+      ...runtimeEnvSnapshot.effectiveEnv,
+      QWEN_RUNTIME_DIR: primarySessionRuntimeBaseDir
     };
     const replaceRuntimeEffectiveEnv = /* @__PURE__ */ __name((nextEnv) => {
       for (const key of Object.keys(runtimeEffectiveEnv)) {
         delete runtimeEffectiveEnv[key];
       }
       Object.assign(runtimeEffectiveEnv, nextEnv);
+      runtimeEffectiveEnv["QWEN_RUNTIME_DIR"] = primarySessionRuntimeBaseDir;
     }, "replaceRuntimeEffectiveEnv");
     const primaryRuntimeEnv = {
       mode: "runtime-overlay",
@@ -4479,7 +4674,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         resolveSkillSettings,
         skillSettingStrings,
         updateWorkspaceSkillSettingLists
-      } = await import("./skill-settings-VJ5PDMZI.js");
+      } = await import("./skill-settings-XVPCPW5K.js");
       const fresh = loadSettingsForPersistence(workspace);
       const normalizedName = skillName.trim().toLowerCase();
       const resolved = resolveSkillSettings(fresh);
@@ -4578,7 +4773,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         );
       }
     }), "persistSettingsFn");
-    const { createSubSessionLauncher } = await import("./create-sub-session-R76FVXCI.js");
+    const { createSubSessionLauncher } = await import("./create-sub-session-XHSCDYFU.js");
     const subSessionLauncher = createSubSessionLauncher({
       getBridge: /* @__PURE__ */ __name(() => bridgeRef, "getBridge"),
       boundWorkspace
@@ -4746,6 +4941,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       {
         workspaceId: daemonWorkspaceHash,
         workspaceCwd: boundWorkspace,
+        sessionRuntimeBaseDir: primarySessionRuntimeBaseDir,
         ...workspaceInputs[0]?.displayName ? { displayName: workspaceInputs[0].displayName } : {},
         primary: true,
         trusted: trustedWorkspace,
@@ -4774,7 +4970,15 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         envFileReadFailures: Object.freeze([])
       };
       logRuntimeEnvFileReadFailures(workspace, snapshot);
-      const effectiveEnv = { ...snapshot.effectiveEnv };
+      const sessionRuntimeBaseDir = resolveSessionRuntimeBaseDir(
+        workspace,
+        settings,
+        snapshot.effectiveEnv
+      );
+      const effectiveEnv = {
+        ...snapshot.effectiveEnv,
+        QWEN_RUNTIME_DIR: sessionRuntimeBaseDir
+      };
       const metadata = {
         mode: "runtime-overlay",
         overlayKeys: [...snapshot.overlayKeys],
@@ -4786,11 +4990,13 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       return {
         metadata,
         effectiveEnv,
+        sessionRuntimeBaseDir,
         replace(nextEnv) {
           for (const key of Object.keys(effectiveEnv)) {
             delete effectiveEnv[key];
           }
           Object.assign(effectiveEnv, nextEnv);
+          effectiveEnv["QWEN_RUNTIME_DIR"] = sessionRuntimeBaseDir;
         }
       };
     }, "createRuntimeEnvMetadata");
@@ -5017,6 +5223,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       const secondaryRuntime = {
         workspaceId: secondaryWorkspaceHash,
         workspaceCwd: workspaceInput.cwd,
+        sessionRuntimeBaseDir: secondaryEnv.sessionRuntimeBaseDir,
         ...workspaceInput.displayName ? { displayName: workspaceInput.displayName } : {},
         primary: false,
         trusted: secondaryTrusted,
@@ -5378,6 +5585,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       const wsRuntime = {
         workspaceId: wsHash,
         workspaceCwd: cwd,
+        sessionRuntimeBaseDir: wsEnv.sessionRuntimeBaseDir,
         ...buildOptions?.displayName !== void 0 ? { displayName: buildOptions.displayName } : {},
         primary: buildOptions?.primary ?? false,
         trusted,
@@ -5666,8 +5874,8 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
           { createChannelManagementService },
           { WorkspaceChannelSettingsStore }
         ] = await Promise.all([
-          import("./channel-management-service-XR7GZSWF.js"),
-          import("./channel-settings-store-HW4FXXUA.js")
+          import("./channel-management-service-QOO7TD3T.js"),
+          import("./channel-settings-store-4CSMTR4L.js")
         ]);
         return createChannelManagementService({
           workspaceCwd: targetRuntime.workspaceCwd,
@@ -5863,8 +6071,8 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         { createWorkspaceTrustReconciler },
         { createDaemonTrustPolicyMonitor }
       ] = await Promise.all([
-        import("./workspace-trust-reconciler-IBUPOUJN.js"),
-        import("./daemon-trust-policy-monitor-HS3PKKRO.js")
+        import("./workspace-trust-reconciler-35EFR4GC.js"),
+        import("./daemon-trust-policy-monitor-ZBTSR333.js")
       ]);
       const materializationFor = /* @__PURE__ */ __name((entry, snapshot, decision) => {
         const boundWorkspaces2 = entry.primary && decision.targetTrusted ? runtime.resolveBoundWorkspacesFromIdeEnv(
@@ -5959,7 +6167,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
             handle?.disposeWorkspace(runtimeToDispose.workspaceId);
             const deadline = Date.now() + 1e3;
             while ((handle?.getWorkspaceActivity(runtimeToDispose.workspaceId).memoryTasks ?? 0) > 0 && Date.now() < deadline) {
-              await new Promise((resolve) => setTimeout(resolve, 25));
+              await new Promise((resolve2) => setTimeout(resolve2, 25));
             }
             if ((handle?.getWorkspaceActivity(runtimeToDispose.workspaceId).memoryTasks ?? 0) > 0) {
               throw new Error(
@@ -6071,7 +6279,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
     );
   }
   const channelValidationSettingsRuntime = opts.channelSelection ? await loadSettingsRuntimeModules() : void 0;
-  const channelValidationTrustPolicy = opts.channelSelection ? await import("./daemon-trust-policy-ILUDTLHD.js") : void 0;
+  const channelValidationTrustPolicy = opts.channelSelection ? await import("./daemon-trust-policy-NOHK7IW5.js") : void 0;
   const channelValidationTrustSnapshot = channelValidationTrustPolicy ? await channelValidationTrustPolicy.readDaemonTrustPolicySnapshot() : void 0;
   const resolveChannelWorkspaceGroupsAtListen = /* @__PURE__ */ __name(() => {
     if (!opts.channelSelection || !channelValidationSettingsRuntime || !channelRuntime) {
@@ -6177,7 +6385,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
   if (opts.channelSelection) {
     reserveChannelServicePidfile(opts.channelSelection);
   }
-  return await new Promise((resolve, reject) => {
+  return await new Promise((resolve2, reject) => {
     const onListening = /* @__PURE__ */ __name((error) => {
       if (error) return;
       startup.listenerReadyAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -6332,7 +6540,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         daemonLog.error("runtime startup failed", error2);
         markRuntimeFailed(error2);
         if (closeServerAfterChannelWorkerStartupFailure && server.listening) {
-          runtimeFailureListenerClose = new Promise((resolve2) => {
+          runtimeFailureListenerClose = new Promise((resolve3) => {
             server.close((closeErr) => {
               if (closeErr) {
                 daemonLog.error(
@@ -6340,7 +6548,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
                   closeErr
                 );
               }
-              resolve2();
+              resolve3();
             });
           });
           server.closeAllConnections();
@@ -6673,7 +6881,9 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
             channelControlDraining = true;
             const initiallyMountedApp = runtimeApp ?? runtimeAppForCleanup;
             const initiallyMountedManagement = initiallyMountedApp?.locals?.["workspaceManagementHandle"];
+            const initiallyMountedSessionMaintenance = initiallyMountedApp?.locals?.["sessionArchiveCoordinator"];
             const initialManagementWait = initiallyMountedManagement?.sealAndWait?.();
+            const initialSessionMaintenanceWait = initiallyMountedSessionMaintenance?.sealMaintenanceAndWait?.();
             let processRegistryShutdown;
             const startProcessRegistryShutdown = /* @__PURE__ */ __name(() => {
               processRegistryShutdown ??= managedProcessRegistry?.shutdown().then(
@@ -6748,10 +6958,15 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
               );
               const appForCleanup = runtimeApp ?? runtimeAppForCleanup;
               const workspaceManagementHandle = appForCleanup?.locals?.["workspaceManagementHandle"];
+              const sessionMaintenance = appForCleanup?.locals?.["sessionArchiveCoordinator"];
               await initialManagementWait;
               if (workspaceManagementHandle !== initiallyMountedManagement) {
                 await workspaceManagementHandle?.sealAndWait?.();
               }
+              await initialSessionMaintenanceWait;
+              if (sessionMaintenance !== initiallyMountedSessionMaintenance) {
+                await sessionMaintenance?.sealMaintenanceAndWait?.();
+              }
               stopTrustPolicyMonitor(appForCleanup);
               const waitForTrustPolicyIdle = appForCleanup?.locals?.["waitForTrustPolicyIdle"];
               await waitForTrustPolicyIdle?.().catch((err) => {
@@ -6881,13 +7096,13 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       if (deps.resolveOnListen) {
         loggerPublished = true;
         loggerLifecycle.published();
-        resolve(handle);
+        resolve2(handle);
       } else {
         void runtimeReady.then(
           () => {
             loggerPublished = true;
             loggerLifecycle.published();
-            resolve(handle);
+            resolve2(handle);
           },
           (err) => {
             void handle.close().then(