@mmmbuto/qwen-code-termux 0.16.1-termux → 0.18.0-termux

package/chunks/{chunk-2LA2TREA.js → chunk-3AA2DK35.js}

@@ -6,26 +6,31 @@ import {
   getLanguageSettingsOptions,
   t,
   writeStderrLine
-} from "./chunk-DQ4QTG7E.js";
+} from "./chunk-VV4F63BD.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-3OCRHZA3.js";
+} from "./chunk-TD4OPI4T.js";
 import {
-  isWithinRoot
-} from "./chunk-K6O2NBMF.js";
+  isWithinRoot,
+  stripRuntimeSnapshotPrefix
+} from "./chunk-OQ7NJIY7.js";
+import {
+  atomicWriteFileSync
+} from "./chunk-B7HXHOHU.js";
 import {
   FatalConfigError,
   QWEN_DIR,
   Storage,
   createDebugLogger,
   getErrorMessage
-} from "./chunk-XP27SJMH.js";
+} from "./chunk-HR7SV7AY.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -11997,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"),
@@ -12018,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) => {
@@ -12044,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);
@@ -12069,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);
@@ -12093,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"),
@@ -12129,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"),
@@ -12323,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;
       }
@@ -12420,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);
@@ -12461,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;
@@ -13118,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");
@@ -13130,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");
@@ -13141,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;
@@ -13154,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
@@ -13165,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;
@@ -13243,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(() => {
@@ -13289,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() {
@@ -13392,13 +13466,320 @@ 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;
@@ -13411,10 +13792,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 {
@@ -13423,7 +13811,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;
@@ -13453,18 +13841,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,
@@ -13585,7 +14078,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";
@@ -13611,7 +14104,7 @@ function resolveOutputLanguage(value) {
 }
 __name(resolveOutputLanguage, "resolveOutputLanguage");
 function getOutputLanguageFilePath() {
-  return path.join(
+  return path2.join(
     Storage.getGlobalQwenDir(),
     LLM_OUTPUT_LANGUAGE_RULE_FILENAME
   );
@@ -13674,19 +14167,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) {
@@ -13701,7 +14202,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);
@@ -13894,6 +14395,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 = {
@@ -14512,14 +15096,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 {
@@ -14531,8 +15115,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
     }));
   }
@@ -14552,7 +15136,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);
@@ -14567,14 +15151,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);
   }
 };
@@ -14614,14 +15198,20 @@ 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 });
     }
-    fs2.writeFileSync(
+    atomicWriteFileSync(
       trustedFoldersFile.path,
       JSON.stringify(trustedFoldersFile.config, null, 2),
-      { encoding: "utf-8", mode: 384 }
+      // noFollow: refuse to follow any pre-placed symlink at the
+      // config path — a redirected write could either leak the
+      // trusted-folder list to an attacker target or leave the user's
+      // real config silently stale. Matches the credential write
+      // sites' security posture (sharedTokenManager, oauth-token-storage,
+      // file-token-storage all use noFollow:true).
+      { encoding: "utf-8", mode: 384, forceMode: true, noFollow: true }
     );
   } catch (error) {
     writeStderrLine("Error saving trusted folders file.");
@@ -14902,6 +15492,18 @@ var SETTINGS_SCHEMA = {
         description: "How many minutes the terminal must be blurred before an auto-recap fires on the next focus-in. Matches Claude Code's default of 5 minutes; raise if you briefly alt-tab and do not want recaps to pile up.",
         showInDialog: true
       },
+      cleanupPeriodDays: {
+        type: "number",
+        label: "Cleanup Period (days)",
+        category: "General",
+        // LoadedSettings._merged is cached without verified setValue→recompute
+        // paths in all UI flows. Mark restart-required so users aren't
+        // surprised when a mid-session edit doesn't take effect immediately.
+        requiresRestart: true,
+        default: 30,
+        description: "Number of days to retain ~/.qwen/file-history/ session backups used by /rewind. Backups older than this are removed by a background housekeeping pass that runs at most once per day. Set to 0 for minimum retention (~1 hour) \u2014 protects sessions touched in the last hour, plus the currently active session. Other persistent caches will honor the same setting in the future.",
+        showInDialog: true
+      },
       gitCoAuthor: {
         type: "object",
         label: "Attribution",
@@ -14942,26 +15544,6 @@ var SETTINGS_SCHEMA = {
           }
         }
       },
