sparkecoder 0.1.4 → 0.1.5

package/dist/index.js

@@ -1,17 +1,32 @@
 var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/agent/index.ts
+import {
+  streamText,
+  generateText as generateText2,
+  tool as tool6,
+  stepCountIs
+} from "ai";
+import { gateway as gateway2 } from "@ai-sdk/gateway";
+import { z as z7 } from "zod";
+import { nanoid as nanoid3 } from "nanoid";
+
+// 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
 var schema_exports = {};
 __export(schema_exports, {
   activeStreams: () => activeStreams,
+  checkpoints: () => checkpoints,
+  fileBackups: () => fileBackups,
   loadedSkills: () => loadedSkills,
   messages: () => messages,
   sessions: () => sessions,
@@ -20,107 +35,108 @@ __export(schema_exports, {
   toolExecutions: () => toolExecutions
 });
 import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
-var sessions, messages, toolExecutions, todoItems, loadedSkills, terminals, activeStreams;
-var init_schema = __esm({
-  "src/db/schema.ts"() {
-    "use strict";
-    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())
-    });
-    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())
-    });
-    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" })
-    });
-    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())
-    });
-    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())
-    });
-    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" })
-    });
-    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 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_exports = {};
-__export(db_exports, {
-  activeStreamQueries: () => activeStreamQueries,
-  closeDatabase: () => closeDatabase,
-  getDb: () => getDb,
-  initDatabase: () => initDatabase,
-  messageQueries: () => messageQueries,
-  sessionQueries: () => sessionQueries,
-  skillQueries: () => skillQueries,
-  terminalQueries: () => terminalQueries,
-  todoQueries: () => todoQueries,
-  toolExecutionQueries: () => toolExecutionQueries
-});
-import Database from "better-sqlite3";
-import { drizzle } from "drizzle-orm/better-sqlite3";
-import { eq, desc, and, sql } from "drizzle-orm";
-import { nanoid } from "nanoid";
+var db = null;
+var sqlite = null;
 function initDatabase(dbPath) {
   sqlite = new Database(dbPath);
   sqlite.pragma("journal_mode = WAL");
@@ -201,12 +217,35 @@ function initDatabase(dbPath) {
       finished_at INTEGER
     );
 
+    -- Checkpoints table - created before each user message
+    CREATE TABLE IF NOT EXISTS checkpoints (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+      message_sequence INTEGER NOT NULL,
+      git_head TEXT,
+      created_at INTEGER NOT NULL
+    );
+
+    -- File backups table - stores original file content
+    CREATE TABLE IF NOT EXISTS file_backups (
+      id TEXT PRIMARY KEY,
+      checkpoint_id TEXT NOT NULL REFERENCES checkpoints(id) ON DELETE CASCADE,
+      session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+      file_path TEXT NOT NULL,
+      original_content TEXT,
+      existed INTEGER NOT NULL DEFAULT 1,
+      created_at INTEGER NOT NULL
+    );
+
     CREATE INDEX IF NOT EXISTS idx_messages_session ON messages(session_id);
     CREATE INDEX IF NOT EXISTS idx_tool_executions_session ON tool_executions(session_id);
     CREATE INDEX IF NOT EXISTS idx_todo_items_session ON todo_items(session_id);
     CREATE INDEX IF NOT EXISTS idx_loaded_skills_session ON loaded_skills(session_id);
     CREATE INDEX IF NOT EXISTS idx_terminals_session ON terminals(session_id);
     CREATE INDEX IF NOT EXISTS idx_active_streams_session ON active_streams(session_id);
+    CREATE INDEX IF NOT EXISTS idx_checkpoints_session ON checkpoints(session_id);
+    CREATE INDEX IF NOT EXISTS idx_file_backups_checkpoint ON file_backups(checkpoint_id);
+    CREATE INDEX IF NOT EXISTS idx_file_backups_session ON file_backups(session_id);
   `);
   return db;
 }
@@ -223,313 +262,383 @@ function closeDatabase() {
     db = null;
   }
 }
-var db, sqlite, sessionQueries, messageQueries, toolExecutionQueries, todoQueries, skillQueries, terminalQueries, activeStreamQueries;
-var init_db = __esm({
-  "src/db/index.ts"() {
-    "use strict";
-    init_schema();
-    db = null;
-    sqlite = null;
-    sessionQueries = {
-      create(data) {
-        const id = nanoid();
-        const now = /* @__PURE__ */ new Date();
-        const result = getDb().insert(sessions).values({
-          id,
-          ...data,
-          createdAt: now,
-          updatedAt: now
-        }).returning().get();
-        return result;
-      },
-      getById(id) {
-        return getDb().select().from(sessions).where(eq(sessions.id, id)).get();
-      },
-      list(limit = 50, offset = 0) {
-        return getDb().select().from(sessions).orderBy(desc(sessions.createdAt)).limit(limit).offset(offset).all();
-      },
-      updateStatus(id, status) {
-        return getDb().update(sessions).set({ status, updatedAt: /* @__PURE__ */ new Date() }).where(eq(sessions.id, id)).returning().get();
-      },
-      updateModel(id, model) {
-        return getDb().update(sessions).set({ model, updatedAt: /* @__PURE__ */ new Date() }).where(eq(sessions.id, id)).returning().get();
-      },
-      update(id, updates) {
-        return getDb().update(sessions).set({ ...updates, updatedAt: /* @__PURE__ */ new Date() }).where(eq(sessions.id, id)).returning().get();
-      },
-      delete(id) {
-        const result = getDb().delete(sessions).where(eq(sessions.id, id)).run();
-        return result.changes > 0;
-      }
-    };
-    messageQueries = {
-      /**
-       * Get the next sequence number for a session
-       */
-      getNextSequence(sessionId) {
-        const result = getDb().select({ maxSeq: sql`COALESCE(MAX(sequence), -1)` }).from(messages).where(eq(messages.sessionId, sessionId)).get();
-        return (result?.maxSeq ?? -1) + 1;
-      },
-      /**
-       * Create a single message from a ModelMessage
-       */
-      create(sessionId, modelMessage) {
-        const id = nanoid();
-        const sequence = this.getNextSequence(sessionId);
-        const result = getDb().insert(messages).values({
-          id,
-          sessionId,
-          modelMessage,
-          sequence,
-          createdAt: /* @__PURE__ */ new Date()
-        }).returning().get();
-        return result;
-      },
-      /**
-       * Add multiple ModelMessages at once (from response.messages)
-       * Maintains insertion order via sequence numbers
-       */
-      addMany(sessionId, modelMessages) {
-        const results = [];
-        let sequence = this.getNextSequence(sessionId);
-        for (const msg of modelMessages) {
-          const id = nanoid();
-          const result = getDb().insert(messages).values({
-            id,
-            sessionId,
-            modelMessage: msg,
-            sequence,
-            createdAt: /* @__PURE__ */ new Date()
-          }).returning().get();
-          results.push(result);
-          sequence++;
-        }
-        return results;
-      },
-      /**
-       * Get all messages for a session as ModelMessage[]
-       * Ordered by sequence to maintain exact insertion order
-       */
-      getBySession(sessionId) {
-        return getDb().select().from(messages).where(eq(messages.sessionId, sessionId)).orderBy(messages.sequence).all();
-      },
-      /**
-       * Get ModelMessages directly (for passing to AI SDK)
-       */
-      getModelMessages(sessionId) {
-        const messages2 = this.getBySession(sessionId);
-        return messages2.map((m) => m.modelMessage);
-      },
-      getRecentBySession(sessionId, limit = 50) {
-        return getDb().select().from(messages).where(eq(messages.sessionId, sessionId)).orderBy(desc(messages.sequence)).limit(limit).all().reverse();
-      },
-      countBySession(sessionId) {
-        const result = getDb().select({ count: sql`count(*)` }).from(messages).where(eq(messages.sessionId, sessionId)).get();
-        return result?.count ?? 0;
-      },
-      deleteBySession(sessionId) {
-        const result = getDb().delete(messages).where(eq(messages.sessionId, sessionId)).run();
-        return result.changes;
-      }
-    };
-    toolExecutionQueries = {
-      create(data) {
-        const id = nanoid();
-        const result = getDb().insert(toolExecutions).values({
-          id,
-          ...data,
-          startedAt: /* @__PURE__ */ new Date()
-        }).returning().get();
-        return result;
-      },
-      getById(id) {
-        return getDb().select().from(toolExecutions).where(eq(toolExecutions.id, id)).get();
-      },
-      getByToolCallId(toolCallId) {
-        return getDb().select().from(toolExecutions).where(eq(toolExecutions.toolCallId, toolCallId)).get();
-      },
-      getPendingApprovals(sessionId) {
-        return getDb().select().from(toolExecutions).where(
-          and(
-            eq(toolExecutions.sessionId, sessionId),
-            eq(toolExecutions.status, "pending"),
-            eq(toolExecutions.requiresApproval, true)
-          )
-        ).all();
-      },
-      approve(id) {
-        return getDb().update(toolExecutions).set({ status: "approved" }).where(eq(toolExecutions.id, id)).returning().get();
-      },
-      reject(id) {
-        return getDb().update(toolExecutions).set({ status: "rejected" }).where(eq(toolExecutions.id, id)).returning().get();
-      },
-      complete(id, output, error) {
-        return getDb().update(toolExecutions).set({
-          status: error ? "error" : "completed",
-          output,
-          error,
-          completedAt: /* @__PURE__ */ new Date()
-        }).where(eq(toolExecutions.id, id)).returning().get();
-      },
-      getBySession(sessionId) {
-        return getDb().select().from(toolExecutions).where(eq(toolExecutions.sessionId, sessionId)).orderBy(toolExecutions.startedAt).all();
-      }
-    };
-    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;
-      }
-    };
-    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;
-      }
-    };
-    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;
-      }
-    };
-    activeStreamQueries = {
-      create(sessionId, streamId) {
-        const id = nanoid();
-        const result = getDb().insert(activeStreams).values({
-          id,
-          sessionId,
-          streamId,
-          status: "active",
-          createdAt: /* @__PURE__ */ new Date()
-        }).returning().get();
-        return result;
-      },
-      getBySessionId(sessionId) {
-        return getDb().select().from(activeStreams).where(
-          and(
-            eq(activeStreams.sessionId, sessionId),
-            eq(activeStreams.status, "active")
-          )
-        ).get();
-      },
-      getByStreamId(streamId) {
-        return getDb().select().from(activeStreams).where(eq(activeStreams.streamId, streamId)).get();
-      },
-      finish(streamId) {
-        return getDb().update(activeStreams).set({ status: "finished", finishedAt: /* @__PURE__ */ new Date() }).where(eq(activeStreams.streamId, streamId)).returning().get();
-      },
-      markError(streamId) {
-        return getDb().update(activeStreams).set({ status: "error", finishedAt: /* @__PURE__ */ new Date() }).where(eq(activeStreams.streamId, streamId)).returning().get();
-      },
-      deleteBySession(sessionId) {
-        const result = getDb().delete(activeStreams).where(eq(activeStreams.sessionId, sessionId)).run();
-        return result.changes;
-      }
-    };
+var sessionQueries = {
+  create(data) {
+    const id = nanoid();
+    const now = /* @__PURE__ */ new Date();
+    const result = getDb().insert(sessions).values({
+      id,
+      ...data,
+      createdAt: now,
+      updatedAt: now
+    }).returning().get();
+    return result;
+  },
+  getById(id) {
+    return getDb().select().from(sessions).where(eq(sessions.id, id)).get();
+  },
+  list(limit = 50, offset = 0) {
+    return getDb().select().from(sessions).orderBy(desc(sessions.createdAt)).limit(limit).offset(offset).all();
+  },
+  updateStatus(id, status) {
+    return getDb().update(sessions).set({ status, updatedAt: /* @__PURE__ */ new Date() }).where(eq(sessions.id, id)).returning().get();
+  },
+  updateModel(id, model) {
+    return getDb().update(sessions).set({ model, updatedAt: /* @__PURE__ */ new Date() }).where(eq(sessions.id, id)).returning().get();
+  },
+  update(id, updates) {
+    return getDb().update(sessions).set({ ...updates, updatedAt: /* @__PURE__ */ new Date() }).where(eq(sessions.id, id)).returning().get();
+  },
+  delete(id) {
+    const result = getDb().delete(sessions).where(eq(sessions.id, id)).run();
+    return result.changes > 0;
   }
-});
-
-// src/agent/index.ts
-init_db();
-import {
-  streamText,
-  generateText as generateText2,
-  tool as tool6,
-  stepCountIs
-} from "ai";
-import { gateway as gateway2 } from "@ai-sdk/gateway";
-import { z as z7 } from "zod";
-import { nanoid as nanoid3 } from "nanoid";
+};
+var messageQueries = {
+  /**
+   * Get the next sequence number for a session
+   */
+  getNextSequence(sessionId) {
+    const result = getDb().select({ maxSeq: sql`COALESCE(MAX(sequence), -1)` }).from(messages).where(eq(messages.sessionId, sessionId)).get();
+    return (result?.maxSeq ?? -1) + 1;
+  },
+  /**
+   * Create a single message from a ModelMessage
+   */
+  create(sessionId, modelMessage) {
+    const id = nanoid();
+    const sequence = this.getNextSequence(sessionId);
+    const result = getDb().insert(messages).values({
+      id,
+      sessionId,
+      modelMessage,
+      sequence,
+      createdAt: /* @__PURE__ */ new Date()
+    }).returning().get();
+    return result;
+  },
+  /**
+   * Add multiple ModelMessages at once (from response.messages)
+   * Maintains insertion order via sequence numbers
+   */
+  addMany(sessionId, modelMessages) {
+    const results = [];
+    let sequence = this.getNextSequence(sessionId);
+    for (const msg of modelMessages) {
+      const id = nanoid();
+      const result = getDb().insert(messages).values({
+        id,
+        sessionId,
+        modelMessage: msg,
+        sequence,
+        createdAt: /* @__PURE__ */ new Date()
+      }).returning().get();
+      results.push(result);
+      sequence++;
+    }
+    return results;
+  },
+  /**
+   * Get all messages for a session as ModelMessage[]
+   * Ordered by sequence to maintain exact insertion order
+   */
+  getBySession(sessionId) {
+    return getDb().select().from(messages).where(eq(messages.sessionId, sessionId)).orderBy(messages.sequence).all();
+  },
+  /**
+   * Get ModelMessages directly (for passing to AI SDK)
+   */
+  getModelMessages(sessionId) {
+    const messages2 = this.getBySession(sessionId);
+    return messages2.map((m) => m.modelMessage);
+  },
+  getRecentBySession(sessionId, limit = 50) {
+    return getDb().select().from(messages).where(eq(messages.sessionId, sessionId)).orderBy(desc(messages.sequence)).limit(limit).all().reverse();
+  },
+  countBySession(sessionId) {
+    const result = getDb().select({ count: sql`count(*)` }).from(messages).where(eq(messages.sessionId, sessionId)).get();
+    return result?.count ?? 0;
+  },
+  deleteBySession(sessionId) {
+    const result = getDb().delete(messages).where(eq(messages.sessionId, sessionId)).run();
+    return result.changes;
+  },
+  /**
+   * Delete all messages with sequence >= the given sequence number
+   * (Used when reverting to a checkpoint)
+   */
+  deleteFromSequence(sessionId, fromSequence) {
+    const result = getDb().delete(messages).where(
+      and(
+        eq(messages.sessionId, sessionId),
+        sql`sequence >= ${fromSequence}`
+      )
+    ).run();
+    return result.changes;
+  }
+};
+var toolExecutionQueries = {
+  create(data) {
+    const id = nanoid();
+    const result = getDb().insert(toolExecutions).values({
+      id,
+      ...data,
+      startedAt: /* @__PURE__ */ new Date()
+    }).returning().get();
+    return result;
+  },
+  getById(id) {
+    return getDb().select().from(toolExecutions).where(eq(toolExecutions.id, id)).get();
+  },
+  getByToolCallId(toolCallId) {
+    return getDb().select().from(toolExecutions).where(eq(toolExecutions.toolCallId, toolCallId)).get();
+  },
+  getPendingApprovals(sessionId) {
+    return getDb().select().from(toolExecutions).where(
+      and(
+        eq(toolExecutions.sessionId, sessionId),
+        eq(toolExecutions.status, "pending"),
+        eq(toolExecutions.requiresApproval, true)
+      )
+    ).all();
+  },
+  approve(id) {
+    return getDb().update(toolExecutions).set({ status: "approved" }).where(eq(toolExecutions.id, id)).returning().get();
+  },
+  reject(id) {
+    return getDb().update(toolExecutions).set({ status: "rejected" }).where(eq(toolExecutions.id, id)).returning().get();
+  },
+  complete(id, output, error) {
+    return getDb().update(toolExecutions).set({
+      status: error ? "error" : "completed",
+      output,
+      error,
+      completedAt: /* @__PURE__ */ new Date()
+    }).where(eq(toolExecutions.id, id)).returning().get();
+  },
+  getBySession(sessionId) {
+    return getDb().select().from(toolExecutions).where(eq(toolExecutions.sessionId, sessionId)).orderBy(toolExecutions.startedAt).all();
+  },
+  /**
+   * Delete all tool executions after a given timestamp
+   * (Used when reverting to a checkpoint)
+   */
+  deleteAfterTime(sessionId, afterTime) {
+    const result = getDb().delete(toolExecutions).where(
+      and(
+        eq(toolExecutions.sessionId, sessionId),
+        sql`started_at > ${afterTime.getTime()}`
+      )
+    ).run();
+    return result.changes;
+  }
+};
+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 activeStreamQueries = {
+  create(sessionId, streamId) {
+    const id = nanoid();
+    const result = getDb().insert(activeStreams).values({
+      id,
+      sessionId,
+      streamId,
+      status: "active",
+      createdAt: /* @__PURE__ */ new Date()
+    }).returning().get();
+    return result;
+  },
+  getBySessionId(sessionId) {
+    return getDb().select().from(activeStreams).where(
+      and(
+        eq(activeStreams.sessionId, sessionId),
+        eq(activeStreams.status, "active")
+      )
+    ).get();
+  },
+  getByStreamId(streamId) {
+    return getDb().select().from(activeStreams).where(eq(activeStreams.streamId, streamId)).get();
+  },
+  finish(streamId) {
+    return getDb().update(activeStreams).set({ status: "finished", finishedAt: /* @__PURE__ */ new Date() }).where(eq(activeStreams.streamId, streamId)).returning().get();
+  },
+  markError(streamId) {
+    return getDb().update(activeStreams).set({ status: "error", finishedAt: /* @__PURE__ */ new Date() }).where(eq(activeStreams.streamId, streamId)).returning().get();
+  },
+  deleteBySession(sessionId) {
+    const result = getDb().delete(activeStreams).where(eq(activeStreams.sessionId, sessionId)).run();
+    return result.changes;
+  }
+};
+var checkpointQueries = {
+  create(data) {
+    const id = nanoid();
+    const result = getDb().insert(checkpoints).values({
+      id,
+      sessionId: data.sessionId,
+      messageSequence: data.messageSequence,
+      gitHead: data.gitHead,
+      createdAt: /* @__PURE__ */ new Date()
+    }).returning().get();
+    return result;
+  },
+  getById(id) {
+    return getDb().select().from(checkpoints).where(eq(checkpoints.id, id)).get();
+  },
+  getBySession(sessionId) {
+    return getDb().select().from(checkpoints).where(eq(checkpoints.sessionId, sessionId)).orderBy(checkpoints.messageSequence).all();
+  },
+  getByMessageSequence(sessionId, messageSequence) {
+    return getDb().select().from(checkpoints).where(
+      and(
+        eq(checkpoints.sessionId, sessionId),
+        eq(checkpoints.messageSequence, messageSequence)
+      )
+    ).get();
+  },
+  getLatest(sessionId) {
+    return getDb().select().from(checkpoints).where(eq(checkpoints.sessionId, sessionId)).orderBy(desc(checkpoints.messageSequence)).limit(1).get();
+  },
+  /**
+   * Delete all checkpoints after a given sequence number
+   * (Used when reverting to a checkpoint)
+   */
+  deleteAfterSequence(sessionId, messageSequence) {
+    const result = getDb().delete(checkpoints).where(
+      and(
+        eq(checkpoints.sessionId, sessionId),
+        sql`message_sequence > ${messageSequence}`
+      )
+    ).run();
+    return result.changes;
+  },
+  deleteBySession(sessionId) {
+    const result = getDb().delete(checkpoints).where(eq(checkpoints.sessionId, sessionId)).run();
+    return result.changes;
+  }
+};
+var fileBackupQueries = {
+  create(data) {
+    const id = nanoid();
+    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/config/index.ts
 import { existsSync, readFileSync, mkdirSync, writeFileSync } from "fs";
@@ -883,7 +992,6 @@ async function isTmuxAvailable() {
   try {
     const { stdout } = await execAsync("tmux -V");
     tmuxAvailableCache = true;
-    console.log(`[tmux] Available: ${stdout.trim()}`);
     return true;
   } catch (error) {
     tmuxAvailableCache = false;
@@ -1503,9 +1611,198 @@ 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 z4 } from "zod";
-import { readFile as readFile3, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { resolve as resolve3, relative as relative2, isAbsolute as isAbsolute2, dirname as dirname2 } from "path";
+import { readFile as readFile4, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
+import { resolve as resolve4, relative as relative3, isAbsolute as isAbsolute2, dirname as dirname3 } from "path";
+import { existsSync as existsSync5 } from "fs";
+
+// src/checkpoints/index.ts
+import { readFile as readFile3, writeFile as writeFile2, unlink, mkdir as mkdir2 } from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
+import { resolve as resolve3, relative as relative2, dirname as dirname2 } from "path";
+import { exec as exec3 } from "child_process";
+import { promisify as promisify3 } from "util";
+var execAsync3 = promisify3(exec3);
+async function getGitHead(workingDirectory) {
+  try {
+    const { stdout } = await execAsync3("git rev-parse HEAD", {
+      cwd: workingDirectory,
+      timeout: 5e3
+    });
+    return stdout.trim();
+  } catch {
+    return void 0;
+  }
+}
+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 createCheckpoint(sessionId, workingDirectory, messageSequence) {
+  const gitHead = await getGitHead(workingDirectory);
+  const checkpoint = checkpointQueries.create({
+    sessionId,
+    messageSequence,
+    gitHead
+  });
+  const manager = getCheckpointManager(sessionId, workingDirectory);
+  manager.currentCheckpointId = checkpoint.id;
+  return checkpoint;
+}
+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 = resolve3(workingDirectory, filePath);
+  const relativePath = relative2(workingDirectory, absolutePath);
+  if (fileBackupQueries.hasBackup(manager.currentCheckpointId, relativePath)) {
+    return null;
+  }
+  let originalContent = null;
+  let existed = false;
+  if (existsSync4(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;
+}
+async function revertToCheckpoint(sessionId, checkpointId) {
+  const session = sessionQueries.getById(sessionId);
+  if (!session) {
+    return {
+      success: false,
+      filesRestored: 0,
+      filesDeleted: 0,
+      messagesDeleted: 0,
+      checkpointsDeleted: 0,
+      error: "Session not found"
+    };
+  }
+  const checkpoint = checkpointQueries.getById(checkpointId);
+  if (!checkpoint || checkpoint.sessionId !== sessionId) {
+    return {
+      success: false,
+      filesRestored: 0,
+      filesDeleted: 0,
+      messagesDeleted: 0,
+      checkpointsDeleted: 0,
+      error: "Checkpoint not found"
+    };
+  }
+  const workingDirectory = session.workingDirectory;
+  const backupsToRevert = fileBackupQueries.getFromSequence(sessionId, checkpoint.messageSequence);
+  const fileToEarliestBackup = /* @__PURE__ */ new Map();
+  for (const backup of backupsToRevert) {
+    if (!fileToEarliestBackup.has(backup.filePath)) {
+      fileToEarliestBackup.set(backup.filePath, backup);
+    }
+  }
+  let filesRestored = 0;
+  let filesDeleted = 0;
+  for (const [filePath, backup] of fileToEarliestBackup) {
+    const absolutePath = resolve3(workingDirectory, filePath);
+    try {
+      if (backup.existed && backup.originalContent !== null) {
+        const dir = dirname2(absolutePath);
+        if (!existsSync4(dir)) {
+          await mkdir2(dir, { recursive: true });
+        }
+        await writeFile2(absolutePath, backup.originalContent, "utf-8");
+        filesRestored++;
+      } else if (!backup.existed) {
+        if (existsSync4(absolutePath)) {
+          await unlink(absolutePath);
+          filesDeleted++;
+        }
+      }
+    } catch (error) {
+      console.error(`Failed to restore ${filePath}: ${error.message}`);
+    }
+  }
+  const messagesDeleted = messageQueries.deleteFromSequence(sessionId, checkpoint.messageSequence);
+  toolExecutionQueries.deleteAfterTime(sessionId, checkpoint.createdAt);
+  const checkpointsDeleted = checkpointQueries.deleteAfterSequence(sessionId, checkpoint.messageSequence);
+  const manager = getCheckpointManager(sessionId, workingDirectory);
+  manager.currentCheckpointId = checkpoint.id;
+  return {
+    success: true,
+    filesRestored,
+    filesDeleted,
+    messagesDeleted,
+    checkpointsDeleted
+  };
+}
+function getCheckpoints(sessionId) {
+  return checkpointQueries.getBySession(sessionId);
+}
+async function getSessionDiff(sessionId) {
+  const session = sessionQueries.getById(sessionId);
+  if (!session) {
+    return { files: [] };
+  }
+  const workingDirectory = session.workingDirectory;
+  const allBackups = fileBackupQueries.getBySession(sessionId);
+  const fileToOriginalBackup = /* @__PURE__ */ new Map();
+  for (const backup of allBackups) {
+    if (!fileToOriginalBackup.has(backup.filePath)) {
+      fileToOriginalBackup.set(backup.filePath, backup);
+    }
+  }
+  const files = [];
+  for (const [filePath, originalBackup] of fileToOriginalBackup) {
+    const absolutePath = resolve3(workingDirectory, filePath);
+    let currentContent = null;
+    let currentExists = false;
+    if (existsSync4(absolutePath)) {
+      try {
+        currentContent = await readFile3(absolutePath, "utf-8");
+        currentExists = true;
+      } catch {
+      }
+    }
+    let status;
+    if (!originalBackup.existed && currentExists) {
+      status = "created";
+    } else if (originalBackup.existed && !currentExists) {
+      status = "deleted";
+    } else {
+      status = "modified";
+    }
+    files.push({
+      path: filePath,
+      status,
+      originalContent: originalBackup.originalContent,
+      currentContent
+    });
+  }
+  return { files };
+}
+function clearCheckpointManager(sessionId) {
+  activeManagers.delete(sessionId);
+}
+
+// src/tools/write-file.ts
 var writeFileInputSchema = z4.object({
   path: z4.string().describe("The path to the file. Can be relative to working directory or absolute."),
   mode: z4.enum(["full", "str_replace"]).describe('Write mode: "full" for complete file write, "str_replace" for targeted string replacement'),
@@ -1534,8 +1831,8 @@ Working directory: ${options.workingDirectory}`,
     inputSchema: writeFileInputSchema,
     execute: async ({ path, mode, content, old_string, new_string }) => {
       try {
-        const absolutePath = isAbsolute2(path) ? path : resolve3(options.workingDirectory, path);
-        const relativePath = relative2(options.workingDirectory, absolutePath);
+        const absolutePath = isAbsolute2(path) ? path : resolve4(options.workingDirectory, path);
+        const relativePath = relative3(options.workingDirectory, absolutePath);
         if (relativePath.startsWith("..") && !isAbsolute2(path)) {
           return {
             success: false,
@@ -1549,16 +1846,17 @@ Working directory: ${options.workingDirectory}`,
               error: 'Content is required for "full" mode'
             };
           }
-          const dir = dirname2(absolutePath);
-          if (!existsSync4(dir)) {
-            await mkdir2(dir, { recursive: true });
+          await backupFile(options.sessionId, options.workingDirectory, absolutePath);
+          const dir = dirname3(absolutePath);
+          if (!existsSync5(dir)) {
+            await mkdir3(dir, { recursive: true });
           }
-          const existed = existsSync4(absolutePath);
-          await writeFile2(absolutePath, content, "utf-8");
+          const existed = existsSync5(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"),
@@ -1571,13 +1869,14 @@ Working directory: ${options.workingDirectory}`,
               error: 'Both old_string and new_string are required for "str_replace" mode'
             };
           }
-          if (!existsSync4(absolutePath)) {
+          if (!existsSync5(absolutePath)) {
             return {
               success: false,
               error: `File not found: ${path}. Use "full" mode to create new files.`
             };
           }
-          const currentContent = await readFile3(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");
@@ -1598,13 +1897,13 @@ Working directory: ${options.workingDirectory}`,
             };
           }
           const newContent = currentContent.replace(old_string, new_string);
-          await writeFile2(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,
@@ -1626,7 +1925,6 @@ Working directory: ${options.workingDirectory}`,
 }
 
 // src/tools/todo.ts
-init_db();
 import { tool as tool4 } from "ai";
 import { z as z5 } from "zod";
 var todoInputSchema = z5.object({
@@ -1756,9 +2054,9 @@ import { tool as tool5 } from "ai";
 import { z as z6 } from "zod";
 
 // src/skills/index.ts
-import { readFile as readFile4, readdir } from "fs/promises";
-import { resolve as resolve4, basename, extname } from "path";
-import { existsSync as existsSync5 } from "fs";
+import { readFile as readFile5, readdir } from "fs/promises";
+import { resolve as resolve5, basename, extname } from "path";
+import { existsSync as existsSync6 } from "fs";
 function parseSkillFrontmatter(content) {
   const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
   if (!frontmatterMatch) {
@@ -1789,15 +2087,15 @@ function getSkillNameFromPath(filePath) {
   return basename(filePath, extname(filePath)).replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
 }
 async function loadSkillsFromDirectory(directory) {
-  if (!existsSync5(directory)) {
+  if (!existsSync6(directory)) {
     return [];
   }
   const skills = [];
   const files = await readdir(directory);
   for (const file of files) {
     if (!file.endsWith(".md")) continue;
-    const filePath = resolve4(directory, file);
-    const content = await readFile4(filePath, "utf-8");
+    const filePath = resolve5(directory, file);
+    const content = await readFile5(filePath, "utf-8");
     const parsed = parseSkillFrontmatter(content);
     if (parsed) {
       skills.push({
@@ -1839,7 +2137,7 @@ async function loadSkillContent(skillName, directories) {
   if (!skill) {
     return null;
   }
-  const content = await readFile4(skill.filePath, "utf-8");
+  const content = await readFile5(skill.filePath, "utf-8");
   const parsed = parseSkillFrontmatter(content);
   return {
     ...skill,
@@ -1858,7 +2156,6 @@ function formatSkillsForContext(skills) {
 }
 
 // src/tools/load-skill.ts
-init_db();
 var loadSkillInputSchema = z6.object({
   action: z6.enum(["list", "load"]).describe('Action to perform: "list" to see available skills, "load" to load a skill'),
   skillName: z6.string().optional().describe('For "load" action: The name of the skill to load')
@@ -1951,7 +2248,8 @@ function createTools(options) {
       workingDirectory: options.workingDirectory
     }),
     write_file: createWriteFileTool({
-      workingDirectory: options.workingDirectory
+      workingDirectory: options.workingDirectory,
+      sessionId: options.sessionId
     }),
     todo: createTodoTool({
       sessionId: options.sessionId
@@ -1964,13 +2262,11 @@ function createTools(options) {
 }
 
 // src/agent/context.ts
-init_db();
 import { generateText } from "ai";
 import { gateway } from "@ai-sdk/gateway";
 
 // src/agent/prompts.ts
 import os from "os";
-init_db();
 function getSearchInstructions() {
   const platform3 = process.platform;
   const common = `- **Prefer \`read_file\` over shell commands** for reading files - don't use \`cat\`, \`head\`, or \`tail\` when \`read_file\` is available
@@ -2011,6 +2307,9 @@ You have access to powerful tools for:
 - **todo**: Manage your task list to track progress on complex operations
 - **load_skill**: Load specialized knowledge documents for specific tasks
 
+
+IMPORTANT: If you have zero context of where you are working, always explore it first to understand the structure before doing things for the user.
+
 Use the TODO tool to manage your task list to track progress on complex operations. Always ask the user what they want to do specifically before doing it, and make a plan. 
 Step 1 of the plan should be researching files and understanding the components/structure of what you're working on (if you don't already have context), then after u have done that, plan out the rest of the tasks u need to do. 
 You can clear the todo and restart it, and do multiple things inside of one session.
@@ -2447,8 +2746,8 @@ var Agent = class _Agent {
           this.pendingApprovals.set(toolCallId, execution);
           options.onApprovalRequired?.(execution);
           sessionQueries.updateStatus(this.session.id, "waiting");
-          const approved = await new Promise((resolve6) => {
-            approvalResolvers.set(toolCallId, { resolve: resolve6, sessionId: this.session.id });
+          const approved = await new Promise((resolve7) => {
+            approvalResolvers.set(toolCallId, { resolve: resolve7, sessionId: this.session.id });
           });
           const resolverData = approvalResolvers.get(toolCallId);
           approvalResolvers.delete(toolCallId);
@@ -2542,18 +2841,18 @@ var Agent = class _Agent {
 };
 
 // src/server/index.ts
+import "dotenv/config";
 import { Hono as Hono5 } from "hono";
 import { serve } from "@hono/node-server";
 import { cors } from "hono/cors";
 import { logger } from "hono/logger";
-import { existsSync as existsSync6, mkdirSync as mkdirSync2 } from "fs";
-import { resolve as resolve5, dirname as dirname3, join as join3 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync2 } from "fs";
+import { resolve as resolve6, dirname as dirname4, join as join3 } from "path";
 import { spawn } from "child_process";
 import { createServer as createNetServer } from "net";
 import { fileURLToPath } from "url";
 
 // src/server/routes/sessions.ts
-init_db();
 import { Hono } from "hono";
 import { zValidator } from "@hono/zod-validator";
 import { z as z8 } from "zod";
@@ -2764,6 +3063,7 @@ sessions2.delete("/:id", async (c) => {
     }
   } catch (e) {
   }
+  clearCheckpointManager(id);
   const deleted = sessionQueries.delete(id);
   if (!deleted) {
     return c.json({ error: "Session not found" }, 404);
@@ -2815,9 +3115,100 @@ sessions2.get("/:id/todos", async (c) => {
     } : null
   });
 });
+sessions2.get("/:id/checkpoints", async (c) => {
+  const id = c.req.param("id");
+  const session = sessionQueries.getById(id);
+  if (!session) {
+    return c.json({ error: "Session not found" }, 404);
+  }
+  const checkpoints2 = getCheckpoints(id);
+  return c.json({
+    sessionId: id,
+    checkpoints: checkpoints2.map((cp) => ({
+      id: cp.id,
+      messageSequence: cp.messageSequence,
+      gitHead: cp.gitHead,
+      createdAt: cp.createdAt.toISOString()
+    })),
+    count: checkpoints2.length
+  });
+});
+sessions2.post("/:id/revert/:checkpointId", async (c) => {
+  const sessionId = c.req.param("id");
+  const checkpointId = c.req.param("checkpointId");
+  const session = sessionQueries.getById(sessionId);
+  if (!session) {
+    return c.json({ error: "Session not found" }, 404);
+  }
+  const activeStream = activeStreamQueries.getBySessionId(sessionId);
+  if (activeStream) {
+    return c.json({
+      error: "Cannot revert while a stream is active. Stop the stream first.",
+      streamId: activeStream.streamId
+    }, 409);
+  }
+  const result = await revertToCheckpoint(sessionId, checkpointId);
+  if (!result.success) {
+    return c.json({ error: result.error }, 400);
+  }
+  return c.json({
+    success: true,
+    sessionId,
+    checkpointId,
+    filesRestored: result.filesRestored,
+    filesDeleted: result.filesDeleted,
+    messagesDeleted: result.messagesDeleted,
+    checkpointsDeleted: result.checkpointsDeleted
+  });
+});
+sessions2.get("/:id/diff", async (c) => {
+  const id = c.req.param("id");
+  const session = sessionQueries.getById(id);
+  if (!session) {
+    return c.json({ error: "Session not found" }, 404);
+  }
+  const diff = await getSessionDiff(id);
+  return c.json({
+    sessionId: id,
+    files: diff.files.map((f) => ({
+      path: f.path,
+      status: f.status,
+      hasOriginal: f.originalContent !== null,
+      hasCurrent: f.currentContent !== null
+      // Optionally include content (can be large)
+      // originalContent: f.originalContent,
+      // currentContent: f.currentContent,
+    })),
+    summary: {
+      created: diff.files.filter((f) => f.status === "created").length,
+      modified: diff.files.filter((f) => f.status === "modified").length,
+      deleted: diff.files.filter((f) => f.status === "deleted").length,
+      total: diff.files.length
+    }
+  });
+});
+sessions2.get("/:id/diff/:filePath", async (c) => {
+  const sessionId = c.req.param("id");
+  const filePath = decodeURIComponent(c.req.param("filePath"));
+  const session = sessionQueries.getById(sessionId);
+  if (!session) {
+    return c.json({ error: "Session not found" }, 404);
+  }
+  const diff = await getSessionDiff(sessionId);
+  const fileDiff = diff.files.find((f) => f.path === filePath);
+  if (!fileDiff) {
+    return c.json({ error: "File not found in diff" }, 404);
+  }
+  return c.json({
+    sessionId,
+    path: fileDiff.path,
+    status: fileDiff.status,
+    originalContent: fileDiff.originalContent,
+    currentContent: fileDiff.currentContent
+  });
+});
 
 // src/server/routes/agents.ts
-init_db();
 import { Hono as Hono2 } from "hono";
 import { zValidator as zValidator2 } from "@hono/zod-validator";
 import { z as z9 } from "zod";
@@ -3091,8 +3482,9 @@ agents.post(
     if (!session) {
       return c.json({ error: "Session not found" }, 404);
     }
-    const { messageQueries: messageQueries2 } = await Promise.resolve().then(() => (init_db(), db_exports));
-    messageQueries2.create(id, { role: "user", content: prompt });
+    const nextSequence = messageQueries.getNextSequence(id);
+    await createCheckpoint(id, session.workingDirectory, nextSequence);
+    messageQueries.create(id, { role: "user", content: prompt });
     const streamId = `stream_${id}_${nanoid4(10)}`;
     activeStreamQueries.create(id, streamId);
     const stream = await streamContext.resumableStream(
@@ -3291,6 +3683,7 @@ agents.post(
     });
     const session = agent.getSession();
     const streamId = `stream_${session.id}_${nanoid4(10)}`;
+    await createCheckpoint(session.id, session.workingDirectory, 0);
     activeStreamQueries.create(session.id, streamId);
     const createQuickStreamProducer = () => {
       const { readable, writable } = new TransformStream();
@@ -3471,10 +3864,14 @@ import { z as z10 } from "zod";
 var health = new Hono3();
 health.get("/", async (c) => {
   const config = getConfig();
+  const apiKeyStatus = getApiKeyStatus();
+  const gatewayKey = apiKeyStatus.find((s) => s.provider === "ai-gateway");
+  const hasApiKey = gatewayKey?.configured ?? false;
   return c.json({
     status: "ok",
     version: "0.1.0",
     uptime: process.uptime(),
+    apiKeyConfigured: hasApiKey,
     config: {
       workingDirectory: config.resolvedWorkingDirectory,
       defaultModel: config.defaultModel,
@@ -3551,7 +3948,6 @@ health.delete("/api-keys/:provider", async (c) => {
 import { Hono as Hono4 } from "hono";
 import { zValidator as zValidator4 } from "@hono/zod-validator";
 import { z as z11 } from "zod";
-init_db();
 var terminals2 = new Hono4();
 var spawnSchema = z11.object({
   command: z11.string(),
@@ -3849,14 +4245,11 @@ data: ${JSON.stringify({ status: "stopped" })}
   );
 });
 
-// src/server/index.ts
-init_db();
-
 // src/utils/dependencies.ts
-import { exec as exec3 } from "child_process";
-import { promisify as promisify3 } from "util";
+import { exec as exec4 } from "child_process";
+import { promisify as promisify4 } from "util";
 import { platform as platform2 } from "os";
-var execAsync3 = promisify3(exec3);
+var execAsync4 = promisify4(exec4);
 function getInstallInstructions() {
   const os2 = platform2();
   if (os2 === "darwin") {
@@ -3889,7 +4282,7 @@ Install tmux:
 }
 async function checkTmux() {
   try {
-    const { stdout } = await execAsync3("tmux -V", { timeout: 5e3 });
+    const { stdout } = await execAsync4("tmux -V", { timeout: 5e3 });
     const version = stdout.trim();
     return {
       available: true,
@@ -3936,13 +4329,13 @@ var DEFAULT_WEB_PORT = 6969;
 var WEB_PORT_SEQUENCE = [6969, 6970, 6971, 6972, 6973, 6974, 6975, 6976, 6977, 6978];
 function getWebDirectory() {
   try {
-    const currentDir = dirname3(fileURLToPath(import.meta.url));
-    const webDir = resolve5(currentDir, "..", "web");
-    if (existsSync6(webDir) && existsSync6(join3(webDir, "package.json"))) {
+    const currentDir = dirname4(fileURLToPath(import.meta.url));
+    const webDir = resolve6(currentDir, "..", "web");
+    if (existsSync7(webDir) && existsSync7(join3(webDir, "package.json"))) {
       return webDir;
     }
-    const altWebDir = resolve5(currentDir, "..", "..", "web");
-    if (existsSync6(altWebDir) && existsSync6(join3(altWebDir, "package.json"))) {
+    const altWebDir = resolve6(currentDir, "..", "..", "web");
+    if (existsSync7(altWebDir) && existsSync7(join3(altWebDir, "package.json"))) {
       return altWebDir;
     }
     return null;
@@ -3965,18 +4358,18 @@ async function isSparkcoderWebRunning(port) {
   }
 }
 function isPortInUse(port) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const server = createNetServer();
     server.once("error", (err) => {
       if (err.code === "EADDRINUSE") {
-        resolve6(true);
+        resolve7(true);
       } else {
-        resolve6(false);
+        resolve7(false);
       }
     });
     server.once("listening", () => {
       server.close();
-      resolve6(false);
+      resolve7(false);
     });
     server.listen(port, "0.0.0.0");
   });
@@ -4010,7 +4403,7 @@ async function startWebUI(apiPort, webPort = DEFAULT_WEB_PORT, quiet = false) {
     if (!quiet) console.log(`  \u2713 Web UI already running at http://localhost:${actualPort}`);
     return { process: null, port: actualPort };
   }
-  const useNpm = existsSync6(join3(webDir, "package-lock.json"));
+  const useNpm = existsSync7(join3(webDir, "package-lock.json"));
   const command = useNpm ? "npm" : "npx";
   const args = useNpm ? ["run", "dev", "--", "-p", String(actualPort)] : ["next", "dev", "-p", String(actualPort)];
   const child = spawn(command, args, {
@@ -4113,7 +4506,7 @@ async function startServer(options = {}) {
   if (options.workingDirectory) {
     config.resolvedWorkingDirectory = options.workingDirectory;
   }
-  if (!existsSync6(config.resolvedWorkingDirectory)) {
+  if (!existsSync7(config.resolvedWorkingDirectory)) {
     mkdirSync2(config.resolvedWorkingDirectory, { recursive: true });
     if (!options.quiet) console.log(`\u{1F4C1} Created agent workspace: ${config.resolvedWorkingDirectory}`);
   }
@@ -4611,23 +5004,31 @@ function generateOpenAPISpec() {
 }
 
 // src/index.ts
-init_db();
 var VERSION = "0.1.0";
 export {
   Agent,
   VERSION,
+  backupFile,
+  checkpointQueries,
+  clearCheckpointManager,
   closeDatabase,
   createApp,
   createBashTool,
+  createCheckpoint,
   createLoadSkillTool,
   createReadFileTool,
   createTodoTool,
   createTools,
   createWriteFileTool,
+  fileBackupQueries,
+  getCheckpointManager,
+  getCheckpoints,
   getDb,
+  getSessionDiff,
   initDatabase,
   loadConfig,
   messageQueries,
+  revertToCheckpoint,
   sessionQueries,
   skillQueries,
   startServer,