@ash-cloud/ash-ai 0.1.8 → 0.1.10

package/dist/index.js

@@ -2,10 +2,11 @@ import { z, ZodType } from 'zod';
 import { spawn, execSync } from 'child_process';
 import { nanoid } from 'nanoid';
 import * as fs from 'fs/promises';
-import * as path3 from 'path';
+import * as path4 from 'path';
 import { Writable } from 'stream';
-import { scryptSync, randomBytes, createCipheriv, createDecipheriv } from 'crypto';
-import * as fs9 from 'fs';
+import chokidar from 'chokidar';
+import { scryptSync, randomBytes, createCipheriv, createDecipheriv, createHmac } from 'crypto';
+import * as fs10 from 'fs';
 import { promises } from 'fs';
 import { Hono } from 'hono';
 import { streamSSE } from 'hono/streaming';
@@ -18,7 +19,7 @@ import { mergePath } from 'hono/utils/url';
 import { HTTPException } from 'hono/http-exception';
 export { serve } from '@hono/node-server';
 import * as os from 'os';
-import { pgEnum, pgTable, timestamp, jsonb, integer, uuid, text, index } from 'drizzle-orm/pg-core';
+import { pgEnum, pgTable, timestamp, jsonb, integer, uuid, text, index, boolean } from 'drizzle-orm/pg-core';
 import { eq, sql, and, asc, desc, isNull, or, lt, relations } from 'drizzle-orm';
 import { drizzle } from 'drizzle-orm/postgres-js';
 import postgres from 'postgres';
@@ -78,7 +79,7 @@ var init_normalized = __esm({
   "src/types/normalized.ts"() {
   }
 });
-var SessionStatus, AgentStatus, MessageRole, messageContentSchema, messageSchema, sessionSchema, attachmentSchema, DEFAULT_SANDBOX_PROVIDER_CONFIG, StreamEventType, QueueItemStatus;
+var SessionStatus, AgentStatus, MessageRole, messageContentSchema, messageSchema, sessionSchema, attachmentSchema, DEFAULT_SANDBOX_PROVIDER_CONFIG, StreamEventType, QueueItemStatus, EventCategory;
 var init_types = __esm({
   "src/types/index.ts"() {
     init_normalized();
@@ -175,6 +176,7 @@ var init_types = __esm({
       SESSION_END: "session_end",
       SESSION_STOPPED: "session_stopped",
       SANDBOX_LOG: "sandbox_log",
+      MCP_STATUS: "mcp_status",
       ERROR: "error"
     };
     QueueItemStatus = {
@@ -184,6 +186,22 @@ var init_types = __esm({
       FAILED: "failed",
       CANCELLED: "cancelled"
     };
+    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)
+    };
   }
 });
 
@@ -603,7 +621,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",
@@ -611,7 +629,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 ?? []]
         };
       }
     };
@@ -669,8 +687,8 @@ var init_mcp = __esm({
       /**
        * Add a custom stdio MCP server
        */
-      withCustom(name, path14, runtime, args) {
-        return this.add(name, McpServers.custom(path14, runtime, args));
+      withCustom(name, path15, runtime, args) {
+        return this.add(name, McpServers.custom(path15, runtime, args));
       }
       /**
        * Add an HTTP MCP server with typed authentication
@@ -2992,9 +3010,9 @@ var init_attachment = __esm({
           throw new Error(`MIME type ${mimeType} is not allowed`);
         }
         const id = nanoid();
-        const ext = path3.extname(filename) || this.getExtensionForMimeType(mimeType);
+        const ext = path4.extname(filename) || this.getExtensionForMimeType(mimeType);
         const storageName = `${id}${ext}`;
-        const storagePath = path3.join(this.config.basePath, storageName);
+        const storagePath = path4.join(this.config.basePath, storageName);
         await fs.writeFile(storagePath, content);
         return {
           id,
@@ -3011,8 +3029,8 @@ var init_attachment = __esm({
        */
       async storeFromPath(messageId, sourcePath, mimeType) {
         const content = await fs.readFile(sourcePath);
-        const filename = path3.basename(sourcePath);
-        const detectedMimeType = mimeType ?? this.getMimeTypeForExtension(path3.extname(filename));
+        const filename = path4.basename(sourcePath);
+        const detectedMimeType = mimeType ?? this.getMimeTypeForExtension(path4.extname(filename));
         return this.storeFromBuffer(messageId, filename, content, detectedMimeType);
       }
       /**
@@ -3243,8 +3261,8 @@ async function loadConfig(configPath, options = {}) {
   return config;
 }
 async function loadConfigFile(filePath) {
-  const ext = path3.extname(filePath);
-  const fullPath = path3.isAbsolute(filePath) ? filePath : path3.resolve(process.cwd(), filePath);
+  const ext = path4.extname(filePath);
+  const fullPath = path4.isAbsolute(filePath) ? filePath : path4.resolve(process.cwd(), filePath);
   if (ext === ".json") {
     const content = await fs.readFile(fullPath, "utf-8");
     return JSON.parse(content);
@@ -3257,7 +3275,7 @@ async function loadConfigFile(filePath) {
 }
 async function findAndLoadConfig(directory) {
   for (const fileName of CONFIG_FILE_NAMES) {
-    const filePath = path3.join(directory, fileName);
+    const filePath = path4.join(directory, fileName);
     try {
       await fs.access(filePath);
       return await loadConfigFile(filePath);
@@ -3595,8 +3613,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
@@ -3743,12 +3761,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);
@@ -3777,17 +3795,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);
       }
     };
   }
@@ -4041,7 +4059,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);
@@ -4051,34 +4069,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 [];
@@ -4093,7 +4111,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"
@@ -4103,12 +4121,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);
@@ -5241,7 +5259,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" };
@@ -5251,14 +5269,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();
@@ -5273,7 +5291,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" };
@@ -5285,14 +5303,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();
@@ -5309,7 +5327,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" };
@@ -5321,14 +5339,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();
@@ -5776,8 +5794,516 @@ var init_vercel_sandbox_executor = __esm({
     heartbeatListeners = /* @__PURE__ */ new Set();
   }
 });