-      checkpointing: {
-        type: "object",
-        label: "Checkpointing",
-        category: "General",
-        requiresRestart: true,
-        default: {},
-        description: "Session checkpointing settings.",
-        showInDialog: false,
-        properties: {
-          enabled: {
-            type: "boolean",
-            label: "Enable Checkpointing",
-            category: "General",
-            requiresRestart: true,
-            default: false,
-            description: "Enable session checkpointing for recovery",
-            showInDialog: false
-          }
-        }
-      },
       debugKeystrokeLogging: {
         type: "boolean",
         label: "Debug Keystroke Logging",
@@ -15008,6 +15590,18 @@ var SETTINGS_SCHEMA = {
         description: "Play terminal bell sound when response completes or needs approval.",
         showInDialog: true
       },
+      preventSystemSleep: {
+        type: "boolean",
+        label: "Prevent System Sleep While Running",
+        category: "General",
+        // Read once at startup via Config.preventSystemSleep (a readonly field
+        // captured in loadCliConfig), so a runtime toggle only takes effect
+        // after restart.
+        requiresRestart: true,
+        default: true,
+        description: "Prevent the system from sleeping while Qwen Code is streaming a model response or executing tools. Idle prompt time and permission prompts do not inhibit sleep.",
+        showInDialog: true
+      },
       chatRecording: {
         type: "boolean",
         label: "Chat Recording",
@@ -15118,7 +15712,7 @@ var SETTINGS_SCHEMA = {
         category: "UI",
         requiresRestart: false,
         default: void 0,
-        description: 'Status line display configuration. Use `type: "preset"` with built-in item ids, or `type: "command"` with a shell command. Optional command `refreshInterval` (seconds, >= 1) re-runs the command on a timer so external data stays fresh.',
+        description: 'Status line display configuration. Use `type: "preset"` with built-in item ids, or `type: "command"` with a shell command. Optional command `refreshInterval` (seconds, >= 1) re-runs the command on a timer so external data stays fresh. Set `respectUserColors: true` to preserve ANSI color codes in command output instead of applying dim/theme styling. Set `hideContextIndicator: true` to hide the built-in context usage indicator in the footer right section.',
         showInDialog: false
       },
       customThemes: {
@@ -15298,6 +15892,24 @@ var SETTINGS_SCHEMA = {
         description: "Hide tool output and thinking for a cleaner view (toggle with Ctrl+O).",
         showInDialog: true
       },
+      compactInline: {
+        type: "boolean",
+        label: "Compact Inline",
+        category: "UI",
+        requiresRestart: true,
+        default: false,
+        description: "Compact tool display within each group instead of merging across groups. Requires compactMode to be enabled.",
+        showInDialog: true
+      },
+      useTerminalBuffer: {
+        type: "boolean",
+        label: "Virtualized History (reduces flicker on long sessions)",
+        category: "UI",
+        requiresRestart: false,
+        default: false,
+        description: "Render conversation history in an in-app scrollable viewport instead of the terminal scrollback buffer. Recommended if you see flicker, scroll-storm, or interface freeze on long sessions, after Ctrl+O, after Ctrl+E / Ctrl+F (expand), after window resize, or when alt-tabbing back. Scroll with Shift+\u2191/\u2193 (line), PgUp/PgDn (page), Ctrl+Home/End (top/bottom), or the mouse wheel. Does NOT use the host terminal scrollback while enabled; for native text selection, hold Shift (or Option on macOS) while dragging.",
+        showInDialog: true
+      },
       shellOutputMaxLines: {
         type: "number",
         label: "Shell Output Max Lines",
@@ -15484,6 +16096,26 @@ var SETTINGS_SCHEMA = {
       additionalProperties: true
     }
   },
+  outboundCorrelation: {
+    type: "object",
+    label: "Outbound Correlation",
+    category: "Advanced",
+    requiresRestart: true,
+    default: void 0,
+    description: "SECURITY-RELEVANT. Controls what client-side correlation data qwen-code writes into outbound LLM API requests (DashScope, OpenAI, Anthropic, etc.) \u2014 separate from `telemetry.*` which governs data flow into the operator's OWN OTLP collector. All values default to off. Opt in only when the LLM provider also reports into your OTel collector for cross-process trace stitching (e.g. ARMS Tracing + DashScope).",
+    showInDialog: false,
+    jsonSchemaOverride: {
+      type: "object",
+      properties: {
+        propagateTraceContext: {
+          description: "Requires `telemetry.enabled: true`. Inject W3C `traceparent` on outbound `fetch` requests (LLM SDK calls, MCP StreamableHTTP, WebFetch, ...) AND as a `TRACEPARENT` environment variable in shell child processes (Bash tool, hooks, monitor). When enabled, any existing `TRACEPARENT` in the parent environment is overwritten with qwen-code's own trace context. Default: false \u2014 trace context stays internal to the operator's OTLP collector. Set true when you want cross-process trace stitching with an OTel-aware LLM provider (e.g. ARMS+DashScope) or need shell scripts / CLI tools to participate in distributed tracing.",
+          type: "boolean",
+          default: false
+        }
+      },
+      additionalProperties: false
+    }
+  },
   fastModel: {
     type: "string",
     label: "Fast Model",
@@ -15520,6 +16152,24 @@ var SETTINGS_SCHEMA = {
         description: "Maximum number of user/model/tool turns to keep in a session. -1 means unlimited.",
         showInDialog: false
       },
+      maxWallTimeSeconds: {
+        type: "number",
+        label: "Max Wall-Clock Time (seconds)",
+        category: "Model",
+        requiresRestart: false,
+        default: -1,
+        description: "Run-level wall-clock budget for headless / unattended runs, in seconds. -1 means unlimited; otherwise must be in [1, ~2,147,483] (sub-second values and values above ~24 days are rejected as typos). Overridable per-invocation via --max-wall-time (which also accepts duration suffixes like 5m, 1.5h).",
+        showInDialog: false
+      },
+      maxToolCalls: {
+        type: "number",
+        label: "Max Tool Calls",
+        category: "Model",
+        requiresRestart: false,
+        default: -1,
+        description: 'Cumulative tool-call budget for a run (counts every executed tool, success or failure; structured_output under --json-schema is exempt). -1 means unlimited; 0 means "no tool calls allowed" (first call aborts). Capped at 1,000,000 to catch typos. Overridable via --max-tool-calls.',
+        showInDialog: false
+      },
       chatCompression: {
         type: "object",
         label: "Chat Compression",
@@ -15553,7 +16203,7 @@ var SETTINGS_SCHEMA = {
         category: "Model",
         requiresRestart: false,
         default: true,
-        description: "Disable all loop detection checks (streaming and LLM).",
+        description: "Skip streaming loop detection. Defaults to true to avoid false-positive interruptions; set to false to re-enable as an unattended-run guardrail.",
         showInDialog: false
       },
       skipStartupContext: {
@@ -15627,8 +16277,8 @@ var SETTINGS_SCHEMA = {
             label: "Split Tool Result Media",
             category: "Generation Configuration",
             requiresRestart: false,
-            default: false,
-            description: 'When true, media (images / audio / video / files) returned by MCP tool calls is split into a follow-up user message instead of being embedded in the tool message. Required for strict OpenAI-compatible servers (e.g., LM Studio) that reject non-text content on `role: "tool"` messages with HTTP 400 "Invalid \'messages\' in payload". Default false preserves the prior behavior for permissive providers. See QwenLM/qwen-code#3616.',
+            default: true,
+            description: 'When true, media (images / audio / video / files) returned by tool calls \u2014 including the built-in read_file and MCP tools \u2014 is split into a follow-up user message instead of being embedded in the `role: "tool"` message. The OpenAI Chat Completions spec only permits text on tool messages, so strict OpenAI-compatible servers (e.g., doubao / new-api / LM Studio) silently drop or reject embedded media and the model never sees an image read via read_file (QwenLM/qwen-code#4876, #3616). Default true is spec-compliant and safe for permissive providers; set false only to restore the legacy embed-in-tool-message behavior.',
             parentKey: "generationConfig",
             showInDialog: false
           },
@@ -15816,7 +16466,7 @@ var SETTINGS_SCHEMA = {
         label: "Enable Managed Auto-Dream",
         category: "Memory",
         requiresRestart: false,
-        default: false,
+        default: true,
         description: "Enable automatic consolidation (dream) of collected memories.",
         showInDialog: false
       },
@@ -15825,7 +16475,7 @@ var SETTINGS_SCHEMA = {
         label: "Enable Auto Skill",
         category: "Memory",
         requiresRestart: false,
-        default: false,
+        default: true,
         description: "Enable background review for reusable project skills after tool-heavy sessions.",
         showInDialog: false
       }
@@ -15852,6 +16502,27 @@ var SETTINGS_SCHEMA = {
       }
     }
   },
+  skills: {
+    type: "object",
+    label: "Skills",
+    category: "Advanced",
+    requiresRestart: false,
+    default: {},
+    description: "Configuration for skills (SKILL.md-based capabilities) exposed to the model.",
+    showInDialog: false,
+    properties: {
+      disabled: {
+        type: "array",
+        label: "Disabled Skills",
+        category: "Advanced",
+        requiresRestart: false,
+        default: void 0,
+        description: "Skill names to hide. Matched case-insensitively against the skill name. Hidden skills do not appear in <available_skills> or as /<name> slash commands. UNION-merged across systemDefaults/user/workspace/system scopes \u2014 workspace cannot remove entries defined in higher scopes.",
+        showInDialog: false,
+        mergeStrategy: "union" /* UNION */
+      }
+    }
+  },
   permissions: {
     type: "object",
     label: "Permissions",
@@ -15900,6 +16571,66 @@ var SETTINGS_SCHEMA = {
         description: "Settings consumed by the AUTO approval mode classifier.",
         showInDialog: false,
         properties: {
+          classifier: {
+            type: "object",
+            label: "Auto Mode Classifier",
+            category: "Tools",
+            requiresRestart: true,
+            default: {},
+            description: "Runtime controls for the AUTO approval mode classifier.",
+            showInDialog: false,
+            properties: {
+              timeouts: {
+                type: "object",
+                label: "Auto Mode Classifier Timeouts",
+                category: "Tools",
+                requiresRestart: true,
+                default: {},
+                description: "Timeouts for the two AUTO classifier stages, in milliseconds.",
+                showInDialog: false,
+                properties: {
+                  stage1Ms: {
+                    type: "number",
+                    label: "Auto Mode Stage 1 Timeout",
+                    category: "Tools",
+                    requiresRestart: true,
+                    default: void 0,
+                    description: "Timeout in milliseconds for the fast stage-1 AUTO classifier.",
+                    showInDialog: false
+                  },
+                  stage2Ms: {
+                    type: "number",
+                    label: "Auto Mode Stage 2 Timeout",
+                    category: "Tools",
+                    requiresRestart: true,
+                    default: void 0,
+                    description: "Timeout in milliseconds for the stage-2 AUTO classifier review.",
+                    showInDialog: false
+                  }
+                }
+              },
+              thinking: {
+                type: "object",
+                label: "Auto Mode Classifier Thinking",
+                category: "Tools",
+                requiresRestart: true,
+                default: {},
+                description: "Provider/API-level thinking controls for the AUTO classifier.",
+                showInDialog: false,
+                properties: {
+                  stage2Enabled: {
+                    type: "boolean",
+                    label: "Auto Mode Stage 2 Thinking",
+                    category: "Tools",
+                    requiresRestart: true,
+                    default: false,
+                    description: "Whether stage 2 may use provider/API-level thinking. Stage 1 always keeps thinking disabled.",
+                    showInDialog: false
+                  }
+                }
+              }
+            }
+          },
           hints: {
             type: "object",
             label: "Classifier Hints",
@@ -15919,13 +16650,33 @@ var SETTINGS_SCHEMA = {
                 showInDialog: false,
                 mergeStrategy: "union" /* UNION */
               },
+              softDeny: {
+                type: "array",
+                label: "Auto Mode Soft-Deny Hints",
+                category: "Tools",
+                requiresRestart: true,
+                default: void 0,
+                description: "Natural-language descriptions of destructive / irreversible actions AUTO mode should block unless the user explicitly authorised that exact action and scope.",
+                showInDialog: false,
+                mergeStrategy: "union" /* UNION */
+              },
+              hardDeny: {
+                type: "array",
+                label: "Auto Mode Hard-Deny Hints",
+                category: "Tools",
+                requiresRestart: true,
+                default: void 0,
+                description: "Natural-language descriptions of security-boundary actions the AUTO classifier must block even when an autoMode allow hint or recent user request would normally authorise them. Does not override permissions.allow; use permissions.deny for deterministic hard permission rules.",
+                showInDialog: false,
+                mergeStrategy: "union" /* UNION */
+              },
               deny: {
                 type: "array",
-                label: "Auto Mode Deny Hints",
+                label: "Auto Mode Deny Hints (legacy)",
                 category: "Tools",
                 requiresRestart: true,
                 default: void 0,
-                description: "Natural-language descriptions of actions AUTO mode should block.",
+                description: "Deprecated alias for `softDeny`. Entries here are merged into the SOFT BLOCK user section so existing settings keep working; new configurations should use `softDeny` or `hardDeny` instead.",
                 showInDialog: false,
                 mergeStrategy: "union" /* UNION */
               }
@@ -16080,7 +16831,7 @@ var SETTINGS_SCHEMA = {
         showInDialog: true,
         options: [
           { value: "plan" /* PLAN */, label: "Plan" },
-          { value: "default" /* DEFAULT */, label: "Default" },
+          { value: "default" /* DEFAULT */, label: "Ask permissions" },
           { value: "auto-edit" /* AUTO_EDIT */, label: "Auto Edit" },
           { value: "auto" /* AUTO */, label: "Auto" },
           { value: "yolo" /* YOLO */, label: "YOLO" }
@@ -16148,6 +16899,80 @@ var SETTINGS_SCHEMA = {
         default: DEFAULT_TRUNCATE_TOOL_OUTPUT_LINES,
         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",
+        category: "Tools",
+        requiresRestart: true,
+        default: {},
+        description: "Cross-platform desktop automation via the upstream open-computer-use MCP server. Tools: list_apps, get_app_state, click, type_text, scroll, drag, press_key, perform_secondary_action, set_value. On first invocation, the upstream binary is fetched via npx and the user is walked through macOS Accessibility / Screen Recording permissions if needed.",
+        showInDialog: false,
+        properties: {
+          enabled: {
+            type: "boolean",
+            label: "Enable Computer Use",
+            category: "Tools",
+            requiresRestart: true,
+            default: true,
+            description: "When enabled (default), the 9 computer_use__* tools are registered as deferred built-ins.",
+            showInDialog: true
+          }
+        }
+      }
+    }
+  },
+  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."
+        }
       }
     }
   },
@@ -16479,6 +17304,17 @@ var SETTINGS_SCHEMA = {
         mergeStrategy: "concat" /* CONCAT */,
         items: HOOK_DEFINITION_ITEMS
       },
+      UserPromptExpansion: {
+        type: "array",
+        label: "Prompt Expansion Hooks",
+        category: "Advanced",
+        requiresRestart: false,
+        default: [],
+        description: "Hooks that execute when a slash command expands into a prompt.",
+        showInDialog: false,
+        mergeStrategy: "concat" /* CONCAT */,
+        items: HOOK_DEFINITION_ITEMS
+      },
       Stop: {
         type: "array",
         label: "After Agent Hooks",
@@ -16534,6 +17370,17 @@ var SETTINGS_SCHEMA = {
         mergeStrategy: "concat" /* CONCAT */,
         items: HOOK_DEFINITION_ITEMS
       },
+      PostToolBatch: {
+        type: "array",
+        label: "Post Tool Batch Hooks",
+        category: "Advanced",
+        requiresRestart: false,
+        default: [],
+        description: "Hooks that execute once after all tool calls in a batch resolve.",
+        showInDialog: false,
+        mergeStrategy: "concat" /* CONCAT */,
+        items: HOOK_DEFINITION_ITEMS
+      },
       SessionStart: {
         type: "array",
         label: "Session Start Hooks",
@@ -16616,8 +17463,17 @@ var SETTINGS_SCHEMA = {
         label: "Enable Cron/Loop Tools",
         category: "Experimental",
         requiresRestart: true,
+        default: true,
+        description: "Enable in-session cron/loop tools. When enabled, the model can create recurring prompts using cron_create, cron_list, and cron_delete tools. Can be disabled via QWEN_CODE_DISABLE_CRON=1 environment variable.",
+        showInDialog: true
+      },
+      agentTeam: {
+        type: "boolean",
+        label: "Enable Agent Team",
+        category: "Experimental",
+        requiresRestart: true,
         default: false,
-        description: "Enable in-session cron/loop tools (experimental). When enabled, the model can create recurring prompts using cron_create, cron_list, and cron_delete tools. Can also be enabled via QWEN_CODE_ENABLE_CRON=1 environment variable.",
+        description: "Enable agent team collaboration tools (experimental). When enabled, the model can create agent teams and coordinate work using team_create, team_delete, send_message, task_create, task_update, and task_list tools. Can also be enabled via QWEN_CODE_ENABLE_AGENT_TEAM=1 environment variable.",
         showInDialog: true
       },
       emitToolUseSummaries: {
@@ -16630,6 +17486,26 @@ var SETTINGS_SCHEMA = {
         showInDialog: true
       }
     }
+  },
+  worktree: {
+    type: "object",
+    label: "Worktree",
+    category: "Advanced",
+    requiresRestart: false,
+    default: {},
+    description: 'Configuration for general-purpose git worktrees created by the CLI (the `enter_worktree` tool, the `agent isolation: "worktree"` parameter, and the startup `--worktree` flag). Does NOT affect Agent Arena worktrees \u2014 see `agents.arena.worktreeBaseDir` for those.',
+    showInDialog: false,
+    properties: {
+      symlinkDirectories: {
+        type: "array",
+        label: "Symlink Directories Into Worktrees",
+        category: "Advanced",
+        requiresRestart: false,
+        default: void 0,
+        description: "Directories under the main repository to symlink into every general-purpose worktree on creation. Useful for sharing large opt-in dirs like `node_modules` so the model can run tests / builds inside the worktree without a fresh install. Paths must be relative to the repo root; absolute paths, anything containing `..`, and any path inside `.git` or `.qwen` (the CLI-managed metadata tree, which contains the worktrees directory itself) are rejected. Missing source dirs and existing destination paths are silently skipped (no overwrite, no failure).",
+        showInDialog: false
+      }
+    }
   }
 };
 function getSettingsSchema() {
@@ -16734,8 +17610,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;
   }
@@ -16749,8 +17625,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) {
@@ -16758,12 +17634,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;
   }
@@ -16814,8 +17690,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");
@@ -16828,8 +17704,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;
@@ -16843,8 +17719,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;
@@ -16863,8 +17739,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;
@@ -16896,10 +17772,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,
@@ -17001,12 +17877,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);
@@ -17139,7 +18015,7 @@ function writeWithBackupSync(targetPath, content, options = {}) {
 __name(writeWithBackupSync, "writeWithBackupSync");
 
 // packages/cli/src/utils/commentJson.ts
-function updateSettingsFilePreservingFormat(filePath, updates, sync = false) {
+function updateSettingsFilePreservingFormat(filePath, updates, sync = false, replacePath = []) {
   if (!fs5.existsSync(filePath)) {
     const content = (0, import_comment_json.stringify)(updates, null, 2);
     writeWithBackupSync(filePath, content);
@@ -17156,7 +18032,7 @@ function updateSettingsFilePreservingFormat(filePath, updates, sync = false) {
     );
     return false;
   }
-  const updatedStructure = applyUpdates(parsed, updates, sync);
+  const updatedStructure = applyUpdates(parsed, updates, sync, replacePath);
   const updatedContent = (0, import_comment_json.stringify)(updatedStructure, null, 2);
   try {
     (0, import_comment_json.parse)(updatedContent);
@@ -17173,7 +18049,7 @@ function updateSettingsFilePreservingFormat(filePath, updates, sync = false) {
   return true;
 }
 __name(updateSettingsFilePreservingFormat, "updateSettingsFilePreservingFormat");
-function applyUpdates(current, updates, sync = false) {
+function applyUpdates(current, updates, sync = false, replacePath = [], currentPath = []) {
   const result = current;
   if (sync) {
     const keysToRemove = Object.keys(result).filter((key) => !(key in updates));
@@ -17182,12 +18058,31 @@ function applyUpdates(current, updates, sync = false) {
     }
   }
   for (const key of Object.getOwnPropertyNames(updates)) {
+    if (key === "__proto__" || key === "constructor" || key === "prototype") {
+      continue;
+    }
     const value = updates[key];
-    if (typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length > 0 && typeof result[key] === "object" && result[key] !== null && !Array.isArray(result[key])) {
+    const nextPath = [...currentPath, key];
+    const valueIsObject = typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length > 0;
+    if (pathsEqual(nextPath, replacePath)) {
+      result[key] = valueIsObject ? applyUpdates({}, value) : value;
+      continue;
+    }
+    if (valueIsObject && (typeof result[key] !== "object" || result[key] === null || Array.isArray(result[key]))) {
+      result[key] = applyUpdates(
+        {},
+        value,
+        sync,
+        replacePath,
+        nextPath
+      );
+    } else if (valueIsObject && typeof result[key] === "object" && result[key] !== null && !Array.isArray(result[key])) {
       result[key] = applyUpdates(
         result[key],
         value,
-        sync
+        sync,
+        replacePath,
+        nextPath
       );
     } else {
       result[key] = value;
@@ -17196,6 +18091,10 @@ function applyUpdates(current, updates, sync = false) {
   return result;
 }
 __name(applyUpdates, "applyUpdates");
+function pathsEqual(left, right) {
+  return left.length === right.length && left.every((segment, index) => segment === right[index]);
+}
+__name(pathsEqual, "pathsEqual");
 
 // packages/cli/src/config/migration/index.ts
 init_esbuild_shims();
@@ -17828,10 +18727,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;
     }
@@ -17847,11 +18746,42 @@ 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"];
-var PROJECT_ENV_HARDCODED_EXCLUSIONS = ["QWEN_HOME", "QWEN_RUNTIME_DIR"];
+var ENV_CORRUPTED_PATH = "QWEN_CODE_SETTINGS_CORRUPTED_PATH";
+var ENV_WAS_RECOVERED = "QWEN_CODE_SETTINGS_WAS_RECOVERED";
+var PROJECT_ENV_HARDCODED_EXCLUSIONS = [
+  "QWEN_HOME",
+  "QWEN_RUNTIME_DIR",
+  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() {
@@ -17871,8 +18801,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"
   );
 }
@@ -17999,7 +18929,7 @@ var LoadedSettings = class {
   static {
     __name(this, "LoadedSettings");
   }
-  constructor(system, systemDefaults, user, workspace, isTrusted, migratedInMemorScopes, migrationWarnings = []) {
+  constructor(system, systemDefaults, user, workspace, isTrusted, migratedInMemorScopes, migrationWarnings = [], corruptedPath = void 0, wasRecovered = false) {
     this.system = system;
     this.systemDefaults = systemDefaults;
     this.user = user;
@@ -18007,6 +18937,8 @@ var LoadedSettings = class {
     this.isTrusted = isTrusted;
     this.migratedInMemorScopes = migratedInMemorScopes;
     this.migrationWarnings = migrationWarnings;
+    this.corruptedPath = corruptedPath;
+    this.wasRecovered = wasRecovered;
     this._merged = this.computeMergedSettings();
   }
   system;
@@ -18016,6 +18948,9 @@ var LoadedSettings = class {
   isTrusted;
   migratedInMemorScopes;
   migrationWarnings;
+  corruptedPath;
+  wasRecovered;
+  corruptionDialogDismissed = false;
   _merged;
   get merged() {
     return this._merged;
@@ -18044,15 +18979,47 @@ var LoadedSettings = class {
     }
   }
   setValue(scope, key, value) {
+    if (key === "model.name" && typeof value === "string") {
+      value = stripRuntimeSnapshotPrefix(value);
+    }
     const settingsFile = this.forScope(scope);
     setNestedPropertySafe(settingsFile.settings, key, value);
     setNestedPropertySafe(settingsFile.originalSettings, key, value);
     this._merged = this.computeMergedSettings();
-    saveSettings(settingsFile, createSettingsUpdate(key, value));
+    const replacePath = key === "mcpServers" ? key.split(".") : [];
+    saveSettings(settingsFile, createSettingsUpdate(key, value), replacePath);
   }
   recomputeMerged() {
     this._merged = this.computeMergedSettings();
   }
+  reloadScopeFromDisk(scope) {
+    const file = this.forScope(scope);
+    try {
+      if (!fs6.existsSync(file.path)) {
+        file.settings = {};
+        file.originalSettings = {};
+        file.rawJson = void 0;
+        this._merged = this.computeMergedSettings();
+        return;
+      }
+      const content = fs6.readFileSync(file.path, "utf-8");
+      const parsed = JSON.parse((0, import_strip_json_comments2.default)(content));
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        const resolved = resolveEnvVarsInObject(
+          parsed,
+          getHomeEnvFallbackVars()
+        );
+        file.settings = resolved;
+        file.originalSettings = structuredClone(parsed);
+        file.rawJson = content;
+      }
+    } catch (err) {
+      debugLogger3.warn(
+        `reloadScopeFromDisk(${scope}): ${getErrorMessage(err)}`
+      );
+    }
+    this._merged = this.computeMergedSettings();
+  }
   /**
    * Get user-level hooks from user settings (not merged with workspace).
    * These hooks should always be loaded regardless of folder trust.
@@ -18085,7 +19052,9 @@ function createMinimalSettings() {
     emptySettingsFile,
     false,
     /* @__PURE__ */ new Set(),
-    []
+    [],
+    void 0,
+    false
   );
 }
 __name(createMinimalSettings, "createMinimalSettings");
@@ -18093,10 +19062,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;
 }
@@ -18112,9 +19081,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);
@@ -18123,7 +19092,7 @@ function preResolveHomeEnvOverrides() {
   if (discoveredQwenHome && discoveredQwenHome !== initialQwenHome) {
     const discoveredDir = Storage.getGlobalQwenDir();
     if (discoveredDir !== initialQwenDir) {
-      readHomeEnvInto(path3.join(discoveredDir, ".env"));
+      readHomeEnvInto(path4.join(discoveredDir, ".env"));
     }
   }
 }
@@ -18143,6 +19112,33 @@ function readHomeEnvInto(file) {
   }
 }
 __name(readHomeEnvInto, "readHomeEnvInto");
+function getHomeEnvFallbackVars() {
+  const globalQwenDir = Storage.getGlobalQwenDir();
+  const candidates = [path4.join(globalQwenDir, ".env")];
+  if (!process2.env["QWEN_HOME"]) {
+    candidates.push(path4.join(path4.dirname(globalQwenDir), ".env"));
+  }
+  const result = {};
+  for (const candidate of candidates) {
+    if (!fs6.existsSync(candidate)) {
+      continue;
+    }
+    try {
+      const parsed = dotenv.parse(fs6.readFileSync(candidate, "utf-8"));
+      for (const key in parsed) {
+        if (Object.hasOwn(parsed, key) && !Object.hasOwn(process2.env, key)) {
+          result[key] ??= parsed[key];
+        }
+      }
+    } catch (e) {
+      debugLogger3.warn(
+        `Failed to read home .env candidate ${candidate}: ${getErrorMessage(e)}`
+      );
+    }
+  }
+  return result;
+}
+__name(getHomeEnvFallbackVars, "getHomeEnvFallbackVars");
 function detectQwenHomeRedirectWithoutMigration(activeUserSettingsPath) {
   if (!process2.env["QWEN_HOME"]) {
     return null;
@@ -18156,13 +19152,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;
   }
@@ -18173,15 +19169,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;
@@ -18189,7 +19185,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) {
@@ -18197,16 +19193,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();
     }
@@ -18239,9 +19235,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)) {
@@ -18252,6 +19248,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]);
           }
         }
       }
@@ -18265,12 +19265,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 loadSettings(workspaceDir = process2.cwd()) {
+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);
@@ -18282,8 +19380,8 @@ function loadSettings(workspaceDir = process2.cwd()) {
   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);
@@ -18298,10 +19396,21 @@ function loadSettings(workspaceDir = process2.cwd()) {
       if (fs6.existsSync(filePath)) {
         let content = fs6.readFileSync(filePath, "utf-8");
         let rawSettings;
-        let recoveryWarning;
+        const corruptedPath = `${filePath}${CORRUPTED_SUFFIX}`;
+        let corruptedSaved = false;
+        let recoveredFromBackup = false;
+        let recoveredFromEnvVar = null;
         try {
           rawSettings = JSON.parse((0, import_strip_json_comments2.default)(content));
         } catch (parseError) {
+          try {
+            fs6.copyFileSync(filePath, corruptedPath);
+            corruptedSaved = true;
+          } catch (copyError) {
+            debugLogger3.warn(
+              `Failed to copy corrupted file: ${getErrorMessage(copyError)}`
+            );
+          }
           const backupPath = `${filePath}.orig`;
           if (fs6.existsSync(backupPath)) {
             debugLogger3.warn(
@@ -18317,7 +19426,7 @@ function loadSettings(workspaceDir = process2.cwd()) {
               rawSettings = backupSettings;
               const recoveryMsg = `Settings file ${filePath} had invalid JSON and was recovered from backup ${backupPath}. Some recent settings changes may have been lost.`;
               debugLogger3.warn(recoveryMsg);
-              recoveryWarning = recoveryMsg;
+              recoveredFromBackup = true;
             } catch (backupError) {
               debugLogger3.warn(
                 `Failed to recover from backup ${backupPath}: ${getErrorMessage(backupError)}. Falling back to empty settings.`
@@ -18325,24 +19434,29 @@ function loadSettings(workspaceDir = process2.cwd()) {
             }
           }
           if (!rawSettings) {
-            const corruptedPath = `${filePath}.corrupted.${Date.now()}`;
-            let warningMsg;
-            try {
-              fs6.renameSync(filePath, corruptedPath);
-              warningMsg = `Settings file ${filePath} has invalid JSON and was renamed to ${corruptedPath}. Your settings have been reset. To recover, fix the JSON in ${corruptedPath} and rename it back.`;
-            } catch (renameError) {
-              debugLogger3.error(
-                `Failed to rename corrupted settings file: ${getErrorMessage(renameError)}`
-              );
-              warningMsg = `Settings file ${filePath} has invalid JSON. Your settings have been reset. Please fix the JSON in ${filePath} manually.`;
-            }
+            const warningMsg = `Settings file ${filePath} has invalid JSON. Your settings have been reset.`;
             debugLogger3.warn(warningMsg);
+            if (corruptedSaved) {
+              try {
+                fs6.writeFileSync(filePath, "{}", "utf-8");
+              } catch {
+              }
+            }
             return {
               settings: {},
-              migrationWarnings: [warningMsg]
+              migrationWarnings: [],
+              corruptedPath: corruptedSaved ? corruptedPath : void 0,
+              wasRecovered: false
             };
           }
         }
+        const envCorruptedPath = process2.env[ENV_CORRUPTED_PATH];
+        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];
+          delete process2.env[ENV_WAS_RECOVERED];
+        }
         if (typeof rawSettings !== "object" || rawSettings === null || Array.isArray(rawSettings)) {
           settingsErrors.push({
             message: "Settings file is not a valid JSON object.",
@@ -18378,26 +19492,27 @@ function loadSettings(workspaceDir = process2.cwd()) {
             settingsObject = migrationResult.settings;
             migrationWarnings = migrationResult.warnings;
             persistSettingsObject("Error migrating settings file on disk");
-          } else if (hasLegacyNumericVersion || hasInvalidVersion) {
+          } else if ((hasLegacyNumericVersion || hasInvalidVersion) && !corruptedSaved) {
             settingsObject[SETTINGS_VERSION_KEY] = SETTINGS_VERSION;
             debugLogger3.warn(
               `Settings version metadata in ${filePath} could not be migrated by any registered migration. Normalizing ${SETTINGS_VERSION_KEY} to ${SETTINGS_VERSION}.`
             );
             persistSettingsObject("Error normalizing settings version on disk");
           }
-        } else if (!hasVersionKey || hasInvalidVersion || hasLegacyNumericVersion) {
+        } else if ((!hasVersionKey || hasInvalidVersion || hasLegacyNumericVersion) && !corruptedSaved) {
           settingsObject[SETTINGS_VERSION_KEY] = SETTINGS_VERSION;
           persistSettingsObject("Error normalizing settings version on disk");
         }
-        const allWarnings = [
-          ...recoveryWarning ? [recoveryWarning] : [],
-          ...migrationWarnings ?? []
-        ];
-        return {
+        const result = {
           settings: settingsObject,
           rawJson: content,
-          migrationWarnings: allWarnings.length > 0 ? allWarnings : migrationWarnings
+          migrationWarnings: migrationWarnings ?? []
         };
+        if (corruptedSaved) {
+          result.corruptedPath = corruptedPath;
+          result.wasRecovered = recoveredFromBackup || (recoveredFromEnvVar ?? false);
+        }
+        return result;
       }
     } catch (error) {
       settingsErrors.push({
@@ -18429,10 +19544,20 @@ function loadSettings(workspaceDir = process2.cwd()) {
   );
   const userOriginalSettings = structuredClone(userResult.settings);
   const workspaceOriginalSettings = structuredClone(workspaceResult.settings);
-  systemSettings = resolveEnvVarsInObject(systemResult.settings);
-  systemDefaultSettings = resolveEnvVarsInObject(systemDefaultsResult.settings);
-  userSettings = resolveEnvVarsInObject(userResult.settings);
-  workspaceSettings = resolveEnvVarsInObject(workspaceResult.settings);
+  const homeEnvFallback = getHomeEnvFallbackVars();
+  systemSettings = resolveEnvVarsInObject(
+    systemResult.settings,
+    homeEnvFallback
+  );
+  systemDefaultSettings = resolveEnvVarsInObject(
+    systemDefaultsResult.settings,
+    homeEnvFallback
+  );
+  userSettings = resolveEnvVarsInObject(userResult.settings, homeEnvFallback);
+  workspaceSettings = resolveEnvVarsInObject(
+    workspaceResult.settings,
+    homeEnvFallback
+  );
   if (userSettings.ui?.theme === "VS") {
     userSettings.ui.theme = DefaultLight.name;
   } else if (userSettings.ui?.theme === "VS2015") {
@@ -18457,7 +19582,9 @@ function loadSettings(workspaceDir = process2.cwd()) {
     workspaceSettings,
     isTrusted
   );
-  loadEnvironment(tempMergedSettings);
+  if (!opts.skipLoadEnvironment) {
+    loadEnvironment(tempMergedSettings);
+  }
   if (settingsErrors.length > 0) {
     const errorMessages = settingsErrors.map(
       (error) => `Error in ${error.path}: ${error.message}`
@@ -18501,7 +19628,9 @@ Please fix the configuration file(s) and try again.`
     },
     isTrusted,
     migratedInMemorScopes,
-    allMigrationWarnings
+    allMigrationWarnings,
+    userResult.corruptedPath,
+    userResult.wasRecovered ?? false
   );
 }
 __name(loadSettings, "loadSettings");
@@ -18511,13 +19640,23 @@ function createSettingsUpdate(key, value) {
   return root;
 }
 __name(createSettingsUpdate, "createSettingsUpdate");
-function saveSettings(settingsFile, updates = settingsFile.originalSettings) {
+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 });
     }
-    updateSettingsFilePreservingFormat(settingsFile.path, updates);
+    const written = updateSettingsFilePreservingFormat(
+      settingsFile.path,
+      updates,
+      false,
+      replacePath
+    );
+    if (!written) {
+      debugLogger3.error(
+        `saveSettings: updateSettingsFilePreservingFormat returned false for ${settingsFile.path}`
+      );
+    }
   } catch (error) {
     debugLogger3.error("Error saving user settings file.");
     debugLogger3.error(error instanceof Error ? error.message : String(error));
@@ -18534,26 +19673,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()) {
@@ -18564,7 +19703,7 @@ async function findUp(name, {
     if (directory === stopAt || directory === root) {
       break;
     }
-    directory = path4.dirname(directory);
+    directory = path5.dirname(directory);
   }
 }
 __name(findUp, "findUp");
@@ -18572,7 +19711,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();
@@ -18711,7 +19850,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) {
@@ -18732,7 +19871,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
   };
 }
@@ -18740,9 +19879,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) {
@@ -18760,16 +19899,10 @@ __name(getPackageJson, "getPackageJson");
 // packages/cli/src/utils/version.ts
 async function getCliVersion() {
   const pkgJson = await getPackageJson();
-  return "0.16.1-termux";
+  return "0.18.0-termux";
 }
 __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) => {
@@ -18853,25 +19986,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 = "5fd0fd640";
+var GIT_COMMIT_INFO = "b74e9dbb4";
 
 // 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");
       }
     );
   });
@@ -19009,6 +20203,9 @@ __name(formatLspStatusSnapshot, "formatLspStatusSnapshot");
 
 export {
   require_strip_json_comments,
+  resolveColor,
+  subtleBandColor,
+  supportsTrueColor,
   lightTheme,
   darkTheme,
   ansiTheme,
@@ -19018,13 +20215,16 @@ export {
   DefaultLight,
   DefaultDark,
   loadTrustedFolders,
+  isFolderTrustEnabled,
   isWorkspaceTrusted,
   getPersistScopeForModelSelection,
   TOGGLE_TYPES,
   OUTPUT_LANGUAGE_AUTO,
   isAutoLanguage,
   resolveOutputLanguage,
+  getOutputLanguageFilePath,
   updateOutputLanguageFile,
+  writeOutputLanguageAndRegisterPath,
   initializeLlmOutputLanguage,
   getSettingDefinition,
   requiresRestart,
@@ -19040,16 +20240,17 @@ export {
   saveModifiedSettings,
   getDisplayValue,
   isDefaultValue,
-  backupSettingsFile,
-  restoreSettingsFromBackup,
-  cleanupSettingsBackup,
   SETTINGS_DIRECTORY_NAME,
   getUserSettingsDir,
+  ENV_CORRUPTED_PATH,
+  ENV_WAS_RECOVERED,
   SettingScope,
   getSettingsWarnings,
   createMinimalSettings,
   preResolveHomeEnvOverrides,
   loadEnvironment,
+  reloadEnvironment,
+  CORRUPTED_SUFFIX,
   loadSettings,
   require_debug,
   require_constants,
@@ -19066,6 +20267,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,
@@ -19073,6 +20298,9 @@ export {
   MissingCliEntryError,
   SERVE_STATUS_EXT_METHODS,
   SERVE_CONTROL_EXT_METHODS,
+  IDLE_HOOK_EVENTS,
+  createIdleWorkspaceExtensionsStatus,
+  createIdleWorkspaceHooksStatus,
   createIdleWorkspaceMemoryStatus,
   createIdleWorkspaceMcpStatus,
   createIdleWorkspaceSkillsStatus,
@@ -19087,7 +20315,8 @@ export {
   formatDuration,
   getNpmVersion,
   getGitVersion,
-  getExtendedSystemInfo
+  getExtendedSystemInfo,
+  createLoadedSettingsAdapter
 };
 /**
  * @license
@@ -19104,6 +20333,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