@qwen-code/qwen-code 0.23.3 → 0.23.4-dev.codemode-responses.20260914.87437db784

package/chunks/{chunk-BZM5U74J.js → chunk-BS7ON54G.js}

@@ -16,7 +16,7 @@ import {
   peerSenderKey,
   probePeerSocketVerdict,
   resolvePeerSocketCandidates
-} from "./chunk-LK2WUCDQ.js";
+} from "./chunk-YM6KUQ2S.js";
 import {
   BudgetExhaustedError,
   CoreToolScheduler,
@@ -58,6 +58,7 @@ import {
   listDescendantPids,
   listExistingSkillDirNames,
   loadUsageHistoryWithLive,
+  loadXtermHeadless,
   mcpSessionMetadataKey,
   mcpTransportOf,
   normalizeMcpIncludeEntry,
@@ -79,34 +80,34 @@ import {
   stripToolResultImages,
   toolResultBoundaryArtifact,
   toolResultPartDiagnosticValues
-} from "./chunk-N7VWZDWW.js";
-import {
-  stripAnsi
-} from "./chunk-TWPJO254.js";
+} from "./chunk-CFSBWJBB.js";
 import {
   hasVerifiableInode,
   openNoFollow
-} from "./chunk-6HUXPLB5.js";
+} from "./chunk-HEOH7JZY.js";
+import {
+  stripAnsi
+} from "./chunk-TWPJO254.js";
 import {
   projectUserTranscriptForDisplay
-} from "./chunk-E4UEO3XM.js";
+} from "./chunk-ME4JBHSB.js";
 import {
   getProjectSkillsRoot,
   parse
-} from "./chunk-2SZH22YO.js";
-import {
-  resolveBundleDir
-} from "./chunk-DTNV6UZY.js";
+} from "./chunk-NJ2OFVUX.js";
 import {
   glob,
   globSync
 } from "./chunk-QJNDUTOL.js";
+import {
+  resolveBundleDir
+} from "./chunk-ACHCT36C.js";
 import {
   escapeJsonTagCharacters
 } from "./chunk-CHEIIBT3.js";
 import {
   flattenPeerLabel
-} from "./chunk-5GLDOLNQ.js";
+} from "./chunk-OWUAZXXN.js";
 import {
   isPidAlive
 } from "./chunk-CH2YDT6X.js";
@@ -116,13 +117,13 @@ import {
 import {
   BUILT_IN_OUTPUT_STYLES,
   getBuiltInOutputStyle
-} from "./chunk-LILGKQ4B.js";
+} from "./chunk-AXZMWAJV.js";
 import {
   getFolderStructure,
   getStartupContextLength,
   isSystemReminderContent,
   stripSystemReminderBlocks
-} from "./chunk-FN3JNDRU.js";
+} from "./chunk-VVI7MK3V.js";
 import {
   getQwenIgnoreFileNames,
   require_ignore
@@ -133,7 +134,7 @@ import {
 } from "./chunk-NUQ4GK5I.js";
 import {
   fetchWithPolicy
-} from "./chunk-YBUMTY7B.js";
+} from "./chunk-66N6C4EH.js";
 import {
   COMBINED_PASS_TOLERANCE_FACTOR,
   TOOL_OUTPUT_TRUNCATED_PREFIX,
@@ -142,7 +143,7 @@ import {
   removeMCPStatusChangeListener,
   runSideQuery,
   updateMCPServerStatus
-} from "./chunk-HBU7EKY4.js";
+} from "./chunk-NRUKL236.js";
 import {
   getInvocationContext
 } from "./chunk-5ETULJLP.js";
@@ -151,10 +152,6 @@ import {
   Mutex,
   withTimeout
 } from "./chunk-VGC4I5JJ.js";
