@ashx-j/lunr 0.2.26 → 0.2.28

package/dist/node-runtime/{chunk-NAY6UUQZ.js → chunk-WDIVLMOH.js}

@@ -1,7 +1,7 @@
 import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
 
 // packages/coding-agent/dist/builtin-extensions/pi-web-access/lazy.js
-var loadExtract = () => import("./extract-EQJE7FZZ.js"), loadGeminiSearch = () => import("./gemini-search-35OCRFLN.js"), loadCuratorServer = () => import("./curator-server-XCM43VEF.js"), loadSummaryReview = () => import("./summary-review-YSMXKITO.js"), loadGeminiWeb = () => import("./gemini-web-MM446SEH.js"), loadGeminiApi = () => import("./gemini-api-QE7ANVDZ.js"), loadOpenAISearch = () => import("./openai-search-B3MSNCQA.js"), loadBrave = () => import("./brave-UWDA3I22.js"), loadParallel = () => import("./parallel-AI2MNSCU.js"), loadTavily = () => import("./tavily-WEZFVFP7.js"), loadPerplexity = () => import("./perplexity-QVJW3I35.js"), loadExa = () => import("./exa-LL64QZR2.js"), loadGithubExtract = () => import("./github-extract-F64RZOEA.js"), loadPdfExtract = () => import("./pdf-extract-IPE6H4HP.js"), loadYoutubeExtract = () => import("./youtube-extract-FNPAUNHU.js"), loadVideoExtract = () => import("./video-extract-OOZHR7SU.js"), loadGeminiUrlContext = () => import("./gemini-url-context-UQY3PHHW.js");
+var loadExtract = () => import("./extract-BFX2N35A.js"), loadGeminiSearch = () => import("./gemini-search-C66QHDT6.js"), loadCuratorServer = () => import("./curator-server-XCM43VEF.js"), loadSummaryReview = () => import("./summary-review-YSMXKITO.js"), loadGeminiWeb = () => import("./gemini-web-MM446SEH.js"), loadGeminiApi = () => import("./gemini-api-QE7ANVDZ.js"), loadOpenAISearch = () => import("./openai-search-K72LJDYN.js"), loadBrave = () => import("./brave-2AFFAXNN.js"), loadParallel = () => import("./parallel-X724NCNU.js"), loadTavily = () => import("./tavily-KZBFYQB6.js"), loadPerplexity = () => import("./perplexity-RDHQHVMK.js"), loadExa = () => import("./exa-6VBZNPGE.js"), loadGithubExtract = () => import("./github-extract-HOGE3D6F.js"), loadPdfExtract = () => import("./pdf-extract-IPE6H4HP.js"), loadYoutubeExtract = () => import("./youtube-extract-77NT7FWH.js"), loadVideoExtract = () => import("./video-extract-UPKYIBW3.js"), loadGeminiUrlContext = () => import("./gemini-url-context-T7DEK73R.js");
 
 export {
   loadExtract,

package/dist/node-runtime/{chunk-E24EO34J.js → chunk-WPXUR3HE.js}

@@ -4,7 +4,7 @@ import {
   CONFIG_DIR_NAME,
   ENV_AGENT_DIR,
   ENV_SESSION_DIR
-} from "./chunk-FQMM2EZ2.js";
+} from "./chunk-64XTQNLA.js";
 
 // packages/coding-agent/dist/cli/args.js
 import chalk from "chalk";

package/dist/node-runtime/{chunk-SLVOAQOY.js → chunk-WXYNALHD.js}

@@ -1,7 +1,7 @@
 import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
 import {
   getAgentDir
-} from "./chunk-FQMM2EZ2.js";
+} from "./chunk-64XTQNLA.js";
 
 // packages/coding-agent/dist/gateway/service.js
 import { spawn, spawnSync } from "node:child_process";
@@ -171,6 +171,117 @@ async function stopGatewayService() {
   }
   throw new Error("Gateway is still stopping after 30 seconds. Inspect the log; no unrelated process was terminated.");
 }
