@mastra/core 1.21.0 → 1.22.0-alpha.0

package/dist/{chunk-LOA2BVRK.js → chunk-HJBVUY76.js}

@@ -72,68 +72,68 @@ var WorkspaceReadOnlyError = class extends WorkspaceError {
   }
 };
 var FilesystemError = class extends Error {
-  constructor(message, code, path8) {
+  constructor(message, code, path9) {
     super(message);
     this.code = code;
-    this.path = path8;
+    this.path = path9;
     this.name = "FilesystemError";
   }
 };
 var FileNotFoundError = class extends FilesystemError {
-  constructor(path8) {
-    super(`File not found: ${path8}`, "ENOENT", path8);
+  constructor(path9) {
+    super(`File not found: ${path9}`, "ENOENT", path9);
     this.name = "FileNotFoundError";
   }
 };
 var DirectoryNotFoundError = class extends FilesystemError {
-  constructor(path8) {
-    super(`Directory not found: ${path8}`, "ENOENT", path8);
+  constructor(path9) {
+    super(`Directory not found: ${path9}`, "ENOENT", path9);
     this.name = "DirectoryNotFoundError";
   }
 };
 var FileExistsError = class extends FilesystemError {
-  constructor(path8) {
-    super(`File already exists: ${path8}`, "EEXIST", path8);
+  constructor(path9) {
+    super(`File already exists: ${path9}`, "EEXIST", path9);
     this.name = "FileExistsError";
   }
 };
 var IsDirectoryError = class extends FilesystemError {
-  constructor(path8) {
-    super(`Path is a directory: ${path8}`, "EISDIR", path8);
+  constructor(path9) {
+    super(`Path is a directory: ${path9}`, "EISDIR", path9);
     this.name = "IsDirectoryError";
   }
 };
 var NotDirectoryError = class extends FilesystemError {
-  constructor(path8) {
-    super(`Path is not a directory: ${path8}`, "ENOTDIR", path8);
+  constructor(path9) {
+    super(`Path is not a directory: ${path9}`, "ENOTDIR", path9);
     this.name = "NotDirectoryError";
   }
 };
 var DirectoryNotEmptyError = class extends FilesystemError {
-  constructor(path8) {
-    super(`Directory not empty: ${path8}`, "ENOTEMPTY", path8);
+  constructor(path9) {
+    super(`Directory not empty: ${path9}`, "ENOTEMPTY", path9);
     this.name = "DirectoryNotEmptyError";
   }
 };
 var PermissionError = class extends FilesystemError {
-  constructor(path8, operation) {
-    super(`Permission denied: ${operation} on ${path8}`, "EACCES", path8);
+  constructor(path9, operation) {
+    super(`Permission denied: ${operation} on ${path9}`, "EACCES", path9);
     this.operation = operation;
     this.name = "PermissionError";
   }
 };
 var FileReadRequiredError = class extends FilesystemError {
-  constructor(path8, reason) {
-    super(reason, "EREAD_REQUIRED", path8);
+  constructor(path9, reason) {
+    super(reason, "EREAD_REQUIRED", path9);
     this.name = "FileReadRequiredError";
   }
 };
 var StaleFileError = class extends FilesystemError {
-  constructor(path8, expectedMtime, actualMtime) {
+  constructor(path9, expectedMtime, actualMtime) {
     super(
-      `File was modified externally: ${path8} (expected mtime ${expectedMtime.toISOString()}, actual ${actualMtime.toISOString()})`,
+      `File was modified externally: ${path9} (expected mtime ${expectedMtime.toISOString()}, actual ${actualMtime.toISOString()})`,
       "ESTALE",
-      path8
+      path9
     );
     this.expectedMtime = expectedMtime;
     this.actualMtime = actualMtime;
@@ -172,8 +172,8 @@ var CompositeFilesystem = class {
   constructor(config) {
     this.id = `cfs-${Date.now().toString(36)}`;
     this._mounts = /* @__PURE__ */ new Map();
-    for (const [path8, fs6] of Object.entries(config.mounts)) {
-      const normalized = this.normalizePath(path8);
+    for (const [path9, fs6] of Object.entries(config.mounts)) {
+      const normalized = this.normalizePath(path9);
       this._mounts.set(normalized, fs6);
     }
     if (this._mounts.size === 0) {
@@ -224,37 +224,37 @@ var CompositeFilesystem = class {
    * Get the underlying filesystem for a given path.
    * Returns undefined if the path doesn't resolve to any mount.
    */
-  getFilesystemForPath(path8) {
-    const resolved = this.resolveMount(path8);
+  getFilesystemForPath(path9) {
+    const resolved = this.resolveMount(path9);
     return resolved?.fs;
   }
   /**
    * Get the mount path for a given path.
    * Returns undefined if the path doesn't resolve to any mount.
    */
-  getMountPathForPath(path8) {
-    const resolved = this.resolveMount(path8);
+  getMountPathForPath(path9) {
+    const resolved = this.resolveMount(path9);
     return resolved?.mountPath;
   }
   /**
    * Resolve a workspace-relative path to an absolute disk path.
    * Strips the mount prefix and delegates to the underlying filesystem.
    */
-  resolveAbsolutePath(path8) {
-    const r = this.resolveMount(path8);
+  resolveAbsolutePath(path9) {
+    const r = this.resolveMount(path9);
     if (!r) return void 0;
     return r.fs.resolveAbsolutePath?.(r.fsPath);
   }
-  normalizePath(path8) {
-    if (!path8 || path8 === "/" || path8 === ".") return "/";
-    let n = posixPath.normalize(path8);
+  normalizePath(path9) {
+    if (!path9 || path9 === "/" || path9 === ".") return "/";
+    let n = posixPath.normalize(path9);
     if (n === ".") return "/";
     if (!n.startsWith("/")) n = `/${n}`;
     if (n.length > 1 && n.endsWith("/")) n = n.slice(0, -1);
     return n;
   }
-  resolveMount(path8) {
-    const normalized = this.normalizePath(path8);
+  resolveMount(path9) {
+    const normalized = this.normalizePath(path9);
     let best = null;
     for (const [mountPath, fs6] of this._mounts) {
       if (normalized === mountPath || normalized.startsWith(mountPath + "/")) {
@@ -269,8 +269,8 @@ var CompositeFilesystem = class {
     else if (fsPath.startsWith("/")) fsPath = fsPath.slice(1);
     return { fs: best.fs, fsPath, mountPath: best.mountPath };
   }
-  getVirtualEntries(path8) {
-    const normalized = this.normalizePath(path8);
+  getVirtualEntries(path9) {
+    const normalized = this.normalizePath(path9);
     if (this.resolveMount(normalized)) return null;
     const entriesMap = /* @__PURE__ */ new Map();
     for (const [mountPath, fs6] of this._mounts.entries()) {
@@ -297,8 +297,8 @@ var CompositeFilesystem = class {
     }
     return entriesMap.size > 0 ? Array.from(entriesMap.values()) : null;
   }
-  isVirtualPath(path8) {
-    const normalized = this.normalizePath(path8);
+  isVirtualPath(path9) {
+    const normalized = this.normalizePath(path9);
     if (normalized === "/" && !this._mounts.has("/")) return true;
     for (const mountPath of this._mounts.keys()) {
       if (mountPath.startsWith(normalized + "/")) return true;
@@ -309,9 +309,9 @@ var CompositeFilesystem = class {
    * Assert that a filesystem is writable (not read-only).
    * @throws {PermissionError} if the filesystem is read-only
    */
-  assertWritable(fs6, path8, operation) {
+  assertWritable(fs6, path9, operation) {
     if (fs6.readOnly) {
-      throw new PermissionError(path8, `${operation} (filesystem is read-only)`);
+      throw new PermissionError(path9, `${operation} (filesystem is read-only)`);
     }
   }
   // ===========================================================================
@@ -345,27 +345,27 @@ var CompositeFilesystem = class {
     }
     this.status = "destroyed";
   }
-  async readFile(path8, options) {
-    const r = this.resolveMount(path8);
-    if (!r) throw new Error(`No mount for path: ${path8}`);
+  async readFile(path9, options) {
+    const r = this.resolveMount(path9);
+    if (!r) throw new Error(`No mount for path: ${path9}`);
     return r.fs.readFile(r.fsPath, options);
   }
-  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");
+  async writeFile(path9, content, options) {
+    const r = this.resolveMount(path9);
+    if (!r) throw new Error(`No mount for path: ${path9}`);
+    this.assertWritable(r.fs, path9, "writeFile");
     return r.fs.writeFile(r.fsPath, content, options);
   }
-  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");
+  async appendFile(path9, content) {
+    const r = this.resolveMount(path9);
+    if (!r) throw new Error(`No mount for path: ${path9}`);
+    this.assertWritable(r.fs, path9, "appendFile");
     return r.fs.appendFile(r.fsPath, content);
   }
-  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");
+  async deleteFile(path9, options) {
+    const r = this.resolveMount(path9);
+    if (!r) throw new Error(`No mount for path: ${path9}`);
+    this.assertWritable(r.fs, path9, "deleteFile");
     return r.fs.deleteFile(r.fsPath, options);
   }
   async copyFile(src, dest, options) {
@@ -393,35 +393,35 @@ var CompositeFilesystem = class {
     await this.copyFile(src, dest, options);
     await srcR.fs.deleteFile(srcR.fsPath);
   }
-  async readdir(path8, options) {
-    const virtual = this.getVirtualEntries(path8);
+  async readdir(path9, options) {
+    const virtual = this.getVirtualEntries(path9);
     if (virtual) return virtual;
-    const r = this.resolveMount(path8);
-    if (!r) throw new Error(`No mount for path: ${path8}`);
+    const r = this.resolveMount(path9);
+    if (!r) throw new Error(`No mount for path: ${path9}`);
     return r.fs.readdir(r.fsPath, options);
   }
-  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");
+  async mkdir(path9, options) {
+    const r = this.resolveMount(path9);
+    if (!r) throw new Error(`No mount for path: ${path9}`);
+    this.assertWritable(r.fs, path9, "mkdir");
     return r.fs.mkdir(r.fsPath, options);
   }
-  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");
+  async rmdir(path9, options) {
+    const r = this.resolveMount(path9);
+    if (!r) throw new Error(`No mount for path: ${path9}`);
+    this.assertWritable(r.fs, path9, "rmdir");
     return r.fs.rmdir(r.fsPath, options);
   }
-  async exists(path8) {
-    if (this.isVirtualPath(path8)) return true;
-    const r = this.resolveMount(path8);
+  async exists(path9) {
+    if (this.isVirtualPath(path9)) return true;
+    const r = this.resolveMount(path9);
     if (!r) return false;
     if (r.fsPath === "") return true;
     return r.fs.exists(r.fsPath);
   }
-  async stat(path8) {
-    const normalized = this.normalizePath(path8);
-    if (this.isVirtualPath(path8)) {
+  async stat(path9) {
+    const normalized = this.normalizePath(path9);
+    if (this.isVirtualPath(path9)) {
       const parts = normalized.split("/").filter(Boolean);
       const now = /* @__PURE__ */ new Date();
       return {
@@ -433,8 +433,8 @@ var CompositeFilesystem = class {
         modifiedAt: now
       };
     }
-    const r = this.resolveMount(path8);
-    if (!r) throw new Error(`No mount for path: ${path8}`);
+    const r = this.resolveMount(path9);
+    if (!r) throw new Error(`No mount for path: ${path9}`);
     if (r.fsPath === "") {
       const parts = normalized.split("/").filter(Boolean);
       const now = /* @__PURE__ */ new Date();
@@ -449,9 +449,9 @@ var CompositeFilesystem = class {
     }
     return r.fs.stat(r.fsPath);
   }
-  async isFile(path8) {
-    if (this.isVirtualPath(path8)) return false;
-    const r = this.resolveMount(path8);
+  async isFile(path9) {
+    if (this.isVirtualPath(path9)) return false;
+    const r = this.resolveMount(path9);
     if (!r) return false;
     try {
       const stat3 = await r.fs.stat(r.fsPath);
@@ -460,9 +460,9 @@ var CompositeFilesystem = class {
       return false;
     }
   }
-  async isDirectory(path8) {
-    if (this.isVirtualPath(path8)) return true;
-    const r = this.resolveMount(path8);
+  async isDirectory(path9) {
+    if (this.isVirtualPath(path9)) return true;
+    const r = this.resolveMount(path9);
     if (!r) return false;
     if (r.fsPath === "") return true;
     try {
@@ -1347,35 +1347,35 @@ var LocalFilesystem = class extends MastraFilesystem {
 };
 var InMemoryFileReadTracker = class {
   records = /* @__PURE__ */ new Map();
-  recordRead(path8, modifiedAt) {
-    const normalizedPath = this.normalizePath(path8);
+  recordRead(path9, modifiedAt) {
+    const normalizedPath = this.normalizePath(path9);
     this.records.set(normalizedPath, {
       path: normalizedPath,
       readAt: /* @__PURE__ */ new Date(),
       modifiedAtRead: modifiedAt
     });
   }
-  getReadRecord(path8) {
-    return this.records.get(this.normalizePath(path8));
+  getReadRecord(path9) {
+    return this.records.get(this.normalizePath(path9));
   }
-  needsReRead(path8, currentModifiedAt) {
-    const record = this.getReadRecord(path8);
+  needsReRead(path9, currentModifiedAt) {
+    const record = this.getReadRecord(path9);
     if (!record) {
       return {
         needsReRead: true,
-        reason: `File "${path8}" has not been read. You must read a file before writing to it.`
+        reason: `File "${path9}" has not been read. You must read a file before writing to it.`
       };
     }
     if (currentModifiedAt.getTime() > record.modifiedAtRead.getTime()) {
       return {
         needsReRead: true,
-        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.`
+        reason: `File "${path9}" 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(path8) {
-    this.records.delete(this.normalizePath(path8));
+  clearReadRecord(path9) {
+    this.records.delete(this.normalizePath(path9));
   }
   clear() {
     this.records.clear();
@@ -1397,10 +1397,10 @@ var InMemoryFileWriteLock = class {
   withLock(filePath, fn) {
     const key = this.normalizePath(filePath);
     const currentQueue = this.queues.get(key) ?? Promise.resolve();
-    let resolve5;
+    let resolve6;
     let reject;
     const resultPromise = new Promise((res, rej) => {
-      resolve5 = res;
+      resolve6 = res;
       reject = rej;
     });
     const queuePromise = currentQueue.catch(() => {
@@ -1417,7 +1417,7 @@ var InMemoryFileWriteLock = class {
           })
         ]);
         clearTimeout(timeoutId);
-        resolve5(result);
+        resolve6(result);
       } catch (error) {
         clearTimeout(timeoutId);
         reject(error);
@@ -1463,10 +1463,10 @@ function createGlobMatcher(patterns, options) {
     posix: true,
     dot: options?.dot ?? false
   });
-  return (path8) => matcher(normalizeForMatch(path8));
+  return (path9) => matcher(normalizeForMatch(path9));
 }
-function matchGlob(path8, pattern, options) {
-  return createGlobMatcher(pattern, options)(path8);
+function matchGlob(path9, pattern, options) {
+  return createGlobMatcher(pattern, options)(path9);
 }
 async function walkAll(readdir4, dir, depth, maxDepth) {
   if (depth >= maxDepth) return [];
@@ -1778,7 +1778,7 @@ var LSPClient = class {
           if (Date.now() - emptyReceivedAt >= settleMs) return currentDiagnostics;
         }
       }
-      await new Promise((resolve5) => setTimeout(resolve5, 100));
+      await new Promise((resolve6) => setTimeout(resolve6, 100));
     }
     return waitForChange ? initialDiagnostics || [] : this.diagnostics.get(uri) || [];
   }
@@ -2112,8 +2112,8 @@ var LSPManager = class {
       await this.fileLocks.get(filePath);
     }
     let release;
-    const lockPromise = new Promise((resolve5) => {
-      release = resolve5;
+    const lockPromise = new Promise((resolve6) => {
+      release = resolve6;
     });
     this.fileLocks.set(filePath, lockPromise);
     return () => {
@@ -2613,7 +2613,7 @@ var LocalProcessHandle = class extends ProcessHandle {
       timedOut = true;
       void killProcessTree(this._numericPid, subprocess, "SIGTERM");
     }, options.timeout) : void 0;
-    this.waitPromise = new Promise((resolve5) => {
+    this.waitPromise = new Promise((resolve6) => {
       subprocess.on("close", (code, signal) => {
         if (timeoutId) clearTimeout(timeoutId);
         if (timedOut) {
@@ -2624,7 +2624,7 @@ Process timed out after ${options.timeout}ms`;
         } else {
           this.exitCode = signal && code === null ? 128 : code ?? 0;
         }
-        resolve5({
+        resolve6({
           success: this.exitCode === 0,
           exitCode: this.exitCode,
           stdout: this.stdout,
@@ -2638,7 +2638,7 @@ Process timed out after ${options.timeout}ms`;
         if (timeoutId) clearTimeout(timeoutId);
         this.emitStderr(err.message);
         this.exitCode = 1;
-        resolve5({
+        resolve6({
           success: false,
           exitCode: 1,
           stdout: this.stdout,
@@ -2669,8 +2669,8 @@ Process timed out after ${options.timeout}ms`;
     if (!this.subprocess.stdin) {
       throw new Error(`Process ${this.pid} does not have stdin available`);
     }
-    return new Promise((resolve5, reject) => {
-      this.subprocess.stdin.write(data, (err) => err ? reject(err) : resolve5());
+    return new Promise((resolve6, reject) => {
+      this.subprocess.stdin.write(data, (err) => err ? reject(err) : resolve6());
     });
   }
 };
@@ -2692,7 +2692,7 @@ async function killProcessTree(pid, subprocess, signal) {
 }
 var LocalProcessManager = class extends SandboxProcessManager {
   async spawn(command, options = {}) {
-    const cwd = options.cwd ?? this.sandbox.workingDirectory;
+    const cwd = options.cwd ? nodePath.resolve(this.sandbox.workingDirectory, options.cwd) : this.sandbox.workingDirectory;
     const env = this.sandbox.buildEnv(options.env);
     const wrapped = this.sandbox.wrapCommandForIsolation(command);
     const baseOptions = {
@@ -2795,14 +2795,14 @@ var MountManager = class {
   /**
    * Get a mount entry by path.
    */
-  get(path8) {
-    return this._entries.get(path8);
+  get(path9) {
+    return this._entries.get(path9);
   }
   /**
    * Check if a mount exists at the given path.
    */
-  has(path8) {
-    return this._entries.has(path8);
+  has(path9) {
+    return this._entries.has(path9);
   }
   // ---------------------------------------------------------------------------
   // Entry Modification
@@ -2814,8 +2814,8 @@ var MountManager = class {
   add(mounts) {
     const paths = Object.keys(mounts);
     this.logger.debug("Adding pending mounts", { count: paths.length, paths });
-    for (const [path8, filesystem] of Object.entries(mounts)) {
-      this._entries.set(path8, {
+    for (const [path9, filesystem] of Object.entries(mounts)) {
+      this._entries.set(path9, {
         filesystem,
         state: "pending"
       });
@@ -2825,8 +2825,8 @@ var MountManager = class {
    * Update a mount entry's state.
    * Creates the entry if it doesn't exist.
    */
-  set(path8, updates) {
-    const existing = this._entries.get(path8);
+  set(path9, updates) {
+    const existing = this._entries.get(path9);
     if (existing) {
       existing.state = updates.state;
       if (updates.config) {
@@ -2837,7 +2837,7 @@ var MountManager = class {
         existing.error = updates.error;
       }
     } else if (updates.filesystem) {
-      this._entries.set(path8, {
+      this._entries.set(path9, {
         filesystem: updates.filesystem,
         state: updates.state,
         config: updates.config,
@@ -2845,14 +2845,14 @@ var MountManager = class {
         error: updates.error
       });
     } else {
-      this.logger.debug("set() called for unknown path without filesystem", { path: path8 });
+      this.logger.debug("set() called for unknown path without filesystem", { path: path9 });
     }
   }
   /**
    * Delete a mount entry.
    */
-  delete(path8) {
-    return this._entries.delete(path8);
+  delete(path9) {
+    return this._entries.delete(path9);
   }
   /**
    * Clear all mount entries.
@@ -2873,7 +2873,7 @@ var MountManager = class {
       return;
     }
     this.logger.debug("Processing pending mounts", { count: pendingCount });
-    for (const [path8, entry] of this._entries) {
+    for (const [path9, entry] of this._entries) {
       if (entry.state !== "pending") {
         continue;
       }
@@ -2883,7 +2883,7 @@ var MountManager = class {
         try {
           const hookResult = await this._onMount({
             filesystem: entry.filesystem,
-            mountPath: path8,
+            mountPath: path9,
             config,
             sandbox: this._sandbox,
             workspace: this._workspace
@@ -2891,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: path8, provider: fsProvider });
+            this.logger.debug("Mount skipped by onMount hook", { path: path9, provider: fsProvider });
             continue;
           }
           if (hookResult && typeof hookResult === "object") {
@@ -2899,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: path8, provider: fsProvider });
+              this.logger.info("Mount handled by onMount hook", { path: path9, provider: fsProvider });
             } else {
               entry.state = "error";
               entry.error = hookResult.error ?? "Mount hook failed";
-              this.logger.error("Mount hook failed", { path: path8, provider: fsProvider, error: entry.error });
+              this.logger.error("Mount hook failed", { path: path9, 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: path8, provider: fsProvider, error: entry.error });
+          this.logger.error("Mount hook threw error", { path: path9, 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: path8, provider: fsProvider });
+        this.logger.debug("Filesystem does not support mounting", { path: path9, provider: fsProvider });
         continue;
       }
       entry.config = config;
       entry.configHash = this.hashConfig(config);
       entry.state = "mounting";
-      this.logger.debug("Mounting filesystem", { path: path8, provider: fsProvider, type: config.type });
+      this.logger.debug("Mounting filesystem", { path: path9, provider: fsProvider, type: config.type });
       try {
-        const result = await this._mountFn(entry.filesystem, path8);
+        const result = await this._mountFn(entry.filesystem, path9);
         if (result.success) {
           entry.state = "mounted";
-          this.logger.info("Mount successful", { path: path8, provider: fsProvider });
+          this.logger.info("Mount successful", { path: path9, provider: fsProvider });
         } else if (result.unavailable) {
           entry.state = "unavailable";
           entry.error = result.error ?? "FUSE tool not installed";
-          this.logger.warn("FUSE mount unavailable", { path: path8, provider: fsProvider, error: entry.error });
+          this.logger.warn("FUSE mount unavailable", { path: path9, provider: fsProvider, error: entry.error });
         } else {
           entry.state = "error";
           entry.error = result.error ?? "Mount failed";
-          this.logger.error("Mount failed", { path: path8, provider: fsProvider, error: entry.error });
+          this.logger.error("Mount failed", { path: path9, 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: path8, provider: fsProvider, error: entry.error });
+          this.logger.warn("FUSE mount unavailable", { path: path9, provider: fsProvider, error: entry.error });
         } else {
           entry.state = "error";
           entry.error = String(err);
-          this.logger.error("Mount threw error", { path: path8, provider: fsProvider, error: entry.error });
+          this.logger.error("Mount threw error", { path: path9, provider: fsProvider, error: entry.error });
         }
       }
     }
@@ -2995,10 +2995,10 @@ var MountManager = class {
     if (separatorIndex <= 0) {
       return null;
     }
-    const path8 = content.slice(0, separatorIndex);
+    const path9 = content.slice(0, separatorIndex);
     const configHash = content.slice(separatorIndex + 1);
-    if (!path8 || !configHash) return null;
-    return { path: path8, configHash };
+    if (!path9 || !configHash) return null;
+    return { path: path9, configHash };
   }
   /**
    * Check if a config hash matches the expected hash for a mount path.
@@ -3488,11 +3488,11 @@ function buildBwrapCommand(command, workspacePath, config) {
   }
   bwrapArgs.push("--proc", "/proc");
   bwrapArgs.push("--tmpfs", "/tmp");
-  for (const path8 of DEFAULT_READONLY_BINDS) {
-    bwrapArgs.push("--ro-bind-try", path8, path8);
+  for (const path9 of DEFAULT_READONLY_BINDS) {
+    bwrapArgs.push("--ro-bind-try", path9, path9);
   }
-  for (const path8 of config.readOnlyPaths ?? []) {
-    bwrapArgs.push("--ro-bind", path8, path8);
+  for (const path9 of config.readOnlyPaths ?? []) {
+    bwrapArgs.push("--ro-bind", path9, path9);
   }
   if (config.allowSystemBinaries !== false) {
     const nodePath4 = process.execPath;
@@ -3504,8 +3504,8 @@ function buildBwrapCommand(command, workspacePath, config) {
     bwrapArgs.push("--ro-bind-try", "/snap", "/snap");
   }
   bwrapArgs.push("--bind", workspacePath, workspacePath);
-  for (const path8 of config.readWritePaths ?? []) {
-    bwrapArgs.push("--bind", path8, path8);
+  for (const path9 of config.readWritePaths ?? []) {
+    bwrapArgs.push("--bind", path9, path9);
   }
   bwrapArgs.push("--chdir", workspacePath);
   bwrapArgs.push("--die-with-parent");
@@ -4915,18 +4915,18 @@ var VersionedSkillSource = class {
   /**
    * Normalize a path by stripping leading/trailing slashes and dots.
    */
-  #normalizePath(path8) {
-    let normalized = path8.replace(/^[./\\]+|[/\\]+$/g, "");
+  #normalizePath(path9) {
+    let normalized = path9.replace(/^[./\\]+|[/\\]+$/g, "");
     if (normalized === "") return "";
     return normalized;
   }
-  async exists(path8) {
-    const normalized = this.#normalizePath(path8);
+  async exists(path9) {
+    const normalized = this.#normalizePath(path9);
     if (this.#tree.entries[normalized]) return true;
     return this.#directories.has(normalized);
   }
-  async stat(path8) {
-    const normalized = this.#normalizePath(path8);
+  async stat(path9) {
+    const normalized = this.#normalizePath(path9);
     const name = normalized.split("/").pop() || normalized || ".";
     const entry = this.#tree.entries[normalized];
     if (entry) {
@@ -4948,27 +4948,27 @@ var VersionedSkillSource = class {
         modifiedAt: this.#versionCreatedAt
       };
     }
-    throw new Error(`Path not found in skill version tree: ${path8}`);
+    throw new Error(`Path not found in skill version tree: ${path9}`);
   }
-  async readFile(path8) {
-    const normalized = this.#normalizePath(path8);
+  async readFile(path9) {
+    const normalized = this.#normalizePath(path9);
     const entry = this.#tree.entries[normalized];
     if (!entry) {
-      throw new Error(`File not found in skill version tree: ${path8}`);
+      throw new Error(`File not found in skill version tree: ${path9}`);
     }
     const blob = await this.#blobStore.get(entry.blobHash);
     if (!blob) {
-      throw new Error(`Blob not found for hash ${entry.blobHash} (file: ${path8})`);
+      throw new Error(`Blob not found for hash ${entry.blobHash} (file: ${path9})`);
     }
     if (entry.encoding === "base64") {
       return Buffer.from(blob.content, "base64");
     }
     return blob.content;
   }
-  async readdir(path8) {
-    const normalized = this.#normalizePath(path8);
+  async readdir(path9) {
+    const normalized = this.#normalizePath(path9);
     if (!this.#directories.has(normalized)) {
-      throw new Error(`Directory not found in skill version tree: ${path8}`);
+      throw new Error(`Directory not found in skill version tree: ${path9}`);
     }
     const prefix = normalized === "" ? "" : normalized + "/";
     const seen = /* @__PURE__ */ new Set();
@@ -5001,15 +5001,15 @@ var CompositeVersionedSkillSource = class {
     this.#fallback = options?.fallback;
     this.#fallbackSkills = new Set(options?.fallbackSkills ?? []);
   }
-  #normalizePath(path8) {
-    return path8.replace(/^[./\\]+|[/\\]+$/g, "");
+  #normalizePath(path9) {
+    return path9.replace(/^[./\\]+|[/\\]+$/g, "");
   }
   /**
    * Route a path to the correct source.
    * Returns the source and the remaining path within that source.
    */
-  #routePath(path8) {
-    const normalized = this.#normalizePath(path8);
+  #routePath(path9) {
+    const normalized = this.#normalizePath(path9);
     if (normalized === "") return null;
     const segments = normalized.split("/");
     const skillDir = segments[0];
@@ -5026,15 +5026,15 @@ var CompositeVersionedSkillSource = class {
     }
     return null;
   }
-  async exists(path8) {
-    const normalized = this.#normalizePath(path8);
+  async exists(path9) {
+    const normalized = this.#normalizePath(path9);
     if (normalized === "") return true;
-    const route = this.#routePath(path8);
+    const route = this.#routePath(path9);
     if (!route) return false;
     return route.source.exists(route.subPath);
   }
-  async stat(path8) {
-    const normalized = this.#normalizePath(path8);
+  async stat(path9) {
+    const normalized = this.#normalizePath(path9);
     if (normalized === "") {
       return {
         name: ".",
@@ -5044,21 +5044,21 @@ var CompositeVersionedSkillSource = class {
         modifiedAt: /* @__PURE__ */ new Date()
       };
     }
-    const route = this.#routePath(path8);
+    const route = this.#routePath(path9);
     if (!route) {
-      throw new Error(`Path not found in composite skill source: ${path8}`);
+      throw new Error(`Path not found in composite skill source: ${path9}`);
     }
     return route.source.stat(route.subPath);
   }
-  async readFile(path8) {
-    const route = this.#routePath(path8);
+  async readFile(path9) {
+    const route = this.#routePath(path9);
     if (!route) {
-      throw new Error(`File not found in composite skill source: ${path8}`);
+      throw new Error(`File not found in composite skill source: ${path9}`);
     }
     return route.source.readFile(route.subPath);
   }
-  async readdir(path8) {
-    const normalized = this.#normalizePath(path8);
+  async readdir(path9) {
+    const normalized = this.#normalizePath(path9);
     if (normalized === "") {
       const entries = [];
       const seen = /* @__PURE__ */ new Set();
@@ -5074,9 +5074,9 @@ var CompositeVersionedSkillSource = class {
       }
       return entries;
     }
-    const route = this.#routePath(path8);
+    const route = this.#routePath(path9);
     if (!route) {
-      throw new Error(`Directory not found in composite skill source: ${path8}`);
+      throw new Error(`Directory not found in composite skill source: ${path9}`);
     }
     return route.source.readdir(route.subPath);
   }
@@ -5276,7 +5276,7 @@ var WorkspaceSkillsImpl = class _WorkspaceSkillsImpl {
     if (a.length !== b.length) return false;
     const sortedA = [...a].sort();
     const sortedB = [...b].sort();
-    return sortedA.every((path8, i) => path8 === sortedB[i]);
+    return sortedA.every((path9, i) => path9 === sortedB[i]);
   }
   // ===========================================================================
   // Search
@@ -5882,9 +5882,9 @@ ${validation.errors.join("\n")}`);
   /**
    * Get parent path
    */
-  #getParentPath(path8) {
-    const lastSlash = path8.lastIndexOf("/");
-    return lastSlash > 0 ? path8.substring(0, lastSlash) : "/";
+  #getParentPath(path9) {
+    const lastSlash = path9.lastIndexOf("/");
+    return lastSlash > 0 ? path9.substring(0, lastSlash) : "/";
   }
 };
 function hashContent(content) {
@@ -6115,14 +6115,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: path8, startLine, endLine }) => {
+    execute: async ({ skillName, path: path9, 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, path8);
-      if (content === null) content = await skills.getScript(resolvedPath, path8);
-      if (content === null) content = await skills.getAsset(resolvedPath, path8);
+      content = await skills.getReference(resolvedPath, path9);
+      if (content === null) content = await skills.getScript(resolvedPath, path9);
+      if (content === null) content = await skills.getAsset(resolvedPath, path9);
       if (content === null) {
         const refs = (await skills.listReferences(resolvedPath)).map((f) => `references/${f}`);
         const scriptsList = (await skills.listScripts(resolvedPath)).map((f) => `scripts/${f}`);
@@ -6130,11 +6130,11 @@ function createSkillReadTool(skills) {
         const allFiles = [...refs, ...scriptsList, ...assets];
         const fileList = allFiles.length > 0 ? `
 Available files: ${allFiles.join(", ")}` : "";
-        return `File "${path8}" not found in skill "${skillName}".${fileList}`;
+        return `File "${path9}" 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}/${path8}`;
+        const fullPath = `${resolved.skill.path}/${path9}`;
         const size = typeof content === "string" ? Buffer.byteLength(content) : content.length;
         return `Binary file: ${fullPath} (${size} bytes)`;
       }
@@ -6368,13 +6368,13 @@ var Workspace = class {
    * @param options - Index options (metadata, type hints)
    * @throws {SearchNotAvailableError} if search is not configured
    */
-  async index(path8, content, options) {
+  async index(path9, content, options) {
     if (!this._searchEngine) {
       throw new SearchNotAvailableError();
     }
     this.lastAccessedAt = /* @__PURE__ */ new Date();
     const doc = {
-      id: path8,
+      id: path9,
       content,
       metadata: {
         type: options?.type,
@@ -7012,7 +7012,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: path8, pattern, replacement, transform, targetName, newName, importSpec }, context) => {
+  execute: async ({ path: path9, pattern, replacement, transform, targetName, newName, importSpec }, context) => {
     const { workspace, filesystem } = requireFilesystem(context);
     await emitWorkspaceMetadata(context, WORKSPACE_TOOLS.FILESYSTEM.AST_EDIT);
     if (filesystem.readOnly) {
@@ -7025,19 +7025,19 @@ Pattern replace (for everything else):
     const { parse: parse2, Lang } = astGrep;
     let content;
     try {
-      content = await filesystem.readFile(path8, { encoding: "utf-8" });
+      content = await filesystem.readFile(path9, { encoding: "utf-8" });
     } catch (error) {
       if (error instanceof FileNotFoundError) {
-        return `File not found: ${path8}. Use the write file tool to create it first.`;
+        return `File not found: ${path9}. 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(path8, Lang);
+    const lang = getLanguageFromPath(path9, Lang);
     if (!lang) {
-      return `Unsupported file type for AST editing: ${path8}`;
+      return `Unsupported file type for AST editing: ${path9}`;
     }
     const ast = parse2(lang, content);
     const root = ast.root();
@@ -7087,16 +7087,16 @@ Pattern replace (for everything else):
     }
     const wasModified = modifiedContent !== content;
     if (wasModified) {
-      await filesystem.writeFile(path8, modifiedContent, {
+      await filesystem.writeFile(path9, modifiedContent, {
         overwrite: true,
         expectedMtime: context?.__expectedMtime
       });
     }
     if (!wasModified) {
-      return `No changes made to ${path8} (${changes.join("; ")})`;
+      return `No changes made to ${path9} (${changes.join("; ")})`;
     }
-    let output = `${path8}: ${changes.join("; ")}`;
-    output += await getEditDiagnosticsText(workspace, path8, modifiedContent);
+    let output = `${path9}: ${changes.join("; ")}`;
+    output += await getEditDiagnosticsText(workspace, path9, modifiedContent);
     return output;
   }
 });
@@ -7107,19 +7107,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: path8, recursive }, context) => {
+  execute: async ({ path: path9, 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(path8);
+    const stat3 = await filesystem.stat(path9);
     if (stat3.type === "directory") {
-      await filesystem.rmdir(path8, { recursive, force: recursive });
+      await filesystem.rmdir(path9, { recursive, force: recursive });
     } else {
-      await filesystem.deleteFile(path8);
+      await filesystem.deleteFile(path9);
     }
-    return `Deleted ${path8}`;
+    return `Deleted ${path9}`;
   }
 });
 var editFileTool = createTool({
@@ -7137,24 +7137,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: path8, old_string, new_string, replace_all }, context) => {
+  execute: async ({ path: path9, 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(path8, { encoding: "utf-8" });
+      const content = await filesystem.readFile(path9, { 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(path8, result.content, {
+      await filesystem.writeFile(path9, result.content, {
         overwrite: true,
         expectedMtime: context?.__expectedMtime
       });
-      let output = `Replaced ${result.replacements} occurrence${result.replacements !== 1 ? "s" : ""} in ${path8}`;
-      output += await getEditDiagnosticsText(workspace, path8, result.content);
+      let output = `Replaced ${result.replacements} occurrence${result.replacements !== 1 ? "s" : ""} in ${path9}`;
+      output += await getEditDiagnosticsText(workspace, path9, result.content);
       return output;
     } catch (error) {
       if (error instanceof StringNotFoundError) {
@@ -7406,19 +7406,19 @@ var fileStatTool = createTool({
   inputSchema: z.object({
     path: z.string().describe("The path to check")
   }),
-  execute: async ({ path: path8 }, context) => {
+  execute: async ({ path: path9 }, context) => {
     const { filesystem } = requireFilesystem(context);
     await emitWorkspaceMetadata(context, WORKSPACE_TOOLS.FILESYSTEM.FILE_STAT);
     try {
-      const stat3 = await filesystem.stat(path8);
+      const stat3 = await filesystem.stat(path9);
       const modifiedAt = stat3.modifiedAt.toISOString();
-      const parts = [`${path8}`, `Type: ${stat3.type}`];
+      const parts = [`${path9}`, `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 `${path8}: not found`;
+        return `${path9}: not found`;
       }
       throw error;
     }
@@ -7684,11 +7684,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: path8, content, metadata }, context) => {
+  execute: async ({ path: path9, content, metadata }, context) => {
     const workspace = requireWorkspace(context);
     await emitWorkspaceMetadata(context, WORKSPACE_TOOLS.SEARCH.INDEX);
-    await workspace.index(path8, content, { metadata });
-    return `Indexed ${path8}`;
+    await workspace.index(path9, content, { metadata });
+    return `Indexed ${path9}`;
   }
 });
 var KILL_TAIL_LINES = 50;
@@ -7744,7 +7744,7 @@ Use this to stop a long-running background process that was started with execute
 });
 
 // src/workspace/tools/tree-formatter.ts
-async function formatAsTree(fs6, path8, options) {
+async function formatAsTree(fs6, path9, options) {
   const maxDepth = options?.maxDepth ?? Infinity;
   const showHidden = options?.showHidden ?? false;
   const dirsOnly = options?.dirsOnly ?? false;
@@ -7756,7 +7756,7 @@ async function formatAsTree(fs6, path8, options) {
   if (!ignoreFilter && respectGitignore) {
     const rawFilter = await loadGitignore(fs6);
     if (rawFilter) {
-      const normalizedPath = path8.replace(/^\.\//, "").replace(/^\//, "").replace(/\/$/, "");
+      const normalizedPath = path9.replace(/^\.\//, "").replace(/^\//, "").replace(/\/$/, "");
       const targetIsIgnored = normalizedPath && rawFilter(normalizedPath + "/");
       ignoreFilter = targetIsIgnored ? void 0 : rawFilter;
     }
@@ -7818,7 +7818,7 @@ async function formatAsTree(fs6, path8, options) {
     if (globMatcher && !dirsOnly) {
       filtered = filtered.filter((e) => {
         if (e.type === "directory") return true;
-        const relativePath = getRelativePath(path8, currentPath, e.name);
+        const relativePath = getRelativePath(path9, currentPath, e.name);
         return globMatcher(relativePath);
       });
     }
@@ -7832,7 +7832,7 @@ async function formatAsTree(fs6, path8, options) {
       const entry = filtered[i];
       const displayName = entry.isSymlink && entry.symlinkTarget ? `${entry.name} -> ${entry.symlinkTarget}` : entry.name;
       lines.push(`${indent}${displayName}`);
-      paths.push(getRelativePath(path8, currentPath, entry.name));
+      paths.push(getRelativePath(path9, currentPath, entry.name));
       if (entry.type === "directory") {
         dirCount++;
         if (!entry.isSymlink) {
@@ -7844,7 +7844,7 @@ async function formatAsTree(fs6, path8, options) {
       }
     }
   }
-  await buildTree(path8, 0);
+  await buildTree(path9, 0);
   const dirPart = dirCount === 1 ? "1 directory" : `${dirCount} directories`;
   const filePart = fileCount === 1 ? "1 file" : `${fileCount} files`;
   let summary = `${dirPart}, ${filePart}`;
@@ -7909,10 +7909,10 @@ To list ALL files, omit the pattern parameter \u2014 do NOT pass pattern: "*".`,
     ),
     respectGitignore: z.boolean().optional().default(true).describe("Respect .gitignore in the listed directory (default: true).")
   }),
-  execute: async ({ path: path8 = ".", maxDepth = 2, showHidden, dirsOnly, exclude, extension, pattern, respectGitignore }, context) => {
+  execute: async ({ path: path9 = ".", 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, path8, {
+    const result = await formatAsTree(filesystem, path9, {
       maxDepth,
       showHidden,
       dirsOnly,
@@ -8125,14 +8125,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: path8, recursive }, context) => {
+  execute: async ({ path: path9, recursive }, context) => {
     const { filesystem } = requireFilesystem(context);
     await emitWorkspaceMetadata(context, WORKSPACE_TOOLS.FILESYSTEM.MKDIR);
     if (filesystem.readOnly) {
       throw new WorkspaceReadOnlyError("mkdir");
     }
-    await filesystem.mkdir(path8, { recursive });
-    return `Created directory ${path8}`;
+    await filesystem.mkdir(path9, { recursive });
+    return `Created directory ${path9}`;
   }
 });
 var readFileTool = createTool({
@@ -8145,12 +8145,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: path8, encoding, offset, limit, showLineNumbers }, context) => {
+  execute: async ({ path: path9, 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(path8, { encoding: effectiveEncoding });
-    const stat3 = await filesystem.stat(path8);
+    const fullContent = await filesystem.readFile(path9, { encoding: effectiveEncoding });
+    const stat3 = await filesystem.stat(path9);
     const isTextEncoding = !encoding || encoding === "utf-8" || encoding === "utf8";
     const tokenLimit = workspace.getToolsConfig()?.[WORKSPACE_TOOLS.FILESYSTEM.READ_FILE]?.maxOutputTokens;
     if (!isTextEncoding) {
@@ -8218,19 +8218,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: path8, content, overwrite }, context) => {
+  execute: async ({ path: path9, 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(path8, content, {
+    await filesystem.writeFile(path9, content, {
       overwrite,
       expectedMtime: context?.__expectedMtime
     });
     const size = Buffer.byteLength(content, "utf-8");
-    let output = `Wrote ${size} bytes to ${path8}`;
-    output += await getEditDiagnosticsText(workspace, path8, content);
+    let output = `Wrote ${size} bytes to ${path9}`;
+    output += await getEditDiagnosticsText(workspace, path9, content);
     return output;
   }
 });
@@ -8390,5 +8390,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, 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-LOA2BVRK.js.map
-//# sourceMappingURL=chunk-LOA2BVRK.js.map
+//# sourceMappingURL=chunk-HJBVUY76.js.map
+//# sourceMappingURL=chunk-HJBVUY76.js.map