-import {
-  getAutoMemoryRoot,
-  getUserAutoMemoryRoot
-} from "./chunk-EDIDYZBT.js";
 import {
   MEMORY_SECTION_HEADER,
   VISION_BRIDGE_MAX_IMAGES,
@@ -164,7 +161,11 @@ import {
   isCacheableReadResult,
   isWithinRoot,
   processSingleFileContent
-} from "./chunk-J6MB5ZHZ.js";
+} from "./chunk-QZW6WRB7.js";
+import {
+  getAutoMemoryRoot,
+  getUserAutoMemoryRoot
+} from "./chunk-EDIDYZBT.js";
 import {
   atomicWriteFile,
   atomicWriteJSON
@@ -174,11 +175,11 @@ import {
   normalizeContent,
   stripAnsiAndControl,
   stripHtmlComments
-} from "./chunk-W5ZQMAEM.js";
+} from "./chunk-4Y2I3CI3.js";
 import {
   ToolNames,
   canonicalToolName
-} from "./chunk-TP6FYVQT.js";
+} from "./chunk-RSWBT7AZ.js";
 import {
   PATH_ARG_KEYS,
   QWEN_DIR,
@@ -1201,7 +1202,7 @@ function buildSessionRecoveryPlanFromApiHistory({
   historyGaps,
   options
 }) {
-  const originalApiHistory = structuredClone(inputApiHistory);
+  const originalApiHistory = inputApiHistory;
   const gaps = historyGaps ?? [];
   const planId = createPlanId(sessionId, originalApiHistory.length);
   const apiHistory = structuredClone(originalApiHistory);
@@ -3230,212 +3231,6 @@ var WorkspaceMcpBudget = class {
   }
 };
 
-// packages/core/src/providers/install.ts
-init_esbuild_shims();
-var DENY_ENV_KEYS = /* @__PURE__ */ new Set([
-  "NODE_OPTIONS",
-  "NODE_PATH",
-  "LD_PRELOAD",
-  "LD_LIBRARY_PATH",
-  "DYLD_INSERT_LIBRARIES",
-  "DYLD_LIBRARY_PATH",
-  "PATH",
-  "HOME",
-  "TMPDIR",
-  "TMP",
-  // Windows temp redirect
-  "TEMP"
-  // Windows temp redirect
-]);
-function isSameModelIdentity(a, b) {
-  return a.id === b.id && (a.baseUrl ?? "") === (b.baseUrl ?? "");
-}
-__name(isSameModelIdentity, "isSameModelIdentity");
-function applyModelProvidersPatch(existingModelProviders, patch) {
-  const existingModels = existingModelProviders[patch.authType] ?? [];
-  let updatedModels = patch.models;
-  if (patch.mergeStrategy === "append") {
-    updatedModels = [...existingModels, ...patch.models];
-  } else {
-    const ownsModel = patch.ownsModel;
-    const preservedModels = existingModels.filter((model) => {
-      if (ownsModel) {
-        return !ownsModel(model);
-      }
-      return !patch.models.some(
-        (newModel) => isSameModelIdentity(newModel, model)
-      );
-    });
-    updatedModels = patch.mergeStrategy === "replace-owned" ? [...preservedModels, ...patch.models] : [...patch.models, ...preservedModels];
-  }
-  return {
-    ...existingModelProviders,
-    [patch.authType]: updatedModels
-  };
-}
-__name(applyModelProvidersPatch, "applyModelProvidersPatch");
-var ProviderInstallError = class extends Error {
-  static {
-    __name(this, "ProviderInstallError");
-  }
-  step;
-  authType;
-  constructor(message, step, authType, options) {
-    super(message, options);
-    this.name = "ProviderInstallError";
-    this.step = step;
-    this.authType = authType;
-  }
-};
-async function applyProviderInstallPlan(plan, options) {
-  const {
-    settings,
-    reloadModelProviders,
-    syncAuthState,
-    refreshAuth,
-    doRefreshAuth = true
-  } = options;
-  const previousEnvValues = /* @__PURE__ */ new Map();
-  const previousRuntimeProviders = {
-    ...settings.getModelProviders()
-  };
-  let currentStep = "init";
-  try {
-    currentStep = "backup";
-    settings.backup?.();
-    currentStep = "env";
-    const shadowedEnvKeys = [];
-    for (const [key, value] of Object.entries(plan.env ?? {})) {
-      if (DENY_ENV_KEYS.has(key.toUpperCase())) {
-        throw new Error(
-          `Install plan must not set reserved environment variable: ${key}`
-        );
-      }
-      const previous = process.env[key];
-      if (previous !== void 0 && previous !== "" && previous !== value) {
-        shadowedEnvKeys.push(key);
-      }
-      previousEnvValues.set(key, previous);
-      settings.setValue(`env.${key}`, value);
-      process.env[key] = value;
-    }
-    if (shadowedEnvKeys.length > 0) {
-      console.error(
-        `[auth] Warning: ${shadowedEnvKeys.join(", ")} ${shadowedEnvKeys.length === 1 ? "is" : "are"} also set in your shell environment or .env file. The shell/file value will take priority on restart. To ensure your new key is used, update or remove the variable from your shell profile or .env file.`
-      );
-    }
-    currentStep = "modelProviders";
-    let updatedModelProviders = {
-      ...previousRuntimeProviders
-    };
-    for (const patch of plan.modelProviders ?? []) {
-      updatedModelProviders = applyModelProvidersPatch(
-        updatedModelProviders,
-        patch
-      );
-      settings.setValue(
-        `modelProviders.${patch.authType}`,
-        updatedModelProviders[patch.authType] ?? []
-      );
-    }
-    currentStep = "authType";
-    settings.setValue("security.auth.selectedType", plan.authType);
-    currentStep = "legacyCredentials";
-    if (plan.legacyCredentials?.apiKey != null) {
-      settings.setValue("security.auth.apiKey", plan.legacyCredentials.apiKey);
-    }
-    if (plan.legacyCredentials?.baseUrl != null) {
-      settings.setValue(
-        "security.auth.baseUrl",
-        plan.legacyCredentials.baseUrl
-      );
-    }
-    currentStep = "modelSelection";
-    let effectiveModelSelection = plan.modelSelection;
-    if (effectiveModelSelection?.modelId) {
-      const currentModelId = settings.getValue("model.name");
-      const currentBaseUrl = settings.getValue("model.baseUrl");
-      const planOffersCurrentModel = typeof currentModelId === "string" && currentModelId.length > 0 && (plan.modelProviders ?? []).some(
-        (patch) => patch.models.some(
-          (model) => currentBaseUrl === "" || currentBaseUrl === void 0 ? model.id === currentModelId : isSameModelIdentity(
-            { id: currentModelId, baseUrl: currentBaseUrl },
-            model
-          )
-        )
-      );
-      if (planOffersCurrentModel) {
-        effectiveModelSelection = void 0;
-      }
-    }
-    if (effectiveModelSelection?.modelId) {
-      settings.setValue("model.name", effectiveModelSelection.modelId);
-      if (effectiveModelSelection.baseUrl) {
-        settings.setValue("model.baseUrl", effectiveModelSelection.baseUrl);
-      } else {
-        settings.setValue("model.baseUrl", "");
-      }
-    }
-    currentStep = "providerState";
-    for (const [key, entries] of Object.entries(plan.providerState ?? {})) {
-      for (const [field, value] of Object.entries(entries)) {
-        settings.setValue(`${key}.${field}`, value);
-      }
-    }
-    currentStep = "persist";
-    settings.persist();
-    currentStep = "reloadModelProviders";
-    reloadModelProviders?.(updatedModelProviders);
-    if (effectiveModelSelection?.modelId) {
-      currentStep = "syncAuthState";
-      syncAuthState?.(
-        plan.authType,
-        effectiveModelSelection.modelId,
-        effectiveModelSelection.baseUrl
-      );
-    }
-    if (doRefreshAuth && refreshAuth) {
-      currentStep = "refreshAuth";
-      await refreshAuth(plan.authType);
-    }
-    currentStep = "cleanupBackup";
-    settings.cleanupBackup?.();
-    return { updatedModelProviders };
-  } catch (error) {
-    try {
-      settings.restore?.();
-    } catch (restoreErr) {
-      console.error(
-        "[applyProviderInstallPlan] settings.restore failed during rollback:",
-        restoreErr
-      );
-    }
-    try {
-      for (const [key, prev] of previousEnvValues) {
-        if (prev === void 0) {
-          delete process.env[key];
-        } else {
-          process.env[key] = prev;
-        }
-      }
-    } catch (envErr) {
-      console.error("[applyProviderInstallPlan] env rollback failed:", envErr);
-    }
-    try {
-      reloadModelProviders?.(previousRuntimeProviders);
-    } catch (reloadErr) {
-      console.error(
-        "[applyProviderInstallPlan] reloadModelProviders failed during rollback:",
-        reloadErr
-      );
-    }
-    const errMsg = error instanceof Error ? error.message : String(error);
-    throw new ProviderInstallError(errMsg, currentStep, plan.authType, {
-      cause: error instanceof Error ? error : void 0
-    });
-  }
-}
-__name(applyProviderInstallPlan, "applyProviderInstallPlan");
-
 // packages/core/src/providers/index.ts
 init_esbuild_shims();
 
@@ -4243,6 +4038,7 @@ __name(describe, "describe");
 // packages/core/src/services/web-terminal-registry.ts
 init_esbuild_shims();
 import { spawnSync } from "node:child_process";
+import os from "node:os";
 var MAX_BUFFER_CHUNKS = 4e3;
 var MAX_BUFFER_BYTES = 4 * 1024 * 1024;
 var MAX_UNACKNOWLEDGED_INPUT_BYTES = 256 * 1024;
@@ -4364,8 +4160,31 @@ var WebTerminalRegistry = class {
     delete env2["NO_COLOR"];
     delete env2["FORCE_COLOR"];
     delete env2["npm_config_prefix"];
+    const useBundledConpty = os.platform() === "win32";
+    let queryTerminal;
+    if (useBundledConpty) {
+      const headlessModule = await loadXtermHeadless().catch(() => void 0);
+      if (this.cancelledCreations.has(terminalId)) {
+        this.finishCreating(terminalId);
+        return { error: "Web terminal creation cancelled" };
+      }
+      if (this.disposed) {
+        this.finishCreating(terminalId);
+        return { error: "Web terminal registry disposed" };
+      }
+      if (headlessModule) {
+        queryTerminal = new headlessModule.Terminal({
+          allowProposedApi: true,
+          cols: 80,
+          rows: 24,
+          scrollback: 0,
+          logLevel: "off"
+        });
+      }
+    }
     let spawned;
     let proc;
+    let queryReplyDisposable;
     const sessionRef = {};
     const earlyOutput = [];
     let earlyExit;
@@ -4379,21 +4198,29 @@ var WebTerminalRegistry = class {
         0,
         session2.unacknowledgedInputBytes - Buffer.byteLength(data)
       );
-      if (Buffer.byteLength(data) > MAX_BUFFER_BYTES) {
-        data = Buffer.from(data).subarray(-MAX_BUFFER_BYTES).toString("utf8");
-        while (Buffer.byteLength(data) > MAX_BUFFER_BYTES) data = data.slice(1);
+      if (queryTerminal) {
+        try {
+          queryTerminal.write(data);
+        } catch {
+        }
+      }
+      let buffered = data;
+      if (Buffer.byteLength(buffered) > MAX_BUFFER_BYTES) {
+        buffered = Buffer.from(buffered).subarray(-MAX_BUFFER_BYTES).toString("utf8");
+        while (Buffer.byteLength(buffered) > MAX_BUFFER_BYTES)
+          buffered = buffered.slice(1);
         session2.buffer = [];
         session2.bufferBytes = 0;
       }
-      session2.buffer.push(data);
-      session2.bufferBytes += Buffer.byteLength(data);
+      session2.buffer.push(buffered);
+      session2.bufferBytes += Buffer.byteLength(buffered);
       while (session2.buffer.length > MAX_BUFFER_CHUNKS || session2.bufferBytes > MAX_BUFFER_BYTES) {
         const dropped = session2.buffer.shift();
         if (dropped !== void 0) {
           session2.bufferBytes -= Buffer.byteLength(dropped);
         }
       }
-      for (const listener of session2.outputListeners) listener(data);
+      for (const listener of session2.outputListeners) listener(buffered);
     }, "handleData");
     const handleExit = /* @__PURE__ */ __name((e) => {
       const session2 = sessionRef.current;
@@ -4404,23 +4231,36 @@ var WebTerminalRegistry = class {
       session2.exited = true;
       session2.exitCode = e.exitCode;
       for (const listener of [...session2.exitListeners]) listener(e);
+      setImmediate(() => this.releasePtyResources(session2));
     }, "handleExit");
     let dataDisposable;
     let exitDisposable;
+    const spawnPty = /* @__PURE__ */ __name((useBundled) => ptyImpl.module.spawn(file, args, {
+      name: "xterm-256color",
+      cols: 80,
+      rows: 24,
+      cwd: options.workspaceCwd,
+      env: {
+        ...env2,
+        TERM: "xterm-256color",
+        COLORTERM: "truecolor",
+        CLICOLOR: "1",
+        PROMPT_EOL_MARK: ""
+      },
+      // Windows: with the inbox ConPTY backend a natural shell exit orphans
+      // the `conhost.exe --headless` it spawned (microsoft/node-pty#965);
+      // the bundled backend releases its host reference right after spawn.
+      // Mirrors the #11497 shell path. Off Windows the option is inert:
+      // `useConptyDll` appears nowhere in the POSIX prebuilds.
+      useConptyDll: useBundled
+    }), "spawnPty");
     try {
-      spawned = ptyImpl.module.spawn(file, args, {
-        name: "xterm-256color",
-        cols: 80,
-        rows: 24,
-        cwd: options.workspaceCwd,
-        env: {
-          ...env2,
-          TERM: "xterm-256color",
-          COLORTERM: "truecolor",
-          CLICOLOR: "1",
-          PROMPT_EOL_MARK: ""
-        }
-      });
+      try {
+        spawned = spawnPty(useBundledConpty);
+      } catch (firstError) {
+        if (!useBundledConpty) throw firstError;
+        spawned = spawnPty(false);
+      }
       dataDisposable = spawned.onData(handleData);
       exitDisposable = spawned.onExit(handleExit);
       proc = {
@@ -4441,7 +4281,18 @@ var WebTerminalRegistry = class {
           releaseConPtyHost(spawned);
         }, "releaseHost")
       };
+      if (queryTerminal) {
+        queryReplyDisposable = queryTerminal.onData((reply) => {
+          if (reply !== "\x1B[?1;2c") return;
+          try {
+            proc.write(reply);
+          } catch {
+          }
+        });
+      }
     } catch {
+      queryReplyDisposable?.dispose();
+      queryTerminal?.dispose();
       this.finishCreating(terminalId);
       return { error: "Failed to spawn shell" };
     }
@@ -4455,7 +4306,10 @@ var WebTerminalRegistry = class {
       outputListeners: /* @__PURE__ */ new Set(),
       exitListeners: /* @__PURE__ */ new Set(),
       dataDisposable,
-      exitDisposable
+      exitDisposable,
+      queryTerminal,
+      queryReplyDisposable,
+      ptyResourcesReleased: false
     };
     sessionRef.current = session;
     this.sessions.set(terminalId, session);
@@ -4491,6 +4345,7 @@ var WebTerminalRegistry = class {
       output: session.buffer.join(""),
       exited: session.exited,
       workspaceCwd: session.workspaceCwd,
+      ...session.queryTerminal ? { handlesPrimaryDa: true } : {},
       ...session.exitCode !== void 0 ? { exitCode: session.exitCode } : {}
     };
   }
@@ -4545,16 +4400,12 @@ var WebTerminalRegistry = class {
         listener({ exitCode: 143, signal: 15 });
       }
     }
-    session.dataDisposable?.dispose();
-    session.exitDisposable?.dispose();
     session.outputListeners.clear();
     session.exitListeners.clear();
     if (!session.exited) {
       killPtyTree(session.pty);
-      session.pty.releaseHost?.();
-    } else {
-      session.pty.releaseHost?.();
     }
