@ash-cloud/ash-ai 0.1.8 → 0.1.10

package/dist/index.cjs

@@ -4,10 +4,11 @@ var zod = require('zod');
 var child_process = require('child_process');
 var nanoid = require('nanoid');
 var fs = require('fs/promises');
-var path3 = require('path');
+var path4 = require('path');
 var stream = require('stream');
+var chokidar = require('chokidar');
 var crypto = require('crypto');
-var fs9 = require('fs');
+var fs10 = require('fs');
 var hono = require('hono');
 var streaming = require('hono/streaming');
 var cors = require('hono/cors');
@@ -46,8 +47,9 @@ function _interopNamespace(e) {
 }
 
 var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
-var path3__namespace = /*#__PURE__*/_interopNamespace(path3);
-var fs9__namespace = /*#__PURE__*/_interopNamespace(fs9);
+var path4__namespace = /*#__PURE__*/_interopNamespace(path4);
+var chokidar__default = /*#__PURE__*/_interopDefault(chokidar);
+var fs10__namespace = /*#__PURE__*/_interopNamespace(fs10);
 var os__namespace = /*#__PURE__*/_interopNamespace(os);
 var postgres__default = /*#__PURE__*/_interopDefault(postgres);
 
@@ -105,7 +107,7 @@ var init_normalized = __esm({
   "src/types/normalized.ts"() {
   }
 });
