@ashx-j/lunr 0.2.24 → 0.2.26

package/dist/node-runtime/{chunk-R3K2F5GI.js → chunk-B4HP6ZWM.js}

@@ -22,6 +22,7 @@ function defaultGatewayConfig() {
   return {
     owners: { telegram: [], discord: [] },
     projectRoots: [],
+    defaultProject: void 0,
     telegram: defaultPlatformConfig(!1),
     discord: { ...defaultPlatformConfig(!0), ignoredChannels: [], autoThread: !0 },
     groupSessionsPerUser: !0,
@@ -69,6 +70,7 @@ function sanitizeConfig(raw) {
   return {
     owners: { telegram: asStringArray(owners.telegram) ?? [], discord: asStringArray(owners.discord) ?? [] },
     projectRoots: asStringArray(r.projectRoots) ?? [],
+    defaultProject: typeof r.defaultProject == "string" ? r.defaultProject : void 0,
     telegram: sanitizePlatform(r.telegram, base.telegram),
     discord: sanitizeDiscord(r.discord, base.discord),
     groupSessionsPerUser: asBoolean(r.groupSessionsPerUser) ?? base.groupSessionsPerUser,

package/dist/node-runtime/{chunk-OCVIXVTZ.js → chunk-D5UCKPBQ.js}

@@ -1,4 +1,7 @@
 import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  encodeChildEventLines
+} from "./chunk-U5F4IC7R.js";
 import {
   flushRawStdout,
   writeRawStdout
@@ -48,8 +51,16 @@ async function runPrintMode(runtimeHost, options) {
         console.error(`Extension error (${err.extensionPath}): ${err.error}`);
       }
     }), unsubscribe?.(), unsubscribe = session.subscribe((event) => {
-      mode === "json" && writeRawStdout(`${JSON.stringify(event)}
+      if (mode === "json") {
+        let json = JSON.stringify(event);
+        if (process.env.PI_SUBAGENT_CHILD === "1")
+          for (let line of encodeChildEventLines(json))
+            writeRawStdout(`${line}
+`);
+        else
+          writeRawStdout(`${json}
 `);
+      }
     });
   };
   try {

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

@@ -0,0 +1,97 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  showStartupInput,
+  showStartupSelector
+} from "./chunk-X3PGBLQ7.js";
+import {
+  getProjectTrustOptions,
+  hasTrustRequiringProjectResources
+} from "./chunk-HTFRRDSF.js";
+import {
+  emitProjectTrustEvent
+} from "./chunk-GJ2RDBRL.js";
+import {
+  APP_NAME,
+  CONFIG_DIR_NAME
+} from "./chunk-FQMM2EZ2.js";
+
+// packages/coding-agent/dist/cli/project-trust.js
+import chalk from "chalk";
+function createProjectTrustContext(options) {
+  return {
+    cwd: options.cwd,
+    mode: options.mode === "interactive" ? "tui" : options.mode,
+    hasUI: options.hasUI,
+    ui: {
+      select: async (title, selectOptions) => {
+        if (options.hasUI && options.mode === "interactive")
+          return showStartupSelector(options.settingsManager, title, selectOptions.map((option) => ({ label: option, value: option })));
+      },
+      confirm: async (title, message) => !options.hasUI || options.mode !== "interactive" ? !1 : await showStartupSelector(options.settingsManager, `${title}
+${message}`, [
+        { label: "Yes", value: !0 },
+        { label: "No", value: !1 }
+      ]) ?? !1,
+      input: async (title, placeholder) => {
+        if (options.hasUI && options.mode === "interactive")
+          return showStartupInput(options.settingsManager, title, placeholder);
+      },
+      notify: (message, type = "info") => {
+        if (options.mode !== "interactive") {
+          let color = type === "error" ? chalk.red : type === "warning" ? chalk.yellow : chalk.cyan;
+          console.error(color(message));
+        }
+      }
+    }
+  };
+}
+
+// packages/coding-agent/dist/core/project-trust.js
+function formatProjectTrustPrompt(cwd) {
+  return `Trust project folder?
+${cwd}
+
+This allows ${APP_NAME} to load ${CONFIG_DIR_NAME} settings and resources, install missing project packages, and execute project extensions.`;
+}
+async function selectProjectTrustOption(cwd, ctx) {
+  let options = getProjectTrustOptions(cwd, { includeSessionOnly: !0 }), selected = await ctx.ui.select(formatProjectTrustPrompt(cwd), options.map((option) => option.label));
+  return options.find((option) => option.label === selected);
+}
+function saveProjectTrustPromptResult(trustStore, result) {
+  result.updates.length > 0 && trustStore.setMany(result.updates);
+}
+async function resolveProjectTrusted(options) {
+  if (options.trustOverride !== void 0)
+    return options.trustOverride;
+  if (!hasTrustRequiringProjectResources(options.cwd))
+    return !0;
+  if (options.extensionsResult) {
+    let { result, errors } = await emitProjectTrustEvent(options.extensionsResult, { type: "project_trust", cwd: options.cwd }, options.projectTrustContext);
+    for (let error of errors)
+      options.onExtensionError?.(`Extension "${error.extensionPath}" project_trust error: ${error.error}`);
+    if (result) {
+      let trusted = result.trusted === "yes";
+      return result.remember === !0 && options.trustStore.set(options.cwd, trusted), trusted;
+    }
+  }
+  let decision = options.trustStore.get(options.cwd);
+  if (decision !== null)
+    return decision;
+  switch (options.defaultProjectTrust ?? "ask") {
+    case "always":
+      return !0;
+    case "never":
+      return !1;
+    case "ask":
+      break;
+  }
+  if (!options.projectTrustContext.hasUI)
+    return !1;
+  let selected = await selectProjectTrustOption(options.cwd, options.projectTrustContext);
+  return selected !== void 0 ? (saveProjectTrustPromptResult(options.trustStore, selected), selected.trusted) : !1;
+}
+
+export {
+  createProjectTrustContext,
+  resolveProjectTrusted
+};

package/dist/node-runtime/{chunk-HFVZUPFJ.js → chunk-E75WFZ33.js}

@@ -4,10 +4,10 @@ import {
   ServerError,
   logger,
   wrapError
-} from "./chunk-DSIKTUPW.js";
+} from "./chunk-4SBQAI4T.js";
 import {
   UrlElicitationRequiredError
-} from "./chunk-4TLO4PO2.js";
+} from "./chunk-2IDTZAG5.js";
 import {
   UI_STREAM_HOST_CONTEXT_KEY,
   UI_STREAM_REQUEST_META_KEY,

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

@@ -0,0 +1,73 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+
+// packages/coding-agent/dist/core/computer-use/policy.js
+var settingsListeners = /* @__PURE__ */ new Set();
+function computerSettingsChanged(settings) {
+  for (let listener of settingsListeners)
+    listener(settings);
+}
+function onComputerSettingsChanged(listener) {
+  return settingsListeners.add(listener), () => {
+    settingsListeners.delete(listener);
+  };
+}
+var COMPUTER_TOOLS = [
+  "computer_load",
+  "computer_apps",
+  "computer_observe",
+  "computer_click",
+  "computer_hover",
+  "computer_drag",
+  "computer_key",
+  "computer_text",
+  "computer_window",
+  "computer_launch",
+  "computer_scroll",
+  "computer_end"
+];
+function computerPolicy(name, input) {
+  if (name.startsWith("computer_"))
+    switch (name) {
+      case "computer_load":
+      case "computer_apps":
+      case "computer_observe":
+      case "computer_end":
+        return { observation: !0, foreground: !1 };
+      case "computer_click":
+      case "computer_hover":
+      case "computer_drag":
+      case "computer_key":
+      case "computer_text":
+      case "computer_scroll":
+        return {
+          observation: !1,
+          foreground: name === "computer_hover" || input.foreground === !0 || input.desktop === !0
+        };
+      case "computer_window":
+      case "computer_launch":
+        return { observation: !1, foreground: !0 };
+      default:
+        throw new Error(`Unknown computer operation: ${name}`);
+    }
+}
+function computerRefusal(name, input, policy) {
+  let operation = computerPolicy(name, input);
+  if (!operation)
+    return "Unknown computer operation.";
+  if (policy.child)
+    return "Computer tools are available only to main agents.";
+  if (!policy.enabled)
+    return "Computer use is disabled in settings.";
+  if (operation.foreground && !policy.foreground)
+    return "Foreground control is disabled. Use background operations.";
+  if (!policy.vision && name !== "computer_end")
+    return "Image-only computer use requires an image-capable model. Select one before loading computer tools.";
+}
+
+export {
+  computerSettingsChanged,
+  onComputerSettingsChanged,
+  COMPUTER_TOOLS,
+  computerPolicy,
+  computerRefusal
+};

package/dist/node-runtime/{chunk-RORY2HMJ.js → chunk-I74LN5JG.js}

@@ -2,10 +2,13 @@ import { createRequire as __lunrRequire } from "node:module"; const require = __
 import {
   browserEnabledDefault,
   notifyBrowserEnabledChange
-} from "./chunk-UP2XBVH5.js";
+} from "./chunk-UOEDI7RP.js";
 import {
   require_proper_lockfile
 } from "./chunk-URD2SLIT.js";
+import {
+  computerSettingsChanged
+} from "./chunk-FY4A63RK.js";
 import {
   MEMORY_CHAR_CAP_DEFAULT,
   MEMORY_CHAR_CAP_MAX,
@@ -18867,6 +18870,18 @@ var FileSettingsStorage = class {
     let value = this.settings.memoryCharCap;
     return typeof value == "number" && Number.isFinite(value) ? Math.min(MEMORY_CHAR_CAP_MAX, Math.max(MEMORY_CHAR_CAP_MIN, Math.floor(value))) : MEMORY_CHAR_CAP_DEFAULT;
   }
+  getComputerUse() {
+    return this.globalSettings.computerUse ?? !0;
+  }
+  setComputerUse(enabled) {
+    this.globalSettings.computerUse = enabled, this.markModified("computerUse"), this.save(), computerSettingsChanged({ enabled, foreground: this.getComputerForeground() });
+  }
+  getComputerForeground() {
+    return this.globalSettings.computerForeground ?? !0;
+  }
+  setComputerForeground(enabled) {
+    this.globalSettings.computerForeground = enabled, this.markModified("computerForeground"), this.save(), computerSettingsChanged({ enabled: this.getComputerUse(), foreground: enabled });
+  }
   getBrowserEnabled() {
     return this.globalSettings.browserEnabled ?? browserEnabledDefault();
   }

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

@@ -0,0 +1,287 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  CUA_VERSION,
+  installRuntime,
+  runtimeEnvironment
+} from "./chunk-5B6VKFEV.js";
+import {
+  Client,
+  StdioClientTransport
+} from "./chunk-LWJXTA6Z.js";
+
+// packages/coding-agent/dist/core/computer-use/adapter.js
+import { mkdir, mkdtemp as mkdtemp2, realpath as realpath2, rm as rm2 } from "node:fs/promises";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join3 } from "node:path";
+import { setTimeout as delay2 } from "node:timers/promises";
+
+// packages/coding-agent/dist/core/computer-use/macos-runtime.js
+import { execFile, spawn } from "node:child_process";
+import { constants } from "node:fs";
+import { mkdtemp, open, realpath, rm } from "node:fs/promises";
+import { connect } from "node:net";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { promisify } from "node:util";
+var exec = promisify(execFile);
+function macLaunchArguments(app, socket, home, lifetime) {
+  let environment = {
+    HOME: home,
+    ...Object.fromEntries(Object.entries(runtimeEnvironment()).filter(([name]) => name.startsWith("CUA_")))
+  };
+  return [
+    "-n",
+    "-g",
+    "-W",
+    "-a",
+    app,
+    "--stdin",
+    lifetime,
+    ...Object.entries(environment).flatMap(([name, value]) => ["--env", `${name}=${value}`]),
+    "--args",
+    "serve",
+    "--embedded",
+    "--parent-liveness-stdio",
+    "--socket",
+    socket,
+    "--permission-mode",
+    "standard",
+    "--no-overlay"
+  ];
+}
+function request(socket, method, args) {
+  return new Promise((resolve, reject) => {
+    let stream = connect(socket), buffer = "";
+    stream.setTimeout(1e3, () => stream.destroy(new Error("Private computer endpoint timed out."))), stream.on("error", reject), stream.on("connect", () => stream.write(`${JSON.stringify({ method, args })}
+`)), stream.on("data", (chunk) => {
+      if (buffer += chunk.toString(), buffer.length > 65536) {
+        stream.destroy(new Error("Invalid private endpoint metadata."));
+        return;
+      }
+      if (buffer.includes(`
+`)) {
+        try {
+          let reply = JSON.parse(buffer.slice(0, buffer.indexOf(`
+`)));
+          if (!reply || typeof reply != "object" || !("result" in reply) || !reply.result || typeof reply.result != "object")
+            throw new Error("Private endpoint refused metadata.");
+          resolve(Object.fromEntries(Object.entries(reply.result)));
+        } catch (error) {
+          reject(error);
+        }
+        stream.destroy();
+      }
+    }), stream.on("end", () => reject(new Error("Private computer endpoint closed.")));
+  });
+}
+var MacRuntime = class {
+  directory;
+  lifetime;
+  exited;
+  pid;
+  get processId() {
+    return this.pid;
+  }
+  socket;
+  closing;
+  async start(app, signal) {
+    let directory = await mkdtemp(join(await realpath(tmpdir()), "lunr-cua-"));
+    this.directory = directory;
+    let socket = join(directory, "driver.sock");
+    this.socket = socket;
+    let lifetime = join(directory, "lifetime");
+    await exec("/usr/bin/mkfifo", ["-m", "600", lifetime], { timeout: 5e3, signal }), this.lifetime = await open(lifetime, constants.O_RDWR), signal.throwIfAborted();
+    let launcher = spawn("/usr/bin/open", macLaunchArguments(app, socket, directory, lifetime), {
+      env: runtimeEnvironment(),
+      stdio: "ignore"
+    });
+    this.exited = new Promise((resolve, reject) => {
+      launcher.once("error", reject), launcher.once("exit", (code) => code === 0 ? resolve() : reject(new Error(`LaunchServices exited ${code}.`)));
+    }), this.exited.catch(() => {
+    });
+    let deadline = Date.now() + 15e3;
+    for (; Date.now() < deadline; ) {
+      signal.throwIfAborted();
+      try {
+        let metadata = await request(socket, "metadata");
+        if (metadata.driver_version !== CUA_VERSION || metadata.embedded !== !0 || typeof metadata.pid != "number" || metadata.pid < 1)
+          throw new Error("Private runtime has incompatible metadata.");
+        return this.pid = metadata.pid, socket;
+      } catch {
+        await Promise.race([
+          delay(100, void 0, { signal }),
+          this.exited.then(() => {
+            throw new Error("Computer app exited during startup.");
+          })
+        ]);
+      }
+    }
+    throw new Error("Private macOS runtime startup timed out. Check CuaDriver Accessibility and Screen Recording grants.");
+  }
+  close() {
+    return this.closing ??= this.stop(), this.closing;
+  }
+  async stop() {
+    if (await this.lifetime?.close(), this.lifetime = void 0, this.socket && this.pid && await request(this.socket, "shutdown_if_pid", { expected_pid: this.pid }).catch(() => {
+    }), this.exited) {
+      let timeout = new AbortController();
+      try {
+        await Promise.race([
+          this.exited,
+          delay(1e4, void 0, { signal: timeout.signal }).then(() => {
+            throw new Error("Owned macOS app shutdown is unconfirmed. Desktop lease retained.");
+          })
+        ]);
+      } finally {
+        timeout.abort();
+      }
+    }
+    this.directory && await rm(this.directory, { recursive: !0, force: !0 });
+  }
+};
+
+// packages/coding-agent/dist/core/computer-use/windows-desktop.js
+import { execFile as execFile2 } from "node:child_process";
+import { join as join2 } from "node:path";
+import { promisify as promisify2 } from "node:util";
+var exec2 = promisify2(execFile2), WINDOWS_DESKTOP_PROBE = `
+$ErrorActionPreference = 'Stop'
+Add-Type -TypeDefinition @'
+using System;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+using System.Text;
+public static class LunrDesktopProbe {
+ [DllImport("user32.dll", SetLastError=true)] static extern IntPtr OpenInputDesktop(uint flags, bool inherit, uint access);
+ [DllImport("user32.dll")] static extern bool CloseDesktop(IntPtr desktop);
+ [DllImport("user32.dll", CharSet=CharSet.Unicode, SetLastError=true)] static extern bool GetUserObjectInformation(IntPtr handle, int index, StringBuilder info, uint length, out uint needed);
+ [DllImport("wtsapi32.dll", SetLastError=true)] static extern bool WTSQuerySessionInformation(IntPtr server, int session, int info, out IntPtr buffer, out uint bytes);
+ [DllImport("wtsapi32.dll")] static extern void WTSFreeMemory(IntPtr buffer);
+ public static bool Ready() {
+  int session = Process.GetCurrentProcess().SessionId;
+  if (session == 0) return false;
+  IntPtr buffer; uint bytes;
+  if (!WTSQuerySessionInformation(IntPtr.Zero, session, 8, out buffer, out bytes)) return false;
+  try { if (bytes < 4 || Marshal.ReadInt32(buffer) != 0) return false; }
+  finally { WTSFreeMemory(buffer); }
+  IntPtr desktop = OpenInputDesktop(0, false, 1);
+  if (desktop == IntPtr.Zero) return false;
+  try {
+   var name = new StringBuilder(256); uint needed;
+   return GetUserObjectInformation(desktop, 2, name, 512, out needed) && name.ToString() == "Default";
+  } finally { CloseDesktop(desktop); }
+ }
+}
+'@
+if ([LunrDesktopProbe]::Ready()) { 'ready' } else { 'unavailable' }
+`;
+async function assertInteractiveDesktop(signal) {
+  if (process.platform !== "win32")
+    return;
+  let command = join2(process.env.SystemRoot ?? "C:\\Windows", "System32", "WindowsPowerShell", "v1.0", "powershell.exe"), { stdout } = await exec2(command, ["-NoProfile", "-NonInteractive", "-Command", WINDOWS_DESKTOP_PROBE], {
+    timeout: 5e3,
+    windowsHide: !0,
+    signal
+  });
+  if (stdout.trim() !== "ready")
+    throw new Error("Computer use requires an active, unlocked Windows desktop. No login, unlock, or elevation is attempted.");
+}
+
+// packages/coding-agent/dist/core/computer-use/adapter.js
+var DriverCallError = class extends Error {
+  phase;
+  dispatched;
+  constructor(phase, dispatched) {
+    super(phase === "adapter_preflight" ? "Computer adapter preflight failed." : "Computer native request failed."), this.phase = phase, this.dispatched = dispatched;
+  }
+}, CuaAdapter = class {
+  client;
+  transport;
+  mac;
+  stateDirectory;
+  connecting;
+  closing;
+  abort = new AbortController();
+  processObserver;
+  setProcessObserver(observer) {
+    this.processObserver = observer;
+  }
+  async connect(signal) {
+    let { command, app } = await installRuntime(signal);
+    signal.throwIfAborted();
+    let args = ["mcp", "--direct", "--embedded", "--no-overlay"];
+    app && (this.mac = new MacRuntime(), args = ["mcp", "--embedded", "--socket", await this.mac.start(app, signal), "--no-overlay"]), signal.throwIfAborted();
+    let state = await mkdtemp2(join3(await realpath2(tmpdir2()), "lunr-cua-client-"));
+    this.stateDirectory = state;
+    let appData = join3(state, "AppData");
+    if (await mkdir(appData), signal.throwIfAborted(), this.transport = new StdioClientTransport({
+      command,
+      args,
+      stderr: "pipe",
+      env: {
+        ...runtimeEnvironment(),
+        HOME: state,
+        USERPROFILE: state,
+        APPDATA: appData,
+        LOCALAPPDATA: appData,
+        XDG_CONFIG_HOME: appData,
+        XDG_STATE_HOME: appData
+      }
+    }), this.transport.stderr?.on("data", () => {
+    }), this.client = new Client({ name: "lunr-computer-use", version: CUA_VERSION }), await this.client.connect(this.transport, { timeout: 15e3, signal }), signal.throwIfAborted(), this.client.getServerVersion()?.version !== CUA_VERSION)
+      throw new Error("Computer runtime version mismatch.");
+    let pids = [this.transport.pid, ...this.mac ? [this.mac.processId] : []];
+    for (let pid of pids) {
+      if (typeof pid != "number" || !Number.isInteger(pid) || pid < 1)
+        throw new Error("Computer runtime process identity is missing. Input refused.");
+      await this.processObserver?.(pid);
+    }
+  }
+  async call(name, args, signal) {
+    let combined = AbortSignal.any([this.abort.signal, ...signal ? [signal] : []]);
+    combined.throwIfAborted();
+    let dispatched = !1;
+    try {
+      if (await assertInteractiveDesktop(combined), combined.throwIfAborted(), this.connecting ??= this.connect(AbortSignal.any([combined, AbortSignal.timeout(6e4)])), await this.connecting, combined.throwIfAborted(), !this.client)
+        throw new Error("Computer connection closed.");
+      return dispatched = !0, await this.client.callTool({ name, arguments: args }, void 0, { timeout: name === "launch_app" ? 45e3 : 15e3, signal: combined });
+    } catch (error) {
+      let wasCancelled = combined.aborted;
+      try {
+        await this.close();
+      } catch {
+      }
+      throw wasCancelled ? error : new DriverCallError(dispatched ? "native_request" : "adapter_preflight", dispatched);
+    }
+  }
+  close() {
+    return this.abort.abort(), this.closing ??= this.stop(), this.closing;
+  }
+  async stop() {
+    await this.connecting?.catch(() => {
+    });
+    let pid = this.transport?.pid;
+    if (await this.client?.close(), await this.transport?.close(), pid) {
+      let deadline = Date.now() + 5e3;
+      for (; ; ) {
+        try {
+          process.kill(pid, 0);
+        } catch (error) {
+          if (error instanceof Error && "code" in error && error.code === "ESRCH")
+            break;
+          throw error;
+        }
+        if (Date.now() >= deadline)
+          throw new Error("Owned computer process shutdown is unconfirmed. Desktop lease retained.");
+        await delay2(50);
+      }
+    }
+    await this.mac?.close(), this.stateDirectory && await rm2(this.stateDirectory, { recursive: !0, force: !0 }), this.client = void 0, this.transport = void 0;
+  }
+};
+
+export {
+  DriverCallError,
+  CuaAdapter
+};

package/dist/node-runtime/{chunk-QM43FEAE.js → chunk-L24TPBS4.js}

@@ -11,7 +11,7 @@ import {
 import {
   isReadOnlyModeActive,
   requestPlanApproval
-} from "./chunk-ZXSGTGJ6.js";
+} from "./chunk-WIF24I7G.js";
 import {
   ashxj_tui_default
 } from "./chunk-MPKSOJBT.js";
@@ -925,14 +925,15 @@ var lightBuiltinExtensions = [
 ], DEFERRED_BUILTIN_LOADERS = [
   { name: "pi-ollama-cloud", load: () => import("./pi-ollama-cloud-2F3Y2QNM.js") },
   { name: "narumiruna-pi-goal", load: () => import("./goal-NJEE5CTU.js") },
-  { name: "lunr-cron", load: () => import("./lunr-cron-CXOL37AL.js") },
+  { name: "lunr-cron", load: () => import("./lunr-cron-USHC4LXH.js") },
   { name: "pi-intercom", load: () => import("./pi-intercom-QM53RLTS.js") },
   { name: "pi-prompt-template-model", load: () => import("./pi-prompt-template-model-QWTCGLJU.js") },
-  { name: "pi-subagents", load: () => import("./pi-subagents-XPCLLKIM.js") },
+  { name: "pi-subagents", load: () => import("./pi-subagents-7IBSSGEW.js") },
   { name: "pi-web-access", load: () => import("./pi-web-access-WTGMNZ32.js") },
-  { name: "lunr-browser", load: () => import("./lunr-browser-J5ZZYVGM.js") },
+  { name: "lunr-browser", load: () => import("./lunr-browser-IR7TL3J7.js") },
   { name: "pi-lsp-extension", load: () => import("./src-IVPNZ2BX.js") },
-  { name: "pi-mcp-adapter", load: () => import("./pi-mcp-adapter-5UKBZP44.js") }
+  { name: "pi-mcp-adapter", load: () => import("./pi-mcp-adapter-3PHF4KZ4.js") },
+  { name: "lunr-computer-use", load: () => import("./lunr-computer-use-Y23CCDIJ.js") }
 ], DEFERRED_BUILTIN_EXTENSION_NAMES = DEFERRED_BUILTIN_LOADERS.map((entry) => entry.name), DEFERRED_BUILTIN_FLAGS = ["mcp-config"];
 async function loadDeferredBuiltinExtensions() {
   return await Promise.all(DEFERRED_BUILTIN_LOADERS.map(async ({ name, load }) => {

package/dist/node-runtime/{chunk-DE2JB6J5.js → chunk-LJTIVM7I.js}

@@ -1,13 +1,13 @@
 import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
-import {
-  TODO_TOOL_NAMES
-} from "./chunk-CCCN2UCX.js";
 import {
   DefaultResourceLoader,
   createSyntheticSourceInfo,
   expandPromptTemplate,
   formatSkillsForPrompt
-} from "./chunk-F4FLTQKV.js";
+} from "./chunk-SN2KSMPQ.js";
+import {
+  TODO_TOOL_NAMES
+} from "./chunk-CCCN2UCX.js";
 import {
   stripFrontmatter
 } from "./chunk-QFWG2RVL.js";
@@ -16,7 +16,7 @@ import {
   createLocalBashOperations,
   createToolDefinitionFromAgentTool,
   wrapToolDefinition
-} from "./chunk-YDO2F2IA.js";
+} from "./chunk-YWOJIGFY.js";
 import {
   DEFAULT_MAX_BYTES,
   truncateTail
@@ -31,7 +31,7 @@ import {
 } from "./chunk-KJ6DWS3K.js";
 import {
   SettingsManager
-} from "./chunk-RORY2HMJ.js";
+} from "./chunk-I74LN5JG.js";
 import {
   DEFAULT_THINKING_LEVEL,
   calculateContextTokens,
@@ -53,7 +53,7 @@ import {
 } from "./chunk-BBUVIEZB.js";
 import {
   gateToolCall
-} from "./chunk-ZXSGTGJ6.js";
+} from "./chunk-WIF24I7G.js";
 import {
   isUserInstructionsPath,
   loadSelectedUserInstructions