+    this.releasePtyResources(session);
     return true;
   }
   releaseWorkspace(workspaceCwd) {
@@ -4573,6 +4424,37 @@ var WebTerminalRegistry = class {
     this.creating.delete(terminalId);
     this.cancelledCreations.delete(terminalId);
   }
+  /**
+   * Free a session's PTY-side resources exactly once: detach the data/exit
+   * listeners, dispose the bundled-backend query responder, then release the
+   * ConPTY host / conout worker that node-pty strands on a natural exit.
+   * Without the second half every terminal the user exits leaks a worker for
+   * the life of the CLI — the same defect the shell-tool path has. On the
+   * bundled ConPTY backend this registry spawns with, the host reference is
+   * already released at spawn, so only the conout worker is left to free here;
+   * the conhost.exe half survives solely on the inbox spawn-failure retry,
+   * where the native baton is already gone. See releaseConPtyHost and #11303.
+   *
+   * Deliberately leaves the session's map entry and its `buffer` alone, and
+   * never signals the pid: on the exited path the shell is gone and its pid may
+   * be recycled, which is why #11313 added `releaseHost` instead of reusing
+   * `kill()`. Keeping the entry is what lets `readSnapshot()` still replay the
+   * scrollback after an exit-time release.
+   *
+   * Called from `handleExit` (deferred one turn, so an exited web terminal
+   * stops holding the worker for the whole idle-reclaim window — #11353) and
+   * from `release()` on both of its arms, where the flag keeps a release that
+   * follows an exit-time release from disposing anything twice.
+   */
+  releasePtyResources(session) {
+    if (session.ptyResourcesReleased) return;
+    session.ptyResourcesReleased = true;
+    session.dataDisposable?.dispose();
+    session.exitDisposable?.dispose();
+    session.queryReplyDisposable?.dispose();
+    session.queryTerminal?.dispose();
+    session.pty.releaseHost?.();
+  }
   clearReclaim(session) {
     if (session.reclaimTimer) {
       clearTimeout(session.reclaimTimer);
@@ -5621,20 +5503,33 @@ var AUTHORITATIVE_OBJECTIVE_LINE = "The objective in that data block is the curr
 var OBJECTIVE_UPDATED_LINE = "The Goal objective changed since your last turn: the objective above replaces the one you were working on. Stop work that only served the previous objective, and carry over only what also serves this one.";
 function renderBudgetLine(usage) {
   const used = usage.tokensUsed.toLocaleString("en-US");
-  const spend = usage.tokenBudget === void 0 ? `${used} tokens used, with no budget on this Goal` : `${used} of ${usage.tokenBudget.toLocaleString("en-US")} tokens used, ${Math.max(
-    0,
-    usage.tokenBudget - usage.tokensUsed
-  ).toLocaleString("en-US")} remaining`;
-  const turns = `${usage.turnCount} Goal ${usage.turnCount === 1 ? "turn" : "turns"} finished`;
-  return `Token budget: ${spend}; ${turns}.`;
+  const segments = [
+    usage.tokenBudget === void 0 ? `${used} tokens used, with no token budget on this Goal` : `${used} of ${usage.tokenBudget.toLocaleString("en-US")} tokens used, ${Math.max(
+      0,
+      usage.tokenBudget - usage.tokensUsed
+    ).toLocaleString("en-US")} remaining`,
+    usage.turnBudget === void 0 ? `${usage.turnCount} Goal ${usage.turnCount === 1 ? "turn" : "turns"} finished` : `${usage.turnCount} of ${usage.turnBudget.toLocaleString("en-US")} Goal turns finished`
+  ];
+  if (usage.activeTimeBudgetMs !== void 0 && usage.activeTimeMs !== void 0) {
+    segments.push(
+      `${renderActiveMinutes(usage.activeTimeMs)} of ${renderActiveMinutes(
+        usage.activeTimeBudgetMs
+      )} active minutes used`
+    );
+  }
+  return `Budget: ${segments.join("; ")}.`;
 }
 __name(renderBudgetLine, "renderBudgetLine");
+function renderActiveMinutes(ms) {
+  return (ms / 6e4).toLocaleString("en-US", { maximumFractionDigits: 1 });
+}
+__name(renderActiveMinutes, "renderActiveMinutes");
 var EVIDENCE_LINE = "Treat the workspace and this turn's tool results as authoritative. Re-inspect state rather than relying on what earlier turns in this conversation reported.";
 var FIDELITY_LINE = "Work toward the end state the objective asks for. Do not substitute a narrower or more easily reached result, and do not redefine success around what already exists.";
 var NO_PROGRESS_LINE = "Judge your previous Goal turn before acting: it made progress only if it changed the workspace or produced evidence that changes what to do next. If it did not, take a different concrete action now instead of restating status; if the same blocker still stands, cite it through update_goal rather than repeating it.";
 var COMPLETION_AUDIT_LINE = "Before proposing that the Goal is complete, check every explicit requirement in the objective against evidence you can cite. Missing, indirect, or self-reported evidence means not done: keep working.";
 var WIND_DOWN_LINES = [
-  "The autonomous token budget for this Goal window is spent. This is the final turn before the Goal stops and waits for the user; do not start new work.",
+  "An autonomous budget for this Goal window is spent -- the budget line above says which. This is the final turn before the Goal stops and waits for the user; do not start new work.",
   "Deliver a concise hand-off: what was accomplished, citing evidence references from get_goal; what remains; and the one concrete next step. Call update_goal only if the objective is already complete or genuinely blocked on the evidence you have. Then end the turn."
 ];
 function serializeGoalData(input) {
@@ -6300,7 +6195,7 @@ var Logger = class {
 // packages/core/src/core/output-style-files.ts
 init_esbuild_shims();
 import * as fs4 from "fs/promises";
-import * as os from "os";
+import * as os2 from "os";
 import * as path6 from "path";
 var debugLogger11 = createDebugLogger("OUTPUT_STYLE_FILES");
 var OUTPUT_STYLES_DIR_NAME = "output-styles";
@@ -6544,7 +6439,7 @@ function getUserOutputStylesRoot() {
   if (envDir) {
     return Storage.getGlobalQwenDir();
   }
-  return os.homedir() || path6.dirname(Storage.getGlobalQwenDir());
+  return os2.homedir() || path6.dirname(Storage.getGlobalQwenDir());
 }
 __name(getUserOutputStylesRoot, "getUserOutputStylesRoot");
 function getProjectOutputStylesDir(projectRoot) {
@@ -9097,8 +8992,8 @@ ${trimmed}
   }
   const sectionIdx = existing.indexOf(MEMORY_SECTION_HEADER);
   if (sectionIdx === -1) {
-    const sep5 = existing.endsWith("\n") ? "" : "\n";
-    return `${existing}${sep5}
+    const sep6 = existing.endsWith("\n") ? "" : "\n";
+    return `${existing}${sep6}
 ${MEMORY_SECTION_HEADER}
 ${trimmed}
 `;
@@ -9106,15 +9001,15 @@ ${trimmed}
   const afterHeaderIdx = sectionIdx + MEMORY_SECTION_HEADER.length;
   const nextHeaderRel = findNextTopLevelHeading(existing, afterHeaderIdx);
   if (nextHeaderRel === -1) {
-    const sep5 = existing.endsWith("\n") ? "" : "\n";
-    return `${existing}${sep5}${trimmed}
+    const sep6 = existing.endsWith("\n") ? "" : "\n";
+    return `${existing}${sep6}${trimmed}
 `;
   }
   const insertAt = afterHeaderIdx + nextHeaderRel;
   const before = existing.slice(0, insertAt);
   const after = existing.slice(insertAt);
-  const sep4 = before.endsWith("\n") ? "" : "\n";
-  return `${before}${sep4}${trimmed}
+  const sep5 = before.endsWith("\n") ? "" : "\n";
+  return `${before}${sep5}${trimmed}
 ${after}`;
 }
 __name(composeAppendedContent, "composeAppendedContent");
@@ -9164,7 +9059,7 @@ import * as child_process from "node:child_process";
 import * as process2 from "node:process";
 import * as path10 from "node:path";
 import * as fs8 from "node:fs";
-import * as os2 from "node:os";
+import * as os3 from "node:os";
 function getVsCodeCommand(platform2 = process2.platform) {
   return platform2 === "win32" ? "code.cmd" : "code";
 }
@@ -9187,7 +9082,7 @@ async function findVsCodeCommand(platform2 = process2.platform) {
   } catch {
   }
   const locations = [];
-  const homeDir = os2.homedir();
+  const homeDir = os3.homedir();
   if (platform2 === "darwin") {
     locations.push(
       "/Applications/Visual Studio Code.app/Contents/Resources/app/bin/code",
@@ -9345,6 +9240,9 @@ var CODE_ACTION_KIND_LABELS = {
 // packages/core/src/lsp/configHash.ts
 init_esbuild_shims();
 import { createHash as createHash4 } from "node:crypto";
+
+// packages/core/src/lsp/sort-json-value.ts
+init_esbuild_shims();
 function sortJsonValue(value) {
   if (Array.isArray(value)) {
     return value.map(sortJsonValue);
@@ -9359,6 +9257,8 @@ function sortJsonValue(value) {
   return value;
 }
 __name(sortJsonValue, "sortJsonValue");
+
+// packages/core/src/lsp/configHash.ts
 function lspServerConfigHash(config) {
   const hashInput = {
     name: config.name,
@@ -10792,12 +10692,22 @@ ${value}
   }
 };
 
-// packages/core/src/lsp/LspServerManager.ts
+// packages/core/src/lsp/lsp-server-manager.ts
 init_esbuild_shims();
 import { spawn as spawn2 } from "node:child_process";
-import * as fs10 from "node:fs";
 import * as path12 from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
+
+// packages/core/src/lsp/types.ts
+init_esbuild_shims();
+function resolveTextDocumentSync(sync) {
+  const change = typeof sync === "number" ? sync : sync?.change ?? 0;
+  const openClose = typeof sync === "number" ? sync !== 0 : sync?.openClose ?? false;
+  return { change, openClose };
+}
+__name(resolveTextDocumentSync, "resolveTextDocumentSync");
+
+// packages/core/src/lsp/lsp-server-manager.ts
 var debugLogger20 = createDebugLogger("LSP");
 var SECURITY_SENSITIVE_ENV_KEYS = /* @__PURE__ */ new Set([
   "DYLD_INSERT_LIBRARIES",
@@ -10934,7 +10844,9 @@ var LspServerManager = class {
         continue;
       }
       const nextHash = desiredHashes.get(name);
-      if (this.serverConfigHashes.get(name) !== nextHash) {
+      if (this.serverConfigHashes.get(name) === nextHash) {
+        result.unchanged.push(name);
+      } else {
         await this.abortAndWaitForStartup(handle);
         await this.stopServer(name, handle);
         const nextHandle = {
@@ -10952,8 +10864,6 @@ var LspServerManager = class {
           }
           result.restarted.push(name);
         }
-      } else {
-        result.unchanged.push(name);
       }
     }
     for (const [name, config] of desiredConfigs) {
@@ -10992,47 +10902,46 @@ var LspServerManager = class {
   }
   /**
    * Ensure tsserver has at least one file open so navto/navtree requests succeed.
-   * Sets warmedUp flag only after successful warm-up to allow retry on failure.
+   * Latches unsupported attempts to avoid repeated discovery; delivery failures retry.
    *
    * @param handle - The LSP server handle
    * @param force - Force re-warmup even if already warmed up
-   * @returns The URI of the file opened during warmup, or undefined if no file was opened
+   * @param synchronizeDocument - Service-owned synchronization of the warmup file
    */
-  async warmupTypescriptServer(handle, force = false) {
+  async warmupTypescriptServer(handle, synchronizeDocument, force = false) {
     if (!handle.connection || !this.isTypescriptServer(handle)) {
-      return void 0;
+      return;
     }
     if (handle.warmedUp && !force) {
-      return void 0;
+      return;
     }
+    const connection = handle.connection;
     const tsFile = this.findFirstTypescriptFile();
     if (!tsFile) {
-      return void 0;
+      return;
     }
+    if (force) handle.warmedUp = false;
     const uri = pathToFileURL2(tsFile).toString();
     const languageId = tsFile.endsWith(".tsx") ? "typescriptreact" : tsFile.endsWith(".jsx") ? "javascriptreact" : tsFile.endsWith(".js") ? "javascript" : "typescript";
     try {
-      const text = fs10.readFileSync(tsFile, "utf-8");
-      handle.connection.send({
-        jsonrpc: "2.0",
-        method: "textDocument/didOpen",
-        params: {
-          textDocument: {
-            uri,
-            languageId,
-            version: 1,
-            text
-          }
-        }
-      });
+      const sent = synchronizeDocument(uri, languageId);
+      const { change, openClose } = resolveTextDocumentSync(
+        handle.textDocumentSync
+      );
+      if (!sent && (!openClose || force && change !== 1 && change !== 2)) {
+        debugLogger20.warn(
+          `TypeScript server ${handle.config.name} warm-up delivered no notification (textDocumentSync=${JSON.stringify(handle.textDocumentSync)})`
+        );
+        handle.warmedUp = true;
+        return;
+      }
       await new Promise(
         (resolve7) => setTimeout(resolve7, DEFAULT_LSP_WARMUP_DELAY_MS)
       );
-      handle.warmedUp = true;
-      return uri;
+      if (handle.connection === connection) handle.warmedUp = true;
     } catch (error) {
       debugLogger20.warn("TypeScript server warm-up failed:", error);
-      return void 0;
+      return;
     }
   }
   /**
@@ -11127,6 +11036,7 @@ var LspServerManager = class {
       handle.error = void 0;
       handle.processDiagnostics = void 0;
       handle.warmedUp = false;
+      handle.textDocumentSync = void 0;
       handle.status = "IN_PROGRESS";
       debugLogger20.info(
         `Starting LSP server ${name}: command=${handle.config.command ?? "<none>"}, transport=${handle.config.transport}, languages=${formatServerNames(
@@ -11142,7 +11052,7 @@ var LspServerManager = class {
       handle.processDiagnostics = connection.processDiagnostics;
       const startupExit = this.createStartupExitWatcher(name, handle);
       try {
-        await this.raceStartupAbort(
+        handle.textDocumentSync = await this.raceStartupAbort(
           this.initializeLspServer(connection, handle.config),
           startupAbortController.signal,
           void 0,
@@ -11722,7 +11632,7 @@ var LspServerManager = class {
       },
       initializationOptions: config.initializationOptions
     };
-    await connection.initialize(initializeParams);
+    const result = await connection.initialize(initializeParams);
     connection.connection.send({
       jsonrpc: "2.0",
       method: "initialized",
@@ -11747,6 +11657,7 @@ var LspServerManager = class {
         }
       });
     }
+    return result?.capabilities?.textDocumentSync;
   }
   /**
    * Check if command exists by spawning it with --version.
@@ -12071,11 +11982,12 @@ var NativeLspClient = class {
   }
 };
 
-// packages/core/src/lsp/NativeLspService.ts
+// packages/core/src/lsp/native-lsp-service.ts
 init_esbuild_shims();
 import * as path13 from "path";
 import { fileURLToPath, pathToFileURL as pathToFileURL3 } from "url";
-import * as fs11 from "node:fs";
+import * as fs10 from "node:fs";
+import { createHash as createHash5, createHmac, randomBytes as randomBytes4 } from "node:crypto";
 import { promises as fsp } from "node:fs";
 var debugLogger21 = createDebugLogger("LSP");
 var LANGUAGE_ID_TO_EXTENSIONS = {
@@ -12093,6 +12005,16 @@ var DEFAULT_EXCLUDE_PATTERNS = [
   "**/dist/**",
   "**/build/**"
 ];
+var StaleCallHierarchyItemError = class extends Error {
+  static {
+    __name(this, "StaleCallHierarchyItemError");
+  }
+  constructor(uri) {
+    super(
+      uri ? `Call hierarchy item is stale or has unknown provenance; prepare call hierarchy again at a current location inside ${uri}.` : "Call hierarchy item is stale or has unknown provenance; prepare call hierarchy again."
+    );
+  }
+};
 var NativeLspService = class {
   static {
     __name(this, "NativeLspService");
@@ -12106,7 +12028,15 @@ var NativeLspService = class {
   serverManager;
   normalizer;
   openedDocuments = /* @__PURE__ */ new Map();
+  documentLifecycles = /* @__PURE__ */ new Map();
+  workspaceSymbolFiles = /* @__PURE__ */ new WeakMap();
+  snapshotDigests = /* @__PURE__ */ new WeakMap();
+  callHierarchySecrets = /* @__PURE__ */ new WeakMap();
   lastConnections = /* @__PURE__ */ new Map();
+  // URIs to re-deliver after a connection swap or synchronization failure.
+  // openedDocuments selects didOpen/didChange and is wiped on connection changes; this
+  // set survives that wipe so a later workspaceDiagnostics can still replay them.
+  replayUris = /* @__PURE__ */ new Map();
   reinitializeQueue = Promise.resolve();
   reinitializeAbortController;
   stopping = false;
@@ -12282,15 +12212,39 @@ var NativeLspService = class {
   clearDocumentTrackingForServers(serverNames) {
     for (const name of serverNames) {
       this.openedDocuments.delete(name);
+      this.documentLifecycles.delete(name);
       this.lastConnections.delete(name);
+      this.replayUris.delete(name);
     }
   }
+  /** The tracked set for one server: delivered documents and durable replay obligations. */
+  trackedUrisFor(serverName) {
+    return /* @__PURE__ */ new Set([
+      ...this.openedDocuments.get(serverName)?.keys() ?? [],
+      ...this.replayUris.get(serverName) ?? []
+    ]);
+  }
+  /**
+   * Drop the delivered snapshot without dropping the obligation to re-deliver it: a
+   * connection change wipes openedDocuments, but a later sweep must still know what the
+   * new connection never received. Callers keep lastConnections bookkeeping themselves.
+   */
+  parkTrackedUris(serverName) {
+    const prior = this.openedDocuments.get(serverName);
+    if (prior && prior.size > 0) {
+      const durable = this.replayUris.get(serverName) ?? /* @__PURE__ */ new Set();
+      for (const tracked of prior.keys()) durable.add(tracked);
+      this.replayUris.set(serverName, durable);
+    }
+    this.openedDocuments.delete(serverName);
+    this.documentLifecycles.delete(serverName);
+  }
   snapshotOpenDocuments(serverNames) {
     const snapshots = /* @__PURE__ */ new Map();
     for (const name of serverNames) {
-      const documents = this.openedDocuments.get(name);
-      if (documents) {
-        snapshots.set(name, new Set(documents));
+      const uris = this.trackedUrisFor(name);
+      if (uris.size > 0) {
+        snapshots.set(name, uris);
       }
     }
     return snapshots;
@@ -12312,7 +12266,7 @@ var NativeLspService = class {
       for (const uri of documents) {
         this.throwIfReinitializeAborted(signal);
         try {
-          openedAny = this.sendDocumentOpen(name, handle, uri) || openedAny;
+          openedAny = this.synchronizeDocument(name, handle, uri).sent || openedAny;
         } catch (error) {
           debugLogger21.warn(
             `Failed to replay document ${uri} for LSP server ${name}:`,
@@ -12343,7 +12297,9 @@ var NativeLspService = class {
     this.reinitializeAbortController?.abort();
     await this.serverManager.stopAll();
     this.openedDocuments.clear();
+    this.documentLifecycles.clear();
     this.lastConnections.clear();
+    this.replayUris.clear();
   }
   /**
    * Get LSP server status
@@ -12374,11 +12330,11 @@ var NativeLspService = class {
           ...handle.config.rootUri ? { rootUri: handle.config.rootUri } : {},
           ...handle.config.workspaceFolder ? { workspaceFolder: handle.config.workspaceFolder } : {},
           ...handle.process?.pid ? { pid: handle.process.pid } : {},
-          ...handle.warmedUp !== void 0 ? { warmedUp: handle.warmedUp } : {},
-          ...handle.restartAttempts !== void 0 ? { restartAttempts: handle.restartAttempts } : {},
+          ...handle.warmedUp === void 0 ? {} : { warmedUp: handle.warmedUp },
+          ...handle.restartAttempts === void 0 ? {} : { restartAttempts: handle.restartAttempts },
           ...handle.processDiagnostics?.stderrTail ? { stderrTail: handle.processDiagnostics.stderrTail } : {},
-          ...handle.processDiagnostics?.exitCode !== void 0 ? { exitCode: handle.processDiagnostics.exitCode } : {},
-          ...handle.processDiagnostics?.exitSignal !== void 0 ? { exitSignal: handle.processDiagnostics.exitSignal } : {},
+          ...handle.processDiagnostics?.exitCode === void 0 ? {} : { exitCode: handle.processDiagnostics.exitCode },
+          ...handle.processDiagnostics?.exitSignal === void 0 ? {} : { exitSignal: handle.processDiagnostics.exitSignal },
           ...error ? { error } : {}
         };
       }
@@ -12409,83 +12365,154 @@ var NativeLspService = class {
       (entry) => entry[1].status === "READY" && entry[1].connection !== void 0 && (!serverName || entry[0] === serverName)
     );
   }
-  /**
-   * Ensure a document is open on the given LSP server. Sends textDocument/didOpen
-   * if not already tracked, then waits for the server to process the file before
-   * returning. This delay prevents empty results when the server hasn't analyzed
-   * the file yet.
-   *
-   * @param serverName - The name of the LSP server
-   * @param handle - The server handle with an active connection
-   * @param uri - The document URI to open
-   * @returns true if a new didOpen was sent; false if already open or failed
-   */
-  async ensureDocumentOpen(serverName, handle, uri) {
-    const lastConnection = this.lastConnections.get(serverName);
-    if (lastConnection && lastConnection !== handle.connection) {
-      this.openedDocuments.delete(serverName);
-    }
-    if (!this.sendDocumentOpen(serverName, handle, uri)) {
-      return false;
+  /** Synchronize disk text before a query; only a new didOpen needs warmup delay. */
+  async ensureDocumentSynchronized(serverName, handle, uri) {
+    const { opened: justOpened } = this.synchronizeDocument(
+      serverName,
+      handle,
+      uri
+    );
+    if (justOpened) {
+      await this.delay(DEFAULT_LSP_DOCUMENT_OPEN_DELAY_MS);
     }
-    await this.delay(DEFAULT_LSP_DOCUMENT_OPEN_DELAY_MS);
-    return true;
+    return justOpened;
   }
-  sendDocumentOpen(serverName, handle, uri) {
+  synchronizeDocument(serverName, handle, uri, languageId, force = false) {
     if (!uri.startsWith("file://")) {
-      return false;
+      return { sent: false, opened: false };
     }
-    const openedForServer = this.openedDocuments.get(serverName);
-    if (openedForServer?.has(uri)) {
-      return false;
+    if (!handle.connection || this.serverManager.getHandles().get(serverName) !== handle) {
+      throw new Error(
+        `LSP server ${serverName} connection is no longer active`
+      );
+    }
+    if (this.lastConnections.get(serverName) !== handle.connection) {
+      this.parkTrackedUris(serverName);
+      this.lastConnections.set(serverName, handle.connection);
+    }
+    const documents = this.openedDocuments.get(serverName) ?? /* @__PURE__ */ new Map();
+    const lifecycles = this.documentLifecycles.get(serverName) ?? /* @__PURE__ */ new Map();
+    this.documentLifecycles.set(serverName, lifecycles);
+    const lifecycle = lifecycles.get(uri);
+    if (lifecycle?.pendingClose) {
+      try {
+        this.closeUnsynchronizableDocument(serverName, handle, uri);
+      } catch (error) {
+        throw new Error(
+          `LSP server ${serverName} still cannot close ${uri}; refusing to reopen it (${error.message})`,
+          { cause: error }
+        );
+      }
+    }
+    const previous = documents.get(uri);
+    const { change, openClose } = resolveTextDocumentSync(
+      handle.textDocumentSync
+    );
+    if (!previous && !openClose) {
+      return { sent: false, opened: false };
     }
     let filePath;
+    let text;
     try {
       filePath = fileURLToPath(uri);
+      text = fs10.readFileSync(filePath, "utf-8");
     } catch (error) {
-      debugLogger21.warn(`Failed to resolve file path for ${uri}:`, error);
-      return false;
+      const replay = this.replayUris.get(serverName) ?? /* @__PURE__ */ new Set();
+      if (previous || replay.has(uri)) {
+        const readFailures = (lifecycle?.readFailures ?? 0) + 1;
+        lifecycles.set(uri, {
+          version: previous?.version ?? lifecycle?.version ?? 0,
+          readFailures,
+          ...previous ? { pendingClose: { error } } : {}
+        });
+        if (readFailures < 2) replay.add(uri);
+        else replay.delete(uri);
+        this.replayUris.set(serverName, replay);
+        if (previous) {
+          documents.delete(uri);
+          this.closeUnsynchronizableDocument(serverName, handle, uri);
+        }
+      }
+      throw error;
     }
-    let text;
-    try {
-      text = fs11.readFileSync(filePath, "utf-8");
-    } catch (error) {
-      debugLogger21.warn(
-        `Failed to read file for LSP didOpen: ${filePath}`,
-        error
-      );
-      return false;
+    if (lifecycle) delete lifecycle.readFailures;
+    if (previous?.text === text && !force) {
+      return { sent: false, opened: false };
     }
-    const languageId = this.resolveLanguageId(filePath, handle) ?? "plaintext";
-    handle.connection.send({
-      jsonrpc: "2.0",
-      method: "textDocument/didOpen",
-      params: {
-        textDocument: {
-          uri,
-          languageId,
-          version: 1,
-          text
+    const version = (previous?.version ?? lifecycle?.version ?? 0) + 1;
+    if (!previous && openClose) {
+      handle.connection.send({
+        jsonrpc: "2.0",
+        method: "textDocument/didOpen",
+        params: {
+          textDocument: {
+            uri,
+            languageId: languageId ?? this.resolveLanguageId(filePath, handle) ?? "plaintext",
+            version,
+            text
+          }
         }
+      });
+    } else if (previous) {
+      if (change !== 1 && change !== 2) {
+        if (previous.text === text) return { sent: false, opened: false };
+        const error = new Error(
+          `LSP server ${serverName} cannot synchronize changed document ${uri}: textDocumentSync.change is None or absent`
+        );
+        lifecycles.set(uri, {
+          version: previous.version,
+          pendingClose: { error }
+        });
+        documents.delete(uri);
+        const replay = this.replayUris.get(serverName) ?? /* @__PURE__ */ new Set();
+        replay.add(uri);
+        this.replayUris.set(serverName, replay);
+        this.closeUnsynchronizableDocument(serverName, handle, uri);
+        throw error;
       }
-    });
-    this.lastConnections.set(serverName, handle.connection);
-    const nextOpened = openedForServer ?? /* @__PURE__ */ new Set();
-    nextOpened.add(uri);
-    this.openedDocuments.set(serverName, nextOpened);
-    return true;
+      const contentChange = { text };
+      if (change === 2) {
+        const lines = previous.text.split(/\r\n|\r|\n/);
+        contentChange.range = {
+          start: { line: 0, character: 0 },
+          end: {
+            line: lines.length - 1,
+            character: lines[lines.length - 1].length
+          }
+        };
+      }
+      handle.connection.send({
+        jsonrpc: "2.0",
+        method: "textDocument/didChange",
+        params: {
+          textDocument: { uri, version },
+          contentChanges: [contentChange]
+        }
+      });
+    }
+    documents.set(uri, { text, version });
+    lifecycles.set(uri, { version });
+    this.openedDocuments.set(serverName, documents);
+    return { sent: true, opened: !previous && openClose };
   }
-  /**
-   * Register a URI that was opened externally (e.g. by warmupTypescriptServer)
-   * so that ensureDocumentOpen does not send a duplicate textDocument/didOpen.
-   *
-   * @param serverName - The name of the LSP server
-   * @param uri - The document URI to track as already opened
-   */
-  trackExternallyOpenedDocument(serverName, uri) {
-    const openedForServer = this.openedDocuments.get(serverName) ?? /* @__PURE__ */ new Set();
-    openedForServer.add(uri);
-    this.openedDocuments.set(serverName, openedForServer);
+  closeUnsynchronizableDocument(serverName, handle, uri) {
+    const lifecycle = this.documentLifecycles.get(serverName)?.get(uri);
+    if (!lifecycle?.pendingClose) return;
+    const originalError = lifecycle.pendingClose.error;
+    const connection = this.lastConnections.get(serverName);
+    if (connection !== handle.connection || this.serverManager.getHandles().get(serverName) !== handle) {
+      throw originalError;
+    }
+    try {
+      connection.send({
+        jsonrpc: "2.0",
+        method: "textDocument/didClose",
+        params: { textDocument: { uri } }
+      });
+    } catch {
+      throw originalError;
+    }
+    delete lifecycle.pendingClose;
   }
   resolveLanguageId(filePath, handle) {
     const ext = path13.extname(filePath).slice(1).toLowerCase();
@@ -12503,24 +12530,51 @@ var NativeLspService = class {
       return false;
     }
     const openedForServer = this.openedDocuments.get(serverName);
-    if (openedForServer && openedForServer.size > 0) {
+    if (this.lastConnections.get(serverName) === handle.connection && openedForServer && openedForServer.size > 0) {
       return true;
     }
-    const filePath = this.findWorkspaceFileForServer(handle);
-    if (!filePath) {
-      return false;
+    const connection = handle.connection;
+    let filePath = this.workspaceSymbolFiles.get(connection);
+    if (filePath && !this.isUsableWorkspaceSymbolFile(filePath)) {
+      this.workspaceSymbolFiles.delete(connection);
+      filePath = void 0;
     }
+    filePath ??= this.findWorkspaceFileForServer(handle);
+    if (!filePath) return false;
     const uri = pathToFileURL3(filePath).toString();
-    const didOpen = await this.ensureDocumentOpen(
-      serverName,
-      handle,
-      uri
-    );
-    if (!didOpen) {
+    try {
+      if (!this.isUsableWorkspaceSymbolFile(filePath)) {
+        throw new Error(
+          "Workspace symbol warmup candidate is no longer usable."
+        );
+      }
+      await this.ensureDocumentSynchronized(
+        serverName,
+        handle,
+        uri
+      );
+    } catch (error) {
+      debugLogger21.warn(
+        `LSP workspace symbol warmup skipped for ${uri}:`,
+        error
+      );
+      this.workspaceSymbolFiles.delete(connection);
       return false;
     }
+    this.workspaceSymbolFiles.set(connection, filePath);
     await this.delay(DEFAULT_LSP_WORKSPACE_SYMBOL_WARMUP_DELAY_MS);
-    return true;
+    return handle.connection === connection;
+  }
+  isUsableWorkspaceSymbolFile(filePath) {
+    try {
+      if (!fs10.statSync(filePath).isFile()) return false;
+      fs10.accessSync(filePath, fs10.constants.R_OK);
+    } catch {
+      return false;
+    }
+    return this.workspaceContext.getDirectories().some(
+      (root) => filePath.startsWith(root.endsWith(path13.sep) ? root : root + path13.sep)
+    );
   }
   /**
    * Find the first source file in the workspace that matches the server's
@@ -12552,7 +12606,7 @@ var NativeLspService = class {
           }
           return match;
         }
-      } catch (_error) {
+      } catch {
       }
     }
     return void 0;
@@ -12598,13 +12652,21 @@ var NativeLspService = class {
    * @param force - Force re-warmup even if already warmed up
    */
   async warmupAndTrack(serverName, handle, force = false) {
-    const warmupUri = await this.serverManager.warmupTypescriptServer(
+    if (!handle.connection) {
+      return;
+    }
+    const connectedHandle = handle;
+    await this.serverManager.warmupTypescriptServer(
       handle,
+      (uri, languageId) => this.synchronizeDocument(
+        serverName,
+        connectedHandle,
+        uri,
+        languageId,
+        force
+      ).sent,
       force
     );
-    if (warmupUri) {
-      this.trackExternallyOpenedDocument(serverName, warmupUri);
-    }
   }
   /**
    * Whether we should retry a document-level operation that returned empty
@@ -12697,12 +12759,12 @@ var NativeLspService = class {
     };
     for (const [name, handle] of handles) {
       try {
-        const justOpened = await this.ensureDocumentOpen(
+        await this.warmupAndTrack(name, handle);
+        const justOpened = await this.ensureDocumentSynchronized(
           name,
           handle,
           location.uri
         );
-        await this.warmupAndTrack(name, handle);
         let response = await handle.connection.request(
           "textDocument/definition",
           requestParams
@@ -12749,12 +12811,12 @@ var NativeLspService = class {
     };
     for (const [name, handle] of handles) {
       try {
-        const justOpened = await this.ensureDocumentOpen(
+        await this.warmupAndTrack(name, handle);
+        const justOpened = await this.ensureDocumentSynchronized(
           name,
           handle,
           location.uri
         );
-        await this.warmupAndTrack(name, handle);
         let response = await handle.connection.request(
           "textDocument/references",
           requestParams
@@ -12802,12 +12864,12 @@ var NativeLspService = class {
     };
     for (const [name, handle] of handles) {
       try {
-        const justOpened = await this.ensureDocumentOpen(
+        await this.warmupAndTrack(name, handle);
+        const justOpened = await this.ensureDocumentSynchronized(
           name,
           handle,
           location.uri
         );
-        await this.warmupAndTrack(name, handle);
         let response = await handle.connection.request(
           "textDocument/hover",
           requestParams
@@ -12837,8 +12899,12 @@ var NativeLspService = class {
     const requestParams = { textDocument: { uri } };
     for (const [name, handle] of handles) {
       try {
-        const justOpened = await this.ensureDocumentOpen(name, handle, uri);
         await this.warmupAndTrack(name, handle);
+        const justOpened = await this.ensureDocumentSynchronized(
+          name,
+          handle,
+          uri
+        );
         let response = await handle.connection.request(
           "textDocument/documentSymbol",
           requestParams
@@ -12903,12 +12969,12 @@ var NativeLspService = class {
     };
     for (const [name, handle] of handles) {
       try {
-        const justOpened = await this.ensureDocumentOpen(
+        await this.warmupAndTrack(name, handle);
+        const justOpened = await this.ensureDocumentSynchronized(
           name,
           handle,
           location.uri
         );
-        await this.warmupAndTrack(name, handle);
         let response = await handle.connection.request(
           "textDocument/implementation",
           requestParams
@@ -12946,6 +13012,95 @@ var NativeLspService = class {
     }
     return [];
   }
+  captureCallHierarchyRevision(name, handle, uri) {
+    const connection = handle.connection;
+    const assertActive = /* @__PURE__ */ __name(() => {
+      if (!connection || handle.connection !== connection || handle.status !== "READY" || this.serverManager.getHandles().get(name) !== handle) {
+        throw new StaleCallHierarchyItemError();
+      }
+    }, "assertActive");
+    assertActive();
+    const readText = /* @__PURE__ */ __name((target) => {
+      try {
+        return fs10.readFileSync(fileURLToPath(target), "utf-8");
+      } catch {
+        return void 0;
+      }
+    }, "readText");
+    const snapshots = new Map(
+      this.lastConnections.get(name) === connection ? this.openedDocuments.get(name) : void 0
+    );
+    const observations = /* @__PURE__ */ new Map();
+    if (!snapshots.has(uri) && uri.startsWith("file://")) {
+      const text = readText(uri);
+      observations.set(uri, text);
+      if (text !== void 0)
+        snapshots.set(uri, {
+          text,
+          version: this.lastConnections.get(name) === connection ? this.documentLifecycles.get(name)?.get(uri)?.version ?? 0 : 0
+        });
+    }
+    const isFresh = /* @__PURE__ */ __name((target) => {
+      assertActive();
+      const snapshot = snapshots.get(target);
+      if (!snapshot) return false;
+      const current = this.lastConnections.get(name) === connection ? this.openedDocuments.get(name)?.get(target) : void 0;
+      const lifecycle = this.lastConnections.get(name) === connection ? this.documentLifecycles.get(name)?.get(target) : void 0;
+      if (!observations.has(target)) observations.set(target, readText(target));
+      return !lifecycle?.pendingClose && (current?.version ?? lifecycle?.version ?? 0) === snapshot.version && (!current || current.text === snapshot.text) && // A previously delivered snapshot must still be open, not just identical on disk.
+      (snapshot.version === 0 || current === snapshot) && observations.get(target) === snapshot.text;
+    }, "isFresh");
+    const assertRoot = /* @__PURE__ */ __name(() => {
+      assertActive();
+      if (uri.startsWith("file://") && !isFresh(uri))
+        throw new StaleCallHierarchyItemError(uri);
+    }, "assertRoot");
+    assertRoot();
+    let secret = this.callHierarchySecrets.get(connection);
+    if (!secret) {
+      secret = randomBytes4(32);
+      this.callHierarchySecrets.set(connection, secret);
+    }
+    return {
+      checkpoint: /* @__PURE__ */ __name(() => {
+        observations.clear();
+        assertRoot();
+      }, "checkpoint"),
+      sign: /* @__PURE__ */ __name((item) => {
+        assertActive();
+        if (!item.uri.startsWith("file://")) return void 0;
+        if (!isFresh(item.uri)) {
+          if (item.uri === uri) throw new StaleCallHierarchyItemError();
+          return void 0;
+        }
+        const snapshot = snapshots.get(item.uri);
+        let digest = this.snapshotDigests.get(snapshot);
+        if (!digest) {
+          digest = createHash5("sha256").update(snapshot.text).digest("hex");
+          this.snapshotDigests.set(snapshot, digest);
+        }
+        return createHmac("sha256", secret).update(
+          JSON.stringify(
+            sortJsonValue([
+              name,
+              this.normalizer.toCallHierarchyItemParams(item),
+              { digest, version: snapshot.version }
+            ])
+          )
+        ).digest("hex");
+      }, "sign")
+    };
+  }
+  validateCallHierarchyItem(item, revision) {
+    if (!item.uri.startsWith("file://")) {
+      throw new Error(
+        `Call hierarchy item ${item.uri} has no verifiable disk snapshot and cannot be traversed; prepare call hierarchy at a file location instead.`
+      );
+    }
+    if (!item.documentRevision || item.documentRevision !== revision.sign(item)) {
+      throw new StaleCallHierarchyItemError(item.uri);
+    }
+  }
   /**
    * Prepare call hierarchy
    */
@@ -12956,42 +13111,81 @@ var NativeLspService = class {
       position: location.range.start
     };
     for (const [name, handle] of handles) {
+      const connection = handle.connection;
+      let revision;
       try {
-        const justOpened = await this.ensureDocumentOpen(
+        let originalText;
+        if (location.uri.startsWith("file://")) {
+          try {
+            originalText = fs10.readFileSync(
+              fileURLToPath(location.uri),
+              "utf-8"
+            );
+          } catch (error) {
+            this.synchronizeDocument(name, handle, location.uri);
+            throw error;
+          }
+        }
+        const assertOriginal = /* @__PURE__ */ __name(() => {
+          if (handle.connection !== connection || handle.status !== "READY" || this.serverManager.getHandles().get(name) !== handle) {
+            throw new StaleCallHierarchyItemError();
+          }
+          if (originalText !== void 0) {
+            let current;
+            try {
+              current = fs10.readFileSync(fileURLToPath(location.uri), "utf-8");
+            } catch {
+              throw new StaleCallHierarchyItemError();
+            }
+            if (current !== originalText)
+              throw new StaleCallHierarchyItemError();
+          }
+        }, "assertOriginal");
+        await this.warmupAndTrack(name, handle);
+        assertOriginal();
+        const justOpened = await this.ensureDocumentSynchronized(
           name,
           handle,
           location.uri
         );
-        await this.warmupAndTrack(name, handle);
-        let response = await handle.connection.request(
+        assertOriginal();
+        revision = this.captureCallHierarchyRevision(
+          name,
+          handle,
+          location.uri
+        );
+        let response = await connection.request(
           "textDocument/prepareCallHierarchy",
           requestParams
         );
+        revision.checkpoint();
         if (this.isEmptyResponse(response) && this.shouldRetryAfterOpen(justOpened, handle)) {
           await this.delay(DEFAULT_LSP_DOCUMENT_RETRY_DELAY_MS);
-          response = await handle.connection.request(
+          revision.checkpoint();
+          response = await connection.request(
             "textDocument/prepareCallHierarchy",
             requestParams
           );
+          revision.checkpoint();
         }
-        const candidates = Array.isArray(response) ? response : response ? [response] : [];
-        const items = [];
-        for (const item of candidates) {
-          const normalized2 = this.normalizer.normalizeCallHierarchyItem(
-            item,
-            name
-          );
-          if (normalized2) {
-            items.push(normalized2);
-            if (items.length >= limit) {
-              return items.slice(0, limit);
-            }
+        const normalize = /* @__PURE__ */ __name((value) => {
+          const items2 = [];
+          for (const candidate of Array.isArray(value) ? value : value ? [value] : []) {
+            const item = this.normalizer.normalizeCallHierarchyItem(
+              candidate,
+              name
+            );
+            if (item) items2.push(item);
+            if (items2.length >= limit) break;
           }
-        }
-        if (items.length > 0) {
-          return items.slice(0, limit);
-        }
+          return items2.slice(0, limit);
+        }, "normalize");
+        const items = normalize(response);
+        for (const item of items) item.documentRevision = revision.sign(item);
+        if (items.length > 0) return items;
       } catch (error) {
+        revision?.checkpoint();
+        if (error instanceof StaleCallHierarchyItemError) throw error;
         debugLogger21.warn(
           `LSP textDocument/prepareCallHierarchy failed for ${name}:`,
           error
@@ -13006,15 +13200,26 @@ var NativeLspService = class {
   async incomingCalls(item, serverName, limit = 50) {
     const targetServer = serverName ?? item.serverName;
     const handles = this.getReadyHandles(targetServer);
+    if (handles.length !== 1) throw new StaleCallHierarchyItemError();
     for (const [name, handle] of handles) {
+      const revision = this.captureCallHierarchyRevision(
+        name,
+        handle,
+        item.uri
+      );
+      this.validateCallHierarchyItem(item, revision);
+      await this.warmupAndTrack(name, handle);
+      revision.checkpoint();
+      this.validateCallHierarchyItem(item, revision);
       try {
-        await this.warmupAndTrack(name, handle);
         const response = await handle.connection.request(
           "callHierarchy/incomingCalls",
           {
             item: this.normalizer.toCallHierarchyItemParams(item)
           }
         );
+        revision.checkpoint();
+        this.validateCallHierarchyItem(item, revision);
         if (!Array.isArray(response)) {
           continue;
         }
@@ -13022,6 +13227,7 @@ var NativeLspService = class {
         for (const call of response) {
           const normalized2 = this.normalizer.normalizeIncomingCall(call, name);
           if (normalized2) {
+            normalized2.from.documentRevision = revision.sign(normalized2.from);
             calls.push(normalized2);
             if (calls.length >= limit) {
               return calls.slice(0, limit);
@@ -13032,6 +13238,9 @@ var NativeLspService = class {
           return calls.slice(0, limit);
         }
       } catch (error) {
+        revision.checkpoint();
+        this.validateCallHierarchyItem(item, revision);
+        if (error instanceof StaleCallHierarchyItemError) throw error;
         debugLogger21.warn(
           `LSP callHierarchy/incomingCalls failed for ${name}:`,
           error
@@ -13046,15 +13255,26 @@ var NativeLspService = class {
   async outgoingCalls(item, serverName, limit = 50) {
     const targetServer = serverName ?? item.serverName;
     const handles = this.getReadyHandles(targetServer);
+    if (handles.length !== 1) throw new StaleCallHierarchyItemError();
     for (const [name, handle] of handles) {
+      const revision = this.captureCallHierarchyRevision(
+        name,
+        handle,
+        item.uri
+      );
+      this.validateCallHierarchyItem(item, revision);
+      await this.warmupAndTrack(name, handle);
+      revision.checkpoint();
+      this.validateCallHierarchyItem(item, revision);
       try {
-        await this.warmupAndTrack(name, handle);
         const response = await handle.connection.request(
           "callHierarchy/outgoingCalls",
           {
             item: this.normalizer.toCallHierarchyItemParams(item)
           }
         );
+        revision.checkpoint();
+        this.validateCallHierarchyItem(item, revision);
         if (!Array.isArray(response)) {
           continue;
         }
@@ -13062,6 +13282,7 @@ var NativeLspService = class {
         for (const call of response) {
           const normalized2 = this.normalizer.normalizeOutgoingCall(call, name);
           if (normalized2) {
+            normalized2.to.documentRevision = revision.sign(normalized2.to);
             calls.push(normalized2);
             if (calls.length >= limit) {
               return calls.slice(0, limit);
@@ -13072,6 +13293,9 @@ var NativeLspService = class {
           return calls.slice(0, limit);
         }
       } catch (error) {
+        revision.checkpoint();
+        this.validateCallHierarchyItem(item, revision);
+        if (error instanceof StaleCallHierarchyItemError) throw error;
         debugLogger21.warn(
           `LSP callHierarchy/outgoingCalls failed for ${name}:`,
           error
@@ -13087,9 +13311,9 @@ var NativeLspService = class {
     const handles = this.getReadyHandles(serverName);
     const allDiagnostics = [];
     for (const [name, handle] of handles) {
+      await this.warmupAndTrack(name, handle);
+      await this.ensureDocumentSynchronized(name, handle, uri);
       try {
-        await this.ensureDocumentOpen(name, handle, uri);
-        await this.warmupAndTrack(name, handle);
         const response = await handle.connection.request(
           "textDocument/diagnostic",
           {
@@ -13127,8 +13351,44 @@ var NativeLspService = class {
     const handles = this.getReadyHandles(serverName);
     const results = [];
     for (const [name, handle] of handles) {
+      const connection = handle.connection;
+      const trackedUris = [...this.trackedUrisFor(name)];
+      await this.warmupAndTrack(name, handle);
+      if (handle.connection !== connection || handle.status !== "READY" || this.serverManager.getHandles().get(name) !== handle) {
+        throw new Error(`LSP server ${name} connection is no longer active`);
+      }
+      if (this.lastConnections.get(name) !== connection) {
+        this.parkTrackedUris(name);
+        this.lastConnections.set(name, connection);
+      }
+      for (const [uri, lifecycle] of this.documentLifecycles.get(name) ?? []) {
+        if (lifecycle.pendingClose) {
+          try {
+            this.closeUnsynchronizableDocument(name, handle, uri);
+          } catch (error) {
+            throw new Error(
+              `LSP server ${name} still cannot close ${uri}; refusing to reopen it (${error.message})`,
+              { cause: error }
+            );
+          }
+        }
+      }
+      let openedAny = false;
+      let syncError;
+      for (const uri of trackedUris) {
+        try {
+          openedAny = this.synchronizeDocument(name, handle, uri).opened || openedAny;
+          this.replayUris.get(name)?.delete(uri);
+        } catch (error) {
+          syncError ??= error;
+        }
+      }
+      if (syncError) throw syncError;
+      if (openedAny) await this.delay(DEFAULT_LSP_DOCUMENT_OPEN_DELAY_MS);
+      if (handle.connection !== connection || handle.status !== "READY" || this.serverManager.getHandles().get(name) !== handle) {
+        throw new Error(`LSP server ${name} connection is no longer active`);
+      }
       try {
-        await this.warmupAndTrack(name, handle);
         const response = await handle.connection.request(
           "workspace/diagnostic",
           {
@@ -13169,8 +13429,8 @@ var NativeLspService = class {
     const handles = this.getReadyHandles(serverName);
     for (const [name, handle] of handles) {
       try {
-        await this.ensureDocumentOpen(name, handle, uri);
         await this.warmupAndTrack(name, handle);
+        await this.ensureDocumentSynchronized(name, handle, uri);
         const lspDiagnostics = context.diagnostics.map(
           (d) => this.normalizer.denormalizeDiagnostic(d)
         );
@@ -13277,7 +13537,7 @@ var NativeLspService = class {
       lines.splice(startLine, endLine - startLine + 1, ...newLines);
     }
     try {
-      await fsp.access(filePath, fs11.constants.W_OK);
+      await fsp.access(filePath, fs10.constants.W_OK);
     } catch (err) {
       if (err?.code !== "ENOENT") {
         throw err;
@@ -13311,9 +13571,6 @@ function formatServerNames2(names) {
 }
 __name(formatServerNames2, "formatServerNames");
 
-// packages/core/src/lsp/types.ts
-init_esbuild_shims();
-
 // packages/core/src/mcp/configHash.ts
 init_esbuild_shims();
 import * as crypto from "node:crypto";
@@ -14420,7 +14677,7 @@ import path17 from "node:path";
 init_esbuild_shims();
 var import_ignore = __toESM(require_ignore(), 1);
 var import_picomatch = __toESM(require_picomatch(), 1);
-import fs12 from "node:fs";
+import fs11 from "node:fs";
 import path14 from "node:path";
 var hasFileExtension = (0, import_picomatch.default)("**/*[*.]*");
 var debugLogger24 = createDebugLogger("FILE_SEARCH_IGNORE");
@@ -14458,7 +14715,7 @@ function loadIgnoreRules(options) {
 __name(loadIgnoreRules, "loadIgnoreRules");
 function readIgnoreFile(filePath) {
   try {
-    return fs12.readFileSync(filePath, "utf8");
+    return fs11.readFileSync(filePath, "utf8");
   } catch (_error) {
     const error = _error;
     if (error.code !== "ENOENT") {
@@ -14612,7 +14869,7 @@ __name(hasGlobSyntax, "hasGlobSyntax");
 init_esbuild_shims();
 var import_fdir = __toESM(require_dist(), 1);
 import path15 from "node:path";
-import fs13 from "node:fs";
+import fs12 from "node:fs";
 import { spawn as spawn3 } from "node:child_process";
 
 // packages/core/src/utils/filesearch/crawlCache.ts
@@ -14871,13 +15128,13 @@ function resolveGitDir(crawlDirectory) {
   while (current) {
     const gitPath = path15.join(current, ".git");
     try {
-      const stat5 = fs13.statSync(gitPath);
+      const stat5 = fs12.statSync(gitPath);
       if (stat5.isDirectory()) {
         pathCacheSet(resolveGitDirCache, cacheKey, gitPath);
         return gitPath;
       }
       if (stat5.isFile()) {
-        const contents = fs13.readFileSync(gitPath, "utf8").trim();
+        const contents = fs12.readFileSync(gitPath, "utf8").trim();
         const match = contents.match(/^gitdir:\s*(.+)$/i);
         if (!match) {
           pathCacheSet(resolveGitDirCache, cacheKey, null);
@@ -14886,11 +15143,11 @@ function resolveGitDir(crawlDirectory) {
         const resolvedGitDir = match[1].trim();
         let resolvedAbs = path15.isAbsolute(resolvedGitDir) ? path15.resolve(resolvedGitDir) : path15.resolve(current, resolvedGitDir);
         try {
-          resolvedAbs = fs13.realpathSync(resolvedAbs);
+          resolvedAbs = fs12.realpathSync(resolvedAbs);
           try {
-            fs13.statSync(path15.join(resolvedAbs, "HEAD"));
+            fs12.statSync(path15.join(resolvedAbs, "HEAD"));
           } catch {
-            fs13.statSync(path15.join(resolvedAbs, "index"));
+            fs12.statSync(path15.join(resolvedAbs, "index"));
           }
         } catch {
           pathCacheSet(resolveGitDirCache, cacheKey, null);
@@ -14923,7 +15180,7 @@ function getGitRootMtime(crawlDirectory) {
       return null;
     }
     const indexPath = path15.join(gitDir, "index");
-    const indexStat = fs13.statSync(indexPath);
+    const indexStat = fs12.statSync(indexPath);
     return indexStat.mtimeMs;
   } catch {
   }
@@ -15164,11 +15421,11 @@ function getPosixRelative(from, to) {
   let fromAbs = fromResolved;
   let toAbs = toResolved;
   try {
-    fromAbs = fs13.realpathSync(fromResolved);
+    fromAbs = fs12.realpathSync(fromResolved);
   } catch {
   }
   try {
-    toAbs = fs13.realpathSync(toResolved);
+    toAbs = fs12.realpathSync(toResolved);
   } catch {
   }
   const relative2 = path15.relative(fromAbs, toAbs);
@@ -15486,7 +15743,7 @@ async function crawlWithGitLsFiles(stateKey, crawlDirectory, cwd, options, worki
     }
     let stat5;
     try {
-      stat5 = fs13.lstatSync(path15.join(gitRoot, ...normalizedFile.split("/")));
+      stat5 = fs12.lstatSync(path15.join(gitRoot, ...normalizedFile.split("/")));
     } catch {
       return true;
     }
@@ -15601,7 +15858,7 @@ function collectDirectoryRows(options) {
     }
     let entries;
     try {
-      entries = fs13.readdirSync(dir, { withFileTypes: true });
+      entries = fs12.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -15847,7 +16104,7 @@ __name(applyMaxFilesLimit, "applyMaxFilesLimit");
 
 // packages/core/src/utils/filesearch/fzfWorkerHandle.ts
 init_esbuild_shims();
-import fs14 from "node:fs";
+import fs13 from "node:fs";
 import path16 from "node:path";
 import { Worker } from "node:worker_threads";
 
@@ -16904,7 +17161,7 @@ function getWorkerScriptPath() {
     resolveBundleDir(import.meta.url),
     "fzfWorker.js"
   );
-  resolvedWorkerPath = fs14.existsSync(candidate) ? candidate : null;
+  resolvedWorkerPath = fs13.existsSync(candidate) ? candidate : null;
   return resolvedWorkerPath;
 }
 __name(getWorkerScriptPath, "getWorkerScriptPath");
@@ -17304,7 +17561,7 @@ __name(analyzeToolResultRetention, "analyzeToolResultRetention");
 
 // packages/core/src/utils/pathReader.ts
 init_esbuild_shims();
-import { promises as fs15 } from "node:fs";
+import { promises as fs14 } from "node:fs";
 import path18 from "node:path";
 async function readPathFromWorkspace(pathStr, config) {
   const workspace = config.getWorkspaceContext();
@@ -17322,7 +17579,7 @@ async function readPathFromWorkspace(pathStr, config) {
     for (const dir of searchDirs) {
       const potentialPath = path18.resolve(dir, pathStr);
       try {
-        await fs15.access(potentialPath);
+        await fs14.access(potentialPath);
         absolutePath = potentialPath;
         break;
       } catch {
@@ -17332,7 +17589,7 @@ async function readPathFromWorkspace(pathStr, config) {
   if (!absolutePath) {
     throw new Error(`Path not found in workspace: ${pathStr}`);
   }
-  const stats = await fs15.stat(absolutePath);
+  const stats = await fs14.stat(absolutePath);
   if (stats.isDirectory()) {
     const allParts = [];
     allParts.push({
@@ -17394,7 +17651,7 @@ __name(readPathFromWorkspace, "readPathFromWorkspace");
 
 // packages/core/src/utils/projectSummary.ts
 init_esbuild_shims();
-import * as fs16 from "fs/promises";
+import * as fs15 from "fs/promises";
 import * as path19 from "path";
 var PROJECT_SUMMARY_FILENAME = "PROJECT_SUMMARY.md";
 var WELCOME_BACK_STATE_FILENAME = "welcome-back-state.json";
@@ -17412,7 +17669,7 @@ function buildSummaryFingerprint(stat5) {
 __name(buildSummaryFingerprint, "buildSummaryFingerprint");
 async function getWelcomeBackState() {
   try {
-    const raw = await fs16.readFile(getWelcomeBackStatePath(), "utf-8");
+    const raw = await fs15.readFile(getWelcomeBackStatePath(), "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.version !== 1 || parsed.lastChoice !== "restart" || typeof parsed.summaryFingerprint !== "string") {
       return null;
@@ -17428,7 +17685,7 @@ async function getWelcomeBackState() {
 __name(getWelcomeBackState, "getWelcomeBackState");
 async function saveWelcomeBackRestartChoice(summaryFingerprint) {
   const statePath = getWelcomeBackStatePath();
-  await fs16.mkdir(path19.dirname(statePath), { recursive: true });
+  await fs15.mkdir(path19.dirname(statePath), { recursive: true });
   const state = {
     version: 1,
     lastChoice: "restart",
@@ -17441,7 +17698,7 @@ async function saveWelcomeBackRestartChoice(summaryFingerprint) {
 __name(saveWelcomeBackRestartChoice, "saveWelcomeBackRestartChoice");
 async function clearWelcomeBackState() {
   try {
-    await fs16.rm(getWelcomeBackStatePath(), { force: true });
+    await fs15.rm(getWelcomeBackStatePath(), { force: true });
   } catch {
   }
 }
@@ -17449,15 +17706,15 @@ __name(clearWelcomeBackState, "clearWelcomeBackState");
 async function getProjectSummaryInfo() {
   const summaryPath = getProjectSummaryPath();
   try {
-    await fs16.access(summaryPath);
+    await fs15.access(summaryPath);
   } catch {
     return {
       hasHistory: false
     };
   }
   try {
-    const summaryStat = await fs16.stat(summaryPath);
-    const content = await fs16.readFile(summaryPath, "utf-8");
+    const summaryStat = await fs15.stat(summaryPath);
+    const content = await fs15.readFile(summaryPath, "utf-8");
     const summaryFingerprint = buildSummaryFingerprint(summaryStat);
     const timestampMatch = content.match(/\*\*Update time\*\*: (.+)/);
     const timestamp = timestampMatch ? timestampMatch[1] : (/* @__PURE__ */ new Date()).toISOString();
@@ -17525,8 +17782,8 @@ __name(getProjectSummaryInfo, "getProjectSummaryInfo");
 
 // packages/core/src/tools/readManyFiles.ts
 init_esbuild_shims();
-import * as fs17 from "node:fs";
-import * as os3 from "node:os";
+import * as fs16 from "node:fs";
+import * as os4 from "node:os";
 import * as path20 from "node:path";
 var DEFAULT_OUTPUT_HEADER = "\n--- Content from referenced files ---";
 var DEFAULT_OUTPUT_TERMINATOR = "\n--- End of content ---";
@@ -17566,7 +17823,7 @@ async function readManyFiles(config, options) {
       if (validatedIdentity && !await matchesValidatedPathIdentity(fullPath, validatedIdentity)) {
         continue;
       }
-      const stats = fs17.existsSync(fullPath) ? fs17.statSync(fullPath) : null;
+      const stats = fs16.existsSync(fullPath) ? fs16.statSync(fullPath) : null;
       if (stats?.isDirectory()) {
         const { contentParts: dirParts, info } = await readDirectory(
           config,
@@ -17686,9 +17943,9 @@ async function readValidatedTextFileContent(config, filePath, expected, preserve
 __name(readValidatedTextFileContent, "readValidatedTextFileContent");
 async function matchesValidatedPathIdentity(filePath, expected) {
   try {
-    const canonicalPath = await fs17.promises.realpath(filePath);
+    const canonicalPath = await fs16.promises.realpath(filePath);
     if (canonicalPath !== filePath) return false;
-    const stats = await fs17.promises.stat(canonicalPath);
+    const stats = await fs16.promises.stat(canonicalPath);
     return statsMatchValidatedIdentity(stats, expected);
   } catch {
     return false;
@@ -17717,13 +17974,13 @@ async function snapshotValidatedFile(filePath, expected, signal) {
       if (stats.size > SNAPSHOT_MAX_SIZE_BYTES) {
         return void 0;
       }
-      snapshotDir = await fs17.promises.mkdtemp(
-        path20.join(os3.tmpdir(), "qwen-validated-read-")
+      snapshotDir = await fs16.promises.mkdtemp(
+        path20.join(os4.tmpdir(), "qwen-validated-read-")
       );
       const snapshotPath = path20.join(snapshotDir, path20.basename(filePath));
-      const target = await fs17.promises.open(
+      const target = await fs16.promises.open(
         snapshotPath,
-        fs17.constants.O_WRONLY | fs17.constants.O_CREAT | fs17.constants.O_EXCL,
+        fs16.constants.O_WRONLY | fs16.constants.O_CREAT | fs16.constants.O_EXCL,
         384
       );
       try {
@@ -17764,7 +18021,7 @@ async function snapshotValidatedFile(filePath, expected, signal) {
       result = {
         filePath: snapshotPath,
         stats,
-        cleanup: /* @__PURE__ */ __name(() => fs17.promises.rm(snapshotDir, { recursive: true, force: true }), "cleanup")
+        cleanup: /* @__PURE__ */ __name(() => fs16.promises.rm(snapshotDir, { recursive: true, force: true }), "cleanup")
       };
       return result;
     } finally {
@@ -17776,7 +18033,7 @@ async function snapshotValidatedFile(filePath, expected, signal) {
     return void 0;
   } finally {
     if (snapshotDir && !result) {
-      await fs17.promises.rm(snapshotDir, { recursive: true, force: true });
+      await fs16.promises.rm(snapshotDir, { recursive: true, force: true });
     }
   }
 }
@@ -17939,7 +18196,6 @@ export {
   ClientMcpRegistrar,
   isWsl,
   discoverProviderModels,
-  applyProviderInstallPlan,
   isApiUserPrompt,
   findApiRewindCutPoint,
   countApiUserPrompts,
@@ -18032,12 +18288,12 @@ export {
  */
 /**
  * @license
- * Copyright 2025 Qwen Team
+ * Copyright 2026 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
  */
 /**
  * @license
- * Copyright 2026 Qwen Team
+ * Copyright 2025 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
  */
 /**