+async function teardownGatewayService() {
+  let dir = serviceDirectory(), ownerPath = join(dir, "lock", "owner.json"), status = readGatewayStatus(), lockOwner = readGatewayStatus(ownerPath);
+  if (existsSync(statusPath()) && !status || existsSync(join(dir, "lock")) && !lockOwner)
+    throw new Error("Gateway ownership is unresolved. Profile retained; run lunr gateway doctor.");
+  if (status && lockOwner && (status.instance !== lockOwner.instance || status.pid !== lockOwner.pid))
+    throw new Error("Gateway status and lock ownership disagree. Profile retained.");
+  let owner = status ?? lockOwner;
+  if (owner && processExists(owner.pid) && !lockOwner)
+    throw new Error("Running gateway has no ownership lock. Profile retained.");
+  let rawSettings = readJson(settingsPath());
+  if (existsSync(settingsPath()) && (!rawSettings || typeof rawSettings != "object" || !("startup" in rawSettings) || !["off", "login", "boot"].includes(String(rawSettings.startup))))
+    throw new Error("Gateway startup settings are unresolved. Profile retained.");
+  let mode = loadServiceSettings().startup, user = userInfo(), options = {
+    home: homedir(),
+    agentDir: getAgentDir(),
+    node: process.execPath,
+    cli: cliPath(),
+    username: user.username,
+    uid: user.uid
+  }, spec = mode === "off" ? void 0 : startupSpec(process.platform, mode, options), startupFileMissing = !!spec && !existsSync(spec.path);
+  if (spec)
+    if (startupFileMissing)
+      confirmStartupRemoval(spec);
+    else {
+      if (readFileSync(spec.path, "utf8") !== spec.content)
+        throw new Error("Gateway startup file does not match this installation. Profile retained.");
+      if (process.platform === "linux") {
+        let unit = spec.verify.at(-1), registration = serviceQuery([
+          "systemctl",
+          "--user",
+          "show",
+          unit,
+          "--property=FragmentPath",
+          "--property=DropInPaths"
+        ]), properties = new Map(registration.stdout.trim().split(`
+`).map((line) => {
+          let separator = line.indexOf("=");
+          return [line.slice(0, separator), line.slice(separator + 1)];
+        }));
+        if (registration.status !== 0 || properties.get("FragmentPath") !== spec.path || properties.get("DropInPaths") !== "")
+          throw new Error("Gateway systemd ownership could not be verified. Profile retained.");
+      } else if (process.platform === "win32") {
+        let name = `${servicePrefix}-${createHash("sha256").update(resolve(getAgentDir())).digest("hex").slice(0, 10)}`, actionArgs = `-NoProfile -NonInteractive -WindowStyle Hidden -ExecutionPolicy Bypass -File "${spec.path}"`;
+        execute([
+          "powershell.exe",
+          "-NoProfile",
+          "-Command",
+          `$ErrorActionPreference='Stop'; $t=Get-ScheduledTask -TaskName ${ps(name)}; if($t.Actions.Count -ne 1 -or $t.Actions[0].Execute -ne 'powershell.exe' -or $t.Actions[0].Arguments -ne ${ps(actionArgs)}){throw 'Gateway task ownership mismatch'}`
+        ]);
+      }
+    }
+  else if (["linux", "darwin", "win32"].includes(process.platform) && ["login", "boot"].some((candidate) => existsSync(startupSpec(process.platform, candidate, options).path)))
+    throw new Error("Gateway startup file exists without active ownership settings. Profile retained.");
+  if (owner && processExists(owner.pid) && atomicJson(controlPath(), { instance: owner.instance, action: "stop" }), spec && !startupFileMissing) {
+    if (process.platform === "linux") {
+      let unit = spec.verify.at(-1);
+      execute(["systemctl", "--user", "disable", "--now", unit]);
+      let disabled = serviceQuery(spec.verify);
+      if (disabled.status !== 1 || disabled.stdout.trim() !== "disabled")
+        throw new Error("Gateway startup disable could not be confirmed. Profile retained.");
+    } else
+      for (let command of spec.remove) {
+        let removed = serviceQuery(command);
+        if (removed.status !== 0 && !(process.platform === "darwin" && /Could not find (?:specified )?service/i.test(removed.stderr)))
+          throw new Error("Gateway startup removal failed. Profile retained.");
+      }
+    process.platform === "darwin" && mode === "boot" ? execute(["sudo", "rm", "-f", spec.path]) : rmSync(spec.path), confirmStartupRemoval(spec);
+  }
+  spec && atomicJson(settingsPath(), { startup: "off" });
+  for (let i = 0; owner && processExists(owner.pid); i++) {
+    if (i >= 150)
+      throw new Error("Gateway shutdown could not be confirmed after 30 seconds. Profile retained.");
+    await sleep(200);
+  }
+  let remaining = readGatewayStatus(), remainingLock = readGatewayStatus(ownerPath);
+  if (remaining && processExists(remaining.pid) || remainingLock && processExists(remainingLock.pid))
+    throw new Error("Gateway ownership changed during teardown. Profile retained.");
+}
+function confirmStartupRemoval(spec) {
+  if (process.platform === "linux") {
+    execute(["systemctl", "--user", "daemon-reload"]);
+    let removed = serviceQuery([
+      "systemctl",
+      "--user",
+      "show",
+      spec.verify.at(-1),
+      "--property=LoadState",
+      "--value"
+    ]);
+    if (removed.status !== 0 || removed.stdout.trim() !== "not-found")
+      throw new Error("Gateway startup removal could not be confirmed. Profile retained.");
+  } else if (process.platform === "darwin") {
+    let removed = serviceQuery(spec.verify);
+    if (removed.status === 0 || !/Could not find (?:specified )?service/i.test(removed.stderr))
+      throw new Error("Gateway launchd removal could not be confirmed. Profile retained.");
+  } else {
+    let name = `${servicePrefix}-${createHash("sha256").update(resolve(getAgentDir())).digest("hex").slice(0, 10)}`;
+    execute([
+      "powershell.exe",
+      "-NoProfile",
+      "-Command",
+      `$ErrorActionPreference='Stop'; if(Get-ScheduledTask | Where-Object {$_.TaskName -eq ${ps(name)}}){throw 'Gateway task still registered'}`
+    ]);
+  }
+}
+function serviceQuery(command) {
+  let [file, ...args] = command, result = spawnSync(file, args, { encoding: "utf8", windowsHide: !0, timeout: 12e4 });
+  if (result.error)
+    throw result.error;
+  return result;
+}
 function xml(value) {
   return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
 }