-
-// src/runtime/sandbox-file-sync.ts
+function createFileWatcher(options) {
+  return new SandboxFileWatcher(options);
+}
+function getFileWatcherManager() {
+  if (!globalWatcherManager) {
+    globalWatcherManager = new FileWatcherManager();
+  }
+  return globalWatcherManager;
+}
+function createFileWatcherManager() {
+  return new FileWatcherManager();
+}
+function createRemoteFileWatcher(options) {
+  return new RemoteSandboxFileWatcher(options);
+}
+function getRemoteFileWatcherManager() {
+  if (!globalRemoteWatcherManager) {
+    globalRemoteWatcherManager = new RemoteFileWatcherManager();
+  }
+  return globalRemoteWatcherManager;
+}
+function createRemoteFileWatcherManager() {
+  return new RemoteFileWatcherManager();
+}
+var SandboxFileWatcher, FileWatcherManager, globalWatcherManager, RemoteSandboxFileWatcher, RemoteFileWatcherManager, globalRemoteWatcherManager;
+var init_sandbox_file_watcher = __esm({
+  "src/runtime/sandbox-file-watcher.ts"() {
+    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.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.join(this.watchPath, pattern)
+        );
+        this.watcher = chokidar.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.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.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);
+          }
+        }
+      }
+    };
+    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 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;
+    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);
+          }
+        }
+      }
+    };
+    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 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)";
@@ -5823,13 +6349,256 @@ function createSandboxFileSync(options) {
 var SandboxFileSync;
 var init_sandbox_file_sync = __esm({
   "src/runtime/sandbox-file-sync.ts"() {
+    init_sandbox_file_watcher();
+    init_types();
     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 = 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: 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
@@ -5843,8 +6612,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;
@@ -5857,33 +6626,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`);
@@ -5908,9 +6711,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
         };
@@ -5919,35 +6722,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" };
@@ -5956,7 +6797,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" };
           }
@@ -5973,21 +6814,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;
@@ -6008,14 +6876,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);
@@ -6023,6 +6913,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}`);
@@ -6055,8 +6952,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);
@@ -6064,6 +6976,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}`);
@@ -6072,16 +6991,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 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 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 InSandboxWatcher(options);
+}
+function getInSandboxWatcherManager() {
+  if (!globalInSandboxManager) {
+    globalInSandboxManager = new InSandboxWatcherManager();
+  }
+  return globalInSandboxManager;
+}
+function createInSandboxWatcherManager() {
+  return new InSandboxWatcherManager();
+}
+var WATCHER_SCRIPT, InSandboxWatcher, InSandboxWatcherManager, 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 }));
+`;
+    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);
+          }
+        }
+      }
+    };
+    InSandboxWatcherManager = class {
+      watchers = /* @__PURE__ */ new Map();
+      /**
+       * Start watching a sandbox
+       */
+      async startWatching(options) {
+        const { sessionId } = options;
+        await this.stopWatching(sessionId);
+        const watcher = new 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;
   }
 });
 
