sparkecoder 0.1.3 → 0.1.5

package/dist/tools/index.js

@@ -1,8 +1,8 @@
 // src/tools/bash.ts
 import { tool } from "ai";
 import { z } from "zod";
-import { exec } from "child_process";
-import { promisify } from "util";
+import { exec as exec2 } from "child_process";
+import { promisify as promisify2 } from "util";
 
 // src/utils/truncate.ts
 var MAX_OUTPUT_CHARS = 1e4;
@@ -19,9 +19,253 @@ function truncateOutput(output, maxChars = MAX_OUTPUT_CHARS) {
 ` + output.slice(-halfMax);
 }
 
-// src/tools/bash.ts
+// src/terminal/tmux.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+import { mkdir, writeFile, readFile } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+import { nanoid } from "nanoid";
 var execAsync = promisify(exec);
-var COMMAND_TIMEOUT = 6e4;
+var SESSION_PREFIX = "spark_";
+var LOG_BASE_DIR = ".sparkecoder/sessions";
+var tmuxAvailableCache = null;
+async function isTmuxAvailable() {
+  if (tmuxAvailableCache !== null) {
+    return tmuxAvailableCache;
+  }
+  try {
+    const { stdout } = await execAsync("tmux -V");
+    tmuxAvailableCache = true;
+    return true;
+  } catch (error) {
+    tmuxAvailableCache = false;
+    console.log(`[tmux] Not available: ${error instanceof Error ? error.message : "unknown error"}`);
+    return false;
+  }
+}
+function generateTerminalId() {
+  return "t" + nanoid(9);
+}
+function getSessionName(terminalId) {
+  return `${SESSION_PREFIX}${terminalId}`;
+}
+function getLogDir(terminalId, workingDirectory, sessionId) {
+  if (sessionId) {
+    return join(workingDirectory, LOG_BASE_DIR, sessionId, "terminals", terminalId);
+  }
+  return join(workingDirectory, ".sparkecoder/terminals", terminalId);
+}
+function shellEscape(str) {
+  return `'${str.replace(/'/g, "'\\''")}'`;
+}
+async function initLogDir(terminalId, meta, workingDirectory) {
+  const logDir = getLogDir(terminalId, workingDirectory, meta.sessionId);
+  await mkdir(logDir, { recursive: true });
+  await writeFile(join(logDir, "meta.json"), JSON.stringify(meta, null, 2));
+  await writeFile(join(logDir, "output.log"), "");
+  return logDir;
+}
+async function pollUntil(condition, options) {
+  const { timeout, interval = 100 } = options;
+  const startTime = Date.now();
+  while (Date.now() - startTime < timeout) {
+    if (await condition()) {
+      return true;
+    }
+    await new Promise((r) => setTimeout(r, interval));
+  }
+  return false;
+}
+async function runSync(command, workingDirectory, options) {
+  if (!options) {
+    throw new Error("runSync: options parameter is required (must include sessionId)");
+  }
+  const id = options.terminalId || generateTerminalId();
+  const session = getSessionName(id);
+  const logDir = await initLogDir(id, {
+    id,
+    command,
+    cwd: workingDirectory,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    sessionId: options.sessionId,
+    background: false
+  }, workingDirectory);
+  const logFile = join(logDir, "output.log");
+  const exitCodeFile = join(logDir, "exit_code");
+  const timeout = options.timeout || 12e4;
+  try {
+    const wrappedCommand = `(${command}) 2>&1 | tee -a ${shellEscape(logFile)}; echo $? > ${shellEscape(exitCodeFile)}`;
+    await execAsync(
+      `tmux new-session -d -s ${session} -c ${shellEscape(workingDirectory)} ${shellEscape(wrappedCommand)}`,
+      { timeout: 5e3 }
+    );
+    try {
+      await execAsync(
+        `tmux pipe-pane -t ${session} -o 'cat >> ${shellEscape(logFile)}'`,
+        { timeout: 1e3 }
+      );
+    } catch {
+    }
+    const completed = await pollUntil(
+      async () => {
+        try {
+          await execAsync(`tmux has-session -t ${session}`, { timeout: 1e3 });
+          return false;
+        } catch {
+          return true;
+        }
+      },
+      { timeout, interval: 100 }
+    );
+    if (!completed) {
+      try {
+        await execAsync(`tmux kill-session -t ${session}`, { timeout: 5e3 });
+      } catch {
+      }
+      let output2 = "";
+      try {
+        output2 = await readFile(logFile, "utf-8");
+      } catch {
+      }
+      return {
+        id,
+        output: output2.trim(),
+        exitCode: 124,
+        // Standard timeout exit code
+        status: "error"
+      };
+    }
+    await new Promise((r) => setTimeout(r, 50));
+    let output = "";
+    try {
+      output = await readFile(logFile, "utf-8");
+    } catch {
+    }
+    let exitCode = 0;
+    try {
+      if (existsSync(exitCodeFile)) {
+        const exitCodeStr = await readFile(exitCodeFile, "utf-8");
+        exitCode = parseInt(exitCodeStr.trim(), 10) || 0;
+      }
+    } catch {
+    }
+    return {
+      id,
+      output: output.trim(),
+      exitCode,
+      status: "completed"
+    };
+  } catch (error) {
+    try {
+      await execAsync(`tmux kill-session -t ${session}`, { timeout: 5e3 });
+    } catch {
+    }
+    throw error;
+  }
+}
+async function runBackground(command, workingDirectory, options) {
+  if (!options) {
+    throw new Error("runBackground: options parameter is required (must include sessionId)");
+  }
+  const id = options.terminalId || generateTerminalId();
+  const session = getSessionName(id);
+  const logDir = await initLogDir(id, {
+    id,
+    command,
+    cwd: workingDirectory,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    sessionId: options.sessionId,
+    background: true
+  }, workingDirectory);
+  const logFile = join(logDir, "output.log");
+  const wrappedCommand = `(${command}) 2>&1 | tee -a ${shellEscape(logFile)}`;
+  await execAsync(
+    `tmux new-session -d -s ${session} -c ${shellEscape(workingDirectory)} ${shellEscape(wrappedCommand)}`,
+    { timeout: 5e3 }
+  );
+  return {
+    id,
+    output: "",
+    exitCode: 0,
+    status: "running"
+  };
+}
+async function getLogs(terminalId, workingDirectory, options = {}) {
+  const session = getSessionName(terminalId);
+  const logDir = getLogDir(terminalId, workingDirectory, options.sessionId);
+  const logFile = join(logDir, "output.log");
+  let isRunning = false;
+  try {
+    await execAsync(`tmux has-session -t ${session}`, { timeout: 5e3 });
+    isRunning = true;
+  } catch {
+  }
+  if (isRunning) {
+    try {
+      const lines = options.tail || 1e3;
+      const { stdout } = await execAsync(
+        `tmux capture-pane -t ${session} -p -S -${lines}`,
+        { timeout: 5e3, maxBuffer: 10 * 1024 * 1024 }
+      );
+      return { output: stdout.trim(), status: "running" };
+    } catch {
+    }
+  }
+  try {
+    let output = await readFile(logFile, "utf-8");
+    if (options.tail) {
+      const lines = output.split("\n");
+      output = lines.slice(-options.tail).join("\n");
+    }
+    return { output: output.trim(), status: isRunning ? "running" : "stopped" };
+  } catch {
+    return { output: "", status: "unknown" };
+  }
+}
+async function killTerminal(terminalId) {
+  const session = getSessionName(terminalId);
+  try {
+    await execAsync(`tmux kill-session -t ${session}`, { timeout: 5e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function sendInput(terminalId, input, options = {}) {
+  const session = getSessionName(terminalId);
+  const { pressEnter = true } = options;
+  try {
+    await execAsync(`tmux has-session -t ${session}`, { timeout: 1e3 });
+    await execAsync(
+      `tmux send-keys -t ${session} -l ${shellEscape(input)}`,
+      { timeout: 1e3 }
+    );
+    if (pressEnter) {
+      await execAsync(
+        `tmux send-keys -t ${session} Enter`,
+        { timeout: 1e3 }
+      );
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function sendKey(terminalId, key) {
+  const session = getSessionName(terminalId);
+  try {
+    await execAsync(`tmux has-session -t ${session}`, { timeout: 1e3 });
+    await execAsync(`tmux send-keys -t ${session} ${key}`, { timeout: 1e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/tools/bash.ts
+var execAsync2 = promisify2(exec2);
+var COMMAND_TIMEOUT = 12e4;
 var MAX_OUTPUT_CHARS2 = 1e4;
 var BLOCKED_COMMANDS = [
   "rm -rf /",
@@ -38,66 +282,226 @@ function isBlockedCommand(command) {
   );
 }
 var bashInputSchema = z.object({
-  command: z.string().describe("The bash command to execute. Can be a single command or a pipeline.")
+  command: z.string().optional().describe("The command to execute. Required for running new commands."),
+  background: z.boolean().default(false).describe("Run the command in background mode (for dev servers, watchers). Returns immediately with terminal ID."),
+  id: z.string().optional().describe("Terminal ID. Use to get logs from, send input to, or kill an existing terminal."),
+  kill: z.boolean().optional().describe("Kill the terminal with the given ID."),
+  tail: z.number().optional().describe("Number of lines to return from the end of output (for logs)."),
+  input: z.string().optional().describe("Send text input to an interactive terminal (requires id). Used for responding to prompts."),
+  key: z.enum(["Enter", "Escape", "Up", "Down", "Left", "Right", "Tab", "C-c", "C-d", "y", "n"]).optional().describe('Send a special key to an interactive terminal (requires id). Use "y" or "n" for yes/no prompts.')
 });
+var useTmux = null;
+async function shouldUseTmux() {
+  if (useTmux === null) {
+    useTmux = await isTmuxAvailable();
+    if (!useTmux) {
+      console.warn("[bash] tmux not available, using fallback exec mode");
+    }
+  }
+  return useTmux;
+}
+async function execFallback(command, workingDirectory, onOutput) {
+  try {
+    const { stdout, stderr } = await execAsync2(command, {
+      cwd: workingDirectory,
+      timeout: COMMAND_TIMEOUT,
+      maxBuffer: 10 * 1024 * 1024
+    });
+    const output = truncateOutput(stdout + (stderr ? `
+${stderr}` : ""), MAX_OUTPUT_CHARS2);
+    onOutput?.(output);
+    return {
+      success: true,
+      output,
+      exitCode: 0
+    };
+  } catch (error) {
+    const output = truncateOutput(
+      (error.stdout || "") + (error.stderr ? `
+${error.stderr}` : ""),
+      MAX_OUTPUT_CHARS2
+    );
+    onOutput?.(output || error.message);
+    if (error.killed) {
+      return {
+        success: false,
+        error: `Command timed out after ${COMMAND_TIMEOUT / 1e3} seconds`,
+        output,
+        exitCode: 124
+      };
+    }
+    return {
+      success: false,
+      error: error.message,
+      output,
+      exitCode: error.code ?? 1
+    };
+  }
+}
 function createBashTool(options) {
   return tool({
-    description: `Execute a bash command in the terminal. The command runs in the working directory: ${options.workingDirectory}. 
-Use this for running shell commands, scripts, git operations, package managers (npm, pip, etc.), and other CLI tools.
-Long outputs will be automatically truncated. Commands have a 60 second timeout.
-IMPORTANT: Avoid destructive commands. Be careful with rm, chmod, and similar operations.`,
+    description: `Execute commands in the terminal. Every command runs in its own session with logs saved to disk.
+
+**Run a command (default - waits for completion):**
+bash({ command: "npm install" })
+bash({ command: "git status" })
+
+**Run in background (for dev servers, watchers, or interactive commands):**
+bash({ command: "npm run dev", background: true })
+\u2192 Returns { id: "abc123" } - save this ID
+
+**Check on a background process:**
+bash({ id: "abc123" })
+bash({ id: "abc123", tail: 50 })  // last 50 lines only
+
+**Stop a background process:**
+bash({ id: "abc123", kill: true })
+
+**Respond to interactive prompts (for yes/no questions, etc.):**
+bash({ id: "abc123", key: "y" })   // send 'y' for yes
+bash({ id: "abc123", key: "n" })   // send 'n' for no
+bash({ id: "abc123", key: "Enter" })  // press Enter
+bash({ id: "abc123", input: "my text" })  // send text input
+
+**IMPORTANT for interactive commands:**
+- Use --yes, -y, or similar flags to avoid prompts when available
+- For create-next-app: add --yes to accept defaults
+- For npm: add --yes or -y to skip confirmation
+- If prompts are unavoidable, run in background mode and use input/key to respond
+
+Logs are saved to .sparkecoder/terminals/{id}/output.log`,
     inputSchema: bashInputSchema,
-    execute: async ({ command }) => {
+    execute: async (inputArgs) => {
+      const { command, background, id, kill, tail, input: textInput, key } = inputArgs;
+      if (id) {
+        if (kill) {
+          const success = await killTerminal(id);
+          return {
+            success,
+            id,
+            status: success ? "stopped" : "not_found",
+            message: success ? `Terminal ${id} stopped` : `Terminal ${id} not found or already stopped`
+          };
+        }
+        if (textInput !== void 0) {
+          const success = await sendInput(id, textInput, { pressEnter: true });
+          if (!success) {
+            return {
+              success: false,
+              id,
+              error: `Terminal ${id} not found or not running`
+            };
+          }
+          await new Promise((r) => setTimeout(r, 300));
+          const { output: output2, status: status2 } = await getLogs(id, options.workingDirectory, { tail: tail || 50, sessionId: options.sessionId });
+          const truncatedOutput2 = truncateOutput(output2, MAX_OUTPUT_CHARS2);
+          return {
+            success: true,
+            id,
+            output: truncatedOutput2,
+            status: status2,
+            message: `Sent input "${textInput}" to terminal`
+          };
+        }
+        if (key) {
+          const success = await sendKey(id, key);
+          if (!success) {
+            return {
+              success: false,
+              id,
+              error: `Terminal ${id} not found or not running`
+            };
+          }
+          await new Promise((r) => setTimeout(r, 300));
+          const { output: output2, status: status2 } = await getLogs(id, options.workingDirectory, { tail: tail || 50, sessionId: options.sessionId });
+          const truncatedOutput2 = truncateOutput(output2, MAX_OUTPUT_CHARS2);
+          return {
+            success: true,
+            id,
+            output: truncatedOutput2,
+            status: status2,
+            message: `Sent key "${key}" to terminal`
+          };
+        }
+        const { output, status } = await getLogs(id, options.workingDirectory, { tail, sessionId: options.sessionId });
+        const truncatedOutput = truncateOutput(output, MAX_OUTPUT_CHARS2);
+        return {
+          success: true,
+          id,
+          output: truncatedOutput,
+          status
+        };
+      }
+      if (!command) {
+        return {
+          success: false,
+          error: 'Either "command" (to run a new command) or "id" (to check/kill/send input) is required'
+        };
+      }
       if (isBlockedCommand(command)) {
         return {
           success: false,
           error: "This command is blocked for safety reasons.",
-          stdout: "",
-          stderr: "",
+          output: "",
           exitCode: 1
         };
       }
-      try {
-        const { stdout, stderr } = await execAsync(command, {
-          cwd: options.workingDirectory,
-          timeout: COMMAND_TIMEOUT,
-          maxBuffer: 10 * 1024 * 1024,
-          // 10MB buffer
-          shell: "/bin/bash"
-        });
-        const truncatedStdout = truncateOutput(stdout, MAX_OUTPUT_CHARS2);
-        const truncatedStderr = truncateOutput(stderr, MAX_OUTPUT_CHARS2 / 2);
-        if (options.onOutput) {
-          options.onOutput(truncatedStdout);
+      const canUseTmux = await shouldUseTmux();
+      if (background) {
+        if (!canUseTmux) {
+          return {
+            success: false,
+            error: "Background mode requires tmux to be installed. Install with: brew install tmux (macOS) or apt install tmux (Linux)"
+          };
         }
+        const terminalId = generateTerminalId();
+        options.onProgress?.({ terminalId, status: "started", command });
+        const result = await runBackground(command, options.workingDirectory, {
+          sessionId: options.sessionId,
+          terminalId
+        });
         return {
           success: true,
-          stdout: truncatedStdout,
-          stderr: truncatedStderr,
-          exitCode: 0
+          id: result.id,
+          status: "running",
+          message: `Started background process. Use bash({ id: "${result.id}" }) to check logs.`
         };
-      } catch (error) {
-        const stdout = error.stdout ? truncateOutput(error.stdout, MAX_OUTPUT_CHARS2) : "";
-        const stderr = error.stderr ? truncateOutput(error.stderr, MAX_OUTPUT_CHARS2) : "";
-        if (options.onOutput) {
-          options.onOutput(stderr || error.message);
-        }
-        if (error.killed) {
+      }
+      if (canUseTmux) {
+        const terminalId = generateTerminalId();
+        options.onProgress?.({ terminalId, status: "started", command });
+        try {
+          const result = await runSync(command, options.workingDirectory, {
+            sessionId: options.sessionId,
+            timeout: COMMAND_TIMEOUT,
+            terminalId
+          });
+          const truncatedOutput = truncateOutput(result.output, MAX_OUTPUT_CHARS2);
+          options.onOutput?.(truncatedOutput);
+          options.onProgress?.({ terminalId, status: "completed", command });
+          return {
+            success: result.exitCode === 0,
+            id: result.id,
+            output: truncatedOutput,
+            exitCode: result.exitCode,
+            status: result.status
+          };
+        } catch (error) {
+          options.onProgress?.({ terminalId, status: "completed", command });
           return {
             success: false,
-            error: `Command timed out after ${COMMAND_TIMEOUT / 1e3} seconds`,
-            stdout,
-            stderr,
-            exitCode: 124
-            // Standard timeout exit code
+            error: error.message,
+            output: "",
+            exitCode: 1
           };
         }
+      } else {
+        const result = await execFallback(command, options.workingDirectory, options.onOutput);
         return {
-          success: false,
-          error: error.message,
-          stdout,
-          stderr,
-          exitCode: error.code ?? 1
+          success: result.success,
+          output: result.output,
+          exitCode: result.exitCode,
+          error: result.error
         };
       }
     }
@@ -107,9 +511,9 @@ IMPORTANT: Avoid destructive commands. Be careful with rm, chmod, and similar op
 // src/tools/read-file.ts
 import { tool as tool2 } from "ai";
 import { z as z2 } from "zod";
-import { readFile, stat } from "fs/promises";
+import { readFile as readFile2, stat } from "fs/promises";
 import { resolve, relative, isAbsolute } from "path";
-import { existsSync } from "fs";
+import { existsSync as existsSync2 } from "fs";
 var MAX_FILE_SIZE = 5 * 1024 * 1024;
 var MAX_OUTPUT_CHARS3 = 5e4;
 var readFileInputSchema = z2.object({
@@ -134,7 +538,7 @@ Use this to understand existing code, check file contents, or gather context.`,
             content: null
           };
         }
-        if (!existsSync(absolutePath)) {
+        if (!existsSync2(absolutePath)) {
           return {
             success: false,
             error: `File not found: ${path}`,
@@ -156,7 +560,7 @@ Use this to understand existing code, check file contents, or gather context.`,
             content: null
           };
         }
-        let content = await readFile(absolutePath, "utf-8");
+        let content = await readFile2(absolutePath, "utf-8");
         if (startLine !== void 0 || endLine !== void 0) {
           const lines = content.split("\n");
           const start = (startLine ?? 1) - 1;
@@ -204,9 +608,305 @@ Use this to understand existing code, check file contents, or gather context.`,
 // src/tools/write-file.ts
 import { tool as tool3 } from "ai";
 import { z as z3 } from "zod";
-import { readFile as readFile2, writeFile, mkdir } from "fs/promises";
-import { resolve as resolve2, relative as relative2, isAbsolute as isAbsolute2, dirname } from "path";
-import { existsSync as existsSync2 } from "fs";
+import { readFile as readFile4, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
+import { resolve as resolve3, relative as relative3, isAbsolute as isAbsolute2, dirname as dirname2 } from "path";
+import { existsSync as existsSync4 } from "fs";
+
+// src/checkpoints/index.ts
+import { readFile as readFile3, writeFile as writeFile2, unlink, mkdir as mkdir2 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { resolve as resolve2, relative as relative2, dirname } from "path";
+import { exec as exec3 } from "child_process";
+import { promisify as promisify3 } from "util";
+
+// src/db/index.ts
+import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import { eq, desc, and, sql } from "drizzle-orm";
+import { nanoid as nanoid2 } from "nanoid";
+
+// src/db/schema.ts
+import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
+var sessions = sqliteTable("sessions", {
+  id: text("id").primaryKey(),
+  name: text("name"),
+  workingDirectory: text("working_directory").notNull(),
+  model: text("model").notNull(),
+  status: text("status", { enum: ["active", "waiting", "completed", "error"] }).notNull().default("active"),
+  config: text("config", { mode: "json" }).$type(),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
+  updatedAt: integer("updated_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
+});
+var messages = sqliteTable("messages", {
+  id: text("id").primaryKey(),
+  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+  // Store the entire ModelMessage as JSON (role + content)
+  modelMessage: text("model_message", { mode: "json" }).$type().notNull(),
+  // Sequence number within session to maintain exact ordering
+  sequence: integer("sequence").notNull().default(0),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
+});
+var toolExecutions = sqliteTable("tool_executions", {
+  id: text("id").primaryKey(),
+  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+  messageId: text("message_id").references(() => messages.id, { onDelete: "cascade" }),
+  toolName: text("tool_name").notNull(),
+  toolCallId: text("tool_call_id").notNull(),
+  input: text("input", { mode: "json" }),
+  output: text("output", { mode: "json" }),
+  status: text("status", { enum: ["pending", "approved", "rejected", "completed", "error"] }).notNull().default("pending"),
+  requiresApproval: integer("requires_approval", { mode: "boolean" }).notNull().default(false),
+  error: text("error"),
+  startedAt: integer("started_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
+  completedAt: integer("completed_at", { mode: "timestamp" })
+});
+var todoItems = sqliteTable("todo_items", {
+  id: text("id").primaryKey(),
+  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+  content: text("content").notNull(),
+  status: text("status", { enum: ["pending", "in_progress", "completed", "cancelled"] }).notNull().default("pending"),
+  order: integer("order").notNull().default(0),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
+  updatedAt: integer("updated_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
+});
+var loadedSkills = sqliteTable("loaded_skills", {
+  id: text("id").primaryKey(),
+  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+  skillName: text("skill_name").notNull(),
+  loadedAt: integer("loaded_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
+});
+var terminals = sqliteTable("terminals", {
+  id: text("id").primaryKey(),
+  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+  name: text("name"),
+  // Optional friendly name (e.g., "dev-server")
+  command: text("command").notNull(),
+  // The command that was run
+  cwd: text("cwd").notNull(),
+  // Working directory
+  pid: integer("pid"),
+  // Process ID (null if not running)
+  status: text("status", { enum: ["running", "stopped", "error"] }).notNull().default("running"),
+  exitCode: integer("exit_code"),
+  // Exit code if stopped
+  error: text("error"),
+  // Error message if status is 'error'
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
+  stoppedAt: integer("stopped_at", { mode: "timestamp" })
+});
+var activeStreams = sqliteTable("active_streams", {
+  id: text("id").primaryKey(),
+  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+  streamId: text("stream_id").notNull().unique(),
+  // Unique stream identifier
+  status: text("status", { enum: ["active", "finished", "error"] }).notNull().default("active"),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
+  finishedAt: integer("finished_at", { mode: "timestamp" })
+});
+var checkpoints = sqliteTable("checkpoints", {
+  id: text("id").primaryKey(),
+  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+  // The message sequence number this checkpoint was created BEFORE
+  // (i.e., the state before this user message was processed)
+  messageSequence: integer("message_sequence").notNull(),
+  // Optional git commit hash if in a git repo
+  gitHead: text("git_head"),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
+});
+var fileBackups = sqliteTable("file_backups", {
+  id: text("id").primaryKey(),
+  checkpointId: text("checkpoint_id").notNull().references(() => checkpoints.id, { onDelete: "cascade" }),
+  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+  // Relative path from working directory
+  filePath: text("file_path").notNull(),
+  // Original content (null means file didn't exist before)
+  originalContent: text("original_content"),
+  // Whether the file existed before this checkpoint
+  existed: integer("existed", { mode: "boolean" }).notNull().default(true),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
+});
+
+// src/db/index.ts
+var db = null;
+function getDb() {
+  if (!db) {
+    throw new Error("Database not initialized. Call initDatabase first.");
+  }
+  return db;
+}
+var todoQueries = {
+  create(data) {
+    const id = nanoid2();
+    const now = /* @__PURE__ */ new Date();
+    const result = getDb().insert(todoItems).values({
+      id,
+      ...data,
+      createdAt: now,
+      updatedAt: now
+    }).returning().get();
+    return result;
+  },
+  createMany(sessionId, items) {
+    const now = /* @__PURE__ */ new Date();
+    const values = items.map((item, index) => ({
+      id: nanoid2(),
+      sessionId,
+      content: item.content,
+      order: item.order ?? index,
+      createdAt: now,
+      updatedAt: now
+    }));
+    return getDb().insert(todoItems).values(values).returning().all();
+  },
+  getBySession(sessionId) {
+    return getDb().select().from(todoItems).where(eq(todoItems.sessionId, sessionId)).orderBy(todoItems.order).all();
+  },
+  updateStatus(id, status) {
+    return getDb().update(todoItems).set({ status, updatedAt: /* @__PURE__ */ new Date() }).where(eq(todoItems.id, id)).returning().get();
+  },
+  delete(id) {
+    const result = getDb().delete(todoItems).where(eq(todoItems.id, id)).run();
+    return result.changes > 0;
+  },
+  clearSession(sessionId) {
+    const result = getDb().delete(todoItems).where(eq(todoItems.sessionId, sessionId)).run();
+    return result.changes;
+  }
+};
+var skillQueries = {
+  load(sessionId, skillName) {
+    const id = nanoid2();
+    const result = getDb().insert(loadedSkills).values({
+      id,
+      sessionId,
+      skillName,
+      loadedAt: /* @__PURE__ */ new Date()
+    }).returning().get();
+    return result;
+  },
+  getBySession(sessionId) {
+    return getDb().select().from(loadedSkills).where(eq(loadedSkills.sessionId, sessionId)).orderBy(loadedSkills.loadedAt).all();
+  },
+  isLoaded(sessionId, skillName) {
+    const result = getDb().select().from(loadedSkills).where(
+      and(
+        eq(loadedSkills.sessionId, sessionId),
+        eq(loadedSkills.skillName, skillName)
+      )
+    ).get();
+    return !!result;
+  }
+};
+var fileBackupQueries = {
+  create(data) {
+    const id = nanoid2();
+    const result = getDb().insert(fileBackups).values({
+      id,
+      checkpointId: data.checkpointId,
+      sessionId: data.sessionId,
+      filePath: data.filePath,
+      originalContent: data.originalContent,
+      existed: data.existed,
+      createdAt: /* @__PURE__ */ new Date()
+    }).returning().get();
+    return result;
+  },
+  getByCheckpoint(checkpointId) {
+    return getDb().select().from(fileBackups).where(eq(fileBackups.checkpointId, checkpointId)).all();
+  },
+  getBySession(sessionId) {
+    return getDb().select().from(fileBackups).where(eq(fileBackups.sessionId, sessionId)).orderBy(fileBackups.createdAt).all();
+  },
+  /**
+   * Get all file backups from a given checkpoint sequence onwards (inclusive)
+   * (Used when reverting - need to restore these files)
+   * 
+   * When reverting to checkpoint X, we need backups from checkpoint X and all later ones
+   * because checkpoint X's backups represent the state BEFORE processing message X.
+   */
+  getFromSequence(sessionId, messageSequence) {
+    const checkpointsFrom = getDb().select().from(checkpoints).where(
+      and(
+        eq(checkpoints.sessionId, sessionId),
+        sql`message_sequence >= ${messageSequence}`
+      )
+    ).all();
+    if (checkpointsFrom.length === 0) {
+      return [];
+    }
+    const checkpointIds = checkpointsFrom.map((c) => c.id);
+    const allBackups = [];
+    for (const cpId of checkpointIds) {
+      const backups = getDb().select().from(fileBackups).where(eq(fileBackups.checkpointId, cpId)).all();
+      allBackups.push(...backups);
+    }
+    return allBackups;
+  },
+  /**
+   * Check if a file already has a backup in the current checkpoint
+   */
+  hasBackup(checkpointId, filePath) {
+    const result = getDb().select().from(fileBackups).where(
+      and(
+        eq(fileBackups.checkpointId, checkpointId),
+        eq(fileBackups.filePath, filePath)
+      )
+    ).get();
+    return !!result;
+  },
+  deleteBySession(sessionId) {
+    const result = getDb().delete(fileBackups).where(eq(fileBackups.sessionId, sessionId)).run();
+    return result.changes;
+  }
+};
+
+// src/checkpoints/index.ts
+var execAsync3 = promisify3(exec3);
+var activeManagers = /* @__PURE__ */ new Map();
+function getCheckpointManager(sessionId, workingDirectory) {
+  let manager = activeManagers.get(sessionId);
+  if (!manager) {
+    manager = {
+      sessionId,
+      workingDirectory,
+      currentCheckpointId: null
+    };
+    activeManagers.set(sessionId, manager);
+  }
+  return manager;
+}
+async function backupFile(sessionId, workingDirectory, filePath) {
+  const manager = getCheckpointManager(sessionId, workingDirectory);
+  if (!manager.currentCheckpointId) {
+    console.warn("[checkpoint] No active checkpoint, skipping file backup");
+    return null;
+  }
+  const absolutePath = resolve2(workingDirectory, filePath);
+  const relativePath = relative2(workingDirectory, absolutePath);
+  if (fileBackupQueries.hasBackup(manager.currentCheckpointId, relativePath)) {
+    return null;
+  }
+  let originalContent = null;
+  let existed = false;
+  if (existsSync3(absolutePath)) {
+    try {
+      originalContent = await readFile3(absolutePath, "utf-8");
+      existed = true;
+    } catch (error) {
+      console.warn(`[checkpoint] Failed to read file for backup: ${error.message}`);
+    }
+  }
+  const backup = fileBackupQueries.create({
+    checkpointId: manager.currentCheckpointId,
+    sessionId,
+    filePath: relativePath,
+    originalContent,
+    existed
+  });
+  return backup;
+}
+
+// src/tools/write-file.ts
 var writeFileInputSchema = z3.object({
   path: z3.string().describe("The path to the file. Can be relative to working directory or absolute."),
   mode: z3.enum(["full", "str_replace"]).describe('Write mode: "full" for complete file write, "str_replace" for targeted string replacement'),
@@ -235,8 +935,8 @@ Working directory: ${options.workingDirectory}`,
     inputSchema: writeFileInputSchema,
     execute: async ({ path, mode, content, old_string, new_string }) => {
       try {
-        const absolutePath = isAbsolute2(path) ? path : resolve2(options.workingDirectory, path);
-        const relativePath = relative2(options.workingDirectory, absolutePath);
+        const absolutePath = isAbsolute2(path) ? path : resolve3(options.workingDirectory, path);
+        const relativePath = relative3(options.workingDirectory, absolutePath);
         if (relativePath.startsWith("..") && !isAbsolute2(path)) {
           return {
             success: false,
@@ -250,16 +950,17 @@ Working directory: ${options.workingDirectory}`,
               error: 'Content is required for "full" mode'
             };
           }
-          const dir = dirname(absolutePath);
-          if (!existsSync2(dir)) {
-            await mkdir(dir, { recursive: true });
+          await backupFile(options.sessionId, options.workingDirectory, absolutePath);
+          const dir = dirname2(absolutePath);
+          if (!existsSync4(dir)) {
+            await mkdir3(dir, { recursive: true });
           }
-          const existed = existsSync2(absolutePath);
-          await writeFile(absolutePath, content, "utf-8");
+          const existed = existsSync4(absolutePath);
+          await writeFile3(absolutePath, content, "utf-8");
           return {
             success: true,
             path: absolutePath,
-            relativePath: relative2(options.workingDirectory, absolutePath),
+            relativePath: relative3(options.workingDirectory, absolutePath),
             mode: "full",
             action: existed ? "replaced" : "created",
             bytesWritten: Buffer.byteLength(content, "utf-8"),
@@ -272,13 +973,14 @@ Working directory: ${options.workingDirectory}`,
               error: 'Both old_string and new_string are required for "str_replace" mode'
             };
           }
-          if (!existsSync2(absolutePath)) {
+          if (!existsSync4(absolutePath)) {
             return {
               success: false,
               error: `File not found: ${path}. Use "full" mode to create new files.`
             };
           }
-          const currentContent = await readFile2(absolutePath, "utf-8");
+          await backupFile(options.sessionId, options.workingDirectory, absolutePath);
+          const currentContent = await readFile4(absolutePath, "utf-8");
           if (!currentContent.includes(old_string)) {
             const lines = currentContent.split("\n");
             const preview = lines.slice(0, 20).join("\n");
@@ -299,13 +1001,13 @@ Working directory: ${options.workingDirectory}`,
             };
           }
           const newContent = currentContent.replace(old_string, new_string);
-          await writeFile(absolutePath, newContent, "utf-8");
+          await writeFile3(absolutePath, newContent, "utf-8");
           const oldLines = old_string.split("\n").length;
           const newLines = new_string.split("\n").length;
           return {
             success: true,
             path: absolutePath,
-            relativePath: relative2(options.workingDirectory, absolutePath),
+            relativePath: relative3(options.workingDirectory, absolutePath),
             mode: "str_replace",
             linesRemoved: oldLines,
             linesAdded: newLines,
@@ -316,213 +1018,19 @@ Working directory: ${options.workingDirectory}`,
           success: false,
           error: `Invalid mode: ${mode}`
         };
-      } catch (error) {
-        return {
-          success: false,
-          error: error.message
-        };
-      }
-    }
-  });
-}
-
-// src/tools/todo.ts
-import { tool as tool4 } from "ai";
-import { z as z4 } from "zod";
-
-// src/db/index.ts
-import Database from "better-sqlite3";
-import { drizzle } from "drizzle-orm/better-sqlite3";
-import { eq, desc, and, sql } from "drizzle-orm";
-import { nanoid } from "nanoid";
-
-// src/db/schema.ts
-import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
-var sessions = sqliteTable("sessions", {
-  id: text("id").primaryKey(),
-  name: text("name"),
-  workingDirectory: text("working_directory").notNull(),
-  model: text("model").notNull(),
-  status: text("status", { enum: ["active", "waiting", "completed", "error"] }).notNull().default("active"),
-  config: text("config", { mode: "json" }).$type(),
-  createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
-  updatedAt: integer("updated_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
-});
-var messages = sqliteTable("messages", {
-  id: text("id").primaryKey(),
-  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
-  // Store the entire ModelMessage as JSON (role + content)
-  modelMessage: text("model_message", { mode: "json" }).$type().notNull(),
-  // Sequence number within session to maintain exact ordering
-  sequence: integer("sequence").notNull().default(0),
-  createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
-});
-var toolExecutions = sqliteTable("tool_executions", {
-  id: text("id").primaryKey(),
-  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
-  messageId: text("message_id").references(() => messages.id, { onDelete: "cascade" }),
-  toolName: text("tool_name").notNull(),
-  toolCallId: text("tool_call_id").notNull(),
-  input: text("input", { mode: "json" }),
-  output: text("output", { mode: "json" }),
-  status: text("status", { enum: ["pending", "approved", "rejected", "completed", "error"] }).notNull().default("pending"),
-  requiresApproval: integer("requires_approval", { mode: "boolean" }).notNull().default(false),
-  error: text("error"),
-  startedAt: integer("started_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
-  completedAt: integer("completed_at", { mode: "timestamp" })
-});
-var todoItems = sqliteTable("todo_items", {
-  id: text("id").primaryKey(),
-  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
-  content: text("content").notNull(),
-  status: text("status", { enum: ["pending", "in_progress", "completed", "cancelled"] }).notNull().default("pending"),
-  order: integer("order").notNull().default(0),
-  createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
-  updatedAt: integer("updated_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
-});
-var loadedSkills = sqliteTable("loaded_skills", {
-  id: text("id").primaryKey(),
-  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
-  skillName: text("skill_name").notNull(),
-  loadedAt: integer("loaded_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
-});
-var terminals = sqliteTable("terminals", {
-  id: text("id").primaryKey(),
-  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
-  name: text("name"),
-  // Optional friendly name (e.g., "dev-server")
-  command: text("command").notNull(),
-  // The command that was run
-  cwd: text("cwd").notNull(),
-  // Working directory
-  pid: integer("pid"),
-  // Process ID (null if not running)
-  status: text("status", { enum: ["running", "stopped", "error"] }).notNull().default("running"),
-  exitCode: integer("exit_code"),
-  // Exit code if stopped
-  error: text("error"),
-  // Error message if status is 'error'
-  createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
-  stoppedAt: integer("stopped_at", { mode: "timestamp" })
-});
-
-// src/db/index.ts
-var db = null;
-function getDb() {
-  if (!db) {
-    throw new Error("Database not initialized. Call initDatabase first.");
-  }
-  return db;
+      } catch (error) {
+        return {
+          success: false,
+          error: error.message
+        };
+      }
+    }
+  });
 }
-var todoQueries = {
-  create(data) {
-    const id = nanoid();
-    const now = /* @__PURE__ */ new Date();
-    const result = getDb().insert(todoItems).values({
-      id,
-      ...data,
-      createdAt: now,
-      updatedAt: now
-    }).returning().get();
-    return result;
-  },
-  createMany(sessionId, items) {
-    const now = /* @__PURE__ */ new Date();
-    const values = items.map((item, index) => ({
-      id: nanoid(),
-      sessionId,
-      content: item.content,
-      order: item.order ?? index,
-      createdAt: now,
-      updatedAt: now
-    }));
-    return getDb().insert(todoItems).values(values).returning().all();
-  },
-  getBySession(sessionId) {
-    return getDb().select().from(todoItems).where(eq(todoItems.sessionId, sessionId)).orderBy(todoItems.order).all();
-  },
-  updateStatus(id, status) {
-    return getDb().update(todoItems).set({ status, updatedAt: /* @__PURE__ */ new Date() }).where(eq(todoItems.id, id)).returning().get();
-  },
-  delete(id) {
-    const result = getDb().delete(todoItems).where(eq(todoItems.id, id)).run();
-    return result.changes > 0;
-  },
-  clearSession(sessionId) {
-    const result = getDb().delete(todoItems).where(eq(todoItems.sessionId, sessionId)).run();
-    return result.changes;
-  }
-};
-var skillQueries = {
-  load(sessionId, skillName) {
-    const id = nanoid();
-    const result = getDb().insert(loadedSkills).values({
-      id,
-      sessionId,
-      skillName,
-      loadedAt: /* @__PURE__ */ new Date()
-    }).returning().get();
-    return result;
-  },
-  getBySession(sessionId) {
-    return getDb().select().from(loadedSkills).where(eq(loadedSkills.sessionId, sessionId)).orderBy(loadedSkills.loadedAt).all();
-  },
-  isLoaded(sessionId, skillName) {
-    const result = getDb().select().from(loadedSkills).where(
-      and(
-        eq(loadedSkills.sessionId, sessionId),
-        eq(loadedSkills.skillName, skillName)
-      )
-    ).get();
-    return !!result;
-  }
-};
-var terminalQueries = {
-  create(data) {
-    const id = nanoid();
-    const result = getDb().insert(terminals).values({
-      id,
-      ...data,
-      createdAt: /* @__PURE__ */ new Date()
-    }).returning().get();
-    return result;
-  },
-  getById(id) {
-    return getDb().select().from(terminals).where(eq(terminals.id, id)).get();
-  },
-  getBySession(sessionId) {
-    return getDb().select().from(terminals).where(eq(terminals.sessionId, sessionId)).orderBy(desc(terminals.createdAt)).all();
-  },
-  getRunning(sessionId) {
-    return getDb().select().from(terminals).where(
-      and(
-        eq(terminals.sessionId, sessionId),
-        eq(terminals.status, "running")
-      )
-    ).all();
-  },
-  updateStatus(id, status, exitCode, error) {
-    return getDb().update(terminals).set({
-      status,
-      exitCode,
-      error,
-      stoppedAt: status !== "running" ? /* @__PURE__ */ new Date() : void 0
-    }).where(eq(terminals.id, id)).returning().get();
-  },
-  updatePid(id, pid) {
-    return getDb().update(terminals).set({ pid }).where(eq(terminals.id, id)).returning().get();
-  },
-  delete(id) {
-    const result = getDb().delete(terminals).where(eq(terminals.id, id)).run();
-    return result.changes > 0;
-  },
-  deleteBySession(sessionId) {
-    const result = getDb().delete(terminals).where(eq(terminals.sessionId, sessionId)).run();
-    return result.changes;
-  }
-};
 
 // src/tools/todo.ts
+import { tool as tool4 } from "ai";
+import { z as z4 } from "zod";
 var todoInputSchema = z4.object({
   action: z4.enum(["add", "list", "mark", "clear"]).describe("The action to perform on the todo list"),
   items: z4.array(
@@ -650,9 +1158,9 @@ import { tool as tool5 } from "ai";
 import { z as z6 } from "zod";
 
 // src/skills/index.ts
-import { readFile as readFile3, readdir } from "fs/promises";
-import { resolve as resolve3, basename, extname } from "path";
-import { existsSync as existsSync3 } from "fs";
+import { readFile as readFile5, readdir } from "fs/promises";
+import { resolve as resolve4, basename, extname } from "path";
+import { existsSync as existsSync5 } from "fs";
 
 // src/config/types.ts
 import { z as z5 } from "zod";
@@ -738,15 +1246,15 @@ function getSkillNameFromPath(filePath) {
   return basename(filePath, extname(filePath)).replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
 }
 async function loadSkillsFromDirectory(directory) {
-  if (!existsSync3(directory)) {
+  if (!existsSync5(directory)) {
     return [];
   }
   const skills = [];
   const files = await readdir(directory);
   for (const file of files) {
     if (!file.endsWith(".md")) continue;
-    const filePath = resolve3(directory, file);
-    const content = await readFile3(filePath, "utf-8");
+    const filePath = resolve4(directory, file);
+    const content = await readFile5(filePath, "utf-8");
     const parsed = parseSkillFrontmatter(content);
     if (parsed) {
       skills.push({
@@ -788,7 +1296,7 @@ async function loadSkillContent(skillName, directories) {
   if (!skill) {
     return null;
   }
-  const content = await readFile3(skill.filePath, "utf-8");
+  const content = await readFile5(skill.filePath, "utf-8");
   const parsed = parseSkillFrontmatter(content);
   return {
     ...skill,
@@ -886,460 +1394,21 @@ Once loaded, a skill's content will be available in the conversation context.`,
   });
 }
 
-// src/tools/terminal.ts
-import { tool as tool6 } from "ai";
-import { z as z7 } from "zod";
-
-// src/terminal/manager.ts
-import { spawn } from "child_process";
-import { EventEmitter } from "events";
-var LogBuffer = class {
-  buffer = [];
-  maxSize;
-  totalBytes = 0;
-  maxBytes;
-  constructor(maxBytes = 50 * 1024) {
-    this.maxBytes = maxBytes;
-    this.maxSize = 1e3;
-  }
-  append(data) {
-    const lines = data.split("\n");
-    for (const line of lines) {
-      if (line) {
-        this.buffer.push(line);
-        this.totalBytes += line.length;
-      }
-    }
-    while (this.totalBytes > this.maxBytes && this.buffer.length > 1) {
-      const removed = this.buffer.shift();
-      if (removed) {
-        this.totalBytes -= removed.length;
-      }
-    }
-    while (this.buffer.length > this.maxSize) {
-      const removed = this.buffer.shift();
-      if (removed) {
-        this.totalBytes -= removed.length;
-      }
-    }
-  }
-  getAll() {
-    return this.buffer.join("\n");
-  }
-  getTail(lines) {
-    const start = Math.max(0, this.buffer.length - lines);
-    return this.buffer.slice(start).join("\n");
-  }
-  clear() {
-    this.buffer = [];
-    this.totalBytes = 0;
-  }
-  get lineCount() {
-    return this.buffer.length;
-  }
-};
-var TerminalManager = class _TerminalManager extends EventEmitter {
-  processes = /* @__PURE__ */ new Map();
-  static instance = null;
-  constructor() {
-    super();
-  }
-  static getInstance() {
-    if (!_TerminalManager.instance) {
-      _TerminalManager.instance = new _TerminalManager();
-    }
-    return _TerminalManager.instance;
-  }
-  /**
-   * Spawn a new background process
-   */
-  spawn(options) {
-    const { sessionId, command, cwd, name, env } = options;
-    const parts = this.parseCommand(command);
-    const executable = parts[0];
-    const args = parts.slice(1);
-    const terminal = terminalQueries.create({
-      sessionId,
-      name: name || null,
-      command,
-      cwd: cwd || process.cwd(),
-      status: "running"
-    });
-    const proc = spawn(executable, args, {
-      cwd: cwd || process.cwd(),
-      shell: true,
-      stdio: ["pipe", "pipe", "pipe"],
-      env: { ...process.env, ...env },
-      detached: false
-    });
-    if (proc.pid) {
-      terminalQueries.updatePid(terminal.id, proc.pid);
-    }
-    const logs = new LogBuffer();
-    proc.stdout?.on("data", (data) => {
-      const text2 = data.toString();
-      logs.append(text2);
-      this.emit("stdout", { terminalId: terminal.id, data: text2 });
-    });
-    proc.stderr?.on("data", (data) => {
-      const text2 = data.toString();
-      logs.append(`[stderr] ${text2}`);
-      this.emit("stderr", { terminalId: terminal.id, data: text2 });
-    });
-    proc.on("exit", (code, signal) => {
-      const exitCode = code ?? (signal ? 128 : 0);
-      terminalQueries.updateStatus(terminal.id, "stopped", exitCode);
-      this.emit("exit", { terminalId: terminal.id, code: exitCode, signal });
-      const managed2 = this.processes.get(terminal.id);
-      if (managed2) {
-        managed2.terminal = { ...managed2.terminal, status: "stopped", exitCode };
-      }
-    });
-    proc.on("error", (err) => {
-      terminalQueries.updateStatus(terminal.id, "error", void 0, err.message);
-      this.emit("error", { terminalId: terminal.id, error: err.message });
-      const managed2 = this.processes.get(terminal.id);
-      if (managed2) {
-        managed2.terminal = { ...managed2.terminal, status: "error", error: err.message };
-      }
-    });
-    const managed = {
-      id: terminal.id,
-      process: proc,
-      logs,
-      terminal: { ...terminal, pid: proc.pid ?? null }
-    };
-    this.processes.set(terminal.id, managed);
-    return this.toTerminalInfo(managed.terminal);
-  }
-  /**
-   * Get logs from a terminal
-   */
-  getLogs(terminalId, tail) {
-    const managed = this.processes.get(terminalId);
-    if (!managed) {
-      return null;
-    }
-    return {
-      logs: tail ? managed.logs.getTail(tail) : managed.logs.getAll(),
-      lineCount: managed.logs.lineCount
-    };
-  }
-  /**
-   * Get terminal status
-   */
-  getStatus(terminalId) {
-    const managed = this.processes.get(terminalId);
-    if (managed) {
-      if (managed.process.exitCode !== null) {
-        managed.terminal = {
-          ...managed.terminal,
-          status: "stopped",
-          exitCode: managed.process.exitCode
-        };
-      }
-      return this.toTerminalInfo(managed.terminal);
-    }
-    const terminal = terminalQueries.getById(terminalId);
-    if (terminal) {
-      return this.toTerminalInfo(terminal);
-    }
-    return null;
-  }
-  /**
-   * Kill a terminal process
-   */
-  kill(terminalId, signal = "SIGTERM") {
-    const managed = this.processes.get(terminalId);
-    if (!managed) {
-      return false;
-    }
-    try {
-      managed.process.kill(signal);
-      return true;
-    } catch (err) {
-      console.error(`Failed to kill terminal ${terminalId}:`, err);
-      return false;
-    }
-  }
-  /**
-   * Write to a terminal's stdin
-   */
-  write(terminalId, input) {
-    const managed = this.processes.get(terminalId);
-    if (!managed || !managed.process.stdin) {
-      return false;
-    }
-    try {
-      managed.process.stdin.write(input);
-      return true;
-    } catch (err) {
-      console.error(`Failed to write to terminal ${terminalId}:`, err);
-      return false;
-    }
-  }
-  /**
-   * List all terminals for a session
-   */
-  list(sessionId) {
-    const terminals2 = terminalQueries.getBySession(sessionId);
-    return terminals2.map((t) => {
-      const managed = this.processes.get(t.id);
-      if (managed) {
-        return this.toTerminalInfo(managed.terminal);
-      }
-      return this.toTerminalInfo(t);
-    });
-  }
-  /**
-   * Get all running terminals for a session
-   */
-  getRunning(sessionId) {
-    return this.list(sessionId).filter((t) => t.status === "running");
-  }
-  /**
-   * Kill all terminals for a session (cleanup)
-   */
-  killAll(sessionId) {
-    let killed = 0;
-    for (const [id, managed] of this.processes) {
-      if (managed.terminal.sessionId === sessionId) {
-        if (this.kill(id)) {
-          killed++;
-        }
-      }
-    }
-    return killed;
-  }
-  /**
-   * Clean up stopped terminals from memory (keep DB records)
-   */
-  cleanup(sessionId) {
-    let cleaned = 0;
-    for (const [id, managed] of this.processes) {
-      if (sessionId && managed.terminal.sessionId !== sessionId) {
-        continue;
-      }
-      if (managed.terminal.status !== "running") {
-        this.processes.delete(id);
-        cleaned++;
-      }
-    }
-    return cleaned;
-  }
-  /**
-   * Parse a command string into executable and arguments
-   */
-  parseCommand(command) {
-    const parts = [];
-    let current = "";
-    let inQuote = false;
-    let quoteChar = "";
-    for (const char of command) {
-      if ((char === '"' || char === "'") && !inQuote) {
-        inQuote = true;
-        quoteChar = char;
-      } else if (char === quoteChar && inQuote) {
-        inQuote = false;
-        quoteChar = "";
-      } else if (char === " " && !inQuote) {
-        if (current) {
-          parts.push(current);
-          current = "";
-        }
-      } else {
-        current += char;
-      }
-    }
-    if (current) {
-      parts.push(current);
-    }
-    return parts.length > 0 ? parts : [command];
-  }
-  toTerminalInfo(terminal) {
-    return {
-      id: terminal.id,
-      name: terminal.name,
-      command: terminal.command,
-      cwd: terminal.cwd,
-      pid: terminal.pid,
-      status: terminal.status,
-      exitCode: terminal.exitCode,
-      error: terminal.error,
-      createdAt: terminal.createdAt,
-      stoppedAt: terminal.stoppedAt
-    };
-  }
-};
-function getTerminalManager() {
-  return TerminalManager.getInstance();
-}
-
-// src/tools/terminal.ts
-var TerminalInputSchema = z7.object({
-  action: z7.enum(["spawn", "logs", "status", "kill", "write", "list"]).describe(
-    "The action to perform: spawn (start process), logs (get output), status (check if running), kill (stop process), write (send stdin), list (show all)"
-  ),
-  // For spawn
-  command: z7.string().optional().describe('For spawn: The command to run (e.g., "npm run dev")'),
-  cwd: z7.string().optional().describe("For spawn: Working directory for the command"),
-  name: z7.string().optional().describe('For spawn: Optional friendly name (e.g., "dev-server")'),
-  // For logs, status, kill, write
-  terminalId: z7.string().optional().describe("For logs/status/kill/write: The terminal ID"),
-  tail: z7.number().optional().describe("For logs: Number of lines to return from the end"),
-  // For kill
-  signal: z7.enum(["SIGTERM", "SIGKILL"]).optional().describe("For kill: Signal to send (default: SIGTERM)"),
-  // For write
-  input: z7.string().optional().describe("For write: The input to send to stdin")
-});
-function createTerminalTool(options) {
-  const { sessionId, workingDirectory } = options;
-  return tool6({
-    description: `Manage background terminal processes. Use this for long-running commands like dev servers, watchers, or any process that shouldn't block.
-
-Actions:
-- spawn: Start a new background process. Requires 'command'. Returns terminal ID.
-- logs: Get output from a terminal. Requires 'terminalId'. Optional 'tail' for recent lines.
-- status: Check if a terminal is still running. Requires 'terminalId'.
-- kill: Stop a terminal process. Requires 'terminalId'. Optional 'signal'.
-- write: Send input to a terminal's stdin. Requires 'terminalId' and 'input'.
-- list: Show all terminals for this session. No other params needed.
-
-Example workflow:
-1. spawn with command="npm run dev", name="dev-server" \u2192 { id: "abc123", status: "running" }
-2. logs with terminalId="abc123", tail=10 \u2192 "Ready on http://localhost:3000"
-3. kill with terminalId="abc123" \u2192 { success: true }`,
-    inputSchema: TerminalInputSchema,
-    execute: async (input) => {
-      const manager = getTerminalManager();
-      switch (input.action) {
-        case "spawn": {
-          if (!input.command) {
-            return { success: false, error: 'spawn requires a "command" parameter' };
-          }
-          const terminal = manager.spawn({
-            sessionId,
-            command: input.command,
-            cwd: input.cwd || workingDirectory,
-            name: input.name
-          });
-          return {
-            success: true,
-            terminal: formatTerminal(terminal),
-            message: `Started "${input.command}" with terminal ID: ${terminal.id}`
-          };
-        }
-        case "logs": {
-          if (!input.terminalId) {
-            return { success: false, error: 'logs requires a "terminalId" parameter' };
-          }
-          const result = manager.getLogs(input.terminalId, input.tail);
-          if (!result) {
-            return {
-              success: false,
-              error: `Terminal not found: ${input.terminalId}`
-            };
-          }
-          return {
-            success: true,
-            terminalId: input.terminalId,
-            logs: result.logs,
-            lineCount: result.lineCount
-          };
-        }
-        case "status": {
-          if (!input.terminalId) {
-            return { success: false, error: 'status requires a "terminalId" parameter' };
-          }
-          const status = manager.getStatus(input.terminalId);
-          if (!status) {
-            return {
-              success: false,
-              error: `Terminal not found: ${input.terminalId}`
-            };
-          }
-          return {
-            success: true,
-            terminal: formatTerminal(status)
-          };
-        }
-        case "kill": {
-          if (!input.terminalId) {
-            return { success: false, error: 'kill requires a "terminalId" parameter' };
-          }
-          const success = manager.kill(input.terminalId, input.signal);
-          if (!success) {
-            return {
-              success: false,
-              error: `Failed to kill terminal: ${input.terminalId}`
-            };
-          }
-          return {
-            success: true,
-            message: `Sent ${input.signal || "SIGTERM"} to terminal ${input.terminalId}`
-          };
-        }
-        case "write": {
-          if (!input.terminalId) {
-            return { success: false, error: 'write requires a "terminalId" parameter' };
-          }
-          if (!input.input) {
-            return { success: false, error: 'write requires an "input" parameter' };
-          }
-          const success = manager.write(input.terminalId, input.input);
-          if (!success) {
-            return {
-              success: false,
-              error: `Failed to write to terminal: ${input.terminalId}`
-            };
-          }
-          return {
-            success: true,
-            message: `Sent input to terminal ${input.terminalId}`
-          };
-        }
-        case "list": {
-          const terminals2 = manager.list(sessionId);
-          return {
-            success: true,
-            terminals: terminals2.map(formatTerminal),
-            count: terminals2.length,
-            running: terminals2.filter((t) => t.status === "running").length
-          };
-        }
-        default:
-          return { success: false, error: `Unknown action: ${input.action}` };
-      }
-    }
-  });
-}
-function formatTerminal(t) {
-  return {
-    id: t.id,
-    name: t.name,
-    command: t.command,
-    cwd: t.cwd,
-    pid: t.pid,
-    status: t.status,
-    exitCode: t.exitCode,
-    error: t.error,
-    createdAt: t.createdAt.toISOString(),
-    stoppedAt: t.stoppedAt?.toISOString() || null
-  };
-}
-
 // src/tools/index.ts
 function createTools(options) {
   return {
     bash: createBashTool({
       workingDirectory: options.workingDirectory,
-      onOutput: options.onBashOutput
+      sessionId: options.sessionId,
+      onOutput: options.onBashOutput,
+      onProgress: options.onBashProgress
     }),
     read_file: createReadFileTool({
       workingDirectory: options.workingDirectory
     }),
     write_file: createWriteFileTool({
-      workingDirectory: options.workingDirectory
+      workingDirectory: options.workingDirectory,
+      sessionId: options.sessionId
     }),
     todo: createTodoTool({
       sessionId: options.sessionId
@@ -1347,10 +1416,6 @@ function createTools(options) {
     load_skill: createLoadSkillTool({
       sessionId: options.sessionId,
       skillsDirectories: options.skillsDirectories
-    }),
-    terminal: createTerminalTool({
-      sessionId: options.sessionId,
-      workingDirectory: options.workingDirectory
     })
   };
 }
@@ -1358,7 +1423,6 @@ export {
   createBashTool,
   createLoadSkillTool,
   createReadFileTool,
-  createTerminalTool,
   createTodoTool,
   createTools,
   createWriteFileTool