@axiom-lattice/core 2.1.84 → 2.1.86

package/dist/index.mjs

@@ -2468,7 +2468,7 @@ var InMemoryBindingStore = class {
    * @returns Array of matching {@link Binding} objects
    */
   async list(params) {
-    let results = Array.from(this.bindings.values()).filter((b) => {
+    const results = Array.from(this.bindings.values()).filter((b) => {
       if (b.tenantId !== params.tenantId) return false;
       if (params.channel && b.channel !== params.channel) return false;
       if (params.agentId && b.agentId !== params.agentId) return false;
@@ -5717,9 +5717,9 @@ var VolumeFilesystem = class {
     this.client = client;
     this.mountPrefix = mountPrefix;
   }
-  async lsInfo(path3) {
-    console.log(`[VolumeFilesystem.lsInfo] path=${path3} mountPrefix=${this.mountPrefix}`);
-    const entries = await this.client.list(path3);
+  async lsInfo(path5) {
+    console.log(`[VolumeFilesystem.lsInfo] path=${path5} mountPrefix=${this.mountPrefix}`);
+    const entries = await this.client.list(path5);
     console.log(`[VolumeFilesystem.lsInfo] got ${entries.length} entries`);
     const prefix = this.mountPrefix.endsWith("/") ? this.mountPrefix : this.mountPrefix + "/";
     return entries.map((entry) => ({
@@ -8032,8 +8032,8 @@ function truncateIfTooLong(result) {
   }
   return result;
 }
-function validatePath(path3) {
-  const pathStr = path3 || "/";
+function validatePath(path5) {
+  const pathStr = path5 || "/";
   if (!pathStr || pathStr.trim() === "") {
     throw new Error("Path cannot be empty");
   }
@@ -8050,10 +8050,10 @@ function validatePath(path3) {
   }
   return normalized;
 }
-function globSearchFiles(files, pattern, path3 = "/") {
+function globSearchFiles(files, pattern, path5 = "/") {
   let normalizedPath;
   try {
-    normalizedPath = validatePath(path3);
+    normalizedPath = validatePath(path5);
   } catch {
     return "No files found";
   }
@@ -8105,7 +8105,7 @@ function formatGrepResults(results, outputMode) {
   }
   return lines.join("\n");
 }
-function grepSearchFiles(files, pattern, path3 = null, glob = null, outputMode = "files_with_matches") {
+function grepSearchFiles(files, pattern, path5 = null, glob = null, outputMode = "files_with_matches") {
   let regex;
   try {
     regex = new RegExp(pattern);
@@ -8114,7 +8114,7 @@ function grepSearchFiles(files, pattern, path3 = null, glob = null, outputMode =
   }
   let normalizedPath;
   try {
-    normalizedPath = validatePath(path3);
+    normalizedPath = validatePath(path5);
   } catch {
     return "No matches found";
   }
@@ -8146,7 +8146,7 @@ function grepSearchFiles(files, pattern, path3 = null, glob = null, outputMode =
   }
   return formatGrepResults(results, outputMode);
 }
-function grepMatchesFromFiles(files, pattern, path3 = null, glob = null) {
+function grepMatchesFromFiles(files, pattern, path5 = null, glob = null) {
   let regex;
   try {
     regex = new RegExp(pattern);
@@ -8155,7 +8155,7 @@ function grepMatchesFromFiles(files, pattern, path3 = null, glob = null) {
   }
   let normalizedPath;
   try {
-    normalizedPath = validatePath(path3);
+    normalizedPath = validatePath(path5);
   } catch {
     return [];
   }
@@ -8216,11 +8216,11 @@ var StateBackend = class {
    * @returns List of FileInfo objects for files and directories directly in the directory.
    *          Directories have a trailing / in their path and is_dir=true.
    */
-  lsInfo(path3) {
+  lsInfo(path5) {
     const files = this.getFiles();
     const infos = [];
     const subdirs = /* @__PURE__ */ new Set();
-    const normalizedPath = path3.endsWith("/") ? path3 : path3 + "/";
+    const normalizedPath = path5.endsWith("/") ? path5 : path5 + "/";
     for (const [k, fd] of Object.entries(files)) {
       if (!k.startsWith(normalizedPath)) {
         continue;
@@ -8326,16 +8326,16 @@ var StateBackend = class {
   /**
    * Structured search results or error string for invalid input.
    */
-  grepRaw(pattern, path3 = "/", glob = null) {
+  grepRaw(pattern, path5 = "/", glob = null) {
     const files = this.getFiles();
-    return grepMatchesFromFiles(files, pattern, path3, glob);
+    return grepMatchesFromFiles(files, pattern, path5, glob);
   }
   /**
    * Structured glob matching returning FileInfo objects.
    */
-  globInfo(pattern, path3 = "/") {
+  globInfo(pattern, path5 = "/") {
     const files = this.getFiles();
-    const result = globSearchFiles(files, pattern, path3);
+    const result = globSearchFiles(files, pattern, path5);
     if (result === "No files found") {
       return [];
     }
@@ -8429,10 +8429,10 @@ function createLsTool(backend, options) {
         ...runConfig
       };
       const resolvedBackend = await getBackend(backend, stateAndStore);
-      const path3 = input.path || "/";
-      const infos = await resolvedBackend.lsInfo(path3);
+      const path5 = input.path || "/";
+      const infos = await resolvedBackend.lsInfo(path5);
       if (infos.length === 0) {
-        return `No files found in ${path3}`;
+        return `No files found in ${path5}`;
       }
       const lines = [];
       for (const info of infos) {
@@ -8575,8 +8575,8 @@ function createGlobTool(backend, options) {
         ...runConfig
       };
       const resolvedBackend = await getBackend(backend, stateAndStore);
-      const { pattern, path: path3 = "/" } = input;
-      const infos = await resolvedBackend.globInfo(pattern, path3);
+      const { pattern, path: path5 = "/" } = input;
+      const infos = await resolvedBackend.globInfo(pattern, path5);
       if (infos.length === 0) {
         return `No files found matching pattern '${pattern}'`;
       }
@@ -8603,8 +8603,8 @@ function createGrepTool(backend, options) {
         ...runConfig
       };
       const resolvedBackend = await getBackend(backend, stateAndStore);
-      const { pattern, path: path3 = "/", glob = null } = input;
-      const result = await resolvedBackend.grepRaw(pattern, path3, glob);
+      const { pattern, path: path5 = "/", glob = null } = input;
+      const result = await resolvedBackend.grepRaw(pattern, path5, glob);
       if (typeof result === "string") {
         return result;
       }
@@ -12721,8 +12721,7 @@ var Agent = class {
     if (signal?.aborted) {
       throw new Error("Agent execution was aborted");
     }
-    let result;
-    result = await runnable_agent.invoke(
+    const result = await runnable_agent.invoke(
       inputMessage.command ? new Command2(inputMessage.command) : { ...rest, messages, "x-tenant-id": this.tenant_id },
       {
         context: { runConfig },
@@ -13081,7 +13080,7 @@ var Agent = class {
       includeTypes: ["ai", "human", "tool"]
       //["human", "ai", "tool"],
     });
-    let messagesArray = filteredMessages.map((message) => ({
+    const messagesArray = filteredMessages.map((message) => ({
       id: message.id,
       role: message.getType(),
       content: message.content,
@@ -14178,12 +14177,12 @@ var AgentManager = class _AgentManager {
     return _AgentManager.instance;
   }
   callAgentInQueue(queue, return_agent_state) {
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       const callback_event = `${queue.assistant_id}::${queue.thread_id}`;
       if (return_agent_state) {
         event_bus_default.subscribeOnce(callback_event, (data) => {
           if (data.success) {
-            resolve3(data.state);
+            resolve4(data.state);
           } else {
             reject(data.error);
           }
@@ -14198,7 +14197,7 @@ var AgentManager = class _AgentManager {
           },
           true
         );
-        !return_agent_state && resolve3({ callback_event_id: callback_event, success: true });
+        !return_agent_state && resolve4({ callback_event_id: callback_event, success: true });
       } catch (error) {
         !return_agent_state && reject({
           callback_event_id: callback_event,
@@ -15097,13 +15096,13 @@ var StoreBackend = class {
    * @returns List of FileInfo objects for files and directories directly in the directory.
    *          Directories have a trailing / in their path and is_dir=true.
    */
-  async lsInfo(path3) {
+  async lsInfo(path5) {
     const store = this.getStore();
     const namespace = this.getNamespace();
     const items = await this.searchStorePaginated(store, namespace);
     const infos = [];
     const subdirs = /* @__PURE__ */ new Set();
-    const normalizedPath = path3.endsWith("/") ? path3 : path3 + "/";
+    const normalizedPath = path5.endsWith("/") ? path5 : path5 + "/";
     for (const item of items) {
       const itemKey = String(item.key);
       if (!itemKey.startsWith(normalizedPath)) {
@@ -15221,7 +15220,7 @@ var StoreBackend = class {
   /**
    * Structured search results or error string for invalid input.
    */
-  async grepRaw(pattern, path3 = "/", glob = null) {
+  async grepRaw(pattern, path5 = "/", glob = null) {
     const store = this.getStore();
     const namespace = this.getNamespace();
     const items = await this.searchStorePaginated(store, namespace);
@@ -15233,12 +15232,12 @@ var StoreBackend = class {
         continue;
       }
     }
-    return grepMatchesFromFiles(files, pattern, path3, glob);
+    return grepMatchesFromFiles(files, pattern, path5, glob);
   }
   /**
    * Structured glob matching returning FileInfo objects.
    */
-  async globInfo(pattern, path3 = "/") {
+  async globInfo(pattern, path5 = "/") {
     const store = this.getStore();
     const namespace = this.getNamespace();
     const items = await this.searchStorePaginated(store, namespace);
@@ -15250,7 +15249,7 @@ var StoreBackend = class {
         continue;
       }
     }
-    const result = globSearchFiles(files, pattern, path3);
+    const result = globSearchFiles(files, pattern, path5);
     if (result === "No files found") {
       return [];
     }
@@ -15335,8 +15334,8 @@ var FilesystemBackend = class {
   async lsInfo(dirPath) {
     try {
       const resolvedPath = this.resolvePath(dirPath);
-      const stat3 = await fs2.stat(resolvedPath);
-      if (!stat3.isDirectory()) {
+      const stat4 = await fs2.stat(resolvedPath);
+      if (!stat4.isDirectory()) {
         return [];
       }
       const entries = await fs2.readdir(resolvedPath, { withFileTypes: true });
@@ -15415,8 +15414,8 @@ var FilesystemBackend = class {
       const resolvedPath = this.resolvePath(filePath);
       let content;
       if (SUPPORTS_NOFOLLOW) {
-        const stat3 = await fs2.stat(resolvedPath);
-        if (!stat3.isFile()) {
+        const stat4 = await fs2.stat(resolvedPath);
+        if (!stat4.isFile()) {
           return `Error: File '${filePath}' not found`;
         }
         const fd = await fs2.open(
@@ -15429,11 +15428,11 @@ var FilesystemBackend = class {
           await fd.close();
         }
       } else {
-        const stat3 = await fs2.lstat(resolvedPath);
-        if (stat3.isSymbolicLink()) {
+        const stat4 = await fs2.lstat(resolvedPath);
+        if (stat4.isSymbolicLink()) {
           return `Error: Symlinks are not allowed: ${filePath}`;
         }
-        if (!stat3.isFile()) {
+        if (!stat4.isFile()) {
           return `Error: File '${filePath}' not found`;
         }
         content = await fs2.readFile(resolvedPath, "utf-8");
@@ -15463,10 +15462,10 @@ var FilesystemBackend = class {
   async readRaw(filePath) {
     const resolvedPath = this.resolvePath(filePath);
     let content;
-    let stat3;
+    let stat4;
     if (SUPPORTS_NOFOLLOW) {
-      stat3 = await fs2.stat(resolvedPath);
-      if (!stat3.isFile()) throw new Error(`File '${filePath}' not found`);
+      stat4 = await fs2.stat(resolvedPath);
+      if (!stat4.isFile()) throw new Error(`File '${filePath}' not found`);
       const fd = await fs2.open(
         resolvedPath,
         fsSync.constants.O_RDONLY | fsSync.constants.O_NOFOLLOW
@@ -15477,17 +15476,17 @@ var FilesystemBackend = class {
         await fd.close();
       }
     } else {
-      stat3 = await fs2.lstat(resolvedPath);
-      if (stat3.isSymbolicLink()) {
+      stat4 = await fs2.lstat(resolvedPath);
+      if (stat4.isSymbolicLink()) {
         throw new Error(`Symlinks are not allowed: ${filePath}`);
       }
-      if (!stat3.isFile()) throw new Error(`File '${filePath}' not found`);
+      if (!stat4.isFile()) throw new Error(`File '${filePath}' not found`);
       content = await fs2.readFile(resolvedPath, "utf-8");
     }
     return {
       content: content.split("\n"),
-      created_at: stat3.ctime.toISOString(),
-      modified_at: stat3.mtime.toISOString()
+      created_at: stat4.ctime.toISOString(),
+      modified_at: stat4.mtime.toISOString()
     };
   }
   /**
@@ -15498,8 +15497,8 @@ var FilesystemBackend = class {
     try {
       const resolvedPath = this.resolvePath(filePath);
       try {
-        const stat3 = await fs2.lstat(resolvedPath);
-        if (stat3.isSymbolicLink()) {
+        const stat4 = await fs2.lstat(resolvedPath);
+        if (stat4.isSymbolicLink()) {
           return {
             error: `Cannot write to ${filePath} because it is a symlink. Symlinks are not allowed.`
           };
@@ -15535,8 +15534,8 @@ var FilesystemBackend = class {
       const resolvedPath = this.resolvePath(filePath);
       let content;
       if (SUPPORTS_NOFOLLOW) {
-        const stat3 = await fs2.stat(resolvedPath);
-        if (!stat3.isFile()) {
+        const stat4 = await fs2.stat(resolvedPath);
+        if (!stat4.isFile()) {
           return { error: `Error: File '${filePath}' not found` };
         }
         const fd = await fs2.open(
@@ -15549,11 +15548,11 @@ var FilesystemBackend = class {
           await fd.close();
         }
       } else {
-        const stat3 = await fs2.lstat(resolvedPath);
-        if (stat3.isSymbolicLink()) {
+        const stat4 = await fs2.lstat(resolvedPath);
+        if (stat4.isSymbolicLink()) {
           return { error: `Error: Symlinks are not allowed: ${filePath}` };
         }
-        if (!stat3.isFile()) {
+        if (!stat4.isFile()) {
           return { error: `Error: File '${filePath}' not found` };
         }
         content = await fs2.readFile(resolvedPath, "utf-8");
@@ -15621,7 +15620,7 @@ var FilesystemBackend = class {
    * Returns null if ripgrep is not available or fails.
    */
   async ripgrepSearch(pattern, baseFull, includeGlob) {
-    return new Promise((resolve3) => {
+    return new Promise((resolve4) => {
       const args = ["--json"];
       if (includeGlob) {
         args.push("--glob", includeGlob);
@@ -15635,7 +15634,7 @@ var FilesystemBackend = class {
       });
       proc.on("close", (code) => {
         if (code !== 0 && code !== 1) {
-          resolve3(null);
+          resolve4(null);
           return;
         }
         for (const line of output.split("\n")) {
@@ -15671,10 +15670,10 @@ var FilesystemBackend = class {
             continue;
           }
         }
-        resolve3(results);
+        resolve4(results);
       });
       proc.on("error", () => {
-        resolve3(null);
+        resolve4(null);
       });
     });
   }
@@ -15689,8 +15688,8 @@ var FilesystemBackend = class {
       return {};
     }
     const results = {};
-    const stat3 = await fs2.stat(baseFull);
-    const root = stat3.isDirectory() ? baseFull : path2.dirname(baseFull);
+    const stat4 = await fs2.stat(baseFull);
+    const root = stat4.isDirectory() ? baseFull : path2.dirname(baseFull);
     const files = await fg("**/*", {
       cwd: root,
       absolute: true,
@@ -15702,8 +15701,8 @@ var FilesystemBackend = class {
         if (includeGlob && !micromatch2.isMatch(path2.basename(fp), includeGlob)) {
           continue;
         }
-        const stat4 = await fs2.stat(fp);
-        if (stat4.size > this.maxFileSizeBytes) {
+        const stat5 = await fs2.stat(fp);
+        if (stat5.size > this.maxFileSizeBytes) {
           continue;
         }
         const content = await fs2.readFile(fp, "utf-8");
@@ -15745,8 +15744,8 @@ var FilesystemBackend = class {
     }
     const resolvedSearchPath = searchPath === "/" ? this.cwd : this.resolvePath(searchPath);
     try {
-      const stat3 = await fs2.stat(resolvedSearchPath);
-      if (!stat3.isDirectory()) {
+      const stat4 = await fs2.stat(resolvedSearchPath);
+      if (!stat4.isDirectory()) {
         return [];
       }
     } catch {
@@ -15762,15 +15761,15 @@ var FilesystemBackend = class {
       });
       for (const matchedPath of matches) {
         try {
-          const stat3 = await fs2.stat(matchedPath);
-          if (!stat3.isFile()) continue;
+          const stat4 = await fs2.stat(matchedPath);
+          if (!stat4.isFile()) continue;
           const normalizedPath = matchedPath.split("/").join(path2.sep);
           if (!this.virtualMode) {
             results.push({
               path: normalizedPath,
               is_dir: false,
-              size: stat3.size,
-              modified_at: stat3.mtime.toISOString()
+              size: stat4.size,
+              modified_at: stat4.mtime.toISOString()
             });
           } else {
             const cwdStr = this.cwd.endsWith(path2.sep) ? this.cwd : this.cwd + path2.sep;
@@ -15787,8 +15786,8 @@ var FilesystemBackend = class {
             results.push({
               path: virt,
               is_dir: false,
-              size: stat3.size,
-              modified_at: stat3.mtime.toISOString()
+              size: stat4.size,
+              modified_at: stat4.mtime.toISOString()
             });
           }
         } catch {
@@ -15835,10 +15834,10 @@ var CompositeBackend = class {
    * @returns List of FileInfo objects with route prefixes added, for files and directories
    *          directly in the directory. Directories have a trailing / in their path and is_dir=true.
    */
-  async lsInfo(path3) {
+  async lsInfo(path5) {
     for (const [routePrefix, backend] of this.sortedRoutes) {
-      if (path3.startsWith(routePrefix.replace(/\/$/, ""))) {
-        const suffix = path3.substring(routePrefix.length);
+      if (path5.startsWith(routePrefix.replace(/\/$/, ""))) {
+        const suffix = path5.substring(routePrefix.length);
         const searchPath = suffix ? "/" + suffix : "/";
         const infos = await backend.lsInfo(searchPath);
         const prefixed = [];
@@ -15851,9 +15850,9 @@ var CompositeBackend = class {
         return prefixed;
       }
     }
-    if (path3 === "/") {
+    if (path5 === "/") {
       const results = [];
-      const defaultInfos = await this.default.lsInfo(path3);
+      const defaultInfos = await this.default.lsInfo(path5);
       results.push(...defaultInfos);
       for (const [routePrefix] of this.sortedRoutes) {
         results.push({
@@ -15866,7 +15865,7 @@ var CompositeBackend = class {
       results.sort((a, b) => a.path.localeCompare(b.path));
       return results;
     }
-    return await this.default.lsInfo(path3);
+    return await this.default.lsInfo(path5);
   }
   /**
    * Read file content, routing to appropriate backend.
@@ -15893,10 +15892,10 @@ var CompositeBackend = class {
   /**
    * Structured search results or error string for invalid input.
    */
-  async grepRaw(pattern, path3 = "/", glob = null) {
+  async grepRaw(pattern, path5 = "/", glob = null) {
     for (const [routePrefix, backend] of this.sortedRoutes) {
-      if (path3.startsWith(routePrefix.replace(/\/$/, ""))) {
-        const searchPath = path3.substring(routePrefix.length - 1);
+      if (path5.startsWith(routePrefix.replace(/\/$/, ""))) {
+        const searchPath = path5.substring(routePrefix.length - 1);
         const raw = await backend.grepRaw(pattern, searchPath || "/", glob);
         if (typeof raw === "string") {
           return raw;
@@ -15908,7 +15907,7 @@ var CompositeBackend = class {
       }
     }
     const allMatches = [];
-    const rawDefault = await this.default.grepRaw(pattern, path3, glob);
+    const rawDefault = await this.default.grepRaw(pattern, path5, glob);
     if (typeof rawDefault === "string") {
       return rawDefault;
     }
@@ -15930,11 +15929,11 @@ var CompositeBackend = class {
   /**
    * Structured glob matching returning FileInfo objects.
    */
-  async globInfo(pattern, path3 = "/") {
+  async globInfo(pattern, path5 = "/") {
     const results = [];
     for (const [routePrefix, backend] of this.sortedRoutes) {
-      if (path3.startsWith(routePrefix.replace(/\/$/, ""))) {
-        const searchPath = path3.substring(routePrefix.length - 1);
+      if (path5.startsWith(routePrefix.replace(/\/$/, ""))) {
+        const searchPath = path5.substring(routePrefix.length - 1);
         const infos = await backend.globInfo(pattern, searchPath || "/");
         return infos.map((fi) => ({
           ...fi,
@@ -15942,7 +15941,7 @@ var CompositeBackend = class {
         }));
       }
     }
-    const defaultInfos = await this.default.globInfo(pattern, path3);
+    const defaultInfos = await this.default.globInfo(pattern, path5);
     results.push(...defaultInfos);
     for (const [routePrefix, backend] of Object.entries(this.routes)) {
       const infos = await backend.globInfo(pattern, "/");
@@ -15990,11 +15989,11 @@ var MemoryBackend = class {
   getFiles() {
     return Object.fromEntries(this.files);
   }
-  lsInfo(path3) {
+  lsInfo(path5) {
     const files = this.getFiles();
     const infos = [];
     const subdirs = /* @__PURE__ */ new Set();
-    const normalizedPath = path3.endsWith("/") ? path3 : path3 + "/";
+    const normalizedPath = path5.endsWith("/") ? path5 : path5 + "/";
     for (const [k, fd] of Object.entries(files)) {
       if (!k.startsWith(normalizedPath)) {
         continue;
@@ -16069,13 +16068,13 @@ var MemoryBackend = class {
     this.files.set(filePath, newFileData);
     return { path: filePath, filesUpdate: null, occurrences };
   }
-  grepRaw(pattern, path3 = "/", glob = null) {
+  grepRaw(pattern, path5 = "/", glob = null) {
     const files = this.getFiles();
-    return grepMatchesFromFiles(files, pattern, path3, glob);
+    return grepMatchesFromFiles(files, pattern, path5, glob);
   }
-  globInfo(pattern, path3 = "/") {
+  globInfo(pattern, path5 = "/") {
     const files = this.getFiles();
-    const result = globSearchFiles(files, pattern, path3);
+    const result = globSearchFiles(files, pattern, path5);
     if (result === "No files found") {
       return [];
     }
@@ -17118,16 +17117,16 @@ function createTeammateTools(options) {
           update: { team_mailbox: relevantMsgs2, messages: [toolMessage2] }
         });
       }
-      const messagePromise = new Promise((resolve3) => {
+      const messagePromise = new Promise((resolve4) => {
         const handler = async (msg) => {
           mailboxStore.offMessage(teamId, agentId, handler);
           const allMsgs = await mailboxStore.getUnreadMessages(teamId, agentId);
-          resolve3(allMsgs);
+          resolve4(allMsgs);
         };
         mailboxStore.onMessage(teamId, agentId, handler);
       });
-      const timeoutPromise = new Promise((resolve3) => {
-        setTimeout(() => resolve3([]), READ_MESSAGES_TIMEOUT_MS2);
+      const timeoutPromise = new Promise((resolve4) => {
+        setTimeout(() => resolve4([]), READ_MESSAGES_TIMEOUT_MS2);
       });
       msgs = await Promise.race([messagePromise, timeoutPromise]);
       mailboxStore.offMessage(teamId, agentId, () => {
@@ -17859,19 +17858,19 @@ Task Status Values:
           update: { team_mailbox: allTeamMessages2, messages: [toolMessage2] }
         });
       }
-      const messagePromise = new Promise((resolve3) => {
+      const messagePromise = new Promise((resolve4) => {
         const handler = async (msg) => {
           mailboxStore.offMessage(teamId, TEAM_LEAD_AGENT_ID, handler);
           const allMsgs = await mailboxStore.getUnreadMessages(
             teamId,
             TEAM_LEAD_AGENT_ID
           );
-          resolve3(allMsgs);
+          resolve4(allMsgs);
         };
         mailboxStore.onMessage(teamId, TEAM_LEAD_AGENT_ID, handler);
       });
-      const timeoutPromise = new Promise((resolve3) => {
-        setTimeout(() => resolve3([]), READ_MESSAGES_TIMEOUT_MS);
+      const timeoutPromise = new Promise((resolve4) => {
+        setTimeout(() => resolve4([]), READ_MESSAGES_TIMEOUT_MS);
       });
       msgs = await Promise.race([messagePromise, timeoutPromise]);
       mailboxStore.offMessage(
@@ -22344,10 +22343,10 @@ var MicrosandboxRemoteInstance = class {
           content
         );
       },
-      listPath: async (path3, options) => {
+      listPath: async (path5, options) => {
         const result = await this.client.listPath(
           this.name,
-          normalizeExternalSandboxPath(path3),
+          normalizeExternalSandboxPath(path5),
           options?.recursive
         );
         const files = result.entries.map((entry) => ({
@@ -22356,10 +22355,10 @@ var MicrosandboxRemoteInstance = class {
         }));
         return { files };
       },
-      findFiles: async (path3, glob) => {
+      findFiles: async (path5, glob) => {
         const result = await this.client.findFiles(
           this.name,
-          normalizeExternalSandboxPath(path3),
+          normalizeExternalSandboxPath(path5),
           glob
         );
         return {
@@ -22401,15 +22400,15 @@ var MicrosandboxRemoteInstance = class {
         }
         return Buffer.from(result.content ?? "");
       },
-      deletePath: async (path3) => {
-        const resolved = normalizeExternalSandboxPath(path3);
+      deletePath: async (path5) => {
+        const resolved = normalizeExternalSandboxPath(path5);
         await this.client.execCommand({
           sandboxName: this.name,
           command: `rm -rf "${resolved}"`
         });
       },
-      createDirectory: async (path3) => {
-        const resolved = normalizeExternalSandboxPath(path3);
+      createDirectory: async (path5) => {
+        const resolved = normalizeExternalSandboxPath(path5);
         await this.client.execCommand({
           sandboxName: this.name,
           command: `mkdir -p "${resolved}"`
@@ -22457,13 +22456,18 @@ var MicrosandboxServiceClient = class {
     this.apiKey = config.apiKey;
   }
   async ensureSandbox(name, input) {
+    const tStart = Date.now();
     console.log(
-      `[MicrosandboxClient] ensureSandbox name=${name} image=${input.image ?? "not set"} envKeys=${Object.keys(input.env ?? {}).join(",") || "none"}`
+      `[MicrosandboxClient] ensureSandbox START name=${name} image=${input.image ?? "not set"} envKeys=${Object.keys(input.env ?? {}).join(",") || "none"}`
     );
-    return this.request(`/api/sandboxes/${encodeURIComponent(name)}`, {
+    const result = await this.request(`/api/sandboxes/${encodeURIComponent(name)}`, {
       method: "PUT",
       body: input
     });
+    console.log(
+      `[MicrosandboxClient] ensureSandbox DONE name=${name} status=${result.status} elapsed=${Date.now() - tStart}ms`
+    );
+    return result;
   }
   async startSandbox(name) {
     return this.request(`/api/sandboxes/${encodeURIComponent(name)}/start`, {
@@ -22490,34 +22494,34 @@ var MicrosandboxServiceClient = class {
       method: "GET"
     });
   }
-  async readFile(sandboxName, path3) {
+  async readFile(sandboxName, path5) {
     return this.request("/api/files/read", {
       method: "POST",
-      body: { sandboxName, path: path3 }
+      body: { sandboxName, path: path5 }
     });
   }
-  async writeFile(sandboxName, path3, content) {
+  async writeFile(sandboxName, path5, content) {
     return this.request("/api/files/write", {
       method: "POST",
-      body: { sandboxName, path: path3, content }
+      body: { sandboxName, path: path5, content }
     });
   }
-  async listPath(sandboxName, path3, recursive) {
+  async listPath(sandboxName, path5, recursive) {
     return this.request("/api/files/list", {
       method: "POST",
-      body: { sandboxName, path: path3, recursive }
+      body: { sandboxName, path: path5, recursive }
     });
   }
-  async findFiles(sandboxName, path3, pattern) {
+  async findFiles(sandboxName, path5, pattern) {
     return this.request("/api/files/find", {
       method: "POST",
-      body: { sandboxName, path: path3, pattern }
+      body: { sandboxName, path: path5, pattern }
     });
   }
-  async searchInFile(sandboxName, path3, query) {
+  async searchInFile(sandboxName, path5, query) {
     return this.request("/api/files/search", {
       method: "POST",
-      body: { sandboxName, path: path3, query }
+      body: { sandboxName, path: path5, query }
     });
   }
   async replaceInFile(sandboxName, input) {
@@ -22526,14 +22530,14 @@ var MicrosandboxServiceClient = class {
       body: { sandboxName, ...input }
     });
   }
-  async uploadFile(sandboxName, path3, content) {
+  async uploadFile(sandboxName, path5, content) {
     return this.request("/api/files/upload", {
       method: "POST",
-      body: { sandboxName, path: path3, contentBase64: content.toString("base64") }
+      body: { sandboxName, path: path5, contentBase64: content.toString("base64") }
     });
   }
-  async downloadFile(sandboxName, path3) {
-    const query = new URLSearchParams({ sandboxName, path: path3 });
+  async downloadFile(sandboxName, path5) {
+    const query = new URLSearchParams({ sandboxName, path: path5 });
     return this.request(`/api/files/download?${query.toString()}`, {
       method: "GET"
     });
@@ -22544,32 +22548,32 @@ var MicrosandboxServiceClient = class {
       body: input
     });
   }
-  async volumeFsRead(volumeName, path3) {
+  async volumeFsRead(volumeName, path5) {
     const result = await this.request(
       `/api/volumes/${encodeURIComponent(volumeName)}/fs/read`,
       {
         method: "POST",
-        body: { path: path3 }
+        body: { path: path5 }
       }
     );
     return result.content;
   }
-  async volumeFsWrite(volumeName, path3, content) {
+  async volumeFsWrite(volumeName, path5, content) {
     await this.request(
       `/api/volumes/${encodeURIComponent(volumeName)}/fs/write`,
       {
         method: "POST",
-        body: { path: path3, content }
+        body: { path: path5, content }
       }
     );
   }
-  async volumeFsList(volumeName, path3) {
-    console.log(`[volumeFsList] volume=${volumeName} path="${path3}" url=POST /api/volumes/${encodeURIComponent(volumeName)}/fs/list`);
+  async volumeFsList(volumeName, path5) {
+    console.log(`[volumeFsList] volume=${volumeName} path="${path5}" url=POST /api/volumes/${encodeURIComponent(volumeName)}/fs/list`);
     const result = await this.request(
       `/api/volumes/${encodeURIComponent(volumeName)}/fs/list`,
       {
         method: "POST",
-        body: { path: path3 }
+        body: { path: path5 }
       }
     );
     console.log(
@@ -22578,25 +22582,25 @@ var MicrosandboxServiceClient = class {
     );
     return result.entries;
   }
-  async volumeFsDownload(volumeName, path3) {
+  async volumeFsDownload(volumeName, path5) {
     const result = await this.request(
-      `/api/volumes/${encodeURIComponent(volumeName)}/fs/download?path=${encodeURIComponent(path3)}`,
+      `/api/volumes/${encodeURIComponent(volumeName)}/fs/download?path=${encodeURIComponent(path5)}`,
       {
         method: "GET"
       }
     );
     return Buffer.from(result.contentBase64, "base64");
   }
-  async volumeFsUpload(volumeName, path3, data) {
+  async volumeFsUpload(volumeName, path5, data) {
     await this.request(
       `/api/volumes/${encodeURIComponent(volumeName)}/fs/upload`,
       {
         method: "POST",
-        body: { path: path3, contentBase64: data.toString("base64") }
+        body: { path: path5, contentBase64: data.toString("base64") }
       }
     );
   }
-  async request(path3, init) {
+  async request(path5, init) {
     const headers = {};
     if (init.body) {
       headers["content-type"] = "application/json";
@@ -22604,7 +22608,7 @@ var MicrosandboxServiceClient = class {
     if (this.apiKey) {
       headers.Authorization = `Bearer ${this.apiKey}`;
     }
-    const response = await fetch(`${this.baseURL}${path3}`, {
+    const response = await fetch(`${this.baseURL}${path5}`, {
       method: init.method,
       headers: Object.keys(headers).length > 0 ? headers : void 0,
       body: init.body ? JSON.stringify(init.body) : void 0
@@ -22655,16 +22659,21 @@ var MicrosandboxRemoteProvider = class {
     });
   }
   async createSandbox(name, config) {
-    const existing = this.instances.get(name);
-    if (existing) {
-      return existing;
-    }
     const inFlight = this.creating.get(name);
     if (inFlight) {
       return inFlight;
     }
+    const existing = this.instances.get(name);
+    if (existing) {
+      console.log(`[MicrosandboxRemote] createSandbox name=${name} INSTANCE_CACHE_HIT`);
+      return existing;
+    }
     const creation = (async () => {
-      await this.client.ensureSandbox(name, this.buildEnsureInput(config));
+      const tStart = Date.now();
+      const input = this.buildEnsureInput(config);
+      console.log(`[MicrosandboxRemote] createSandbox name=${name} calling ensureSandbox...`);
+      await this.client.ensureSandbox(name, input);
+      console.log(`[MicrosandboxRemote] createSandbox DONE name=${name} elapsed=${Date.now() - tStart}ms`);
       const instance = new MicrosandboxRemoteInstance(name, this.client);
       this.instances.set(name, instance);
       return instance;
@@ -22700,11 +22709,11 @@ var MicrosandboxRemoteProvider = class {
   }
   createVolumeFsClient(volumeName, _pathPrefix) {
     return {
-      read: (path3) => this.client.volumeFsRead(volumeName, path3),
-      write: (path3, content) => this.client.volumeFsWrite(volumeName, path3, content),
-      list: (path3) => this.client.volumeFsList(volumeName, path3),
-      readRaw: (path3) => this.client.volumeFsDownload(volumeName, path3),
-      writeRaw: (path3, data) => this.client.volumeFsUpload(volumeName, path3, data)
+      read: (path5) => this.client.volumeFsRead(volumeName, path5),
+      write: (path5, content) => this.client.volumeFsWrite(volumeName, path5, content),
+      list: (path5) => this.client.volumeFsList(volumeName, path5),
+      readRaw: (path5) => this.client.volumeFsDownload(volumeName, path5),
+      writeRaw: (path5, data) => this.client.volumeFsUpload(volumeName, path5, data)
     };
   }
   async listSandboxes() {
@@ -22803,8 +22812,8 @@ var RemoteSandboxInstance = class {
           throw new Error(`writeFile failed: ${extractFetcherError(result.error)}`);
         }
       },
-      listPath: async (path3, options) => {
-        const resolved = this.resolvePath(path3);
+      listPath: async (path5, options) => {
+        const resolved = this.resolvePath(path5);
         const result = await this.client.file.listPath({
           path: resolved,
           recursive: options?.recursive ?? false
@@ -22820,8 +22829,8 @@ var RemoteSandboxInstance = class {
         }));
         return { files };
       },
-      findFiles: async (path3, glob) => {
-        const resolved = this.resolvePath(path3);
+      findFiles: async (path5, glob) => {
+        const resolved = this.resolvePath(path5);
         const result = await this.client.file.findFiles({ path: resolved, glob });
         if (!result.ok) {
           throw new Error(`findFiles failed: ${extractFetcherError(result.error)}`);
@@ -22871,8 +22880,8 @@ var RemoteSandboxInstance = class {
         const buffer2 = await result.body.arrayBuffer();
         return Buffer.from(buffer2);
       },
-      deletePath: async (path3) => {
-        const resolved = this.resolvePath(path3);
+      deletePath: async (path5) => {
+        const resolved = this.resolvePath(path5);
         const result = await this.client.shell.execCommand({
           command: `rm -rf "${resolved}"`
         });
@@ -22880,8 +22889,8 @@ var RemoteSandboxInstance = class {
           throw new Error(`deletePath failed: ${extractFetcherError(result.error)}`);
         }
       },
-      createDirectory: async (path3) => {
-        const resolved = this.resolvePath(path3);
+      createDirectory: async (path5) => {
+        const resolved = this.resolvePath(path5);
         const result = await this.client.shell.execCommand({
           command: `mkdir -p "${resolved}"`
         });
@@ -23008,7 +23017,7 @@ var RemoteSandboxProvider = class {
   }
   createVolumeFsClient(_volumeName, pathPrefix) {
     const workspace = this.workspace;
-    const resolve3 = (p) => {
+    const resolve4 = (p) => {
       if (!p || p === "/") {
         if (pathPrefix) {
           return `${workspace}${pathPrefix}`;
@@ -23028,23 +23037,23 @@ var RemoteSandboxProvider = class {
       return `${workspace}/${p}`;
     };
     return {
-      read: async (path3) => {
-        const resolved = resolve3(path3);
+      read: async (path5) => {
+        const resolved = resolve4(path5);
         const result = await this.client.file.readFile({ file: resolved });
         if (!result.ok) {
           throw new Error(`Volume read failed: ${extractFetcherError(result.error)}`);
         }
         return result.body.data?.content ?? "";
       },
-      write: async (path3, content) => {
-        const resolved = resolve3(path3);
+      write: async (path5, content) => {
+        const resolved = resolve4(path5);
         const result = await this.client.file.writeFile({ file: resolved, content });
         if (!result.ok) {
           throw new Error(`Volume write failed: ${extractFetcherError(result.error)}`);
         }
       },
-      list: async (path3) => {
-        const resolved = resolve3(path3);
+      list: async (path5) => {
+        const resolved = resolve4(path5);
         const result = await this.client.file.listPath({
           path: resolved,
           recursive: false
@@ -23061,8 +23070,8 @@ var RemoteSandboxProvider = class {
         }));
         return entries;
       },
-      readRaw: async (path3) => {
-        const resolved = resolve3(path3);
+      readRaw: async (path5) => {
+        const resolved = resolve4(path5);
         const result = await this.client.file.downloadFile({ path: resolved });
         if (!result.ok) {
           throw new Error(`Volume download failed: ${extractFetcherError(result.error)}`);
@@ -23070,8 +23079,8 @@ var RemoteSandboxProvider = class {
         const buffer2 = await result.body.arrayBuffer();
         return Buffer.from(buffer2);
       },
-      writeRaw: async (path3, data) => {
-        const resolved = resolve3(path3);
+      writeRaw: async (path5, data) => {
+        const resolved = resolve4(path5);
         const result = await this.client.file.uploadFile({
           file: data,
           path: resolved
@@ -23099,8 +23108,8 @@ var E2BInstance = class {
       writeFile: async (file, content) => {
         await this.native.files.write(file, content);
       },
-      listPath: async (path3, options) => {
-        const entries = await this.native.files.list(path3);
+      listPath: async (path5, options) => {
+        const entries = await this.native.files.list(path5);
         const files = entries.map((e) => ({
           path: e.path,
           is_dir: e.type === "dir",
@@ -23109,9 +23118,9 @@ var E2BInstance = class {
         }));
         return { files };
       },
-      findFiles: async (path3, glob) => {
+      findFiles: async (path5, glob) => {
         const result = await this.native.commands.run(
-          `find "${path3}" -name "${glob}" -type f`
+          `find "${path5}" -name "${glob}" -type f`
         );
         const lines = result.stdout.split("\n").filter(Boolean);
         return { files: lines };
@@ -23134,13 +23143,13 @@ var E2BInstance = class {
         return { matches, line_numbers };
       },
       strReplaceEditor: async (params) => {
-        const { path: path3, old_str, new_str, replace_mode } = params;
+        const { path: path5, old_str, new_str, replace_mode } = params;
         const delim = "#";
         const escapedOld = old_str.replace(new RegExp(`[\\\\${delim}]`, "g"), "\\$&").replace(/\n/g, "\\n");
         const escapedNew = new_str.replace(new RegExp(`[\\\\${delim}]`, "g"), "\\$&").replace(/\n/g, "\\n");
         const flag = replace_mode === "ALL" ? "g" : "";
         await this.native.commands.run(
-          `sed -i 's${delim}${escapedOld}${delim}${escapedNew}${delim}${flag}' "${path3}"`
+          `sed -i 's${delim}${escapedOld}${delim}${escapedNew}${delim}${flag}' "${path5}"`
         );
       },
       uploadFile: async (params) => {
@@ -23152,11 +23161,11 @@ var E2BInstance = class {
         const data = await this.native.files.read(params.file, { format: "bytes" });
         return Buffer.isBuffer(data) ? data : Buffer.from(data);
       },
-      deletePath: async (path3) => {
-        await this.native.commands.run(`rm -rf "${path3}"`);
+      deletePath: async (path5) => {
+        await this.native.commands.run(`rm -rf "${path5}"`);
       },
-      createDirectory: async (path3) => {
-        await this.native.commands.run(`mkdir -p "${path3}"`);
+      createDirectory: async (path5) => {
+        await this.native.commands.run(`mkdir -p "${path5}"`);
       }
     };
     this.shell = {
@@ -23275,8 +23284,8 @@ var DaytonaInstance = class {
       writeFile: async (file, content) => {
         await this.native.fs.uploadFile(Buffer.from(content, "utf-8"), toRelativePath(file));
       },
-      listPath: async (path3, options) => {
-        const entries = await this.native.fs.listFiles(toRelativePath(path3));
+      listPath: async (path5, options) => {
+        const entries = await this.native.fs.listFiles(toRelativePath(path5));
         const files = entries.map((e) => {
           const rawPath = e.name || "";
           return {
@@ -23288,8 +23297,8 @@ var DaytonaInstance = class {
         });
         return { files };
       },
-      findFiles: async (path3, glob) => {
-        const result = await this.native.fs.searchFiles(toRelativePath(path3), glob);
+      findFiles: async (path5, glob) => {
+        const result = await this.native.fs.searchFiles(toRelativePath(path5), glob);
         return { files: (result.files || []).map((filePath) => normalizeExternalSandboxPath(filePath)) };
       },
       searchInFile: async (file, regex) => {
@@ -23303,8 +23312,8 @@ var DaytonaInstance = class {
         return { matches: matchTexts, line_numbers };
       },
       strReplaceEditor: async (params) => {
-        const { path: path3, old_str, new_str, replace_mode } = params;
-        const relPath = toRelativePath(path3);
+        const { path: path5, old_str, new_str, replace_mode } = params;
+        const relPath = toRelativePath(path5);
         if (replace_mode === "ALL") {
           await this.native.fs.replaceInFiles([relPath], old_str, new_str);
         } else {
@@ -23324,11 +23333,11 @@ var DaytonaInstance = class {
         const buffer2 = await this.native.fs.downloadFile(toRelativePath(params.file));
         return Buffer.isBuffer(buffer2) ? buffer2 : Buffer.from(buffer2);
       },
-      deletePath: async (path3) => {
-        await this.native.process.executeCommand(`rm -rf "${toRelativePath(path3)}"`, void 0, void 0);
+      deletePath: async (path5) => {
+        await this.native.process.executeCommand(`rm -rf "${toRelativePath(path5)}"`, void 0, void 0);
       },
-      createDirectory: async (path3) => {
-        await this.native.process.executeCommand(`mkdir -p "${toRelativePath(path3)}"`, void 0, void 0);
+      createDirectory: async (path5) => {
+        await this.native.process.executeCommand(`mkdir -p "${toRelativePath(path5)}"`, void 0, void 0);
       }
     };
     this.shell = {
@@ -23567,6 +23576,277 @@ var DaytonaProvider = class {
   }
 };
 
+// src/sandbox_lattice/providers/LocalSandboxProvider.ts
+import * as path4 from "path";
+import * as os from "os";
+
+// src/sandbox_lattice/LocalSandboxInstance.ts
+import { execFile } from "child_process";
+import * as fs3 from "fs/promises";
+import * as path3 from "path";
+import * as posix from "path/posix";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var isWin = process.platform === "win32";
+var LocalSandboxInstance = class {
+  constructor(name, rootDir) {
+    this.file = {
+      readFile: async (file) => {
+        const content = await fs3.readFile(this.hostPath(file), "utf-8");
+        return { content };
+      },
+      writeFile: async (file, content) => {
+        const hp = this.hostPath(file);
+        await fs3.mkdir(path3.dirname(hp), { recursive: true });
+        await fs3.writeFile(hp, content, "utf-8");
+      },
+      listPath: async (targetPath, options) => {
+        const hp = this.hostPath(targetPath);
+        const files = [];
+        if (options?.recursive) {
+          await this.walkDir(hp, targetPath, files);
+        } else {
+          const entries = await fs3.readdir(hp, { withFileTypes: true });
+          for (const e of entries) {
+            const full = path3.join(hp, e.name);
+            const stat4 = await fs3.stat(full).catch(() => null);
+            files.push({
+              path: posix.join(targetPath, e.name),
+              is_dir: e.isDirectory(),
+              size: stat4?.size ?? 0,
+              modified_at: stat4?.mtime.toISOString()
+            });
+          }
+        }
+        return { files };
+      },
+      findFiles: async (targetPath, glob) => {
+        const hp = this.hostPath(targetPath);
+        const results = [];
+        const regex = new RegExp(
+          "^" + glob.replace(/\*+/g, "(.*)").replace(/\?/g, ".") + "$"
+        );
+        await this.walkDirFilter(hp, regex, results);
+        const hpNorm = hp + path3.sep;
+        const toSandboxPath = (hostPath) => posix.join(targetPath, hostPath.slice(hpNorm.length).split(path3.sep).join("/"));
+        return { files: results.map(toSandboxPath) };
+      },
+      searchInFile: async (file, regex) => {
+        const content = await fs3.readFile(this.hostPath(file), "utf-8");
+        const lines = content.split("\n");
+        const matches = [];
+        const line_numbers = [];
+        try {
+          const re = new RegExp(regex);
+          for (let i = 0; i < lines.length; i++) {
+            if (re.test(lines[i])) {
+              matches.push(lines[i]);
+              line_numbers.push(i + 1);
+            }
+          }
+        } catch {
+        }
+        return { matches, line_numbers };
+      },
+      strReplaceEditor: async (params) => {
+        const content = await fs3.readFile(this.hostPath(params.path), "utf-8");
+        let result;
+        if (params.replace_mode === "ALL") {
+          result = content.split(params.old_str).join(params.new_str);
+        } else {
+          const idx = content.indexOf(params.old_str);
+          if (idx === -1) {
+            throw new Error(`Old string not found in ${params.path}`);
+          }
+          result = content.slice(0, idx) + params.new_str + content.slice(idx + params.old_str.length);
+        }
+        await fs3.writeFile(this.hostPath(params.path), result, "utf-8");
+      },
+      uploadFile: async (params) => {
+        const hp = this.hostPath(params.file);
+        await fs3.mkdir(path3.dirname(hp), { recursive: true });
+        await fs3.writeFile(hp, params.data);
+      },
+      downloadFile: async (params) => {
+        const data = await fs3.readFile(this.hostPath(params.file));
+        return data;
+      },
+      deletePath: async (targetPath) => {
+        await fs3.rm(this.hostPath(targetPath), { recursive: true, force: true });
+      },
+      createDirectory: async (targetPath) => {
+        await fs3.mkdir(this.hostPath(targetPath), { recursive: true });
+      }
+    };
+    this.shell = {
+      execCommand: async (params) => {
+        const hp = params.exec_dir ? this.hostPath(params.exec_dir) : this.rootDir;
+        const timeoutMs = params.timeout ? params.timeout * 1e3 : void 0;
+        const [shell, shellArg] = isWin ? ["cmd.exe", "/c"] : ["/bin/sh", "-c"];
+        try {
+          const { stdout, stderr } = await execFileAsync(
+            shell,
+            [shellArg, params.command],
+            {
+              cwd: hp,
+              timeout: timeoutMs,
+              maxBuffer: 10 * 1024 * 1024,
+              // 10MB
+              env: { ...process.env, HOME: this.rootDir }
+            }
+          );
+          const output = stderr ? `${stdout}
+${stderr}`.trim() : stdout.trim();
+          return { output, exit_code: 0 };
+        } catch (err) {
+          const execErr = err;
+          const out = execErr.stdout ?? "";
+          const errOut = execErr.stderr ?? "";
+          const output = errOut ? `${out}
+${errOut}`.trim() : out.trim();
+          return { output, exit_code: execErr.code ?? 1 };
+        }
+      }
+    };
+    this.name = name;
+    this.rootDir = rootDir;
+  }
+  /** Map sandbox path (absolute, e.g. `/root/foo`) to host filesystem path. */
+  hostPath(sandboxPath) {
+    const normalized = sandboxPath.startsWith("/") ? sandboxPath : `/${sandboxPath}`;
+    const clean = normalized.replace(/\/+/g, "/");
+    const resolved = path3.resolve(this.rootDir, `.${clean}`);
+    if (!resolved.startsWith(this.rootDir + path3.sep) && resolved !== this.rootDir) {
+      throw new Error(`Path traversal denied: ${sandboxPath}`);
+    }
+    return resolved;
+  }
+  async start() {
+    await fs3.mkdir(this.rootDir, { recursive: true });
+  }
+  async stop() {
+  }
+  async kill() {
+    await fs3.rm(this.rootDir, { recursive: true, force: true });
+  }
+  async getStatus() {
+    try {
+      await fs3.access(this.rootDir);
+      return "running";
+    } catch {
+      return "stopped";
+    }
+  }
+  async walkDir(rootHost, sandboxPrefix, result) {
+    const walk = async (hostDir, sandboxDir) => {
+      let entries;
+      try {
+        entries = await fs3.readdir(hostDir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      for (const e of entries) {
+        const fullHost = path3.join(hostDir, e.name);
+        const fullSandbox = posix.join(sandboxDir, e.name);
+        try {
+          const stat4 = await fs3.stat(fullHost);
+          result.push({
+            path: fullSandbox,
+            is_dir: e.isDirectory(),
+            size: stat4.size,
+            modified_at: stat4.mtime.toISOString()
+          });
+        } catch {
+          result.push({
+            path: fullSandbox,
+            is_dir: e.isDirectory()
+          });
+        }
+        if (e.isDirectory()) {
+          await walk(fullHost, fullSandbox);
+        }
+      }
+    };
+    await walk(rootHost, sandboxPrefix);
+  }
+  async walkDirFilter(dir, regex, result) {
+    let entries;
+    try {
+      entries = await fs3.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      const full = path3.join(dir, e.name);
+      if (e.isFile() && regex.test(e.name)) {
+        result.push(full);
+      }
+      if (e.isDirectory()) {
+        await this.walkDirFilter(full, regex, result);
+      }
+    }
+  }
+};
+
+// src/sandbox_lattice/providers/LocalSandboxProvider.ts
+var LocalSandboxProvider = class {
+  constructor(config = {}) {
+    this.instances = /* @__PURE__ */ new Map();
+    this.creating = /* @__PURE__ */ new Map();
+    this.basePath = config.basePath ?? path4.join(os.homedir(), ".axiom-local-sandbox");
+  }
+  async createSandbox(name, _config) {
+    const existing = this.instances.get(name);
+    if (existing) {
+      const running = await existing.getStatus();
+      if (running === "running") {
+        return existing;
+      }
+      this.instances.delete(name);
+    }
+    const inFlight = this.creating.get(name);
+    if (inFlight) {
+      return inFlight;
+    }
+    const sandboxDir = path4.join(this.basePath, name);
+    const creation = (async () => {
+      const instance = new LocalSandboxInstance(name, sandboxDir);
+      await instance.start();
+      this.instances.set(name, instance);
+      return instance;
+    })();
+    this.creating.set(name, creation);
+    creation.catch(() => this.instances.delete(name)).finally(() => this.creating.delete(name));
+    return creation;
+  }
+  async getSandbox(name) {
+    const instance = this.instances.get(name);
+    if (!instance) {
+      throw new Error(`Sandbox ${name} not found`);
+    }
+    return instance;
+  }
+  async stopSandbox(name) {
+    const instance = this.instances.get(name);
+    if (instance) {
+      try {
+        await instance.stop();
+      } catch {
+      }
+    }
+  }
+  async deleteSandbox(name) {
+    const instance = this.instances.get(name);
+    this.instances.delete(name);
+    if (instance) {
+      await instance.kill();
+    }
+  }
+  async listSandboxes() {
+    return Array.from(this.instances.values());
+  }
+};
+
 // src/sandbox_lattice/SandboxProviderFactory.ts
 function createSandboxProvider(config) {
   switch (config.type) {
@@ -23611,6 +23891,9 @@ function createSandboxProvider(config) {
         volumeName: config.daytonaVolumeName
       });
     }
+    case "local": {
+      return new LocalSandboxProvider({ basePath: config.localSandboxBasePath });
+    }
     default: {
       const exhaustiveCheck = config.type;
       throw new Error(`Unknown sandbox provider type: ${exhaustiveCheck}`);
@@ -23901,6 +24184,8 @@ export {
   InMemoryUserStore,
   InMemoryUserTenantLinkStore,
   LINE_NUMBER_WIDTH,
+  LocalSandboxInstance,
+  LocalSandboxProvider,
   LoggerLatticeManager,
   MAX_LINE_LENGTH,
   McpLatticeManager,