-exports.SessionStatus = void 0; exports.AgentStatus = void 0; exports.MessageRole = void 0; exports.messageContentSchema = void 0; exports.messageSchema = void 0; exports.sessionSchema = void 0; exports.attachmentSchema = void 0; exports.DEFAULT_SANDBOX_PROVIDER_CONFIG = void 0; exports.StreamEventType = void 0; exports.QueueItemStatus = void 0;
+exports.SessionStatus = void 0; exports.AgentStatus = void 0; exports.MessageRole = void 0; exports.messageContentSchema = void 0; exports.messageSchema = void 0; exports.sessionSchema = void 0; exports.attachmentSchema = void 0; exports.DEFAULT_SANDBOX_PROVIDER_CONFIG = void 0; exports.StreamEventType = void 0; exports.QueueItemStatus = void 0; exports.EventCategory = void 0;
 var init_types = __esm({
   "src/types/index.ts"() {
     init_normalized();
@@ -202,6 +204,7 @@ var init_types = __esm({
       SESSION_END: "session_end",
       SESSION_STOPPED: "session_stopped",
       SANDBOX_LOG: "sandbox_log",
+      MCP_STATUS: "mcp_status",
       ERROR: "error"
     };
     exports.QueueItemStatus = {
@@ -211,6 +214,22 @@ var init_types = __esm({
       FAILED: "failed",
       CANCELLED: "cancelled"
     };
+    exports.EventCategory = {
+      LIFECYCLE: "lifecycle",
+      // session_start, session_end, turn_complete
+      CONTENT: "content",
+      // text_stream (aggregated), thinking_stream
+      TOOL: "tool",
+      // tool_use, tool_result
+      SYSTEM: "system",
+      // mcp_status, sandbox_log
+      ERROR: "error",
+      // error events
+      FILE: "file",
+      // file_push, file_pull, file_sync (file sync operations)
+      INPUT: "input"
+      // user_input (user prompts/messages)
+    };
   }
 });
 
@@ -630,7 +649,7 @@ var init_mcp = __esm({
        * @param path Path to the server script
        * @param runtime Runtime to use (node, python, etc.)
        */
-      custom: (path14, runtime = "node", args) => {
+      custom: (path15, runtime = "node", args) => {
         const commands = {
           node: "node",
           python: "python3",
@@ -638,7 +657,7 @@ var init_mcp = __esm({
         };
         return {
           command: commands[runtime] ?? "node",
-          args: runtime === "deno" ? ["run", "-A", path14, ...args ?? []] : [path14, ...args ?? []]
+          args: runtime === "deno" ? ["run", "-A", path15, ...args ?? []] : [path15, ...args ?? []]
         };
       }
     };
@@ -696,8 +715,8 @@ var init_mcp = __esm({
       /**
        * Add a custom stdio MCP server
        */
-      withCustom(name, path14, runtime, args) {
-        return this.add(name, exports.McpServers.custom(path14, runtime, args));
+      withCustom(name, path15, runtime, args) {
+        return this.add(name, exports.McpServers.custom(path15, runtime, args));
       }
       /**
        * Add an HTTP MCP server with typed authentication
@@ -3019,9 +3038,9 @@ var init_attachment = __esm({
           throw new Error(`MIME type ${mimeType} is not allowed`);
         }
         const id = nanoid.nanoid();
-        const ext = path3__namespace.extname(filename) || this.getExtensionForMimeType(mimeType);
+        const ext = path4__namespace.extname(filename) || this.getExtensionForMimeType(mimeType);
         const storageName = `${id}${ext}`;
-        const storagePath = path3__namespace.join(this.config.basePath, storageName);
+        const storagePath = path4__namespace.join(this.config.basePath, storageName);
         await fs__namespace.writeFile(storagePath, content);
         return {
           id,
@@ -3038,8 +3057,8 @@ var init_attachment = __esm({
        */
       async storeFromPath(messageId, sourcePath, mimeType) {
         const content = await fs__namespace.readFile(sourcePath);
-        const filename = path3__namespace.basename(sourcePath);
-        const detectedMimeType = mimeType ?? this.getMimeTypeForExtension(path3__namespace.extname(filename));
+        const filename = path4__namespace.basename(sourcePath);
+        const detectedMimeType = mimeType ?? this.getMimeTypeForExtension(path4__namespace.extname(filename));
         return this.storeFromBuffer(messageId, filename, content, detectedMimeType);
       }
       /**
@@ -3270,8 +3289,8 @@ async function loadConfig(configPath, options = {}) {
   return config;
 }
 async function loadConfigFile(filePath) {
-  const ext = path3__namespace.extname(filePath);
-  const fullPath = path3__namespace.isAbsolute(filePath) ? filePath : path3__namespace.resolve(process.cwd(), filePath);
+  const ext = path4__namespace.extname(filePath);
+  const fullPath = path4__namespace.isAbsolute(filePath) ? filePath : path4__namespace.resolve(process.cwd(), filePath);
   if (ext === ".json") {
     const content = await fs__namespace.readFile(fullPath, "utf-8");
     return JSON.parse(content);
@@ -3284,7 +3303,7 @@ async function loadConfigFile(filePath) {
 }
 async function findAndLoadConfig(directory) {
   for (const fileName of CONFIG_FILE_NAMES) {
-    const filePath = path3__namespace.join(directory, fileName);
+    const filePath = path4__namespace.join(directory, fileName);
     try {
       await fs__namespace.access(filePath);
       return await loadConfigFile(filePath);
@@ -3622,8 +3641,8 @@ var init_modal = __esm({
       }
       async writeFile(_sandboxId, _path, _content) {
       }
-      async readFile(_sandboxId, path14) {
-        return `[Modal] File content from ${path14}`;
+      async readFile(_sandboxId, path15) {
+        return `[Modal] File content from ${path15}`;
       }
       /**
        * Modal-specific: Get GPU information
@@ -3770,12 +3789,12 @@ var init_e2b = __esm({
           throw new SandboxNotFoundError(this.name, sandboxId);
         }
       }
-      async readFile(sandboxId, path14) {
+      async readFile(sandboxId, path15) {
         const sandbox = this.sandboxes.get(sandboxId);
         if (!sandbox) {
           throw new SandboxNotFoundError(this.name, sandboxId);
         }
-        return `[E2B] File content from ${path14}`;
+        return `[E2B] File content from ${path15}`;
       }
       async listFiles(sandboxId, _path) {
         const sandbox = this.sandboxes.get(sandboxId);
@@ -3804,17 +3823,17 @@ var init_e2b = __esm({
        * E2B-specific: Upload a file from local filesystem
        */
       async uploadFile(sandboxId, localPath, remotePath) {
-        const fs14 = await import('fs/promises');
-        const content = await fs14.readFile(localPath);
+        const fs15 = await import('fs/promises');
+        const content = await fs15.readFile(localPath);
         await this.writeFile(sandboxId, remotePath, content);
       }
       /**
        * E2B-specific: Download a file to local filesystem
        */
       async downloadFile(sandboxId, remotePath, localPath) {
-        const fs14 = await import('fs/promises');
+        const fs15 = await import('fs/promises');
         const content = await this.readFile(sandboxId, remotePath);
-        await fs14.writeFile(localPath, content);
+        await fs15.writeFile(localPath, content);
       }
     };
   }
@@ -4068,7 +4087,7 @@ var init_vercel = __esm({
           }
         };
       }
-      async writeFile(sandboxId, path14, content) {
+      async writeFile(sandboxId, path15, content) {
         const instance = this.sandboxes.get(sandboxId);
         if (!instance) {
           throw new SandboxNotFoundError(this.name, sandboxId);
@@ -4078,34 +4097,34 @@ var init_vercel = __esm({
         if (isBase64) {
           await this.executeCommand(
             sandboxId,
-            `echo "${contentStr}" | base64 -d > "${path14}"`
+            `echo "${contentStr}" | base64 -d > "${path15}"`
           );
         } else {
           const escaped = contentStr.replace(/'/g, "'\\''");
-          await this.executeCommand(sandboxId, `cat > "${path14}" << 'VERCEL_EOF'
+          await this.executeCommand(sandboxId, `cat > "${path15}" << 'VERCEL_EOF'
 ${escaped}
 VERCEL_EOF`);
         }
       }
-      async readFile(sandboxId, path14) {
+      async readFile(sandboxId, path15) {
         const instance = this.sandboxes.get(sandboxId);
         if (!instance) {
           throw new SandboxNotFoundError(this.name, sandboxId);
         }
-        const result = await this.executeCommand(sandboxId, `cat "${path14}"`);
+        const result = await this.executeCommand(sandboxId, `cat "${path15}"`);
         if (result.exitCode !== 0) {
-          throw new Error(`Failed to read file ${path14}: ${result.stderr}`);
+          throw new Error(`Failed to read file ${path15}: ${result.stderr}`);
         }
         return result.stdout;
       }
-      async listFiles(sandboxId, path14) {
+      async listFiles(sandboxId, path15) {
         const instance = this.sandboxes.get(sandboxId);
         if (!instance) {
           throw new SandboxNotFoundError(this.name, sandboxId);
         }
         const result = await this.executeCommand(
           sandboxId,
-          `ls -la "${path14}" 2>/dev/null || echo ""`
+          `ls -la "${path15}" 2>/dev/null || echo ""`
         );
         if (result.exitCode !== 0 || !result.stdout.trim()) {
           return [];
@@ -4120,7 +4139,7 @@ VERCEL_EOF`);
             const [, type, , size, , name] = match;
             if (name && name !== "." && name !== ".." && size) {
               files.push({
-                path: `${path14}/${name}`.replace(/\/+/g, "/"),
+                path: `${path15}/${name}`.replace(/\/+/g, "/"),
                 name,
                 size: parseInt(size, 10),
                 isDirectory: type === "d"
@@ -4130,12 +4149,12 @@ VERCEL_EOF`);
         }
         return files;
       }
-      async deleteFile(sandboxId, path14) {
+      async deleteFile(sandboxId, path15) {
         const instance = this.sandboxes.get(sandboxId);
         if (!instance) {
           throw new SandboxNotFoundError(this.name, sandboxId);
         }
-        await this.executeCommand(sandboxId, `rm -rf "${path14}"`);
+        await this.executeCommand(sandboxId, `rm -rf "${path15}"`);
       }
       async getLogs(sandboxId, _options) {
         const instance = this.sandboxes.get(sandboxId);
@@ -5268,7 +5287,7 @@ function isSandboxRunning(sessionId) {
   const cached = sandboxCache.get(sessionId);
   return cached !== void 0 && !cached.isExpired;
 }
-async function writeFileToSandbox(sessionId, path14, content) {
+async function writeFileToSandbox(sessionId, path15, content) {
   const cached = sandboxCache.get(sessionId);
   if (!cached) {
     return { success: false, error: "No active sandbox for session" };
@@ -5278,14 +5297,14 @@ async function writeFileToSandbox(sessionId, path14, content) {
   }
   try {
     const sandbox = cached.sandbox;
-    const dir = path14.substring(0, path14.lastIndexOf("/"));
+    const dir = path15.substring(0, path15.lastIndexOf("/"));
     if (dir) {
       await sandbox.runCommand({ cmd: "mkdir", args: ["-p", dir] });
     }
     const base64Content = content.toString("base64");
     const result = await sandbox.runCommand({
       cmd: "bash",
-      args: ["-c", `echo '${base64Content}' | base64 -d > '${path14}'`]
+      args: ["-c", `echo '${base64Content}' | base64 -d > '${path15}'`]
     });
     if (result.exitCode !== 0) {
       const stderr = await result.stderr();
@@ -5300,7 +5319,7 @@ async function writeFileToSandbox(sessionId, path14, content) {
     };
   }
 }
-async function readFileFromSandbox(sessionId, path14) {
+async function readFileFromSandbox(sessionId, path15) {
   const cached = sandboxCache.get(sessionId);
   if (!cached) {
     return { success: false, error: "No active sandbox for session" };
@@ -5312,14 +5331,14 @@ async function readFileFromSandbox(sessionId, path14) {
     const sandbox = cached.sandbox;
     const checkResult = await sandbox.runCommand({
       cmd: "test",
-      args: ["-f", path14]
+      args: ["-f", path15]
     });
     if (checkResult.exitCode !== 0) {
       return { success: false, error: "File not found" };
     }
     const result = await sandbox.runCommand({
       cmd: "base64",
-      args: [path14]
+      args: [path15]
     });
     if (result.exitCode !== 0) {
       const stderr = await result.stderr();
@@ -5336,7 +5355,7 @@ async function readFileFromSandbox(sessionId, path14) {
     };
   }
 }
-async function listFilesInSandbox(sessionId, path14) {
+async function listFilesInSandbox(sessionId, path15) {
   const cached = sandboxCache.get(sessionId);
   if (!cached) {
     return { success: false, error: "No active sandbox for session" };
@@ -5348,14 +5367,14 @@ async function listFilesInSandbox(sessionId, path14) {
     const sandbox = cached.sandbox;
     const checkResult = await sandbox.runCommand({
       cmd: "test",
-      args: ["-d", path14]
+      args: ["-d", path15]
     });
     if (checkResult.exitCode !== 0) {
       return { success: true, files: [] };
     }
     const result = await sandbox.runCommand({
       cmd: "find",
-      args: [path14, "-type", "f", "-printf", "%P\\n"]
+      args: [path15, "-type", "f", "-printf", "%P\\n"]
     });
     if (result.exitCode !== 0) {
       const stderr = await result.stderr();
@@ -5803,8 +5822,516 @@ var init_vercel_sandbox_executor = __esm({
     heartbeatListeners = /* @__PURE__ */ new Set();
   }
 });
-
-// src/runtime/sandbox-file-sync.ts
+function createFileWatcher(options) {
+  return new exports.SandboxFileWatcher(options);
+}
+function getFileWatcherManager() {
+  if (!globalWatcherManager) {
+    globalWatcherManager = new exports.FileWatcherManager();
+  }
+  return globalWatcherManager;
+}
+function createFileWatcherManager() {
+  return new exports.FileWatcherManager();
+}
+function createRemoteFileWatcher(options) {
+  return new exports.RemoteSandboxFileWatcher(options);
+}
+function getRemoteFileWatcherManager() {
+  if (!globalRemoteWatcherManager) {
+    globalRemoteWatcherManager = new exports.RemoteFileWatcherManager();
+  }
+  return globalRemoteWatcherManager;
+}
+function createRemoteFileWatcherManager() {
+  return new exports.RemoteFileWatcherManager();
+}
+exports.SandboxFileWatcher = void 0; exports.FileWatcherManager = void 0; var globalWatcherManager; exports.RemoteSandboxFileWatcher = void 0; exports.RemoteFileWatcherManager = void 0; var globalRemoteWatcherManager;
+var init_sandbox_file_watcher = __esm({
+  "src/runtime/sandbox-file-watcher.ts"() {
+    exports.SandboxFileWatcher = class {
+      sessionId;
+      watchPath;
+      debounceMs;
+      patterns;
+      ignored;
+      emitInitialEvents;
+      followSymlinks;
+      usePolling;
+      pollInterval;
+      watcher = null;
+      pendingEvents = /* @__PURE__ */ new Map();
+      subscribers = /* @__PURE__ */ new Set();
+      isWatching = false;
+      startedAt;
+      watchedFileCount = 0;
+      onError;
+      onReady;
+      constructor(options) {
+        this.sessionId = options.sessionId;
+        this.watchPath = options.watchPath;
+        this.debounceMs = options.debounceMs ?? 300;
+        this.patterns = options.patterns ?? ["**/*"];
+        this.ignored = options.ignored ?? ["**/node_modules/**", "**/.git/**", "**/*.log"];
+        this.emitInitialEvents = options.emitInitialEvents ?? false;
+        this.followSymlinks = options.followSymlinks ?? false;
+        this.usePolling = options.usePolling ?? false;
+        this.pollInterval = options.pollInterval ?? 100;
+        this.onError = options.onError;
+        this.onReady = options.onReady;
+        if (options.onFileChange) {
+          this.subscribers.add(options.onFileChange);
+        }
+      }
+      /**
+       * Start watching the directory for changes
+       */
+      async start() {
+        if (this.isWatching) {
+          console.warn(`[FILE_WATCHER] Already watching ${this.watchPath}`);
+          return;
+        }
+        try {
+          const stat2 = await fs__namespace.stat(this.watchPath);
+          if (!stat2.isDirectory()) {
+            throw new Error(`Watch path is not a directory: ${this.watchPath}`);
+          }
+        } catch (error) {
+          if (error.code === "ENOENT") {
+            throw new Error(`Watch path does not exist: ${this.watchPath}`);
+          }
+          throw error;
+        }
+        const watchPaths = this.patterns.map(
+          (pattern) => path4__namespace.join(this.watchPath, pattern)
+        );
+        this.watcher = chokidar__default.default.watch(watchPaths, {
+          ignored: this.ignored,
+          persistent: true,
+          ignoreInitial: !this.emitInitialEvents,
+          followSymlinks: this.followSymlinks,
+          usePolling: this.usePolling,
+          interval: this.pollInterval,
+          awaitWriteFinish: {
+            stabilityThreshold: this.debounceMs,
+            pollInterval: 100
+          }
+        });
+        this.watcher.on("add", (filePath) => this.handleFileEvent("add", filePath)).on("change", (filePath) => this.handleFileEvent("change", filePath)).on("unlink", (filePath) => this.handleFileEvent("unlink", filePath)).on("addDir", (dirPath) => this.handleFileEvent("addDir", dirPath)).on("unlinkDir", (dirPath) => this.handleFileEvent("unlinkDir", dirPath)).on("error", (error) => {
+          console.error(`[FILE_WATCHER] Error watching ${this.watchPath}:`, error);
+          if (this.onError) {
+            this.onError(error);
+          }
+        }).on("ready", () => {
+          console.log(`[FILE_WATCHER] Ready to watch ${this.watchPath}`);
+          this.isWatching = true;
+          this.startedAt = /* @__PURE__ */ new Date();
+          if (this.onReady) {
+            this.onReady();
+          }
+        });
+        this.watcher.on("add", () => this.watchedFileCount++);
+        this.watcher.on("unlink", () => this.watchedFileCount--);
+      }
+      /**
+       * Stop watching and cleanup resources
+       */
+      async stop() {
+        if (!this.isWatching || !this.watcher) {
+          return;
+        }
+        for (const pending of this.pendingEvents.values()) {
+          clearTimeout(pending.timer);
+        }
+        this.pendingEvents.clear();
+        await this.watcher.close();
+        this.watcher = null;
+        this.isWatching = false;
+        this.watchedFileCount = 0;
+        console.log(`[FILE_WATCHER] Stopped watching ${this.watchPath}`);
+      }
+      /**
+       * Subscribe to file change events
+       * @returns Unsubscribe function
+       */
+      subscribe(callback) {
+        this.subscribers.add(callback);
+        return () => this.subscribers.delete(callback);
+      }
+      /**
+       * Remove a subscriber
+       */
+      unsubscribe(callback) {
+        this.subscribers.delete(callback);
+      }
+      /**
+       * Get the current status of the watcher
+       */
+      getStatus() {
+        return {
+          sessionId: this.sessionId,
+          watchPath: this.watchPath,
+          isWatching: this.isWatching,
+          watchedFileCount: this.watchedFileCount,
+          pendingEventCount: this.pendingEvents.size,
+          startedAt: this.startedAt
+        };
+      }
+      /**
+       * Check if the watcher is currently active
+       */
+      isActive() {
+        return this.isWatching;
+      }
+      /**
+       * Handle a file system event with debouncing
+       */
+      handleFileEvent(type, absolutePath) {
+        const relativePath = path4__namespace.relative(this.watchPath, absolutePath);
+        const existing = this.pendingEvents.get(absolutePath);
+        if (existing) {
+          clearTimeout(existing.timer);
+        }
+        const timer = setTimeout(async () => {
+          this.pendingEvents.delete(absolutePath);
+          await this.emitEvent(type, absolutePath, relativePath);
+        }, this.debounceMs);
+        this.pendingEvents.set(absolutePath, {
+          type,
+          absolutePath,
+          relativePath,
+          timer
+        });
+      }
+      /**
+       * Emit a file change event to all subscribers
+       */
+      async emitEvent(type, absolutePath, relativePath) {
+        let fileSize;
+        if (type === "add" || type === "change") {
+          try {
+            const stat2 = await fs__namespace.stat(absolutePath);
+            fileSize = stat2.size;
+          } catch {
+          }
+        }
+        const event = {
+          type,
+          relativePath,
+          absolutePath,
+          sessionId: this.sessionId,
+          fileSize,
+          timestamp: /* @__PURE__ */ new Date()
+        };
+        for (const callback of this.subscribers) {
+          try {
+            await callback(event);
+          } catch (error) {
+            console.error("[FILE_WATCHER] Error in subscriber callback:", error);
+          }
+        }
+      }
+    };
+    exports.FileWatcherManager = class {
+      watchers = /* @__PURE__ */ new Map();
+      /**
+       * Start watching a session's sandbox directory
+       */
+      async startWatching(options) {
+        const { sessionId } = options;
+        const existing = this.watchers.get(sessionId);
+        if (existing) {
+          await existing.stop();
+        }
+        const watcher = new exports.SandboxFileWatcher(options);
+        await watcher.start();
+        this.watchers.set(sessionId, watcher);
+        return watcher;
+      }
+      /**
+       * Stop watching a session's sandbox directory
+       */
+      async stopWatching(sessionId) {
+        const watcher = this.watchers.get(sessionId);
+        if (watcher) {
+          await watcher.stop();
+          this.watchers.delete(sessionId);
+        }
+      }
+      /**
+       * Get a watcher for a session
+       */
+      getWatcher(sessionId) {
+        return this.watchers.get(sessionId);
+      }
+      /**
+       * Check if a session is being watched
+       */
+      isWatching(sessionId) {
+        const watcher = this.watchers.get(sessionId);
+        return watcher?.isActive() ?? false;
+      }
+      /**
+       * Get status of all watchers
+       */
+      getAllStatuses() {
+        return Array.from(this.watchers.values()).map((w) => w.getStatus());
+      }
+      /**
+       * Stop all watchers and cleanup
+       */
+      async stopAll() {
+        const promises = Array.from(this.watchers.values()).map((w) => w.stop());
+        await Promise.all(promises);
+        this.watchers.clear();
+      }
+    };
+    globalWatcherManager = null;
+    exports.RemoteSandboxFileWatcher = class {
+      sessionId;
+      sandboxOps;
+      basePath;
+      pollIntervalMs;
+      ignored;
+      pollTimer = null;
+      previousFiles = /* @__PURE__ */ new Map();
+      subscribers = /* @__PURE__ */ new Set();
+      isWatching = false;
+      startedAt;
+      lastPollAt;
+      pollCount = 0;
+      onError;
+      constructor(options) {
+        this.sessionId = options.sessionId;
+        this.sandboxOps = options.sandboxOps;
+        this.basePath = options.basePath;
+        this.pollIntervalMs = options.pollIntervalMs ?? 2e3;
+        this.ignored = options.ignored ?? ["**/node_modules/**", "**/.git/**"];
+        this.onError = options.onError;
+        if (options.onFileChange) {
+          this.subscribers.add(options.onFileChange);
+        }
+      }
+      /**
+       * Start polling for file changes
+       */
+      async start() {
+        if (this.isWatching) {
+          console.warn(`[REMOTE_WATCHER] Already watching session ${this.sessionId}`);
+          return;
+        }
+        if (!this.sandboxOps.isSandboxRunning(this.sessionId)) {
+          throw new Error(`Sandbox is not running for session ${this.sessionId}`);
+        }
+        await this.scan(true);
+        this.pollTimer = setInterval(async () => {
+          try {
+            await this.scan(false);
+          } catch (error) {
+            console.error(`[REMOTE_WATCHER] Poll error for session ${this.sessionId}:`, error);
+            if (this.onError && error instanceof Error) {
+              this.onError(error);
+            }
+          }
+        }, this.pollIntervalMs);
+        this.isWatching = true;
+        this.startedAt = /* @__PURE__ */ new Date();
+        console.log(`[REMOTE_WATCHER] Started watching session ${this.sessionId} at ${this.basePath}`);
+      }
+      /**
+       * Stop polling and cleanup
+       */
+      async stop() {
+        if (!this.isWatching) {
+          return;
+        }
+        if (this.pollTimer) {
+          clearInterval(this.pollTimer);
+          this.pollTimer = null;
+        }
+        this.isWatching = false;
+        this.previousFiles.clear();
+        console.log(`[REMOTE_WATCHER] Stopped watching session ${this.sessionId}`);
+      }
+      /**
+       * Subscribe to file change events
+       */
+      subscribe(callback) {
+        this.subscribers.add(callback);
+        return () => this.subscribers.delete(callback);
+      }
+      /**
+       * Remove a subscriber
+       */
+      unsubscribe(callback) {
+        this.subscribers.delete(callback);
+      }
+      /**
+       * Check if watcher is active
+       */
+      isActive() {
+        return this.isWatching;
+      }
+      /**
+       * Get watcher status
+       */
+      getStatus() {
+        return {
+          sessionId: this.sessionId,
+          watchPath: this.basePath,
+          isWatching: this.isWatching,
+          watchedFileCount: this.previousFiles.size,
+          pendingEventCount: 0,
+          startedAt: this.startedAt,
+          lastPollAt: this.lastPollAt,
+          pollCount: this.pollCount
+        };
+      }
+      /**
+       * Force an immediate scan (useful for testing or manual refresh)
+       */
+      async forceScan() {
+        await this.scan(false);
+      }
+      /**
+       * Scan the sandbox for file changes
+       */
+      async scan(isInitial) {
+        if (!this.sandboxOps.isSandboxRunning(this.sessionId)) {
+          console.warn(`[REMOTE_WATCHER] Sandbox stopped for session ${this.sessionId}`);
+          await this.stop();
+          return;
+        }
+        const listResult = await this.sandboxOps.listFiles(this.sessionId, this.basePath);
+        if (!listResult.success || !listResult.files) {
+          throw new Error(listResult.error ?? "Failed to list files in sandbox");
+        }
+        const currentFiles = /* @__PURE__ */ new Map();
+        for (const filePath of listResult.files) {
+          if (this.shouldIgnore(filePath)) {
+            continue;
+          }
+          currentFiles.set(filePath, { path: filePath });
+        }
+        this.lastPollAt = /* @__PURE__ */ new Date();
+        this.pollCount++;
+        if (isInitial) {
+          this.previousFiles = currentFiles;
+          return;
+        }
+        const changes = [];
+        for (const [filePath, info] of currentFiles) {
+          const previous = this.previousFiles.get(filePath);
+          if (!previous) {
+            changes.push({
+              type: "add",
+              relativePath: filePath,
+              absolutePath: `${this.basePath}/${filePath}`,
+              sessionId: this.sessionId,
+              fileSize: info.size,
+              timestamp: /* @__PURE__ */ new Date()
+            });
+          }
+        }
+        for (const [filePath] of this.previousFiles) {
+          if (!currentFiles.has(filePath)) {
+            changes.push({
+              type: "unlink",
+              relativePath: filePath,
+              absolutePath: `${this.basePath}/${filePath}`,
+              sessionId: this.sessionId,
+              timestamp: /* @__PURE__ */ new Date()
+            });
+          }
+        }
+        this.previousFiles = currentFiles;
+        for (const event of changes) {
+          await this.emitEvent(event);
+        }
+      }
+      /**
+       * Check if a path should be ignored
+       */
+      shouldIgnore(filePath) {
+        for (const pattern of this.ignored) {
+          if (this.matchesGlob(filePath, pattern)) {
+            return true;
+          }
+        }
+        return false;
+      }
+      /**
+       * Simple glob matching (supports ** and *)
+       */
+      matchesGlob(filePath, pattern) {
+        const regexPattern = pattern.replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/{{GLOBSTAR}}/g, ".*").replace(/\//g, "\\/");
+        const regex = new RegExp(`^${regexPattern}$`);
+        return regex.test(filePath);
+      }
+      /**
+       * Emit a file change event to all subscribers
+       */
+      async emitEvent(event) {
+        for (const callback of this.subscribers) {
+          try {
+            await callback(event);
+          } catch (error) {
+            console.error("[REMOTE_WATCHER] Error in subscriber callback:", error);
+          }
+        }
+      }
+    };
+    exports.RemoteFileWatcherManager = class {
+      watchers = /* @__PURE__ */ new Map();
+      /**
+       * Start watching a session's sandbox
+       */
+      async startWatching(options) {
+        const { sessionId } = options;
+        const existing = this.watchers.get(sessionId);
+        if (existing) {
+          await existing.stop();
+        }
+        const watcher = new exports.RemoteSandboxFileWatcher(options);
+        await watcher.start();
+        this.watchers.set(sessionId, watcher);
+        return watcher;
+      }
+      /**
+       * Stop watching a session
+       */
+      async stopWatching(sessionId) {
+        const watcher = this.watchers.get(sessionId);
+        if (watcher) {
+          await watcher.stop();
+          this.watchers.delete(sessionId);
+        }
+      }
+      /**
+       * Get a watcher for a session
+       */
+      getWatcher(sessionId) {
+        return this.watchers.get(sessionId);
+      }
+      /**
+       * Check if a session is being watched
+       */
+      isWatching(sessionId) {
+        const watcher = this.watchers.get(sessionId);
+        return watcher?.isActive() ?? false;
+      }
+      /**
+       * Stop all watchers
+       */
+      async stopAll() {
+        const promises = Array.from(this.watchers.values()).map((w) => w.stop());
+        await Promise.all(promises);
+        this.watchers.clear();
+      }
+    };
+    globalRemoteWatcherManager = null;
+  }
+});
 function extractErrorMessage(error) {
   if (error === null || error === void 0) {
     return "Unknown error (null/undefined)";
@@ -5850,13 +6377,256 @@ function createSandboxFileSync(options) {
 exports.SandboxFileSync = void 0;
 var init_sandbox_file_sync = __esm({
   "src/runtime/sandbox-file-sync.ts"() {
+    init_sandbox_file_watcher();
+    init_types();
     exports.SandboxFileSync = class {
       fileStore;
       sandboxBasePath;
+      defaultWatchOptions;
       sandboxOps = null;
+      onFileEvent;
+      eventStorage;
+      webhookConfig;
+      // Watcher management
+      remoteWatchers = /* @__PURE__ */ new Map();
+      localWatchers = /* @__PURE__ */ new Map();
+      fileChangeSubscribers = /* @__PURE__ */ new Set();
+      // Sequence number cache per session (for event storage)
+      sequenceNumbers = /* @__PURE__ */ new Map();
       constructor(options) {
         this.fileStore = options.fileStore;
         this.sandboxBasePath = options.sandboxBasePath ?? ".claude/files";
+        this.onFileEvent = options.onFileEvent;
+        this.defaultWatchOptions = options.watchOptions ?? {};
+        this.eventStorage = options.eventStorage;
+        this.webhookConfig = options.webhook;
+      }
+      /**
+       * Set the file event callback
+       * This can be used to set or update the callback after construction
+       */
+      setFileEventCallback(callback) {
+        this.onFileEvent = callback;
+      }
+      /**
+       * Set the event storage for persisting file events to the timeline
+       * This can be used to set or update the storage after construction
+       */
+      setEventStorage(storage) {
+        this.eventStorage = storage;
+      }
+      /**
+       * Set webhook configuration for external notifications
+       * This can be used to set or update the webhook after construction
+       */
+      setWebhook(config) {
+        this.webhookConfig = config;
+      }
+      /**
+       * Remove webhook configuration
+       */
+      removeWebhook() {
+        this.webhookConfig = void 0;
+      }
+      /**
+       * Send a webhook notification
+       * @param payload - The webhook payload to send
+       */
+      async sendWebhook(payload) {
+        if (!this.webhookConfig) return;
+        const config = this.webhookConfig;
+        const eventType = payload.fileSyncEvent?.operation ?? "file_change";
+        if (config.events && config.events.length > 0) {
+          const shouldSend = config.events.some(
+            (e) => e === eventType || e === "file_change" && payload.event === "file_change"
+          );
+          if (!shouldSend) return;
+        }
+        const body = JSON.stringify(payload);
+        const timeoutMs = config.timeoutMs ?? 1e4;
+        const retries = config.retries ?? 3;
+        const isAsync = config.async !== false;
+        const headers = {
+          "Content-Type": "application/json",
+          "User-Agent": "Ash-FileSync/1.0",
+          ...config.headers
+        };
+        if (config.secret) {
+          const signature = crypto.createHmac("sha256", config.secret).update(body).digest("hex");
+          headers["X-Ash-Signature"] = `sha256=${signature}`;
+          headers["X-Ash-Timestamp"] = payload.timestamp;
+        }
+        const sendWithRetry = async (attempt) => {
+          try {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+            const response = await fetch(config.url, {
+              method: "POST",
+              headers,
+              body,
+              signal: controller.signal
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+              throw new Error(`Webhook returned ${response.status}: ${response.statusText}`);
+            }
+            console.log(`[FILE_SYNC] Webhook sent successfully to ${config.url}`);
+          } catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            if (attempt < retries) {
+              const delay = Math.pow(2, attempt) * 1e3;
+              console.warn(`[FILE_SYNC] Webhook failed (attempt ${attempt + 1}/${retries}), retrying in ${delay}ms: ${errorMsg}`);
+              await new Promise((resolve3) => setTimeout(resolve3, delay));
+              return sendWithRetry(attempt + 1);
+            }
+            console.error(`[FILE_SYNC] Webhook failed after ${retries} attempts: ${errorMsg}`);
+            throw error;
+          }
+        };
+        if (isAsync) {
+          sendWithRetry(0).catch((error) => {
+            console.error("[FILE_SYNC] Async webhook failed:", error);
+          });
+        } else {
+          await sendWithRetry(0);
+        }
+      }
+      /**
+       * Send a file sync event webhook
+       */
+      async sendFileSyncWebhook(sessionId, event) {
+        const payload = {
+          event: "file_sync",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          sessionId,
+          metadata: this.webhookConfig?.metadata,
+          fileSyncEvent: event
+        };
+        await this.sendWebhook(payload);
+      }
+      /**
+       * Send a file change event webhook (from watcher)
+       */
+      async sendFileChangeWebhook(event) {
+        const payload = {
+          event: "file_change",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          sessionId: event.sessionId,
+          metadata: this.webhookConfig?.metadata,
+          fileChangeEvent: event
+        };
+        await this.sendWebhook(payload);
+      }
+      /**
+       * Get the next sequence number for a session
+       */
+      async getNextSequenceNumber(sessionId) {
+        const cached = this.sequenceNumbers.get(sessionId);
+        if (cached !== void 0) {
+          const next = cached + 1;
+          this.sequenceNumbers.set(sessionId, next);
+          return next;
+        }
+        if (this.eventStorage) {
+          try {
+            const next = await this.eventStorage.getNextEventSequence(sessionId);
+            this.sequenceNumbers.set(sessionId, next);
+            return next;
+          } catch (error) {
+            console.warn("[FILE_SYNC] Failed to get next sequence number:", error);
+          }
+        }
+        this.sequenceNumbers.set(sessionId, 1);
+        return 1;
+      }
+      /**
+       * Compute a unified diff between two text contents
+       */
+      computeDiff(previousContent, newContent) {
+        if (!previousContent && !newContent) return void 0;
+        if (!previousContent || !newContent) return void 0;
+        try {
+          const MAX_DIFF_SIZE = 100 * 1024;
+          if (previousContent.length > MAX_DIFF_SIZE || newContent.length > MAX_DIFF_SIZE) {
+            return void 0;
+          }
+          const prevText = previousContent.toString("utf-8");
+          const newText = newContent.toString("utf-8");
+          const sampleSize = Math.min(8192, prevText.length, newText.length);
+          if (prevText.slice(0, sampleSize).includes("\0") || newText.slice(0, sampleSize).includes("\0")) {
+            return void 0;
+          }
+          const prevLines = prevText.split("\n");
+          const newLines = newText.split("\n");
+          const diffLines = [];
+          diffLines.push("--- a/file");
+          diffLines.push("+++ b/file");
+          const removed = prevLines.filter((l) => !newLines.includes(l));
+          const added = newLines.filter((l) => !prevLines.includes(l));
+          if (removed.length === 0 && added.length === 0) {
+            return void 0;
+          }
+          diffLines.push("@@ -1 +1 @@");
+          for (const line of removed) {
+            diffLines.push(`-${line}`);
+          }
+          for (const line of added) {
+            diffLines.push(`+${line}`);
+          }
+          return diffLines.join("\n");
+        } catch {
+          return void 0;
+        }
+      }
+      /**
+       * Emit a file event if a callback is registered
+       * Also persists to EventStorage if configured
+       */
+      async emitFileEvent(sessionId, event) {
+        if (this.onFileEvent) {
+          try {
+            this.onFileEvent(event);
+          } catch (error) {
+            console.error("[FILE_SYNC] Error in file event callback:", error);
+          }
+        }
+        if (this.webhookConfig) {
+          this.sendFileSyncWebhook(sessionId, event);
+        }
+        if (this.eventStorage) {
+          try {
+            const now = /* @__PURE__ */ new Date();
+            const sequenceNumber = await this.getNextSequenceNumber(sessionId);
+            const diff = this.computeDiff(event.previousContent, event.newContent);
+            const isTextFile = diff !== void 0 || event.newContent && !event.newContent.slice(0, 8192).includes(0);
+            const eventData = {
+              operation: event.operation,
+              direction: event.direction,
+              source: "internal",
+              // File sync operations are internal
+              filePath: event.filePath,
+              fileSize: event.fileSize,
+              success: event.success,
+              error: event.error,
+              diff,
+              isTextFile,
+              previousSize: event.previousContent?.length
+            };
+            const eventType = `file_${event.operation}`;
+            const sessionEvent = {
+              eventType,
+              category: exports.EventCategory.FILE,
+              startedAt: now,
+              endedAt: now,
+              durationMs: 0,
+              eventData,
+              sequenceNumber
+            };
+            await this.eventStorage.saveEvents(sessionId, [sessionEvent]);
+          } catch (error) {
+            console.error("[FILE_SYNC] Error saving file event to storage:", error);
+          }
+        }
       }
       /**
        * Set the sandbox operations implementation
@@ -5870,8 +6640,8 @@ var init_sandbox_file_sync = __esm({
        * @param path - The relative file path
        * @param targetPath - Optional override for the base path
        */
-      getSandboxPath(path14, targetPath) {
-        const normalizedPath = path14.replace(/^\/+/, "");
+      getSandboxPath(path15, targetPath) {
+        const normalizedPath = path15.replace(/^\/+/, "");
         const basePath = targetPath ?? this.sandboxBasePath;
         if (basePath === ".") {
           return normalizedPath;
@@ -5884,33 +6654,67 @@ var init_sandbox_file_sync = __esm({
        * @param path - File path (stored in S3 and used as relative path in sandbox)
        * @param content - File content
        * @param options - Push options (e.g., targetPath to override sandbox location)
+       * @param previousContent - Optional previous content for diff computation
        */
-      async pushFile(sessionId, path14, content, options) {
+      async pushFile(sessionId, path15, content, options, previousContent) {
         const result = {
-          path: path14,
+          path: path15,
           s3Written: false,
           sandboxWritten: false
         };
         try {
-          await this.fileStore.writeFile(sessionId, path14, content);
+          await this.fileStore.writeFile(sessionId, path15, content);
           result.s3Written = true;
+          await this.emitFileEvent(sessionId, {
+            operation: "push",
+            direction: "to_s3",
+            filePath: path15,
+            fileSize: content.length,
+            success: true,
+            previousContent,
+            newContent: content
+          });
         } catch (error) {
           const errorMessage = extractErrorMessage(error);
           result.error = `S3 write failed: ${errorMessage}`;
-          console.error(`[FILE_SYNC] S3 write failed for session ${sessionId}, path ${path14}:`, error);
+          console.error(`[FILE_SYNC] S3 write failed for session ${sessionId}, path ${path15}:`, error);
+          await this.emitFileEvent(sessionId, {
+            operation: "push",
+            direction: "to_s3",
+            filePath: path15,
+            fileSize: content.length,
+            success: false,
+            error: errorMessage
+          });
           return result;
         }
         if (this.sandboxOps?.isSandboxRunning(sessionId)) {
           try {
-            const sandboxPath = this.getSandboxPath(path14, options?.targetPath);
+            const sandboxPath = this.getSandboxPath(path15, options?.targetPath);
             const writeResult = await this.sandboxOps.writeFile(sessionId, sandboxPath, content);
             result.sandboxWritten = writeResult.success;
+            await this.emitFileEvent(sessionId, {
+              operation: "push",
+              direction: "to_sandbox",
+              filePath: path15,
+              fileSize: content.length,
+              success: writeResult.success,
+              error: writeResult.error
+            });
             if (!writeResult.success && writeResult.error) {
-              console.warn(`[FILE_SYNC] Sandbox write failed for ${path14}: ${writeResult.error}`);
+              console.warn(`[FILE_SYNC] Sandbox write failed for ${path15}: ${writeResult.error}`);
             }
           } catch (error) {
             const errorMessage = extractErrorMessage(error);
-            console.warn(`[FILE_SYNC] Sandbox write error for ${path14}: ${errorMessage}`);
+            console.warn(`[FILE_SYNC] Sandbox write error for ${path15}: ${errorMessage}`);
+            await this.emitFileEvent(sessionId, {
+              operation: "push",
+              direction: "to_sandbox",
+              filePath: path15,
+              fileSize: content.length,
+              success: false,
+              error: errorMessage
+            });
           }
         } else {
           console.debug(`[FILE_SYNC] Sandbox not running for session ${sessionId}, skipping sandbox write`);
@@ -5935,9 +6739,9 @@ var init_sandbox_file_sync = __esm({
        * Pull a file from sandbox to S3
        * Reads from sandbox and writes to S3
        */
-      async pullFile(sessionId, path14) {
+      async pullFile(sessionId, path15) {
         const result = {
-          path: path14,
+          path: path15,
           content: null,
           s3Written: false
         };
@@ -5946,35 +6750,73 @@ var init_sandbox_file_sync = __esm({
           return result;
         }
         try {
-          const sandboxPath = this.getSandboxPath(path14);
+          const sandboxPath = this.getSandboxPath(path15);
           const readResult = await this.sandboxOps.readFile(sessionId, sandboxPath);
           if (!readResult.success || !readResult.content) {
             result.error = readResult.error ?? "File not found in sandbox";
+            await this.emitFileEvent(sessionId, {
+              operation: "pull",
+              direction: "from_sandbox",
+              filePath: path15,
+              success: false,
+              error: result.error
+            });
             return result;
           }
           result.content = readResult.content;
+          await this.emitFileEvent(sessionId, {
+            operation: "pull",
+            direction: "from_sandbox",
+            filePath: path15,
+            fileSize: readResult.content.length,
+            success: true,
+            newContent: readResult.content
+          });
         } catch (error) {
           const errorMessage = extractErrorMessage(error);
           result.error = `Sandbox read failed: ${errorMessage}`;
+          await this.emitFileEvent(sessionId, {
+            operation: "pull",
+            direction: "from_sandbox",
+            filePath: path15,
+            success: false,
+            error: errorMessage
+          });
           return result;
         }
         try {
-          await this.fileStore.writeFile(sessionId, path14, result.content);
+          await this.fileStore.writeFile(sessionId, path15, result.content);
           result.s3Written = true;
+          await this.emitFileEvent(sessionId, {
+            operation: "pull",
+            direction: "to_s3",
+            filePath: path15,
+            fileSize: result.content.length,
+            success: true,
+            newContent: result.content
+          });
         } catch (error) {
           const errorMessage = extractErrorMessage(error);
           result.error = `S3 write failed: ${errorMessage}`;
-          console.error(`[FILE_SYNC] S3 write failed in pullFile for session ${sessionId}, path ${path14}:`, error);
+          console.error(`[FILE_SYNC] S3 write failed in pullFile for session ${sessionId}, path ${path15}:`, error);
+          await this.emitFileEvent(sessionId, {
+            operation: "pull",
+            direction: "to_s3",
+            filePath: path15,
+            fileSize: result.content?.length,
+            success: false,
+            error: errorMessage
+          });
         }
         return result;
       }
       /**
        * Read a file (tries sandbox first, falls back to S3)
        */
-      async readFile(sessionId, path14) {
+      async readFile(sessionId, path15) {
         if (this.sandboxOps?.isSandboxRunning(sessionId)) {
           try {
-            const sandboxPath = this.getSandboxPath(path14);
+            const sandboxPath = this.getSandboxPath(path15);
             const readResult = await this.sandboxOps.readFile(sessionId, sandboxPath);
             if (readResult.success && readResult.content) {
               return { content: readResult.content, source: "sandbox" };
@@ -5983,7 +6825,7 @@ var init_sandbox_file_sync = __esm({
           }
         }
         try {
-          const content = await this.fileStore.readFile(sessionId, path14);
+          const content = await this.fileStore.readFile(sessionId, path15);
           if (content) {
             return { content, source: "s3" };
           }
@@ -6000,21 +6842,48 @@ var init_sandbox_file_sync = __esm({
       /**
        * Delete a file from both S3 and sandbox
        */
-      async deleteFile(sessionId, path14) {
+      async deleteFile(sessionId, path15) {
         const result = { s3Deleted: false, sandboxDeleted: false };
         try {
-          await this.fileStore.deleteFile(sessionId, path14);
+          await this.fileStore.deleteFile(sessionId, path15);
           result.s3Deleted = true;
+          await this.emitFileEvent(sessionId, {
+            operation: "delete",
+            direction: "from_s3",
+            filePath: path15,
+            success: true
+          });
         } catch (error) {
           const errorMessage = extractErrorMessage(error);
-          console.warn(`[FILE_SYNC] S3 delete failed for ${path14}: ${errorMessage}`);
+          console.warn(`[FILE_SYNC] S3 delete failed for ${path15}: ${errorMessage}`);
+          await this.emitFileEvent(sessionId, {
+            operation: "delete",
+            direction: "from_s3",
+            filePath: path15,
+            success: false,
+            error: errorMessage
+          });
         }
         if (this.sandboxOps?.isSandboxRunning(sessionId)) {
           try {
-            const sandboxPath = this.getSandboxPath(path14);
+            const sandboxPath = this.getSandboxPath(path15);
             console.log(`[FILE_SYNC] Would delete ${sandboxPath} from sandbox`);
             result.sandboxDeleted = true;
-          } catch {
+            await this.emitFileEvent(sessionId, {
+              operation: "delete",
+              direction: "from_sandbox",
+              filePath: path15,
+              success: true
+            });
+          } catch (error) {
+            const errorMessage = extractErrorMessage(error);
+            await this.emitFileEvent(sessionId, {
+              operation: "delete",
+              direction: "from_sandbox",
+              filePath: path15,
+              success: false,
+              error: errorMessage
+            });
           }
         }
         return result;
@@ -6035,14 +6904,36 @@ var init_sandbox_file_sync = __esm({
             const content = await this.fileStore.readFile(sessionId, file.path);
             if (!content) {
               result.errors.push({ path: file.path, error: "File not found in S3" });
+              await this.emitFileEvent(sessionId, {
+                operation: "sync_to_sandbox",
+                direction: "from_s3",
+                filePath: file.path,
+                success: false,
+                error: "File not found in S3"
+              });
               continue;
             }
             const sandboxPath = this.getSandboxPath(file.path);
             const writeResult = await this.sandboxOps.writeFile(sessionId, sandboxPath, content);
             if (writeResult.success) {
               result.fileCount++;
+              await this.emitFileEvent(sessionId, {
+                operation: "sync_to_sandbox",
+                direction: "to_sandbox",
+                filePath: file.path,
+                fileSize: content.length,
+                success: true
+              });
             } else {
               result.errors.push({ path: file.path, error: writeResult.error ?? "Unknown error" });
+              await this.emitFileEvent(sessionId, {
+                operation: "sync_to_sandbox",
+                direction: "to_sandbox",
+                filePath: file.path,
+                fileSize: content.length,
+                success: false,
+                error: writeResult.error
+              });
             }
           } catch (error) {
             const errorMessage = extractErrorMessage(error);
@@ -6050,6 +6941,13 @@ var init_sandbox_file_sync = __esm({
               path: file.path,
               error: errorMessage
             });
+            await this.emitFileEvent(sessionId, {
+              operation: "sync_to_sandbox",
+              direction: "to_sandbox",
+              filePath: file.path,
+              success: false,
+              error: errorMessage
+            });
           }
         }
         console.log(`[FILE_SYNC] Synced ${result.fileCount} files to sandbox for session ${sessionId}`);
@@ -6082,8 +6980,23 @@ var init_sandbox_file_sync = __esm({
             const pullResult = await this.pullFile(sessionId, filePath);
             if (pullResult.s3Written) {
               result.fileCount++;
+              await this.emitFileEvent(sessionId, {
+                operation: "sync_from_sandbox",
+                direction: "to_s3",
+                filePath,
+                fileSize: pullResult.content?.length,
+                success: true,
+                newContent: pullResult.content ?? void 0
+              });
             } else if (pullResult.error) {
               result.errors.push({ path: filePath, error: pullResult.error });
+              await this.emitFileEvent(sessionId, {
+                operation: "sync_from_sandbox",
+                direction: "to_s3",
+                filePath,
+                success: false,
+                error: pullResult.error
+              });
             }
           } catch (error) {
             const errorMessage = extractErrorMessage(error);
@@ -6091,6 +7004,13 @@ var init_sandbox_file_sync = __esm({
               path: filePath,
               error: errorMessage
             });
+            await this.emitFileEvent(sessionId, {
+              operation: "sync_from_sandbox",
+              direction: "to_s3",
+              filePath,
+              success: false,
+              error: errorMessage
+            });
           }
         }
         console.log(`[FILE_SYNC] Synced ${result.fileCount} files from sandbox to S3 for session ${sessionId}`);
@@ -6099,16 +7019,526 @@ var init_sandbox_file_sync = __esm({
       /**
        * Get a signed URL for direct file download
        */
-      async getSignedUrl(sessionId, path14, expiresIn) {
-        return this.fileStore.getSignedUrl(sessionId, path14, expiresIn);
+      async getSignedUrl(sessionId, path15, expiresIn) {
+        return this.fileStore.getSignedUrl(sessionId, path15, expiresIn);
       }
       /**
        * Get a signed URL for direct file upload
        */
-      async getUploadUrl(sessionId, path14, expiresIn) {
-        return this.fileStore.getUploadUrl(sessionId, path14, expiresIn);
+      async getUploadUrl(sessionId, path15, expiresIn) {
+        return this.fileStore.getUploadUrl(sessionId, path15, expiresIn);
+      }
+      // ===========================================================================
+      // File Watching API
+      // ===========================================================================
+      /**
+       * Start watching a sandbox for file changes and auto-sync to S3.
+       *
+       * For remote sandboxes (Vercel, E2B, etc.), uses polling.
+       * For local sandboxes, can optionally use native file watching via chokidar.
+       *
+       * @param sessionId - Session to watch
+       * @param options - Watch options (overrides constructor defaults)
+       */
+      async startWatching(sessionId, options) {
+        const opts = { ...this.defaultWatchOptions, ...options };
+        await this.stopWatching(sessionId);
+        const handleFileChange = async (event) => {
+          console.log(`[FILE_SYNC] File change detected: ${event.type} ${event.relativePath}`);
+          if (this.webhookConfig) {
+            this.sendFileChangeWebhook(event);
+          }
+          for (const subscriber of this.fileChangeSubscribers) {
+            try {
+              await subscriber(event);
+            } catch (error) {
+              console.error("[FILE_SYNC] Error in file change subscriber:", error);
+            }
+          }
+          if (event.type === "add" || event.type === "change") {
+            try {
+              const pullResult = await this.pullFile(sessionId, event.relativePath);
+              if (pullResult.s3Written) {
+                console.log(`[FILE_SYNC] Auto-synced ${event.relativePath} to S3`);
+              } else if (pullResult.error) {
+                console.warn(`[FILE_SYNC] Failed to auto-sync ${event.relativePath}: ${pullResult.error}`);
+              }
+            } catch (error) {
+              console.error(`[FILE_SYNC] Error auto-syncing ${event.relativePath}:`, error);
+            }
+          } else if (event.type === "unlink") {
+            try {
+              await this.deleteFile(sessionId, event.relativePath);
+              console.log(`[FILE_SYNC] Auto-deleted ${event.relativePath} from S3`);
+            } catch (error) {
+              console.error(`[FILE_SYNC] Error auto-deleting ${event.relativePath}:`, error);
+            }
+          }
+        };
+        if (opts.useLocalWatcher && opts.localPath) {
+          const watcher = new exports.SandboxFileWatcher({
+            sessionId,
+            watchPath: opts.localPath,
+            debounceMs: opts.debounceMs ?? 300,
+            ignored: opts.ignored ?? ["**/node_modules/**", "**/.git/**"],
+            onFileChange: handleFileChange,
+            onError: (error) => {
+              console.error(`[FILE_SYNC] Local watcher error for session ${sessionId}:`, error);
+            }
+          });
+          await watcher.start();
+          this.localWatchers.set(sessionId, watcher);
+          console.log(`[FILE_SYNC] Started local file watching for session ${sessionId}`);
+        } else {
+          if (!this.sandboxOps) {
+            throw new Error("Sandbox operations not configured. Call setSandboxOperations first.");
+          }
+          const watcher = new exports.RemoteSandboxFileWatcher({
+            sessionId,
+            sandboxOps: this.sandboxOps,
+            basePath: this.sandboxBasePath,
+            pollIntervalMs: opts.pollIntervalMs ?? 2e3,
+            ignored: opts.ignored ?? ["**/node_modules/**", "**/.git/**"],
+            onFileChange: handleFileChange,
+            onError: (error) => {
+              console.error(`[FILE_SYNC] Remote watcher error for session ${sessionId}:`, error);
+            }
+          });
+          await watcher.start();
+          this.remoteWatchers.set(sessionId, watcher);
+          console.log(`[FILE_SYNC] Started remote file watching for session ${sessionId}`);
+        }
+      }
+      /**
+       * Stop watching a session's sandbox
+       */
+      async stopWatching(sessionId) {
+        const remoteWatcher = this.remoteWatchers.get(sessionId);
+        if (remoteWatcher) {
+          await remoteWatcher.stop();
+          this.remoteWatchers.delete(sessionId);
+        }
+        const localWatcher = this.localWatchers.get(sessionId);
+        if (localWatcher) {
+          await localWatcher.stop();
+          this.localWatchers.delete(sessionId);
+        }
+      }
+      /**
+       * Check if a session is being watched
+       */
+      isWatching(sessionId) {
+        return this.remoteWatchers.has(sessionId) || this.localWatchers.has(sessionId);
+      }
+      /**
+       * Subscribe to file change events across all watched sessions.
+       * This allows external applications to react to file changes.
+       *
+       * @param callback - Function to call when a file changes
+       * @returns Unsubscribe function
+       *
+       * @example
+       * ```typescript
+       * const unsubscribe = fileSync.onFileChange((event) => {
+       *   console.log(`File ${event.relativePath} was ${event.type}d`);
+       *   // Update your application state here
+       * });
+       *
+       * // Later, when done
+       * unsubscribe();
+       * ```
+       */
+      onFileChange(callback) {
+        this.fileChangeSubscribers.add(callback);
+        return () => this.fileChangeSubscribers.delete(callback);
+      }
+      /**
+       * Remove a file change subscriber
+       */
+      offFileChange(callback) {
+        this.fileChangeSubscribers.delete(callback);
+      }
+      /**
+       * Stop all watchers and cleanup
+       */
+      async stopAllWatching() {
+        const remotePromises = Array.from(this.remoteWatchers.values()).map((w) => w.stop());
+        const localPromises = Array.from(this.localWatchers.values()).map((w) => w.stop());
+        await Promise.all([...remotePromises, ...localPromises]);
+        this.remoteWatchers.clear();
+        this.localWatchers.clear();
+      }
+      /**
+       * Get watching status for all sessions
+       */
+      getWatchingStatus() {
+        const statuses = [];
+        for (const [sessionId, watcher] of this.remoteWatchers) {
+          statuses.push({ sessionId, type: "remote", isActive: watcher.isActive() });
+        }
+        for (const [sessionId, watcher] of this.localWatchers) {
+          statuses.push({ sessionId, type: "local", isActive: watcher.isActive() });
+        }
+        return statuses;
+      }
+    };
+  }
+});
+
+// src/runtime/in-sandbox-watcher.ts
+function createInSandboxWatcher(options) {
+  return new exports.InSandboxWatcher(options);
+}
+function getInSandboxWatcherManager() {
+  if (!globalInSandboxManager) {
+    globalInSandboxManager = new exports.InSandboxWatcherManager();
+  }
+  return globalInSandboxManager;
+}
+function createInSandboxWatcherManager() {
+  return new exports.InSandboxWatcherManager();
+}
+var WATCHER_SCRIPT; exports.InSandboxWatcher = void 0; exports.InSandboxWatcherManager = void 0; var globalInSandboxManager;
+var init_in_sandbox_watcher = __esm({
+  "src/runtime/in-sandbox-watcher.ts"() {
+    init_vercel_sandbox_executor();
+    WATCHER_SCRIPT = `
+const fs = require('fs');
+const path = require('path');
+
+const watchPath = process.argv[2] || '.';
+const ignored = new Set(['node_modules', '.git', '.cache', '__pycache__']);
+
+// Track all watchers for cleanup
+const watchers = new Map();
+
+// Debounce map to coalesce rapid changes
+const pending = new Map();
+const DEBOUNCE_MS = 100;
+
+function emit(type, filePath) {
+  const event = {
+    type,
+    path: filePath,
+    timestamp: Date.now()
+  };
+  console.log(JSON.stringify(event));
+}
+
+function shouldIgnore(name) {
+  return ignored.has(name) || name.startsWith('.');
+}
+
+function watchDir(dir) {
+  try {
+    const watcher = fs.watch(dir, { persistent: true }, (eventType, filename) => {
+      if (!filename || shouldIgnore(filename)) return;
+
+      const fullPath = path.join(dir, filename);
+      const key = fullPath;
+
+      // Debounce
+      if (pending.has(key)) {
+        clearTimeout(pending.get(key));
+      }
+
+      pending.set(key, setTimeout(() => {
+        pending.delete(key);
+
+        fs.stat(fullPath, (err, stats) => {
+          if (err) {
+            if (err.code === 'ENOENT') {
+              emit('unlink', fullPath);
+              // Stop watching if it was a directory
+              if (watchers.has(fullPath)) {
+                watchers.get(fullPath).close();
+                watchers.delete(fullPath);
+              }
+            }
+          } else {
+            const type = eventType === 'rename' ? 'add' : 'change';
+            emit(type, fullPath);
+
+            // If it's a new directory, start watching it
+            if (stats.isDirectory() && !watchers.has(fullPath)) {
+              watchDir(fullPath);
+            }
+          }
+        });
+      }, DEBOUNCE_MS));
+    });
+
+    watchers.set(dir, watcher);
+
+    // Watch subdirectories
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() && !shouldIgnore(entry.name)) {
+        watchDir(path.join(dir, entry.name));
+      }
+    }
+  } catch (err) {
+    // Directory may not exist or be inaccessible
+    console.error(JSON.stringify({ error: err.message, dir }));
+  }
+}
+
+// Start watching
+watchDir(watchPath);
+
+// Keep alive
+process.on('SIGTERM', () => {
+  for (const watcher of watchers.values()) {
+    watcher.close();
+  }
+  process.exit(0);
+});
+
+// Heartbeat to indicate we're running
+setInterval(() => {
+  console.log(JSON.stringify({ heartbeat: true, timestamp: Date.now() }));
+}, 5000);
+
+console.log(JSON.stringify({ started: true, path: watchPath }));
+`;
+    exports.InSandboxWatcher = class {
+      sessionId;
+      watchPath;
+      outputPollIntervalMs;
+      sandboxState = null;
+      outputPollTimer = null;
+      subscribers = /* @__PURE__ */ new Set();
+      isRunning = false;
+      startedAt;
+      lastHeartbeat;
+      lastOutputPosition = 0;
+      onError;
+      onReady;
+      constructor(options) {
+        this.sessionId = options.sessionId;
+        this.watchPath = options.watchPath;
+        this.outputPollIntervalMs = options.outputPollIntervalMs ?? 1e3;
+        this.onError = options.onError;
+        this.onReady = options.onReady;
+        if (options.onFileChange) {
+          this.subscribers.add(options.onFileChange);
+        }
+      }
+      /**
+       * Start the watcher process inside the sandbox
+       */
+      async start() {
+        if (this.isRunning) {
+          console.warn(`[IN_SANDBOX_WATCHER] Already running for session ${this.sessionId}`);
+          return;
+        }
+        try {
+          this.sandboxState = await getOrCreateSandbox({
+            sessionId: this.sessionId,
+            runtime: "node22",
+            timeout: 600
+          });
+          const { sandbox } = this.sandboxState;
+          const scriptPath = "/tmp/.file-watcher.js";
+          const outputPath = "/tmp/.file-watcher-output.log";
+          const writeScriptCmd = `cat > ${scriptPath} << 'WATCHER_EOF'
+${WATCHER_SCRIPT}
+WATCHER_EOF`;
+          await sandbox.runCommand({
+            cmd: "sh",
+            args: ["-c", writeScriptCmd]
+          });
+          const startCmd = `nohup node ${scriptPath} "${this.watchPath}" > ${outputPath} 2>&1 &`;
+          await sandbox.runCommand({
+            cmd: "sh",
+            args: ["-c", startCmd]
+          });
+          console.log(`[IN_SANDBOX_WATCHER] Started watcher in sandbox for ${this.watchPath}`);
+          this.isRunning = true;
+          this.startedAt = /* @__PURE__ */ new Date();
+          this.outputPollTimer = setInterval(async () => {
+            try {
+              await this.pollOutput(outputPath);
+            } catch (error) {
+              console.error("[IN_SANDBOX_WATCHER] Error polling output:", error);
+              if (this.onError && error instanceof Error) {
+                this.onError(error);
+              }
+            }
+          }, this.outputPollIntervalMs);
+          setTimeout(() => {
+            this.pollOutput(outputPath).catch(console.error);
+          }, 500);
+        } catch (error) {
+          console.error(`[IN_SANDBOX_WATCHER] Failed to start watcher:`, error);
+          throw error;
+        }
+      }
+      /**
+       * Poll the output file for new events
+       */
+      async pollOutput(outputPath) {
+        if (!this.sandboxState?.sandbox) return;
+        try {
+          const result = await this.sandboxState.sandbox.runCommand({
+            cmd: "sh",
+            args: ["-c", `tail -c +${this.lastOutputPosition + 1} ${outputPath} 2>/dev/null || true`]
+          });
+          const output = await result.stdout();
+          if (output && output.trim()) {
+            const sizeResult = await this.sandboxState.sandbox.runCommand({
+              cmd: "sh",
+              args: ["-c", `stat -c%s ${outputPath} 2>/dev/null || echo 0`]
+            });
+            const sizeStr = await sizeResult.stdout();
+            this.lastOutputPosition = parseInt(sizeStr.trim(), 10) || 0;
+            this.processOutput(output);
+          }
+        } catch {
+        }
+      }
+      /**
+       * Process output from the watcher script
+       */
+      processOutput(stdout) {
+        const lines = stdout.split("\n").filter(Boolean);
+        for (const line of lines) {
+          try {
+            const data = JSON.parse(line);
+            if (data.started) {
+              console.log(`[IN_SANDBOX_WATCHER] Watcher started for ${data.path}`);
+              if (this.onReady) {
+                this.onReady();
+              }
+            } else if (data.heartbeat) {
+              this.lastHeartbeat = new Date(data.timestamp);
+            } else if (data.error) {
+              console.warn(`[IN_SANDBOX_WATCHER] Error in sandbox:`, data.error);
+            } else if (data.type && data.path) {
+              this.emitEvent({
+                type: data.type,
+                relativePath: data.path.replace(/^\.\//, ""),
+                absolutePath: data.path,
+                sessionId: this.sessionId,
+                timestamp: new Date(data.timestamp)
+              });
+            }
+          } catch {
+          }
+        }
+      }
+      /**
+       * Stop the watcher process
+       */
+      async stop() {
+        if (!this.isRunning) {
+          return;
+        }
+        if (this.outputPollTimer) {
+          clearInterval(this.outputPollTimer);
+          this.outputPollTimer = null;
+        }
+        try {
+          if (this.sandboxState?.sandbox) {
+            await this.sandboxState.sandbox.runCommand({
+              cmd: "sh",
+              args: ["-c", "pkill -f file-watcher.js 2>/dev/null || true"]
+            });
+            await this.sandboxState.sandbox.runCommand({
+              cmd: "sh",
+              args: ["-c", "rm -f /tmp/.file-watcher.js /tmp/.file-watcher-output.log"]
+            });
+          }
+        } catch {
+        }
+        this.isRunning = false;
+        this.sandboxState = null;
+        this.lastOutputPosition = 0;
+        console.log(`[IN_SANDBOX_WATCHER] Stopped watcher for session ${this.sessionId}`);
+      }
+      /**
+       * Subscribe to file change events
+       */
+      subscribe(callback) {
+        this.subscribers.add(callback);
+        return () => this.subscribers.delete(callback);
+      }
+      /**
+       * Check if watcher is running
+       */
+      isActive() {
+        return this.isRunning;
+      }
+      /**
+       * Get watcher status
+       */
+      getStatus() {
+        return {
+          sessionId: this.sessionId,
+          watchPath: this.watchPath,
+          isRunning: this.isRunning,
+          startedAt: this.startedAt,
+          lastHeartbeat: this.lastHeartbeat
+        };
+      }
+      /**
+       * Emit event to all subscribers
+       */
+      async emitEvent(event) {
+        for (const callback of this.subscribers) {
+          try {
+            await callback(event);
+          } catch (error) {
+            console.error("[IN_SANDBOX_WATCHER] Error in subscriber callback:", error);
+          }
+        }
+      }
+    };
+    exports.InSandboxWatcherManager = class {
+      watchers = /* @__PURE__ */ new Map();
+      /**
+       * Start watching a sandbox
+       */
+      async startWatching(options) {
+        const { sessionId } = options;
+        await this.stopWatching(sessionId);
+        const watcher = new exports.InSandboxWatcher(options);
+        await watcher.start();
+        this.watchers.set(sessionId, watcher);
+        return watcher;
+      }
+      /**
+       * Stop watching a session
+       */
+      async stopWatching(sessionId) {
+        const watcher = this.watchers.get(sessionId);
+        if (watcher) {
+          await watcher.stop();
+          this.watchers.delete(sessionId);
+        }
+      }
+      /**
+       * Get watcher for a session
+       */
+      getWatcher(sessionId) {
+        return this.watchers.get(sessionId);
+      }
+      /**
+       * Check if watching
+       */
+      isWatching(sessionId) {
+        return this.watchers.get(sessionId)?.isActive() ?? false;
+      }
+      /**
+       * Stop all watchers
+       */
+      async stopAll() {
+        const promises = Array.from(this.watchers.values()).map((w) => w.stop());
+        await Promise.all(promises);
+        this.watchers.clear();
       }
     };
+    globalInSandboxManager = null;
   }
 });
 
@@ -6220,8 +7650,8 @@ function checkSecurityConfig(config) {
   }
   return { issues, warnings, recommendations };
 }
-function isSensitivePath(path14) {
-  const normalized = path14.replace(/\\/g, "/").toLowerCase();
+function isSensitivePath(path15) {
+  const normalized = path15.replace(/\\/g, "/").toLowerCase();
   for (const sensitive of exports.SENSITIVE_PATHS) {
     const pattern = sensitive.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/~/g, ".*");
     if (new RegExp(pattern).test(normalized)) {
@@ -6238,6 +7668,8 @@ var init_runtime = __esm({
     init_vercel_sandbox_executor();
     init_sandbox_file_sync();
     init_sandbox_pool();
+    init_sandbox_file_watcher();
+    init_in_sandbox_watcher();
     exports.RuntimePresets = {
       /**
        * Development mode - no isolation, for local testing
@@ -6348,8 +7780,8 @@ var init_runtime = __esm({
         this.config.pattern = pattern;
         return this;
       }
-      workingDirectory(path14) {
-        this.config.workingDirectory = path14;
+      workingDirectory(path15) {
+        this.config.workingDirectory = path15;
         return this;
       }
       sandbox(config) {
@@ -6587,7 +8019,7 @@ var init_local_provider = __esm({
       maxFileSize;
       constructor(source, options = {}) {
         this.source = source;
-        this.basePath = path3__namespace.resolve(source.localPath);
+        this.basePath = path4__namespace.resolve(source.localPath);
         this.maxFileSize = options.maxFileSize ?? DEFAULT_MAX_FILE_SIZE;
       }
       /**
@@ -6595,8 +8027,8 @@ var init_local_provider = __esm({
        * Prevents path traversal attacks.
        */
       resolvePath(relativePath) {
-        const normalized = path3__namespace.normalize(relativePath);
-        const resolved = path3__namespace.resolve(this.basePath, normalized);
+        const normalized = path4__namespace.normalize(relativePath);
+        const resolved = path4__namespace.resolve(this.basePath, normalized);
         if (!resolved.startsWith(this.basePath)) {
           throw new Error(`Path traversal detected: ${relativePath}`);
         }
@@ -6605,15 +8037,15 @@ var init_local_provider = __esm({
       async listFiles(relativePath) {
         const dirPath = this.resolvePath(relativePath || ".");
         try {
-          const entries = await fs9.promises.readdir(dirPath, { withFileTypes: true });
+          const entries = await fs10.promises.readdir(dirPath, { withFileTypes: true });
           const fileEntries = await Promise.all(
             entries.map(async (entry) => {
-              const entryPath = path3__namespace.join(relativePath || ".", entry.name);
-              const fullPath = path3__namespace.join(dirPath, entry.name);
+              const entryPath = path4__namespace.join(relativePath || ".", entry.name);
+              const fullPath = path4__namespace.join(dirPath, entry.name);
               let size;
               let modifiedAt;
               try {
-                const stats = await fs9.promises.stat(fullPath);
+                const stats = await fs10.promises.stat(fullPath);
                 size = entry.isFile() ? stats.size : void 0;
                 modifiedAt = stats.mtime;
               } catch {
@@ -6647,7 +8079,7 @@ var init_local_provider = __esm({
       async readFile(relativePath) {
         const filePath = this.resolvePath(relativePath);
         try {
-          const stats = await fs9.promises.stat(filePath);
+          const stats = await fs10.promises.stat(filePath);
           if (stats.isDirectory()) {
             throw new Error(`Cannot read directory as file: ${relativePath}`);
           }
@@ -6657,7 +8089,7 @@ var init_local_provider = __esm({
             );
           }
           try {
-            const content = await fs9.promises.readFile(filePath, "utf-8");
+            const content = await fs10.promises.readFile(filePath, "utf-8");
             return {
               path: relativePath,
               content,
@@ -6665,7 +8097,7 @@ var init_local_provider = __esm({
               size: stats.size
             };
           } catch {
-            const buffer = await fs9.promises.readFile(filePath);
+            const buffer = await fs10.promises.readFile(filePath);
             return {
               path: relativePath,
               content: buffer.toString("base64"),
@@ -6683,7 +8115,7 @@ var init_local_provider = __esm({
       async exists(relativePath) {
         try {
           const fullPath = this.resolvePath(relativePath);
-          const stats = await fs9.promises.stat(fullPath);
+          const stats = await fs10.promises.stat(fullPath);
           return stats.isDirectory() ? "directory" : "file";
         } catch {
           return null;
@@ -6692,7 +8124,7 @@ var init_local_provider = __esm({
       async copyTo(sourcePath, targetPath, recursive = true) {
         const sourceFullPath = this.resolvePath(sourcePath);
         try {
-          const stats = await fs9.promises.stat(sourceFullPath);
+          const stats = await fs10.promises.stat(sourceFullPath);
           if (stats.isDirectory()) {
             if (!recursive) {
               throw new Error(
@@ -6701,8 +8133,8 @@ var init_local_provider = __esm({
             }
             await this.copyDirectory(sourceFullPath, targetPath);
           } else {
-            await fs9.promises.mkdir(path3__namespace.dirname(targetPath), { recursive: true });
-            await fs9.promises.copyFile(sourceFullPath, targetPath);
+            await fs10.promises.mkdir(path4__namespace.dirname(targetPath), { recursive: true });
+            await fs10.promises.copyFile(sourceFullPath, targetPath);
           }
         } catch (error) {
           if (error.code === "ENOENT") {
@@ -6712,16 +8144,16 @@ var init_local_provider = __esm({
         }
       }
       async copyDirectory(sourceDir, targetDir) {
-        await fs9.promises.mkdir(targetDir, { recursive: true });
-        const entries = await fs9.promises.readdir(sourceDir, { withFileTypes: true });
+        await fs10.promises.mkdir(targetDir, { recursive: true });
+        const entries = await fs10.promises.readdir(sourceDir, { withFileTypes: true });
         await Promise.all(
           entries.map(async (entry) => {
-            const sourcePath = path3__namespace.join(sourceDir, entry.name);
-            const targetPath = path3__namespace.join(targetDir, entry.name);
+            const sourcePath = path4__namespace.join(sourceDir, entry.name);
+            const targetPath = path4__namespace.join(targetDir, entry.name);
             if (entry.isDirectory()) {
               await this.copyDirectory(sourcePath, targetPath);
             } else {
-              await fs9.promises.copyFile(sourcePath, targetPath);
+              await fs10.promises.copyFile(sourcePath, targetPath);
             }
           })
         );
@@ -6916,11 +8348,11 @@ var init_github_provider = __esm({
         }
         if (type === "file") {
           const content = await this.readFile(sourcePath);
-          await fs9.promises.mkdir(path3__namespace.dirname(targetPath), { recursive: true });
+          await fs10.promises.mkdir(path4__namespace.dirname(targetPath), { recursive: true });
           if (content.encoding === "base64") {
-            await fs9.promises.writeFile(targetPath, Buffer.from(content.content, "base64"));
+            await fs10.promises.writeFile(targetPath, Buffer.from(content.content, "base64"));
           } else {
-            await fs9.promises.writeFile(targetPath, content.content, "utf-8");
+            await fs10.promises.writeFile(targetPath, content.content, "utf-8");
           }
         } else {
           if (!recursive) {
@@ -6928,13 +8360,13 @@ var init_github_provider = __esm({
               `Cannot copy directory without recursive flag: ${sourcePath}`
             );
           }
-          await fs9.promises.mkdir(targetPath, { recursive: true });
+          await fs10.promises.mkdir(targetPath, { recursive: true });
           const entries = await this.listFiles(sourcePath);
           await Promise.all(
             entries.map(
               (entry) => this.copyTo(
                 entry.path,
-                path3__namespace.join(targetPath, entry.name),
+                path4__namespace.join(targetPath, entry.name),
                 recursive
               )
             )
@@ -7017,9 +8449,9 @@ var init_manager2 = __esm({
         if (enabledSkills.length === 0) {
           return "";
         }
-        const sessionDir = path3__namespace.join(this.tempDir, sessionId);
-        const skillsDir = path3__namespace.join(sessionDir, ".claude", "skills");
-        await fs9.promises.mkdir(skillsDir, { recursive: true });
+        const sessionDir = path4__namespace.join(this.tempDir, sessionId);
+        const skillsDir = path4__namespace.join(sessionDir, ".claude", "skills");
+        await fs10.promises.mkdir(skillsDir, { recursive: true });
         await Promise.all(
           enabledSkills.map((skill) => this.materializeSkill(skill, skillsDir, token))
         );
@@ -7030,10 +8462,10 @@ var init_manager2 = __esm({
        */
       async materializeSkill(skill, skillsDir, token) {
         const provider = this.createFileProvider(skill.source, token);
-        const skillDir = path3__namespace.join(skillsDir, skill.name);
-        await fs9.promises.mkdir(skillDir, { recursive: true });
+        const skillDir = path4__namespace.join(skillsDir, skill.name);
+        await fs10.promises.mkdir(skillDir, { recursive: true });
         for (const includePath of skill.includePaths) {
-          const targetPath = path3__namespace.join(skillDir, path3__namespace.basename(includePath));
+          const targetPath = path4__namespace.join(skillDir, path4__namespace.basename(includePath));
           try {
             await provider.copyTo(includePath, targetPath, true);
           } catch (error) {
@@ -7048,9 +8480,9 @@ var init_manager2 = __esm({
        * Clean up materialized skills for a session
        */
       async cleanupSession(sessionId) {
-        const sessionDir = path3__namespace.join(this.tempDir, sessionId);
+        const sessionDir = path4__namespace.join(this.tempDir, sessionId);
         try {
-          await fs9.promises.rm(sessionDir, { recursive: true, force: true });
+          await fs10.promises.rm(sessionDir, { recursive: true, force: true });
         } catch (error) {
           console.warn(`Failed to cleanup session directory: ${sessionDir}`, error);
         }
@@ -7061,16 +8493,16 @@ var init_manager2 = __esm({
        */
       async cleanupStale(maxAgeMs = 24 * 60 * 60 * 1e3) {
         try {
-          const entries = await fs9.promises.readdir(this.tempDir, { withFileTypes: true });
+          const entries = await fs10.promises.readdir(this.tempDir, { withFileTypes: true });
           const now = Date.now();
           await Promise.all(
             entries.map(async (entry) => {
               if (!entry.isDirectory()) return;
-              const dirPath = path3__namespace.join(this.tempDir, entry.name);
+              const dirPath = path4__namespace.join(this.tempDir, entry.name);
               try {
-                const stats = await fs9.promises.stat(dirPath);
+                const stats = await fs10.promises.stat(dirPath);
                 if (now - stats.mtimeMs > maxAgeMs) {
-                  await fs9.promises.rm(dirPath, { recursive: true, force: true });
+                  await fs10.promises.rm(dirPath, { recursive: true, force: true });
                 }
               } catch {
               }
@@ -9875,11 +11307,11 @@ var init_dist = __esm({
         return isZodType(schema, "ZodEffects") ? this.cleanParameter(schema._def.schema) : schema;
       }
       generatePath(route) {
-        const { method, path: path14, request, responses } = route, pathItemConfig = __rest(route, ["method", "path", "request", "responses"]);
+        const { method, path: path15, request, responses } = route, pathItemConfig = __rest(route, ["method", "path", "request", "responses"]);
         const generatedResponses = mapValues(responses, (response) => {
           return this.getResponse(response);
         });
-        const parameters = enhanceMissingParametersError(() => this.getParameters(request), { route: `${method} ${path14}` });
+        const parameters = enhanceMissingParametersError(() => this.getParameters(request), { route: `${method} ${path15}` });
         const requestBody = this.getRequestBody(request === null || request === void 0 ? void 0 : request.body);
         const routeDoc = {
           [method]: Object.assign(Object.assign(Object.assign(Object.assign({}, pathItemConfig), parameters.length > 0 ? {
@@ -10074,8 +11506,8 @@ var init_dist2 = __esm({
 });
 function addBasePathToDocument(document, basePath) {
   const updatedPaths = {};
-  Object.keys(document.paths).forEach((path14) => {
-    updatedPaths[url.mergePath(basePath.replaceAll(/:([^\/]+)/g, "{$1}"), path14)] = document.paths[path14];
+  Object.keys(document.paths).forEach((path15) => {
+    updatedPaths[url.mergePath(basePath.replaceAll(/:([^\/]+)/g, "{$1}"), path15)] = document.paths[path15];
   });
   return {
     ...document,
@@ -10219,8 +11651,8 @@ var init_dist3 = __esm({
         const document = generator.generateDocument(config);
         return this._basePath ? addBasePathToDocument(document, this._basePath) : document;
       };
-      doc = (path14, configure) => {
-        return this.get(path14, (c) => {
+      doc = (path15, configure) => {
+        return this.get(path15, (c) => {
           const config = typeof configure === "function" ? configure(c) : configure;
           try {
             const document = this.getOpenAPIDocument(config);
@@ -10230,8 +11662,8 @@ var init_dist3 = __esm({
           }
         });
       };
-      doc31 = (path14, configure) => {
-        return this.get(path14, (c) => {
+      doc31 = (path15, configure) => {
+        return this.get(path15, (c) => {
           const config = typeof configure === "function" ? configure(c) : configure;
           try {
             const document = this.getOpenAPI31Document(config);
@@ -10241,9 +11673,9 @@ var init_dist3 = __esm({
           }
         });
       };
-      route(path14, app) {
-        const pathForOpenAPI = path14.replaceAll(/:([^\/]+)/g, "{$1}");
-        super.route(path14, app);
+      route(path15, app) {
+        const pathForOpenAPI = path15.replaceAll(/:([^\/]+)/g, "{$1}");
+        super.route(path15, app);
         if (!(app instanceof _OpenAPIHono)) {
           return this;
         }
@@ -10290,8 +11722,8 @@ var init_dist3 = __esm({
         });
         return this;
       }
-      basePath(path14) {
-        return new _OpenAPIHono({ ...super.basePath(path14), defaultHook: this.defaultHook });
+      basePath(path15) {
+        return new _OpenAPIHono({ ...super.basePath(path15), defaultHook: this.defaultHook });
       }
     };
     createRoute = (routeConfig) => {
@@ -12072,12 +13504,12 @@ function requestLogger(options = {}) {
     const requestId = generateId();
     const start = Date.now();
     const method = c.req.method;
-    const path14 = c.req.path;
+    const path15 = c.req.path;
     c.set("requestId", requestId);
     logger3.debug("Request started", {
       requestId,
       method,
-      path: path14,
+      path: path15,
       userAgent: c.req.header("user-agent")
     });
     await next();
@@ -12087,7 +13519,7 @@ function requestLogger(options = {}) {
     logFn("Request completed", {
       requestId,
       method,
-      path: path14,
+      path: path15,
       status,
       duration: `${duration}ms`
     });
@@ -12572,8 +14004,8 @@ function shellQuote3(str) {
 async function loadWorkspaceState(workspaceId, sandbox, bundleStore, repoRoot) {
   const resolvedRoot = repoRoot ?? sandbox.defaultRepoRoot;
   const gitRepo = new exports.SandboxGitRepo(sandbox, resolvedRoot);
-  const tmpDir = fs9__namespace.mkdtempSync(path3__namespace.join(os__namespace.tmpdir(), "ash-workspace-"));
-  const localBundle = path3__namespace.join(tmpDir, `${workspaceId}.bundle`);
+  const tmpDir = fs10__namespace.mkdtempSync(path4__namespace.join(os__namespace.tmpdir(), "ash-workspace-"));
+  const localBundle = path4__namespace.join(tmpDir, `${workspaceId}.bundle`);
   try {
     const bundleExists = await Promise.resolve(
       bundleStore.downloadBundle(workspaceId, localBundle)
@@ -12609,7 +14041,7 @@ async function loadWorkspaceState(workspaceId, sandbox, bundleStore, repoRoot) {
     }
   } finally {
     try {
-      fs9__namespace.rmSync(tmpDir, { recursive: true, force: true });
+      fs10__namespace.rmSync(tmpDir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -12629,11 +14061,11 @@ async function saveWorkspaceState(workspaceId, sandbox, gitRepo, bundleStore, co
   }
   const remoteBundlePath = BUNDLE_PATH_TEMPLATE.replace("{workspaceId}", workspaceId);
   await gitRepo.createBundle(remoteBundlePath);
-  const tmpDir = fs9__namespace.mkdtempSync(path3__namespace.join(os__namespace.tmpdir(), "ash-workspace-"));
-  const localBundle = path3__namespace.join(tmpDir, `${workspaceId}.bundle`);
+  const tmpDir = fs10__namespace.mkdtempSync(path4__namespace.join(os__namespace.tmpdir(), "ash-workspace-"));
+  const localBundle = path4__namespace.join(tmpDir, `${workspaceId}.bundle`);
   try {
     await sandbox.downloadFile(remoteBundlePath, localBundle);
-    const bundleSize = fs9__namespace.statSync(localBundle).size;
+    const bundleSize = fs10__namespace.statSync(localBundle).size;
     await bundleStore.uploadBundle(workspaceId, localBundle);
     return {
       committed,
@@ -12642,7 +14074,7 @@ async function saveWorkspaceState(workspaceId, sandbox, gitRepo, bundleStore, co
     };
   } finally {
     try {
-      fs9__namespace.rmSync(tmpDir, { recursive: true, force: true });
+      fs10__namespace.rmSync(tmpDir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -12655,7 +14087,7 @@ var init_persistence = __esm({
   }
 });
 async function cloneRepository(url, ref, timeout = 12e4) {
-  const tmpDir = fs9__namespace.mkdtempSync(path3__namespace.join(os__namespace.tmpdir(), "ash-github-skill-"));
+  const tmpDir = fs10__namespace.mkdtempSync(path4__namespace.join(os__namespace.tmpdir(), "ash-github-skill-"));
   try {
     const cloneCmd = ["git", "clone", "--depth", "1"];
     if (ref) {
@@ -12670,7 +14102,7 @@ async function cloneRepository(url, ref, timeout = 12e4) {
     return tmpDir;
   } catch (error) {
     try {
-      fs9__namespace.rmSync(tmpDir, { recursive: true, force: true });
+      fs10__namespace.rmSync(tmpDir, { recursive: true, force: true });
     } catch {
     }
     throw error;
@@ -12682,10 +14114,10 @@ function getRepoName(url) {
 }
 function countFiles(dir, exclude) {
   let count = 0;
-  const entries = fs9__namespace.readdirSync(dir, { withFileTypes: true });
+  const entries = fs10__namespace.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (exclude.has(entry.name)) continue;
-    const fullPath = path3__namespace.join(dir, entry.name);
+    const fullPath = path4__namespace.join(dir, entry.name);
     if (entry.isDirectory()) {
       count += countFiles(fullPath, exclude);
     } else if (entry.isFile()) {
@@ -12697,15 +14129,15 @@ function countFiles(dir, exclude) {
 async function uploadDirectory(sandbox, localPath, remotePath, exclude) {
   let uploadCount = 0;
   await sandbox.runCommand(`mkdir -p '${remotePath}'`);
-  const entries = fs9__namespace.readdirSync(localPath, { withFileTypes: true });
+  const entries = fs10__namespace.readdirSync(localPath, { withFileTypes: true });
   for (const entry of entries) {
     if (exclude.has(entry.name)) continue;
-    const srcPath = path3__namespace.join(localPath, entry.name);
+    const srcPath = path4__namespace.join(localPath, entry.name);
     const destPath = `${remotePath}/${entry.name}`;
     if (entry.isDirectory()) {
       uploadCount += await uploadDirectory(sandbox, srcPath, destPath, exclude);
     } else if (entry.isFile()) {
-      const content = fs9__namespace.readFileSync(srcPath, "utf-8");
+      const content = fs10__namespace.readFileSync(srcPath, "utf-8");
       await sandbox.writeFile(destPath, content);
       uploadCount++;
     }
@@ -12731,13 +14163,13 @@ async function loadGitHubSkill(sandbox, config, skillsBasePath) {
     );
   }
   try {
-    const sourcePath = subpath ? path3__namespace.join(clonePath, subpath) : clonePath;
-    if (!fs9__namespace.existsSync(sourcePath)) {
+    const sourcePath = subpath ? path4__namespace.join(clonePath, subpath) : clonePath;
+    if (!fs10__namespace.existsSync(sourcePath)) {
       throw new Error(
         `Path '${subpath}' not found in repository ${url}`
       );
     }
-    if (!fs9__namespace.statSync(sourcePath).isDirectory()) {
+    if (!fs10__namespace.statSync(sourcePath).isDirectory()) {
       throw new Error(
         `Path '${subpath}' in ${url} is not a directory`
       );
@@ -12756,7 +14188,7 @@ async function loadGitHubSkill(sandbox, config, skillsBasePath) {
     };
   } finally {
     try {
-      fs9__namespace.rmSync(clonePath, { recursive: true, force: true });
+      fs10__namespace.rmSync(clonePath, { recursive: true, force: true });
     } catch {
     }
   }
@@ -13449,26 +14881,26 @@ var init_workspace = __esm({
         const localPaths = normalizeToArray(skillsConfig.local);
         for (const localPath of localPaths) {
           try {
-            if (!fs9__namespace.existsSync(localPath)) {
+            if (!fs10__namespace.existsSync(localPath)) {
               errors.push({
                 source: localPath,
                 error: new Error(`Path does not exist: ${localPath}`)
               });
               continue;
             }
-            const stat = fs9__namespace.statSync(localPath);
-            if (!stat.isDirectory()) {
+            const stat2 = fs10__namespace.statSync(localPath);
+            if (!stat2.isDirectory()) {
               errors.push({
                 source: localPath,
                 error: new Error(`Path is not a directory: ${localPath}`)
               });
               continue;
             }
-            const entries = fs9__namespace.readdirSync(localPath);
+            const entries = fs10__namespace.readdirSync(localPath);
             for (const entry of entries) {
               if (FILTERED_ITEMS2.has(entry)) continue;
-              const entryPath = path3__namespace.join(localPath, entry);
-              const entryStat = fs9__namespace.statSync(entryPath);
+              const entryPath = path4__namespace.join(localPath, entry);
+              const entryStat = fs10__namespace.statSync(entryPath);
               if (entryStat.isDirectory()) {
                 const remotePath = `${skillsBase}/${entry}`;
                 await this.sandbox.uploadDirectory(entryPath, remotePath, {
@@ -13553,50 +14985,50 @@ var init_bundle_store = __esm({
       directory;
       constructor(options) {
         this.directory = options.directory;
-        if (!fs9__namespace.existsSync(this.directory)) {
-          fs9__namespace.mkdirSync(this.directory, { recursive: true });
+        if (!fs10__namespace.existsSync(this.directory)) {
+          fs10__namespace.mkdirSync(this.directory, { recursive: true });
         }
       }
       keyForWorkspace(workspaceId) {
-        return path3__namespace.join(this.directory, `${workspaceId}.bundle`);
+        return path4__namespace.join(this.directory, `${workspaceId}.bundle`);
       }
       downloadBundle(workspaceId, destPath) {
         const bundlePath = this.keyForWorkspace(workspaceId);
-        if (!fs9__namespace.existsSync(bundlePath)) {
+        if (!fs10__namespace.existsSync(bundlePath)) {
           return false;
         }
-        const destDir = path3__namespace.dirname(destPath);
-        if (!fs9__namespace.existsSync(destDir)) {
-          fs9__namespace.mkdirSync(destDir, { recursive: true });
+        const destDir = path4__namespace.dirname(destPath);
+        if (!fs10__namespace.existsSync(destDir)) {
+          fs10__namespace.mkdirSync(destDir, { recursive: true });
         }
-        fs9__namespace.copyFileSync(bundlePath, destPath);
+        fs10__namespace.copyFileSync(bundlePath, destPath);
         return true;
       }
       uploadBundle(workspaceId, srcPath) {
-        if (!fs9__namespace.existsSync(srcPath)) {
+        if (!fs10__namespace.existsSync(srcPath)) {
           throw new Error(`Source bundle not found: ${srcPath}`);
         }
         const bundlePath = this.keyForWorkspace(workspaceId);
-        const bundleDir = path3__namespace.dirname(bundlePath);
-        if (!fs9__namespace.existsSync(bundleDir)) {
-          fs9__namespace.mkdirSync(bundleDir, { recursive: true });
+        const bundleDir = path4__namespace.dirname(bundlePath);
+        if (!fs10__namespace.existsSync(bundleDir)) {
+          fs10__namespace.mkdirSync(bundleDir, { recursive: true });
         }
-        fs9__namespace.copyFileSync(srcPath, bundlePath);
+        fs10__namespace.copyFileSync(srcPath, bundlePath);
       }
       exists(workspaceId) {
-        return fs9__namespace.existsSync(this.keyForWorkspace(workspaceId));
+        return fs10__namespace.existsSync(this.keyForWorkspace(workspaceId));
       }
       deleteBundle(workspaceId) {
         const bundlePath = this.keyForWorkspace(workspaceId);
-        if (fs9__namespace.existsSync(bundlePath)) {
-          fs9__namespace.unlinkSync(bundlePath);
+        if (fs10__namespace.existsSync(bundlePath)) {
+          fs10__namespace.unlinkSync(bundlePath);
         }
       }
       listWorkspaces() {
-        if (!fs9__namespace.existsSync(this.directory)) {
+        if (!fs10__namespace.existsSync(this.directory)) {
           return [];
         }
-        return fs9__namespace.readdirSync(this.directory).filter((file) => file.endsWith(".bundle")).map((file) => file.replace(".bundle", ""));
+        return fs10__namespace.readdirSync(this.directory).filter((file) => file.endsWith(".bundle")).map((file) => file.replace(".bundle", ""));
       }
     };
     exports.MemoryBundleStore = class {
@@ -13609,18 +15041,18 @@ var init_bundle_store = __esm({
         if (!bundle) {
           return false;
         }
-        const destDir = path3__namespace.dirname(destPath);
-        if (!fs9__namespace.existsSync(destDir)) {
-          fs9__namespace.mkdirSync(destDir, { recursive: true });
+        const destDir = path4__namespace.dirname(destPath);
+        if (!fs10__namespace.existsSync(destDir)) {
+          fs10__namespace.mkdirSync(destDir, { recursive: true });
         }
-        fs9__namespace.writeFileSync(destPath, bundle);
+        fs10__namespace.writeFileSync(destPath, bundle);
         return true;
       }
       uploadBundle(workspaceId, srcPath) {
-        if (!fs9__namespace.existsSync(srcPath)) {
+        if (!fs10__namespace.existsSync(srcPath)) {
           throw new Error(`Source bundle not found: ${srcPath}`);
         }
-        const content = fs9__namespace.readFileSync(srcPath);
+        const content = fs10__namespace.readFileSync(srcPath);
         this.bundles.set(workspaceId, content);
       }
       exists(workspaceId) {
@@ -13711,21 +15143,21 @@ var init_supabase_store = __esm({
         if (!data) {
           return false;
         }
-        const dir = path3__namespace.dirname(destPath);
-        if (!fs9__namespace.existsSync(dir)) {
-          fs9__namespace.mkdirSync(dir, { recursive: true });
+        const dir = path4__namespace.dirname(destPath);
+        if (!fs10__namespace.existsSync(dir)) {
+          fs10__namespace.mkdirSync(dir, { recursive: true });
         }
         const arrayBuffer = await data.arrayBuffer();
-        fs9__namespace.writeFileSync(destPath, Buffer.from(arrayBuffer));
+        fs10__namespace.writeFileSync(destPath, Buffer.from(arrayBuffer));
         return true;
       }
       async uploadBundle(workspaceId, srcPath) {
-        if (!fs9__namespace.existsSync(srcPath)) {
+        if (!fs10__namespace.existsSync(srcPath)) {
           throw new Error(`Source bundle not found: ${srcPath}`);
         }
         const client = await this.ensureClient();
         const key = this.keyForWorkspace(workspaceId);
-        const content = fs9__namespace.readFileSync(srcPath);
+        const content = fs10__namespace.readFileSync(srcPath);
         const { error } = await client.storage.from(this.bucket).upload(key, content, {
           contentType: "application/octet-stream",
           upsert: true
@@ -13854,11 +15286,11 @@ var init_cloud_store = __esm({
             return false;
           }
           const bytes = await body.transformToByteArray();
-          const dir = path3__namespace.dirname(destPath);
-          if (!fs9__namespace.existsSync(dir)) {
-            fs9__namespace.mkdirSync(dir, { recursive: true });
+          const dir = path4__namespace.dirname(destPath);
+          if (!fs10__namespace.existsSync(dir)) {
+            fs10__namespace.mkdirSync(dir, { recursive: true });
           }
-          fs9__namespace.writeFileSync(destPath, Buffer.from(bytes));
+          fs10__namespace.writeFileSync(destPath, Buffer.from(bytes));
           return true;
         } catch (error) {
           const err = error;
@@ -13869,12 +15301,12 @@ var init_cloud_store = __esm({
         }
       }
       async uploadBundle(workspaceId, srcPath) {
-        if (!fs9__namespace.existsSync(srcPath)) {
+        if (!fs10__namespace.existsSync(srcPath)) {
           throw new Error(`Source bundle not found: ${srcPath}`);
         }
         const { client, module } = await this.ensureClient();
         const key = this.keyForWorkspace(workspaceId);
-        const content = fs9__namespace.readFileSync(srcPath);
+        const content = fs10__namespace.readFileSync(srcPath);
         await client.send(
           new module.PutObjectCommand({
             Bucket: this.bucket,
@@ -13976,9 +15408,9 @@ var init_cloud_store = __esm({
           if (!exists) {
             return false;
           }
-          const dir = path3__namespace.dirname(destPath);
-          if (!fs9__namespace.existsSync(dir)) {
-            fs9__namespace.mkdirSync(dir, { recursive: true });
+          const dir = path4__namespace.dirname(destPath);
+          if (!fs10__namespace.existsSync(dir)) {
+            fs10__namespace.mkdirSync(dir, { recursive: true });
           }
           await file.download({ destination: destPath });
           return true;
@@ -13987,12 +15419,12 @@ var init_cloud_store = __esm({
         }
       }
       async uploadBundle(workspaceId, srcPath) {
-        if (!fs9__namespace.existsSync(srcPath)) {
+        if (!fs10__namespace.existsSync(srcPath)) {
           throw new Error(`Source bundle not found: ${srcPath}`);
         }
         const storage = await this.ensureStorage();
         const key = this.keyForWorkspace(workspaceId);
-        const content = fs9__namespace.readFileSync(srcPath);
+        const content = fs10__namespace.readFileSync(srcPath);
         const file = storage.bucket(this.bucket).file(key);
         await file.save(content);
       }
@@ -14091,25 +15523,25 @@ var init_file_store = __esm({
       /**
        * Generate the S3 key for a file
        */
-      keyForFile(sessionId, path14) {
-        const normalizedPath = path14.replace(/^\/+/, "");
+      keyForFile(sessionId, path15) {
+        const normalizedPath = path15.replace(/^\/+/, "");
         return `${this.prefix}${sessionId}/${normalizedPath}`;
       }
-      async writeFile(sessionId, path14, content) {
+      async writeFile(sessionId, path15, content) {
         const { client, module } = await this.ensureClient();
-        const key = this.keyForFile(sessionId, path14);
+        const key = this.keyForFile(sessionId, path15);
         await client.send(
           new module.PutObjectCommand({
             Bucket: this.bucket,
             Key: key,
             Body: content,
-            ContentType: this.getMimeType(path14)
+            ContentType: this.getMimeType(path15)
           })
         );
       }
-      async readFile(sessionId, path14) {
+      async readFile(sessionId, path15) {
         const { client, module } = await this.ensureClient();
-        const key = this.keyForFile(sessionId, path14);
+        const key = this.keyForFile(sessionId, path15);
         try {
           const response = await client.send(
             new module.GetObjectCommand({
@@ -14131,9 +15563,9 @@ var init_file_store = __esm({
           throw error;
         }
       }
-      async exists(sessionId, path14) {
+      async exists(sessionId, path15) {
         const { client, module } = await this.ensureClient();
-        const key = this.keyForFile(sessionId, path14);
+        const key = this.keyForFile(sessionId, path15);
         try {
           await client.send(
             new module.HeadObjectCommand({
@@ -14150,9 +15582,9 @@ var init_file_store = __esm({
           throw error;
         }
       }
-      async deleteFile(sessionId, path14) {
+      async deleteFile(sessionId, path15) {
         const { client, module } = await this.ensureClient();
-        const key = this.keyForFile(sessionId, path14);
+        const key = this.keyForFile(sessionId, path15);
         await client.send(
           new module.DeleteObjectCommand({
             Bucket: this.bucket,
@@ -14207,30 +15639,30 @@ var init_file_store = __esm({
           );
         }
       }
-      async getSignedUrl(sessionId, path14, expiresIn = 3600) {
+      async getSignedUrl(sessionId, path15, expiresIn = 3600) {
         const { client, module, presigner } = await this.ensureClient();
-        const key = this.keyForFile(sessionId, path14);
+        const key = this.keyForFile(sessionId, path15);
         const command = new module.GetObjectCommand({
           Bucket: this.bucket,
           Key: key
         });
         return presigner.getSignedUrl(client, command, { expiresIn });
       }
-      async getUploadUrl(sessionId, path14, expiresIn = 3600) {
+      async getUploadUrl(sessionId, path15, expiresIn = 3600) {
         const { client, module, presigner } = await this.ensureClient();
-        const key = this.keyForFile(sessionId, path14);
+        const key = this.keyForFile(sessionId, path15);
         const command = new module.PutObjectCommand({
           Bucket: this.bucket,
           Key: key,
-          ContentType: this.getMimeType(path14)
+          ContentType: this.getMimeType(path15)
         });
         return presigner.getSignedUrl(client, command, { expiresIn });
       }
       /**
        * Get MIME type based on file extension
        */
-      getMimeType(path14) {
-        const ext = path14.split(".").pop()?.toLowerCase();
+      getMimeType(path15) {
+        const ext = path15.split(".").pop()?.toLowerCase();
         const mimeTypes = {
           // Text
           txt: "text/plain",
@@ -14285,8 +15717,8 @@ var init_local_sandbox = __esm({
         this.defaultRepoRoot = config.defaultRepoRoot ?? `${this.workingDirectory}/repo`;
         this.env = { ...process.env, ...config.env };
         this.timeout = config.timeout ?? 3e4;
-        if (!fs9__namespace.existsSync(this.workingDirectory)) {
-          fs9__namespace.mkdirSync(this.workingDirectory, { recursive: true });
+        if (!fs10__namespace.existsSync(this.workingDirectory)) {
+          fs10__namespace.mkdirSync(this.workingDirectory, { recursive: true });
         }
       }
       runCommand(command) {
@@ -14315,51 +15747,51 @@ var init_local_sandbox = __esm({
         }
       }
       uploadFile(localPath, remotePath) {
-        const dir = path3__namespace.dirname(remotePath);
-        if (!fs9__namespace.existsSync(dir)) {
-          fs9__namespace.mkdirSync(dir, { recursive: true });
+        const dir = path4__namespace.dirname(remotePath);
+        if (!fs10__namespace.existsSync(dir)) {
+          fs10__namespace.mkdirSync(dir, { recursive: true });
         }
-        fs9__namespace.copyFileSync(localPath, remotePath);
+        fs10__namespace.copyFileSync(localPath, remotePath);
       }
       downloadFile(remotePath, localPath) {
-        const dir = path3__namespace.dirname(localPath);
-        if (!fs9__namespace.existsSync(dir)) {
-          fs9__namespace.mkdirSync(dir, { recursive: true });
+        const dir = path4__namespace.dirname(localPath);
+        if (!fs10__namespace.existsSync(dir)) {
+          fs10__namespace.mkdirSync(dir, { recursive: true });
         }
-        fs9__namespace.copyFileSync(remotePath, localPath);
+        fs10__namespace.copyFileSync(remotePath, localPath);
       }
       uploadDirectory(localPath, remotePath, options) {
         const exclude = options?.exclude ?? /* @__PURE__ */ new Set();
-        if (!fs9__namespace.existsSync(remotePath)) {
-          fs9__namespace.mkdirSync(remotePath, { recursive: true });
+        if (!fs10__namespace.existsSync(remotePath)) {
+          fs10__namespace.mkdirSync(remotePath, { recursive: true });
         }
         const copyRecursive = (src, dest) => {
-          const entries = fs9__namespace.readdirSync(src, { withFileTypes: true });
+          const entries = fs10__namespace.readdirSync(src, { withFileTypes: true });
           for (const entry of entries) {
             if (exclude.has(entry.name)) continue;
-            const srcPath = path3__namespace.join(src, entry.name);
-            const destPath = path3__namespace.join(dest, entry.name);
+            const srcPath = path4__namespace.join(src, entry.name);
+            const destPath = path4__namespace.join(dest, entry.name);
             if (entry.isDirectory()) {
-              if (!fs9__namespace.existsSync(destPath)) {
-                fs9__namespace.mkdirSync(destPath, { recursive: true });
+              if (!fs10__namespace.existsSync(destPath)) {
+                fs10__namespace.mkdirSync(destPath, { recursive: true });
               }
               copyRecursive(srcPath, destPath);
             } else if (entry.isFile()) {
-              fs9__namespace.copyFileSync(srcPath, destPath);
+              fs10__namespace.copyFileSync(srcPath, destPath);
             }
           }
         };
         copyRecursive(localPath, remotePath);
       }
       readFile(remotePath) {
-        return fs9__namespace.readFileSync(remotePath, "utf-8");
+        return fs10__namespace.readFileSync(remotePath, "utf-8");
       }
       writeFile(remotePath, content) {
-        const dir = path3__namespace.dirname(remotePath);
-        if (!fs9__namespace.existsSync(dir)) {
-          fs9__namespace.mkdirSync(dir, { recursive: true });
+        const dir = path4__namespace.dirname(remotePath);
+        if (!fs10__namespace.existsSync(dir)) {
+          fs10__namespace.mkdirSync(dir, { recursive: true });
         }
-        fs9__namespace.writeFileSync(remotePath, content, "utf-8");
+        fs10__namespace.writeFileSync(remotePath, content, "utf-8");
       }
       close() {
       }
@@ -14367,8 +15799,8 @@ var init_local_sandbox = __esm({
        * Clean up the working directory
        */
       cleanup() {
-        if (fs9__namespace.existsSync(this.workingDirectory)) {
-          fs9__namespace.rmSync(this.workingDirectory, { recursive: true, force: true });
+        if (fs10__namespace.existsSync(this.workingDirectory)) {
+          fs10__namespace.rmSync(this.workingDirectory, { recursive: true, force: true });
         }
       }
     };
@@ -14478,33 +15910,33 @@ var init_provider_sandbox = __esm({
       }
       async uploadFile(localPath, remotePath) {
         await this.initialize();
-        const content = fs9__namespace.readFileSync(localPath);
+        const content = fs10__namespace.readFileSync(localPath);
         await this.provider.writeFile(this.getSandboxId(), remotePath, content);
       }
       async downloadFile(remotePath, localPath) {
         await this.initialize();
         const content = await this.provider.readFile(this.getSandboxId(), remotePath);
-        const dir = path3__namespace.dirname(localPath);
-        if (!fs9__namespace.existsSync(dir)) {
-          fs9__namespace.mkdirSync(dir, { recursive: true });
+        const dir = path4__namespace.dirname(localPath);
+        if (!fs10__namespace.existsSync(dir)) {
+          fs10__namespace.mkdirSync(dir, { recursive: true });
         }
-        fs9__namespace.writeFileSync(localPath, content);
+        fs10__namespace.writeFileSync(localPath, content);
       }
       async uploadDirectory(localPath, remotePath, options) {
         await this.initialize();
         const exclude = options?.exclude ?? /* @__PURE__ */ new Set();
         await this.runCommand(`mkdir -p '${remotePath}'`);
         const uploadRecursive = async (src, dest) => {
-          const entries = fs9__namespace.readdirSync(src, { withFileTypes: true });
+          const entries = fs10__namespace.readdirSync(src, { withFileTypes: true });
           for (const entry of entries) {
             if (exclude.has(entry.name)) continue;
-            const srcPath = path3__namespace.join(src, entry.name);
+            const srcPath = path4__namespace.join(src, entry.name);
             const destPath = `${dest}/${entry.name}`;
             if (entry.isDirectory()) {
               await this.runCommand(`mkdir -p '${destPath}'`);
               await uploadRecursive(srcPath, destPath);
             } else if (entry.isFile()) {
-              const content = fs9__namespace.readFileSync(srcPath);
+              const content = fs10__namespace.readFileSync(srcPath);
               await this.provider.writeFile(this.getSandboxId(), destPath, content);
             }
           }
@@ -14742,16 +16174,19 @@ __export(schema_exports, {
   configDeploymentTriggerEnum: () => configDeploymentTriggerEnum,
   configDeployments: () => configDeployments,
   configDeploymentsRelations: () => configDeploymentsRelations,
+  eventCategoryEnum: () => eventCategoryEnum,
   messageRoleEnum: () => messageRoleEnum,
   messages: () => messages,
   messagesRelations: () => messagesRelations,
   queueItemStatusEnum: () => queueItemStatusEnum,
   queueItems: () => queueItems,
+  sessionEvents: () => sessionEvents,
+  sessionEventsRelations: () => sessionEventsRelations,
   sessionStatusEnum: () => sessionStatusEnum,
   sessions: () => sessions,
   sessionsRelations: () => sessionsRelations
 });
-var sessionStatusEnum, messageRoleEnum, agentStatusEnum, agentBackendEnum, queueItemStatusEnum, configDeploymentStatusEnum, configDeploymentTriggerEnum, sessions, messages, attachments, agents, queueItems, configDeployments, sessionsRelations, messagesRelations, attachmentsRelations, configDeploymentsRelations, agentsRelations;
+var sessionStatusEnum, messageRoleEnum, agentStatusEnum, agentBackendEnum, queueItemStatusEnum, configDeploymentStatusEnum, configDeploymentTriggerEnum, eventCategoryEnum, sessions, messages, attachments, agents, queueItems, configDeployments, sessionEvents, sessionsRelations, sessionEventsRelations, messagesRelations, attachmentsRelations, configDeploymentsRelations, agentsRelations;
 var init_schema = __esm({
   "src/storage-postgres/schema.ts"() {
     sessionStatusEnum = pgCore.pgEnum("session_status", [
@@ -14793,6 +16228,22 @@ var init_schema = __esm({
       "initial",
       "rollback"
     ]);
+    eventCategoryEnum = pgCore.pgEnum("event_category", [
+      "lifecycle",
+      // session_start, session_end, turn_complete
+      "content",
+      // text_stream (aggregated), thinking_stream
+      "tool",
+      // tool_use, tool_result
+      "system",
+      // mcp_status, sandbox_log
+      "error",
+      // error events
+      "file",
+      // file_push, file_pull, file_sync (file sync operations)
+      "input"
+      // user_input (user prompts/messages)
+    ]);
     sessions = pgCore.pgTable(
       "sessions",
       {
@@ -14948,6 +16399,32 @@ var init_schema = __esm({
         pgCore.index("idx_config_deployments_created").on(table.agentId, table.createdAt)
       ]
     );
+    sessionEvents = pgCore.pgTable(
+      "session_events",
+      {
+        id: pgCore.uuid("id").defaultRandom().primaryKey(),
+        sessionId: pgCore.uuid("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+        eventType: pgCore.text("event_type").notNull(),
+        category: eventCategoryEnum("category").notNull(),
+        startedAt: pgCore.timestamp("started_at", { withTimezone: true }).notNull(),
+        endedAt: pgCore.timestamp("ended_at", { withTimezone: true }),
+        durationMs: pgCore.integer("duration_ms"),
+        eventData: pgCore.jsonb("event_data").default({}).$type(),
+        // Tool-specific fields
+        toolUseId: pgCore.text("tool_use_id"),
+        toolName: pgCore.text("tool_name"),
+        // Aggregation fields (for text_stream events)
+        isAggregated: pgCore.boolean("is_aggregated").default(false),
+        aggregatedCount: pgCore.integer("aggregated_count"),
+        // Ordering
+        sequenceNumber: pgCore.integer("sequence_number").notNull(),
+        createdAt: pgCore.timestamp("created_at", { withTimezone: true }).defaultNow().notNull()
+      },
+      (table) => [
+        pgCore.index("idx_session_events_session").on(table.sessionId, table.sequenceNumber),
+        pgCore.index("idx_session_events_category").on(table.sessionId, table.category)
+      ]
+    );
     sessionsRelations = drizzleOrm.relations(sessions, ({ one, many }) => ({
       parentSession: one(sessions, {
         fields: [sessions.parentSessionId],
@@ -14957,7 +16434,14 @@ var init_schema = __esm({
       childSessions: many(sessions, {
         relationName: "parentSession"
       }),
-      messages: many(messages)
+      messages: many(messages),
+      events: many(sessionEvents)
+    }));
+    sessionEventsRelations = drizzleOrm.relations(sessionEvents, ({ one }) => ({
+      session: one(sessions, {
+        fields: [sessionEvents.sessionId],
+        references: [sessions.id]
+      })
     }));
     messagesRelations = drizzleOrm.relations(messages, ({ one, many }) => ({
       session: one(sessions, {
@@ -16496,6 +17980,92 @@ var init_storage3 = __esm({
           executionWebhookSecret: row.execution_webhook_secret ?? void 0
         };
       }
+      rowToSessionEvent(row) {
+        return {
+          id: row.id,
+          sessionId: row.session_id,
+          eventType: row.event_type,
+          category: row.category,
+          startedAt: new Date(row.started_at),
+          endedAt: row.ended_at ? new Date(row.ended_at) : void 0,
+          durationMs: row.duration_ms ?? void 0,
+          eventData: row.event_data ?? void 0,
+          toolUseId: row.tool_use_id ?? void 0,
+          toolName: row.tool_name ?? void 0,
+          isAggregated: row.is_aggregated ?? void 0,
+          aggregatedCount: row.aggregated_count ?? void 0,
+          sequenceNumber: row.sequence_number,
+          createdAt: new Date(row.created_at)
+        };
+      }
+      // ============================================================================
+      // Events
+      // ============================================================================
+      async saveEvents(sessionId, events) {
+        if (events.length === 0) return [];
+        const { data, error } = await this.client.from("session_events").insert(
+          events.map((event) => ({
+            session_id: sessionId,
+            event_type: event.eventType,
+            category: event.category,
+            started_at: event.startedAt.toISOString(),
+            ended_at: event.endedAt?.toISOString() ?? null,
+            duration_ms: event.durationMs ?? null,
+            event_data: event.eventData ?? {},
+            tool_use_id: event.toolUseId ?? null,
+            tool_name: event.toolName ?? null,
+            is_aggregated: event.isAggregated ?? false,
+            aggregated_count: event.aggregatedCount ?? null,
+            sequence_number: event.sequenceNumber
+          }))
+        ).select();
+        if (error) {
+          throw new Error(`Failed to save events: ${error.message}`);
+        }
+        return data.map((row) => this.rowToSessionEvent(row));
+      }
+      async getSessionEvents(sessionId, options = {}) {
+        const limit = options.limit ?? 100;
+        const offset = options.offset ?? 0;
+        let query = this.client.from("session_events").select("*", { count: "exact" }).eq("session_id", sessionId);
+        if (options.category) {
+          query = query.eq("category", options.category);
+        }
+        if (options.eventType) {
+          query = query.eq("event_type", options.eventType);
+        }
+        if (options.filePath) {
+          query = query.or(
+            `event_data->>filePath.eq.${options.filePath},and(category.eq.tool,tool_name.in.(Read,Write,Edit),event_data->input->>file_path.eq.${options.filePath})`
+          );
+        }
+        const ascending = options.order !== "desc";
+        query = query.order("sequence_number", { ascending }).range(offset, offset + limit - 1);
+        const { data, error, count } = await query;
+        if (error) {
+          throw new Error(`Failed to get session events: ${error.message}`);
+        }
+        const total = count ?? 0;
+        return {
+          items: data.map((row) => this.rowToSessionEvent(row)),
+          total,
+          hasMore: offset + limit < total,
+          nextCursor: offset + limit < total ? String(offset + limit) : void 0
+        };
+      }
+      async deleteSessionEvents(sessionId) {
+        const { error } = await this.client.from("session_events").delete().eq("session_id", sessionId);
+        if (error) {
+          throw new Error(`Failed to delete session events: ${error.message}`);
+        }
+      }
+      async getNextEventSequence(sessionId) {
+        const { data, error } = await this.client.from("session_events").select("sequence_number").eq("session_id", sessionId).order("sequence_number", { ascending: false }).limit(1).single();
+        if (error && error.code !== "PGRST116") {
+          throw new Error(`Failed to get next event sequence: ${error.message}`);
+        }
+        return data ? data.sequence_number + 1 : 1;
+      }
     };
   }
 });
@@ -16518,8 +18088,8 @@ var init_client = __esm({
       /**
        * Make an authenticated request to the Ash Cloud API
        */
-      async request(method, path14, options) {
-        const url = new URL(`${this.baseUrl}${path14}`);
+      async request(method, path15, options) {
+        const url = new URL(`${this.baseUrl}${path15}`);
         if (options?.query) {
           for (const [key, value] of Object.entries(options.query)) {
             if (value !== void 0) {
@@ -16587,8 +18157,8 @@ var init_client = __esm({
       /**
        * Make a streaming request (for SSE endpoints)
        */
-      async *stream(method, path14, options) {
-        const url = `${this.baseUrl}${path14}`;
+      async *stream(method, path15, options) {
+        const url = `${this.baseUrl}${path15}`;
         const headers = {
           Authorization: `Bearer ${this.apiKey}`,
           "Content-Type": "application/json",
@@ -17370,11 +18940,15 @@ exports.createDocumentedServer = createOpenAPIServer;
 exports.createE2BSandbox = createE2BSandbox;
 exports.createEventHandler = createEventHandler;
 exports.createEventMiddlewareChain = createEventMiddlewareChain;
+exports.createFileWatcher = createFileWatcher;
+exports.createFileWatcherManager = createFileWatcherManager;
 exports.createGCSBundleStore = createGCSBundleStore;
 exports.createGeminiExecutor = createGeminiExecutor;
 exports.createGitHubFileProvider = createGitHubFileProvider;
 exports.createGitRepo = createGitRepo;
 exports.createHarnessServer = createHarnessServer;
+exports.createInSandboxWatcher = createInSandboxWatcher;
+exports.createInSandboxWatcherManager = createInSandboxWatcherManager;
 exports.createLocalBundleStore = createLocalBundleStore;
 exports.createLocalFileProvider = createLocalFileProvider;
 exports.createLocalSandbox = createLocalSandbox;
@@ -17392,6 +18966,8 @@ exports.createQueueProcessor = createQueueProcessor;
 exports.createQueueRouter = createQueueRouter;
 exports.createR2BundleStore = createR2BundleStore;
 exports.createR2FileStore = createR2FileStore;
+exports.createRemoteFileWatcher = createRemoteFileWatcher;
+exports.createRemoteFileWatcherManager = createRemoteFileWatcherManager;
 exports.createS3BundleStore = createS3BundleStore;
 exports.createS3FileStore = createS3FileStore;
 exports.createSandboxFileOperations = createSandboxFileOperations;
@@ -17430,8 +19006,11 @@ exports.getActionLabel = getActionLabel;
 exports.getAllHeartbeatStatuses = getAllHeartbeatStatuses;
 exports.getApiKeyEnvVar = getApiKeyEnvVar;
 exports.getDefaultModel = getDefaultModel;
+exports.getFileWatcherManager = getFileWatcherManager;
 exports.getHeartbeatStatus = getHeartbeatStatus;
+exports.getInSandboxWatcherManager = getInSandboxWatcherManager;
 exports.getOrCreateSandbox = getOrCreateSandbox;
+exports.getRemoteFileWatcherManager = getRemoteFileWatcherManager;
 exports.getSandboxCacheStats = getSandboxCacheStats;
 exports.getSandboxPool = getSandboxPool;
 exports.getWorkspaceManager = getWorkspaceManager;