@mastra/core 1.7.0 → 1.8.0

package/dist/{chunk-ZSBM2SVU.js → chunk-4H5F6AFP.js}

@@ -1,20 +1,22 @@
-import { createTool } from './chunk-BQHWJLXU.js';
+import { createTool } from './chunk-63G75DJE.js';
 import { MastraBase } from './chunk-WCAFTXGK.js';
 import { RegisteredLogger } from './chunk-X2WMFSPB.js';
 import posixPath from 'path/posix';
-import { constants } from 'fs';
+import { constants, existsSync } from 'fs';
 import * as fs2 from 'fs/promises';
 import * as nodePath from 'path';
+import nodePath__default, { parse, join, dirname } from 'path';
 import picomatch from 'picomatch';
+import { createRequire } from 'module';
+import { pathToFileURL } from 'url';
+import * as childProcess from 'child_process';
+import { execFileSync } from 'child_process';
 import * as crypto from 'crypto';
 import { createHash } from 'crypto';
 import matter from 'gray-matter';
 import * as os from 'os';
 import os__default from 'os';
-import * as childProcess from 'child_process';
-import { execFileSync } from 'child_process';
 import { Readable, Writable } from 'stream';
-import { createRequire } from 'module';
 import { z } from 'zod';
 
 // src/workspace/errors.ts
