@mastra/core 1.16.1-alpha.0 → 1.17.0-alpha.2

package/dist/{chunk-J3NJXIJ4.js → chunk-ABA3KD3X.js}

@@ -6,11 +6,12 @@ import nodePath__default, { parse, join, dirname } from 'path';
 import posixPath from 'path/posix';
 import { constants, existsSync } from 'fs';
 import * as fs2 from 'fs/promises';
+import fs2__default from 'fs/promises';
 import * as os3 from 'os';
 import os3__default from 'os';
 import picomatch from 'picomatch';
 import { createRequire } from 'module';
-import { pathToFileURL } from 'url';
+import { fileURLToPath, pathToFileURL } from 'url';
 import { execFileSync } from 'child_process';
 import * as crypto from 'crypto';
 import { createHash } from 'crypto';
@@ -71,68 +72,68 @@ var WorkspaceReadOnlyError = class extends WorkspaceError {
   }
 };
 var FilesystemError = class extends Error {
-  constructor(message, code, path7) {
+  constructor(message, code, path8) {
     super(message);
     this.code = code;
-    this.path = path7;
+    this.path = path8;
     this.name = "FilesystemError";
   }
 };
 var FileNotFoundError = class extends FilesystemError {
-  constructor(path7) {
-    super(`File not found: ${path7}`, "ENOENT", path7);
+  constructor(path8) {
+    super(`File not found: ${path8}`, "ENOENT", path8);
     this.name = "FileNotFoundError";
   }
 };
 var DirectoryNotFoundError = class extends FilesystemError {
-  constructor(path7) {
-    super(`Directory not found: ${path7}`, "ENOENT", path7);
+  constructor(path8) {
+    super(`Directory not found: ${path8}`, "ENOENT", path8);
     this.name = "DirectoryNotFoundError";
   }
 };
 var FileExistsError = class extends FilesystemError {
-  constructor(path7) {
-    super(`File already exists: ${path7}`, "EEXIST", path7);
+  constructor(path8) {
+    super(`File already exists: ${path8}`, "EEXIST", path8);
     this.name = "FileExistsError";
   }
 };
 var IsDirectoryError = class extends FilesystemError {
-  constructor(path7) {
-    super(`Path is a directory: ${path7}`, "EISDIR", path7);
+  constructor(path8) {
+    super(`Path is a directory: ${path8}`, "EISDIR", path8);
     this.name = "IsDirectoryError";
   }
 };
 var NotDirectoryError = class extends FilesystemError {
-  constructor(path7) {
-    super(`Path is not a directory: ${path7}`, "ENOTDIR", path7);
+  constructor(path8) {
+    super(`Path is not a directory: ${path8}`, "ENOTDIR", path8);
     this.name = "NotDirectoryError";
   }
 };
 var DirectoryNotEmptyError = class extends FilesystemError {
-  constructor(path7) {
-    super(`Directory not empty: ${path7}`, "ENOTEMPTY", path7);
+  constructor(path8) {
+    super(`Directory not empty: ${path8}`, "ENOTEMPTY", path8);
     this.name = "DirectoryNotEmptyError";
   }
 };
 var PermissionError = class extends FilesystemError {
-  constructor(path7, operation) {
-    super(`Permission denied: ${operation} on ${path7}`, "EACCES", path7);
+  constructor(path8, operation) {
+    super(`Permission denied: ${operation} on ${path8}`, "EACCES", path8);
     this.operation = operation;
     this.name = "PermissionError";
   }
 };
 var FileReadRequiredError = class extends FilesystemError {
-  constructor(path7, reason) {
-    super(reason, "EREAD_REQUIRED", path7);
+  constructor(path8, reason) {
+    super(reason, "EREAD_REQUIRED", path8);
     this.name = "FileReadRequiredError";
   }
 };
 var StaleFileError = class extends FilesystemError {
-  constructor(path7, expectedMtime, actualMtime) {
+  constructor(path8, expectedMtime, actualMtime) {
     super(
-      `File was modified externally: ${path7} (expected mtime ${expectedMtime.toISOString()}, actual ${actualMtime.toISOString()})`,
+      `File was modified externally: ${path8} (expected mtime ${expectedMtime.toISOString()}, actual ${actualMtime.toISOString()})`,
       "ESTALE",
-      path7
+      path8
     );
     this.expectedMtime = expectedMtime;
     this.actualMtime = actualMtime;
@@ -171,14 +172,14 @@ var CompositeFilesystem = class {
   constructor(config) {
     this.id = `cfs-${Date.now().toString(36)}`;
     this._mounts = /* @__PURE__ */ new Map();
-    for (const [path7, fs5] of Object.entries(config.mounts)) {
-      const normalized = this.normalizePath(path7);
-      this._mounts.set(normalized, fs5);
+    for (const [path8, fs6] of Object.entries(config.mounts)) {
+      const normalized = this.normalizePath(path8);
+      this._mounts.set(normalized, fs6);
     }
     if (this._mounts.size === 0) {
       throw new Error("CompositeFilesystem requires at least one mount");
     }
-    this.readOnly = [...this._mounts.values()].every((fs5) => fs5.readOnly) || void 0;
+    this.readOnly = [...this._mounts.values()].every((fs6) => fs6.readOnly) || void 0;
     const mountPaths = [...this._mounts.keys()];
     for (const a of mountPaths) {
       for (const b of mountPaths) {
@@ -207,8 +208,8 @@ var CompositeFilesystem = class {
    */
   async getInfo() {
     const mounts = {};
-    for (const [mountPath, fs5] of this._mounts) {
-      mounts[mountPath] = await fs5.getInfo?.() ?? null;
+    for (const [mountPath, fs6] of this._mounts) {
+      mounts[mountPath] = await fs6.getInfo?.() ?? null;
     }
     return {
       id: this.id,
@@ -223,42 +224,42 @@ var CompositeFilesystem = class {
    * Get the underlying filesystem for a given path.
    * Returns undefined if the path doesn't resolve to any mount.
    */
-  getFilesystemForPath(path7) {
-    const resolved = this.resolveMount(path7);
+  getFilesystemForPath(path8) {
+    const resolved = this.resolveMount(path8);
     return resolved?.fs;
   }
   /**
    * Get the mount path for a given path.
    * Returns undefined if the path doesn't resolve to any mount.
    */
-  getMountPathForPath(path7) {
-    const resolved = this.resolveMount(path7);
+  getMountPathForPath(path8) {
+    const resolved = this.resolveMount(path8);
     return resolved?.mountPath;
   }
   /**
    * Resolve a workspace-relative path to an absolute disk path.
    * Strips the mount prefix and delegates to the underlying filesystem.
    */
-  resolveAbsolutePath(path7) {
-    const r = this.resolveMount(path7);
+  resolveAbsolutePath(path8) {
+    const r = this.resolveMount(path8);
     if (!r) return void 0;
     return r.fs.resolveAbsolutePath?.(r.fsPath);
   }
-  normalizePath(path7) {
-    if (!path7 || path7 === "/" || path7 === ".") return "/";
-    let n = posixPath.normalize(path7);
+  normalizePath(path8) {
+    if (!path8 || path8 === "/" || path8 === ".") return "/";
+    let n = posixPath.normalize(path8);
     if (n === ".") return "/";
     if (!n.startsWith("/")) n = `/${n}`;
     if (n.length > 1 && n.endsWith("/")) n = n.slice(0, -1);
     return n;
   }
-  resolveMount(path7) {
-    const normalized = this.normalizePath(path7);
+  resolveMount(path8) {
+    const normalized = this.normalizePath(path8);
     let best = null;
-    for (const [mountPath, fs5] of this._mounts) {
+    for (const [mountPath, fs6] of this._mounts) {
       if (normalized === mountPath || normalized.startsWith(mountPath + "/")) {
         if (!best || mountPath.length > best.mountPath.length) {
-          best = { mountPath, fs: fs5 };
+          best = { mountPath, fs: fs6 };
         }
       }
     }
@@ -268,11 +269,11 @@ var CompositeFilesystem = class {
     else if (fsPath.startsWith("/")) fsPath = fsPath.slice(1);
     return { fs: best.fs, fsPath, mountPath: best.mountPath };
   }
-  getVirtualEntries(path7) {
-    const normalized = this.normalizePath(path7);
+  getVirtualEntries(path8) {
+    const normalized = this.normalizePath(path8);
     if (this.resolveMount(normalized)) return null;
     const entriesMap = /* @__PURE__ */ new Map();
-    for (const [mountPath, fs5] of this._mounts.entries()) {
+    for (const [mountPath, fs6] of this._mounts.entries()) {
       const isUnder = normalized === "/" ? mountPath.startsWith("/") : mountPath.startsWith(normalized + "/");
       if (isUnder) {
         const remaining = normalized === "/" ? mountPath.slice(1) : mountPath.slice(normalized.length + 1);
@@ -282,12 +283,12 @@ var CompositeFilesystem = class {
           const entry = { name: next, type: "directory" };
           if (isDirectMount) {
             entry.mount = {
-              provider: fs5.provider,
-              icon: fs5.icon,
-              displayName: fs5.displayName,
-              description: fs5.description,
-              status: fs5.status,
-              error: fs5.error
+              provider: fs6.provider,
+              icon: fs6.icon,
+              displayName: fs6.displayName,
+              description: fs6.description,
+              status: fs6.status,
+              error: fs6.error
             };
           }
           entriesMap.set(next, entry);
@@ -296,8 +297,8 @@ var CompositeFilesystem = class {
     }
     return entriesMap.size > 0 ? Array.from(entriesMap.values()) : null;
   }
-  isVirtualPath(path7) {
-    const normalized = this.normalizePath(path7);
+  isVirtualPath(path8) {
+    const normalized = this.normalizePath(path8);
     if (normalized === "/" && !this._mounts.has("/")) return true;
     for (const mountPath of this._mounts.keys()) {
       if (mountPath.startsWith(normalized + "/")) return true;
@@ -308,9 +309,9 @@ var CompositeFilesystem = class {
    * Assert that a filesystem is writable (not read-only).
    * @throws {PermissionError} if the filesystem is read-only
    */
-  assertWritable(fs5, path7, operation) {
-    if (fs5.readOnly) {
-      throw new PermissionError(path7, `${operation} (filesystem is read-only)`);
+  assertWritable(fs6, path8, operation) {
+    if (fs6.readOnly) {
+      throw new PermissionError(path8, `${operation} (filesystem is read-only)`);
     }
   }
   // ===========================================================================
@@ -318,9 +319,9 @@ var CompositeFilesystem = class {
   // ===========================================================================
   async init() {
     this.status = "initializing";
-    for (const [mountPath, fs5] of this._mounts.entries()) {
+    for (const [mountPath, fs6] of this._mounts.entries()) {
       try {
-        await callLifecycle(fs5, "init");
+        await callLifecycle(fs6, "init");
       } catch (e) {
         const message = e instanceof Error ? e.message : String(e);
         console.warn(`[CompositeFilesystem] Mount "${mountPath}" failed to initialize: ${message}`);
@@ -331,9 +332,9 @@ var CompositeFilesystem = class {
   async destroy() {
     this.status = "destroying";
     const errors = [];
-    for (const fs5 of this._mounts.values()) {
+    for (const fs6 of this._mounts.values()) {
       try {
-        await callLifecycle(fs5, "destroy");
+        await callLifecycle(fs6, "destroy");
       } catch (e) {
         errors.push(e instanceof Error ? e : new Error(String(e)));
       }
@@ -344,27 +345,27 @@ var CompositeFilesystem = class {
     }
     this.status = "destroyed";
   }
-  async readFile(path7, options) {
-    const r = this.resolveMount(path7);
-    if (!r) throw new Error(`No mount for path: ${path7}`);
+  async readFile(path8, options) {
+    const r = this.resolveMount(path8);
+    if (!r) throw new Error(`No mount for path: ${path8}`);
     return r.fs.readFile(r.fsPath, options);
   }
-  async writeFile(path7, content, options) {
-    const r = this.resolveMount(path7);
-    if (!r) throw new Error(`No mount for path: ${path7}`);
-    this.assertWritable(r.fs, path7, "writeFile");
+  async writeFile(path8, content, options) {
+    const r = this.resolveMount(path8);
+    if (!r) throw new Error(`No mount for path: ${path8}`);
+    this.assertWritable(r.fs, path8, "writeFile");
     return r.fs.writeFile(r.fsPath, content, options);
   }
-  async appendFile(path7, content) {
-    const r = this.resolveMount(path7);
-    if (!r) throw new Error(`No mount for path: ${path7}`);
-    this.assertWritable(r.fs, path7, "appendFile");
+  async appendFile(path8, content) {
+    const r = this.resolveMount(path8);
+    if (!r) throw new Error(`No mount for path: ${path8}`);
+    this.assertWritable(r.fs, path8, "appendFile");
     return r.fs.appendFile(r.fsPath, content);
   }
-  async deleteFile(path7, options) {
-    const r = this.resolveMount(path7);
-    if (!r) throw new Error(`No mount for path: ${path7}`);
-    this.assertWritable(r.fs, path7, "deleteFile");
+  async deleteFile(path8, options) {
+    const r = this.resolveMount(path8);
+    if (!r) throw new Error(`No mount for path: ${path8}`);
+    this.assertWritable(r.fs, path8, "deleteFile");
     return r.fs.deleteFile(r.fsPath, options);
   }
   async copyFile(src, dest, options) {
@@ -392,35 +393,35 @@ var CompositeFilesystem = class {
     await this.copyFile(src, dest, options);
     await srcR.fs.deleteFile(srcR.fsPath);
   }
-  async readdir(path7, options) {
-    const virtual = this.getVirtualEntries(path7);
+  async readdir(path8, options) {
+    const virtual = this.getVirtualEntries(path8);
     if (virtual) return virtual;
-    const r = this.resolveMount(path7);
-    if (!r) throw new Error(`No mount for path: ${path7}`);
+    const r = this.resolveMount(path8);
+    if (!r) throw new Error(`No mount for path: ${path8}`);
     return r.fs.readdir(r.fsPath, options);
   }
-  async mkdir(path7, options) {
-    const r = this.resolveMount(path7);
-    if (!r) throw new Error(`No mount for path: ${path7}`);
-    this.assertWritable(r.fs, path7, "mkdir");
+  async mkdir(path8, options) {
+    const r = this.resolveMount(path8);
+    if (!r) throw new Error(`No mount for path: ${path8}`);
+    this.assertWritable(r.fs, path8, "mkdir");
     return r.fs.mkdir(r.fsPath, options);
   }
-  async rmdir(path7, options) {
-    const r = this.resolveMount(path7);
-    if (!r) throw new Error(`No mount for path: ${path7}`);
-    this.assertWritable(r.fs, path7, "rmdir");
+  async rmdir(path8, options) {
+    const r = this.resolveMount(path8);
+    if (!r) throw new Error(`No mount for path: ${path8}`);
+    this.assertWritable(r.fs, path8, "rmdir");
     return r.fs.rmdir(r.fsPath, options);
   }
-  async exists(path7) {
-    if (this.isVirtualPath(path7)) return true;
-    const r = this.resolveMount(path7);
+  async exists(path8) {
+    if (this.isVirtualPath(path8)) return true;
+    const r = this.resolveMount(path8);
     if (!r) return false;
     if (r.fsPath === "") return true;
     return r.fs.exists(r.fsPath);
   }
-  async stat(path7) {
-    const normalized = this.normalizePath(path7);
-    if (this.isVirtualPath(path7)) {
+  async stat(path8) {
+    const normalized = this.normalizePath(path8);
+    if (this.isVirtualPath(path8)) {
       const parts = normalized.split("/").filter(Boolean);
       const now = /* @__PURE__ */ new Date();
       return {
@@ -432,8 +433,8 @@ var CompositeFilesystem = class {
         modifiedAt: now
       };
     }
-    const r = this.resolveMount(path7);
-    if (!r) throw new Error(`No mount for path: ${path7}`);
+    const r = this.resolveMount(path8);
+    if (!r) throw new Error(`No mount for path: ${path8}`);
     if (r.fsPath === "") {
       const parts = normalized.split("/").filter(Boolean);
       const now = /* @__PURE__ */ new Date();
@@ -448,9 +449,9 @@ var CompositeFilesystem = class {
     }
     return r.fs.stat(r.fsPath);
   }
-  async isFile(path7) {
-    if (this.isVirtualPath(path7)) return false;
-    const r = this.resolveMount(path7);
+  async isFile(path8) {
+    if (this.isVirtualPath(path8)) return false;
+    const r = this.resolveMount(path8);
     if (!r) return false;
     try {
       const stat3 = await r.fs.stat(r.fsPath);
@@ -459,9 +460,9 @@ var CompositeFilesystem = class {
       return false;
     }
   }
-  async isDirectory(path7) {
-    if (this.isVirtualPath(path7)) return true;
-    const r = this.resolveMount(path7);
+  async isDirectory(path8) {
+    if (this.isVirtualPath(path8)) return true;
+    const r = this.resolveMount(path8);
     if (!r) return false;
     if (r.fsPath === "") return true;
     try {
@@ -476,9 +477,9 @@ var CompositeFilesystem = class {
    * Used by agents to understand available storage locations.
    */
   getInstructions(_opts) {
-    const mountDescriptions = Array.from(this._mounts.entries()).map(([mountPath, fs5]) => {
-      const name = fs5.displayName || fs5.provider;
-      const access3 = fs5.readOnly ? "(read-only)" : "(read-write)";
+    const mountDescriptions = Array.from(this._mounts.entries()).map(([mountPath, fs6]) => {
+      const name = fs6.displayName || fs6.provider;
+      const access3 = fs6.readOnly ? "(read-only)" : "(read-write)";
       return `- ${mountPath}: ${name} ${access3}`;
     }).join("\n");
     return `Filesystem mount points:
@@ -1346,35 +1347,35 @@ var LocalFilesystem = class extends MastraFilesystem {
 };
 var InMemoryFileReadTracker = class {
   records = /* @__PURE__ */ new Map();
-  recordRead(path7, modifiedAt) {
-    const normalizedPath = this.normalizePath(path7);
+  recordRead(path8, modifiedAt) {
+    const normalizedPath = this.normalizePath(path8);
     this.records.set(normalizedPath, {
       path: normalizedPath,
       readAt: /* @__PURE__ */ new Date(),
       modifiedAtRead: modifiedAt
     });
   }
-  getReadRecord(path7) {
-    return this.records.get(this.normalizePath(path7));
+  getReadRecord(path8) {
+    return this.records.get(this.normalizePath(path8));
   }
-  needsReRead(path7, currentModifiedAt) {
-    const record = this.getReadRecord(path7);
+  needsReRead(path8, currentModifiedAt) {
+    const record = this.getReadRecord(path8);
     if (!record) {
       return {
         needsReRead: true,
-        reason: `File "${path7}" has not been read. You must read a file before writing to it.`
+        reason: `File "${path8}" has not been read. You must read a file before writing to it.`
       };
     }
     if (currentModifiedAt.getTime() > record.modifiedAtRead.getTime()) {
       return {
         needsReRead: true,
-        reason: `File "${path7}" was modified since last read (read at: ${record.modifiedAtRead.toISOString()}, current: ${currentModifiedAt.toISOString()}). Please re-read the file to get the latest contents.`
+        reason: `File "${path8}" was modified since last read (read at: ${record.modifiedAtRead.toISOString()}, current: ${currentModifiedAt.toISOString()}). Please re-read the file to get the latest contents.`
       };
     }
     return { needsReRead: false };
   }
-  clearReadRecord(path7) {
-    this.records.delete(this.normalizePath(path7));
+  clearReadRecord(path8) {
+    this.records.delete(this.normalizePath(path8));
   }
   clear() {
     this.records.clear();
@@ -1462,10 +1463,10 @@ function createGlobMatcher(patterns, options) {
     posix: true,
     dot: options?.dot ?? false
   });
-  return (path7) => matcher(normalizeForMatch(path7));
+  return (path8) => matcher(normalizeForMatch(path8));
 }
-function matchGlob(path7, pattern, options) {
-  return createGlobMatcher(pattern, options)(path7);
+function matchGlob(path8, pattern, options) {
+  return createGlobMatcher(pattern, options)(path8);
 }
 async function walkAll(readdir4, dir, depth, maxDepth) {
   if (depth >= maxDepth) return [];
@@ -1591,6 +1592,15 @@ async function loadLSPDeps() {
 function toFileUri(fsPath) {
   return pathToFileURL(fsPath).toString();
 }
+async function withTimeout(promise, ms, errorMessage) {
+  let timer;
+  return Promise.race([
+    promise,
+    new Promise((_, reject) => {
+      timer = setTimeout(() => reject(new Error(errorMessage)), ms);
+    })
+  ]).finally(() => clearTimeout(timer));
+}
 var LSPClient = class {
   connection = null;
   handle = null;
@@ -1608,6 +1618,10 @@ var LSPClient = class {
   get isAlive() {
     return this.handle !== null && this.handle.exitCode === void 0;
   }
+  /** Name of the LSP server. */
+  get serverName() {
+    return this.serverDef.name;
+  }
   /**
    * Initialize the LSP connection — spawns the server and performs the handshake.
    */
@@ -1779,6 +1793,56 @@ var LSPClient = class {
       textDocument: { uri }
     });
   }
+  /**
+   * Query hover information at a position.
+   */
+  async queryHover(uri, position, timeoutMs = 5e3) {
+    if (!this.connection) return null;
+    return withTimeout(
+      this.connection.sendRequest("textDocument/hover", { textDocument: { uri }, position }),
+      timeoutMs,
+      "Hover request timed out"
+    );
+  }
+  /**
+   * Query definition(s) at a position.
+   */
+  async queryDefinition(uri, position, timeoutMs = 5e3) {
+    if (!this.connection) return [];
+    const result = await withTimeout(
+      this.connection.sendRequest("textDocument/definition", { textDocument: { uri }, position }),
+      timeoutMs,
+      "Definition request timed out"
+    );
+    if (!result) return [];
+    return Array.isArray(result) ? result : result.uri ? [result] : [];
+  }
+  /**
+   * Query type definition(s) at a position.
+   */
+  async queryTypeDefinition(uri, position, timeoutMs = 5e3) {
+    if (!this.connection) return [];
+    const result = await withTimeout(
+      this.connection.sendRequest("textDocument/typeDefinition", { textDocument: { uri }, position }),
+      timeoutMs,
+      "Type definition request timed out"
+    );
+    if (!result) return [];
+    return Array.isArray(result) ? result : result.uri ? [result] : [];
+  }
+  /**
+   * Query implementation(s) at a position.
+   */
+  async queryImplementation(uri, position, timeoutMs = 5e3) {
+    if (!this.connection) return [];
+    const result = await withTimeout(
+      this.connection.sendRequest("textDocument/implementation", { textDocument: { uri }, position }),
+      timeoutMs,
+      "Implementation request timed out"
+    );
+    if (!result) return [];
+    return Array.isArray(result) ? result : result.uri ? [result] : [];
+  }
   /**
    * Shutdown the connection and kill the process.
    */
@@ -1874,12 +1938,12 @@ function walkUp(startDir, markers) {
   }
   return null;
 }
-async function walkUpAsync(startDir, markers, fs5) {
+async function walkUpAsync(startDir, markers, fs6) {
   let current = startDir;
   const fsRoot = parse(current).root;
   while (true) {
     for (const marker of markers) {
-      if (await fs5.exists(join(current, marker))) {
+      if (await fs6.exists(join(current, marker))) {
         return current;
       }
     }
@@ -2126,6 +2190,28 @@ var LSPManager = class {
     }
     return this.initClient(serverDef, projectRoot, key);
   }
+  /**
+   * Get LSP client ready to query a file.
+   * Opens the file in the client so queries can be made.
+   * Returns null when no LSP client is available.
+   */
+  async prepareQuery(filePath) {
+    const client = await this.getClient(filePath);
+    if (!client) return null;
+    const languageId = getLanguageId(filePath);
+    if (!languageId) return null;
+    const fs6 = await import('fs/promises');
+    let content = "";
+    try {
+      content = await fs6.readFile(filePath, "utf-8");
+    } catch {
+      content = "";
+    }
+    client.notifyOpen(filePath, content, languageId);
+    const { pathToFileURL: pathToFileURL3 } = await import('url');
+    const uri = pathToFileURL3(filePath).toString();
+    return { client, uri, languageId, serverName: client.serverName };
+  }
   /**
    * Convenience method: open file, send content, wait for diagnostics, return normalized results.
    * Returns null when no LSP client is available; otherwise returns diagnostics
@@ -2709,14 +2795,14 @@ var MountManager = class {
   /**
    * Get a mount entry by path.
    */
-  get(path7) {
-    return this._entries.get(path7);
+  get(path8) {
+    return this._entries.get(path8);
   }
   /**
    * Check if a mount exists at the given path.
    */
-  has(path7) {
-    return this._entries.has(path7);
+  has(path8) {
+    return this._entries.has(path8);
   }
   // ---------------------------------------------------------------------------
   // Entry Modification
@@ -2728,8 +2814,8 @@ var MountManager = class {
   add(mounts) {
     const paths = Object.keys(mounts);
     this.logger.debug(`Adding ${paths.length} pending mount(s)`, { paths });
-    for (const [path7, filesystem] of Object.entries(mounts)) {
-      this._entries.set(path7, {
+    for (const [path8, filesystem] of Object.entries(mounts)) {
+      this._entries.set(path8, {
         filesystem,
         state: "pending"
       });
@@ -2739,8 +2825,8 @@ var MountManager = class {
    * Update a mount entry's state.
    * Creates the entry if it doesn't exist.
    */
-  set(path7, updates) {
-    const existing = this._entries.get(path7);
+  set(path8, updates) {
+    const existing = this._entries.get(path8);
     if (existing) {
       existing.state = updates.state;
       if (updates.config) {
@@ -2751,7 +2837,7 @@ var MountManager = class {
         existing.error = updates.error;
       }
     } else if (updates.filesystem) {
-      this._entries.set(path7, {
+      this._entries.set(path8, {
         filesystem: updates.filesystem,
         state: updates.state,
         config: updates.config,
@@ -2759,14 +2845,14 @@ var MountManager = class {
         error: updates.error
       });
     } else {
-      this.logger.debug(`set() called for unknown path "${path7}" without filesystem \u2014 no entry created`);
+      this.logger.debug(`set() called for unknown path "${path8}" without filesystem \u2014 no entry created`);
     }
   }
   /**
    * Delete a mount entry.
    */
-  delete(path7) {
-    return this._entries.delete(path7);
+  delete(path8) {
+    return this._entries.delete(path8);
   }
   /**
    * Clear all mount entries.
@@ -2787,7 +2873,7 @@ var MountManager = class {
       return;
     }
     this.logger.debug(`Processing ${pendingCount} pending mount(s)`);
-    for (const [path7, entry] of this._entries) {
+    for (const [path8, entry] of this._entries) {
       if (entry.state !== "pending") {
         continue;
       }
@@ -2797,7 +2883,7 @@ var MountManager = class {
         try {
           const hookResult = await this._onMount({
             filesystem: entry.filesystem,
-            mountPath: path7,
+            mountPath: path8,
             config,
             sandbox: this._sandbox,
             workspace: this._workspace
@@ -2805,7 +2891,7 @@ var MountManager = class {
           if (hookResult === false) {
             entry.state = "unsupported";
             entry.error = "Skipped by onMount hook";
-            this.logger.debug(`Mount skipped by onMount hook`, { path: path7, provider: fsProvider });
+            this.logger.debug(`Mount skipped by onMount hook`, { path: path8, provider: fsProvider });
             continue;
           }
           if (hookResult && typeof hookResult === "object") {
@@ -2813,54 +2899,54 @@ var MountManager = class {
               entry.state = "mounted";
               entry.config = config;
               entry.configHash = config ? this.hashConfig(config) : void 0;
-              this.logger.info(`Mount handled by onMount hook`, { path: path7, provider: fsProvider });
+              this.logger.info(`Mount handled by onMount hook`, { path: path8, provider: fsProvider });
             } else {
               entry.state = "error";
               entry.error = hookResult.error ?? "Mount hook failed";
-              this.logger.error(`Mount hook failed`, { path: path7, provider: fsProvider, error: entry.error });
+              this.logger.error(`Mount hook failed`, { path: path8, provider: fsProvider, error: entry.error });
             }
             continue;
           }
         } catch (err) {
           entry.state = "error";
           entry.error = `Mount hook error: ${String(err)}`;
-          this.logger.error(`Mount hook threw error`, { path: path7, provider: fsProvider, error: entry.error });
+          this.logger.error(`Mount hook threw error`, { path: path8, provider: fsProvider, error: entry.error });
           continue;
         }
       }
       if (!config) {
         entry.state = "unsupported";
         entry.error = "Filesystem does not support mounting";
-        this.logger.debug(`Filesystem does not support mounting`, { path: path7, provider: fsProvider });
+        this.logger.debug(`Filesystem does not support mounting`, { path: path8, provider: fsProvider });
         continue;
       }
       entry.config = config;
       entry.configHash = this.hashConfig(config);
       entry.state = "mounting";
-      this.logger.debug(`Mounting filesystem`, { path: path7, provider: fsProvider, type: config.type });
+      this.logger.debug(`Mounting filesystem`, { path: path8, provider: fsProvider, type: config.type });
       try {
-        const result = await this._mountFn(entry.filesystem, path7);
+        const result = await this._mountFn(entry.filesystem, path8);
         if (result.success) {
           entry.state = "mounted";
-          this.logger.info(`Mount successful`, { path: path7, provider: fsProvider });
+          this.logger.info(`Mount successful`, { path: path8, provider: fsProvider });
         } else if (result.unavailable) {
           entry.state = "unavailable";
           entry.error = result.error ?? "FUSE tool not installed";
-          this.logger.warn(`FUSE mount unavailable`, { path: path7, provider: fsProvider, error: entry.error });
+          this.logger.warn(`FUSE mount unavailable`, { path: path8, provider: fsProvider, error: entry.error });
         } else {
           entry.state = "error";
           entry.error = result.error ?? "Mount failed";
-          this.logger.error(`Mount failed`, { path: path7, provider: fsProvider, error: entry.error });
+          this.logger.error(`Mount failed`, { path: path8, provider: fsProvider, error: entry.error });
         }
       } catch (err) {
         if (err instanceof MountToolNotFoundError) {
           entry.state = "unavailable";
           entry.error = String(err);
-          this.logger.warn(`FUSE mount unavailable`, { path: path7, provider: fsProvider, error: entry.error });
+          this.logger.warn(`FUSE mount unavailable`, { path: path8, provider: fsProvider, error: entry.error });
         } else {
           entry.state = "error";
           entry.error = String(err);
-          this.logger.error(`Mount threw error`, { path: path7, provider: fsProvider, error: entry.error });
+          this.logger.error(`Mount threw error`, { path: path8, provider: fsProvider, error: entry.error });
         }
       }
     }
@@ -2909,10 +2995,10 @@ var MountManager = class {
     if (separatorIndex <= 0) {
       return null;
     }
-    const path7 = content.slice(0, separatorIndex);
+    const path8 = content.slice(0, separatorIndex);
     const configHash = content.slice(separatorIndex + 1);
-    if (!path7 || !configHash) return null;
-    return { path: path7, configHash };
+    if (!path8 || !configHash) return null;
+    return { path: path8, configHash };
   }
   /**
    * Check if a config hash matches the expected hash for a mount path.
@@ -3398,11 +3484,11 @@ function buildBwrapCommand(command, workspacePath, config) {
   }
   bwrapArgs.push("--proc", "/proc");
   bwrapArgs.push("--tmpfs", "/tmp");
-  for (const path7 of DEFAULT_READONLY_BINDS) {
-    bwrapArgs.push("--ro-bind-try", path7, path7);
+  for (const path8 of DEFAULT_READONLY_BINDS) {
+    bwrapArgs.push("--ro-bind-try", path8, path8);
   }
-  for (const path7 of config.readOnlyPaths ?? []) {
-    bwrapArgs.push("--ro-bind", path7, path7);
+  for (const path8 of config.readOnlyPaths ?? []) {
+    bwrapArgs.push("--ro-bind", path8, path8);
   }
   if (config.allowSystemBinaries !== false) {
     const nodePath4 = process.execPath;
@@ -3414,8 +3500,8 @@ function buildBwrapCommand(command, workspacePath, config) {
     bwrapArgs.push("--ro-bind-try", "/snap", "/snap");
   }
   bwrapArgs.push("--bind", workspacePath, workspacePath);
-  for (const path7 of config.readWritePaths ?? []) {
-    bwrapArgs.push("--bind", path7, path7);
+  for (const path8 of config.readWritePaths ?? []) {
+    bwrapArgs.push("--bind", path8, path8);
   }
   bwrapArgs.push("--chdir", workspacePath);
   bwrapArgs.push("--die-with-parent");
@@ -4823,18 +4909,18 @@ var VersionedSkillSource = class {
   /**
    * Normalize a path by stripping leading/trailing slashes and dots.
    */
-  #normalizePath(path7) {
-    let normalized = path7.replace(/^[./\\]+|[/\\]+$/g, "");
+  #normalizePath(path8) {
+    let normalized = path8.replace(/^[./\\]+|[/\\]+$/g, "");
     if (normalized === "") return "";
     return normalized;
   }
-  async exists(path7) {
-    const normalized = this.#normalizePath(path7);
+  async exists(path8) {
+    const normalized = this.#normalizePath(path8);
     if (this.#tree.entries[normalized]) return true;
     return this.#directories.has(normalized);
   }
-  async stat(path7) {
-    const normalized = this.#normalizePath(path7);
+  async stat(path8) {
+    const normalized = this.#normalizePath(path8);
     const name = normalized.split("/").pop() || normalized || ".";
     const entry = this.#tree.entries[normalized];
     if (entry) {
@@ -4856,27 +4942,27 @@ var VersionedSkillSource = class {
         modifiedAt: this.#versionCreatedAt
       };
     }
-    throw new Error(`Path not found in skill version tree: ${path7}`);
+    throw new Error(`Path not found in skill version tree: ${path8}`);
   }
-  async readFile(path7) {
-    const normalized = this.#normalizePath(path7);
+  async readFile(path8) {
+    const normalized = this.#normalizePath(path8);
     const entry = this.#tree.entries[normalized];
     if (!entry) {
-      throw new Error(`File not found in skill version tree: ${path7}`);
+      throw new Error(`File not found in skill version tree: ${path8}`);
     }
     const blob = await this.#blobStore.get(entry.blobHash);
     if (!blob) {
-      throw new Error(`Blob not found for hash ${entry.blobHash} (file: ${path7})`);
+      throw new Error(`Blob not found for hash ${entry.blobHash} (file: ${path8})`);
     }
     if (entry.encoding === "base64") {
       return Buffer.from(blob.content, "base64");
     }
     return blob.content;
   }
-  async readdir(path7) {
-    const normalized = this.#normalizePath(path7);
+  async readdir(path8) {
+    const normalized = this.#normalizePath(path8);
     if (!this.#directories.has(normalized)) {
-      throw new Error(`Directory not found in skill version tree: ${path7}`);
+      throw new Error(`Directory not found in skill version tree: ${path8}`);
     }
     const prefix = normalized === "" ? "" : normalized + "/";
     const seen = /* @__PURE__ */ new Set();
@@ -4909,15 +4995,15 @@ var CompositeVersionedSkillSource = class {
     this.#fallback = options?.fallback;
     this.#fallbackSkills = new Set(options?.fallbackSkills ?? []);
   }
-  #normalizePath(path7) {
-    return path7.replace(/^[./\\]+|[/\\]+$/g, "");
+  #normalizePath(path8) {
+    return path8.replace(/^[./\\]+|[/\\]+$/g, "");
   }
   /**
    * Route a path to the correct source.
    * Returns the source and the remaining path within that source.
    */
-  #routePath(path7) {
-    const normalized = this.#normalizePath(path7);
+  #routePath(path8) {
+    const normalized = this.#normalizePath(path8);
     if (normalized === "") return null;
     const segments = normalized.split("/");
     const skillDir = segments[0];
@@ -4934,15 +5020,15 @@ var CompositeVersionedSkillSource = class {
     }
     return null;
   }
-  async exists(path7) {
-    const normalized = this.#normalizePath(path7);
+  async exists(path8) {
+    const normalized = this.#normalizePath(path8);
     if (normalized === "") return true;
-    const route = this.#routePath(path7);
+    const route = this.#routePath(path8);
     if (!route) return false;
     return route.source.exists(route.subPath);
   }
-  async stat(path7) {
-    const normalized = this.#normalizePath(path7);
+  async stat(path8) {
+    const normalized = this.#normalizePath(path8);
     if (normalized === "") {
       return {
         name: ".",
@@ -4952,21 +5038,21 @@ var CompositeVersionedSkillSource = class {
         modifiedAt: /* @__PURE__ */ new Date()
       };
     }
-    const route = this.#routePath(path7);
+    const route = this.#routePath(path8);
     if (!route) {
-      throw new Error(`Path not found in composite skill source: ${path7}`);
+      throw new Error(`Path not found in composite skill source: ${path8}`);
     }
     return route.source.stat(route.subPath);
   }
-  async readFile(path7) {
-    const route = this.#routePath(path7);
+  async readFile(path8) {
+    const route = this.#routePath(path8);
     if (!route) {
-      throw new Error(`File not found in composite skill source: ${path7}`);
+      throw new Error(`File not found in composite skill source: ${path8}`);
     }
     return route.source.readFile(route.subPath);
   }
-  async readdir(path7) {
-    const normalized = this.#normalizePath(path7);
+  async readdir(path8) {
+    const normalized = this.#normalizePath(path8);
     if (normalized === "") {
       const entries = [];
       const seen = /* @__PURE__ */ new Set();
@@ -4982,9 +5068,9 @@ var CompositeVersionedSkillSource = class {
       }
       return entries;
     }
-    const route = this.#routePath(path7);
+    const route = this.#routePath(path8);
     if (!route) {
-      throw new Error(`Directory not found in composite skill source: ${path7}`);
+      throw new Error(`Directory not found in composite skill source: ${path8}`);
     }
     return route.source.readdir(route.subPath);
   }
@@ -5184,7 +5270,7 @@ var WorkspaceSkillsImpl = class _WorkspaceSkillsImpl {
     if (a.length !== b.length) return false;
     const sortedA = [...a].sort();
     const sortedB = [...b].sort();
-    return sortedA.every((path7, i) => path7 === sortedB[i]);
+    return sortedA.every((path8, i) => path8 === sortedB[i]);
   }
   // ===========================================================================
   // Search
@@ -5790,9 +5876,9 @@ ${validation.errors.join("\n")}`);
   /**
    * Get parent path
    */
-  #getParentPath(path7) {
-    const lastSlash = path7.lastIndexOf("/");
-    return lastSlash > 0 ? path7.substring(0, lastSlash) : "/";
+  #getParentPath(path8) {
+    const lastSlash = path8.lastIndexOf("/");
+    return lastSlash > 0 ? path8.substring(0, lastSlash) : "/";
   }
 };
 function hashContent(content) {
@@ -6023,14 +6109,14 @@ function createSkillReadTool(skills) {
       startLine: z.number().optional().describe("Starting line number (1-indexed). If omitted, starts from the beginning."),
       endLine: z.number().optional().describe("Ending line number (1-indexed, inclusive). If omitted, reads to the end.")
     }),
-    execute: async ({ skillName, path: path7, startLine, endLine }) => {
+    execute: async ({ skillName, path: path8, startLine, endLine }) => {
       const resolved = await resolveSkill(skills, skillName);
       if ("notFound" in resolved) return resolved.notFound;
       const resolvedPath = resolved.skill.path;
       let content = null;
-      content = await skills.getReference(resolvedPath, path7);
-      if (content === null) content = await skills.getScript(resolvedPath, path7);
-      if (content === null) content = await skills.getAsset(resolvedPath, path7);
+      content = await skills.getReference(resolvedPath, path8);
+      if (content === null) content = await skills.getScript(resolvedPath, path8);
+      if (content === null) content = await skills.getAsset(resolvedPath, path8);
       if (content === null) {
         const refs = (await skills.listReferences(resolvedPath)).map((f) => `references/${f}`);
         const scriptsList = (await skills.listScripts(resolvedPath)).map((f) => `scripts/${f}`);
@@ -6038,11 +6124,11 @@ function createSkillReadTool(skills) {
         const allFiles = [...refs, ...scriptsList, ...assets];
         const fileList = allFiles.length > 0 ? `
 Available files: ${allFiles.join(", ")}` : "";
-        return `File "${path7}" not found in skill "${skillName}".${fileList}`;
+        return `File "${path8}" not found in skill "${skillName}".${fileList}`;
       }
       const textContent = typeof content === "string" ? content : content.toString("utf-8");
       if (textContent.slice(0, 1e3).includes("\0")) {
-        const fullPath = `${resolved.skill.path}/${path7}`;
+        const fullPath = `${resolved.skill.path}/${path8}`;
         const size = typeof content === "string" ? Buffer.byteLength(content) : content.length;
         return `Binary file: ${fullPath} (${size} bytes)`;
       }
@@ -6078,8 +6164,8 @@ var Workspace = class {
       if (config.filesystem) {
         throw new WorkspaceError('Cannot use both "filesystem" and "mounts"', "INVALID_CONFIG");
       }
-      for (const [mountPath, fs5] of Object.entries(config.mounts)) {
-        if (fs5 instanceof LocalFilesystem && !fs5.contained) {
+      for (const [mountPath, fs6] of Object.entries(config.mounts)) {
+        if (fs6 instanceof LocalFilesystem && !fs6.contained) {
           console.warn(
             `[Workspace] LocalFilesystem at mount "${mountPath}" has contained: false, which is incompatible with mounts. CompositeFilesystem strips mount prefixes and produces absolute paths (e.g. "/file.txt"), which a non-contained LocalFilesystem interprets as real host paths instead of paths relative to basePath. Use contained: true (default) or allowedPaths for specific exceptions.`
           );
@@ -6275,13 +6361,13 @@ var Workspace = class {
    * @param options - Index options (metadata, type hints)
    * @throws {SearchNotAvailableError} if search is not configured
    */
-  async index(path7, content, options) {
+  async index(path8, content, options) {
     if (!this._searchEngine) {
       throw new SearchNotAvailableError();
     }
     this.lastAccessedAt = /* @__PURE__ */ new Date();
     const doc = {
-      id: path7,
+      id: path8,
       content,
       metadata: {
         type: options?.type,
@@ -6590,6 +6676,9 @@ var WORKSPACE_TOOLS = {
   SEARCH: {
     SEARCH: `${WORKSPACE_TOOLS_PREFIX}_search`,
     INDEX: `${WORKSPACE_TOOLS_PREFIX}_index`
+  },
+  LSP: {
+    LSP_INSPECT: `${WORKSPACE_TOOLS_PREFIX}_lsp_inspect`
   }
 };
 function requireWorkspace(context) {
@@ -6912,7 +7001,7 @@ Pattern replace (for everything else):
       isDefault: z.boolean().optional().describe("Whether the first name is a default import")
     }).optional().describe("Required for add-import transform. Specifies the module and names to import.")
   }),
-  execute: async ({ path: path7, pattern, replacement, transform, targetName, newName, importSpec }, context) => {
+  execute: async ({ path: path8, pattern, replacement, transform, targetName, newName, importSpec }, context) => {
     const { workspace, filesystem } = requireFilesystem(context);
     await emitWorkspaceMetadata(context, WORKSPACE_TOOLS.FILESYSTEM.AST_EDIT);
     if (filesystem.readOnly) {
@@ -6925,19 +7014,19 @@ Pattern replace (for everything else):
     const { parse: parse2, Lang } = astGrep;
     let content;
     try {
-      content = await filesystem.readFile(path7, { encoding: "utf-8" });
+      content = await filesystem.readFile(path8, { encoding: "utf-8" });
     } catch (error) {
       if (error instanceof FileNotFoundError) {
-        return `File not found: ${path7}. Use the write file tool to create it first.`;
+        return `File not found: ${path8}. Use the write file tool to create it first.`;
       }
       throw error;
     }
     if (typeof content !== "string") {
       return `Cannot perform AST edits on binary files. Use the write file tool instead.`;
     }
-    const lang = getLanguageFromPath(path7, Lang);
+    const lang = getLanguageFromPath(path8, Lang);
     if (!lang) {
-      return `Unsupported file type for AST editing: ${path7}`;
+      return `Unsupported file type for AST editing: ${path8}`;
     }
     const ast = parse2(lang, content);
     const root = ast.root();
@@ -6987,16 +7076,16 @@ Pattern replace (for everything else):
     }
     const wasModified = modifiedContent !== content;
     if (wasModified) {
-      await filesystem.writeFile(path7, modifiedContent, {
+      await filesystem.writeFile(path8, modifiedContent, {
         overwrite: true,
         expectedMtime: context?.__expectedMtime
       });
     }
     if (!wasModified) {
-      return `No changes made to ${path7} (${changes.join("; ")})`;
+      return `No changes made to ${path8} (${changes.join("; ")})`;
     }
-    let output = `${path7}: ${changes.join("; ")}`;
-    output += await getEditDiagnosticsText(workspace, path7, modifiedContent);
+    let output = `${path8}: ${changes.join("; ")}`;
+    output += await getEditDiagnosticsText(workspace, path8, modifiedContent);
     return output;
   }
 });
@@ -7007,19 +7096,19 @@ var deleteFileTool = createTool({
     path: z.string().describe("The path to the file or directory to delete"),
     recursive: z.boolean().optional().default(false).describe("If true, delete directories and their contents recursively. Required for non-empty directories.")
   }),
-  execute: async ({ path: path7, recursive }, context) => {
+  execute: async ({ path: path8, recursive }, context) => {
     const { filesystem } = requireFilesystem(context);
     await emitWorkspaceMetadata(context, WORKSPACE_TOOLS.FILESYSTEM.DELETE);
     if (filesystem.readOnly) {
       throw new WorkspaceReadOnlyError("delete");
     }
-    const stat3 = await filesystem.stat(path7);
+    const stat3 = await filesystem.stat(path8);
     if (stat3.type === "directory") {
-      await filesystem.rmdir(path7, { recursive, force: recursive });
+      await filesystem.rmdir(path8, { recursive, force: recursive });
     } else {
-      await filesystem.deleteFile(path7);
+      await filesystem.deleteFile(path8);
     }
-    return `Deleted ${path7}`;
+    return `Deleted ${path8}`;
   }
 });
 var editFileTool = createTool({
@@ -7037,24 +7126,24 @@ Usage:
     new_string: z.string().describe("The text to replace old_string with"),
     replace_all: z.boolean().optional().default(false).describe("If true, replace all occurrences. If false (default), old_string must be unique.")
   }),
-  execute: async ({ path: path7, old_string, new_string, replace_all }, context) => {
+  execute: async ({ path: path8, old_string, new_string, replace_all }, context) => {
     const { workspace, filesystem } = requireFilesystem(context);
     await emitWorkspaceMetadata(context, WORKSPACE_TOOLS.FILESYSTEM.EDIT_FILE);
     if (filesystem.readOnly) {
       throw new WorkspaceReadOnlyError("edit_file");
     }
     try {
-      const content = await filesystem.readFile(path7, { encoding: "utf-8" });
+      const content = await filesystem.readFile(path8, { encoding: "utf-8" });
       if (typeof content !== "string") {
         return `Cannot edit binary files. Use the write file tool instead.`;
       }
       const result = replaceString(content, old_string, new_string, replace_all);
-      await filesystem.writeFile(path7, result.content, {
+      await filesystem.writeFile(path8, result.content, {
         overwrite: true,
         expectedMtime: context?.__expectedMtime
       });
-      let output = `Replaced ${result.replacements} occurrence${result.replacements !== 1 ? "s" : ""} in ${path7}`;
-      output += await getEditDiagnosticsText(workspace, path7, result.content);
+      let output = `Replaced ${result.replacements} occurrence${result.replacements !== 1 ? "s" : ""} in ${path8}`;
+      output += await getEditDiagnosticsText(workspace, path8, result.content);
       return output;
     } catch (error) {
       if (error instanceof StringNotFoundError) {
@@ -7306,19 +7395,19 @@ var fileStatTool = createTool({
   inputSchema: z.object({
     path: z.string().describe("The path to check")
   }),
-  execute: async ({ path: path7 }, context) => {
+  execute: async ({ path: path8 }, context) => {
     const { filesystem } = requireFilesystem(context);
     await emitWorkspaceMetadata(context, WORKSPACE_TOOLS.FILESYSTEM.FILE_STAT);
     try {
-      const stat3 = await filesystem.stat(path7);
+      const stat3 = await filesystem.stat(path8);
       const modifiedAt = stat3.modifiedAt.toISOString();
-      const parts = [`${path7}`, `Type: ${stat3.type}`];
+      const parts = [`${path8}`, `Type: ${stat3.type}`];
       if (stat3.size !== void 0) parts.push(`Size: ${stat3.size} bytes`);
       parts.push(`Modified: ${modifiedAt}`);
       return parts.join(" ");
     } catch (error) {
       if (error instanceof FileNotFoundError) {
-        return `${path7}: not found`;
+        return `${path8}: not found`;
       }
       throw error;
     }
@@ -7584,11 +7673,11 @@ var indexContentTool = createTool({
     content: z.string().describe("The text content to index"),
     metadata: z.record(z.string(), z.unknown()).optional().describe("Optional metadata to store with the document")
   }),
-  execute: async ({ path: path7, content, metadata }, context) => {
+  execute: async ({ path: path8, content, metadata }, context) => {
     const workspace = requireWorkspace(context);
     await emitWorkspaceMetadata(context, WORKSPACE_TOOLS.SEARCH.INDEX);
-    await workspace.index(path7, content, { metadata });
-    return `Indexed ${path7}`;
+    await workspace.index(path8, content, { metadata });
+    return `Indexed ${path8}`;
   }
 });
 var KILL_TAIL_LINES = 50;
@@ -7644,7 +7733,7 @@ Use this to stop a long-running background process that was started with execute
 });
 
 // src/workspace/tools/tree-formatter.ts
-async function formatAsTree(fs5, path7, options) {
+async function formatAsTree(fs6, path8, options) {
   const maxDepth = options?.maxDepth ?? Infinity;
   const showHidden = options?.showHidden ?? false;
   const dirsOnly = options?.dirsOnly ?? false;
@@ -7654,9 +7743,9 @@ async function formatAsTree(fs5, path7, options) {
   const respectGitignore = options?.respectGitignore ?? true;
   let ignoreFilter = options?.ignoreFilter;
   if (!ignoreFilter && respectGitignore) {
-    const rawFilter = await loadGitignore(fs5);
+    const rawFilter = await loadGitignore(fs6);
     if (rawFilter) {
-      const normalizedPath = path7.replace(/^\.\//, "").replace(/^\//, "").replace(/\/$/, "");
+      const normalizedPath = path8.replace(/^\.\//, "").replace(/^\//, "").replace(/\/$/, "");
       const targetIsIgnored = normalizedPath && rawFilter(normalizedPath + "/");
       ignoreFilter = targetIsIgnored ? void 0 : rawFilter;
     }
@@ -7678,7 +7767,7 @@ async function formatAsTree(fs5, path7, options) {
     }
     let entries;
     try {
-      entries = await fs5.readdir(currentPath);
+      entries = await fs6.readdir(currentPath);
     } catch (error) {
       if (depth === 0) {
         throw error;
@@ -7718,7 +7807,7 @@ async function formatAsTree(fs5, path7, options) {
     if (globMatcher && !dirsOnly) {
       filtered = filtered.filter((e) => {
         if (e.type === "directory") return true;
-        const relativePath = getRelativePath(path7, currentPath, e.name);
+        const relativePath = getRelativePath(path8, currentPath, e.name);
         return globMatcher(relativePath);
       });
     }
@@ -7732,7 +7821,7 @@ async function formatAsTree(fs5, path7, options) {
       const entry = filtered[i];
       const displayName = entry.isSymlink && entry.symlinkTarget ? `${entry.name} -> ${entry.symlinkTarget}` : entry.name;
       lines.push(`${indent}${displayName}`);
-      paths.push(getRelativePath(path7, currentPath, entry.name));
+      paths.push(getRelativePath(path8, currentPath, entry.name));
       if (entry.type === "directory") {
         dirCount++;
         if (!entry.isSymlink) {
@@ -7744,7 +7833,7 @@ async function formatAsTree(fs5, path7, options) {
       }
     }
   }
-  await buildTree(path7, 0);
+  await buildTree(path8, 0);
   const dirPart = dirCount === 1 ? "1 directory" : `${dirCount} directories`;
   const filePart = fileCount === 1 ? "1 file" : `${fileCount} files`;
   let summary = `${dirPart}, ${filePart}`;
@@ -7807,10 +7896,10 @@ Examples:
     ),
     respectGitignore: z.boolean().optional().default(true).describe("Respect .gitignore in the listed directory (default: true).")
   }),
-  execute: async ({ path: path7 = ".", maxDepth = 2, showHidden, dirsOnly, exclude, extension, pattern, respectGitignore }, context) => {
+  execute: async ({ path: path8 = ".", maxDepth = 2, showHidden, dirsOnly, exclude, extension, pattern, respectGitignore }, context) => {
     const { workspace, filesystem } = requireFilesystem(context);
     await emitWorkspaceMetadata(context, WORKSPACE_TOOLS.FILESYSTEM.LIST_FILES);
-    const result = await formatAsTree(filesystem, path7, {
+    const result = await formatAsTree(filesystem, path8, {
       maxDepth,
       showHidden,
       dirsOnly,
@@ -7828,6 +7917,194 @@ ${result.summary}`,
     );
   }
 });
+var CURSOR_MARKER = "<<<";
+async function getLinePreview(filePath, lineNumber) {
+  try {
+    const content = await fs2__default.readFile(filePath, "utf-8");
+    const lines = content.split("\n");
+    const line = lines[lineNumber - 1];
+    return line?.trim() ?? null;
+  } catch {
+    return null;
+  }
+}
+function getAbsolutePath(workspacePath, lspRoot, resolveAbsolutePath) {
+  const resolvedPath = resolveAbsolutePath?.(workspacePath);
+  if (resolvedPath) {
+    return resolvedPath;
+  }
+  if (nodePath__default.isAbsolute(workspacePath)) {
+    return workspacePath;
+  }
+  return nodePath__default.resolve(lspRoot, workspacePath);
+}
+function locationUriToPath(uri) {
+  if (!uri.startsWith("file://")) {
+    return null;
+  }
+  try {
+    return fileURLToPath(uri);
+  } catch {
+    return null;
+  }
+}
+function locationKey(location) {
+  return `${location.path}:L${location.line}`;
+}
+function compressPath(filePath) {
+  const cwd = process.cwd();
+  if (filePath.startsWith(cwd)) {
+    return "$cwd" + filePath.slice(cwd.length);
+  }
+  return filePath;
+}
+var lspInspectTool = createTool({
+  id: WORKSPACE_TOOLS.LSP.LSP_INSPECT,
+  description: "Inspect code at a specific symbol position using the Language Server Protocol. Provide an absolute file path, a 1-indexed line number, and the exact line content with <<< marking the cursor position. Exactly one <<< marker is required. Returns hover information, any diagnostics reported on that line, plus definition and implementation locations when available. Use this for type information, symbol navigation, and go-to-definition; use view to read the surrounding implementation.",
+  inputSchema: z.object({
+    path: z.string().describe("Absolute path to the file"),
+    line: z.number().int().positive().describe("Line number (1-indexed)"),
+    match: z.string().describe(
+      'Line content with <<< marking the cursor position. Exactly one <<< marker is required. Example: "const foo = <<<bar()" means cursor is at bar'
+    )
+  }),
+  execute: async ({ path: filePath, line, match }, context) => {
+    const workspace = requireWorkspace(context);
+    await emitWorkspaceMetadata(context, WORKSPACE_TOOLS.LSP.LSP_INSPECT);
+    const cursorPositions = [];
+    let searchStart = 0;
+    while (true) {
+      const pos = match.indexOf(CURSOR_MARKER, searchStart);
+      if (pos === -1) break;
+      cursorPositions.push(pos);
+      searchStart = pos + CURSOR_MARKER.length;
+    }
+    if (cursorPositions.length === 0) {
+      return {
+        error: `No <<< cursor marker found in match`
+      };
+    }
+    if (cursorPositions.length > 1) {
+      return {
+        error: `Multiple <<< markers found (found ${cursorPositions.length}, expected 1)`
+      };
+    }
+    const character = cursorPositions[0] + 1;
+    const lspManager = workspace.lsp;
+    if (!lspManager) {
+      return {
+        error: "LSP is not configured for this workspace. Enable LSP in workspace config to use this tool."
+      };
+    }
+    const absolutePath = getAbsolutePath(
+      filePath,
+      lspManager.root,
+      workspace.filesystem?.resolveAbsolutePath?.bind(workspace.filesystem)
+    );
+    let fileContent = "";
+    try {
+      fileContent = await fs2__default.readFile(absolutePath, "utf-8");
+    } catch {
+      fileContent = "";
+    }
+    let queryResult;
+    try {
+      queryResult = await lspManager.prepareQuery(absolutePath);
+    } catch (err) {
+      return {
+        error: `Failed to initialize LSP client: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+    if (!queryResult) {
+      return {
+        error: `No language server available for files of this type: ${filePath}`
+      };
+    }
+    const { client, uri } = queryResult;
+    const position = { line: line - 1, character: character - 1 };
+    const result = {};
+    try {
+      const hoverResult = await client.queryHover(uri, position).catch(() => null);
+      if (hoverResult) {
+        const contents = hoverResult.contents;
+        if (contents) {
+          if (typeof contents === "string") {
+            result.hover = { value: contents, kind: "plaintext" };
+          } else if (Array.isArray(contents)) {
+            const first = contents[0];
+            if (typeof first === "string") {
+              result.hover = { value: first, kind: "plaintext" };
+            } else if (first?.value) {
+              result.hover = { value: first.value, kind: first.kind ?? "markdown" };
+            }
+          } else if (contents.value) {
+            result.hover = { value: contents.value, kind: contents.kind ?? "markdown" };
+          }
+        }
+      }
+      const diagnosticsPromise = fileContent ? Promise.resolve().then(() => {
+        client.notifyChange(absolutePath, fileContent, 1);
+        return client.waitForDiagnostics(absolutePath, 5e3, true);
+      }).catch(() => []) : Promise.resolve([]);
+      const [diagnosticsResult, definitionResult, implResult] = await Promise.all([
+        diagnosticsPromise,
+        client.queryDefinition(uri, position).catch(() => []),
+        client.queryImplementation(uri, position).catch(() => [])
+      ]);
+      if (diagnosticsResult && diagnosticsResult.length > 0) {
+        const lineDiagnostics = diagnosticsResult.map((diagnostic) => ({
+          line: typeof diagnostic.line === "number" ? diagnostic.line : (diagnostic.range?.start?.line ?? -1) + 1,
+          severity: typeof diagnostic.severity === "number" ? diagnostic.severity === 1 ? "error" : diagnostic.severity === 2 ? "warning" : diagnostic.severity === 3 ? "info" : "hint" : diagnostic.severity,
+          message: diagnostic.message,
+          source: diagnostic.source ?? null
+        })).filter((diagnostic) => diagnostic.line === line).map(({ severity, message, source }) => ({ severity, message, source }));
+        if (lineDiagnostics.length > 0) {
+          result.diagnostics = lineDiagnostics;
+        }
+      }
+      const definitionLocations = definitionResult.map((loc) => ({
+        uri: loc.uri ?? loc.targetUri,
+        range: loc.range ?? loc.targetRange
+      })).map((loc) => {
+        const resolvedPath = loc.uri ? locationUriToPath(String(loc.uri)) : null;
+        return resolvedPath ? {
+          path: resolvedPath,
+          line: (loc.range?.start?.line ?? 0) + 1,
+          character: (loc.range?.start?.character ?? 0) + 1
+        } : null;
+      }).filter((loc) => Boolean(loc)).filter((loc) => !(loc.path === absolutePath && loc.line === line));
+      if (definitionLocations.length > 0) {
+        const previews = await Promise.all(definitionLocations.map((loc) => getLinePreview(loc.path, loc.line)));
+        result.definition = definitionLocations.map((loc, i) => ({
+          location: `${compressPath(loc.path)}:L${loc.line}:C${loc.character}`,
+          preview: previews[i]
+        }));
+      }
+      const definitionKeys = new Set(definitionLocations.map(locationKey));
+      const implementationLocations = implResult.map((loc) => ({
+        uri: loc.uri ?? loc.targetUri,
+        range: loc.range ?? loc.targetRange
+      })).map((loc) => {
+        const resolvedPath = loc.uri ? locationUriToPath(String(loc.uri)) : null;
+        return resolvedPath ? {
+          path: resolvedPath,
+          line: (loc.range?.start?.line ?? 0) + 1,
+          character: (loc.range?.start?.character ?? 0) + 1
+        } : null;
+      }).filter((loc) => Boolean(loc)).filter((loc) => !definitionKeys.has(locationKey(loc)) && !(loc.path === absolutePath && loc.line === line));
+      if (implementationLocations.length > 0) {
+        result.implementation = implementationLocations.map(
+          (loc) => `${compressPath(loc.path)}:L${loc.line}:C${loc.character}`
+        );
+      }
+    } catch (err) {
+      result.error = `LSP query failed: ${err instanceof Error ? err.message : String(err)}`;
+    } finally {
+      client.notifyClose(absolutePath);
+    }
+    return result;
+  }
+});
 var mkdirTool = createTool({
   id: WORKSPACE_TOOLS.FILESYSTEM.MKDIR,
   description: "Create a directory in the workspace filesystem",
@@ -7835,14 +8112,14 @@ var mkdirTool = createTool({
     path: z.string().describe("The path of the directory to create"),
     recursive: z.boolean().optional().default(true).describe("Whether to create parent directories if they do not exist")
   }),
-  execute: async ({ path: path7, recursive }, context) => {
+  execute: async ({ path: path8, recursive }, context) => {
     const { filesystem } = requireFilesystem(context);
     await emitWorkspaceMetadata(context, WORKSPACE_TOOLS.FILESYSTEM.MKDIR);
     if (filesystem.readOnly) {
       throw new WorkspaceReadOnlyError("mkdir");
     }
-    await filesystem.mkdir(path7, { recursive });
-    return `Created directory ${path7}`;
+    await filesystem.mkdir(path8, { recursive });
+    return `Created directory ${path8}`;
   }
 });
 var readFileTool = createTool({
@@ -7855,12 +8132,12 @@ var readFileTool = createTool({
     limit: z.number().optional().describe("Maximum number of lines to read. If omitted, reads to the end of the file."),
     showLineNumbers: z.boolean().optional().default(true).describe("Whether to prefix each line with its line number (default: true)")
   }),
-  execute: async ({ path: path7, encoding, offset, limit, showLineNumbers }, context) => {
+  execute: async ({ path: path8, encoding, offset, limit, showLineNumbers }, context) => {
     const { workspace, filesystem } = requireFilesystem(context);
     await emitWorkspaceMetadata(context, WORKSPACE_TOOLS.FILESYSTEM.READ_FILE);
     const effectiveEncoding = encoding ?? "utf-8";
-    const fullContent = await filesystem.readFile(path7, { encoding: effectiveEncoding });
-    const stat3 = await filesystem.stat(path7);
+    const fullContent = await filesystem.readFile(path8, { encoding: effectiveEncoding });
+    const stat3 = await filesystem.stat(path8);
     const isTextEncoding = !encoding || encoding === "utf-8" || encoding === "utf8";
     const tokenLimit = workspace.getToolsConfig()?.[WORKSPACE_TOOLS.FILESYSTEM.READ_FILE]?.maxOutputTokens;
     if (!isTextEncoding) {
@@ -7928,19 +8205,19 @@ var writeFileTool = createTool({
     content: z.string().describe("The content to write to the file"),
     overwrite: z.boolean().optional().default(true).describe("Whether to overwrite the file if it already exists")
   }),
-  execute: async ({ path: path7, content, overwrite }, context) => {
+  execute: async ({ path: path8, content, overwrite }, context) => {
     const { workspace, filesystem } = requireFilesystem(context);
     await emitWorkspaceMetadata(context, WORKSPACE_TOOLS.FILESYSTEM.WRITE_FILE);
     if (filesystem.readOnly) {
       throw new WorkspaceReadOnlyError("write_file");
     }
-    await filesystem.writeFile(path7, content, {
+    await filesystem.writeFile(path8, content, {
       overwrite,
       expectedMtime: context?.__expectedMtime
     });
     const size = Buffer.byteLength(content, "utf-8");
-    let output = `Wrote ${size} bytes to ${path7}`;
-    output += await getEditDiagnosticsText(workspace, path7, content);
+    let output = `Wrote ${size} bytes to ${path8}`;
+    output += await getEditDiagnosticsText(workspace, path8, content);
     return output;
   }
 });
@@ -8095,9 +8372,10 @@ function createWorkspaceTools(workspace) {
       addTool(WORKSPACE_TOOLS.SANDBOX.KILL_PROCESS, killProcessTool);
     }
   }
+  addTool(WORKSPACE_TOOLS.LSP.LSP_INSPECT, lspInspectTool);
   return tools;
 }
 
 export { BM25Index, CompositeFilesystem, CompositeVersionedSkillSource, DirectoryNotEmptyError, DirectoryNotFoundError, FileExistsError, FileNotFoundError, FileReadRequiredError, FilesystemError, FilesystemNotAvailableError, FilesystemNotMountableError, FilesystemNotReadyError, IsDirectoryError, IsolationUnavailableError, LocalFilesystem, LocalSandbox, LocalSkillSource, MastraFilesystem, MastraSandbox, MountError, MountManager, MountNotSupportedError, NotDirectoryError, PermissionError, ProcessHandle, SandboxError, SandboxExecutionError, SandboxFeatureNotSupportedError, SandboxNotAvailableError, SandboxNotReadyError, SandboxProcessManager, SandboxTimeoutError, SearchNotAvailableError, StaleFileError, VersionedSkillSource, WORKSPACE_TOOLS, WORKSPACE_TOOLS_PREFIX, Workspace, WorkspaceError, WorkspaceNotAvailableError, WorkspaceNotReadyError, WorkspaceReadOnlyError, callLifecycle, collectSkillForPublish, createGlobMatcher, createSkillTools, createWorkspaceTools, deleteFileTool, detectIsolation, editFileTool, executeCommandTool, extractGlobBase, fileStatTool, getRecommendedIsolation, getTiktoken, indexContentTool, isGlobPattern, isIsolationAvailable, listFilesTool, matchGlob, mkdirTool, publishSkillFromSource, readFileTool, requireFilesystem, requireSandbox, requireWorkspace, resolveToolConfig, searchTool, writeFileTool };
-//# sourceMappingURL=chunk-J3NJXIJ4.js.map
-//# sourceMappingURL=chunk-J3NJXIJ4.js.map
+//# sourceMappingURL=chunk-ABA3KD3X.js.map
+//# sourceMappingURL=chunk-ABA3KD3X.js.map