@qwen-code/qwen-code 0.18.0-preview.2 → 0.18.0

package/chunks/{chunk-HXJE7VOG.js → chunk-LBP46COL.js}

@@ -6,30 +6,31 @@ import {
   getLanguageSettingsOptions,
   t,
   writeStderrLine
-} from "./chunk-7YKXFA3D.js";
+} from "./chunk-PL3MVCWD.js";
 import {
   DEFAULT_STOP_HOOK_BLOCK_CAP,
+  DEFAULT_TOOL_OUTPUT_BATCH_BUDGET,
   DEFAULT_TRUNCATE_TOOL_OUTPUT_LINES,
   DEFAULT_TRUNCATE_TOOL_OUTPUT_THRESHOLD,
   IdeClient,
   SkillError,
   ideContextStore,
   require_main
-} from "./chunk-QCG6KPNM.js";
+} from "./chunk-IWAYOW5Q.js";
 import {
   isWithinRoot,
   stripRuntimeSnapshotPrefix
-} from "./chunk-ZK4AMNIU.js";
+} from "./chunk-6YIUGZTC.js";
 import {
   atomicWriteFileSync
-} from "./chunk-UAMOBVVW.js";
+} from "./chunk-B7HXHOHU.js";
 import {
   FatalConfigError,
   QWEN_DIR,
   Storage,
   createDebugLogger,
   getErrorMessage
-} from "./chunk-JXAZUMDW.js";
+} from "./chunk-HR7SV7AY.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -12001,13 +12002,13 @@ var require_hosts = __commonJS({
     var defaults = {
       sshtemplate: /* @__PURE__ */ __name(({ domain, user, project, committish }) => `git@${domain}:${user}/${project}.git${maybeJoin("#", committish)}`, "sshtemplate"),
       sshurltemplate: /* @__PURE__ */ __name(({ domain, user, project, committish }) => `git+ssh://git@${domain}/${user}/${project}.git${maybeJoin("#", committish)}`, "sshurltemplate"),
-      edittemplate: /* @__PURE__ */ __name(({ domain, user, project, committish, editpath, path: path8 }) => `https://${domain}/${user}/${project}${maybeJoin("/", editpath, "/", maybeEncode(committish || "HEAD"), "/", path8)}`, "edittemplate"),
+      edittemplate: /* @__PURE__ */ __name(({ domain, user, project, committish, editpath, path: path9 }) => `https://${domain}/${user}/${project}${maybeJoin("/", editpath, "/", maybeEncode(committish || "HEAD"), "/", path9)}`, "edittemplate"),
       browsetemplate: /* @__PURE__ */ __name(({ domain, user, project, committish, treepath }) => `https://${domain}/${user}/${project}${maybeJoin("/", treepath, "/", maybeEncode(committish))}`, "browsetemplate"),
-      browsetreetemplate: /* @__PURE__ */ __name(({ domain, user, project, committish, treepath, path: path8, fragment, hashformat }) => `https://${domain}/${user}/${project}/${treepath}/${maybeEncode(committish || "HEAD")}/${path8}${maybeJoin("#", hashformat(fragment || ""))}`, "browsetreetemplate"),
-      browseblobtemplate: /* @__PURE__ */ __name(({ domain, user, project, committish, blobpath, path: path8, fragment, hashformat }) => `https://${domain}/${user}/${project}/${blobpath}/${maybeEncode(committish || "HEAD")}/${path8}${maybeJoin("#", hashformat(fragment || ""))}`, "browseblobtemplate"),
+      browsetreetemplate: /* @__PURE__ */ __name(({ domain, user, project, committish, treepath, path: path9, fragment, hashformat }) => `https://${domain}/${user}/${project}/${treepath}/${maybeEncode(committish || "HEAD")}/${path9}${maybeJoin("#", hashformat(fragment || ""))}`, "browsetreetemplate"),
+      browseblobtemplate: /* @__PURE__ */ __name(({ domain, user, project, committish, blobpath, path: path9, fragment, hashformat }) => `https://${domain}/${user}/${project}/${blobpath}/${maybeEncode(committish || "HEAD")}/${path9}${maybeJoin("#", hashformat(fragment || ""))}`, "browseblobtemplate"),
       docstemplate: /* @__PURE__ */ __name(({ domain, user, project, treepath, committish }) => `https://${domain}/${user}/${project}${maybeJoin("/", treepath, "/", maybeEncode(committish))}#readme`, "docstemplate"),
       httpstemplate: /* @__PURE__ */ __name(({ auth, domain, user, project, committish }) => `git+https://${maybeJoin(auth, "@")}${domain}/${user}/${project}.git${maybeJoin("#", committish)}`, "httpstemplate"),
-      filetemplate: /* @__PURE__ */ __name(({ domain, user, project, committish, path: path8 }) => `https://${domain}/${user}/${project}/raw/${maybeEncode(committish || "HEAD")}/${path8}`, "filetemplate"),
+      filetemplate: /* @__PURE__ */ __name(({ domain, user, project, committish, path: path9 }) => `https://${domain}/${user}/${project}/raw/${maybeEncode(committish || "HEAD")}/${path9}`, "filetemplate"),
       shortcuttemplate: /* @__PURE__ */ __name(({ type, user, project, committish }) => `${type}:${user}/${project}${maybeJoin("#", committish)}`, "shortcuttemplate"),
       pathtemplate: /* @__PURE__ */ __name(({ user, project, committish }) => `${user}/${project}${maybeJoin("#", committish)}`, "pathtemplate"),
       bugstemplate: /* @__PURE__ */ __name(({ domain, user, project }) => `https://${domain}/${user}/${project}/issues`, "bugstemplate"),
@@ -12022,7 +12023,7 @@ var require_hosts = __commonJS({
       treepath: "tree",
       blobpath: "blob",
       editpath: "edit",
-      filetemplate: /* @__PURE__ */ __name(({ auth, user, project, committish, path: path8 }) => `https://${maybeJoin(auth, "@")}raw.githubusercontent.com/${user}/${project}/${maybeEncode(committish || "HEAD")}/${path8}`, "filetemplate"),
+      filetemplate: /* @__PURE__ */ __name(({ auth, user, project, committish, path: path9 }) => `https://${maybeJoin(auth, "@")}raw.githubusercontent.com/${user}/${project}/${maybeEncode(committish || "HEAD")}/${path9}`, "filetemplate"),
       gittemplate: /* @__PURE__ */ __name(({ auth, domain, user, project, committish }) => `git://${maybeJoin(auth, "@")}${domain}/${user}/${project}.git${maybeJoin("#", committish)}`, "gittemplate"),
       tarballtemplate: /* @__PURE__ */ __name(({ domain, user, project, committish }) => `https://codeload.${domain}/${user}/${project}/tar.gz/${maybeEncode(committish || "HEAD")}`, "tarballtemplate"),
       extract: /* @__PURE__ */ __name((url) => {
@@ -12048,7 +12049,7 @@ var require_hosts = __commonJS({
       treepath: "src",
       blobpath: "src",
       editpath: "?mode=edit",
-      edittemplate: /* @__PURE__ */ __name(({ domain, user, project, committish, treepath, path: path8, editpath }) => `https://${domain}/${user}/${project}${maybeJoin("/", treepath, "/", maybeEncode(committish || "HEAD"), "/", path8, editpath)}`, "edittemplate"),
+      edittemplate: /* @__PURE__ */ __name(({ domain, user, project, committish, treepath, path: path9, editpath }) => `https://${domain}/${user}/${project}${maybeJoin("/", treepath, "/", maybeEncode(committish || "HEAD"), "/", path9, editpath)}`, "edittemplate"),
       tarballtemplate: /* @__PURE__ */ __name(({ domain, user, project, committish }) => `https://${domain}/${user}/${project}/get/${maybeEncode(committish || "HEAD")}.tar.gz`, "tarballtemplate"),
       extract: /* @__PURE__ */ __name((url) => {
         let [, user, project, aux] = url.pathname.split("/", 4);
@@ -12073,11 +12074,11 @@ var require_hosts = __commonJS({
       httpstemplate: /* @__PURE__ */ __name(({ auth, domain, user, project, committish }) => `git+https://${maybeJoin(auth, "@")}${domain}/${user}/${project}.git${maybeJoin("#", committish)}`, "httpstemplate"),
       tarballtemplate: /* @__PURE__ */ __name(({ domain, user, project, committish }) => `https://${domain}/${user}/${project}/repository/archive.tar.gz?ref=${maybeEncode(committish || "HEAD")}`, "tarballtemplate"),
       extract: /* @__PURE__ */ __name((url) => {
-        const path8 = url.pathname.slice(1);
-        if (path8.includes("/-/") || path8.includes("/archive.tar.gz")) {
+        const path9 = url.pathname.slice(1);
+        if (path9.includes("/-/") || path9.includes("/archive.tar.gz")) {
           return;
         }
-        const segments = path8.split("/");
+        const segments = path9.split("/");
         let project = segments.pop();
         if (project.endsWith(".git")) {
           project = project.slice(0, -4);
@@ -12097,11 +12098,11 @@ var require_hosts = __commonJS({
       sshurltemplate: /* @__PURE__ */ __name(({ domain, project, committish }) => `git+ssh://git@${domain}/${project}.git${maybeJoin("#", committish)}`, "sshurltemplate"),
       edittemplate: /* @__PURE__ */ __name(({ domain, user, project, committish, editpath }) => `https://${domain}/${user}/${project}${maybeJoin("/", maybeEncode(committish))}/${editpath}`, "edittemplate"),
       browsetemplate: /* @__PURE__ */ __name(({ domain, project, committish }) => `https://${domain}/${project}${maybeJoin("/", maybeEncode(committish))}`, "browsetemplate"),
-      browsetreetemplate: /* @__PURE__ */ __name(({ domain, project, committish, path: path8, hashformat }) => `https://${domain}/${project}${maybeJoin("/", maybeEncode(committish))}${maybeJoin("#", hashformat(path8))}`, "browsetreetemplate"),
-      browseblobtemplate: /* @__PURE__ */ __name(({ domain, project, committish, path: path8, hashformat }) => `https://${domain}/${project}${maybeJoin("/", maybeEncode(committish))}${maybeJoin("#", hashformat(path8))}`, "browseblobtemplate"),
+      browsetreetemplate: /* @__PURE__ */ __name(({ domain, project, committish, path: path9, hashformat }) => `https://${domain}/${project}${maybeJoin("/", maybeEncode(committish))}${maybeJoin("#", hashformat(path9))}`, "browsetreetemplate"),
+      browseblobtemplate: /* @__PURE__ */ __name(({ domain, project, committish, path: path9, hashformat }) => `https://${domain}/${project}${maybeJoin("/", maybeEncode(committish))}${maybeJoin("#", hashformat(path9))}`, "browseblobtemplate"),
       docstemplate: /* @__PURE__ */ __name(({ domain, project, committish }) => `https://${domain}/${project}${maybeJoin("/", maybeEncode(committish))}`, "docstemplate"),
       httpstemplate: /* @__PURE__ */ __name(({ domain, project, committish }) => `git+https://${domain}/${project}.git${maybeJoin("#", committish)}`, "httpstemplate"),
-      filetemplate: /* @__PURE__ */ __name(({ user, project, committish, path: path8 }) => `https://gist.githubusercontent.com/${user}/${project}/raw${maybeJoin("/", maybeEncode(committish))}/${path8}`, "filetemplate"),
+      filetemplate: /* @__PURE__ */ __name(({ user, project, committish, path: path9 }) => `https://gist.githubusercontent.com/${user}/${project}/raw${maybeJoin("/", maybeEncode(committish))}/${path9}`, "filetemplate"),
       shortcuttemplate: /* @__PURE__ */ __name(({ type, project, committish }) => `${type}:${project}${maybeJoin("#", committish)}`, "shortcuttemplate"),
       pathtemplate: /* @__PURE__ */ __name(({ project, committish }) => `${project}${maybeJoin("#", committish)}`, "pathtemplate"),
       bugstemplate: /* @__PURE__ */ __name(({ domain, project }) => `https://${domain}/${project}`, "bugstemplate"),
@@ -12133,7 +12134,7 @@ var require_hosts = __commonJS({
       domain: "git.sr.ht",
       treepath: "tree",
       blobpath: "tree",
-      filetemplate: /* @__PURE__ */ __name(({ domain, user, project, committish, path: path8 }) => `https://${domain}/${user}/${project}/blob/${maybeEncode(committish) || "HEAD"}/${path8}`, "filetemplate"),
+      filetemplate: /* @__PURE__ */ __name(({ domain, user, project, committish, path: path9 }) => `https://${domain}/${user}/${project}/blob/${maybeEncode(committish) || "HEAD"}/${path9}`, "filetemplate"),
       httpstemplate: /* @__PURE__ */ __name(({ domain, user, project, committish }) => `https://${domain}/${user}/${project}.git${maybeJoin("#", committish)}`, "httpstemplate"),
       tarballtemplate: /* @__PURE__ */ __name(({ domain, user, project, committish }) => `https://${domain}/${user}/${project}/archive/${maybeEncode(committish) || "HEAD"}.tar.gz`, "tarballtemplate"),
       bugstemplate: /* @__PURE__ */ __name(() => null, "bugstemplate"),
@@ -12327,8 +12328,8 @@ var require_lib3 = __commonJS({
           return null;
         }
         const proto = /(?:git\+)http:$/.test(protocol) ? "http:" : "https:";
-        const path8 = pathname.replace(/\.git$/, "");
-        return `${proto}//${hostname}${path8}`;
+        const path9 = pathname.replace(/\.git$/, "");
+        return `${proto}//${hostname}${path9}`;
       } catch {
         return null;
       }
@@ -12424,25 +12425,25 @@ var require_lib3 = __commonJS({
       sshurl(opts) {
         return this.#fill(this.sshurltemplate, opts);
       }
-      browse(path8, ...args) {
-        if (typeof path8 !== "string") {
-          return this.#fill(this.browsetemplate, path8);
+      browse(path9, ...args) {
+        if (typeof path9 !== "string") {
+          return this.#fill(this.browsetemplate, path9);
         }
         if (typeof args[0] !== "string") {
-          return this.#fill(this.browsetreetemplate, { ...args[0], path: path8 });
+          return this.#fill(this.browsetreetemplate, { ...args[0], path: path9 });
         }
-        return this.#fill(this.browsetreetemplate, { ...args[1], fragment: args[0], path: path8 });
+        return this.#fill(this.browsetreetemplate, { ...args[1], fragment: args[0], path: path9 });
       }
       // If the path is known to be a file, then browseFile should be used. For some hosts
       // the url is the same as browse, but for others like GitHub a file can use both `/tree/`
       // and `/blob/` in the path. When using a default committish of `HEAD` then the `/tree/`
       // path will redirect to a specific commit. Using the `/blob/` path avoids this and
       // does not redirect to a different commit.
-      browseFile(path8, ...args) {
+      browseFile(path9, ...args) {
         if (typeof args[0] !== "string") {
-          return this.#fill(this.browseblobtemplate, { ...args[0], path: path8 });
+          return this.#fill(this.browseblobtemplate, { ...args[0], path: path9 });
         }
-        return this.#fill(this.browseblobtemplate, { ...args[1], fragment: args[0], path: path8 });
+        return this.#fill(this.browseblobtemplate, { ...args[1], fragment: args[0], path: path9 });
       }
       docs(opts) {
         return this.#fill(this.docstemplate, opts);
@@ -12465,11 +12466,11 @@ var require_lib3 = __commonJS({
       tarball(opts) {
         return this.#fill(this.tarballtemplate, { ...opts, noCommittish: false });
       }
-      file(path8, opts) {
-        return this.#fill(this.filetemplate, { ...opts, path: path8 });
+      file(path9, opts) {
+        return this.#fill(this.filetemplate, { ...opts, path: path9 });
       }
-      edit(path8, opts) {
-        return this.#fill(this.edittemplate, { ...opts, path: path8 });
+      edit(path9, opts) {
+        return this.#fill(this.edittemplate, { ...opts, path: path9 });
       }
       getDefaultRepresentation() {
         return this.default;
@@ -13122,6 +13123,11 @@ var DEFAULT_RING_SIZE = 8e3;
 var WARN_THRESHOLD_RATIO = 0.75;
 var WARN_RESET_RATIO = 0.375;
 var DEFAULT_MAX_SUBSCRIBERS = 64;
+function getServerTimestamp(meta) {
+  const existing = meta?.["serverTimestamp"];
+  return typeof existing === "number" && Number.isFinite(existing) ? existing : Date.now();
+}
+__name(getServerTimestamp, "getServerTimestamp");
 var SubscriberLimitExceededError = class extends Error {
   static {
     __name(this, "SubscriberLimitExceededError");
@@ -13134,9 +13140,10 @@ var SubscriberLimitExceededError = class extends Error {
   }
 };
 var EventBus = class {
-  constructor(ringSize = DEFAULT_RING_SIZE, maxSubscribers = DEFAULT_MAX_SUBSCRIBERS) {
+  constructor(ringSize = DEFAULT_RING_SIZE, maxSubscribers = DEFAULT_MAX_SUBSCRIBERS, compactionEngine) {
     this.ringSize = ringSize;
     this.maxSubscribers = maxSubscribers;
+    this.compactionEngine = compactionEngine;
   }
   static {
     __name(this, "EventBus");
@@ -13145,6 +13152,9 @@ var EventBus = class {
   ring = [];
   subs = /* @__PURE__ */ new Set();
   closed = false;
+  snapshotReplay() {
+    return this.compactionEngine?.snapshot();
+  }
   /** Most recent id ever assigned by `publish`. 0 if no events published. */
   get lastEventId() {
     return this.nextId - 1;
@@ -13158,7 +13168,7 @@ var EventBus = class {
    * (with `id` + `v` assigned) on success, or `undefined` when the
    * bus is closed.
    *
-   * **Never throws** (BX9_p contract). Closing the bus mid-publish
+   * **Never throws** (never-throws contract). Closing the bus mid-publish
    * is the only abnormal path and is handled as a return-undefined
    * no-op; subscriber-enqueue failures are caught internally and
    * translated to per-subscriber eviction. Call sites can rely on
@@ -13169,12 +13179,21 @@ var EventBus = class {
    */
   publish(input) {
     if (this.closed) return void 0;
+    const existingMeta = input._meta;
     const event = {
       id: this.nextId++,
       v: EVENT_SCHEMA_VERSION,
-      ...input
+      ...input,
+      _meta: {
+        ...existingMeta ?? {},
+        serverTimestamp: getServerTimestamp(existingMeta)
+      }
     };
     this.ring.push(event);
+    try {
+      this.compactionEngine?.ingest(event);
+    } catch {
+    }
     if (this.ring.length > this.ringSize) this.ring.shift();
     for (const sub of Array.from(this.subs)) {
       if (sub.evicted) continue;
@@ -13247,11 +13266,61 @@ var EventBus = class {
     };
     this.subs.add(sub);
     if (opts.lastEventId !== void 0) {
+      const epochReset = opts.lastEventId >= this.nextId;
+      if (epochReset) {
+        queue.forcePush({
+          v: EVENT_SCHEMA_VERSION,
+          type: "state_resync_required",
+          data: {
+            reason: "epoch_reset",
+            lastDeliveredId: opts.lastEventId,
+            // Ring is typically empty right after a restart; fall back to
+            // `nextId` (the first id this epoch will assign) so the field
+            // stays meaningful ("fresh sequence starts here").
+            earliestAvailableId: this.ring[0]?.id ?? this.nextId
+          }
+        });
+      } else {
+        const earliestInRing = this.ring[0]?.id;
+        if (earliestInRing !== void 0 && earliestInRing > opts.lastEventId + 1) {
+          queue.forcePush({
+            v: EVENT_SCHEMA_VERSION,
+            type: "state_resync_required",
+            data: {
+              reason: "ring_evicted",
+              lastDeliveredId: opts.lastEventId,
+              earliestAvailableId: earliestInRing
+            }
+          });
+        }
+      }
+      const replayFrom = epochReset ? 0 : opts.lastEventId;
+      let replayedCount = 0;
+      let lastReplayedId;
       for (const e of this.ring) {
-        if (e.id !== void 0 && e.id > opts.lastEventId) {
+        if (e.id !== void 0 && e.id > replayFrom) {
           queue.forcePush(e);
+          replayedCount += 1;
+          lastReplayedId = e.id;
+        }
+      }
+      queue.forcePush({
+        v: EVENT_SCHEMA_VERSION,
+        type: "replay_complete",
+        data: {
+          // Note: `lastReplayedEventId`
+          // is the canonical wire name — the old `lastEventId` collided
+          // semantically with the SSE protocol's `Last-Event-ID` (envelope
+          // `id`) in raw daemon traces. Emit both: `lastReplayedEventId`
+          // for current SDKs and `lastEventId` as a deprecated alias so
+          // pre-rename consumers keep working (additive, non-breaking).
+          ...lastReplayedId !== void 0 ? {
+            lastReplayedEventId: lastReplayedId,
+            lastEventId: lastReplayedId
+          } : {},
+          replayedCount
         }
-      }
+      });
     }
     let disposed = false;
     const dispose = /* @__PURE__ */ __name(() => {
@@ -13293,6 +13362,7 @@ var EventBus = class {
     this.closed = true;
     for (const sub of this.subs) sub.queue.close();
     this.subs.clear();
+    this.compactionEngine?.close();
   }
 };
 function emptyAsyncIterable() {
@@ -13396,13 +13466,322 @@ var BoundedAsyncQueue = class {
         done: true
       });
     }
-    return new Promise((resolve2) => this.resolvers.push(resolve2));
+    return new Promise((resolve3) => this.resolvers.push(resolve3));
   }
 };
 
 // packages/cli/src/serve/eventBus.ts
 init_esbuild_shims();
 
+// packages/acp-bridge/src/bridgeErrors.ts
+init_esbuild_shims();
+
+// packages/acp-bridge/src/workspacePaths.ts
+init_esbuild_shims();
+import { realpathSync } from "node:fs";
+import * as path from "node:path";
+function canonicalizeWorkspace(p) {
+  const resolved = path.resolve(p);
+  try {
+    return realpathSync.native(resolved);
+  } catch (err) {
+    if (err && typeof err === "object" && err.code === "ENOENT") {
+      return resolved;
+    }
+    throw err;
+  }
+}
+__name(canonicalizeWorkspace, "canonicalizeWorkspace");
+var MAX_WORKSPACE_PATH_LENGTH = 4096;
+
+// packages/acp-bridge/src/bridgeErrors.ts
+var NOT_CURRENTLY_GENERATING_CANCEL_MESSAGE = "Not currently generating";
+function isNotCurrentlyGeneratingCancelError(err) {
+  if (!err || typeof err !== "object") return false;
+  const maybe = err;
+  if (isNotCurrentlyGeneratingText(maybe.message)) return true;
+  if (!maybe.data || typeof maybe.data !== "object") return false;
+  return isNotCurrentlyGeneratingText(
+    maybe.data.details
+  );
+}
+__name(isNotCurrentlyGeneratingCancelError, "isNotCurrentlyGeneratingCancelError");
+function isNotCurrentlyGeneratingText(value) {
+  return typeof value === "string" && /\bnot currently generating\b/i.test(value);
+}
+__name(isNotCurrentlyGeneratingText, "isNotCurrentlyGeneratingText");
+var SessionNotFoundError = class extends Error {
+  static {
+    __name(this, "SessionNotFoundError");
+  }
+  sessionId;
+  constructor(sessionId, extra) {
+    super(`No session with id "${sessionId}"` + (extra ? `. ${extra}` : ""));
+    this.name = "SessionNotFoundError";
+    this.sessionId = sessionId;
+  }
+};
+var RestoreInProgressError = class extends Error {
+  static {
+    __name(this, "RestoreInProgressError");
+  }
+  sessionId;
+  activeAction;
+  requestedAction;
+  constructor(sessionId, activeAction, requestedAction) {
+    super(
+      `Session "${sessionId}" is already being restored via session/${activeAction}; retry session/${requestedAction} after it completes`
+    );
+    this.name = "RestoreInProgressError";
+    this.sessionId = sessionId;
+    this.activeAction = activeAction;
+    this.requestedAction = requestedAction;
+  }
+};
+var InvalidSessionScopeError = class extends Error {
+  static {
+    __name(this, "InvalidSessionScopeError");
+  }
+  sessionScope;
+  constructor(sessionScope) {
+    super(
+      `Invalid sessionScope: ${JSON.stringify(sessionScope)}. Expected 'single' or 'thread'.`
+    );
+    this.name = "InvalidSessionScopeError";
+    this.sessionScope = sessionScope;
+  }
+};
+var SessionLimitExceededError = class extends Error {
+  static {
+    __name(this, "SessionLimitExceededError");
+  }
+  limit;
+  constructor(limit) {
+    super(`Session limit reached (${limit})`);
+    this.name = "SessionLimitExceededError";
+    this.limit = limit;
+  }
+};
+var WorkspaceMismatchError = class extends Error {
+  static {
+    __name(this, "WorkspaceMismatchError");
+  }
+  bound;
+  requested;
+  constructor(bound, requested) {
+    const safeRequested = requested.length > MAX_WORKSPACE_PATH_LENGTH ? `${requested.slice(0, MAX_WORKSPACE_PATH_LENGTH)}\u2026[truncated]` : requested;
+    super(
+      `Workspace mismatch: daemon is bound to "${bound}" but request asked for "${safeRequested}". Each \`qwen serve\` daemon binds to exactly one workspace; start a separate daemon for "${safeRequested}" (or route the request to one via an orchestrator).`
+    );
+    this.name = "WorkspaceMismatchError";
+    this.bound = bound;
+    this.requested = safeRequested;
+  }
+};
+var InvalidClientIdError = class extends Error {
+  static {
+    __name(this, "InvalidClientIdError");
+  }
+  sessionId;
+  clientId;
+  constructor(sessionId, clientId) {
+    super(`Client id "${clientId}" is not registered for session ${sessionId}`);
+    this.name = "InvalidClientIdError";
+    this.sessionId = sessionId;
+    this.clientId = clientId;
+  }
+};
+var InvalidPermissionOptionError = class extends Error {
+  static {
+    __name(this, "InvalidPermissionOptionError");
+  }
+  requestId;
+  optionId;
+  constructor(requestId, optionId) {
+    super(
+      `Permission ${requestId}: optionId "${optionId}" is not in the set of options the agent offered.`
+    );
+    this.name = "InvalidPermissionOptionError";
+    this.requestId = requestId;
+    this.optionId = optionId;
+  }
+};
+var InvalidSessionMetadataError = class extends Error {
+  static {
+    __name(this, "InvalidSessionMetadataError");
+  }
+  field;
+  constructor(field, reason) {
+    super(`Invalid session metadata: ${field} ${reason}`);
+    this.name = "InvalidSessionMetadataError";
+    this.field = field;
+  }
+};
+var PermissionPolicyNotImplementedError = class extends Error {
+  static {
+    __name(this, "PermissionPolicyNotImplementedError");
+  }
+  policy;
+  constructor(policy) {
+    super(
+      `Permission policy "${policy}" is declared in the contract but not yet implemented in this daemon build.`
+    );
+    this.name = "PermissionPolicyNotImplementedError";
+    this.policy = policy;
+  }
+};
+var CancelSentinelCollisionError = class extends Error {
+  static {
+    __name(this, "CancelSentinelCollisionError");
+  }
+  requestId;
+  sentinel;
+  constructor(requestId, sentinel) {
+    super(
+      `Permission ${requestId}: agent-declared optionId set contains the cancel-vote sentinel "${sentinel}", which would prevent the daemon from disambiguating cancel intent from a real vote.`
+    );
+    this.name = "CancelSentinelCollisionError";
+    this.requestId = requestId;
+    this.sentinel = sentinel;
+  }
+};
+var PermissionForbiddenError = class extends Error {
+  static {
+    __name(this, "PermissionForbiddenError");
+  }
+  requestId;
+  sessionId;
+  reason;
+  constructor(requestId, sessionId, reason) {
+    super(
+      `Permission ${requestId} on session ${sessionId}: vote rejected by policy (${reason}).`
+    );
+    this.name = "PermissionForbiddenError";
+    this.requestId = requestId;
+    this.sessionId = sessionId;
+    this.reason = reason;
+  }
+};
+var WorkspaceInitConflictError = class extends Error {
+  static {
+    __name(this, "WorkspaceInitConflictError");
+  }
+  path;
+  existingSize;
+  constructor(path9, existingSize) {
+    super(
+      `Workspace file ${path9} already exists (${existingSize} bytes); pass {force: true} to overwrite.`
+    );
+    this.name = "WorkspaceInitConflictError";
+    this.path = path9;
+    this.existingSize = existingSize;
+  }
+};
+var WorkspaceInitPathEscapeError = class extends Error {
+  static {
+    __name(this, "WorkspaceInitPathEscapeError");
+  }
+  filename;
+  boundWorkspace;
+  constructor(filename, boundWorkspace) {
+    super(
+      `Configured workspace context filename ${JSON.stringify(filename)} resolves outside the bound workspace ${JSON.stringify(boundWorkspace)}. Refusing to write.`
+    );
+    this.name = "WorkspaceInitPathEscapeError";
+    this.filename = filename;
+    this.boundWorkspace = boundWorkspace;
+  }
+};
+var WorkspaceInitSymlinkError = class extends Error {
+  static {
+    __name(this, "WorkspaceInitSymlinkError");
+  }
+  target;
+  kind;
+  constructor(target, kind, detail) {
+    super(detail);
+    this.name = "WorkspaceInitSymlinkError";
+    this.target = target;
+    this.kind = kind;
+  }
+};
+var WorkspaceInitRaceError = class extends Error {
+  static {
+    __name(this, "WorkspaceInitRaceError");
+  }
+  target;
+  kind;
+  constructor(target, kind, detail) {
+    super(detail);
+    this.name = "WorkspaceInitRaceError";
+    this.target = target;
+    this.kind = kind;
+  }
+};
+var McpServerNotFoundError = class extends Error {
+  static {
+    __name(this, "McpServerNotFoundError");
+  }
+  serverName;
+  constructor(serverName) {
+    super(`MCP server not configured: ${JSON.stringify(serverName)}`);
+    this.name = "McpServerNotFoundError";
+    this.serverName = serverName;
+  }
+};
+var McpServerRestartFailedError = class extends Error {
+  static {
+    __name(this, "McpServerRestartFailedError");
+  }
+  serverName;
+  mcpStatus;
+  constructor(serverName, mcpStatus) {
+    super(
+      `MCP server ${JSON.stringify(serverName)} did not reach a connected state after restart (status: ${mcpStatus}).`
+    );
+    this.name = "McpServerRestartFailedError";
+    this.serverName = serverName;
+    this.mcpStatus = mcpStatus;
+  }
+};
+var SessionBusyError = class extends Error {
+  static {
+    __name(this, "SessionBusyError");
+  }
+  sessionId;
+  constructor(sessionId, message) {
+    super(message ?? `Session ${sessionId} is busy (prompt running)`);
+    this.name = "SessionBusyError";
+    this.sessionId = sessionId;
+  }
+};
+var InvalidRewindTargetError = class extends Error {
+  static {
+    __name(this, "InvalidRewindTargetError");
+  }
+  sessionId;
+  constructor(sessionId, message) {
+    super(
+      message ?? `Cannot rewind to the requested turn (compressed or does not exist)`
+    );
+    this.name = "InvalidRewindTargetError";
+    this.sessionId = sessionId;
+  }
+};
+var BranchWhilePromptActiveError = class extends Error {
+  static {
+    __name(this, "BranchWhilePromptActiveError");
+  }
+  sessionId;
+  constructor(sessionId) {
+    super(
+      `Cannot branch session ${sessionId}: a prompt is currently active`
+    );
+    this.name = "BranchWhilePromptActiveError";
+    this.sessionId = sessionId;
+  }
+};
+
 // packages/acp-bridge/src/status.ts
 init_esbuild_shims();
 var STATUS_SCHEMA_VERSION = 1;
@@ -13415,10 +13794,17 @@ var SERVE_ERROR_KINDS = [
   "missing_file",
   "parse_error",
   "stat_failed",
-  // Issue #4175 PR 14: budget refusal under `--mcp-budget-mode=enforce`.
+  // Budget refusal under `--mcp-budget-mode=enforce`.
   // Surfaced on per-server `mcp_server` cells (refused at discovery)
   // and on the workspace-level `mcp_budget` cell (any refusal this pass).
-  "budget_exhausted"
+  "budget_exhausted",
+  // Runtime MCP mutation routes
+  "mcp_budget_would_exceed",
+  "mcp_server_spawn_failed",
+  "invalid_config",
+  // Prompt deadline + writer idle timeout
+  "prompt_deadline_exceeded",
+  "writer_idle_timeout"
 ];
 var BridgeTimeoutError = class extends Error {
   static {
@@ -13427,7 +13813,7 @@ var BridgeTimeoutError = class extends Error {
   label;
   timeoutMs;
   constructor(label, timeoutMs) {
-    super(`HttpAcpBridge ${label} timed out after ${timeoutMs}ms`);
+    super(`AcpSessionBridge ${label} timed out after ${timeoutMs}ms`);
     this.name = "BridgeTimeoutError";
     this.label = label;
     this.timeoutMs = timeoutMs;
@@ -13457,18 +13843,123 @@ var MissingCliEntryError = class extends Error {
 };
 var SERVE_STATUS_EXT_METHODS = {
   workspaceMcp: "qwen/status/workspace/mcp",
+  workspaceMcpTools: "qwen/status/workspace/mcp/tools",
   workspaceSkills: "qwen/status/workspace/skills",
+  workspaceTools: "qwen/status/workspace/tools",
   workspaceProviders: "qwen/status/workspace/providers",
   workspaceMemory: "qwen/status/workspace/memory",
   workspaceAgents: "qwen/status/workspace/agents",
   workspacePreflight: "qwen/status/workspace/preflight",
   sessionContext: "qwen/status/session/context",
-  sessionSupportedCommands: "qwen/status/session/supported_commands"
+  sessionContextUsage: "qwen/status/session/context_usage",
+  sessionSupportedCommands: "qwen/status/session/supported_commands",
+  sessionTasks: "qwen/status/session/tasks",
+  sessionStats: "qwen/status/session/stats",
+  sessionRewindSnapshots: "qwen/status/session/rewind_snapshots",
+  workspaceHooks: "qwen/status/workspace/hooks",
+  sessionHooks: "qwen/status/session/hooks",
+  workspaceExtensions: "qwen/status/workspace/extensions"
 };
 var SERVE_CONTROL_EXT_METHODS = {
+  sessionClose: "qwen/control/session/close",
   sessionApprovalMode: "qwen/control/session/approval_mode",
-  workspaceMcpRestart: "qwen/control/workspace/mcp/restart"
+  sessionBranch: "qwen/control/session/branch",
+  sessionRecap: "qwen/control/session/recap",
+  sessionBtw: "qwen/control/session/btw",
+  sessionShellHistory: "qwen/control/session/shell_history",
+  sessionLanguage: "qwen/control/session/language",
+  sessionRewind: "qwen/control/session/rewind",
+  workspaceMcpRestart: "qwen/control/workspace/mcp/restart",
+  workspaceMcpManage: "qwen/control/workspace/mcp/manage",
+  workspaceAgentGenerate: "qwen/control/workspace/agents/generate",
+  // Runtime MCP server mutation ext-methods
+  sessionTaskCancel: "qwen/control/session/task/cancel",
+  sessionGoalClear: "qwen/control/session/goal/clear",
+  workspaceMcpRuntimeAdd: "qwen/control/workspace/mcp/runtime-add",
+  workspaceMcpRuntimeRemove: "qwen/control/workspace/mcp/runtime-remove",
+  workspaceReload: "qwen/control/workspace/reload"
+};
+var IDLE_HOOK_EVENTS = {
+  PreToolUse: { description: "Before tool execution", matcherKind: "toolName" },
+  PostToolUse: { description: "After tool execution", matcherKind: "toolName" },
+  PostToolUseFailure: {
+    description: "After tool execution fails",
+    matcherKind: "toolName"
+  },
+  PostToolBatch: { description: "After a batch of tool calls resolves" },
+  Notification: {
+    description: "When notifications are sent",
+    matcherKind: "notificationType"
+  },
+  UserPromptSubmit: { description: "When the user submits a prompt" },
+  UserPromptExpansion: {
+    description: "When a slash command expands into a prompt",
+    matcherKind: "commandName"
+  },
+  SessionStart: {
+    description: "When a new session is started",
+    matcherKind: "sessionTrigger"
+  },
+  Stop: { description: "Right before Qwen Code concludes its response" },
+  SubagentStart: {
+    description: "When a subagent is started",
+    matcherKind: "agentType"
+  },
+  SubagentStop: {
+    description: "Right before a subagent concludes its response",
+    matcherKind: "agentType"
+  },
+  PreCompact: {
+    description: "Before conversation compaction",
+    matcherKind: "trigger"
+  },
+  PostCompact: {
+    description: "After conversation compaction",
+    matcherKind: "trigger"
+  },
+  SessionEnd: {
+    description: "When a session is ending",
+    matcherKind: "sessionTrigger"
+  },
+  PermissionRequest: {
+    description: "When a permission dialog is displayed",
+    matcherKind: "toolName"
+  },
+  PermissionDenied: {
+    description: "When a tool call is denied",
+    matcherKind: "toolName"
+  },
+  StopFailure: {
+    description: "When the turn ends due to an API error",
+    matcherKind: "error"
+  },
+  TodoCreated: { description: "When a new todo item is created" },
+  TodoCompleted: { description: "When a todo item is marked as completed" },
+  InstructionsLoaded: {
+    description: "When an instruction or context file is loaded",
+    matcherKind: "filePath"
+  }
 };
+function createIdleWorkspaceExtensionsStatus(workspaceCwd) {
+  return {
+    v: STATUS_SCHEMA_VERSION,
+    workspaceCwd,
+    initialized: false,
+    extensions: []
+  };
+}
+__name(createIdleWorkspaceExtensionsStatus, "createIdleWorkspaceExtensionsStatus");
+function createIdleWorkspaceHooksStatus(workspaceCwd) {
+  return {
+    v: STATUS_SCHEMA_VERSION,
+    workspaceCwd,
+    initialized: false,
+    disabled: false,
+    hooks: [],
+    events: IDLE_HOOK_EVENTS
+  };
+}
+__name(createIdleWorkspaceHooksStatus, "createIdleWorkspaceHooksStatus");
 function createIdleWorkspaceMemoryStatus(workspaceCwd) {
   return {
     v: STATUS_SCHEMA_VERSION,
@@ -13589,7 +14080,7 @@ init_esbuild_shims();
 // packages/cli/src/utils/languageUtils.ts
 init_esbuild_shims();
 import * as fs from "node:fs";
-import * as path from "node:path";
+import * as path2 from "node:path";
 var LLM_OUTPUT_LANGUAGE_RULE_FILENAME = "output-language.md";
 var LLM_OUTPUT_LANGUAGE_MARKER_PREFIX = "qwen-code:llm-output-language:";
 var OUTPUT_LANGUAGE_AUTO = "auto";
@@ -13615,7 +14106,7 @@ function resolveOutputLanguage(value) {
 }
 __name(resolveOutputLanguage, "resolveOutputLanguage");
 function getOutputLanguageFilePath() {
-  return path.join(
+  return path2.join(
     Storage.getGlobalQwenDir(),
     LLM_OUTPUT_LANGUAGE_RULE_FILENAME
   );
@@ -13678,19 +14169,27 @@ function readOutputLanguageFromFile() {
   }
 }
 __name(readOutputLanguageFromFile, "readOutputLanguageFromFile");
-function writeOutputLanguageFile(language) {
-  const filePath = getOutputLanguageFilePath();
+function writeOutputLanguageFile(language, targetPath) {
+  const filePath = targetPath ?? getOutputLanguageFilePath();
   const content = generateOutputLanguageFileContent(language);
-  const dir = path.dirname(filePath);
+  const dir = path2.dirname(filePath);
   fs.mkdirSync(dir, { recursive: true });
   fs.writeFileSync(filePath, content, "utf-8");
 }
 __name(writeOutputLanguageFile, "writeOutputLanguageFile");
-function updateOutputLanguageFile(settingValue) {
+function updateOutputLanguageFile(settingValue, targetPath) {
   const resolved = resolveOutputLanguage(settingValue);
-  writeOutputLanguageFile(resolved);
+  writeOutputLanguageFile(resolved, targetPath);
 }
 __name(updateOutputLanguageFile, "updateOutputLanguageFile");
+function writeOutputLanguageAndRegisterPath(settingValue, config) {
+  const targetPath = config?.getOutputLanguageFilePath();
+  updateOutputLanguageFile(settingValue, targetPath);
+  if (!targetPath) {
+    config?.setOutputLanguageFilePath(getOutputLanguageFilePath());
+  }
+}
+__name(writeOutputLanguageAndRegisterPath, "writeOutputLanguageAndRegisterPath");
 function initializeLlmOutputLanguage(outputLanguage) {
   const currentFileLanguage = readOutputLanguageFromFile();
   if (currentFileLanguage) {
@@ -13705,7 +14204,7 @@ __name(initializeLlmOutputLanguage, "initializeLlmOutputLanguage");
 init_esbuild_shims();
 var dotenv = __toESM(require_main(), 1);
 import * as fs6 from "node:fs";
-import * as path3 from "node:path";
+import * as path4 from "node:path";
 import { homedir, platform } from "node:os";
 import process2 from "node:process";
 var import_strip_json_comments2 = __toESM(require_strip_json_comments(), 1);
@@ -13898,6 +14397,89 @@ function resolveColor(colorValue) {
   return void 0;
 }
 __name(resolveColor, "resolveColor");
+var INK_NAME_TO_HEX = {
+  black: "#000000",
+  red: "#ff0000",
+  green: "#00ff00",
+  yellow: "#ffff00",
+  blue: "#0000ff",
+  cyan: "#00ffff",
+  magenta: "#ff00ff",
+  white: "#ffffff",
+  gray: "#808080",
+  grey: "#808080",
+  blackbright: "#808080",
+  redbright: "#ff8080",
+  greenbright: "#80ff80",
+  yellowbright: "#ffff80",
+  bluebright: "#8080ff",
+  cyanbright: "#80ffff",
+  magentabright: "#ff80ff",
+  whitebright: "#ffffff"
+};
+function toHex(color) {
+  const resolved = (resolveColor(color) ?? color).toLowerCase();
+  if (resolved.startsWith("#")) {
+    if (/^#[0-9a-f]{3}$/.test(resolved)) {
+      return `#${resolved.slice(1).split("").map((c) => c + c).join("")}`;
+    }
+    if (/^#[0-9a-f]{6}$/.test(resolved)) {
+      return resolved;
+    }
+    return void 0;
+  }
+  return INK_NAME_TO_HEX[resolved];
+}
+__name(toHex, "toHex");
+function interpolateColor(color1, color2, factor) {
+  if (factor <= 0) {
+    return color1;
+  }
+  if (factor >= 1) {
+    return color2;
+  }
+  const h1 = toHex(color1);
+  const h2 = toHex(color2);
+  if (!h1 || !h2) {
+    return "";
+  }
+  const r1 = parseInt(h1.slice(1, 3), 16);
+  const g1 = parseInt(h1.slice(3, 5), 16);
+  const b1 = parseInt(h1.slice(5, 7), 16);
+  const r2 = parseInt(h2.slice(1, 3), 16);
+  const g2 = parseInt(h2.slice(3, 5), 16);
+  const b2 = parseInt(h2.slice(5, 7), 16);
+  const lerp = /* @__PURE__ */ __name((a, b) => Math.round(a + (b - a) * factor), "lerp");
+  const toByte = /* @__PURE__ */ __name((n) => Math.max(0, Math.min(255, n)).toString(16).padStart(2, "0"), "toByte");
+  return `#${toByte(lerp(r1, r2))}${toByte(lerp(g1, g2))}${toByte(lerp(b1, b2))}`;
+}
+__name(interpolateColor, "interpolateColor");
+function subtleBandColor(bgColor, factor = 0.06) {
+  const hex = toHex(bgColor);
+  if (!hex) {
+    return "";
+  }
+  const r = parseInt(hex.slice(1, 3), 16);
+  const g = parseInt(hex.slice(3, 5), 16);
+  const b = parseInt(hex.slice(5, 7), 16);
+  const isDark = (r * 299 + g * 587 + b * 114) / 1e3 < 128;
+  const target = isDark ? "#ffffff" : "#000000";
+  return interpolateColor(hex, target, factor);
+}
+__name(subtleBandColor, "subtleBandColor");
+var _supportsTrueColor;
+function supportsTrueColor() {
+  if (_supportsTrueColor !== void 0) return _supportsTrueColor;
+  const colorterm = process.env["COLORTERM"];
+  if (colorterm === "truecolor" || colorterm === "24bit" || colorterm === "kmscon") {
+    return _supportsTrueColor = true;
+  }
+  if (process.stdout.getColorDepth && process.stdout.getColorDepth() >= 24) {
+    return _supportsTrueColor = true;
+  }
+  return _supportsTrueColor = false;
+}
+__name(supportsTrueColor, "supportsTrueColor");
 
 // packages/cli/src/ui/themes/theme.ts
 var lightTheme = {
@@ -14516,14 +15098,14 @@ var DefaultDark = new Theme(
 // packages/cli/src/config/trustedFolders.ts
 init_esbuild_shims();
 import * as fs2 from "node:fs";
-import * as path2 from "node:path";
+import * as path3 from "node:path";
 var import_strip_json_comments = __toESM(require_strip_json_comments(), 1);
 var TRUSTED_FOLDERS_FILENAME = "trustedFolders.json";
 function getTrustedFoldersPath() {
   if (process.env["QWEN_CODE_TRUSTED_FOLDERS_PATH"]) {
     return process.env["QWEN_CODE_TRUSTED_FOLDERS_PATH"];
   }
-  return path2.join(Storage.getGlobalQwenDir(), TRUSTED_FOLDERS_FILENAME);
+  return path3.join(Storage.getGlobalQwenDir(), TRUSTED_FOLDERS_FILENAME);
 }
 __name(getTrustedFoldersPath, "getTrustedFoldersPath");
 var LoadedTrustedFolders = class {
@@ -14535,8 +15117,8 @@ var LoadedTrustedFolders = class {
     __name(this, "LoadedTrustedFolders");
   }
   get rules() {
-    return Object.entries(this.user.config).map(([path8, trustLevel]) => ({
-      path: path8,
+    return Object.entries(this.user.config).map(([path9, trustLevel]) => ({
+      path: path9,
       trustLevel
     }));
   }
@@ -14556,7 +15138,7 @@ var LoadedTrustedFolders = class {
           trustedPaths.push(rule.path);
           break;
         case "TRUST_PARENT" /* TRUST_PARENT */:
-          trustedPaths.push(path2.dirname(rule.path));
+          trustedPaths.push(path3.dirname(rule.path));
           break;
         case "DO_NOT_TRUST" /* DO_NOT_TRUST */:
           untrustedPaths.push(rule.path);
@@ -14571,14 +15153,14 @@ var LoadedTrustedFolders = class {
       }
     }
     for (const untrustedPath of untrustedPaths) {
-      if (path2.normalize(location) === path2.normalize(untrustedPath)) {
+      if (path3.normalize(location) === path3.normalize(untrustedPath)) {
         return false;
       }
     }
     return void 0;
   }
-  setValue(path8, trustLevel) {
-    this.user.config[path8] = trustLevel;
+  setValue(path9, trustLevel) {
+    this.user.config[path9] = trustLevel;
     saveTrustedFolders(this.user);
   }
 };
@@ -14618,7 +15200,7 @@ function loadTrustedFolders() {
 __name(loadTrustedFolders, "loadTrustedFolders");
 function saveTrustedFolders(trustedFoldersFile) {
   try {
-    const dirPath = path2.dirname(trustedFoldersFile.path);
+    const dirPath = path3.dirname(trustedFoldersFile.path);
     if (!fs2.existsSync(dirPath)) {
       fs2.mkdirSync(dirPath, { recursive: true });
     }
@@ -16320,6 +16902,15 @@ var SETTINGS_SCHEMA = {
         description: "The number of lines to keep when truncating tool output.",
         showInDialog: false
       },
+      toolOutputBatchBudget: {
+        type: "number",
+        label: "Tool Output Batch Budget",
+        category: "General",
+        requiresRestart: true,
+        default: DEFAULT_TOOL_OUTPUT_BATCH_BUDGET,
+        description: "Per-message budget (characters) for the combined output of one batch of tool calls; the largest results are offloaded to disk when exceeded. Set to -1 to disable.",
+        showInDialog: false
+      },
       computerUse: {
         type: "object",
         label: "Computer Use",
@@ -16342,6 +16933,51 @@ var SETTINGS_SCHEMA = {
       }
     }
   },
+  policy: {
+    type: "object",
+    label: "Daemon Policy",
+    category: "Daemon",
+    requiresRestart: true,
+    default: {},
+    description: "Daemon multi-client coordination policies. Tool-level allow/deny rules live under `permissions`; this section is for runtime mediation behavior between concurrent HTTP clients sharing one `qwen serve` daemon.",
+    showInDialog: false,
+    properties: {
+      permissionStrategy: {
+        type: "enum",
+        label: "Permission Mediation Policy",
+        category: "Daemon",
+        requiresRestart: true,
+        default: "first-responder",
+        description: 'How permission requests resolve when multiple clients are attached. `first-responder` (default) = any client decides, first wins. `designated` = only the prompt originator decides; falls back to first-responder if originator is anonymous. NOTE: client identity comes from self-declared X-Qwen-Client-Id with no proof-of-possession (pair-token identity is not implemented yet), so any client observing originatorClientId on SSE frames can register with the same id and impersonate the originator. `consensus` = N-of-M voters must agree. Default N=floor(M/2)+1, which means UNANIMITY for M=2 (quorum=2, both must agree) and supermajority for larger even M (M=4 \u2192 quorum=3; M=6 \u2192 quorum=4). For M=2 specifically, split votes resolve only via permissionTimeoutMs. `local-only` = only loopback clients can RESOLVE; remote clients can still ABORT a pending permission via the cancel sentinel ({outcome:"cancelled"}) \u2014 cancel stays cross-policy for consistency. Strict-cancel-too deployments need a dedicated loopback-bound daemon. Requires daemon restart \u2014 read once at boot.',
+        showInDialog: true,
+        options: [
+          { value: "first-responder", label: "First Responder" },
+          { value: "designated", label: "Designated Originator" },
+          { value: "consensus", label: "Consensus Quorum" },
+          { value: "local-only", label: "Local Only" }
+        ]
+      },
+      consensusQuorum: {
+        type: "number",
+        label: "Consensus Quorum Override",
+        category: "Daemon",
+        requiresRestart: true,
+        default: void 0,
+        description: "Optional fixed quorum size for consensus policy. Capped at M (count of registered voters at request issue time) to prevent unreachable quorum. Unset = floor(M/2)+1. Requires daemon restart \u2014 read once at boot.",
+        showInDialog: false,
+        // runQwenServe.ts validates `Number.isInteger(n) && n >= 1` and
+        // refuses to boot otherwise. Override the generated schema so IDE
+        // (VSCode, JetBrains via JSON Schema) flags `0`, `-1`, `1.5`
+        // BEFORE the user restarts the daemon. The bare `type:'number'`
+        // mapping accepts all of these.
+        jsonSchemaOverride: {
+          type: "integer",
+          minimum: 1,
+          description: "Optional fixed quorum size for consensus policy. Capped at M (count of registered voters at request issue time) to prevent unreachable quorum. Unset = floor(M/2)+1. Requires daemon restart \u2014 read once at boot."
+        }
+      }
+    }
+  },
   mcp: {
     type: "object",
     label: "MCP",
@@ -16976,8 +17612,8 @@ function getDefaultValue(key) {
   return getFlattenedSchema()[key]?.default;
 }
 __name(getDefaultValue, "getDefaultValue");
-function getNestedValue(obj, path8) {
-  const [first, ...rest] = path8;
+function getNestedValue(obj, path9) {
+  const [first, ...rest] = path9;
   if (!first || !(first in obj)) {
     return void 0;
   }
@@ -16991,8 +17627,8 @@ function getNestedValue(obj, path8) {
   return void 0;
 }
 __name(getNestedValue, "getNestedValue");
-function getNestedProperty(obj, path8) {
-  return getNestedValue(obj, path8.split("."));
+function getNestedProperty(obj, path9) {
+  return getNestedValue(obj, path9.split("."));
 }
 __name(getNestedProperty, "getNestedProperty");
 function getEffectiveValue(key, settings, mergedSettings) {
@@ -17000,12 +17636,12 @@ function getEffectiveValue(key, settings, mergedSettings) {
   if (!definition) {
     return void 0;
   }
-  const path8 = key.split(".");
-  let value = getNestedValue(settings, path8);
+  const path9 = key.split(".");
+  let value = getNestedValue(settings, path9);
   if (value !== void 0) {
     return value;
   }
-  value = getNestedValue(mergedSettings, path8);
+  value = getNestedValue(mergedSettings, path9);
   if (value !== void 0) {
     return value;
   }
@@ -17056,8 +17692,8 @@ function getDialogSettingKeys() {
 }
 __name(getDialogSettingKeys, "getDialogSettingKeys");
 function settingExistsInScope(key, scopeSettings) {
-  const path8 = key.split(".");
-  const value = getNestedValue(scopeSettings, path8);
+  const path9 = key.split(".");
+  const value = getNestedValue(scopeSettings, path9);
   return value !== void 0;
 }
 __name(settingExistsInScope, "settingExistsInScope");
@@ -17070,8 +17706,8 @@ function pathHasUnsafeSegment(keys) {
   return false;
 }
 __name(pathHasUnsafeSegment, "pathHasUnsafeSegment");
-function setNestedPropertyForce(obj, path8, value) {
-  const keys = path8.split(".");
+function setNestedPropertyForce(obj, path9, value) {
+  const keys = path9.split(".");
   if (pathHasUnsafeSegment(keys)) return;
   const lastKey = keys.pop();
   if (!lastKey) return;
@@ -17085,8 +17721,8 @@ function setNestedPropertyForce(obj, path8, value) {
   current[lastKey] = value;
 }
 __name(setNestedPropertyForce, "setNestedPropertyForce");
-function setNestedPropertySafe(obj, path8, value) {
-  const keys = path8.split(".");
+function setNestedPropertySafe(obj, path9, value) {
+  const keys = path9.split(".");
   if (pathHasUnsafeSegment(keys)) return;
   const lastKey = keys.pop();
   if (!lastKey) return;
@@ -17105,8 +17741,8 @@ function setNestedPropertySafe(obj, path8, value) {
   current[lastKey] = value;
 }
 __name(setNestedPropertySafe, "setNestedPropertySafe");
-function deleteNestedPropertySafe(obj, path8) {
-  const keys = path8.split(".");
+function deleteNestedPropertySafe(obj, path9) {
+  const keys = path9.split(".");
   const lastKey = keys.pop();
   if (!lastKey) return;
   let current = obj;
@@ -17138,10 +17774,10 @@ function getRestartRequiredFromModified(modifiedSettings) {
 __name(getRestartRequiredFromModified, "getRestartRequiredFromModified");
 function saveModifiedSettings(modifiedSettings, pendingSettings, loadedSettings, scope) {
   modifiedSettings.forEach((settingKey) => {
-    const path8 = settingKey.split(".");
+    const path9 = settingKey.split(".");
     const value = getNestedValue(
       pendingSettings,
-      path8
+      path9
     );
     const existsInOriginalFile = settingExistsInScope(
       settingKey,
@@ -17243,12 +17879,12 @@ function isPlainObject(item) {
   return !!item && typeof item === "object" && !Array.isArray(item);
 }
 __name(isPlainObject, "isPlainObject");
-function mergeRecursively(target, source, getMergeStrategyForPath2, path8 = []) {
+function mergeRecursively(target, source, getMergeStrategyForPath2, path9 = []) {
   for (const key of Object.keys(source)) {
     if (key === "__proto__" || key === "constructor" || key === "prototype") {
       continue;
     }
-    const newPath = [...path8, key];
+    const newPath = [...path9, key];
     const srcValue = source[key];
     const objValue = target[key];
     const mergeStrategy = getMergeStrategyForPath2(newPath);
@@ -18093,10 +18729,10 @@ __name(needsMigration, "needsMigration");
 
 // packages/cli/src/config/settings.ts
 var debugLogger3 = createDebugLogger("SETTINGS");
-function getMergeStrategyForPath(path8) {
+function getMergeStrategyForPath(path9) {
   let current = void 0;
   let currentSchema = getSettingsSchema();
-  for (const key of path8) {
+  for (const key of path9) {
     if (!currentSchema || !currentSchema[key]) {
       return void 0;
     }
@@ -18112,7 +18748,7 @@ function getUserSettingsPath() {
 }
 __name(getUserSettingsPath, "getUserSettingsPath");
 function getUserSettingsDir() {
-  return path3.dirname(getUserSettingsPath());
+  return path4.dirname(getUserSettingsPath());
 }
 __name(getUserSettingsDir, "getUserSettingsDir");
 var DEFAULT_EXCLUDED_ENV_VARS = ["DEBUG", "DEBUG_MODE"];
@@ -18124,6 +18760,30 @@ var PROJECT_ENV_HARDCODED_EXCLUSIONS = [
   ENV_CORRUPTED_PATH,
   ENV_WAS_RECOVERED
 ];
+var RELOAD_EXCLUDED_KEYS = /* @__PURE__ */ new Set([
+  ...PROJECT_ENV_HARDCODED_EXCLUSIONS,
+  "QWEN_SERVER_TOKEN",
+  "QWEN_CLI_ENTRY",
+  "NODE_OPTIONS",
+  "NODE_PATH",
+  "NODE_TLS_REJECT_UNAUTHORIZED",
+  "LD_PRELOAD",
+  "LD_AUDIT",
+  "LD_LIBRARY_PATH",
+  "DYLD_INSERT_LIBRARIES",
+  "DYLD_LIBRARY_PATH",
+  "BASH_ENV",
+  "ENV",
+  "PATH",
+  "HOME",
+  "TMPDIR",
+  "TMP",
+  "TEMP"
+]);
+var dotEnvSourcedKeys = /* @__PURE__ */ new Set();
+var settingsEnvSourcedKeys = /* @__PURE__ */ new Set();
+var lastReloadSnapshot = /* @__PURE__ */ new Map();
+var lastReloadSnapshotSeeded = false;
 var SETTINGS_VERSION = 4;
 var SETTINGS_VERSION_KEY = "$version";
 function getSystemSettingsPath() {
@@ -18143,8 +18803,8 @@ function getSystemDefaultsPath() {
   if (process2.env["QWEN_CODE_SYSTEM_DEFAULTS_PATH"]) {
     return process2.env["QWEN_CODE_SYSTEM_DEFAULTS_PATH"];
   }
-  return path3.join(
-    path3.dirname(getSystemSettingsPath()),
+  return path4.join(
+    path4.dirname(getSystemSettingsPath()),
     "system-defaults.json"
   );
 }
@@ -18404,10 +19064,10 @@ function getUserLevelEnvPaths() {
   const homeDir = homedir();
   const globalQwenDir = Storage.getGlobalQwenDir();
   const paths = /* @__PURE__ */ new Set([
-    path3.normalize(path3.join(homeDir, ".env")),
-    path3.normalize(path3.join(globalQwenDir, ".env"))
+    path4.normalize(path4.join(homeDir, ".env")),
+    path4.normalize(path4.join(globalQwenDir, ".env"))
   ]);
-  const legacyQwenEnv = path3.normalize(path3.join(homeDir, QWEN_DIR, ".env"));
+  const legacyQwenEnv = path4.normalize(path4.join(homeDir, QWEN_DIR, ".env"));
   paths.add(legacyQwenEnv);
   return paths;
 }
@@ -18423,9 +19083,9 @@ function preResolveHomeEnvOverrides() {
   }
   const initialQwenHome = process2.env["QWEN_HOME"];
   const initialQwenDir = Storage.getGlobalQwenDir();
-  const candidates = [path3.join(initialQwenDir, ".env")];
+  const candidates = [path4.join(initialQwenDir, ".env")];
   if (!initialQwenHome) {
-    candidates.push(path3.join(path3.dirname(initialQwenDir), ".env"));
+    candidates.push(path4.join(path4.dirname(initialQwenDir), ".env"));
   }
   for (const candidate of candidates) {
     readHomeEnvInto(candidate);
@@ -18434,7 +19094,7 @@ function preResolveHomeEnvOverrides() {
   if (discoveredQwenHome && discoveredQwenHome !== initialQwenHome) {
     const discoveredDir = Storage.getGlobalQwenDir();
     if (discoveredDir !== initialQwenDir) {
-      readHomeEnvInto(path3.join(discoveredDir, ".env"));
+      readHomeEnvInto(path4.join(discoveredDir, ".env"));
     }
   }
 }
@@ -18456,9 +19116,9 @@ function readHomeEnvInto(file) {
 __name(readHomeEnvInto, "readHomeEnvInto");
 function getHomeEnvFallbackVars() {
   const globalQwenDir = Storage.getGlobalQwenDir();
-  const candidates = [path3.join(globalQwenDir, ".env")];
+  const candidates = [path4.join(globalQwenDir, ".env")];
   if (!process2.env["QWEN_HOME"]) {
-    candidates.push(path3.join(path3.dirname(globalQwenDir), ".env"));
+    candidates.push(path4.join(path4.dirname(globalQwenDir), ".env"));
   }
   const result = {};
   for (const candidate of candidates) {
@@ -18494,13 +19154,13 @@ function detectQwenHomeRedirectWithoutMigration(activeUserSettingsPath) {
   } finally {
     process2.env["QWEN_HOME"] = savedQwenHome;
   }
-  if (path3.resolve(activeQwenDir) === path3.resolve(legacyQwenDir)) {
+  if (path4.resolve(activeQwenDir) === path4.resolve(legacyQwenDir)) {
     return null;
   }
   if (fs6.existsSync(activeUserSettingsPath)) {
     return null;
   }
-  const legacyUserSettings = path3.join(legacyQwenDir, "settings.json");
+  const legacyUserSettings = path4.join(legacyQwenDir, "settings.json");
   if (!fs6.existsSync(legacyUserSettings)) {
     return null;
   }
@@ -18511,15 +19171,15 @@ function findEnvFile(settings, startDir, userLevelPaths = getUserLevelEnvPaths()
   const homeDir = homedir();
   const isTrusted = isWorkspaceTrusted(settings).isTrusted;
   const globalQwenDir = Storage.getGlobalQwenDir();
-  const legacyQwenDir = path3.normalize(path3.join(homeDir, QWEN_DIR));
-  const hasCustomConfigDir = path3.normalize(globalQwenDir) !== legacyQwenDir;
-  const canUseEnvFile = /* @__PURE__ */ __name((filePath) => isTrusted !== false || userLevelPaths.has(path3.normalize(filePath)), "canUseEnvFile");
+  const legacyQwenDir = path4.normalize(path4.join(homeDir, QWEN_DIR));
+  const hasCustomConfigDir = path4.normalize(globalQwenDir) !== legacyQwenDir;
+  const canUseEnvFile = /* @__PURE__ */ __name((filePath) => isTrusted !== false || userLevelPaths.has(path4.normalize(filePath)), "canUseEnvFile");
   const findHomeCandidate = /* @__PURE__ */ __name(() => {
-    const candidates = [path3.join(globalQwenDir, ".env")];
+    const candidates = [path4.join(globalQwenDir, ".env")];
     if (hasCustomConfigDir) {
-      candidates.push(path3.join(legacyQwenDir, ".env"));
+      candidates.push(path4.join(legacyQwenDir, ".env"));
     }
-    candidates.push(path3.join(homeDir, ".env"));
+    candidates.push(path4.join(homeDir, ".env"));
     for (const candidate of candidates) {
       if (fs6.existsSync(candidate) && canUseEnvFile(candidate)) {
         return candidate;
@@ -18527,7 +19187,7 @@ function findEnvFile(settings, startDir, userLevelPaths = getUserLevelEnvPaths()
     }
     return null;
   }, "findHomeCandidate");
-  let currentDir = path3.resolve(startDir);
+  let currentDir = path4.resolve(startDir);
   let visitedHomeDir = false;
   while (true) {
     if (currentDir === homeDir) {
@@ -18535,16 +19195,16 @@ function findEnvFile(settings, startDir, userLevelPaths = getUserLevelEnvPaths()
       const found = findHomeCandidate();
       if (found) return found;
     } else {
-      const geminiEnvPath = path3.join(currentDir, QWEN_DIR, ".env");
+      const geminiEnvPath = path4.join(currentDir, QWEN_DIR, ".env");
       if (fs6.existsSync(geminiEnvPath) && canUseEnvFile(geminiEnvPath)) {
         return geminiEnvPath;
       }
-      const envPath = path3.join(currentDir, ".env");
+      const envPath = path4.join(currentDir, ".env");
       if (fs6.existsSync(envPath) && canUseEnvFile(envPath)) {
         return envPath;
       }
     }
-    const parentDir = path3.dirname(currentDir);
+    const parentDir = path4.dirname(currentDir);
     if (parentDir === currentDir || !parentDir) {
       return visitedHomeDir ? null : findHomeCandidate();
     }
@@ -18577,9 +19237,9 @@ function loadEnvironment(settings) {
       const envFileContent = fs6.readFileSync(envFilePath, "utf-8");
       const parsedEnv = dotenv.parse(envFileContent);
       const excludedVars = settings?.advanced?.excludedEnvVars || DEFAULT_EXCLUDED_ENV_VARS;
-      const normalizedEnvFilePath = path3.normalize(envFilePath);
+      const normalizedEnvFilePath = path4.normalize(envFilePath);
       const isHomeScopedEnvFile = userLevelPaths.has(normalizedEnvFilePath);
-      const isQwenScopedEnvFile = isHomeScopedEnvFile || path3.basename(path3.dirname(normalizedEnvFilePath)) === QWEN_DIR;
+      const isQwenScopedEnvFile = isHomeScopedEnvFile || path4.basename(path4.dirname(normalizedEnvFilePath)) === QWEN_DIR;
       for (const key in parsedEnv) {
         if (Object.hasOwn(parsedEnv, key)) {
           if (!isHomeScopedEnvFile && PROJECT_ENV_HARDCODED_EXCLUSIONS.includes(key)) {
@@ -18590,6 +19250,10 @@ function loadEnvironment(settings) {
           }
           if (!Object.hasOwn(process2.env, key)) {
             process2.env[key] = parsedEnv[key];
+            dotEnvSourcedKeys.add(key);
+          }
+          if (!lastReloadSnapshotSeeded) {
+            lastReloadSnapshot.set(key, parsedEnv[key]);
           }
         }
       }
@@ -18603,13 +19267,110 @@ function loadEnvironment(settings) {
       }
       if (!Object.hasOwn(process2.env, key) && typeof value === "string") {
         process2.env[key] = value;
+        settingsEnvSourcedKeys.add(key);
+      }
+      if (!lastReloadSnapshotSeeded && typeof value === "string" && !lastReloadSnapshot.has(key)) {
+        lastReloadSnapshot.set(key, value);
       }
     }
   }
+  lastReloadSnapshotSeeded = true;
 }
 __name(loadEnvironment, "loadEnvironment");
+function reloadEnvironment(settings, workspaceCwd) {
+  const userLevelPaths = getUserLevelEnvPaths();
+  const envFilePath = findEnvFile(settings, workspaceCwd, userLevelPaths);
+  if (process2.env["CLOUD_SHELL"] === "true") {
+    setUpCloudShellEnvironment(envFilePath);
+  }
+  let dotEnvReadFailed = false;
+  const newDotEnvKeys = /* @__PURE__ */ new Map();
+  const newSettingsEnvKeys = /* @__PURE__ */ new Map();
+  if (envFilePath) {
+    try {
+      const envFileContent = fs6.readFileSync(envFilePath, "utf-8");
+      const parsedEnv = dotenv.parse(envFileContent);
+      const excludedVars = settings?.advanced?.excludedEnvVars || DEFAULT_EXCLUDED_ENV_VARS;
+      const normalizedEnvFilePath = path4.normalize(envFilePath);
+      const isHomeScopedEnvFile = userLevelPaths.has(normalizedEnvFilePath);
+      const isQwenScopedEnvFile = isHomeScopedEnvFile || path4.basename(path4.dirname(normalizedEnvFilePath)) === QWEN_DIR;
+      for (const key in parsedEnv) {
+        if (!Object.hasOwn(parsedEnv, key)) continue;
+        if (RELOAD_EXCLUDED_KEYS.has(key)) continue;
+        if (!isHomeScopedEnvFile && PROJECT_ENV_HARDCODED_EXCLUSIONS.includes(key)) {
+          continue;
+        }
+        if (!isQwenScopedEnvFile && excludedVars.includes(key)) continue;
+        newDotEnvKeys.set(key, parsedEnv[key]);
+      }
+    } catch {
+      dotEnvReadFailed = true;
+    }
+  }
+  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 (typeof value !== "string") continue;
+      if (newDotEnvKeys.has(key)) continue;
+      if (dotEnvReadFailed && lastReloadSnapshot.has(key)) continue;
+      newSettingsEnvKeys.set(key, value);
+    }
+  }
+  const allNewKeys = /* @__PURE__ */ new Set([
+    ...newDotEnvKeys.keys(),
+    ...newSettingsEnvKeys.keys()
+  ]);
+  const updatedKeys = [];
+  const removedKeys = [];
+  if (!dotEnvReadFailed) {
+    const previouslyKnown = /* @__PURE__ */ new Set([
+      ...lastReloadSnapshot.keys(),
+      ...dotEnvSourcedKeys,
+      ...settingsEnvSourcedKeys
+    ]);
+    for (const key of previouslyKnown) {
+      if (!allNewKeys.has(key) && !RELOAD_EXCLUDED_KEYS.has(key)) {
+        delete process2.env[key];
+        removedKeys.push(key);
+      }
+    }
+  }
+  for (const [key, value] of newDotEnvKeys) {
+    if (process2.env[key] !== value) {
+      updatedKeys.push(key);
+    }
+    process2.env[key] = value;
+  }
+  for (const [key, value] of newSettingsEnvKeys) {
+    if (process2.env[key] !== value) {
+      updatedKeys.push(key);
+    }
+    process2.env[key] = value;
+  }
+  if (!dotEnvReadFailed) {
+    dotEnvSourcedKeys.clear();
+    for (const key of newDotEnvKeys.keys()) {
+      dotEnvSourcedKeys.add(key);
+    }
+    lastReloadSnapshot.clear();
+    for (const [key, value] of newDotEnvKeys) {
+      lastReloadSnapshot.set(key, value);
+    }
+    for (const [key, value] of newSettingsEnvKeys) {
+      lastReloadSnapshot.set(key, value);
+    }
+  }
+  settingsEnvSourcedKeys.clear();
+  for (const key of newSettingsEnvKeys.keys()) {
+    settingsEnvSourcedKeys.add(key);
+  }
+  return { updatedKeys, removedKeys };
+}
+__name(reloadEnvironment, "reloadEnvironment");
 var CORRUPTED_SUFFIX = ".corrupted";
 function loadSettings(workspaceDir = process2.cwd(), consumeCorruptionEnvVars = true) {
+  const opts = typeof consumeCorruptionEnvVars === "object" ? consumeCorruptionEnvVars : { consumeCorruptionEnvVars };
   preResolveHomeEnvOverrides();
   const userSettingsPath = getUserSettingsPath();
   const qwenHomeRedirectWarning = detectQwenHomeRedirectWithoutMigration(userSettingsPath);
@@ -18621,8 +19382,8 @@ function loadSettings(workspaceDir = process2.cwd(), consumeCorruptionEnvVars =
   const systemSettingsPath = getSystemSettingsPath();
   const systemDefaultsPath = getSystemDefaultsPath();
   const migratedInMemorScopes = /* @__PURE__ */ new Set();
-  const resolvedWorkspaceDir = path3.resolve(workspaceDir);
-  const resolvedHomeDir = path3.resolve(homedir());
+  const resolvedWorkspaceDir = path4.resolve(workspaceDir);
+  const resolvedHomeDir = path4.resolve(homedir());
   let realWorkspaceDir = resolvedWorkspaceDir;
   try {
     realWorkspaceDir = fs6.realpathSync(resolvedWorkspaceDir);
@@ -18692,7 +19453,7 @@ function loadSettings(workspaceDir = process2.cwd(), consumeCorruptionEnvVars =
           }
         }
         const envCorruptedPath = process2.env[ENV_CORRUPTED_PATH];
-        if (consumeCorruptionEnvVars && envCorruptedPath && envCorruptedPath === corruptedPath && scope === "User" /* User */) {
+        if ((opts.consumeCorruptionEnvVars ?? true) && envCorruptedPath && envCorruptedPath === corruptedPath && scope === "User" /* User */) {
           corruptedSaved = true;
           recoveredFromEnvVar = process2.env[ENV_WAS_RECOVERED] === "1";
           delete process2.env[ENV_CORRUPTED_PATH];
@@ -18823,7 +19584,9 @@ function loadSettings(workspaceDir = process2.cwd(), consumeCorruptionEnvVars =
     workspaceSettings,
     isTrusted
   );
-  loadEnvironment(tempMergedSettings);
+  if (!opts.skipLoadEnvironment) {
+    loadEnvironment(tempMergedSettings);
+  }
   if (settingsErrors.length > 0) {
     const errorMessages = settingsErrors.map(
       (error) => `Error in ${error.path}: ${error.message}`
@@ -18881,7 +19644,7 @@ function createSettingsUpdate(key, value) {
 __name(createSettingsUpdate, "createSettingsUpdate");
 function saveSettings(settingsFile, updates = settingsFile.originalSettings, replacePath = []) {
   try {
-    const dirPath = path3.dirname(settingsFile.path);
+    const dirPath = path4.dirname(settingsFile.path);
     if (!fs6.existsSync(dirPath)) {
       fs6.mkdirSync(dirPath, { recursive: true });
     }
@@ -18912,26 +19675,26 @@ init_esbuild_shims();
 
 // node_modules/read-package-up/index.js
 init_esbuild_shims();
-import path6 from "node:path";
+import path7 from "node:path";
 
 // node_modules/find-up-simple/index.js
 init_esbuild_shims();
 import process3 from "node:process";
 import fsPromises from "node:fs/promises";
 import { fileURLToPath } from "node:url";
-import path4 from "node:path";
+import path5 from "node:path";
 var toPath = /* @__PURE__ */ __name((urlOrPath) => urlOrPath instanceof URL ? fileURLToPath(urlOrPath) : urlOrPath, "toPath");
 async function findUp(name, {
   cwd = process3.cwd(),
   type = "file",
   stopAt
 } = {}) {
-  let directory = path4.resolve(toPath(cwd) ?? "");
-  const { root } = path4.parse(directory);
-  stopAt = path4.resolve(directory, toPath(stopAt ?? root));
-  const isAbsoluteName = path4.isAbsolute(name);
+  let directory = path5.resolve(toPath(cwd) ?? "");
+  const { root } = path5.parse(directory);
+  stopAt = path5.resolve(directory, toPath(stopAt ?? root));
+  const isAbsoluteName = path5.isAbsolute(name);
   while (directory) {
-    const filePath = isAbsoluteName ? name : path4.join(directory, name);
+    const filePath = isAbsoluteName ? name : path5.join(directory, name);
     try {
       const stats = await fsPromises.stat(filePath);
       if (type === "file" && stats.isFile() || type === "directory" && stats.isDirectory()) {
@@ -18942,7 +19705,7 @@ async function findUp(name, {
     if (directory === stopAt || directory === root) {
       break;
     }
-    directory = path4.dirname(directory);
+    directory = path5.dirname(directory);
   }
 }
 __name(findUp, "findUp");
@@ -18950,7 +19713,7 @@ __name(findUp, "findUp");
 // node_modules/read-pkg/index.js
 init_esbuild_shims();
 import fsPromises2 from "node:fs/promises";
-import path5 from "node:path";
+import path6 from "node:path";
 
 // node_modules/parse-json/index.js
 init_esbuild_shims();
@@ -19089,7 +19852,7 @@ function toPath2(urlOrPath) {
 __name(toPath2, "toPath");
 
 // node_modules/read-pkg/index.js
-var getPackagePath = /* @__PURE__ */ __name((cwd) => path5.resolve(toPath2(cwd) ?? ".", "package.json"), "getPackagePath");
+var getPackagePath = /* @__PURE__ */ __name((cwd) => path6.resolve(toPath2(cwd) ?? ".", "package.json"), "getPackagePath");
 var _readPackage = /* @__PURE__ */ __name((file, normalize3) => {
   const json = typeof file === "string" ? parseJson(file) : file;
   if (normalize3) {
@@ -19110,7 +19873,7 @@ async function readPackageUp(options) {
     return;
   }
   return {
-    packageJson: await readPackage({ ...options, cwd: path6.dirname(filePath) }),
+    packageJson: await readPackage({ ...options, cwd: path7.dirname(filePath) }),
     path: filePath
   };
 }
@@ -19118,9 +19881,9 @@ __name(readPackageUp, "readPackageUp");
 
 // packages/cli/src/utils/package.ts
 import { fileURLToPath as fileURLToPath3 } from "node:url";
-import path7 from "node:path";
+import path8 from "node:path";
 var __filename = fileURLToPath3(import.meta.url);
-var __dirname = path7.dirname(__filename);
+var __dirname = path8.dirname(__filename);
 var packageJson;
 async function getPackageJson() {
   if (packageJson) {
@@ -19138,16 +19901,10 @@ __name(getPackageJson, "getPackageJson");
 // packages/cli/src/utils/version.ts
 async function getCliVersion() {
   const pkgJson = await getPackageJson();
-  return "0.18.0-preview.2";
+  return "0.18.0";
 }
 __name(getCliVersion, "getCliVersion");
 
-// packages/cli/src/utils/systemInfo.ts
-init_esbuild_shims();
-import process4 from "node:process";
-import os from "node:os";
-import { execFile } from "node:child_process";
-
 // packages/cli/src/ui/utils/formatters.ts
 init_esbuild_shims();
 var formatMemoryUsage = /* @__PURE__ */ __name((bytes) => {
@@ -19231,25 +19988,86 @@ var formatDuration = /* @__PURE__ */ __name((milliseconds, options) => {
   return parts.join(" ");
 }, "formatDuration");
 
+// packages/cli/src/config/loadedSettingsAdapter.ts
+init_esbuild_shims();
+function createLoadedSettingsAdapter(settings, scope) {
+  const persistScope = scope ?? getPersistScopeForModelSelection(settings);
+  const settingsFile = settings.forScope(persistScope);
+  let settingsSnapshot = null;
+  let originalSnapshot = null;
+  return {
+    getValue(key) {
+      return getNestedProperty(settings.merged, key);
+    },
+    setValue(key, value) {
+      for (const part of key.split(".")) {
+        if (part === "__proto__" || part === "constructor" || part === "prototype") {
+          throw new Error(
+            `Refusing to write settings key with reserved segment: ${key}`
+          );
+        }
+      }
+      settings.setValue(persistScope, key, value);
+    },
+    getModelProviders() {
+      return settings.merged.modelProviders ?? {};
+    },
+    persist() {
+    },
+    backup() {
+      backupSettingsFile(settingsFile.path);
+      settingsSnapshot = structuredClone(settingsFile.settings);
+      originalSnapshot = structuredClone(settingsFile.originalSettings);
+    },
+    restore() {
+      const restored = restoreSettingsFromBackup(settingsFile.path);
+      if (!restored) {
+        console.error(
+          `[loadedSettingsAdapter] On-disk rollback of ${settingsFile.path} failed; in-memory state was restored but the file may be inconsistent. Re-run /auth or inspect the file directly to recover.`
+        );
+      }
+      if (settingsSnapshot !== null) {
+        settingsFile.settings = settingsSnapshot;
+      }
+      if (originalSnapshot !== null) {
+        settingsFile.originalSettings = originalSnapshot;
+      }
+      settings.recomputeMerged();
+    },
+    cleanupBackup() {
+      cleanupSettingsBackup(settingsFile.path);
+      settingsSnapshot = null;
+      originalSnapshot = null;
+    }
+  };
+}
+__name(createLoadedSettingsAdapter, "createLoadedSettingsAdapter");
+
+// packages/cli/src/utils/systemInfo.ts
+init_esbuild_shims();
+import process4 from "node:process";
+import os from "node:os";
+import { execFile } from "node:child_process";
+
 // packages/cli/src/generated/git-commit.ts
 init_esbuild_shims();
-var GIT_COMMIT_INFO = "c78b0394e";
+var GIT_COMMIT_INFO = "a7b8a3655";
 
 // packages/cli/src/utils/systemInfo.ts
 var debugLogger4 = createDebugLogger("STATUS");
 var VERSION_PROBE_TIMEOUT_MS = 5e3;
 function probeVersion(binary) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     execFile(
       binary,
       ["--version"],
       { timeout: VERSION_PROBE_TIMEOUT_MS, encoding: "utf-8" },
       (err, stdout) => {
         if (err) {
-          resolve2("unknown");
+          resolve3("unknown");
           return;
         }
-        resolve2(typeof stdout === "string" ? stdout.trim() : "unknown");
+        resolve3(typeof stdout === "string" ? stdout.trim() : "unknown");
       }
     );
   });
@@ -19387,6 +20205,9 @@ __name(formatLspStatusSnapshot, "formatLspStatusSnapshot");
 
 export {
   require_strip_json_comments,
+  resolveColor,
+  subtleBandColor,
+  supportsTrueColor,
   lightTheme,
   darkTheme,
   ansiTheme,
@@ -19396,13 +20217,16 @@ export {
   DefaultLight,
   DefaultDark,
   loadTrustedFolders,
+  isFolderTrustEnabled,
   isWorkspaceTrusted,
   getPersistScopeForModelSelection,
   TOGGLE_TYPES,
   OUTPUT_LANGUAGE_AUTO,
   isAutoLanguage,
   resolveOutputLanguage,
+  getOutputLanguageFilePath,
   updateOutputLanguageFile,
+  writeOutputLanguageAndRegisterPath,
   initializeLlmOutputLanguage,
   getSettingDefinition,
   requiresRestart,
@@ -19418,9 +20242,6 @@ export {
   saveModifiedSettings,
   getDisplayValue,
   isDefaultValue,
-  backupSettingsFile,
-  restoreSettingsFromBackup,
-  cleanupSettingsBackup,
   SETTINGS_DIRECTORY_NAME,
   getUserSettingsDir,
   ENV_CORRUPTED_PATH,
@@ -19430,6 +20251,7 @@ export {
   createMinimalSettings,
   preResolveHomeEnvOverrides,
   loadEnvironment,
+  reloadEnvironment,
   CORRUPTED_SUFFIX,
   loadSettings,
   require_debug,
@@ -19447,6 +20269,30 @@ export {
   DEFAULT_RING_SIZE,
   SubscriberLimitExceededError,
   EventBus,
+  canonicalizeWorkspace,
+  MAX_WORKSPACE_PATH_LENGTH,
+  NOT_CURRENTLY_GENERATING_CANCEL_MESSAGE,
+  isNotCurrentlyGeneratingCancelError,
+  SessionNotFoundError,
+  RestoreInProgressError,
+  InvalidSessionScopeError,
+  SessionLimitExceededError,
+  WorkspaceMismatchError,
+  InvalidClientIdError,
+  InvalidPermissionOptionError,
+  InvalidSessionMetadataError,
+  PermissionPolicyNotImplementedError,
+  CancelSentinelCollisionError,
+  PermissionForbiddenError,
+  WorkspaceInitConflictError,
+  WorkspaceInitPathEscapeError,
+  WorkspaceInitSymlinkError,
+  WorkspaceInitRaceError,
+  McpServerNotFoundError,
+  McpServerRestartFailedError,
+  SessionBusyError,
+  InvalidRewindTargetError,
+  BranchWhilePromptActiveError,
   STATUS_SCHEMA_VERSION,
   SERVE_ERROR_KINDS,
   BridgeTimeoutError,
@@ -19454,6 +20300,9 @@ export {
   MissingCliEntryError,
   SERVE_STATUS_EXT_METHODS,
   SERVE_CONTROL_EXT_METHODS,
+  IDLE_HOOK_EVENTS,
+  createIdleWorkspaceExtensionsStatus,
+  createIdleWorkspaceHooksStatus,
   createIdleWorkspaceMemoryStatus,
   createIdleWorkspaceMcpStatus,
   createIdleWorkspaceSkillsStatus,
@@ -19468,7 +20317,8 @@ export {
   formatDuration,
   getNpmVersion,
   getGitVersion,
-  getExtendedSystemInfo
+  getExtendedSystemInfo,
+  createLoadedSettingsAdapter
 };
 /**
  * @license
@@ -19485,6 +20335,18 @@ export {
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Adapter that lets core's `applyProviderInstallPlan` write through
+ * `LoadedSettings` while preserving CLI-specific guarantees:
+ * - scope resolution via `getPersistScopeForModelSelection`
+ * - on-disk `.orig` backup of the target settings file
+ * - in-memory snapshot of `settings` / `originalSettings` for rollback
+ * - merged-settings recomputation after restore
+ */
 /**
  * @license
  * Copyright 2026 Google LLC