@@ -6193,8 +7622,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 SENSITIVE_PATHS) {
     const pattern = sensitive.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/~/g, ".*");
     if (new RegExp(pattern).test(normalized)) {
@@ -6211,6 +7640,8 @@ var init_runtime = __esm({
     init_vercel_sandbox_executor();
     init_sandbox_file_sync();
     init_sandbox_pool();
+    init_sandbox_file_watcher();
+    init_in_sandbox_watcher();
     RuntimePresets = {
       /**
        * Development mode - no isolation, for local testing
@@ -6321,8 +7752,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) {
@@ -6560,7 +7991,7 @@ var init_local_provider = __esm({
       maxFileSize;
       constructor(source, options = {}) {
         this.source = source;
-        this.basePath = path3.resolve(source.localPath);
+        this.basePath = path4.resolve(source.localPath);
         this.maxFileSize = options.maxFileSize ?? DEFAULT_MAX_FILE_SIZE;
       }
       /**
@@ -6568,8 +7999,8 @@ var init_local_provider = __esm({
        * Prevents path traversal attacks.
        */
       resolvePath(relativePath) {
-        const normalized = path3.normalize(relativePath);
-        const resolved = path3.resolve(this.basePath, normalized);
+        const normalized = path4.normalize(relativePath);
+        const resolved = path4.resolve(this.basePath, normalized);
         if (!resolved.startsWith(this.basePath)) {
           throw new Error(`Path traversal detected: ${relativePath}`);
         }
@@ -6581,8 +8012,8 @@ var init_local_provider = __esm({
           const entries = await promises.readdir(dirPath, { withFileTypes: true });
           const fileEntries = await Promise.all(
             entries.map(async (entry) => {
-              const entryPath = path3.join(relativePath || ".", entry.name);
-              const fullPath = path3.join(dirPath, entry.name);
+              const entryPath = path4.join(relativePath || ".", entry.name);
+              const fullPath = path4.join(dirPath, entry.name);
               let size;
               let modifiedAt;
               try {
@@ -6674,7 +8105,7 @@ var init_local_provider = __esm({
             }
             await this.copyDirectory(sourceFullPath, targetPath);
           } else {
-            await promises.mkdir(path3.dirname(targetPath), { recursive: true });
+            await promises.mkdir(path4.dirname(targetPath), { recursive: true });
             await promises.copyFile(sourceFullPath, targetPath);
           }
         } catch (error) {
@@ -6689,8 +8120,8 @@ var init_local_provider = __esm({
         const entries = await promises.readdir(sourceDir, { withFileTypes: true });
         await Promise.all(
           entries.map(async (entry) => {
-            const sourcePath = path3.join(sourceDir, entry.name);
-            const targetPath = path3.join(targetDir, entry.name);
+            const sourcePath = path4.join(sourceDir, entry.name);
+            const targetPath = path4.join(targetDir, entry.name);
             if (entry.isDirectory()) {
               await this.copyDirectory(sourcePath, targetPath);
             } else {
@@ -6889,7 +8320,7 @@ var init_github_provider = __esm({
         }
         if (type === "file") {
           const content = await this.readFile(sourcePath);
-          await promises.mkdir(path3.dirname(targetPath), { recursive: true });
+          await promises.mkdir(path4.dirname(targetPath), { recursive: true });
           if (content.encoding === "base64") {
             await promises.writeFile(targetPath, Buffer.from(content.content, "base64"));
           } else {
@@ -6907,7 +8338,7 @@ var init_github_provider = __esm({
             entries.map(
               (entry) => this.copyTo(
                 entry.path,
-                path3.join(targetPath, entry.name),
+                path4.join(targetPath, entry.name),
                 recursive
               )
             )
@@ -6990,8 +8421,8 @@ var init_manager2 = __esm({
         if (enabledSkills.length === 0) {
           return "";
         }
-        const sessionDir = path3.join(this.tempDir, sessionId);
-        const skillsDir = path3.join(sessionDir, ".claude", "skills");
+        const sessionDir = path4.join(this.tempDir, sessionId);
+        const skillsDir = path4.join(sessionDir, ".claude", "skills");
         await promises.mkdir(skillsDir, { recursive: true });
         await Promise.all(
           enabledSkills.map((skill) => this.materializeSkill(skill, skillsDir, token))
@@ -7003,10 +8434,10 @@ var init_manager2 = __esm({
        */
       async materializeSkill(skill, skillsDir, token) {
         const provider = this.createFileProvider(skill.source, token);
-        const skillDir = path3.join(skillsDir, skill.name);
+        const skillDir = path4.join(skillsDir, skill.name);
         await promises.mkdir(skillDir, { recursive: true });
         for (const includePath of skill.includePaths) {
-          const targetPath = path3.join(skillDir, path3.basename(includePath));
+          const targetPath = path4.join(skillDir, path4.basename(includePath));
           try {
             await provider.copyTo(includePath, targetPath, true);
           } catch (error) {
@@ -7021,7 +8452,7 @@ var init_manager2 = __esm({
        * Clean up materialized skills for a session
        */
       async cleanupSession(sessionId) {
-        const sessionDir = path3.join(this.tempDir, sessionId);
+        const sessionDir = path4.join(this.tempDir, sessionId);
         try {
           await promises.rm(sessionDir, { recursive: true, force: true });
         } catch (error) {
@@ -7039,7 +8470,7 @@ var init_manager2 = __esm({
           await Promise.all(
             entries.map(async (entry) => {
               if (!entry.isDirectory()) return;
-              const dirPath = path3.join(this.tempDir, entry.name);
+              const dirPath = path4.join(this.tempDir, entry.name);
               try {
                 const stats = await promises.stat(dirPath);
                 if (now - stats.mtimeMs > maxAgeMs) {
@@ -9848,11 +11279,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 ? {
@@ -10047,8 +11478,8 @@ var init_dist2 = __esm({
 });
 function addBasePathToDocument(document, basePath) {
   const updatedPaths = {};
-  Object.keys(document.paths).forEach((path14) => {
-    updatedPaths[mergePath(basePath.replaceAll(/:([^\/]+)/g, "{$1}"), path14)] = document.paths[path14];
+  Object.keys(document.paths).forEach((path15) => {
+    updatedPaths[mergePath(basePath.replaceAll(/:([^\/]+)/g, "{$1}"), path15)] = document.paths[path15];
   });
   return {
     ...document,
@@ -10192,8 +11623,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);
@@ -10203,8 +11634,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);
@@ -10214,9 +11645,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;
         }
@@ -10263,8 +11694,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) => {
@@ -12045,12 +13476,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();
@@ -12060,7 +13491,7 @@ function requestLogger(options = {}) {
     logFn("Request completed", {
       requestId,
       method,
-      path: path14,
+      path: path15,
       status,
       duration: `${duration}ms`
     });
@@ -12545,8 +13976,8 @@ function shellQuote3(str) {
 async function loadWorkspaceState(workspaceId, sandbox, bundleStore, repoRoot) {
   const resolvedRoot = repoRoot ?? sandbox.defaultRepoRoot;
   const gitRepo = new SandboxGitRepo(sandbox, resolvedRoot);
-  const tmpDir = fs9.mkdtempSync(path3.join(os.tmpdir(), "ash-workspace-"));
-  const localBundle = path3.join(tmpDir, `${workspaceId}.bundle`);
+  const tmpDir = fs10.mkdtempSync(path4.join(os.tmpdir(), "ash-workspace-"));
+  const localBundle = path4.join(tmpDir, `${workspaceId}.bundle`);
   try {
     const bundleExists = await Promise.resolve(
       bundleStore.downloadBundle(workspaceId, localBundle)
@@ -12582,7 +14013,7 @@ async function loadWorkspaceState(workspaceId, sandbox, bundleStore, repoRoot) {
     }
   } finally {
     try {
-      fs9.rmSync(tmpDir, { recursive: true, force: true });
+      fs10.rmSync(tmpDir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -12602,11 +14033,11 @@ async function saveWorkspaceState(workspaceId, sandbox, gitRepo, bundleStore, co
   }
   const remoteBundlePath = BUNDLE_PATH_TEMPLATE.replace("{workspaceId}", workspaceId);
   await gitRepo.createBundle(remoteBundlePath);
-  const tmpDir = fs9.mkdtempSync(path3.join(os.tmpdir(), "ash-workspace-"));
-  const localBundle = path3.join(tmpDir, `${workspaceId}.bundle`);
+  const tmpDir = fs10.mkdtempSync(path4.join(os.tmpdir(), "ash-workspace-"));
+  const localBundle = path4.join(tmpDir, `${workspaceId}.bundle`);
   try {
     await sandbox.downloadFile(remoteBundlePath, localBundle);
-    const bundleSize = fs9.statSync(localBundle).size;
+    const bundleSize = fs10.statSync(localBundle).size;
     await bundleStore.uploadBundle(workspaceId, localBundle);
     return {
       committed,
@@ -12615,7 +14046,7 @@ async function saveWorkspaceState(workspaceId, sandbox, gitRepo, bundleStore, co
     };
   } finally {
     try {
-      fs9.rmSync(tmpDir, { recursive: true, force: true });
+      fs10.rmSync(tmpDir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -12628,7 +14059,7 @@ var init_persistence = __esm({
   }
 });
 async function cloneRepository(url, ref, timeout = 12e4) {
-  const tmpDir = fs9.mkdtempSync(path3.join(os.tmpdir(), "ash-github-skill-"));
+  const tmpDir = fs10.mkdtempSync(path4.join(os.tmpdir(), "ash-github-skill-"));
   try {
     const cloneCmd = ["git", "clone", "--depth", "1"];
     if (ref) {
@@ -12643,7 +14074,7 @@ async function cloneRepository(url, ref, timeout = 12e4) {
     return tmpDir;
   } catch (error) {
     try {
-      fs9.rmSync(tmpDir, { recursive: true, force: true });
+      fs10.rmSync(tmpDir, { recursive: true, force: true });
     } catch {
     }
     throw error;
@@ -12655,10 +14086,10 @@ function getRepoName(url) {
 }
 function countFiles(dir, exclude) {
   let count = 0;
-  const entries = fs9.readdirSync(dir, { withFileTypes: true });
+  const entries = fs10.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (exclude.has(entry.name)) continue;
-    const fullPath = path3.join(dir, entry.name);
+    const fullPath = path4.join(dir, entry.name);
     if (entry.isDirectory()) {
       count += countFiles(fullPath, exclude);
     } else if (entry.isFile()) {
@@ -12670,15 +14101,15 @@ function countFiles(dir, exclude) {
 async function uploadDirectory(sandbox, localPath, remotePath, exclude) {
   let uploadCount = 0;
   await sandbox.runCommand(`mkdir -p '${remotePath}'`);
-  const entries = fs9.readdirSync(localPath, { withFileTypes: true });
+  const entries = fs10.readdirSync(localPath, { withFileTypes: true });
   for (const entry of entries) {
     if (exclude.has(entry.name)) continue;
-    const srcPath = path3.join(localPath, entry.name);
+    const srcPath = path4.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.readFileSync(srcPath, "utf-8");
+      const content = fs10.readFileSync(srcPath, "utf-8");
       await sandbox.writeFile(destPath, content);
       uploadCount++;
     }
@@ -12704,13 +14135,13 @@ async function loadGitHubSkill(sandbox, config, skillsBasePath) {
     );
   }
   try {
-    const sourcePath = subpath ? path3.join(clonePath, subpath) : clonePath;
-    if (!fs9.existsSync(sourcePath)) {
+    const sourcePath = subpath ? path4.join(clonePath, subpath) : clonePath;
+    if (!fs10.existsSync(sourcePath)) {
       throw new Error(
         `Path '${subpath}' not found in repository ${url}`
       );
     }
-    if (!fs9.statSync(sourcePath).isDirectory()) {
+    if (!fs10.statSync(sourcePath).isDirectory()) {
       throw new Error(
         `Path '${subpath}' in ${url} is not a directory`
       );
@@ -12729,7 +14160,7 @@ async function loadGitHubSkill(sandbox, config, skillsBasePath) {
     };
   } finally {
     try {
-      fs9.rmSync(clonePath, { recursive: true, force: true });
+      fs10.rmSync(clonePath, { recursive: true, force: true });
     } catch {
     }
   }
@@ -13422,26 +14853,26 @@ var init_workspace = __esm({
         const localPaths = normalizeToArray(skillsConfig.local);
         for (const localPath of localPaths) {
           try {
-            if (!fs9.existsSync(localPath)) {
+            if (!fs10.existsSync(localPath)) {
               errors.push({
                 source: localPath,
                 error: new Error(`Path does not exist: ${localPath}`)
               });
               continue;
             }
-            const stat = fs9.statSync(localPath);
-            if (!stat.isDirectory()) {
+            const stat2 = fs10.statSync(localPath);
+            if (!stat2.isDirectory()) {
               errors.push({
                 source: localPath,
                 error: new Error(`Path is not a directory: ${localPath}`)
               });
               continue;
             }
-            const entries = fs9.readdirSync(localPath);
+            const entries = fs10.readdirSync(localPath);
             for (const entry of entries) {
               if (FILTERED_ITEMS2.has(entry)) continue;
-              const entryPath = path3.join(localPath, entry);
-              const entryStat = fs9.statSync(entryPath);
+              const entryPath = path4.join(localPath, entry);
+              const entryStat = fs10.statSync(entryPath);
               if (entryStat.isDirectory()) {
                 const remotePath = `${skillsBase}/${entry}`;
                 await this.sandbox.uploadDirectory(entryPath, remotePath, {
@@ -13526,50 +14957,50 @@ var init_bundle_store = __esm({
       directory;
       constructor(options) {
         this.directory = options.directory;
-        if (!fs9.existsSync(this.directory)) {
-          fs9.mkdirSync(this.directory, { recursive: true });
+        if (!fs10.existsSync(this.directory)) {
+          fs10.mkdirSync(this.directory, { recursive: true });
         }
       }
       keyForWorkspace(workspaceId) {
-        return path3.join(this.directory, `${workspaceId}.bundle`);
+        return path4.join(this.directory, `${workspaceId}.bundle`);
       }
       downloadBundle(workspaceId, destPath) {
         const bundlePath = this.keyForWorkspace(workspaceId);
-        if (!fs9.existsSync(bundlePath)) {
+        if (!fs10.existsSync(bundlePath)) {
           return false;
         }
-        const destDir = path3.dirname(destPath);
-        if (!fs9.existsSync(destDir)) {
-          fs9.mkdirSync(destDir, { recursive: true });
+        const destDir = path4.dirname(destPath);
+        if (!fs10.existsSync(destDir)) {
+          fs10.mkdirSync(destDir, { recursive: true });
         }
-        fs9.copyFileSync(bundlePath, destPath);
+        fs10.copyFileSync(bundlePath, destPath);
         return true;
       }
       uploadBundle(workspaceId, srcPath) {
-        if (!fs9.existsSync(srcPath)) {
+        if (!fs10.existsSync(srcPath)) {
           throw new Error(`Source bundle not found: ${srcPath}`);
         }
         const bundlePath = this.keyForWorkspace(workspaceId);
-        const bundleDir = path3.dirname(bundlePath);
-        if (!fs9.existsSync(bundleDir)) {
-          fs9.mkdirSync(bundleDir, { recursive: true });
+        const bundleDir = path4.dirname(bundlePath);
+        if (!fs10.existsSync(bundleDir)) {
+          fs10.mkdirSync(bundleDir, { recursive: true });
         }
-        fs9.copyFileSync(srcPath, bundlePath);
+        fs10.copyFileSync(srcPath, bundlePath);
       }
       exists(workspaceId) {
-        return fs9.existsSync(this.keyForWorkspace(workspaceId));
+        return fs10.existsSync(this.keyForWorkspace(workspaceId));
       }
       deleteBundle(workspaceId) {
         const bundlePath = this.keyForWorkspace(workspaceId);
-        if (fs9.existsSync(bundlePath)) {
-          fs9.unlinkSync(bundlePath);
+        if (fs10.existsSync(bundlePath)) {
+          fs10.unlinkSync(bundlePath);
         }
       }
       listWorkspaces() {
-        if (!fs9.existsSync(this.directory)) {
+        if (!fs10.existsSync(this.directory)) {
           return [];
         }
-        return fs9.readdirSync(this.directory).filter((file) => file.endsWith(".bundle")).map((file) => file.replace(".bundle", ""));
+        return fs10.readdirSync(this.directory).filter((file) => file.endsWith(".bundle")).map((file) => file.replace(".bundle", ""));
       }
     };
     MemoryBundleStore = class {
@@ -13582,18 +15013,18 @@ var init_bundle_store = __esm({
         if (!bundle) {
           return false;
         }
-        const destDir = path3.dirname(destPath);
-        if (!fs9.existsSync(destDir)) {
-          fs9.mkdirSync(destDir, { recursive: true });
+        const destDir = path4.dirname(destPath);
+        if (!fs10.existsSync(destDir)) {
+          fs10.mkdirSync(destDir, { recursive: true });
         }
-        fs9.writeFileSync(destPath, bundle);
+        fs10.writeFileSync(destPath, bundle);
         return true;
       }
       uploadBundle(workspaceId, srcPath) {
-        if (!fs9.existsSync(srcPath)) {
+        if (!fs10.existsSync(srcPath)) {
           throw new Error(`Source bundle not found: ${srcPath}`);
         }
-        const content = fs9.readFileSync(srcPath);
+        const content = fs10.readFileSync(srcPath);
         this.bundles.set(workspaceId, content);
       }
       exists(workspaceId) {
@@ -13684,21 +15115,21 @@ var init_supabase_store = __esm({
         if (!data) {
           return false;
         }
-        const dir = path3.dirname(destPath);
-        if (!fs9.existsSync(dir)) {
-          fs9.mkdirSync(dir, { recursive: true });
+        const dir = path4.dirname(destPath);
+        if (!fs10.existsSync(dir)) {
+          fs10.mkdirSync(dir, { recursive: true });
         }
         const arrayBuffer = await data.arrayBuffer();
-        fs9.writeFileSync(destPath, Buffer.from(arrayBuffer));
+        fs10.writeFileSync(destPath, Buffer.from(arrayBuffer));
         return true;
       }
       async uploadBundle(workspaceId, srcPath) {
-        if (!fs9.existsSync(srcPath)) {
+        if (!fs10.existsSync(srcPath)) {
           throw new Error(`Source bundle not found: ${srcPath}`);
         }
         const client = await this.ensureClient();
         const key = this.keyForWorkspace(workspaceId);
-        const content = fs9.readFileSync(srcPath);
+        const content = fs10.readFileSync(srcPath);
         const { error } = await client.storage.from(this.bucket).upload(key, content, {
           contentType: "application/octet-stream",
           upsert: true
@@ -13827,11 +15258,11 @@ var init_cloud_store = __esm({
             return false;
           }
           const bytes = await body.transformToByteArray();
-          const dir = path3.dirname(destPath);
-          if (!fs9.existsSync(dir)) {
-            fs9.mkdirSync(dir, { recursive: true });
+          const dir = path4.dirname(destPath);
+          if (!fs10.existsSync(dir)) {
+            fs10.mkdirSync(dir, { recursive: true });
           }
-          fs9.writeFileSync(destPath, Buffer.from(bytes));
+          fs10.writeFileSync(destPath, Buffer.from(bytes));
           return true;
         } catch (error) {
           const err = error;
@@ -13842,12 +15273,12 @@ var init_cloud_store = __esm({
         }
       }
       async uploadBundle(workspaceId, srcPath) {
-        if (!fs9.existsSync(srcPath)) {
+        if (!fs10.existsSync(srcPath)) {
           throw new Error(`Source bundle not found: ${srcPath}`);
         }
         const { client, module } = await this.ensureClient();
         const key = this.keyForWorkspace(workspaceId);
-        const content = fs9.readFileSync(srcPath);
+        const content = fs10.readFileSync(srcPath);
         await client.send(
           new module.PutObjectCommand({
             Bucket: this.bucket,
@@ -13949,9 +15380,9 @@ var init_cloud_store = __esm({
           if (!exists) {
             return false;
           }
-          const dir = path3.dirname(destPath);
-          if (!fs9.existsSync(dir)) {
-            fs9.mkdirSync(dir, { recursive: true });
+          const dir = path4.dirname(destPath);
+          if (!fs10.existsSync(dir)) {
+            fs10.mkdirSync(dir, { recursive: true });
           }
           await file.download({ destination: destPath });
           return true;
@@ -13960,12 +15391,12 @@ var init_cloud_store = __esm({
         }
       }
       async uploadBundle(workspaceId, srcPath) {
-        if (!fs9.existsSync(srcPath)) {
+        if (!fs10.existsSync(srcPath)) {
           throw new Error(`Source bundle not found: ${srcPath}`);
         }
         const storage = await this.ensureStorage();
         const key = this.keyForWorkspace(workspaceId);
-        const content = fs9.readFileSync(srcPath);
+        const content = fs10.readFileSync(srcPath);
         const file = storage.bucket(this.bucket).file(key);
         await file.save(content);
       }
@@ -14064,25 +15495,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({
@@ -14104,9 +15535,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({
@@ -14123,9 +15554,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,
@@ -14180,30 +15611,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",
@@ -14258,8 +15689,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.existsSync(this.workingDirectory)) {
-          fs9.mkdirSync(this.workingDirectory, { recursive: true });
+        if (!fs10.existsSync(this.workingDirectory)) {
+          fs10.mkdirSync(this.workingDirectory, { recursive: true });
         }
       }
       runCommand(command) {
@@ -14288,51 +15719,51 @@ var init_local_sandbox = __esm({
         }
       }
       uploadFile(localPath, remotePath) {
-        const dir = path3.dirname(remotePath);
-        if (!fs9.existsSync(dir)) {
-          fs9.mkdirSync(dir, { recursive: true });
+        const dir = path4.dirname(remotePath);
+        if (!fs10.existsSync(dir)) {
+          fs10.mkdirSync(dir, { recursive: true });
         }
-        fs9.copyFileSync(localPath, remotePath);
+        fs10.copyFileSync(localPath, remotePath);
       }
       downloadFile(remotePath, localPath) {
-        const dir = path3.dirname(localPath);
-        if (!fs9.existsSync(dir)) {
-          fs9.mkdirSync(dir, { recursive: true });
+        const dir = path4.dirname(localPath);
+        if (!fs10.existsSync(dir)) {
+          fs10.mkdirSync(dir, { recursive: true });
         }
-        fs9.copyFileSync(remotePath, localPath);
+        fs10.copyFileSync(remotePath, localPath);
       }
       uploadDirectory(localPath, remotePath, options) {
         const exclude = options?.exclude ?? /* @__PURE__ */ new Set();
-        if (!fs9.existsSync(remotePath)) {
-          fs9.mkdirSync(remotePath, { recursive: true });
+        if (!fs10.existsSync(remotePath)) {
+          fs10.mkdirSync(remotePath, { recursive: true });
         }
         const copyRecursive = (src, dest) => {
-          const entries = fs9.readdirSync(src, { withFileTypes: true });
+          const entries = fs10.readdirSync(src, { withFileTypes: true });
           for (const entry of entries) {
             if (exclude.has(entry.name)) continue;
-            const srcPath = path3.join(src, entry.name);
-            const destPath = path3.join(dest, entry.name);
+            const srcPath = path4.join(src, entry.name);
+            const destPath = path4.join(dest, entry.name);
             if (entry.isDirectory()) {
-              if (!fs9.existsSync(destPath)) {
-                fs9.mkdirSync(destPath, { recursive: true });
+              if (!fs10.existsSync(destPath)) {
+                fs10.mkdirSync(destPath, { recursive: true });
               }
               copyRecursive(srcPath, destPath);
             } else if (entry.isFile()) {
-              fs9.copyFileSync(srcPath, destPath);
+              fs10.copyFileSync(srcPath, destPath);
             }
           }
         };
         copyRecursive(localPath, remotePath);
       }
       readFile(remotePath) {
-        return fs9.readFileSync(remotePath, "utf-8");
+        return fs10.readFileSync(remotePath, "utf-8");
       }
       writeFile(remotePath, content) {
-        const dir = path3.dirname(remotePath);
-        if (!fs9.existsSync(dir)) {
-          fs9.mkdirSync(dir, { recursive: true });
+        const dir = path4.dirname(remotePath);
+        if (!fs10.existsSync(dir)) {
+          fs10.mkdirSync(dir, { recursive: true });
         }
-        fs9.writeFileSync(remotePath, content, "utf-8");
+        fs10.writeFileSync(remotePath, content, "utf-8");
       }
       close() {
       }
@@ -14340,8 +15771,8 @@ var init_local_sandbox = __esm({
        * Clean up the working directory
        */
       cleanup() {
-        if (fs9.existsSync(this.workingDirectory)) {
-          fs9.rmSync(this.workingDirectory, { recursive: true, force: true });
+        if (fs10.existsSync(this.workingDirectory)) {
+          fs10.rmSync(this.workingDirectory, { recursive: true, force: true });
         }
       }
     };
@@ -14451,33 +15882,33 @@ var init_provider_sandbox = __esm({
       }
       async uploadFile(localPath, remotePath) {
         await this.initialize();
-        const content = fs9.readFileSync(localPath);
+        const content = fs10.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.dirname(localPath);
-        if (!fs9.existsSync(dir)) {
-          fs9.mkdirSync(dir, { recursive: true });
+        const dir = path4.dirname(localPath);
+        if (!fs10.existsSync(dir)) {
+          fs10.mkdirSync(dir, { recursive: true });
         }
-        fs9.writeFileSync(localPath, content);
+        fs10.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.readdirSync(src, { withFileTypes: true });
+          const entries = fs10.readdirSync(src, { withFileTypes: true });
           for (const entry of entries) {
             if (exclude.has(entry.name)) continue;
-            const srcPath = path3.join(src, entry.name);
+            const srcPath = path4.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.readFileSync(srcPath);
+              const content = fs10.readFileSync(srcPath);
               await this.provider.writeFile(this.getSandboxId(), destPath, content);
             }
           }
@@ -14715,16 +16146,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 = pgEnum("session_status", [
@@ -14766,6 +16200,22 @@ var init_schema = __esm({
       "initial",
       "rollback"
     ]);
+    eventCategoryEnum = 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 = pgTable(
       "sessions",
       {
@@ -14921,6 +16371,32 @@ var init_schema = __esm({
         index("idx_config_deployments_created").on(table.agentId, table.createdAt)
       ]
     );
+    sessionEvents = pgTable(
+      "session_events",
+      {
+        id: uuid("id").defaultRandom().primaryKey(),
+        sessionId: uuid("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+        eventType: text("event_type").notNull(),
+        category: eventCategoryEnum("category").notNull(),
+        startedAt: timestamp("started_at", { withTimezone: true }).notNull(),
+        endedAt: timestamp("ended_at", { withTimezone: true }),
+        durationMs: integer("duration_ms"),
+        eventData: jsonb("event_data").default({}).$type(),
+        // Tool-specific fields
+        toolUseId: text("tool_use_id"),
+        toolName: text("tool_name"),
+        // Aggregation fields (for text_stream events)
+        isAggregated: boolean("is_aggregated").default(false),
+        aggregatedCount: integer("aggregated_count"),
+        // Ordering
+        sequenceNumber: integer("sequence_number").notNull(),
+        createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull()
+      },
+      (table) => [
+        index("idx_session_events_session").on(table.sessionId, table.sequenceNumber),
+        index("idx_session_events_category").on(table.sessionId, table.category)
+      ]
+    );
     sessionsRelations = relations(sessions, ({ one, many }) => ({
       parentSession: one(sessions, {
         fields: [sessions.parentSessionId],
@@ -14930,7 +16406,14 @@ var init_schema = __esm({
       childSessions: many(sessions, {
         relationName: "parentSession"
       }),
-      messages: many(messages)
+      messages: many(messages),
+      events: many(sessionEvents)
+    }));
+    sessionEventsRelations = relations(sessionEvents, ({ one }) => ({
+      session: one(sessions, {
+        fields: [sessionEvents.sessionId],
+        references: [sessions.id]
+      })
     }));
     messagesRelations = relations(messages, ({ one, many }) => ({
       session: one(sessions, {
@@ -16469,6 +17952,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;
+      }
     };
   }
 });
@@ -16491,8 +18060,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) {
@@ -16560,8 +18129,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",
@@ -17323,6 +18892,6 @@ var init_src = __esm({
 });
 init_src();
 
-export { AVAILABLE_MODELS, AgentConfigSchema, AgentError, AgentHarness, AgentStatus, AshCloud, AshCloudApiError, AshCloudClient, AttachmentConfigSchema, AttachmentStorage, ClaudeSdkClient, CloudSandbox, CloudStorage, ConfigBuilder, ConfigError, CredentialManager, DEFAULT_MODELS, DEFAULT_SANDBOX_PROVIDER_CONFIG, GCSBundleStore, GeminiCliClient, GitHubFileProvider, HarnessConfigSchema, HarnessError, HarnessErrorCode, HarnessEventEmitter, LocalBundleStore, LocalFileProvider, LocalSandbox, McpConfigBuilder, McpPresets, McpServers, MemoryBundleStore, MemoryCredentialStorage, MemoryQueueStorage, MemoryRateLimitStore, MemoryStorage, MessageRole, NotFoundError, PostgresQueueStorage, PostgresStorage, ProviderSandbox, QueueItemStatus, QueueProcessor, RuntimeConfigBuilder, RuntimePresets, S3BundleStore, S3FileStore, SENSITIVE_PATHS, SandboxFileSync, SandboxGitRepo, SandboxLogger, SandboxPool, ServerConfigSchema, SessionError, SessionManager, SessionStatus, SkillCatalog, SkillManager, StorageConfigSchema, StorageError, StreamEventType, SupabaseBundleStore, SupabaseStorage, ToolCallProcessor, ToolError, ValidationError, Workspace, WorkspaceManager, attachmentSchema, attachmentToDataUrl, checkSecurityConfig, claudeClient, cleanupAllSandboxes, configureMcp, configureRuntime, convertClaudeMessage, createAgentsRouter, createAshCloud, createBackendExecutor, createCloudSandbox, createConfig, createCredentialManager, createOpenAPIServer as createDocumentedServer, createE2BSandbox, createEventHandler, createEventMiddlewareChain, createGCSBundleStore, createGeminiExecutor, createGitHubFileProvider, createGitRepo, createHarnessServer, createLocalBundleStore, createLocalFileProvider, createLocalSandbox, createLogger, createMemoryBundleStore, createMinioBundleStore, createMinioFileStore, createModalSandbox, createAgentsRouter2 as createOpenAPIAgentsRouter, createOpenAPIServer, createSessionsRouter2 as createOpenAPISessionsRouter, createSkillsRouter2 as createOpenAPISkillsRouter, createProviderSandbox, createQueueProcessor, createQueueRouter, createR2BundleStore, createR2FileStore, createS3BundleStore, createS3FileStore, createSandboxFileOperations, createSandboxFileSync, createSandboxLogger, createSandboxOptions, createSessionWorkspace, createSessionsRouter, createSkillCatalog, createSkillManager, createSupabaseBundleStore, createSupabaseBundleStoreFromEnv, createToolCall, createToolCallProcessor, createVercelSandbox, createVercelSandboxExecutor, createWorkspace, createWorkspaceHooks, createWorkspaceManager, dataUrlToBuffer, defineAgent, defineConfig, ensureSandboxPoolInitialized, env, envOptional, extractTextContent, extractTextFromMessage, fileEntrySchema, formatToolName, generateDockerCommand, generateMcpServerPackage, generateMcpServers, generateProxyEnv, generateToolSummary, getActionIcon, getActionLabel, getAllHeartbeatStatuses, getApiKeyEnvVar, getDefaultModel, getHeartbeatStatus, getOrCreateSandbox, getSandboxCacheStats, getSandboxPool, getWorkspaceManager, gitHubSkillSourceSchema, globalEventEmitter, hasErrorCode, hashStartupScript, httpMcpWithAuth, initializeSandboxPool, introspectMcpServer, invalidateSandbox, isCommandRunAction, isDocumentMimeType, isErrorEntry, isFileEditAction, isFileReadAction, isFileWriteAction, isGenericToolAction, isGlobAction, isHarnessError, isHttpMcpConfig, isImageMimeType, isMcpToolAction, isSandboxExpiredError, isSandboxRunning, isSearchAction, isSensitivePath, isStdioMcpConfig, isTodoWriteAction, isToolCallEntry, isValidModel, isWebFetchAction, isWebSearchAction, listFilesInSandbox, loadConfig, loadGitHubSkill, loadGitHubSkills, loadWorkspaceState, localSkillSourceSchema, log, mapClaudeOptionsToGemini, mapToolToActionType, markConfigInstalled, markSdkInstalled, markStartupScriptRan, mcpAuthToHeaders, messageContentSchema, messageSchema, needsStartupScriptRerun, normalizeGitHubConfigs, normalizeMcpServers, normalizeMessages, normalizeToolResult, onHeartbeat, schemas_exports as openApiSchemas, parseCommandResult, parseGitHubUrl, parseMcpToolName, processStreamEvents, rateLimit, rateLimiters, readFileFromSandbox, rekeySessionId, releaseSandbox, requestLogger, saveWorkspaceState, schema_exports as schema, sessionSchema, shouldUseSandbox, shutdownSandboxPool, skillConfigSchema, skillSourceSchema, sseMcpWithAuth, startServer, updateToolCallWithResult, writeFileToSandbox };
+export { AVAILABLE_MODELS, AgentConfigSchema, AgentError, AgentHarness, AgentStatus, AshCloud, AshCloudApiError, AshCloudClient, AttachmentConfigSchema, AttachmentStorage, ClaudeSdkClient, CloudSandbox, CloudStorage, ConfigBuilder, ConfigError, CredentialManager, DEFAULT_MODELS, DEFAULT_SANDBOX_PROVIDER_CONFIG, EventCategory, FileWatcherManager, GCSBundleStore, GeminiCliClient, GitHubFileProvider, HarnessConfigSchema, HarnessError, HarnessErrorCode, HarnessEventEmitter, InSandboxWatcher, InSandboxWatcherManager, LocalBundleStore, LocalFileProvider, LocalSandbox, McpConfigBuilder, McpPresets, McpServers, MemoryBundleStore, MemoryCredentialStorage, MemoryQueueStorage, MemoryRateLimitStore, MemoryStorage, MessageRole, NotFoundError, PostgresQueueStorage, PostgresStorage, ProviderSandbox, QueueItemStatus, QueueProcessor, RemoteFileWatcherManager, RemoteSandboxFileWatcher, RuntimeConfigBuilder, RuntimePresets, S3BundleStore, S3FileStore, SENSITIVE_PATHS, SandboxFileSync, SandboxFileWatcher, SandboxGitRepo, SandboxLogger, SandboxPool, ServerConfigSchema, SessionError, SessionManager, SessionStatus, SkillCatalog, SkillManager, StorageConfigSchema, StorageError, StreamEventType, SupabaseBundleStore, SupabaseStorage, ToolCallProcessor, ToolError, ValidationError, Workspace, WorkspaceManager, attachmentSchema, attachmentToDataUrl, checkSecurityConfig, claudeClient, cleanupAllSandboxes, configureMcp, configureRuntime, convertClaudeMessage, createAgentsRouter, createAshCloud, createBackendExecutor, createCloudSandbox, createConfig, createCredentialManager, createOpenAPIServer as createDocumentedServer, createE2BSandbox, createEventHandler, createEventMiddlewareChain, createFileWatcher, createFileWatcherManager, createGCSBundleStore, createGeminiExecutor, createGitHubFileProvider, createGitRepo, createHarnessServer, createInSandboxWatcher, createInSandboxWatcherManager, createLocalBundleStore, createLocalFileProvider, createLocalSandbox, createLogger, createMemoryBundleStore, createMinioBundleStore, createMinioFileStore, createModalSandbox, createAgentsRouter2 as createOpenAPIAgentsRouter, createOpenAPIServer, createSessionsRouter2 as createOpenAPISessionsRouter, createSkillsRouter2 as createOpenAPISkillsRouter, createProviderSandbox, createQueueProcessor, createQueueRouter, createR2BundleStore, createR2FileStore, createRemoteFileWatcher, createRemoteFileWatcherManager, createS3BundleStore, createS3FileStore, createSandboxFileOperations, createSandboxFileSync, createSandboxLogger, createSandboxOptions, createSessionWorkspace, createSessionsRouter, createSkillCatalog, createSkillManager, createSupabaseBundleStore, createSupabaseBundleStoreFromEnv, createToolCall, createToolCallProcessor, createVercelSandbox, createVercelSandboxExecutor, createWorkspace, createWorkspaceHooks, createWorkspaceManager, dataUrlToBuffer, defineAgent, defineConfig, ensureSandboxPoolInitialized, env, envOptional, extractTextContent, extractTextFromMessage, fileEntrySchema, formatToolName, generateDockerCommand, generateMcpServerPackage, generateMcpServers, generateProxyEnv, generateToolSummary, getActionIcon, getActionLabel, getAllHeartbeatStatuses, getApiKeyEnvVar, getDefaultModel, getFileWatcherManager, getHeartbeatStatus, getInSandboxWatcherManager, getOrCreateSandbox, getRemoteFileWatcherManager, getSandboxCacheStats, getSandboxPool, getWorkspaceManager, gitHubSkillSourceSchema, globalEventEmitter, hasErrorCode, hashStartupScript, httpMcpWithAuth, initializeSandboxPool, introspectMcpServer, invalidateSandbox, isCommandRunAction, isDocumentMimeType, isErrorEntry, isFileEditAction, isFileReadAction, isFileWriteAction, isGenericToolAction, isGlobAction, isHarnessError, isHttpMcpConfig, isImageMimeType, isMcpToolAction, isSandboxExpiredError, isSandboxRunning, isSearchAction, isSensitivePath, isStdioMcpConfig, isTodoWriteAction, isToolCallEntry, isValidModel, isWebFetchAction, isWebSearchAction, listFilesInSandbox, loadConfig, loadGitHubSkill, loadGitHubSkills, loadWorkspaceState, localSkillSourceSchema, log, mapClaudeOptionsToGemini, mapToolToActionType, markConfigInstalled, markSdkInstalled, markStartupScriptRan, mcpAuthToHeaders, messageContentSchema, messageSchema, needsStartupScriptRerun, normalizeGitHubConfigs, normalizeMcpServers, normalizeMessages, normalizeToolResult, onHeartbeat, schemas_exports as openApiSchemas, parseCommandResult, parseGitHubUrl, parseMcpToolName, processStreamEvents, rateLimit, rateLimiters, readFileFromSandbox, rekeySessionId, releaseSandbox, requestLogger, saveWorkspaceState, schema_exports as schema, sessionSchema, shouldUseSandbox, shutdownSandboxPool, skillConfigSchema, skillSourceSchema, sseMcpWithAuth, startServer, updateToolCallWithResult, writeFileToSandbox };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map