@@ -69,59 +71,59 @@ var WorkspaceReadOnlyError = class extends WorkspaceError {
   }
 };
 var FilesystemError = class extends Error {
-  constructor(message, code, path4) {
+  constructor(message, code, path6) {
     super(message);
     this.code = code;
-    this.path = path4;
+    this.path = path6;
     this.name = "FilesystemError";
   }
 };
 var FileNotFoundError = class extends FilesystemError {
-  constructor(path4) {
-    super(`File not found: ${path4}`, "ENOENT", path4);
+  constructor(path6) {
+    super(`File not found: ${path6}`, "ENOENT", path6);
     this.name = "FileNotFoundError";
   }
 };
 var DirectoryNotFoundError = class extends FilesystemError {
-  constructor(path4) {
-    super(`Directory not found: ${path4}`, "ENOENT", path4);
+  constructor(path6) {
+    super(`Directory not found: ${path6}`, "ENOENT", path6);
     this.name = "DirectoryNotFoundError";
   }
 };
 var FileExistsError = class extends FilesystemError {
-  constructor(path4) {
-    super(`File already exists: ${path4}`, "EEXIST", path4);
+  constructor(path6) {
+    super(`File already exists: ${path6}`, "EEXIST", path6);
     this.name = "FileExistsError";
   }
 };
 var IsDirectoryError = class extends FilesystemError {
-  constructor(path4) {
-    super(`Path is a directory: ${path4}`, "EISDIR", path4);
+  constructor(path6) {
+    super(`Path is a directory: ${path6}`, "EISDIR", path6);
     this.name = "IsDirectoryError";
   }
 };
 var NotDirectoryError = class extends FilesystemError {
-  constructor(path4) {
-    super(`Path is not a directory: ${path4}`, "ENOTDIR", path4);
+  constructor(path6) {
+    super(`Path is not a directory: ${path6}`, "ENOTDIR", path6);
     this.name = "NotDirectoryError";
   }
 };
 var DirectoryNotEmptyError = class extends FilesystemError {
-  constructor(path4) {
-    super(`Directory not empty: ${path4}`, "ENOTEMPTY", path4);
+  constructor(path6) {
+    super(`Directory not empty: ${path6}`, "ENOTEMPTY", path6);
     this.name = "DirectoryNotEmptyError";
   }
 };
 var PermissionError = class extends FilesystemError {
-  constructor(path4, operation) {
-    super(`Permission denied: ${operation} on ${path4}`, "EACCES", path4);
+  constructor(path6, operation) {
+    super(`Permission denied: ${operation} on ${path6}`, "EACCES", path6);
     this.operation = operation;
     this.name = "PermissionError";
   }
 };
 var FileReadRequiredError = class extends FilesystemError {
-  constructor(path4, reason) {
-    super(reason, "EREAD_REQUIRED", path4);
+  constructor(path6, reason) {
+    super(reason, "EREAD_REQUIRED", path6);
     this.name = "FileReadRequiredError";
   }
 };
@@ -157,8 +159,8 @@ var CompositeFilesystem = class {
   constructor(config) {
     this.id = `cfs-${Date.now().toString(36)}`;
     this._mounts = /* @__PURE__ */ new Map();
-    for (const [path4, fs5] of Object.entries(config.mounts)) {
-      const normalized = this.normalizePath(path4);
+    for (const [path6, fs5] of Object.entries(config.mounts)) {
+      const normalized = this.normalizePath(path6);
       this._mounts.set(normalized, fs5);
     }
     if (this._mounts.size === 0) {
@@ -209,27 +211,36 @@ var CompositeFilesystem = class {
    * Get the underlying filesystem for a given path.
    * Returns undefined if the path doesn't resolve to any mount.
    */
-  getFilesystemForPath(path4) {
-    const resolved = this.resolveMount(path4);
+  getFilesystemForPath(path6) {
+    const resolved = this.resolveMount(path6);
     return resolved?.fs;
   }
   /**
    * Get the mount path for a given path.
    * Returns undefined if the path doesn't resolve to any mount.
    */
-  getMountPathForPath(path4) {
-    const resolved = this.resolveMount(path4);
+  getMountPathForPath(path6) {
+    const resolved = this.resolveMount(path6);
     return resolved?.mountPath;
   }
-  normalizePath(path4) {
-    if (!path4 || path4 === "/") return "/";
-    let n = posixPath.normalize(path4);
+  /**
+   * Resolve a workspace-relative path to an absolute disk path.
+   * Strips the mount prefix and delegates to the underlying filesystem.
+   */
+  resolveAbsolutePath(path6) {
+    const r = this.resolveMount(path6);
+    if (!r) return void 0;
+    return r.fs.resolveAbsolutePath?.(r.fsPath);
+  }
+  normalizePath(path6) {
+    if (!path6 || path6 === "/") return "/";
+    let n = posixPath.normalize(path6);
     if (!n.startsWith("/")) n = `/${n}`;
     if (n.length > 1 && n.endsWith("/")) n = n.slice(0, -1);
     return n;
   }
-  resolveMount(path4) {
-    const normalized = this.normalizePath(path4);
+  resolveMount(path6) {
+    const normalized = this.normalizePath(path6);
     let best = null;
     for (const [mountPath, fs5] of this._mounts) {
       if (normalized === mountPath || normalized.startsWith(mountPath + "/")) {
@@ -244,8 +255,8 @@ var CompositeFilesystem = class {
     if (!fsPath.startsWith("/")) fsPath = "/" + fsPath;
     return { fs: best.fs, fsPath, mountPath: best.mountPath };
   }
-  getVirtualEntries(path4) {
-    const normalized = this.normalizePath(path4);
+  getVirtualEntries(path6) {
+    const normalized = this.normalizePath(path6);
     if (this.resolveMount(normalized)) return null;
     const entriesMap = /* @__PURE__ */ new Map();
     for (const [mountPath, fs5] of this._mounts.entries()) {
@@ -272,8 +283,8 @@ var CompositeFilesystem = class {
     }
     return entriesMap.size > 0 ? Array.from(entriesMap.values()) : null;
   }
-  isVirtualPath(path4) {
-    const normalized = this.normalizePath(path4);
+  isVirtualPath(path6) {
+    const normalized = this.normalizePath(path6);
     if (normalized === "/" && !this._mounts.has("/")) return true;
     for (const mountPath of this._mounts.keys()) {
       if (mountPath.startsWith(normalized + "/")) return true;
@@ -284,9 +295,9 @@ var CompositeFilesystem = class {
    * Assert that a filesystem is writable (not read-only).
    * @throws {PermissionError} if the filesystem is read-only
    */
-  assertWritable(fs5, path4, operation) {
+  assertWritable(fs5, path6, operation) {
     if (fs5.readOnly) {
-      throw new PermissionError(path4, `${operation} (filesystem is read-only)`);
+      throw new PermissionError(path6, `${operation} (filesystem is read-only)`);
     }
   }
   // ===========================================================================
@@ -320,27 +331,27 @@ var CompositeFilesystem = class {
     }
     this.status = "destroyed";
   }
-  async readFile(path4, options) {
-    const r = this.resolveMount(path4);
-    if (!r) throw new Error(`No mount for path: ${path4}`);
+  async readFile(path6, options) {
+    const r = this.resolveMount(path6);
+    if (!r) throw new Error(`No mount for path: ${path6}`);
     return r.fs.readFile(r.fsPath, options);
   }
-  async writeFile(path4, content, options) {
-    const r = this.resolveMount(path4);
-    if (!r) throw new Error(`No mount for path: ${path4}`);
-    this.assertWritable(r.fs, path4, "writeFile");
+  async writeFile(path6, content, options) {
+    const r = this.resolveMount(path6);
+    if (!r) throw new Error(`No mount for path: ${path6}`);
+    this.assertWritable(r.fs, path6, "writeFile");
     return r.fs.writeFile(r.fsPath, content, options);
   }
-  async appendFile(path4, content) {
-    const r = this.resolveMount(path4);
-    if (!r) throw new Error(`No mount for path: ${path4}`);
-    this.assertWritable(r.fs, path4, "appendFile");
+  async appendFile(path6, content) {
+    const r = this.resolveMount(path6);
+    if (!r) throw new Error(`No mount for path: ${path6}`);
+    this.assertWritable(r.fs, path6, "appendFile");
     return r.fs.appendFile(r.fsPath, content);
   }
-  async deleteFile(path4, options) {
-    const r = this.resolveMount(path4);
-    if (!r) throw new Error(`No mount for path: ${path4}`);
-    this.assertWritable(r.fs, path4, "deleteFile");
+  async deleteFile(path6, options) {
+    const r = this.resolveMount(path6);
+    if (!r) throw new Error(`No mount for path: ${path6}`);
+    this.assertWritable(r.fs, path6, "deleteFile");
     return r.fs.deleteFile(r.fsPath, options);
   }
   async copyFile(src, dest, options) {
@@ -368,35 +379,35 @@ var CompositeFilesystem = class {
     await this.copyFile(src, dest, options);
     await srcR.fs.deleteFile(srcR.fsPath);
   }
-  async readdir(path4, options) {
-    const virtual = this.getVirtualEntries(path4);
+  async readdir(path6, options) {
+    const virtual = this.getVirtualEntries(path6);
     if (virtual) return virtual;
-    const r = this.resolveMount(path4);
-    if (!r) throw new Error(`No mount for path: ${path4}`);
+    const r = this.resolveMount(path6);
+    if (!r) throw new Error(`No mount for path: ${path6}`);
     return r.fs.readdir(r.fsPath, options);
   }
-  async mkdir(path4, options) {
-    const r = this.resolveMount(path4);
-    if (!r) throw new Error(`No mount for path: ${path4}`);
-    this.assertWritable(r.fs, path4, "mkdir");
+  async mkdir(path6, options) {
+    const r = this.resolveMount(path6);
+    if (!r) throw new Error(`No mount for path: ${path6}`);
+    this.assertWritable(r.fs, path6, "mkdir");
     return r.fs.mkdir(r.fsPath, options);
   }
-  async rmdir(path4, options) {
-    const r = this.resolveMount(path4);
-    if (!r) throw new Error(`No mount for path: ${path4}`);
-    this.assertWritable(r.fs, path4, "rmdir");
+  async rmdir(path6, options) {
+    const r = this.resolveMount(path6);
+    if (!r) throw new Error(`No mount for path: ${path6}`);
+    this.assertWritable(r.fs, path6, "rmdir");
     return r.fs.rmdir(r.fsPath, options);
   }
-  async exists(path4) {
-    if (this.isVirtualPath(path4)) return true;
-    const r = this.resolveMount(path4);
+  async exists(path6) {
+    if (this.isVirtualPath(path6)) return true;
+    const r = this.resolveMount(path6);
     if (!r) return false;
     if (r.fsPath === "/") return true;
     return r.fs.exists(r.fsPath);
   }
-  async stat(path4) {
-    const normalized = this.normalizePath(path4);
-    if (this.isVirtualPath(path4)) {
+  async stat(path6) {
+    const normalized = this.normalizePath(path6);
+    if (this.isVirtualPath(path6)) {
       const parts = normalized.split("/").filter(Boolean);
       const now = /* @__PURE__ */ new Date();
       return {
@@ -408,8 +419,8 @@ var CompositeFilesystem = class {
         modifiedAt: now
       };
     }
-    const r = this.resolveMount(path4);
-    if (!r) throw new Error(`No mount for path: ${path4}`);
+    const r = this.resolveMount(path6);
+    if (!r) throw new Error(`No mount for path: ${path6}`);
     if (r.fsPath === "/") {
       const parts = normalized.split("/").filter(Boolean);
       const now = /* @__PURE__ */ new Date();
@@ -424,9 +435,9 @@ var CompositeFilesystem = class {
     }
     return r.fs.stat(r.fsPath);
   }
-  async isFile(path4) {
-    if (this.isVirtualPath(path4)) return false;
-    const r = this.resolveMount(path4);
+  async isFile(path6) {
+    if (this.isVirtualPath(path6)) return false;
+    const r = this.resolveMount(path6);
     if (!r) return false;
     try {
       const stat3 = await r.fs.stat(r.fsPath);
@@ -435,9 +446,9 @@ var CompositeFilesystem = class {
       return false;
     }
   }
-  async isDirectory(path4) {
-    if (this.isVirtualPath(path4)) return true;
-    const r = this.resolveMount(path4);
+  async isDirectory(path6) {
+    if (this.isVirtualPath(path6)) return true;
+    const r = this.resolveMount(path6);
     if (!r) return false;
     if (r.fsPath === "/") return true;
     try {
@@ -740,6 +751,17 @@ function isTextFile(filename) {
   const ext = nodePath.extname(filename).toLowerCase();
   return TEXT_EXTENSIONS.has(ext);
 }
+function resolveWorkspacePath(basePath, filePath) {
+  if (nodePath.isAbsolute(filePath)) {
+    const normalizedBase = nodePath.normalize(basePath);
+    const normalizedFile = nodePath.normalize(filePath);
+    const rel = nodePath.relative(normalizedBase, normalizedFile);
+    if (!rel.startsWith("..") && !nodePath.isAbsolute(rel)) {
+      return normalizedFile;
+    }
+  }
+  return nodePath.join(basePath, filePath.replace(/^\/+/, ""));
+}
 async function fsExists(absolutePath) {
   try {
     await fs2.access(absolutePath);
@@ -827,8 +849,8 @@ var LocalFilesystem = class extends MastraFilesystem {
   _isWithinAnyRoot(absolutePath) {
     const roots = [this._basePath, ...this._allowedPaths];
     return roots.some((root) => {
-      const relative2 = nodePath.relative(root, absolutePath);
-      return !relative2.startsWith("..") && !nodePath.isAbsolute(relative2);
+      const relative3 = nodePath.relative(root, absolutePath);
+      return !relative3.startsWith("..") && !nodePath.isAbsolute(relative3);
     });
   }
   toBuffer(content) {
@@ -845,12 +867,10 @@ var LocalFilesystem = class extends MastraFilesystem {
       if (this._isWithinAnyRoot(normalized)) {
         absolutePath = normalized;
       } else {
-        const cleanedPath = inputPath.replace(/^\/+/, "");
-        absolutePath = nodePath.resolve(this._basePath, nodePath.normalize(cleanedPath));
+        absolutePath = resolveWorkspacePath(this._basePath, inputPath);
       }
     } else {
-      const cleanedPath = inputPath.replace(/^\/+/, "");
-      absolutePath = nodePath.resolve(this._basePath, nodePath.normalize(cleanedPath));
+      absolutePath = resolveWorkspacePath(this._basePath, inputPath);
     }
     if (this._contained) {
       if (!this._isWithinAnyRoot(absolutePath)) {
@@ -859,6 +879,18 @@ var LocalFilesystem = class extends MastraFilesystem {
     }
     return absolutePath;
   }
+  /**
+   * Resolve a workspace-relative path to an absolute disk path.
+   * Uses the same resolution logic as internal file operations.
+   * Returns `undefined` if the path violates containment.
+   */
+  resolveAbsolutePath(inputPath) {
+    try {
+      return this.resolvePath(inputPath);
+    } catch {
+      return void 0;
+    }
+  }
   toRelativePath(absolutePath) {
     return "/" + nodePath.relative(this._basePath, absolutePath).replace(/\\/g, "/");
   }
@@ -1292,35 +1324,35 @@ var LocalFilesystem = class extends MastraFilesystem {
 };
 var InMemoryFileReadTracker = class {
   records = /* @__PURE__ */ new Map();
-  recordRead(path4, modifiedAt) {
-    const normalizedPath = this.normalizePath(path4);
+  recordRead(path6, modifiedAt) {
+    const normalizedPath = this.normalizePath(path6);
     this.records.set(normalizedPath, {
       path: normalizedPath,
       readAt: /* @__PURE__ */ new Date(),
       modifiedAtRead: modifiedAt
     });
   }
-  getReadRecord(path4) {
-    return this.records.get(this.normalizePath(path4));
+  getReadRecord(path6) {
+    return this.records.get(this.normalizePath(path6));
   }
-  needsReRead(path4, currentModifiedAt) {
-    const record = this.getReadRecord(path4);
+  needsReRead(path6, currentModifiedAt) {
+    const record = this.getReadRecord(path6);
     if (!record) {
       return {
         needsReRead: true,
-        reason: `File "${path4}" has not been read. You must read a file before writing to it.`
+        reason: `File "${path6}" has not been read. You must read a file before writing to it.`
       };
     }
     if (currentModifiedAt.getTime() > record.modifiedAtRead.getTime()) {
       return {
         needsReRead: true,
-        reason: `File "${path4}" 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 "${path6}" 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(path4) {
-    this.records.delete(this.normalizePath(path4));
+  clearReadRecord(path6) {
+    this.records.delete(this.normalizePath(path6));
   }
   clear() {
     this.records.clear();
@@ -1408,11 +1440,721 @@ function createGlobMatcher(patterns, options) {
     posix: true,
     dot: options?.dot ?? false
   });
-  return (path4) => matcher(normalizeForMatch(path4));
+  return (path6) => matcher(normalizeForMatch(path6));
+}
+function matchGlob(path6, pattern, options) {
+  return createGlobMatcher(pattern, options)(path6);
+}
+
+// src/workspace/lsp/language.ts
+var LANGUAGE_EXTENSIONS = {
+  // TypeScript/JavaScript
+  ".ts": "typescript",
+  ".tsx": "typescriptreact",
+  ".js": "javascript",
+  ".jsx": "javascriptreact",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  // Python
+  ".py": "python",
+  ".pyi": "python",
+  // Go
+  ".go": "go",
+  // Rust
+  ".rs": "rust",
+  // C/C++
+  ".c": "c",
+  ".cpp": "cpp",
+  ".cc": "cpp",
+  ".cxx": "cpp",
+  ".h": "c",
+  ".hpp": "cpp",
+  // Java
+  ".java": "java",
+  // JSON
+  ".json": "json",
+  ".jsonc": "jsonc",
+  // YAML
+  ".yaml": "yaml",
+  ".yml": "yaml",
+  // Markdown
+  ".md": "markdown",
+  // HTML/CSS
+  ".html": "html",
+  ".css": "css",
+  ".scss": "scss",
+  ".sass": "sass",
+  ".less": "less"
+};
+function getLanguageId(filePath) {
+  const dotIndex = filePath.lastIndexOf(".");
+  if (dotIndex === -1) return void 0;
+  const ext = filePath.substring(dotIndex);
+  return LANGUAGE_EXTENSIONS[ext];
+}
+var jsonrpcModule;
+var lspProtocolModule;
+function isLSPAvailable() {
+  if (jsonrpcModule !== void 0) {
+    return jsonrpcModule !== null;
+  }
+  try {
+    const req = createRequire(import.meta.url);
+    req.resolve("vscode-jsonrpc/node");
+    req.resolve("vscode-languageserver-protocol");
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function loadLSPDeps() {
+  if (jsonrpcModule !== void 0 && lspProtocolModule !== void 0) {
+    if (jsonrpcModule === null || lspProtocolModule === null) return null;
+    return { ...jsonrpcModule, ...lspProtocolModule };
+  }
+  try {
+    const req = createRequire(import.meta.url);
+    const jsonrpc = req("vscode-jsonrpc/node");
+    const protocol = req("vscode-languageserver-protocol");
+    jsonrpcModule = {
+      StreamMessageReader: jsonrpc.StreamMessageReader,
+      StreamMessageWriter: jsonrpc.StreamMessageWriter,
+      createMessageConnection: jsonrpc.createMessageConnection
+    };
+    lspProtocolModule = {
+      TextDocumentIdentifier: protocol.TextDocumentIdentifier,
+      Position: protocol.Position
+    };
+    return { ...jsonrpcModule, ...lspProtocolModule };
+  } catch {
+    jsonrpcModule = null;
+    lspProtocolModule = null;
+    return null;
+  }
+}
+function toFileUri(fsPath) {
+  return pathToFileURL(fsPath).toString();
+}
+var LSPClient = class {
+  connection = null;
+  handle = null;
+  serverDef;
+  workspaceRoot;
+  processManager;
+  diagnostics = /* @__PURE__ */ new Map();
+  initializationOptions = null;
+  constructor(serverDef, workspaceRoot, processManager) {
+    this.serverDef = serverDef;
+    this.workspaceRoot = workspaceRoot;
+    this.processManager = processManager;
+  }
+  /** Whether the underlying server process is still running. */
+  get isAlive() {
+    return this.handle !== null && this.handle.exitCode === void 0;
+  }
+  /**
+   * Initialize the LSP connection — spawns the server and performs the handshake.
+   */
+  async initialize(initTimeout = 1e4) {
+    const deps = await loadLSPDeps();
+    if (!deps) {
+      throw new Error("LSP dependencies (vscode-jsonrpc) are not available");
+    }
+    const { StreamMessageReader, StreamMessageWriter, createMessageConnection } = deps;
+    const command = this.serverDef.command(this.workspaceRoot);
+    if (!command) {
+      throw new Error("Failed to resolve LSP server command");
+    }
+    this.handle = await this.processManager.spawn(command, { cwd: this.workspaceRoot });
+    const initializationOptions = this.serverDef.initialization?.(this.workspaceRoot);
+    const reader = new StreamMessageReader(this.handle.reader);
+    const writer = new StreamMessageWriter(this.handle.writer);
+    this.connection = createMessageConnection(reader, writer);
+    this.connection.onError(() => {
+    });
+    this.connection.onNotification("textDocument/publishDiagnostics", (params) => {
+      this.diagnostics.set(params.uri, params.diagnostics);
+    });
+    this.connection.listen();
+    const initParams = {
+      processId: process.pid,
+      rootUri: toFileUri(this.workspaceRoot),
+      workspaceFolders: [
+        {
+          name: "workspace",
+          uri: toFileUri(this.workspaceRoot)
+        }
+      ],
+      capabilities: {
+        window: { workDoneProgress: true },
+        workspace: { configuration: true },
+        textDocument: {
+          publishDiagnostics: {
+            relatedInformation: true,
+            tagSupport: { valueSet: [1, 2] },
+            versionSupport: false
+          },
+          synchronization: {
+            didOpen: true,
+            didChange: true,
+            dynamicRegistration: false,
+            willSave: false,
+            willSaveWaitUntil: false,
+            didSave: false
+          },
+          completion: {
+            dynamicRegistration: false,
+            completionItem: {
+              snippetSupport: false,
+              commitCharactersSupport: false,
+              documentationFormat: ["markdown", "plaintext"],
+              deprecatedSupport: false,
+              preselectSupport: false
+            }
+          },
+          definition: { dynamicRegistration: false, linkSupport: true },
+          typeDefinition: { dynamicRegistration: false, linkSupport: true },
+          implementation: { dynamicRegistration: false, linkSupport: true },
+          references: { dynamicRegistration: false },
+          documentHighlight: { dynamicRegistration: false },
+          documentSymbol: { dynamicRegistration: false, hierarchicalDocumentSymbolSupport: true },
+          codeAction: {
+            dynamicRegistration: false,
+            codeActionLiteralSupport: {
+              codeActionKind: {
+                valueSet: [
+                  "quickfix",
+                  "refactor",
+                  "refactor.extract",
+                  "refactor.inline",
+                  "refactor.rewrite",
+                  "source",
+                  "source.organizeImports"
+                ]
+              }
+            }
+          },
+          hover: { dynamicRegistration: false, contentFormat: ["markdown", "plaintext"] }
+        }
+      }
+    };
+    if (initializationOptions) {
+      initParams.initializationOptions = initializationOptions;
+      this.initializationOptions = initializationOptions;
+    }
+    this.connection.onRequest("workspace/configuration", (params) => {
+      return params.items?.map(() => ({})) || [];
+    });
+    this.connection.onRequest("window/workDoneProgress/create", () => null);
+    let initTimer;
+    await Promise.race([
+      this.connection.sendRequest("initialize", initParams),
+      new Promise((_, reject) => {
+        initTimer = setTimeout(() => reject(new Error("LSP initialize request timed out")), initTimeout);
+      })
+    ]).finally(() => clearTimeout(initTimer));
+    this.connection.sendNotification("initialized", {});
+    this.connection.sendNotification("workspace/didChangeConfiguration", {
+      settings: this.initializationOptions ?? {}
+    });
+  }
+  /**
+   * Notify the server that a document has been opened.
+   */
+  notifyOpen(filePath, content, languageId) {
+    if (!this.connection) return;
+    const uri = toFileUri(filePath);
+    this.diagnostics.delete(uri);
+    this.connection.sendNotification("textDocument/didOpen", {
+      textDocument: { uri, languageId, version: 0, text: content }
+    });
+  }
+  /**
+   * Notify the server that a document has changed.
+   */
+  notifyChange(filePath, content, version) {
+    if (!this.connection) return;
+    this.connection.sendNotification("textDocument/didChange", {
+      textDocument: { uri: toFileUri(filePath), version },
+      contentChanges: [{ text: content }]
+    });
+  }
+  /**
+   * Wait for diagnostics to arrive for a file.
+   *
+   * When `waitForChange` is false (default), returns as soon as diagnostics
+   * are available. To avoid returning a premature empty array (servers may
+   * publish `[]` first while still analysing), empty results trigger a short
+   * settle window: polling continues for up to `settleMs` (default 500ms)
+   * to see if non-empty diagnostics arrive. Non-empty results are returned
+   * immediately.
+   */
+  async waitForDiagnostics(filePath, timeoutMs = 5e3, waitForChange = false, settleMs = 500) {
+    if (!this.connection) return [];
+    const uri = toFileUri(filePath);
+    const startTime = Date.now();
+    const initialDiagnostics = this.diagnostics.get(uri);
+    let emptyReceivedAt;
+    while (Date.now() - startTime < timeoutMs) {
+      const currentDiagnostics = this.diagnostics.get(uri);
+      if (waitForChange) {
+        if (currentDiagnostics !== void 0 && currentDiagnostics !== initialDiagnostics) {
+          return currentDiagnostics;
+        }
+      } else {
+        if (currentDiagnostics !== void 0) {
+          if (currentDiagnostics.length > 0) return currentDiagnostics;
+          if (emptyReceivedAt === void 0) emptyReceivedAt = Date.now();
+          if (Date.now() - emptyReceivedAt >= settleMs) return currentDiagnostics;
+        }
+      }
+      await new Promise((resolve3) => setTimeout(resolve3, 100));
+    }
+    return waitForChange ? initialDiagnostics || [] : this.diagnostics.get(uri) || [];
+  }
+  /**
+   * Notify the server that a document was closed.
+   */
+  notifyClose(filePath) {
+    if (!this.connection) return;
+    const uri = toFileUri(filePath);
+    this.diagnostics.delete(uri);
+    this.connection.sendNotification("textDocument/didClose", {
+      textDocument: { uri }
+    });
+  }
+  /**
+   * Shutdown the connection and kill the process.
+   */
+  async shutdown() {
+    if (this.connection) {
+      try {
+        if (this.handle && this.handle.exitCode === void 0) {
+          let shutdownTimer;
+          await Promise.race([
+            this.connection.sendRequest("shutdown"),
+            new Promise((_, reject) => {
+              shutdownTimer = setTimeout(() => reject(new Error("Shutdown request timed out")), 1e3);
+            })
+          ]).finally(() => clearTimeout(shutdownTimer));
+          this.connection.sendNotification("exit");
+        }
+      } catch {
+      }
+      try {
+        this.connection.dispose();
+      } catch {
+      }
+      this.connection = null;
+    }
+    if (this.handle) {
+      try {
+        await this.handle.kill();
+      } catch {
+      }
+      this.handle = null;
+    }
+    this.diagnostics = /* @__PURE__ */ new Map();
+  }
+};
+function whichSync(binary) {
+  try {
+    const cmd = process.platform === "win32" ? "where" : "which";
+    execFileSync(cmd, [binary], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function resolveRequire(root, moduleId) {
+  try {
+    const req = createRequire(pathToFileURL(join(root, "package.json")));
+    return { require: req, resolved: req.resolve(moduleId) };
+  } catch {
+  }
+  try {
+    const req = createRequire(pathToFileURL(join(process.cwd(), "package.json")));
+    return { require: req, resolved: req.resolve(moduleId) };
+  } catch {
+    return null;
+  }
+}
+function walkUp(startDir, markers) {
+  let current = startDir;
+  const fsRoot = parse(current).root;
+  while (true) {
+    for (const marker of markers) {
+      if (existsSync(join(current, marker))) {
+        return current;
+      }
+    }
+    if (current === fsRoot) break;
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return null;
 }
-function matchGlob(path4, pattern, options) {
-  return createGlobMatcher(pattern, options)(path4);
+async function walkUpAsync(startDir, markers, fs5) {
+  let current = startDir;
+  const fsRoot = parse(current).root;
+  while (true) {
+    for (const marker of markers) {
+      if (await fs5.exists(join(current, marker))) {
+        return current;
+      }
+    }
+    if (current === fsRoot) break;
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return null;
+}
+var DEFAULT_MARKERS = [
+  "tsconfig.json",
+  "package.json",
+  "pyproject.toml",
+  "go.mod",
+  "Cargo.toml",
+  "composer.json",
+  ".git"
+];
+function findProjectRoot(startDir) {
+  return walkUp(startDir, DEFAULT_MARKERS);
+}
+var BUILTIN_SERVERS = {
+  typescript: {
+    id: "typescript",
+    name: "TypeScript Language Server",
+    languageIds: ["typescript", "typescriptreact", "javascript", "javascriptreact"],
+    markers: ["tsconfig.json", "package.json"],
+    command: (root) => {
+      const ts = resolveRequire(root, "typescript/lib/tsserver.js");
+      if (!ts) return void 0;
+      const localBin = join(root, "node_modules", ".bin", "typescript-language-server");
+      const cwdBin = join(process.cwd(), "node_modules", ".bin", "typescript-language-server");
+      if (existsSync(localBin)) return `${localBin} --stdio`;
+      if (existsSync(cwdBin)) return `${cwdBin} --stdio`;
+      return void 0;
+    },
+    initialization: (root) => {
+      const ts = resolveRequire(root, "typescript/lib/tsserver.js");
+      if (!ts) return void 0;
+      return {
+        tsserver: {
+          path: ts.resolved,
+          logVerbosity: "off"
+        }
+      };
+    }
+  },
+  eslint: {
+    id: "eslint",
+    name: "ESLint Language Server",
+    languageIds: ["typescript", "typescriptreact", "javascript", "javascriptreact"],
+    markers: [
+      "package.json",
+      ".eslintrc.js",
+      ".eslintrc.json",
+      ".eslintrc.yml",
+      ".eslintrc.yaml",
+      "eslint.config.js",
+      "eslint.config.mjs",
+      "eslint.config.ts"
+    ],
+    command: (root) => {
+      const localBin = join(root, "node_modules", ".bin", "vscode-eslint-language-server");
+      const cwdBin = join(process.cwd(), "node_modules", ".bin", "vscode-eslint-language-server");
+      if (existsSync(localBin)) return `${localBin} --stdio`;
+      if (existsSync(cwdBin)) return `${cwdBin} --stdio`;
+      return void 0;
+    }
+  },
+  python: {
+    id: "python",
+    name: "Python Language Server (Pyright)",
+    languageIds: ["python"],
+    markers: ["pyproject.toml", "setup.py", "requirements.txt", "setup.cfg"],
+    command: (root) => {
+      const localBin = join(root, "node_modules", ".bin", "pyright-langserver");
+      const cwdBin = join(process.cwd(), "node_modules", ".bin", "pyright-langserver");
+      if (existsSync(localBin)) return `${localBin} --stdio`;
+      if (existsSync(cwdBin)) return `${cwdBin} --stdio`;
+      return whichSync("pyright-langserver") ? "pyright-langserver --stdio" : void 0;
+    }
+  },
+  go: {
+    id: "go",
+    name: "Go Language Server (gopls)",
+    languageIds: ["go"],
+    markers: ["go.mod"],
+    command: () => {
+      return whichSync("gopls") ? "gopls serve" : void 0;
+    }
+  },
+  rust: {
+    id: "rust",
+    name: "Rust Language Server (rust-analyzer)",
+    languageIds: ["rust"],
+    markers: ["Cargo.toml"],
+    command: () => {
+      return whichSync("rust-analyzer") ? "rust-analyzer --stdio" : void 0;
+    }
+  }
+};
+function getServersForFile(filePath, disabledServers) {
+  const languageId = getLanguageId(filePath);
+  if (!languageId) return [];
+  const disabled = new Set(disabledServers ?? []);
+  return Object.values(BUILTIN_SERVERS).filter(
+    (server) => !disabled.has(server.id) && server.languageIds.includes(languageId)
+  );
 }
+function mapSeverity(severity) {
+  switch (severity) {
+    case 1:
+      return "error";
+    case 2:
+      return "warning";
+    case 3:
+      return "info";
+    case 4:
+      return "hint";
+    default:
+      return "warning";
+  }
+}
+var LSPManager = class {
+  clients = /* @__PURE__ */ new Map();
+  initPromises = /* @__PURE__ */ new Map();
+  fileLocks = /* @__PURE__ */ new Map();
+  processManager;
+  _root;
+  config;
+  filesystem;
+  constructor(processManager, root, config = {}, filesystem) {
+    this.processManager = processManager;
+    this._root = root;
+    this.config = config;
+    this.filesystem = filesystem;
+  }
+  /** Default project root (fallback when per-file walkup finds nothing). */
+  get root() {
+    return this._root;
+  }
+  /**
+   * Resolve the project root for a given file path using the server's markers.
+   * Uses the workspace filesystem when available (supports remote filesystems),
+   * falls back to sync walkUp (local disk) otherwise.
+   */
+  async resolveRoot(filePath, markers) {
+    const fileDir = nodePath__default.dirname(filePath);
+    if (this.filesystem) {
+      return await walkUpAsync(fileDir, markers, this.filesystem) ?? this._root;
+    }
+    return walkUp(fileDir, markers) ?? this._root;
+  }
+  /**
+   * Acquire a per-file lock so that concurrent getDiagnostics calls for the
+   * same file are serialized (preventing interleaved open/change/close).
+   * Different files can run in parallel.
+   */
+  async acquireFileLock(filePath) {
+    while (this.fileLocks.has(filePath)) {
+      await this.fileLocks.get(filePath);
+    }
+    let release;
+    const lockPromise = new Promise((resolve3) => {
+      release = resolve3;
+    });
+    this.fileLocks.set(filePath, lockPromise);
+    return () => {
+      this.fileLocks.delete(filePath);
+      release();
+    };
+  }
+  /**
+   * Initialize an LSP client for the given server definition and project root.
+   * Handles timeout, deduplication of concurrent init calls, and caching.
+   */
+  async initClient(serverDef, projectRoot, key) {
+    if (this.initPromises.has(key)) {
+      await this.initPromises.get(key);
+      return this.clients.get(key) || null;
+    }
+    const initTimeout = this.config.initTimeout ?? 15e3;
+    let timedOut = false;
+    const initPromise = (async () => {
+      const client = new LSPClient(serverDef, projectRoot, this.processManager);
+      await client.initialize(initTimeout);
+      if (timedOut) {
+        await client.shutdown().catch(() => {
+        });
+        return;
+      }
+      this.clients.set(key, client);
+    })();
+    this.initPromises.set(key, initPromise);
+    initPromise.catch(() => {
+    });
+    try {
+      await Promise.race([
+        initPromise,
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("LSP client initialization timed out")), initTimeout + 1e3)
+        )
+      ]);
+      return this.clients.get(key) || null;
+    } catch {
+      timedOut = true;
+      this.clients.delete(key);
+      return null;
+    } finally {
+      this.initPromises.delete(key);
+    }
+  }
+  /**
+   * Get or create an LSP client for a file path.
+   * Resolves the project root per-file using the server's markers.
+   * Returns null if no server is available.
+   */
+  async getClient(filePath) {
+    const servers = getServersForFile(filePath, this.config.disableServers);
+    if (servers.length === 0) return null;
+    const serverDef = servers.find(
+      (s) => s.languageIds.includes("typescript") || s.languageIds.includes("javascript") || s.languageIds.includes("python") || s.languageIds.includes("go")
+    ) ?? servers[0];
+    const projectRoot = await this.resolveRoot(filePath, serverDef.markers);
+    if (serverDef.command(projectRoot) === void 0) return null;
+    const key = `${serverDef.name}:${projectRoot}`;
+    if (this.clients.has(key)) {
+      const existing = this.clients.get(key);
+      if (!existing.isAlive) {
+        this.clients.delete(key);
+        existing.shutdown().catch(() => {
+        });
+      } else {
+        return existing;
+      }
+    }
+    return this.initClient(serverDef, projectRoot, key);
+  }
+  /**
+   * Convenience method: open file, send content, wait for diagnostics, return normalized results.
+   * Returns an empty array on any failure (non-blocking).
+   * Uses a per-file lock to serialize concurrent calls for the same file.
+   */
+  async getDiagnostics(filePath, content) {
+    const release = await this.acquireFileLock(filePath);
+    try {
+      const client = await this.getClient(filePath);
+      if (!client) return [];
+      const languageId = getLanguageId(filePath);
+      if (!languageId) return [];
+      client.notifyOpen(filePath, content, languageId);
+      client.notifyChange(filePath, content, 1);
+      const diagnosticTimeout = this.config.diagnosticTimeout ?? 5e3;
+      let rawDiagnostics;
+      try {
+        rawDiagnostics = await client.waitForDiagnostics(filePath, diagnosticTimeout);
+      } finally {
+        client.notifyClose(filePath);
+      }
+      return rawDiagnostics.map((d) => ({
+        severity: mapSeverity(d.severity),
+        message: d.message,
+        line: (d.range?.start?.line ?? 0) + 1,
+        // LSP is 0-indexed, we report 1-indexed
+        character: (d.range?.start?.character ?? 0) + 1,
+        source: d.source
+      }));
+    } catch {
+      return [];
+    } finally {
+      release();
+    }
+  }
+  /**
+   * Get diagnostics from ALL matching language servers for a file.
+   * Deduplicates results by (line, character, message).
+   * Individual server failures don't block other servers.
+   */
+  async getDiagnosticsMulti(filePath, content) {
+    const servers = getServersForFile(filePath, this.config.disableServers);
+    if (servers.length === 0) return [];
+    const release = await this.acquireFileLock(filePath);
+    try {
+      const languageId = getLanguageId(filePath);
+      if (!languageId) return [];
+      const allDiagnostics = [];
+      const results = await Promise.allSettled(
+        servers.map(async (serverDef) => {
+          const projectRoot = await this.resolveRoot(filePath, serverDef.markers);
+          if (serverDef.command(projectRoot) === void 0) return [];
+          const key = `${serverDef.name}:${projectRoot}`;
+          if (this.clients.has(key)) {
+            const existing = this.clients.get(key);
+            if (!existing.isAlive) {
+              this.clients.delete(key);
+              existing.shutdown().catch(() => {
+              });
+            } else {
+              return this.collectDiagnostics(existing, filePath, content, languageId);
+            }
+          }
+          const client = await this.initClient(serverDef, projectRoot, key);
+          if (!client) return [];
+          return this.collectDiagnostics(client, filePath, content, languageId);
+        })
+      );
+      for (const result of results) {
+        if (result.status === "fulfilled") {
+          allDiagnostics.push(...result.value);
+        }
+      }
+      const seen = /* @__PURE__ */ new Set();
+      return allDiagnostics.filter((d) => {
+        const key = `${d.line}:${d.character}:${d.message}`;
+        if (seen.has(key)) return false;
+        seen.add(key);
+        return true;
+      });
+    } finally {
+      release();
+    }
+  }
+  /**
+   * Collect diagnostics from a single client for a file.
+   */
+  async collectDiagnostics(client, filePath, content, languageId) {
+    client.notifyOpen(filePath, content, languageId);
+    client.notifyChange(filePath, content, 1);
+    const diagnosticTimeout = this.config.diagnosticTimeout ?? 5e3;
+    let rawDiagnostics;
+    try {
+      rawDiagnostics = await client.waitForDiagnostics(filePath, diagnosticTimeout);
+    } finally {
+      client.notifyClose(filePath);
+    }
+    return rawDiagnostics.map((d) => ({
+      severity: mapSeverity(d.severity),
+      message: d.message,
+      line: (d.range?.start?.line ?? 0) + 1,
+      character: (d.range?.start?.character ?? 0) + 1,
+      source: d.source
+    }));
+  }
+  /**
+   * Shutdown all managed LSP clients.
+   */
+  async shutdownAll() {
+    await Promise.allSettled(Array.from(this.clients.values()).map((client) => client.shutdown()));
+    this.clients.clear();
+    this.initPromises.clear();
+    this.fileLocks.clear();
+  }
+};
 
 // src/workspace/sandbox/errors.ts
 var SandboxError = class extends Error {
@@ -1522,14 +2264,14 @@ var MountManager = class {
   /**
    * Get a mount entry by path.
    */
-  get(path4) {
-    return this._entries.get(path4);
+  get(path6) {
+    return this._entries.get(path6);
   }
   /**
    * Check if a mount exists at the given path.
    */
-  has(path4) {
-    return this._entries.has(path4);
+  has(path6) {
+    return this._entries.has(path6);
   }
   // ---------------------------------------------------------------------------
   // Entry Modification
@@ -1541,8 +2283,8 @@ var MountManager = class {
   add(mounts) {
     const paths = Object.keys(mounts);
     this.logger.debug(`Adding ${paths.length} pending mount(s)`, { paths });
-    for (const [path4, filesystem] of Object.entries(mounts)) {
-      this._entries.set(path4, {
+    for (const [path6, filesystem] of Object.entries(mounts)) {
+      this._entries.set(path6, {
         filesystem,
         state: "pending"
       });
@@ -1552,8 +2294,8 @@ var MountManager = class {
    * Update a mount entry's state.
    * Creates the entry if it doesn't exist.
    */
-  set(path4, updates) {
-    const existing = this._entries.get(path4);
+  set(path6, updates) {
+    const existing = this._entries.get(path6);
     if (existing) {
       existing.state = updates.state;
       if (updates.config) {
@@ -1564,7 +2306,7 @@ var MountManager = class {
         existing.error = updates.error;
       }
     } else if (updates.filesystem) {
-      this._entries.set(path4, {
+      this._entries.set(path6, {
         filesystem: updates.filesystem,
         state: updates.state,
         config: updates.config,
@@ -1572,14 +2314,14 @@ var MountManager = class {
         error: updates.error
       });
     } else {
-      this.logger.debug(`set() called for unknown path "${path4}" without filesystem \u2014 no entry created`);
+      this.logger.debug(`set() called for unknown path "${path6}" without filesystem \u2014 no entry created`);
     }
   }
   /**
    * Delete a mount entry.
    */
-  delete(path4) {
-    return this._entries.delete(path4);
+  delete(path6) {
+    return this._entries.delete(path6);
   }
   /**
    * Clear all mount entries.
@@ -1600,7 +2342,7 @@ var MountManager = class {
       return;
     }
     this.logger.debug(`Processing ${pendingCount} pending mount(s)`);
-    for (const [path4, entry] of this._entries) {
+    for (const [path6, entry] of this._entries) {
       if (entry.state !== "pending") {
         continue;
       }
@@ -1610,7 +2352,7 @@ var MountManager = class {
         try {
           const hookResult = await this._onMount({
             filesystem: entry.filesystem,
-            mountPath: path4,
+            mountPath: path6,
             config,
             sandbox: this._sandbox,
             workspace: this._workspace
@@ -1618,7 +2360,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: path4, provider: fsProvider });
+            this.logger.debug(`Mount skipped by onMount hook`, { path: path6, provider: fsProvider });
             continue;
           }
           if (hookResult && typeof hookResult === "object") {
@@ -1626,45 +2368,45 @@ 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: path4, provider: fsProvider });
+              this.logger.info(`Mount handled by onMount hook`, { path: path6, provider: fsProvider });
             } else {
               entry.state = "error";
               entry.error = hookResult.error ?? "Mount hook failed";
-              this.logger.error(`Mount hook failed`, { path: path4, provider: fsProvider, error: entry.error });
+              this.logger.error(`Mount hook failed`, { path: path6, 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: path4, provider: fsProvider, error: entry.error });
+          this.logger.error(`Mount hook threw error`, { path: path6, 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: path4, provider: fsProvider });
+        this.logger.debug(`Filesystem does not support mounting`, { path: path6, provider: fsProvider });
         continue;
       }
       entry.config = config;
       entry.configHash = this.hashConfig(config);
       entry.state = "mounting";
-      this.logger.debug(`Mounting filesystem`, { path: path4, provider: fsProvider, type: config.type });
+      this.logger.debug(`Mounting filesystem`, { path: path6, provider: fsProvider, type: config.type });
       try {
-        const result = await this._mountFn(entry.filesystem, path4);
+        const result = await this._mountFn(entry.filesystem, path6);
         if (result.success) {
           entry.state = "mounted";
-          this.logger.info(`Mount successful`, { path: path4, provider: fsProvider });
+          this.logger.info(`Mount successful`, { path: path6, provider: fsProvider });
         } else {
           entry.state = "error";
           entry.error = result.error ?? "Mount failed";
-          this.logger.error(`Mount failed`, { path: path4, provider: fsProvider, error: entry.error });
+          this.logger.error(`Mount failed`, { path: path6, provider: fsProvider, error: entry.error });
         }
       } catch (err) {
         entry.state = "error";
         entry.error = String(err);
-        this.logger.error(`Mount threw error`, { path: path4, provider: fsProvider, error: entry.error });
+        this.logger.error(`Mount threw error`, { path: path6, provider: fsProvider, error: entry.error });
       }
     }
   }
@@ -1712,10 +2454,10 @@ var MountManager = class {
     if (separatorIndex <= 0) {
       return null;
     }
-    const path4 = content.slice(0, separatorIndex);
+    const path6 = content.slice(0, separatorIndex);
     const configHash = content.slice(separatorIndex + 1);
-    if (!path4 || !configHash) return null;
-    return { path: path4, configHash };
+    if (!path6 || !configHash) return null;
+    return { path: path6, configHash };
   }
   /**
    * Check if a config hash matches the expected hash for a mount path.
@@ -2937,18 +3679,18 @@ var VersionedSkillSource = class {
   /**
    * Normalize a path by stripping leading/trailing slashes and dots.
    */
-  #normalizePath(path4) {
-    let normalized = path4.replace(/^[./\\]+|[/\\]+$/g, "");
+  #normalizePath(path6) {
+    let normalized = path6.replace(/^[./\\]+|[/\\]+$/g, "");
     if (normalized === "") return "";
     return normalized;
   }
-  async exists(path4) {
-    const normalized = this.#normalizePath(path4);
+  async exists(path6) {
+    const normalized = this.#normalizePath(path6);
     if (this.#tree.entries[normalized]) return true;
     return this.#directories.has(normalized);
   }
-  async stat(path4) {
-    const normalized = this.#normalizePath(path4);
+  async stat(path6) {
+    const normalized = this.#normalizePath(path6);
     const name = normalized.split("/").pop() || normalized || ".";
     const entry = this.#tree.entries[normalized];
     if (entry) {
@@ -2970,27 +3712,27 @@ var VersionedSkillSource = class {
         modifiedAt: this.#versionCreatedAt
       };
     }
-    throw new Error(`Path not found in skill version tree: ${path4}`);
+    throw new Error(`Path not found in skill version tree: ${path6}`);
   }
-  async readFile(path4) {
-    const normalized = this.#normalizePath(path4);
+  async readFile(path6) {
+    const normalized = this.#normalizePath(path6);
     const entry = this.#tree.entries[normalized];
     if (!entry) {
-      throw new Error(`File not found in skill version tree: ${path4}`);
+      throw new Error(`File not found in skill version tree: ${path6}`);
     }
     const blob = await this.#blobStore.get(entry.blobHash);
     if (!blob) {
-      throw new Error(`Blob not found for hash ${entry.blobHash} (file: ${path4})`);
+      throw new Error(`Blob not found for hash ${entry.blobHash} (file: ${path6})`);
     }
     if (entry.encoding === "base64") {
       return Buffer.from(blob.content, "base64");
     }
     return blob.content;
   }
-  async readdir(path4) {
-    const normalized = this.#normalizePath(path4);
+  async readdir(path6) {
+    const normalized = this.#normalizePath(path6);
     if (!this.#directories.has(normalized)) {
-      throw new Error(`Directory not found in skill version tree: ${path4}`);
+      throw new Error(`Directory not found in skill version tree: ${path6}`);
     }
     const prefix = normalized === "" ? "" : normalized + "/";
     const seen = /* @__PURE__ */ new Set();
@@ -3023,15 +3765,15 @@ var CompositeVersionedSkillSource = class {
     this.#fallback = options?.fallback;
     this.#fallbackSkills = new Set(options?.fallbackSkills ?? []);
   }
-  #normalizePath(path4) {
-    return path4.replace(/^[./\\]+|[/\\]+$/g, "");
+  #normalizePath(path6) {
+    return path6.replace(/^[./\\]+|[/\\]+$/g, "");
   }
   /**
    * Route a path to the correct source.
    * Returns the source and the remaining path within that source.
    */
-  #routePath(path4) {
-    const normalized = this.#normalizePath(path4);
+  #routePath(path6) {
+    const normalized = this.#normalizePath(path6);
     if (normalized === "") return null;
     const segments = normalized.split("/");
     const skillDir = segments[0];
@@ -3048,15 +3790,15 @@ var CompositeVersionedSkillSource = class {
     }
     return null;
   }
-  async exists(path4) {
-    const normalized = this.#normalizePath(path4);
+  async exists(path6) {
+    const normalized = this.#normalizePath(path6);
     if (normalized === "") return true;
-    const route = this.#routePath(path4);
+    const route = this.#routePath(path6);
     if (!route) return false;
     return route.source.exists(route.subPath);
   }
-  async stat(path4) {
-    const normalized = this.#normalizePath(path4);
+  async stat(path6) {
+    const normalized = this.#normalizePath(path6);
     if (normalized === "") {
       return {
         name: ".",
@@ -3066,21 +3808,21 @@ var CompositeVersionedSkillSource = class {
         modifiedAt: /* @__PURE__ */ new Date()
       };
     }
-    const route = this.#routePath(path4);
+    const route = this.#routePath(path6);
     if (!route) {
-      throw new Error(`Path not found in composite skill source: ${path4}`);
+      throw new Error(`Path not found in composite skill source: ${path6}`);
     }
     return route.source.stat(route.subPath);
   }
-  async readFile(path4) {
-    const route = this.#routePath(path4);
+  async readFile(path6) {
+    const route = this.#routePath(path6);
     if (!route) {
-      throw new Error(`File not found in composite skill source: ${path4}`);
+      throw new Error(`File not found in composite skill source: ${path6}`);
     }
     return route.source.readFile(route.subPath);
   }
-  async readdir(path4) {
-    const normalized = this.#normalizePath(path4);
+  async readdir(path6) {
+    const normalized = this.#normalizePath(path6);
     if (normalized === "") {
       const entries = [];
       const seen = /* @__PURE__ */ new Set();
@@ -3096,9 +3838,9 @@ var CompositeVersionedSkillSource = class {
       }
       return entries;
     }
-    const route = this.#routePath(path4);
+    const route = this.#routePath(path6);
     if (!route) {
-      throw new Error(`Directory not found in composite skill source: ${path4}`);
+      throw new Error(`Directory not found in composite skill source: ${path6}`);
     }
     return route.source.readdir(route.subPath);
   }
@@ -3222,7 +3964,7 @@ var WorkspaceSkillsImpl = class _WorkspaceSkillsImpl {
     if (a.length !== b.length) return false;
     const sortedA = [...a].sort();
     const sortedB = [...b].sort();
-    return sortedA.every((path4, i) => path4 === sortedB[i]);
+    return sortedA.every((path6, i) => path6 === sortedB[i]);
   }
   // ===========================================================================
   // Search
@@ -3270,7 +4012,7 @@ var WorkspaceSkillsImpl = class _WorkspaceSkillsImpl {
     const skill = this.#skills.get(skillName);
     if (!skill) return null;
     const safeRefPath = this.#assertRelativePath(referencePath, "reference");
-    const refFilePath = this.#joinPath(skill.path, "references", safeRefPath);
+    const refFilePath = this.#joinPath(skill.path, safeRefPath);
     if (!await this.#source.exists(refFilePath)) {
       return null;
     }
@@ -3286,7 +4028,7 @@ var WorkspaceSkillsImpl = class _WorkspaceSkillsImpl {
     const skill = this.#skills.get(skillName);
     if (!skill) return null;
     const safeScriptPath = this.#assertRelativePath(scriptPath, "script");
-    const scriptFilePath = this.#joinPath(skill.path, "scripts", safeScriptPath);
+    const scriptFilePath = this.#joinPath(skill.path, safeScriptPath);
     if (!await this.#source.exists(scriptFilePath)) {
       return null;
     }
@@ -3302,7 +4044,7 @@ var WorkspaceSkillsImpl = class _WorkspaceSkillsImpl {
     const skill = this.#skills.get(skillName);
     if (!skill) return null;
     const safeAssetPath = this.#assertRelativePath(assetPath, "asset");
-    const assetFilePath = this.#joinPath(skill.path, "assets", safeAssetPath);
+    const assetFilePath = this.#joinPath(skill.path, safeAssetPath);
     if (!await this.#source.exists(assetFilePath)) {
       return null;
     }
@@ -3748,7 +4490,7 @@ ${validation.errors.join("\n")}`);
       if (includeReferences) {
         for (const refPath of skill.references) {
           if (results.length >= topK) break;
-          const content = await this.getReference(skill.name, refPath);
+          const content = await this.getReference(skill.name, `references/${refPath}`);
           if (content && content.toLowerCase().includes(queryLower)) {
             results.push({
               skillName: skill.name,
@@ -3791,8 +4533,8 @@ ${validation.errors.join("\n")}`);
    */
   #assertRelativePath(input, label) {
     const normalized = input.replace(/\\/g, "/");
-    const segments = normalized.split("/").filter(Boolean);
-    if (normalized.startsWith("/") || segments.some((seg) => seg === "." || seg === "..")) {
+    const segments = normalized.split("/").filter((seg) => Boolean(seg) && seg !== ".");
+    if (normalized.startsWith("/") || segments.some((seg) => seg === "..")) {
       throw new Error(`Invalid ${label} path: ${input}`);
     }
     return segments.join("/");
@@ -3800,9 +4542,9 @@ ${validation.errors.join("\n")}`);
   /**
    * Get parent path
    */
-  #getParentPath(path4) {
-    const lastSlash = path4.lastIndexOf("/");
-    return lastSlash > 0 ? path4.substring(0, lastSlash) : "/";
+  #getParentPath(path6) {
+    const lastSlash = path6.lastIndexOf("/");
+    return lastSlash > 0 ? path6.substring(0, lastSlash) : "/";
   }
 };
 function hashContent(content) {
@@ -3963,6 +4705,7 @@ var Workspace = class {
   _config;
   _searchEngine;
   _skills;
+  _lsp;
   constructor(config) {
     this.id = config.id ?? this.generateId();
     this.name = config.name ?? `workspace-${this.id.slice(0, 8)}`;
@@ -4019,6 +4762,26 @@ var Workspace = class {
         } : void 0
       });
     }
+    if (config.lsp) {
+      const processes = this._sandbox?.processes;
+      if (!this._sandbox) {
+        console.warn(
+          `[Workspace "${this.name}"] lsp: true requires a sandbox with a process manager. No sandbox configured \u2014 LSP disabled.`
+        );
+      } else if (!processes) {
+        console.warn(
+          `[Workspace "${this.name}"] lsp: true requires a sandbox with a process manager. Sandbox "${this._sandbox.name ?? "unknown"}" does not provide one \u2014 LSP disabled.`
+        );
+      } else if (!isLSPAvailable()) {
+        console.warn(
+          `[Workspace "${this.name}"] lsp: true requires vscode-jsonrpc and vscode-languageserver-protocol packages. Install them to enable LSP diagnostics.`
+        );
+      } else {
+        const lspConfig = config.lsp === true ? {} : config.lsp;
+        const defaultRoot = lspConfig.root ?? findProjectRoot(process.cwd()) ?? process.cwd();
+        this._lsp = new LSPManager(processes, defaultRoot, lspConfig, this._fs);
+      }
+    }
     if (!this._fs && !this._sandbox && !this.hasSkillsConfig()) {
       throw new WorkspaceError("Workspace requires at least a filesystem, sandbox, or skills", "NO_PROVIDERS");
     }
@@ -4057,6 +4820,13 @@ var Workspace = class {
   getToolsConfig() {
     return this._config.tools;
   }
+  /**
+   * The LSP manager (if configured, initialized, and a process manager is available).
+   * Returns undefined if LSP is not configured, deps are missing, or sandbox has no process manager.
+   */
+  get lsp() {
+    return this._lsp;
+  }
   /**
    * Update the per-tool configuration for this workspace.
    * Takes effect on the next `createWorkspaceTools()` call.
@@ -4137,13 +4907,13 @@ var Workspace = class {
    * @param options - Index options (metadata, type hints)
    * @throws {SearchNotAvailableError} if search is not configured
    */
-  async index(path4, content, options) {
+  async index(path6, content, options) {
     if (!this._searchEngine) {
       throw new SearchNotAvailableError();
     }
     this.lastAccessedAt = /* @__PURE__ */ new Date();
     const doc = {
-      id: path4,
+      id: path6,
       content,
       metadata: {
         type: options?.type,
@@ -4260,6 +5030,13 @@ var Workspace = class {
   async destroy() {
     this._status = "destroying";
     try {
+      if (this._lsp) {
+        try {
+          await this._lsp.shutdownAll();
+        } catch {
+        }
+        this._lsp = void 0;
+      }
       if (this._sandbox) {
         await callLifecycle(this._sandbox, "destroy");
       }
@@ -4850,11 +5627,11 @@ function buildBwrapCommand(command, workspacePath, config) {
   }
   bwrapArgs.push("--proc", "/proc");
   bwrapArgs.push("--tmpfs", "/tmp");
-  for (const path4 of DEFAULT_READONLY_BINDS) {
-    bwrapArgs.push("--ro-bind-try", path4, path4);
+  for (const path6 of DEFAULT_READONLY_BINDS) {
+    bwrapArgs.push("--ro-bind-try", path6, path6);
   }
-  for (const path4 of config.readOnlyPaths ?? []) {
-    bwrapArgs.push("--ro-bind", path4, path4);
+  for (const path6 of config.readOnlyPaths ?? []) {
+    bwrapArgs.push("--ro-bind", path6, path6);
   }
   if (config.allowSystemBinaries !== false) {
     const nodePath4 = process.execPath;
@@ -4866,8 +5643,8 @@ function buildBwrapCommand(command, workspacePath, config) {
     bwrapArgs.push("--ro-bind-try", "/snap", "/snap");
   }
   bwrapArgs.push("--bind", workspacePath, workspacePath);
-  for (const path4 of config.readWritePaths ?? []) {
-    bwrapArgs.push("--bind", path4, path4);
+  for (const path6 of config.readWritePaths ?? []) {
+    bwrapArgs.push("--bind", path6, path6);
   }
   bwrapArgs.push("--chdir", workspacePath);
   bwrapArgs.push("--die-with-parent");
@@ -5112,8 +5889,6 @@ var WORKSPACE_TOOLS = {
     INDEX: `${WORKSPACE_TOOLS_PREFIX}_index`
   }
 };
-
-// src/workspace/tools/helpers.ts
 function requireWorkspace(context) {
   if (!context?.workspace) {
     throw new WorkspaceNotAvailableError();
@@ -5143,6 +5918,63 @@ async function emitWorkspaceMetadata(context, toolName) {
     data: { toolName, toolCallId, ...info }
   });
 }
+async function getEditDiagnosticsText(workspace, filePath, content) {
+  try {
+    const lspManager = workspace.lsp;
+    if (!lspManager) return "";
+    const absolutePath = workspace.filesystem?.resolveAbsolutePath?.(filePath) ?? nodePath__default.resolve(lspManager.root, filePath.replace(/^\/+/, ""));
+    const DIAG_TIMEOUT_MS = 1e4;
+    let diagTimer;
+    const diagnostics = await Promise.race([
+      lspManager.getDiagnostics(absolutePath, content),
+      new Promise((_, reject) => {
+        diagTimer = setTimeout(() => reject(new Error("LSP diagnostics timeout")), DIAG_TIMEOUT_MS);
+      })
+    ]).finally(() => clearTimeout(diagTimer));
+    if (diagnostics.length === 0) return "";
+    const seen = /* @__PURE__ */ new Set();
+    const deduped = diagnostics.filter((d) => {
+      const key = `${d.severity}:${d.line}:${d.character}:${d.message}`;
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+    const groups = {
+      error: [],
+      warning: [],
+      info: [],
+      hint: []
+    };
+    for (const d of deduped) {
+      groups[d.severity].push(d);
+    }
+    const lines = ["\n\nLSP Diagnostics:"];
+    const severityLabels = [
+      ["error", "Errors"],
+      ["warning", "Warnings"],
+      ["info", "Info"],
+      ["hint", "Hints"]
+    ];
+    for (const [severity, label] of severityLabels) {
+      const items = groups[severity];
+      if (items.length === 0) continue;
+      lines.push(`${label}:`);
+      for (const d of items) {
+        const source = d.source ? ` [${d.source}]` : "";
+        lines.push(`  ${d.line}:${d.character} - ${d.message}${source}`);
+      }
+    }
+    let result = lines.join("\n");
+    const maxChars = 2e3;
+    if (result.length > maxChars) {
+      const cutoff = result.lastIndexOf("\n", maxChars);
+      result = result.slice(0, cutoff > 0 ? cutoff : maxChars) + "\n  ... (truncated)";
+    }
+    return result;
+  } catch {
+    return "";
+  }
+}
 
 // src/workspace/tools/ast-edit.ts
 var astGrepModule;
@@ -5373,8 +6205,8 @@ 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: path4, pattern, replacement, transform, targetName, newName, importSpec }, context) => {
-    const { filesystem } = requireFilesystem(context);
+  execute: async ({ path: path6, pattern, replacement, transform, targetName, newName, importSpec }, context) => {
+    const { workspace, filesystem } = requireFilesystem(context);
     await emitWorkspaceMetadata(context, WORKSPACE_TOOLS.FILESYSTEM.AST_EDIT);
     if (filesystem.readOnly) {
       throw new WorkspaceReadOnlyError("ast_edit");
@@ -5383,24 +6215,24 @@ Pattern replace (for everything else):
     if (!astGrep) {
       return "@ast-grep/napi is not available. Install it to use AST editing.";
     }
-    const { parse, Lang } = astGrep;
+    const { parse: parse2, Lang } = astGrep;
     let content;
     try {
-      content = await filesystem.readFile(path4, { encoding: "utf-8" });
+      content = await filesystem.readFile(path6, { encoding: "utf-8" });
     } catch (error) {
       if (error instanceof FileNotFoundError) {
-        return `File not found: ${path4}. Use ${WORKSPACE_TOOLS.FILESYSTEM.WRITE_FILE} to create it first.`;
+        return `File not found: ${path6}. Use ${WORKSPACE_TOOLS.FILESYSTEM.WRITE_FILE} to create it first.`;
       }
       throw error;
     }
     if (typeof content !== "string") {
       return `Cannot perform AST edits on binary files. Use ${WORKSPACE_TOOLS.FILESYSTEM.WRITE_FILE} instead.`;
     }
-    const lang = getLanguageFromPath(path4, Lang);
+    const lang = getLanguageFromPath(path6, Lang);
     if (!lang) {
-      return `Unsupported file type for AST editing: ${path4}`;
+      return `Unsupported file type for AST editing: ${path6}`;
     }
-    const ast = parse(lang, content);
+    const ast = parse2(lang, content);
     const root = ast.root();
     let modifiedContent = content;
     const changes = [];
@@ -5448,12 +6280,14 @@ Pattern replace (for everything else):
     }
     const wasModified = modifiedContent !== content;
     if (wasModified) {
-      await filesystem.writeFile(path4, modifiedContent, { overwrite: true });
+      await filesystem.writeFile(path6, modifiedContent, { overwrite: true });
     }
     if (!wasModified) {
-      return `No changes made to ${path4} (${changes.join("; ")})`;
+      return `No changes made to ${path6} (${changes.join("; ")})`;
     }
-    return `${path4}: ${changes.join("; ")}`;
+    let output = `${path6}: ${changes.join("; ")}`;
+    output += await getEditDiagnosticsText(workspace, path6, modifiedContent);
+    return output;
   }
 });
 var deleteFileTool = createTool({
@@ -5463,19 +6297,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: path4, recursive }, context) => {
+  execute: async ({ path: path6, 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(path4);
+    const stat3 = await filesystem.stat(path6);
     if (stat3.type === "directory") {
-      await filesystem.rmdir(path4, { recursive, force: recursive });
+      await filesystem.rmdir(path6, { recursive, force: recursive });
     } else {
-      await filesystem.deleteFile(path4);
+      await filesystem.deleteFile(path6);
     }
-    return `Deleted ${path4}`;
+    return `Deleted ${path6}`;
   }
 });
 var editFileTool = createTool({
@@ -5493,20 +6327,22 @@ 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: path4, old_string, new_string, replace_all }, context) => {
-    const { filesystem } = requireFilesystem(context);
+  execute: async ({ path: path6, 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(path4, { encoding: "utf-8" });
+      const content = await filesystem.readFile(path6, { encoding: "utf-8" });
       if (typeof content !== "string") {
         return `Cannot edit binary files. Use ${WORKSPACE_TOOLS.FILESYSTEM.WRITE_FILE} instead.`;
       }
       const result = replaceString(content, old_string, new_string, replace_all);
-      await filesystem.writeFile(path4, result.content, { overwrite: true });
-      return `Replaced ${result.replacements} occurrence${result.replacements !== 1 ? "s" : ""} in ${path4}`;
+      await filesystem.writeFile(path6, result.content, { overwrite: true });
+      let output = `Replaced ${result.replacements} occurrence${result.replacements !== 1 ? "s" : ""} in ${path6}`;
+      output += await getEditDiagnosticsText(workspace, path6, result.content);
+      return output;
     } catch (error) {
       if (error instanceof StringNotFoundError) {
         return error.message;
@@ -5663,19 +6499,19 @@ var fileStatTool = createTool({
   inputSchema: z.object({
     path: z.string().describe("The path to check")
   }),
-  execute: async ({ path: path4 }, context) => {
+  execute: async ({ path: path6 }, context) => {
     const { filesystem } = requireFilesystem(context);
     await emitWorkspaceMetadata(context, WORKSPACE_TOOLS.FILESYSTEM.FILE_STAT);
     try {
-      const stat3 = await filesystem.stat(path4);
+      const stat3 = await filesystem.stat(path6);
       const modifiedAt = stat3.modifiedAt.toISOString();
-      const parts = [`${path4}`, `Type: ${stat3.type}`];
+      const parts = [`${path6}`, `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 `${path4}: not found`;
+        return `${path6}: not found`;
       }
       throw error;
     }
@@ -5906,11 +6742,11 @@ var indexContentTool = createTool({
     content: z.string().describe("The text content to index"),
     metadata: z.record(z.unknown()).optional().describe("Optional metadata to store with the document")
   }),
-  execute: async ({ path: path4, content, metadata }, context) => {
+  execute: async ({ path: path6, content, metadata }, context) => {
     const workspace = requireWorkspace(context);
     await emitWorkspaceMetadata(context, WORKSPACE_TOOLS.SEARCH.INDEX);
-    await workspace.index(path4, content, { metadata });
-    return `Indexed ${path4}`;
+    await workspace.index(path6, content, { metadata });
+    return `Indexed ${path6}`;
   }
 });
 var KILL_TAIL_LINES = 50;
@@ -5968,7 +6804,7 @@ var BRANCH = "\u251C\u2500\u2500 ";
 var LAST_BRANCH = "\u2514\u2500\u2500 ";
 var VERTICAL = "\u2502   ";
 var SPACE = "    ";
-async function formatAsTree(fs5, path4, options) {
+async function formatAsTree(fs5, path6, options) {
   const maxDepth = options?.maxDepth ?? Infinity;
   const showHidden = options?.showHidden ?? false;
   const dirsOnly = options?.dirsOnly ?? false;
@@ -6024,12 +6860,12 @@ async function formatAsTree(fs5, path4, options) {
     if (globMatcher && !dirsOnly) {
       filtered = filtered.filter((e) => {
         if (e.type === "directory") return true;
-        const entryPath = currentPath === path4 ? e.name : `${currentPath === "/" ? "" : currentPath}/${e.name}`;
+        const entryPath = currentPath === path6 ? e.name : `${currentPath === "/" ? "" : currentPath}/${e.name}`;
         let relativePath;
-        if (path4 === "/" || path4 === "") {
+        if (path6 === "/" || path6 === "") {
           relativePath = entryPath.startsWith("/") ? entryPath.slice(1) : entryPath;
         } else {
-          relativePath = entryPath.startsWith(path4 + "/") ? entryPath.slice(path4.length + 1) : entryPath;
+          relativePath = entryPath.startsWith(path6 + "/") ? entryPath.slice(path6.length + 1) : entryPath;
           if (!relativePath) relativePath = entryPath;
         }
         return globMatcher(relativePath);
@@ -6058,7 +6894,7 @@ async function formatAsTree(fs5, path4, options) {
       }
     }
   }
-  await buildTree(path4, "", 0);
+  await buildTree(path6, "", 0);
   const dirPart = dirCount === 1 ? "1 directory" : `${dirCount} directories`;
   const filePart = fileCount === 1 ? "1 file" : `${fileCount} files`;
   let summary = `${dirPart}, ${filePart}`;
@@ -6107,10 +6943,10 @@ Examples:
       'Glob pattern(s) to filter files. Examples: "**/*.ts", "src/**/*.test.ts", "*.config.{js,ts}". Directories always pass through.'
     )
   }),
-  execute: async ({ path: path4 = "./", maxDepth = 3, showHidden, dirsOnly, exclude, extension, pattern }, context) => {
+  execute: async ({ path: path6 = "./", maxDepth = 3, showHidden, dirsOnly, exclude, extension, pattern }, context) => {
     const { filesystem } = requireFilesystem(context);
     await emitWorkspaceMetadata(context, WORKSPACE_TOOLS.FILESYSTEM.LIST_FILES);
-    const result = await formatAsTree(filesystem, path4, {
+    const result = await formatAsTree(filesystem, path6, {
       maxDepth,
       showHidden,
       dirsOnly,
@@ -6130,14 +6966,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: path4, recursive }, context) => {
+  execute: async ({ path: path6, recursive }, context) => {
     const { filesystem } = requireFilesystem(context);
     await emitWorkspaceMetadata(context, WORKSPACE_TOOLS.FILESYSTEM.MKDIR);
     if (filesystem.readOnly) {
       throw new WorkspaceReadOnlyError("mkdir");
     }
-    await filesystem.mkdir(path4, { recursive });
-    return `Created directory ${path4}`;
+    await filesystem.mkdir(path6, { recursive });
+    return `Created directory ${path6}`;
   }
 });
 var readFileTool = createTool({
@@ -6150,12 +6986,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: path4, encoding, offset, limit, showLineNumbers }, context) => {
+  execute: async ({ path: path6, encoding, offset, limit, showLineNumbers }, context) => {
     const { filesystem } = requireFilesystem(context);
     await emitWorkspaceMetadata(context, WORKSPACE_TOOLS.FILESYSTEM.READ_FILE);
     const effectiveEncoding = encoding ?? "utf-8";
-    const fullContent = await filesystem.readFile(path4, { encoding: effectiveEncoding });
-    const stat3 = await filesystem.stat(path4);
+    const fullContent = await filesystem.readFile(path6, { encoding: effectiveEncoding });
+    const stat3 = await filesystem.stat(path6);
     const isTextEncoding = !encoding || encoding === "utf-8" || encoding === "utf8";
     if (!isTextEncoding) {
       return `${stat3.path} (${stat3.size} bytes, ${effectiveEncoding})
@@ -6214,15 +7050,17 @@ 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: path4, content, overwrite }, context) => {
-    const { filesystem } = requireFilesystem(context);
+  execute: async ({ path: path6, 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(path4, content, { overwrite });
+    await filesystem.writeFile(path6, content, { overwrite });
     const size = Buffer.byteLength(content, "utf-8");
-    return `Wrote ${size} bytes to ${path4}`;
+    let output = `Wrote ${size} bytes to ${path6}`;
+    output += await getEditDiagnosticsText(workspace, path6, content);
+    return output;
   }
 });
 
@@ -6378,5 +7216,5 @@ function createWorkspaceTools(workspace) {
 }
 
 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, VersionedSkillSource, WORKSPACE_TOOLS, WORKSPACE_TOOLS_PREFIX, Workspace, WorkspaceError, WorkspaceNotAvailableError, WorkspaceNotReadyError, WorkspaceReadOnlyError, callLifecycle, collectSkillForPublish, createGlobMatcher, createWorkspaceTools, deleteFileTool, detectIsolation, editFileTool, executeCommandTool, extractGlobBase, extractLines, fileStatTool, getRecommendedIsolation, indexContentTool, isGlobPattern, isIsolationAvailable, listFilesTool, matchGlob, mkdirTool, publishSkillFromSource, readFileTool, requireFilesystem, requireSandbox, requireWorkspace, resolveToolConfig, searchTool, writeFileTool };
-//# sourceMappingURL=chunk-ZSBM2SVU.js.map
-//# sourceMappingURL=chunk-ZSBM2SVU.js.map
+//# sourceMappingURL=chunk-4H5F6AFP.js.map
+//# sourceMappingURL=chunk-4H5F6AFP.js.map