@@ -345,6 +456,7 @@ export {
   claimGateway,
   startGatewayService,
   stopGatewayService,
+  teardownGatewayService,
   startupSpec,
   configureStartup,
   serviceStatusText,

package/dist/node-runtime/{chunk-KJ6DWS3K.js → chunk-XEOCUEUJ.js}

@@ -4,16 +4,16 @@ import {
 } from "./chunk-URD2SLIT.js";
 import {
   getShellConfig
-} from "./chunk-CSFI6YXL.js";
+} from "./chunk-ES6PBSIE.js";
 import {
   clearPlanUsageCache
-} from "./chunk-2MI5OPMN.js";
+} from "./chunk-HNNHHJAB.js";
 import {
   VERSION,
   getAgentDir,
   getPackageDir,
   normalizePath
-} from "./chunk-FQMM2EZ2.js";
+} from "./chunk-64XTQNLA.js";
 import {
   __toESM
 } from "./chunk-BRJX2PRC.js";
@@ -1875,9 +1875,11 @@ function configuredRequestAuthStatus(config, extension) {
 }
 
 // packages/coding-agent/dist/core/runtime-credentials.js
+import { AsyncLocalStorage } from "node:async_hooks";
 var RuntimeCredentials = class {
   store;
   overrides = /* @__PURE__ */ new Map();
+  requestReads = new AsyncLocalStorage();
   constructor(store) {
     this.store = store;
   }
@@ -1892,7 +1894,14 @@ var RuntimeCredentials = class {
   }
   async read(providerId) {
     let override = this.overrides.get(providerId);
-    return override ? { type: "api_key", key: override } : this.store.read(providerId);
+    if (override)
+      return { type: "api_key", key: override };
+    let credential = await this.store.read(providerId), request = this.requestReads.getStore();
+    return request?.providerId === providerId && request.observe(credential?.type === "api_key" ? credential.key : void 0), credential;
+  }
+  /** Observe the actual stored read for this request, excluding runtime overrides. */
+  withStoredApiKeyRead(providerId, observe, resolve) {
+    return this.requestReads.run({ providerId, observe }, resolve);
   }
   async list() {
     let entries = new Map((await this.store.list()).map((entry) => [entry.providerId, entry]));
@@ -1909,6 +1918,7 @@ var RuntimeCredentials = class {
 };
 
 // packages/coding-agent/dist/core/subscriptions.js
+import { createHash as createHash3 } from "node:crypto";
 import { join as join5 } from "path";
 
 // packages/coding-agent/dist/core/usage-limit.js
@@ -1968,14 +1978,16 @@ function parseResetTimeMs(errorMessage) {
 }
 
 // packages/coding-agent/dist/core/subscriptions.js
+function subscriptionKeyFingerprint(providerId, key) {
+  return createHash3("sha256").update(providerId).update("\0").update(key).digest("hex");
+}
 var SubscriptionManager = class _SubscriptionManager {
   data = {};
-  loaded = !1;
   storage;
   authStorage;
   // In-process write queue so mutations serialize even before the file lock.
   queue = Promise.resolve();
-  // Per-provider ids of keys exhausted without a parseable reset time.
+  // Per-provider fingerprints exhausted without a parseable reset time.
   // Process-local on purpose: infinite exhaustion is never persisted.
   memoryExhausted = /* @__PURE__ */ new Map();
   constructor(authStorage, storage) {
@@ -1992,29 +2004,50 @@ var SubscriptionManager = class _SubscriptionManager {
     return storage.withLock(() => ({ result: void 0, next: JSON.stringify(data, null, 2) })), _SubscriptionManager.fromStorage(authStorage, storage);
   }
   parseStorageData(content) {
-    return content ? JSON.parse(content) : {};
-  }
-  ensureLoaded() {
-    if (this.loaded)
-      return;
-    this.loaded = !0;
-    let content;
+    if (content === void 0)
+      return {};
     try {
-      this.storage.withLock((current) => (content = current, { result: void 0 })), this.data = this.parseStorageData(content);
+      let parsed = JSON.parse(content);
+      if (!parsed || typeof parsed != "object" || Array.isArray(parsed))
+        throw new Error();
+      for (let value of Object.values(parsed)) {
+        if (!value || typeof value != "object")
+          throw new Error();
+        let pool = value;
+        if (typeof pool.active != "string" || !Array.isArray(pool.keys))
+          throw new Error();
+        let ids = /* @__PURE__ */ new Set();
+        for (let value2 of pool.keys) {
+          if (!value2 || typeof value2 != "object")
+            throw new Error();
+          let entry = value2;
+          if (typeof entry.id != "string" || ids.has(entry.id) || typeof entry.name != "string" || typeof entry.key != "string" || typeof entry.addedAt != "number" || !Number.isFinite(entry.addedAt) || entry.exhaustedUntil !== void 0 && (typeof entry.exhaustedUntil != "number" || !Number.isFinite(entry.exhaustedUntil)) || entry.lastError !== void 0 && typeof entry.lastError != "string")
+            throw new Error();
+          ids.add(entry.id);
+        }
+        if (!ids.has(pool.active))
+          throw new Error();
+      }
+      return parsed;
     } catch {
+      throw new Error("Subscription storage is malformed. Repair it before changing subscriptions.");
     }
   }
+  /**
+   * Lock order is subscriptions then auth. Keep selection and its auth mirror
+   * under the subscription lock so later selectors cannot overtake a mirror.
+   * These files are not an atomic commit: a failed mirror aborts the pool write;
+   * a later pool write failure can leave auth ahead and a repeated selection repairs it.
+   */
   enqueue(fn) {
-    let next = this.queue.then(fn);
+    let next = this.queue.then(() => this.storage.withLockAsync(async (current) => {
+      this.data = this.parseStorageData(current);
+      let before = JSON.stringify(this.data, null, 2), result = await fn(), after = JSON.stringify(this.data, null, 2);
+      return { result, next: before === after ? void 0 : after };
+    }));
     return this.queue = next.catch(() => {
     }), next;
   }
-  persist() {
-    return this.storage.withLockAsync(async () => ({
-      result: void 0,
-      next: JSON.stringify(this.data, null, 2)
-    }));
-  }
   /** Raw stored credential read via the modify path (returning undefined leaves it unchanged). */
   async readRawCredential(providerId) {
     let current;
@@ -2027,7 +2060,6 @@ var SubscriptionManager = class _SubscriptionManager {
    * as "Sub 1" on first access. OAuth credentials are not imported.
    */
   async ensurePool(providerId) {
-    this.ensureLoaded();
     let existing = this.data[providerId];
     if (existing)
       return existing;
@@ -2038,7 +2070,7 @@ var SubscriptionManager = class _SubscriptionManager {
       active: "1",
       keys: [{ id: "1", name: "Sub 1", key: credential.key, addedAt: Date.now() }]
     };
-    return this.data = { ...this.data, [providerId]: pool }, await this.persist(), pool;
+    return this.data = { ...this.data, [providerId]: pool }, pool;
   }
   nextId(pool) {
     let max = 0;
@@ -2049,7 +2081,16 @@ var SubscriptionManager = class _SubscriptionManager {
     return String(max + 1);
   }
   async mirrorActive(providerId, key) {
-    await this.authStorage.modify(providerId, async () => ({ type: "api_key", key }));
+    clearPlanUsageCache();
+    try {
+      await this.authStorage.modify(providerId, async (current) => ({
+        type: "api_key",
+        key,
+        ...current?.type === "api_key" && current.env ? { env: current.env } : {}
+      }));
+    } finally {
+      clearPlanUsageCache();
+    }
   }
   async list(providerId) {
     return this.enqueue(async () => {
@@ -2065,9 +2106,8 @@ var SubscriptionManager = class _SubscriptionManager {
   }
   async addKey(providerId, key, name) {
     return this.enqueue(async () => {
-      this.ensureLoaded();
       let pool = await this.ensurePool(providerId), id = pool ? this.nextId(pool) : "1", entry = { id, name: name ?? `Sub ${id}`, key, addedAt: Date.now() }, keys = [...pool?.keys ?? [], entry];
-      return this.data = { ...this.data, [providerId]: { active: id, keys } }, await this.persist(), await this.mirrorActive(providerId, key), entry;
+      return this.data = { ...this.data, [providerId]: { active: id, keys } }, await this.mirrorActive(providerId, key), entry;
     });
   }
   async removeKey(providerId, id) {
@@ -2075,20 +2115,25 @@ var SubscriptionManager = class _SubscriptionManager {
       let pool = await this.ensurePool(providerId);
       if (!pool || !pool.keys.some((entry) => entry.id === id))
         return;
-      let keys = pool.keys.filter((entry) => entry.id !== id);
-      if (this.memoryExhausted.get(providerId)?.delete(id), keys.length === 0) {
+      let keys = pool.keys.filter((entry) => entry.id !== id), removed = pool.keys.find((entry) => entry.id === id);
+      if (keys.some((entry) => entry.key === removed.key) || this.memoryExhausted.get(providerId)?.delete(subscriptionKeyFingerprint(providerId, removed.key)), keys.length === 0) {
         let data = { ...this.data };
-        delete data[providerId], this.data = data, await this.persist(), await this.authStorage.delete(providerId);
+        delete data[providerId], this.data = data, clearPlanUsageCache();
+        try {
+          await this.authStorage.delete(providerId);
+        } finally {
+          clearPlanUsageCache();
+        }
         return;
       }
       let active = pool.active;
       if (active === id) {
-        active = keys[0]?.id ?? active, this.data = { ...this.data, [providerId]: { active, keys } }, await this.persist();
+        active = keys[0]?.id ?? active, this.data = { ...this.data, [providerId]: { active, keys } };
         let promoted = keys.find((entry) => entry.id === active);
         promoted && await this.mirrorActive(providerId, promoted.key);
         return;
       }
-      this.data = { ...this.data, [providerId]: { active, keys } }, await this.persist();
+      this.data = { ...this.data, [providerId]: { active, keys } };
     });
   }
   async renameKey(providerId, id, name) {
@@ -2097,57 +2142,58 @@ var SubscriptionManager = class _SubscriptionManager {
       if (!pool)
         return;
       let keys = pool.keys.map((entry) => entry.id === id ? { ...entry, name } : entry);
-      this.data = { ...this.data, [providerId]: { ...pool, keys } }, await this.persist();
+      this.data = { ...this.data, [providerId]: { ...pool, keys } };
     });
   }
   async setActive(providerId, id) {
     return this.enqueue(async () => {
       let pool = await this.ensurePool(providerId), entry = pool?.keys.find((candidate) => candidate.id === id);
-      !pool || !entry || (this.data = { ...this.data, [providerId]: { ...pool, active: id } }, await this.persist(), await this.mirrorActive(providerId, entry.key));
+      !pool || !entry || (this.data = { ...this.data, [providerId]: { ...pool, active: id } }, await this.mirrorActive(providerId, entry.key));
     });
   }
   /**
-   * Mark the active key exhausted and rotate to the next non-exhausted key in
+   * Mark the request's key exhausted and rotate to the next non-exhausted key in
    * round-robin order. A parseable reset time is persisted as exhaustedUntil;
-   * otherwise the exhaustion is process-local only. Returns the new active key,
-   * or null when no non-exhausted alternative exists (current key stays active).
+   * otherwise the exhaustion is process-local only. A later selection is preserved.
+   * Returns the usable active key for retry, or null when no alternative exists.
    */
-  async rotateOnFailure(providerId, errorMessage, now = Date.now()) {
-    return this.enqueue(async () => {
-      let pool = await this.ensurePool(providerId);
-      if (!pool)
+  async rotateOnFailure(providerId, errorMessage, requestFingerprint, now = Date.now()) {
+    return requestFingerprint ? this.enqueue(async () => {
+      let pool = this.data[providerId];
+      if (!pool || pool.keys.length < 2)
         return null;
       let currentIndex = pool.keys.findIndex((entry) => entry.id === pool.active);
       if (currentIndex === -1)
         return null;
-      let current = pool.keys[currentIndex];
-      if (!current)
+      let current = pool.keys[currentIndex], matchesRequest = (entry) => subscriptionKeyFingerprint(providerId, entry.key) === requestFingerprint;
+      if (!current || !pool.keys.some(matchesRequest))
         return null;
       let resetAt = parseResetTimeMs(errorMessage), keys = pool.keys;
       if (resetAt !== void 0 && resetAt > now)
-        keys = pool.keys.map((entry) => entry.id === current.id ? { ...entry, exhaustedUntil: resetAt, lastError: errorMessage } : entry);
+        keys = pool.keys.map((entry) => matchesRequest(entry) ? { ...entry, exhaustedUntil: resetAt, lastError: errorMessage } : entry);
       else {
         let set = this.memoryExhausted.get(providerId) ?? /* @__PURE__ */ new Set();
-        set.add(current.id), this.memoryExhausted.set(providerId, set);
+        set.add(requestFingerprint), this.memoryExhausted.set(providerId, set);
       }
-      let isExhausted = (entry) => this.memoryExhausted.get(providerId)?.has(entry.id) === !0 || entry.exhaustedUntil !== void 0 && entry.exhaustedUntil > now;
+      let isExhausted = (entry) => this.memoryExhausted.get(providerId)?.has(subscriptionKeyFingerprint(providerId, entry.key)) === !0 || entry.exhaustedUntil !== void 0 && entry.exhaustedUntil > now;
+      if (keys !== pool.keys && (this.data = { ...this.data, [providerId]: { ...pool, keys } }), !matchesRequest(current))
+        return isExhausted(current) ? null : current;
       for (let offset = 1; offset < keys.length; offset++) {
         let candidate = keys[(currentIndex + offset) % keys.length];
         if (!(!candidate || isExhausted(candidate)))
-          return this.data = { ...this.data, [providerId]: { active: candidate.id, keys } }, await this.persist(), await this.mirrorActive(providerId, candidate.key), candidate;
+          return this.data = { ...this.data, [providerId]: { active: candidate.id, keys } }, await this.mirrorActive(providerId, candidate.key), candidate;
       }
-      return keys !== pool.keys && (this.data = { ...this.data, [providerId]: { ...pool, keys } }, await this.persist()), null;
-    });
+      return null;
+    }) : null;
   }
   /** Manual reactivate: clears persisted and process-local exhaustion for a key. */
   async clearExhaustion(providerId, id) {
     return this.enqueue(async () => {
-      this.memoryExhausted.get(providerId)?.delete(id);
       let pool = await this.ensurePool(providerId);
       if (!pool)
         return;
       let target = pool.keys.find((entry) => entry.id === id);
-      if (!target || target.exhaustedUntil === void 0 && target.lastError === void 0)
+      if (target && this.memoryExhausted.get(providerId)?.delete(subscriptionKeyFingerprint(providerId, target.key)), !target || target.exhaustedUntil === void 0 && target.lastError === void 0)
         return;
       let keys = pool.keys.map((entry) => {
         if (entry.id !== id)
@@ -2155,7 +2201,7 @@ var SubscriptionManager = class _SubscriptionManager {
         let { exhaustedUntil: _exhaustedUntil, lastError: _lastError, ...rest } = entry;
         return rest;
       });
-      this.data = { ...this.data, [providerId]: { ...pool, keys } }, await this.persist();
+      this.data = { ...this.data, [providerId]: { ...pool, keys } };
     });
   }
 };
@@ -2313,6 +2359,7 @@ var ModelRuntime = class _ModelRuntime {
   credentials;
   /** lunr: per-provider subscription-key pools; rotation mirrors the active key into the credential store. */
   subscriptionManager;
+  requestSubscriptionKeys = /* @__PURE__ */ new WeakMap();
   defaultBuiltins;
   builtins = /* @__PURE__ */ new Map();
   extensionProviders = /* @__PURE__ */ new Map();
@@ -2528,7 +2575,7 @@ var ModelRuntime = class _ModelRuntime {
     return this.credentials.hasRuntimeApiKey(providerId);
   }
   async setRuntimeApiKey(providerId, apiKey, options) {
-    this.credentials.setRuntimeApiKey(providerId, apiKey);
+    clearPlanUsageCache(), this.credentials.setRuntimeApiKey(providerId, apiKey);
     let auth = new Map(this.snapshot.auth).set(providerId, { type: "api_key", source: "runtime API key" }), configuredProviders = new Set(this.snapshot.configuredProviders).add(providerId), storedProviders = new Set(this.snapshot.storedProviders).add(providerId);
     this.snapshot = {
       ...this.snapshot,
@@ -2539,7 +2586,7 @@ var ModelRuntime = class _ModelRuntime {
     }, await this.refresh({ allowNetwork: options?.allowNetwork ?? this.allowModelNetwork });
   }
   async removeRuntimeApiKey(providerId) {
-    this.credentials.removeRuntimeApiKey(providerId), await this.refresh({ allowNetwork: this.allowModelNetwork });
+    clearPlanUsageCache(), this.credentials.removeRuntimeApiKey(providerId), await this.refresh({ allowNetwork: this.allowModelNetwork });
   }
   /** lunr: whether network model-catalog fetches are allowed (offline mode disables them). */
   isNetworkAllowed() {
@@ -2563,14 +2610,17 @@ var ModelRuntime = class _ModelRuntime {
     let provider = this.models.getProvider(model.provider);
     if (!provider)
       throw new ModelsError("provider", `Unknown provider: ${model.provider}`);
-    let resolution = await this.getAuth(model, { apiKey: options?.apiKey, env: options?.env });
+    let storedKeyFingerprint, resolution = await this.credentials.withStoredApiKeyRead(model.provider, (apiKey) => {
+      storedKeyFingerprint = apiKey ? subscriptionKeyFingerprint(model.provider, apiKey) : void 0;
+    }, () => this.getAuth(model, { apiKey: options?.apiKey, env: options?.env }));
     if (!resolution)
       throw new ModelsError("auth", `Provider is not configured: ${model.provider}`);
     let { transformHeaders, ...providerOptions } = options ?? {}, route = anthropicRequestRoute(model.provider, resolution, options), headers = mergeHeaders(resolution.auth.headers, providerOptions.headers);
     transformHeaders && (headers = await transformHeaders(headers ?? {}));
-    let env = resolution.env || providerOptions.env ? { ...resolution.env ?? {}, ...providerOptions.env ?? {} } : void 0;
+    let overridesAuth = Object.entries(headers ?? {}).some(([name, value]) => /^(authorization|x-api-key|api-key|x-goog-api-key)$/i.test(name) && value !== route.apiKey && value !== `Bearer ${route.apiKey}`), subscriptionKey = route.apiKey && options?.apiKey === void 0 && storedKeyFingerprint === subscriptionKeyFingerprint(model.provider, route.apiKey) && !overridesAuth ? { providerId: model.provider, fingerprint: subscriptionKeyFingerprint(model.provider, route.apiKey) } : void 0, env = resolution.env || providerOptions.env ? { ...resolution.env ?? {}, ...providerOptions.env ?? {} } : void 0;
     return {
       provider,
+      subscriptionKey,
       model: resolution.auth.baseUrl ? { ...model, baseUrl: resolution.auth.baseUrl } : model,
       options: {
         ...providerOptions,
@@ -2580,30 +2630,41 @@ var ModelRuntime = class _ModelRuntime {
       }
     };
   }
+  /** The final response identity stays process-local and never enters saved chat. */
+  getRequestSubscriptionKey(message) {
+    return this.requestSubscriptionKeys.get(message);
+  }
   stream(model, context, options) {
-    return lazyStream2(model, async () => {
+    let subscriptionKey, stream = lazyStream2(model, async () => {
       let prepared = await this.prepareRequest(model, options);
-      return prepared.provider.stream(prepared.model, context, prepared.options);
+      return subscriptionKey = prepared.subscriptionKey, prepared.provider.stream(prepared.model, context, prepared.options);
     });
+    return stream.result().then((message) => {
+      subscriptionKey && this.requestSubscriptionKeys.set(message, subscriptionKey);
+    }), stream;
   }
   complete(model, context, options) {
     return this.stream(model, context, options).result();
   }
   streamSimple(model, context, options) {
-    return lazyStream2(model, async () => {
+    let subscriptionKey, stream = lazyStream2(model, async () => {
       let prepared = await this.prepareRequest(model, options);
-      return prepared.provider.streamSimple(prepared.model, context, prepared.options);
+      return subscriptionKey = prepared.subscriptionKey, prepared.provider.streamSimple(prepared.model, context, prepared.options);
     });
+    return stream.result().then((message) => {
+      subscriptionKey && this.requestSubscriptionKeys.set(message, subscriptionKey);
+    }), stream;
   }
   completeSimple(model, context, options) {
     return this.streamSimple(model, context, options).result();
   }
   async login(providerId, type, interaction) {
+    clearPlanUsageCache();
     let credential = await this.models.login(providerId, type, interaction);
     return clearPlanUsageCache(), await this.refresh({ allowNetwork: this.allowModelNetwork }), credential;
   }
   async logout(providerId) {
-    await this.models.logout(providerId), await this.modelsStore.delete(providerId), this.userModels.evictProvider(providerId), this.overlay.setLive(providerId, []), this.recomposeProvider(providerId), clearPlanUsageCache(), await this.refresh({ allowNetwork: this.allowModelNetwork });
+    clearPlanUsageCache(), await this.models.logout(providerId), await this.modelsStore.delete(providerId), this.userModels.evictProvider(providerId), this.overlay.setLive(providerId, []), this.recomposeProvider(providerId), clearPlanUsageCache(), await this.refresh({ allowNetwork: this.allowModelNetwork });
   }
   /** Copy a live Grok CLI SuperGrok session into lunR `auth.json`. */
   async importGrokCliXaiAuth() {

package/dist/node-runtime/chunk-YD3IZAZ7.js

@@ -0,0 +1,47 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  ActivityMonitor,
+  runWithActivity
+} from "./chunk-IPP5BIV5.js";
+
+// packages/coding-agent/dist/builtin-extensions/pi-web-access/session-cleanup.js
+import { AsyncLocalStorage } from "node:async_hooks";
+function createWebSession() {
+  return {
+    activity: new ActivityMonitor(),
+    cleanups: /* @__PURE__ */ new Set(),
+    closed: !1
+  };
+}
+var sessionScope = new AsyncLocalStorage(), pendingCleanups = /* @__PURE__ */ new WeakMap();
+function getWebSession() {
+  return sessionScope.getStore();
+}
+function runWithWebSession(session, fn) {
+  return sessionScope.run(session, () => runWithActivity(session.activity, fn));
+}
+function runSessionCleanups(session) {
+  let existing = pendingCleanups.get(session);
+  if (existing)
+    return existing;
+  session.closed = !0;
+  let pending = [...session.cleanups].map(async (cleanup2) => cleanup2());
+  session.cleanups.clear();
+  let cleanup = Promise.allSettled(pending).then((results) => {
+    let errors = [];
+    for (let result of results)
+      result.status === "rejected" && errors.push(result.reason);
+    if (errors.length > 0) {
+      let details = errors.map((error) => error instanceof Error ? error.message : String(error)).join("; ");
+      throw new AggregateError(errors, `Web session cleanup failed: ${details}`);
+    }
+  });
+  return pendingCleanups.set(session, cleanup), cleanup;
+}
+
+export {
+  createWebSession,
+  getWebSession,
+  runWithWebSession,
+  runSessionCleanups
+};

package/dist/node-runtime/chunk-YSB6URMT.js

@@ -0,0 +1,41 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+
+// packages/coding-agent/dist/core/tools/file-mutation-queue.js
+import { realpath } from "node:fs/promises";
+import { resolve } from "node:path";
+var fileMutationQueues = /* @__PURE__ */ new Map(), registrationQueue = Promise.resolve();
+function isMissingPathError(error) {
+  return typeof error == "object" && error !== null && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR");
+}
+async function getMutationQueueKey(filePath) {
+  let resolvedPath = resolve(filePath);
+  try {
+    return await realpath(resolvedPath);
+  } catch (error) {
+    if (isMissingPathError(error))
+      return resolvedPath;
+    throw error;
+  }
+}
+async function withFileMutationQueue(filePath, fn) {
+  let registration = registrationQueue.then(async () => {
+    let key2 = await getMutationQueueKey(filePath), currentQueue2 = fileMutationQueues.get(key2) ?? Promise.resolve(), releaseNext2, nextQueue = new Promise((resolveQueue) => {
+      releaseNext2 = resolveQueue;
+    }), chainedQueue2 = currentQueue2.then(() => nextQueue);
+    return fileMutationQueues.set(key2, chainedQueue2), { key: key2, currentQueue: currentQueue2, chainedQueue: chainedQueue2, releaseNext: releaseNext2 };
+  });
+  registrationQueue = registration.then(() => {
+  }, () => {
+  });
+  let { key, currentQueue, chainedQueue, releaseNext } = await registration;
+  await currentQueue;
+  try {
+    return await fn();
+  } finally {
+    releaseNext(), fileMutationQueues.get(key) === chainedQueue && fileMutationQueues.delete(key);
+  }
+}
+
+export {
+  withFileMutationQueue
+};