sparkecoder 0.1.3 → 0.1.4

package/dist/server/index.js

@@ -1,30 +1,17 @@
 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/server/index.ts
-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 existsSync5, mkdirSync } from "fs";
-
-// src/server/routes/sessions.ts
-import { Hono } from "hono";
-import { zValidator } from "@hono/zod-validator";
-import { z as z9 } 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
 var schema_exports = {};
 __export(schema_exports, {
+  activeStreams: () => activeStreams,
   loadedSkills: () => loadedSkills,
   messages: () => messages,
   sessions: () => sessions,
@@ -33,90 +20,113 @@ __export(schema_exports, {
   toolExecutions: () => toolExecutions
 });
 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 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" })
+    });
+  }
 });
 
 // src/db/index.ts
-var db = null;
-var sqlite = null;
+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";
 function initDatabase(dbPath) {
   sqlite = new Database(dbPath);
   sqlite.pragma("journal_mode = WAL");
   db = drizzle(sqlite, { schema: schema_exports });
   sqlite.exec(`
-    DROP TABLE IF EXISTS terminals;
-    DROP TABLE IF EXISTS loaded_skills;
-    DROP TABLE IF EXISTS todo_items;
-    DROP TABLE IF EXISTS tool_executions;
-    DROP TABLE IF EXISTS messages;
-    DROP TABLE IF EXISTS sessions;
-
-    CREATE TABLE sessions (
+    CREATE TABLE IF NOT EXISTS sessions (
       id TEXT PRIMARY KEY,
       name TEXT,
       working_directory TEXT NOT NULL,
@@ -127,7 +137,7 @@ function initDatabase(dbPath) {
       updated_at INTEGER NOT NULL
     );
 
-    CREATE TABLE messages (
+    CREATE TABLE IF NOT EXISTS messages (
       id TEXT PRIMARY KEY,
       session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
       model_message TEXT NOT NULL,
@@ -135,7 +145,7 @@ function initDatabase(dbPath) {
       created_at INTEGER NOT NULL
     );
 
-    CREATE TABLE tool_executions (
+    CREATE TABLE IF NOT EXISTS tool_executions (
       id TEXT PRIMARY KEY,
       session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
       message_id TEXT REFERENCES messages(id) ON DELETE CASCADE,
@@ -150,7 +160,7 @@ function initDatabase(dbPath) {
       completed_at INTEGER
     );
 
-    CREATE TABLE todo_items (
+    CREATE TABLE IF NOT EXISTS todo_items (
       id TEXT PRIMARY KEY,
       session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
       content TEXT NOT NULL,
@@ -160,14 +170,14 @@ function initDatabase(dbPath) {
       updated_at INTEGER NOT NULL
     );
 
-    CREATE TABLE loaded_skills (
+    CREATE TABLE IF NOT EXISTS loaded_skills (
       id TEXT PRIMARY KEY,
       session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
       skill_name TEXT NOT NULL,
       loaded_at INTEGER NOT NULL
     );
 
-    CREATE TABLE terminals (
+    CREATE TABLE IF NOT EXISTS terminals (
       id TEXT PRIMARY KEY,
       session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
       name TEXT,
@@ -181,11 +191,22 @@ function initDatabase(dbPath) {
       stopped_at INTEGER
     );
 
+    -- Table for tracking active streams (for resumable streams)
+    CREATE TABLE IF NOT EXISTS active_streams (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+      stream_id TEXT NOT NULL UNIQUE,
+      status TEXT NOT NULL DEFAULT 'active',
+      created_at INTEGER NOT NULL,
+      finished_at INTEGER
+    );
+
     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);
   `);
   return db;
 }
@@ -202,267 +223,335 @@ function closeDatabase() {
     db = null;
   }
 }
-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();
-  },
-  delete(id) {
-    const result = getDb().delete(sessions).where(eq(sessions.id, id)).run();
-    return result.changes > 0;
-  }
-};
-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;
-  }
-};
-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();
-  }
-};
-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;
+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;
+      }
+    };
   }
-};
+});
+
+// src/server/index.ts
+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 { 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";
 
 // src/agent/index.ts
+init_db();
 import {
   streamText,
   generateText as generateText2,
-  tool as tool7,
+  tool as tool6,
   stepCountIs
 } from "ai";
 import { gateway as gateway2 } from "@ai-sdk/gateway";
-import { z as z8 } from "zod";
-import { nanoid as nanoid2 } from "nanoid";
+import { z as z7 } from "zod";
+import { nanoid as nanoid3 } from "nanoid";
 
 // src/config/index.ts
-import { existsSync, readFileSync } from "fs";
-import { resolve, dirname } from "path";
+import { existsSync, readFileSync, mkdirSync, writeFileSync } from "fs";
+import { resolve, dirname, join } from "path";
+import { homedir, platform } from "os";
 
 // src/config/types.ts
 import { z } from "zod";
@@ -523,6 +612,24 @@ var CONFIG_FILE_NAMES = [
   "sparkecoder.json",
   ".sparkecoder.json"
 ];
+function getAppDataDirectory() {
+  const appName = "sparkecoder";
+  switch (platform()) {
+    case "darwin":
+      return join(homedir(), "Library", "Application Support", appName);
+    case "win32":
+      return join(process.env.APPDATA || join(homedir(), "AppData", "Roaming"), appName);
+    default:
+      return join(process.env.XDG_DATA_HOME || join(homedir(), ".local", "share"), appName);
+  }
+}
+function ensureAppDataDirectory() {
+  const dir = getAppDataDirectory();
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
 var cachedConfig = null;
 function findConfigFile(startDir) {
   let currentDir = startDir;
@@ -535,6 +642,13 @@ function findConfigFile(startDir) {
     }
     currentDir = dirname(currentDir);
   }
+  const appDataDir = getAppDataDirectory();
+  for (const fileName of CONFIG_FILE_NAMES) {
+    const configPath = join(appDataDir, fileName);
+    if (existsSync(configPath)) {
+      return configPath;
+    }
+  }
   return null;
 }
 function loadConfig(configPath, workingDirectory) {
@@ -569,7 +683,14 @@ function loadConfig(configPath, workingDirectory) {
     rawConfig.databasePath = process.env.DATABASE_PATH;
   }
   const config = SparkcoderConfigSchema.parse(rawConfig);
-  const resolvedWorkingDirectory = config.workingDirectory ? resolve(configDir, config.workingDirectory) : cwd;
+  let resolvedWorkingDirectory;
+  if (workingDirectory) {
+    resolvedWorkingDirectory = workingDirectory;
+  } else if (config.workingDirectory && config.workingDirectory !== "." && config.workingDirectory.startsWith("/")) {
+    resolvedWorkingDirectory = config.workingDirectory;
+  } else {
+    resolvedWorkingDirectory = process.cwd();
+  }
   const resolvedSkillsDirectories = [
     resolve(configDir, config.skills?.directory || "./skills"),
     // Built-in skills
@@ -584,7 +705,13 @@ function loadConfig(configPath, workingDirectory) {
       return false;
     }
   });
-  const resolvedDatabasePath = resolve(configDir, config.databasePath || "./sparkecoder.db");
+  let resolvedDatabasePath;
+  if (config.databasePath && config.databasePath !== "./sparkecoder.db") {
+    resolvedDatabasePath = resolve(configDir, config.databasePath);
+  } else {
+    const appDataDir = ensureAppDataDirectory();
+    resolvedDatabasePath = join(appDataDir, "sparkecoder.db");
+  }
   const resolved = {
     ...config,
     server: {
@@ -618,12 +745,104 @@ function requiresApproval(toolName, sessionConfig) {
   }
   return false;
 }
+var API_KEYS_FILE = "api-keys.json";
+var PROVIDER_ENV_MAP = {
+  anthropic: "ANTHROPIC_API_KEY",
+  openai: "OPENAI_API_KEY",
+  google: "GOOGLE_GENERATIVE_AI_API_KEY",
+  xai: "XAI_API_KEY",
+  "ai-gateway": "AI_GATEWAY_API_KEY"
+};
+var SUPPORTED_PROVIDERS = Object.keys(PROVIDER_ENV_MAP);
+function getApiKeysPath() {
+  const appDir = ensureAppDataDirectory();
+  return join(appDir, API_KEYS_FILE);
+}
+function loadStoredApiKeys() {
+  const keysPath = getApiKeysPath();
+  if (!existsSync(keysPath)) {
+    return {};
+  }
+  try {
+    const content = readFileSync(keysPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+function saveStoredApiKeys(keys) {
+  const keysPath = getApiKeysPath();
+  writeFileSync(keysPath, JSON.stringify(keys, null, 2), { mode: 384 });
+}
+function loadApiKeysIntoEnv() {
+  const storedKeys = loadStoredApiKeys();
+  for (const [provider, envVar] of Object.entries(PROVIDER_ENV_MAP)) {
+    if (!process.env[envVar] && storedKeys[provider]) {
+      process.env[envVar] = storedKeys[provider];
+    }
+  }
+}
+function setApiKey(provider, apiKey) {
+  const normalizedProvider = provider.toLowerCase();
+  const envVar = PROVIDER_ENV_MAP[normalizedProvider];
+  if (!envVar) {
+    throw new Error(`Unknown provider: ${provider}. Supported: ${SUPPORTED_PROVIDERS.join(", ")}`);
+  }
+  const storedKeys = loadStoredApiKeys();
+  storedKeys[normalizedProvider] = apiKey;
+  saveStoredApiKeys(storedKeys);
+  process.env[envVar] = apiKey;
+}
+function removeApiKey(provider) {
+  const normalizedProvider = provider.toLowerCase();
+  const envVar = PROVIDER_ENV_MAP[normalizedProvider];
+  if (!envVar) {
+    throw new Error(`Unknown provider: ${provider}. Supported: ${SUPPORTED_PROVIDERS.join(", ")}`);
+  }
+  const storedKeys = loadStoredApiKeys();
+  delete storedKeys[normalizedProvider];
+  saveStoredApiKeys(storedKeys);
+}
+function getApiKeyStatus() {
+  const storedKeys = loadStoredApiKeys();
+  return SUPPORTED_PROVIDERS.map((provider) => {
+    const envVar = PROVIDER_ENV_MAP[provider];
+    const envValue = process.env[envVar];
+    const storedValue = storedKeys[provider];
+    let source = "none";
+    let value;
+    if (envValue) {
+      if (storedValue && envValue === storedValue) {
+        source = "storage";
+      } else {
+        source = "env";
+      }
+      value = envValue;
+    } else if (storedValue) {
+      source = "storage";
+      value = storedValue;
+    }
+    return {
+      provider,
+      envVar,
+      configured: !!value,
+      source,
+      maskedKey: value ? maskApiKey(value) : null
+    };
+  });
+}
+function maskApiKey(key) {
+  if (key.length <= 12) {
+    return "****" + key.slice(-4);
+  }
+  return key.slice(0, 4) + "..." + key.slice(-4);
+}
 
 // src/tools/bash.ts
 import { tool } from "ai";
 import { z as z2 } 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;
@@ -646,9 +865,302 @@ function calculateContextSize(messages2) {
   }, 0);
 }
 
-// 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 as existsSync2 } from "fs";
+import { join as join2 } from "path";
+import { nanoid as nanoid2 } 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;
+    console.log(`[tmux] Available: ${stdout.trim()}`);
+    return true;
+  } catch (error) {
+    tmuxAvailableCache = false;
+    console.log(`[tmux] Not available: ${error instanceof Error ? error.message : "unknown error"}`);
+    return false;
+  }
+}
+function generateTerminalId() {
+  return "t" + nanoid2(9);
+}
+function getSessionName(terminalId) {
+  return `${SESSION_PREFIX}${terminalId}`;
+}
+function getLogDir(terminalId, workingDirectory, sessionId) {
+  if (sessionId) {
+    return join2(workingDirectory, LOG_BASE_DIR, sessionId, "terminals", terminalId);
+  }
+  return join2(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(join2(logDir, "meta.json"), JSON.stringify(meta, null, 2));
+  await writeFile(join2(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 = join2(logDir, "output.log");
+  const exitCodeFile = join2(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 (existsSync2(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 = join2(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 = join2(logDir, "output.log");
+  let isRunning2 = false;
+  try {
+    await execAsync(`tmux has-session -t ${session}`, { timeout: 5e3 });
+    isRunning2 = true;
+  } catch {
+  }
+  if (isRunning2) {
+    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: isRunning2 ? "running" : "stopped" };
+  } catch {
+    return { output: "", status: "unknown" };
+  }
+}
+async function isRunning(terminalId) {
+  const session = getSessionName(terminalId);
+  try {
+    await execAsync(`tmux has-session -t ${session}`, { timeout: 5e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+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 listSessions() {
+  try {
+    const { stdout } = await execAsync(
+      `tmux list-sessions -F '#{session_name}' 2>/dev/null || true`,
+      { timeout: 5e3 }
+    );
+    return stdout.trim().split("\n").filter((name) => name.startsWith(SESSION_PREFIX)).map((name) => name.slice(SESSION_PREFIX.length));
+  } catch {
+    return [];
+  }
+}
+async function getMeta(terminalId, workingDirectory, sessionId) {
+  const logDir = getLogDir(terminalId, workingDirectory, sessionId);
+  const metaFile = join2(logDir, "meta.json");
+  try {
+    const content = await readFile(metaFile, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function listSessionTerminals(sessionId, workingDirectory) {
+  const terminalsDir = join2(workingDirectory, LOG_BASE_DIR, sessionId, "terminals");
+  const terminals3 = [];
+  try {
+    const { readdir: readdir2 } = await import("fs/promises");
+    const entries = await readdir2(terminalsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const meta = await getMeta(entry.name, workingDirectory, sessionId);
+        if (meta) {
+          terminals3.push(meta);
+        }
+      }
+    }
+  } catch {
+  }
+  return terminals3;
+}
+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 /",
@@ -664,67 +1176,227 @@ function isBlockedCommand(command) {
     (blocked) => normalizedCommand.includes(blocked.toLowerCase())
   );
 }
-var bashInputSchema = z2.object({
-  command: z2.string().describe("The bash command to execute. Can be a single command or a pipeline.")
-});
+var bashInputSchema = z2.object({
+  command: z2.string().optional().describe("The command to execute. Required for running new commands."),
+  background: z2.boolean().default(false).describe("Run the command in background mode (for dev servers, watchers). Returns immediately with terminal ID."),
+  id: z2.string().optional().describe("Terminal ID. Use to get logs from, send input to, or kill an existing terminal."),
+  kill: z2.boolean().optional().describe("Kill the terminal with the given ID."),
+  tail: z2.number().optional().describe("Number of lines to return from the end of output (for logs)."),
+  input: z2.string().optional().describe("Send text input to an interactive terminal (requires id). Used for responding to prompts."),
+  key: z2.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
         };
       }
     }
@@ -734,9 +1406,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 z3 } from "zod";
-import { readFile, stat } from "fs/promises";
+import { readFile as readFile2, stat } from "fs/promises";
 import { resolve as resolve2, relative, isAbsolute } from "path";
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync3 } from "fs";
 var MAX_FILE_SIZE = 5 * 1024 * 1024;
 var MAX_OUTPUT_CHARS3 = 5e4;
 var readFileInputSchema = z3.object({
@@ -761,7 +1433,7 @@ Use this to understand existing code, check file contents, or gather context.`,
             content: null
           };
         }
-        if (!existsSync2(absolutePath)) {
+        if (!existsSync3(absolutePath)) {
           return {
             success: false,
             error: `File not found: ${path}`,
@@ -783,7 +1455,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;
@@ -831,9 +1503,9 @@ 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 readFile2, writeFile, mkdir } from "fs/promises";
+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 { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 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'),
@@ -878,11 +1550,11 @@ Working directory: ${options.workingDirectory}`,
             };
           }
           const dir = dirname2(absolutePath);
-          if (!existsSync3(dir)) {
-            await mkdir(dir, { recursive: true });
+          if (!existsSync4(dir)) {
+            await mkdir2(dir, { recursive: true });
           }
-          const existed = existsSync3(absolutePath);
-          await writeFile(absolutePath, content, "utf-8");
+          const existed = existsSync4(absolutePath);
+          await writeFile2(absolutePath, content, "utf-8");
           return {
             success: true,
             path: absolutePath,
@@ -899,13 +1571,13 @@ Working directory: ${options.workingDirectory}`,
               error: 'Both old_string and new_string are required for "str_replace" mode'
             };
           }
-          if (!existsSync3(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");
+          const currentContent = await readFile3(absolutePath, "utf-8");
           if (!currentContent.includes(old_string)) {
             const lines = currentContent.split("\n");
             const preview = lines.slice(0, 20).join("\n");
@@ -926,7 +1598,7 @@ Working directory: ${options.workingDirectory}`,
             };
           }
           const newContent = currentContent.replace(old_string, new_string);
-          await writeFile(absolutePath, newContent, "utf-8");
+          await writeFile2(absolutePath, newContent, "utf-8");
           const oldLines = old_string.split("\n").length;
           const newLines = new_string.split("\n").length;
           return {
@@ -954,6 +1626,7 @@ 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({
@@ -1083,9 +1756,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 { readFile as readFile4, readdir } from "fs/promises";
 import { resolve as resolve4, basename, extname } from "path";
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 function parseSkillFrontmatter(content) {
   const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
   if (!frontmatterMatch) {
@@ -1116,7 +1789,7 @@ function getSkillNameFromPath(filePath) {
   return basename(filePath, extname(filePath)).replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
 }
 async function loadSkillsFromDirectory(directory) {
-  if (!existsSync4(directory)) {
+  if (!existsSync5(directory)) {
     return [];
   }
   const skills = [];
@@ -1124,7 +1797,7 @@ async function loadSkillsFromDirectory(directory) {
   for (const file of files) {
     if (!file.endsWith(".md")) continue;
     const filePath = resolve4(directory, file);
-    const content = await readFile3(filePath, "utf-8");
+    const content = await readFile4(filePath, "utf-8");
     const parsed = parseSkillFrontmatter(content);
     if (parsed) {
       skills.push({
@@ -1166,7 +1839,7 @@ async function loadSkillContent(skillName, directories) {
   if (!skill) {
     return null;
   }
-  const content = await readFile3(skill.filePath, "utf-8");
+  const content = await readFile4(skill.filePath, "utf-8");
   const parsed = parseSkillFrontmatter(content);
   return {
     ...skill,
@@ -1185,533 +1858,94 @@ 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')
-});
-function createLoadSkillTool(options) {
-  return tool5({
-    description: `Load a skill document into the conversation context. Skills are specialized knowledge files that provide guidance on specific topics like debugging, code review, architecture patterns, etc.
-
-Available actions:
-- "list": Show all available skills with their descriptions
-- "load": Load a specific skill's full content into context
-
-Use this when you need specialized knowledge or guidance for a particular task.
-Once loaded, a skill's content will be available in the conversation context.`,
-    inputSchema: loadSkillInputSchema,
-    execute: async ({ action, skillName }) => {
-      try {
-        switch (action) {
-          case "list": {
-            const skills = await loadAllSkills(options.skillsDirectories);
-            return {
-              success: true,
-              action: "list",
-              skillCount: skills.length,
-              skills: skills.map((s) => ({
-                name: s.name,
-                description: s.description
-              })),
-              formatted: formatSkillsForContext(skills)
-            };
-          }
-          case "load": {
-            if (!skillName) {
-              return {
-                success: false,
-                error: 'skillName is required for "load" action'
-              };
-            }
-            if (skillQueries.isLoaded(options.sessionId, skillName)) {
-              return {
-                success: false,
-                error: `Skill "${skillName}" is already loaded in this session`
-              };
-            }
-            const skill = await loadSkillContent(skillName, options.skillsDirectories);
-            if (!skill) {
-              const allSkills = await loadAllSkills(options.skillsDirectories);
-              return {
-                success: false,
-                error: `Skill "${skillName}" not found`,
-                availableSkills: allSkills.map((s) => s.name)
-              };
-            }
-            skillQueries.load(options.sessionId, skillName);
-            return {
-              success: true,
-              action: "load",
-              skillName: skill.name,
-              description: skill.description,
-              content: skill.content,
-              contentLength: skill.content.length
-            };
-          }
-          default:
-            return {
-              success: false,
-              error: `Unknown action: ${action}`
-            };
-        }
-      } catch (error) {
-        return {
-          success: false,
-          error: error.message
-        };
-      }
-    }
-  });
-}
-
-// 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 terminals3 = terminalQueries.getBySession(sessionId);
-    return terminals3.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) {
+  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')
+});
+function createLoadSkillTool(options) {
+  return tool5({
+    description: `Load a skill document into the conversation context. Skills are specialized knowledge files that provide guidance on specific topics like debugging, code review, architecture patterns, etc.
+
+Available actions:
+- "list": Show all available skills with their descriptions
+- "load": Load a specific skill's full content into context
+
+Use this when you need specialized knowledge or guidance for a particular task.
+Once loaded, a skill's content will be available in the conversation context.`,
+    inputSchema: loadSkillInputSchema,
+    execute: async ({ action, skillName }) => {
+      try {
+        switch (action) {
+          case "list": {
+            const skills = await loadAllSkills(options.skillsDirectories);
             return {
-              success: false,
-              error: `Terminal not found: ${input.terminalId}`
+              success: true,
+              action: "list",
+              skillCount: skills.length,
+              skills: skills.map((s) => ({
+                name: s.name,
+                description: s.description
+              })),
+              formatted: formatSkillsForContext(skills)
             };
           }
-          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) {
+          case "load": {
+            if (!skillName) {
+              return {
+                success: false,
+                error: 'skillName is required for "load" action'
+              };
+            }
+            if (skillQueries.isLoaded(options.sessionId, skillName)) {
+              return {
+                success: false,
+                error: `Skill "${skillName}" is already loaded in this session`
+              };
+            }
+            const skill = await loadSkillContent(skillName, options.skillsDirectories);
+            if (!skill) {
+              const allSkills = await loadAllSkills(options.skillsDirectories);
+              return {
+                success: false,
+                error: `Skill "${skillName}" not found`,
+                availableSkills: allSkills.map((s) => s.name)
+              };
+            }
+            skillQueries.load(options.sessionId, skillName);
             return {
-              success: false,
-              error: `Failed to kill terminal: ${input.terminalId}`
+              success: true,
+              action: "load",
+              skillName: skill.name,
+              description: skill.description,
+              content: skill.content,
+              contentLength: skill.content.length
             };
           }
-          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) {
+          default:
             return {
               success: false,
-              error: `Failed to write to terminal: ${input.terminalId}`
+              error: `Unknown action: ${action}`
             };
-          }
-          return {
-            success: true,
-            message: `Sent input to terminal ${input.terminalId}`
-          };
-        }
-        case "list": {
-          const terminals3 = manager.list(sessionId);
-          return {
-            success: true,
-            terminals: terminals3.map(formatTerminal),
-            count: terminals3.length,
-            running: terminals3.filter((t) => t.status === "running").length
-          };
         }
-        default:
-          return { success: false, error: `Unknown action: ${input.action}` };
+      } catch (error) {
+        return {
+          success: false,
+          error: error.message
+        };
       }
     }
   });
 }
-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
@@ -1725,38 +1959,110 @@ function createTools(options) {
     load_skill: createLoadSkillTool({
       sessionId: options.sessionId,
       skillsDirectories: options.skillsDirectories
-    }),
-    terminal: createTerminalTool({
-      sessionId: options.sessionId,
-      workingDirectory: options.workingDirectory
     })
   };
 }
 
 // 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
+- **Avoid unbounded searches** - always scope searches with glob patterns and directory paths to prevent overwhelming output
+- **Search strategically**: Start with specific patterns and directories, then broaden only if needed`;
+  if (platform3 === "win32") {
+    return `${common}
+- **Find files**: \`dir /s /b *.ts\` or PowerShell: \`Get-ChildItem -Recurse -Filter *.ts\`
+- **Search content**: \`findstr /s /n "pattern" *.ts\` or PowerShell: \`Select-String -Pattern "pattern" -Path *.ts -Recurse\`
+- **If ripgrep (\`rg\`) is installed**: \`rg "pattern" -t ts src/\` - faster and respects .gitignore`;
+  }
+  return `${common}
+- **Find files**: \`find . -name "*.ts"\` or \`find src/ -type f -name "*.tsx"\`
+- **Search content**: \`grep -rn "pattern" --include="*.ts" src/\` - use \`-l\` for filenames only, \`-c\` for counts
+- **If ripgrep (\`rg\`) is installed**: \`rg "pattern" -t ts src/\` - faster and respects .gitignore`;
+}
 async function buildSystemPrompt(options) {
   const { workingDirectory, skillsDirectories, sessionId, customInstructions } = options;
   const skills = await loadAllSkills(skillsDirectories);
   const skillsContext = formatSkillsForContext(skills);
   const todos = todoQueries.getBySession(sessionId);
   const todosContext = formatTodosForContext(todos);
-  const systemPrompt = `You are Sparkecoder, an expert AI coding assistant. You help developers write, debug, and improve code.
+  const platform3 = process.platform === "win32" ? "Windows" : process.platform === "darwin" ? "macOS" : "Linux";
+  const currentDate = (/* @__PURE__ */ new Date()).toLocaleDateString("en-US", { weekday: "long", year: "numeric", month: "long", day: "numeric" });
+  const searchInstructions = getSearchInstructions();
+  const systemPrompt = `You are SparkECoder, an expert AI coding assistant. You help developers write, debug, and improve code.
 
-## Working Directory
-You are working in: ${workingDirectory}
+## Environment
+- **Platform**: ${platform3} (${os.release()})
+- **Date**: ${currentDate}
+- **Working Directory**: ${workingDirectory}
 
 ## Core Capabilities
 You have access to powerful tools for:
-- **bash**: Execute shell commands, run scripts, install packages, use git
+- **bash**: Execute commands in the terminal (see below for details)
 - **read_file**: Read file contents to understand code and context
 - **write_file**: Create new files or edit existing ones (supports targeted string replacement)
 - **todo**: Manage your task list to track progress on complex operations
 - **load_skill**: Load specialized knowledge documents for specific tasks
 
+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.
+
+### bash Tool
+The bash tool runs 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):**
+\`\`\`
+bash({ command: "npm run dev", background: true })
+\u2192 Returns { id: "abc123" } - save this ID to check logs or stop it later
+\`\`\`
+
+**Check on a background process:**
+\`\`\`
+bash({ id: "abc123" })              // get full output
+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 - Handling Interactive Commands:**
+- ALWAYS prefer non-interactive flags when available:
+  - \`npm init --yes\` or \`npm install --yes\`
+  - \`npx create-next-app --yes\` (accepts all defaults)
+  - \`npx create-react-app --yes\`
+  - \`git commit --no-edit\`
+  - \`apt-get install -y\`
+- If a command might prompt for input, run it in background mode first
+- Check the output to see if it's waiting for input
+- Use \`key: "y"\` or \`key: "n"\` for yes/no prompts
+- Use \`input: "text"\` for text input prompts
+
+Logs are saved to \`.sparkecoder/terminals/{id}/output.log\` and can be read with \`read_file\` if needed.
+
 ## Guidelines
 
 ### Code Quality
@@ -1777,6 +2083,30 @@ You have access to powerful tools for:
 - Use \`write_file\` with mode "full" only for new files or complete rewrites
 - Always verify changes by reading files after modifications
 
+### Searching and Exploration
+${searchInstructions}
+
+Follow these principles when designing and implementing software:
+
+1. **Modularity** \u2014 Write simple parts connected by clean interfaces
+2. **Clarity** \u2014 Clarity is better than cleverness
+3. **Composition** \u2014 Design programs to be connected to other programs
+4. **Separation** \u2014 Separate policy from mechanism; separate interfaces from engines
+5. **Simplicity** \u2014 Design for simplicity; add complexity only where you must
+6. **Parsimony** \u2014 Write a big program only when it is clear by demonstration that nothing else will do
+7. **Transparency** \u2014 Design for visibility to make inspection and debugging easier
+8. **Robustness** \u2014 Robustness is the child of transparency and simplicity
+9. **Representation** \u2014 Fold knowledge into data so program logic can be stupid and robust
+10. **Least Surprise** \u2014 In interface design, always do the least surprising thing
+11. **Silence** \u2014 When a program has nothing surprising to say, it should say nothing
+12. **Repair** \u2014 When you must fail, fail noisily and as soon as possible
+13. **Economy** \u2014 Programmer time is expensive; conserve it in preference to machine time
+14. **Generation** \u2014 Avoid hand-hacking; write programs to write programs when you can
+15. **Optimization** \u2014 Prototype before polishing. Get it working before you optimize it
+16. **Diversity** \u2014 Distrust all claims for "one true way"
+17. **Extensibility** \u2014 Design for the future, because it will be here sooner than you think
+
+
 ### Communication
 - Explain your reasoning and approach
 - Be concise but thorough
@@ -1933,12 +2263,24 @@ var approvalResolvers = /* @__PURE__ */ new Map();
 var Agent = class _Agent {
   session;
   context;
-  tools;
+  baseTools;
   pendingApprovals = /* @__PURE__ */ new Map();
   constructor(session, context, tools) {
     this.session = session;
     this.context = context;
-    this.tools = tools;
+    this.baseTools = tools;
+  }
+  /**
+   * Create tools with optional progress callbacks
+   */
+  createToolsWithCallbacks(options) {
+    const config = getConfig();
+    return createTools({
+      sessionId: this.session.id,
+      workingDirectory: this.session.workingDirectory,
+      skillsDirectories: config.resolvedSkillsDirectories,
+      onBashProgress: options.onToolProgress ? (progress) => options.onToolProgress({ toolName: "bash", data: progress }) : void 0
+    });
   }
   /**
    * Create or resume an agent session
@@ -1990,7 +2332,9 @@ var Agent = class _Agent {
    */
   async stream(options) {
     const config = getConfig();
-    this.context.addUserMessage(options.prompt);
+    if (!options.skipSaveUserMessage) {
+      this.context.addUserMessage(options.prompt);
+    }
     sessionQueries.updateStatus(this.session.id, "active");
     const systemPrompt = await buildSystemPrompt({
       workingDirectory: this.session.workingDirectory,
@@ -1998,15 +2342,30 @@ var Agent = class _Agent {
       sessionId: this.session.id
     });
     const messages2 = await this.context.getMessages();
-    const wrappedTools = this.wrapToolsWithApproval(options);
+    const tools = options.onToolProgress ? this.createToolsWithCallbacks({ onToolProgress: options.onToolProgress }) : this.baseTools;
+    const wrappedTools = this.wrapToolsWithApproval(options, tools);
     const stream = streamText({
       model: gateway2(this.session.model),
       system: systemPrompt,
       messages: messages2,
       tools: wrappedTools,
-      stopWhen: stepCountIs(20),
+      stopWhen: stepCountIs(500),
+      // Forward abort signal if provided
+      abortSignal: options.abortSignal,
+      // Enable extended thinking/reasoning for models that support it
+      providerOptions: {
+        anthropic: {
+          thinking: {
+            type: "enabled",
+            budgetTokens: 1e4
+          }
+        }
+      },
       onStepFinish: async (step) => {
         options.onStepFinish?.(step);
+      },
+      onAbort: ({ steps }) => {
+        options.onAbort?.({ steps });
       }
     });
     const saveResponseMessages = async () => {
@@ -2034,13 +2393,23 @@ var Agent = class _Agent {
       sessionId: this.session.id
     });
     const messages2 = await this.context.getMessages();
-    const wrappedTools = this.wrapToolsWithApproval(options);
+    const tools = options.onToolProgress ? this.createToolsWithCallbacks({ onToolProgress: options.onToolProgress }) : this.baseTools;
+    const wrappedTools = this.wrapToolsWithApproval(options, tools);
     const result = await generateText2({
       model: gateway2(this.session.model),
       system: systemPrompt,
       messages: messages2,
       tools: wrappedTools,
-      stopWhen: stepCountIs(20)
+      stopWhen: stepCountIs(500),
+      // Enable extended thinking/reasoning for models that support it
+      providerOptions: {
+        anthropic: {
+          thinking: {
+            type: "enabled",
+            budgetTokens: 1e4
+          }
+        }
+      }
     });
     const responseMessages = result.response.messages;
     this.context.addResponseMessages(responseMessages);
@@ -2052,20 +2421,21 @@ var Agent = class _Agent {
   /**
    * Wrap tools to add approval checking
    */
-  wrapToolsWithApproval(options) {
+  wrapToolsWithApproval(options, tools) {
     const sessionConfig = this.session.config;
     const wrappedTools = {};
-    for (const [name, originalTool] of Object.entries(this.tools)) {
+    const toolsToWrap = tools || this.baseTools;
+    for (const [name, originalTool] of Object.entries(toolsToWrap)) {
       const needsApproval = requiresApproval(name, sessionConfig ?? void 0);
       if (!needsApproval) {
         wrappedTools[name] = originalTool;
         continue;
       }
-      wrappedTools[name] = tool7({
+      wrappedTools[name] = tool6({
         description: originalTool.description || "",
-        inputSchema: originalTool.inputSchema || z8.object({}),
+        inputSchema: originalTool.inputSchema || z7.object({}),
         execute: async (input, toolOptions) => {
-          const toolCallId = toolOptions.toolCallId || nanoid2();
+          const toolCallId = toolOptions.toolCallId || nanoid3();
           const execution = toolExecutionQueries.create({
             sessionId: this.session.id,
             toolName: name,
@@ -2077,8 +2447,8 @@ var Agent = class _Agent {
           this.pendingApprovals.set(toolCallId, execution);
           options.onApprovalRequired?.(execution);
           sessionQueries.updateStatus(this.session.id, "waiting");
-          const approved = await new Promise((resolve5) => {
-            approvalResolvers.set(toolCallId, { resolve: resolve5, sessionId: this.session.id });
+          const approved = await new Promise((resolve6) => {
+            approvalResolvers.set(toolCallId, { resolve: resolve6, sessionId: this.session.id });
           });
           const resolverData = approvalResolvers.get(toolCallId);
           approvalResolvers.delete(toolCallId);
@@ -2173,18 +2543,18 @@ var Agent = class _Agent {
 
 // src/server/routes/sessions.ts
 var sessions2 = new Hono();
-var createSessionSchema = z9.object({
-  name: z9.string().optional(),
-  workingDirectory: z9.string().optional(),
-  model: z9.string().optional(),
-  toolApprovals: z9.record(z9.string(), z9.boolean()).optional()
+var createSessionSchema = z8.object({
+  name: z8.string().optional(),
+  workingDirectory: z8.string().optional(),
+  model: z8.string().optional(),
+  toolApprovals: z8.record(z8.string(), z8.boolean()).optional()
 });
-var paginationQuerySchema = z9.object({
-  limit: z9.string().optional(),
-  offset: z9.string().optional()
+var paginationQuerySchema = z8.object({
+  limit: z8.string().optional(),
+  offset: z8.string().optional()
 });
-var messagesQuerySchema = z9.object({
-  limit: z9.string().optional()
+var messagesQuerySchema = z8.object({
+  limit: z8.string().optional()
 });
 sessions2.get(
   "/",
@@ -2194,16 +2564,22 @@ sessions2.get(
     const limit = parseInt(query.limit || "50");
     const offset = parseInt(query.offset || "0");
     const allSessions = sessionQueries.list(limit, offset);
-    return c.json({
-      sessions: allSessions.map((s) => ({
+    const sessionsWithStreamInfo = allSessions.map((s) => {
+      const activeStream = activeStreamQueries.getBySessionId(s.id);
+      return {
         id: s.id,
         name: s.name,
         workingDirectory: s.workingDirectory,
         model: s.model,
         status: s.status,
+        config: s.config,
+        isStreaming: !!activeStream,
         createdAt: s.createdAt.toISOString(),
         updatedAt: s.updatedAt.toISOString()
-      })),
+      };
+    });
+    return c.json({
+      sessions: sessionsWithStreamInfo,
       count: allSessions.length,
       limit,
       offset
@@ -2317,11 +2693,60 @@ sessions2.get("/:id/tools", async (c) => {
     count: executions.length
   });
 });
+var updateSessionSchema = z8.object({
+  model: z8.string().optional(),
+  name: z8.string().optional(),
+  toolApprovals: z8.record(z8.string(), z8.boolean()).optional()
+});
+sessions2.patch(
+  "/:id",
+  zValidator("json", updateSessionSchema),
+  async (c) => {
+    const id = c.req.param("id");
+    const body = c.req.valid("json");
+    const session = sessionQueries.getById(id);
+    if (!session) {
+      return c.json({ error: "Session not found" }, 404);
+    }
+    const updates = {};
+    if (body.model) updates.model = body.model;
+    if (body.name !== void 0) updates.name = body.name;
+    if (body.toolApprovals !== void 0) {
+      const existingConfig = session.config || {};
+      const existingToolApprovals = existingConfig.toolApprovals || {};
+      updates.config = {
+        ...existingConfig,
+        toolApprovals: {
+          ...existingToolApprovals,
+          ...body.toolApprovals
+        }
+      };
+    }
+    const updatedSession = Object.keys(updates).length > 0 ? sessionQueries.update(id, updates) || session : session;
+    return c.json({
+      id: updatedSession.id,
+      name: updatedSession.name,
+      model: updatedSession.model,
+      status: updatedSession.status,
+      workingDirectory: updatedSession.workingDirectory,
+      config: updatedSession.config,
+      updatedAt: updatedSession.updatedAt.toISOString()
+    });
+  }
+);
 sessions2.delete("/:id", async (c) => {
   const id = c.req.param("id");
   try {
-    const manager = getTerminalManager();
-    manager.killAll(id);
+    const session = sessionQueries.getById(id);
+    if (session) {
+      const terminalIds = await listSessions();
+      for (const tid of terminalIds) {
+        const meta = await getMeta(tid, session.workingDirectory);
+        if (meta && meta.sessionId === id) {
+          await killTerminal(tid);
+        }
+      }
+    }
   } catch (e) {
   }
   const deleted = sessionQueries.delete(id);
@@ -2340,160 +2765,396 @@ sessions2.post("/:id/clear", async (c) => {
   agent.clearContext();
   return c.json({ success: true, sessionId: id });
 });
+sessions2.get("/:id/todos", async (c) => {
+  const id = c.req.param("id");
+  const session = sessionQueries.getById(id);
+  if (!session) {
+    return c.json({ error: "Session not found" }, 404);
+  }
+  const todos = todoQueries.getBySession(id);
+  const pending = todos.filter((t) => t.status === "pending");
+  const inProgress = todos.filter((t) => t.status === "in_progress");
+  const completed = todos.filter((t) => t.status === "completed");
+  const cancelled = todos.filter((t) => t.status === "cancelled");
+  const nextTodo = inProgress[0] || pending[0] || null;
+  return c.json({
+    todos: todos.map((t) => ({
+      id: t.id,
+      content: t.content,
+      status: t.status,
+      order: t.order,
+      createdAt: t.createdAt.toISOString(),
+      updatedAt: t.updatedAt.toISOString()
+    })),
+    stats: {
+      total: todos.length,
+      pending: pending.length,
+      inProgress: inProgress.length,
+      completed: completed.length,
+      cancelled: cancelled.length
+    },
+    nextTodo: nextTodo ? {
+      id: nextTodo.id,
+      content: nextTodo.content,
+      status: nextTodo.status
+    } : null
+  });
+});
 
 // src/server/routes/agents.ts
+init_db();
 import { Hono as Hono2 } from "hono";
 import { zValidator as zValidator2 } from "@hono/zod-validator";
-import { streamSSE } from "hono/streaming";
-import { z as z10 } from "zod";
+import { z as z9 } from "zod";
+
+// src/server/resumable-stream.ts
+import { createResumableStreamContext } from "resumable-stream/generic";
+var store = /* @__PURE__ */ new Map();
+var channels = /* @__PURE__ */ new Map();
+var cleanupInterval = setInterval(() => {
+  const now = Date.now();
+  for (const [key, data] of store.entries()) {
+    if (data.expiresAt && data.expiresAt < now) {
+      store.delete(key);
+    }
+  }
+}, 6e4);
+cleanupInterval.unref();
+var publisher = {
+  connect: async () => {
+  },
+  publish: async (channel, message) => {
+    const subscribers = channels.get(channel);
+    if (subscribers) {
+      for (const callback of subscribers) {
+        setImmediate(() => callback(message));
+      }
+    }
+  },
+  set: async (key, value, options) => {
+    const expiresAt = options?.EX ? Date.now() + options.EX * 1e3 : void 0;
+    store.set(key, { value, expiresAt });
+    if (options?.EX) {
+      setTimeout(() => store.delete(key), options.EX * 1e3);
+    }
+  },
+  get: async (key) => {
+    const data = store.get(key);
+    if (!data) return null;
+    if (data.expiresAt && data.expiresAt < Date.now()) {
+      store.delete(key);
+      return null;
+    }
+    return data.value;
+  },
+  incr: async (key) => {
+    const data = store.get(key);
+    const current = data ? parseInt(data.value, 10) : 0;
+    const next = (isNaN(current) ? 0 : current) + 1;
+    store.set(key, { value: String(next), expiresAt: data?.expiresAt });
+    return next;
+  }
+};
+var subscriber = {
+  connect: async () => {
+  },
+  subscribe: async (channel, callback) => {
+    if (!channels.has(channel)) {
+      channels.set(channel, /* @__PURE__ */ new Set());
+    }
+    channels.get(channel).add(callback);
+  },
+  unsubscribe: async (channel) => {
+    channels.delete(channel);
+  }
+};
+var streamContext = createResumableStreamContext({
+  // Background task handler - just let promises run and log errors
+  waitUntil: (promise) => {
+    promise.catch((err) => {
+      console.error("[ResumableStream] Background task error:", err);
+    });
+  },
+  publisher,
+  subscriber
+});
+
+// src/server/routes/agents.ts
+import { nanoid as nanoid4 } from "nanoid";
 var agents = new Hono2();
-var runPromptSchema = z10.object({
-  prompt: z10.string().min(1)
+var runPromptSchema = z9.object({
+  prompt: z9.string().min(1)
 });
-var quickStartSchema = z10.object({
-  prompt: z10.string().min(1),
-  name: z10.string().optional(),
-  workingDirectory: z10.string().optional(),
-  model: z10.string().optional(),
-  toolApprovals: z10.record(z10.string(), z10.boolean()).optional()
+var quickStartSchema = z9.object({
+  prompt: z9.string().min(1),
+  name: z9.string().optional(),
+  workingDirectory: z9.string().optional(),
+  model: z9.string().optional(),
+  toolApprovals: z9.record(z9.string(), z9.boolean()).optional()
 });
-var rejectSchema = z10.object({
-  reason: z10.string().optional()
+var rejectSchema = z9.object({
+  reason: z9.string().optional()
 }).optional();
-agents.post(
-  "/:id/run",
-  zValidator2("json", runPromptSchema),
-  async (c) => {
-    const id = c.req.param("id");
-    const { prompt } = c.req.valid("json");
-    const session = sessionQueries.getById(id);
-    if (!session) {
-      return c.json({ error: "Session not found" }, 404);
-    }
-    c.header("Content-Type", "text/event-stream");
-    c.header("Cache-Control", "no-cache");
-    c.header("Connection", "keep-alive");
-    c.header("x-vercel-ai-ui-message-stream", "v1");
-    return streamSSE(c, async (stream) => {
+var streamAbortControllers = /* @__PURE__ */ new Map();
+function createAgentStreamProducer(sessionId, prompt, streamId) {
+  return () => {
+    const { readable, writable } = new TransformStream();
+    const writer = writable.getWriter();
+    let writerClosed = false;
+    const abortController = new AbortController();
+    streamAbortControllers.set(streamId, abortController);
+    const writeSSE = async (data) => {
+      if (writerClosed) return;
+      try {
+        await writer.write(`data: ${data}
+
+`);
+      } catch (err) {
+        writerClosed = true;
+      }
+    };
+    const safeClose = async () => {
+      if (writerClosed) return;
+      try {
+        writerClosed = true;
+        await writer.close();
+      } catch {
+      }
+    };
+    const cleanupAbortController = () => {
+      streamAbortControllers.delete(streamId);
+    };
+    (async () => {
+      let isAborted = false;
       try {
-        const agent = await Agent.create({ sessionId: id });
+        const agent = await Agent.create({ sessionId });
+        await writeSSE(JSON.stringify({ type: "data-stream-id", streamId }));
+        await writeSSE(JSON.stringify({
+          type: "data-user-message",
+          data: { id: `user_${Date.now()}`, content: prompt }
+        }));
         const messageId = `msg_${Date.now()}`;
-        await stream.writeSSE({
-          data: JSON.stringify({ type: "start", messageId })
-        });
+        await writeSSE(JSON.stringify({ type: "start", messageId }));
         let textId = `text_${Date.now()}`;
         let textStarted = false;
         const result = await agent.stream({
           prompt,
-          onToolCall: async (toolCall) => {
-            await stream.writeSSE({
-              data: JSON.stringify({
-                type: "tool-input-start",
-                toolCallId: toolCall.toolCallId,
-                toolName: toolCall.toolName
-              })
-            });
-            await stream.writeSSE({
-              data: JSON.stringify({
-                type: "tool-input-available",
-                toolCallId: toolCall.toolCallId,
-                toolName: toolCall.toolName,
-                input: toolCall.input
-              })
-            });
+          abortSignal: abortController.signal,
+          // Use our managed abort controller, NOT client signal
+          skipSaveUserMessage: true,
+          // User message is saved in the route before streaming
+          // Note: tool-input-start/available events are sent from the stream loop
+          // when we see tool-call-streaming-start and tool-call events.
+          // We only use onToolCall/onToolResult for non-streaming scenarios or
+          // tools that need special handling (like approval requests).
+          onToolCall: async () => {
           },
-          onToolResult: async (result2) => {
-            await stream.writeSSE({
-              data: JSON.stringify({
-                type: "tool-output-available",
-                toolCallId: result2.toolCallId,
-                output: result2.output
-              })
-            });
+          onToolResult: async () => {
           },
           onApprovalRequired: async (execution) => {
-            await stream.writeSSE({
-              data: JSON.stringify({
-                type: "data-approval-required",
-                data: {
-                  id: execution.id,
-                  toolCallId: execution.toolCallId,
-                  toolName: execution.toolName,
-                  input: execution.input
-                }
-              })
-            });
+            await writeSSE(JSON.stringify({
+              type: "data-approval-required",
+              data: {
+                id: execution.id,
+                toolCallId: execution.toolCallId,
+                toolName: execution.toolName,
+                input: execution.input
+              }
+            }));
+          },
+          onToolProgress: async (progress) => {
+            await writeSSE(JSON.stringify({
+              type: "tool-progress",
+              toolName: progress.toolName,
+              data: progress.data
+            }));
           },
           onStepFinish: async () => {
-            await stream.writeSSE({
-              data: JSON.stringify({ type: "finish-step" })
-            });
+            await writeSSE(JSON.stringify({ type: "finish-step" }));
             if (textStarted) {
-              await stream.writeSSE({
-                data: JSON.stringify({ type: "text-end", id: textId })
-              });
+              await writeSSE(JSON.stringify({ type: "text-end", id: textId }));
               textStarted = false;
               textId = `text_${Date.now()}`;
             }
+          },
+          onAbort: async ({ steps }) => {
+            isAborted = true;
+            console.log(`Stream aborted after ${steps.length} steps`);
           }
         });
+        let reasoningId = `reasoning_${Date.now()}`;
+        let reasoningStarted = false;
         for await (const part of result.stream.fullStream) {
           if (part.type === "text-delta") {
             if (!textStarted) {
-              await stream.writeSSE({
-                data: JSON.stringify({ type: "text-start", id: textId })
-              });
+              await writeSSE(JSON.stringify({ type: "text-start", id: textId }));
               textStarted = true;
             }
-            await stream.writeSSE({
-              data: JSON.stringify({ type: "text-delta", id: textId, delta: part.text })
-            });
+            await writeSSE(JSON.stringify({ type: "text-delta", id: textId, delta: part.text }));
+          } else if (part.type === "reasoning-start") {
+            await writeSSE(JSON.stringify({ type: "reasoning-start", id: reasoningId }));
+            reasoningStarted = true;
+          } else if (part.type === "reasoning-delta") {
+            await writeSSE(JSON.stringify({ type: "reasoning-delta", id: reasoningId, delta: part.text }));
+          } else if (part.type === "reasoning-end") {
+            if (reasoningStarted) {
+              await writeSSE(JSON.stringify({ type: "reasoning-end", id: reasoningId }));
+              reasoningStarted = false;
+              reasoningId = `reasoning_${Date.now()}`;
+            }
+          } else if (part.type === "tool-call-streaming-start") {
+            const p = part;
+            await writeSSE(JSON.stringify({
+              type: "tool-input-start",
+              toolCallId: p.toolCallId,
+              toolName: p.toolName
+            }));
+          } else if (part.type === "tool-call-delta") {
+            const p = part;
+            await writeSSE(JSON.stringify({
+              type: "tool-input-delta",
+              toolCallId: p.toolCallId,
+              argsTextDelta: p.argsTextDelta
+            }));
           } else if (part.type === "tool-call") {
-            await stream.writeSSE({
-              data: JSON.stringify({
-                type: "tool-input-available",
-                toolCallId: part.toolCallId,
-                toolName: part.toolName,
-                input: part.input
-              })
-            });
+            await writeSSE(JSON.stringify({
+              type: "tool-input-available",
+              toolCallId: part.toolCallId,
+              toolName: part.toolName,
+              input: part.input
+            }));
           } else if (part.type === "tool-result") {
-            await stream.writeSSE({
-              data: JSON.stringify({
-                type: "tool-output-available",
-                toolCallId: part.toolCallId,
-                output: part.output
-              })
-            });
+            await writeSSE(JSON.stringify({
+              type: "tool-output-available",
+              toolCallId: part.toolCallId,
+              output: part.output
+            }));
           } else if (part.type === "error") {
             console.error("Stream error:", part.error);
-            await stream.writeSSE({
-              data: JSON.stringify({ type: "error", errorText: String(part.error) })
-            });
+            await writeSSE(JSON.stringify({ type: "error", errorText: String(part.error) }));
           }
         }
         if (textStarted) {
-          await stream.writeSSE({
-            data: JSON.stringify({ type: "text-end", id: textId })
-          });
+          await writeSSE(JSON.stringify({ type: "text-end", id: textId }));
         }
-        await result.saveResponseMessages();
-        await stream.writeSSE({
-          data: JSON.stringify({ type: "finish" })
-        });
-        await stream.writeSSE({ data: "[DONE]" });
+        if (reasoningStarted) {
+          await writeSSE(JSON.stringify({ type: "reasoning-end", id: reasoningId }));
+        }
+        if (!isAborted) {
+          await result.saveResponseMessages();
+        }
+        if (isAborted) {
+          await writeSSE(JSON.stringify({ type: "abort" }));
+        } else {
+          await writeSSE(JSON.stringify({ type: "finish" }));
+        }
+        activeStreamQueries.finish(streamId);
       } catch (error) {
-        await stream.writeSSE({
-          data: JSON.stringify({
-            type: "error",
-            errorText: error.message
-          })
-        });
-        await stream.writeSSE({ data: "[DONE]" });
+        if (error.name === "AbortError" || error.message?.includes("aborted")) {
+          await writeSSE(JSON.stringify({ type: "abort" }));
+        } else {
+          console.error("Agent error:", error);
+          await writeSSE(JSON.stringify({ type: "error", errorText: error.message }));
+          activeStreamQueries.markError(streamId);
+        }
+      } finally {
+        cleanupAbortController();
+        await writeSSE("[DONE]");
+        await safeClose();
+      }
+    })();
+    return readable;
+  };
+}
+agents.post(
+  "/:id/run",
+  zValidator2("json", runPromptSchema),
+  async (c) => {
+    const id = c.req.param("id");
+    const { prompt } = c.req.valid("json");
+    const session = sessionQueries.getById(id);
+    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 streamId = `stream_${id}_${nanoid4(10)}`;
+    activeStreamQueries.create(id, streamId);
+    const stream = await streamContext.resumableStream(
+      streamId,
+      createAgentStreamProducer(id, prompt, streamId)
+    );
+    if (!stream) {
+      return c.json({ error: "Failed to create stream" }, 500);
+    }
+    const encodedStream = stream.pipeThrough(new TextEncoderStream());
+    return new Response(encodedStream, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive",
+        "x-vercel-ai-ui-message-stream": "v1",
+        "x-stream-id": streamId
       }
     });
   }
 );
+agents.get("/:id/watch", async (c) => {
+  const sessionId = c.req.param("id");
+  const resumeAt = c.req.query("resumeAt");
+  const explicitStreamId = c.req.query("streamId");
+  const session = sessionQueries.getById(sessionId);
+  if (!session) {
+    return c.json({ error: "Session not found" }, 404);
+  }
+  let streamId = explicitStreamId;
+  if (!streamId) {
+    const activeStream = activeStreamQueries.getBySessionId(sessionId);
+    if (!activeStream) {
+      return c.json({ error: "No active stream for this session", hint: "Start a new run with POST /agents/:id/run" }, 404);
+    }
+    streamId = activeStream.streamId;
+  }
+  const stream = await streamContext.resumeExistingStream(
+    streamId,
+    resumeAt ? parseInt(resumeAt, 10) : void 0
+  );
+  if (!stream) {
+    return c.json({
+      error: "Stream is no longer active",
+      streamId,
+      hint: "The stream may have finished. Check /agents/:id/approvals or start a new run."
+    }, 422);
+  }
+  const encodedStream = stream.pipeThrough(new TextEncoderStream());
+  return new Response(encodedStream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      "Connection": "keep-alive",
+      "x-vercel-ai-ui-message-stream": "v1",
+      "x-stream-id": streamId
+    }
+  });
+});
+agents.get("/:id/stream", async (c) => {
+  const sessionId = c.req.param("id");
+  const session = sessionQueries.getById(sessionId);
+  if (!session) {
+    return c.json({ error: "Session not found" }, 404);
+  }
+  const activeStream = activeStreamQueries.getBySessionId(sessionId);
+  return c.json({
+    sessionId,
+    hasActiveStream: !!activeStream,
+    stream: activeStream ? {
+      id: activeStream.id,
+      streamId: activeStream.streamId,
+      status: activeStream.status,
+      createdAt: activeStream.createdAt.toISOString()
+    } : null
+  });
+});
 agents.post(
   "/:id/generate",
   zValidator2("json", runPromptSchema),
@@ -2579,6 +3240,28 @@ agents.get("/:id/approvals", async (c) => {
     count: pendingApprovals.length
   });
 });
+agents.post("/:id/abort", async (c) => {
+  const sessionId = c.req.param("id");
+  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: "No active stream for this session" }, 404);
+  }
+  const abortController = streamAbortControllers.get(activeStream.streamId);
+  if (abortController) {
+    abortController.abort();
+    streamAbortControllers.delete(activeStream.streamId);
+    return c.json({ success: true, streamId: activeStream.streamId, aborted: true });
+  }
+  return c.json({
+    success: false,
+    streamId: activeStream.streamId,
+    message: "Stream may have already finished or was not found"
+  });
+});
 agents.post(
   "/quick",
   zValidator2("json", quickStartSchema),
@@ -2592,14 +3275,40 @@ agents.post(
       sessionConfig: body.toolApprovals ? { toolApprovals: body.toolApprovals } : void 0
     });
     const session = agent.getSession();
-    c.header("Content-Type", "text/event-stream");
-    c.header("Cache-Control", "no-cache");
-    c.header("Connection", "keep-alive");
-    c.header("x-vercel-ai-ui-message-stream", "v1");
-    return streamSSE(c, async (stream) => {
-      try {
-        await stream.writeSSE({
-          data: JSON.stringify({
+    const streamId = `stream_${session.id}_${nanoid4(10)}`;
+    activeStreamQueries.create(session.id, streamId);
+    const createQuickStreamProducer = () => {
+      const { readable, writable } = new TransformStream();
+      const writer = writable.getWriter();
+      let writerClosed = false;
+      const abortController = new AbortController();
+      streamAbortControllers.set(streamId, abortController);
+      const writeSSE = async (data) => {
+        if (writerClosed) return;
+        try {
+          await writer.write(`data: ${data}
+
+`);
+        } catch (err) {
+          writerClosed = true;
+        }
+      };
+      const safeClose = async () => {
+        if (writerClosed) return;
+        try {
+          writerClosed = true;
+          await writer.close();
+        } catch {
+        }
+      };
+      const cleanupAbortController = () => {
+        streamAbortControllers.delete(streamId);
+      };
+      (async () => {
+        let isAborted = false;
+        try {
+          await writeSSE(JSON.stringify({ type: "data-stream-id", streamId }));
+          await writeSSE(JSON.stringify({
             type: "data-session",
             data: {
               id: session.id,
@@ -2607,63 +3316,134 @@ agents.post(
               workingDirectory: session.workingDirectory,
               model: session.model
             }
-          })
-        });
-        const messageId = `msg_${Date.now()}`;
-        await stream.writeSSE({
-          data: JSON.stringify({ type: "start", messageId })
-        });
-        let textId = `text_${Date.now()}`;
-        let textStarted = false;
-        const result = await agent.stream({
-          prompt: body.prompt,
-          onStepFinish: async () => {
-            await stream.writeSSE({
-              data: JSON.stringify({ type: "finish-step" })
-            });
-            if (textStarted) {
-              await stream.writeSSE({
-                data: JSON.stringify({ type: "text-end", id: textId })
-              });
-              textStarted = false;
-              textId = `text_${Date.now()}`;
+          }));
+          const messageId = `msg_${Date.now()}`;
+          await writeSSE(JSON.stringify({ type: "start", messageId }));
+          let textId = `text_${Date.now()}`;
+          let textStarted = false;
+          const result = await agent.stream({
+            prompt: body.prompt,
+            abortSignal: abortController.signal,
+            // Use our managed abort controller, NOT client signal
+            onToolProgress: async (progress) => {
+              await writeSSE(JSON.stringify({
+                type: "tool-progress",
+                toolName: progress.toolName,
+                data: progress.data
+              }));
+            },
+            onStepFinish: async () => {
+              await writeSSE(JSON.stringify({ type: "finish-step" }));
+              if (textStarted) {
+                await writeSSE(JSON.stringify({ type: "text-end", id: textId }));
+                textStarted = false;
+                textId = `text_${Date.now()}`;
+              }
+            },
+            onAbort: async ({ steps }) => {
+              isAborted = true;
+              console.log(`Stream aborted after ${steps.length} steps`);
             }
-          }
-        });
-        for await (const part of result.stream.fullStream) {
-          if (part.type === "text-delta") {
-            if (!textStarted) {
-              await stream.writeSSE({
-                data: JSON.stringify({ type: "text-start", id: textId })
-              });
-              textStarted = true;
+          });
+          let reasoningId = `reasoning_${Date.now()}`;
+          let reasoningStarted = false;
+          for await (const part of result.stream.fullStream) {
+            if (part.type === "text-delta") {
+              if (!textStarted) {
+                await writeSSE(JSON.stringify({ type: "text-start", id: textId }));
+                textStarted = true;
+              }
+              await writeSSE(JSON.stringify({ type: "text-delta", id: textId, delta: part.text }));
+            } else if (part.type === "reasoning-start") {
+              await writeSSE(JSON.stringify({ type: "reasoning-start", id: reasoningId }));
+              reasoningStarted = true;
+            } else if (part.type === "reasoning-delta") {
+              await writeSSE(JSON.stringify({ type: "reasoning-delta", id: reasoningId, delta: part.text }));
+            } else if (part.type === "reasoning-end") {
+              if (reasoningStarted) {
+                await writeSSE(JSON.stringify({ type: "reasoning-end", id: reasoningId }));
+                reasoningStarted = false;
+                reasoningId = `reasoning_${Date.now()}`;
+              }
+            } else if (part.type === "tool-call-streaming-start") {
+              const p = part;
+              await writeSSE(JSON.stringify({
+                type: "tool-input-start",
+                toolCallId: p.toolCallId,
+                toolName: p.toolName
+              }));
+            } else if (part.type === "tool-call-delta") {
+              const p = part;
+              await writeSSE(JSON.stringify({
+                type: "tool-input-delta",
+                toolCallId: p.toolCallId,
+                argsTextDelta: p.argsTextDelta
+              }));
+            } else if (part.type === "tool-call") {
+              await writeSSE(JSON.stringify({
+                type: "tool-input-available",
+                toolCallId: part.toolCallId,
+                toolName: part.toolName,
+                input: part.input
+              }));
+            } else if (part.type === "tool-result") {
+              await writeSSE(JSON.stringify({
+                type: "tool-output-available",
+                toolCallId: part.toolCallId,
+                output: part.output
+              }));
+            } else if (part.type === "error") {
+              console.error("Stream error:", part.error);
+              await writeSSE(JSON.stringify({ type: "error", errorText: String(part.error) }));
             }
-            await stream.writeSSE({
-              data: JSON.stringify({ type: "text-delta", id: textId, delta: part.text })
-            });
-          } else if (part.type === "error") {
-            console.error("Stream error:", part.error);
-            await stream.writeSSE({
-              data: JSON.stringify({ type: "error", errorText: String(part.error) })
-            });
           }
+          if (textStarted) {
+            await writeSSE(JSON.stringify({ type: "text-end", id: textId }));
+          }
+          if (reasoningStarted) {
+            await writeSSE(JSON.stringify({ type: "reasoning-end", id: reasoningId }));
+          }
+          if (!isAborted) {
+            await result.saveResponseMessages();
+          }
+          if (isAborted) {
+            await writeSSE(JSON.stringify({ type: "abort" }));
+          } else {
+            await writeSSE(JSON.stringify({ type: "finish" }));
+          }
+          activeStreamQueries.finish(streamId);
+        } catch (error) {
+          if (error.name === "AbortError" || error.message?.includes("aborted")) {
+            await writeSSE(JSON.stringify({ type: "abort" }));
+          } else {
+            console.error("Agent error:", error);
+            await writeSSE(JSON.stringify({ type: "error", errorText: error.message }));
+            activeStreamQueries.markError(streamId);
+          }
+        } finally {
+          cleanupAbortController();
+          await writeSSE("[DONE]");
+          await safeClose();
         }
-        if (textStarted) {
-          await stream.writeSSE({
-            data: JSON.stringify({ type: "text-end", id: textId })
-          });
-        }
-        await result.saveResponseMessages();
-        await stream.writeSSE({
-          data: JSON.stringify({ type: "finish" })
-        });
-        await stream.writeSSE({ data: "[DONE]" });
-      } catch (error) {
-        console.error("Agent error:", error);
-        await stream.writeSSE({
-          data: JSON.stringify({ type: "error", errorText: error.message })
-        });
-        await stream.writeSSE({ data: "[DONE]" });
+      })();
+      return readable;
+    };
+    const stream = await streamContext.resumableStream(
+      streamId,
+      createQuickStreamProducer
+    );
+    if (!stream) {
+      return c.json({ error: "Failed to create stream" }, 500);
+    }
+    const encodedStream = stream.pipeThrough(new TextEncoderStream());
+    return new Response(encodedStream, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive",
+        "x-vercel-ai-ui-message-stream": "v1",
+        "x-stream-id": streamId,
+        "x-session-id": session.id
       }
     });
   }
@@ -2671,6 +3451,8 @@ agents.post(
 
 // src/server/routes/health.ts
 import { Hono as Hono3 } from "hono";
+import { zValidator as zValidator3 } from "@hono/zod-validator";
+import { z as z10 } from "zod";
 var health = new Hono3();
 health.get("/", async (c) => {
   const config = getConfig();
@@ -2681,6 +3463,7 @@ health.get("/", async (c) => {
     config: {
       workingDirectory: config.resolvedWorkingDirectory,
       defaultModel: config.defaultModel,
+      defaultToolApprovals: config.toolApprovals || {},
       port: config.server.port
     },
     timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -2704,11 +3487,56 @@ health.get("/ready", async (c) => {
     );
   }
 });
+health.get("/api-keys", async (c) => {
+  const status = getApiKeyStatus();
+  return c.json({
+    providers: status,
+    supportedProviders: SUPPORTED_PROVIDERS
+  });
+});
+var setApiKeySchema = z10.object({
+  provider: z10.string(),
+  apiKey: z10.string().min(1)
+});
+health.post(
+  "/api-keys",
+  zValidator3("json", setApiKeySchema),
+  async (c) => {
+    const { provider, apiKey } = c.req.valid("json");
+    try {
+      setApiKey(provider, apiKey);
+      const status = getApiKeyStatus();
+      const providerStatus = status.find((s) => s.provider === provider.toLowerCase());
+      return c.json({
+        success: true,
+        provider: provider.toLowerCase(),
+        maskedKey: providerStatus?.maskedKey,
+        message: `API key for ${provider} saved successfully`
+      });
+    } catch (error) {
+      return c.json({ error: error.message }, 400);
+    }
+  }
+);
+health.delete("/api-keys/:provider", async (c) => {
+  const provider = c.req.param("provider");
+  try {
+    removeApiKey(provider);
+    return c.json({
+      success: true,
+      provider: provider.toLowerCase(),
+      message: `API key for ${provider} removed`
+    });
+  } catch (error) {
+    return c.json({ error: error.message }, 400);
+  }
+});
 
 // src/server/routes/terminals.ts
 import { Hono as Hono4 } from "hono";
-import { zValidator as zValidator3 } from "@hono/zod-validator";
+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(),
@@ -2717,7 +3545,7 @@ var spawnSchema = z11.object({
 });
 terminals2.post(
   "/:sessionId/terminals",
-  zValidator3("json", spawnSchema),
+  zValidator4("json", spawnSchema),
   async (c) => {
     const sessionId = c.req.param("sessionId");
     const body = c.req.valid("json");
@@ -2725,14 +3553,21 @@ terminals2.post(
     if (!session) {
       return c.json({ error: "Session not found" }, 404);
     }
-    const manager = getTerminalManager();
-    const terminal = manager.spawn({
-      sessionId,
+    const hasTmux = await isTmuxAvailable();
+    if (!hasTmux) {
+      return c.json({ error: "tmux is not installed. Background terminals require tmux." }, 400);
+    }
+    const workingDirectory = body.cwd || session.workingDirectory;
+    const result = await runBackground(body.command, workingDirectory, { sessionId });
+    return c.json({
+      id: result.id,
+      name: body.name || null,
       command: body.command,
-      cwd: body.cwd || session.workingDirectory,
-      name: body.name
-    });
-    return c.json(terminal, 201);
+      cwd: workingDirectory,
+      status: result.status,
+      pid: null
+      // tmux doesn't expose PID directly
+    }, 201);
   }
 );
 terminals2.get("/:sessionId/terminals", async (c) => {
@@ -2741,8 +3576,20 @@ terminals2.get("/:sessionId/terminals", async (c) => {
   if (!session) {
     return c.json({ error: "Session not found" }, 404);
   }
-  const manager = getTerminalManager();
-  const terminalList = manager.list(sessionId);
+  const sessionTerminals = await listSessionTerminals(sessionId, session.workingDirectory);
+  const terminalList = await Promise.all(
+    sessionTerminals.map(async (meta) => {
+      const running = await isRunning(meta.id);
+      return {
+        id: meta.id,
+        name: null,
+        command: meta.command,
+        cwd: meta.cwd,
+        status: running ? "running" : "stopped",
+        createdAt: meta.createdAt
+      };
+    })
+  );
   return c.json({
     sessionId,
     terminals: terminalList,
@@ -2753,31 +3600,47 @@ terminals2.get("/:sessionId/terminals", async (c) => {
 terminals2.get("/:sessionId/terminals/:terminalId", async (c) => {
   const sessionId = c.req.param("sessionId");
   const terminalId = c.req.param("terminalId");
-  const manager = getTerminalManager();
-  const terminal = manager.getStatus(terminalId);
-  if (!terminal) {
+  const session = sessionQueries.getById(sessionId);
+  if (!session) {
+    return c.json({ error: "Session not found" }, 404);
+  }
+  const meta = await getMeta(terminalId, session.workingDirectory, sessionId);
+  if (!meta) {
     return c.json({ error: "Terminal not found" }, 404);
   }
-  return c.json(terminal);
+  const running = await isRunning(terminalId);
+  return c.json({
+    id: terminalId,
+    command: meta.command,
+    cwd: meta.cwd,
+    status: running ? "running" : "stopped",
+    createdAt: meta.createdAt,
+    exitCode: running ? null : 0
+    // We don't track exit codes in tmux mode
+  });
 });
 var logsQuerySchema = z11.object({
   tail: z11.string().optional().transform((v) => v ? parseInt(v, 10) : void 0)
 });
 terminals2.get(
   "/:sessionId/terminals/:terminalId/logs",
-  zValidator3("query", logsQuerySchema),
+  zValidator4("query", logsQuerySchema),
   async (c) => {
+    const sessionId = c.req.param("sessionId");
     const terminalId = c.req.param("terminalId");
     const query = c.req.valid("query");
-    const manager = getTerminalManager();
-    const result = manager.getLogs(terminalId, query.tail);
-    if (!result) {
+    const session = sessionQueries.getById(sessionId);
+    if (!session) {
+      return c.json({ error: "Session not found" }, 404);
+    }
+    const result = await getLogs(terminalId, session.workingDirectory, { tail: query.tail, sessionId });
+    if (result.status === "unknown") {
       return c.json({ error: "Terminal not found" }, 404);
     }
     return c.json({
       terminalId,
-      logs: result.logs,
-      lineCount: result.lineCount
+      logs: result.output,
+      lineCount: result.output.split("\n").length
     });
   }
 );
@@ -2786,16 +3649,14 @@ var killSchema = z11.object({
 });
 terminals2.post(
   "/:sessionId/terminals/:terminalId/kill",
-  zValidator3("json", killSchema.optional()),
+  zValidator4("json", killSchema.optional()),
   async (c) => {
     const terminalId = c.req.param("terminalId");
-    const body = await c.req.json().catch(() => ({}));
-    const manager = getTerminalManager();
-    const success = manager.kill(terminalId, body.signal);
+    const success = await killTerminal(terminalId);
     if (!success) {
-      return c.json({ error: "Failed to kill terminal" }, 400);
+      return c.json({ error: "Failed to kill terminal (may already be stopped)" }, 400);
     }
-    return c.json({ success: true, message: `Sent ${body.signal || "SIGTERM"} to terminal` });
+    return c.json({ success: true, message: "Terminal killed" });
   }
 );
 var writeSchema = z11.object({
@@ -2803,97 +3664,164 @@ var writeSchema = z11.object({
 });
 terminals2.post(
   "/:sessionId/terminals/:terminalId/write",
-  zValidator3("json", writeSchema),
+  zValidator4("json", writeSchema),
   async (c) => {
-    const terminalId = c.req.param("terminalId");
-    const body = c.req.valid("json");
-    const manager = getTerminalManager();
-    const success = manager.write(terminalId, body.input);
-    if (!success) {
-      return c.json({ error: "Failed to write to terminal" }, 400);
-    }
-    return c.json({ success: true });
+    return c.json({
+      error: "stdin writing not supported in tmux mode. Use tmux send-keys directly if needed.",
+      hint: 'tmux send-keys -t spark_{terminalId} "your input"'
+    }, 501);
   }
 );
 terminals2.post("/:sessionId/terminals/kill-all", async (c) => {
   const sessionId = c.req.param("sessionId");
-  const manager = getTerminalManager();
-  const killed = manager.killAll(sessionId);
+  const session = sessionQueries.getById(sessionId);
+  if (!session) {
+    return c.json({ error: "Session not found" }, 404);
+  }
+  const terminalIds = await listSessions();
+  let killed = 0;
+  for (const id of terminalIds) {
+    const meta = await getMeta(id, session.workingDirectory);
+    if (meta && meta.sessionId === sessionId) {
+      const success = await killTerminal(id);
+      if (success) killed++;
+    }
+  }
   return c.json({ success: true, killed });
 });
-terminals2.get("/:sessionId/terminals/:terminalId/stream", async (c) => {
+terminals2.get("/stream/:terminalId", async (c) => {
   const terminalId = c.req.param("terminalId");
-  const manager = getTerminalManager();
-  const terminal = manager.getStatus(terminalId);
-  if (!terminal) {
+  const sessions3 = sessionQueries.list();
+  let terminalMeta = null;
+  let workingDirectory = process.cwd();
+  let foundSessionId;
+  for (const session of sessions3) {
+    terminalMeta = await getMeta(terminalId, session.workingDirectory, session.id);
+    if (terminalMeta) {
+      workingDirectory = session.workingDirectory;
+      foundSessionId = session.id;
+      break;
+    }
+  }
+  if (!terminalMeta) {
+    for (const session of sessions3) {
+      terminalMeta = await getMeta(terminalId, session.workingDirectory);
+      if (terminalMeta) {
+        workingDirectory = session.workingDirectory;
+        foundSessionId = terminalMeta.sessionId;
+        break;
+      }
+    }
+  }
+  const isActive = await isRunning(terminalId);
+  if (!terminalMeta && !isActive) {
     return c.json({ error: "Terminal not found" }, 404);
   }
-  c.header("Content-Type", "text/event-stream");
-  c.header("Cache-Control", "no-cache");
-  c.header("Connection", "keep-alive");
   return new Response(
     new ReadableStream({
-      start(controller) {
+      async start(controller) {
         const encoder = new TextEncoder();
-        const initialLogs = manager.getLogs(terminalId);
-        if (initialLogs) {
-          controller.enqueue(
-            encoder.encode(`event: logs
-data: ${JSON.stringify({ logs: initialLogs.logs })}
+        let lastOutput = "";
+        let isRunning2 = true;
+        let pollCount = 0;
+        const maxPolls = 600;
+        controller.enqueue(
+          encoder.encode(`event: status
+data: ${JSON.stringify({ terminalId, status: "connected" })}
 
 `)
-          );
-        }
-        const onStdout = ({ terminalId: tid, data }) => {
-          if (tid === terminalId) {
-            controller.enqueue(
-              encoder.encode(`event: stdout
-data: ${JSON.stringify({ data })}
+        );
+        while (isRunning2 && pollCount < maxPolls) {
+          try {
+            const result = await getLogs(terminalId, workingDirectory, { sessionId: foundSessionId });
+            if (result.output !== lastOutput) {
+              const newContent = result.output.slice(lastOutput.length);
+              if (newContent) {
+                controller.enqueue(
+                  encoder.encode(`event: stdout
+data: ${JSON.stringify({ data: newContent })}
 
 `)
-            );
-          }
-        };
-        const onStderr = ({ terminalId: tid, data }) => {
-          if (tid === terminalId) {
-            controller.enqueue(
-              encoder.encode(`event: stderr
-data: ${JSON.stringify({ data })}
+                );
+              }
+              lastOutput = result.output;
+            }
+            isRunning2 = result.status === "running";
+            if (!isRunning2) {
+              controller.enqueue(
+                encoder.encode(`event: exit
+data: ${JSON.stringify({ status: "stopped" })}
 
 `)
-            );
+              );
+              break;
+            }
+            await new Promise((r) => setTimeout(r, 200));
+            pollCount++;
+          } catch {
+            break;
           }
-        };
-        const onExit = ({ terminalId: tid, code, signal }) => {
-          if (tid === terminalId) {
-            controller.enqueue(
-              encoder.encode(`event: exit
-data: ${JSON.stringify({ code, signal })}
+        }
+        controller.close();
+      }
+    }),
+    {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive"
+      }
+    }
+  );
+});
+terminals2.get("/:sessionId/terminals/:terminalId/stream", async (c) => {
+  const sessionId = c.req.param("sessionId");
+  const terminalId = c.req.param("terminalId");
+  const session = sessionQueries.getById(sessionId);
+  if (!session) {
+    return c.json({ error: "Session not found" }, 404);
+  }
+  const meta = await getMeta(terminalId, session.workingDirectory, sessionId);
+  if (!meta) {
+    return c.json({ error: "Terminal not found" }, 404);
+  }
+  return new Response(
+    new ReadableStream({
+      async start(controller) {
+        const encoder = new TextEncoder();
+        let lastOutput = "";
+        let isRunning2 = true;
+        while (isRunning2) {
+          try {
+            const result = await getLogs(terminalId, session.workingDirectory, { sessionId });
+            if (result.output !== lastOutput) {
+              const newContent = result.output.slice(lastOutput.length);
+              if (newContent) {
+                controller.enqueue(
+                  encoder.encode(`event: stdout
+data: ${JSON.stringify({ data: newContent })}
 
 `)
-            );
-            cleanup();
-            controller.close();
-          }
-        };
-        const cleanup = () => {
-          manager.off("stdout", onStdout);
-          manager.off("stderr", onStderr);
-          manager.off("exit", onExit);
-        };
-        manager.on("stdout", onStdout);
-        manager.on("stderr", onStderr);
-        manager.on("exit", onExit);
-        if (terminal.status !== "running") {
-          controller.enqueue(
-            encoder.encode(`event: exit
-data: ${JSON.stringify({ code: terminal.exitCode, status: terminal.status })}
+                );
+              }
+              lastOutput = result.output;
+            }
+            isRunning2 = result.status === "running";
+            if (!isRunning2) {
+              controller.enqueue(
+                encoder.encode(`event: exit
+data: ${JSON.stringify({ status: "stopped" })}
 
 `)
-          );
-          cleanup();
-          controller.close();
+              );
+              break;
+            }
+            await new Promise((r) => setTimeout(r, 500));
+          } catch {
+            break;
+          }
         }
+        controller.close();
       }
     }),
     {
@@ -2906,16 +3834,218 @@ data: ${JSON.stringify({ code: terminal.exitCode, status: terminal.status })}
   );
 });
 
+// src/server/index.ts
+init_db();
+
+// src/utils/dependencies.ts
+import { exec as exec3 } from "child_process";
+import { promisify as promisify3 } from "util";
+import { platform as platform2 } from "os";
+var execAsync3 = promisify3(exec3);
+function getInstallInstructions() {
+  const os2 = platform2();
+  if (os2 === "darwin") {
+    return `
+Install tmux on macOS:
+  brew install tmux
+
+If you don't have Homebrew, install it first:
+  /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
+`.trim();
+  }
+  if (os2 === "linux") {
+    return `
+Install tmux on Linux:
+  # Ubuntu/Debian
+  sudo apt-get update && sudo apt-get install -y tmux
+
+  # Fedora/RHEL
+  sudo dnf install -y tmux
+
+  # Arch Linux
+  sudo pacman -S tmux
+`.trim();
+  }
+  return `
+Install tmux:
+  Please install tmux for your operating system.
+  Visit: https://github.com/tmux/tmux/wiki/Installing
+`.trim();
+}
+async function checkTmux() {
+  try {
+    const { stdout } = await execAsync3("tmux -V", { timeout: 5e3 });
+    const version = stdout.trim();
+    return {
+      available: true,
+      version
+    };
+  } catch (error) {
+    return {
+      available: false,
+      error: "tmux is not installed or not in PATH",
+      installInstructions: getInstallInstructions()
+    };
+  }
+}
+async function checkDependencies(options = {}) {
+  const { quiet = false, exitOnFailure = true } = options;
+  const tmuxCheck = await checkTmux();
+  if (!tmuxCheck.available) {
+    if (!quiet) {
+      console.error("\n\u274C Missing required dependency: tmux");
+      console.error("");
+      console.error("SparkECoder requires tmux for terminal session management.");
+      console.error("");
+      if (tmuxCheck.installInstructions) {
+        console.error(tmuxCheck.installInstructions);
+      }
+      console.error("");
+      console.error("After installing tmux, run sparkecoder again.");
+      console.error("");
+    }
+    if (exitOnFailure) {
+      process.exit(1);
+    }
+    return false;
+  }
+  if (!quiet) {
+  }
+  return true;
+}
+
 // src/server/index.ts
 var serverInstance = null;
-async function createApp() {
+var webUIProcess = null;
+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"))) {
+      return webDir;
+    }
+    const altWebDir = resolve5(currentDir, "..", "..", "web");
+    if (existsSync6(altWebDir) && existsSync6(join3(altWebDir, "package.json"))) {
+      return altWebDir;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function isSparkcoderWebRunning(port) {
+  try {
+    const response = await fetch(`http://localhost:${port}/api/health`, {
+      signal: AbortSignal.timeout(1e3)
+    });
+    if (response.ok) {
+      const data = await response.json();
+      return data.name === "sparkecoder-web";
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function isPortInUse(port) {
+  return new Promise((resolve6) => {
+    const server = createNetServer();
+    server.once("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        resolve6(true);
+      } else {
+        resolve6(false);
+      }
+    });
+    server.once("listening", () => {
+      server.close();
+      resolve6(false);
+    });
+    server.listen(port, "0.0.0.0");
+  });
+}
+async function findWebPort(preferredPort) {
+  if (await isSparkcoderWebRunning(preferredPort)) {
+    return { port: preferredPort, alreadyRunning: true };
+  }
+  if (!await isPortInUse(preferredPort)) {
+    return { port: preferredPort, alreadyRunning: false };
+  }
+  for (const port of WEB_PORT_SEQUENCE) {
+    if (port === preferredPort) continue;
+    if (await isSparkcoderWebRunning(port)) {
+      return { port, alreadyRunning: true };
+    }
+    if (!await isPortInUse(port)) {
+      return { port, alreadyRunning: false };
+    }
+  }
+  return { port: preferredPort, alreadyRunning: false };
+}
+async function startWebUI(apiPort, webPort = DEFAULT_WEB_PORT, quiet = false) {
+  const webDir = getWebDirectory();
+  if (!webDir) {
+    if (!quiet) console.log("  \u26A0 Web UI not found, skipping...");
+    return { process: null, port: webPort };
+  }
+  const { port: actualPort, alreadyRunning } = await findWebPort(webPort);
+  if (alreadyRunning) {
+    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 command = useNpm ? "npm" : "npx";
+  const args = useNpm ? ["run", "dev", "--", "-p", String(actualPort)] : ["next", "dev", "-p", String(actualPort)];
+  const child = spawn(command, args, {
+    cwd: webDir,
+    stdio: ["ignore", "pipe", "pipe"],
+    env: {
+      ...process.env,
+      NEXT_PUBLIC_API_URL: `http://127.0.0.1:${apiPort}`
+    },
+    detached: false
+  });
+  let started = false;
+  child.stdout?.on("data", (data) => {
+    const output = data.toString();
+    if (!started && (output.includes("Ready") || output.includes("started") || output.includes("localhost"))) {
+      started = true;
+      if (!quiet) console.log(`  \u2713 Web UI running at http://localhost:${actualPort}`);
+    }
+  });
+  if (!quiet) {
+    child.stderr?.on("data", (data) => {
+      const output = data.toString();
+      if (output.toLowerCase().includes("error")) {
+        console.error(`  Web UI error: ${output.trim()}`);
+      }
+    });
+  }
+  child.on("exit", () => {
+    webUIProcess = null;
+  });
+  webUIProcess = child;
+  return { process: child, port: actualPort };
+}
+function stopWebUI() {
+  if (webUIProcess) {
+    webUIProcess.kill("SIGTERM");
+    webUIProcess = null;
+  }
+}
+async function createApp(options = {}) {
   const app = new Hono5();
   app.use("*", cors());
-  app.use("*", logger());
+  if (!options.quiet) {
+    app.use("*", logger());
+  }
   app.route("/health", health);
   app.route("/sessions", sessions2);
   app.route("/agents", agents);
   app.route("/sessions", terminals2);
+  app.route("/terminals", terminals2);
   app.get("/openapi.json", async (c) => {
     return c.json(generateOpenAPISpec());
   });
@@ -2924,7 +4054,7 @@ async function createApp() {
 <html lang="en">
 <head>
   <meta charset="UTF-8">
-  <title>Sparkecoder API - Swagger UI</title>
+  <title>SparkECoder API - Swagger UI</title>
   <link rel="stylesheet" href="https://unpkg.com/swagger-ui-dist@5/swagger-ui.css">
 </head>
 <body>
@@ -2944,7 +4074,7 @@ async function createApp() {
   });
   app.get("/", (c) => {
     return c.json({
-      name: "Sparkecoder API",
+      name: "SparkECoder API",
       version: "0.1.0",
       description: "A powerful coding agent CLI with HTTP API",
       docs: "/openapi.json",
@@ -2959,38 +4089,52 @@ async function createApp() {
   return app;
 }
 async function startServer(options = {}) {
+  const depsOk = await checkDependencies({ quiet: options.quiet, exitOnFailure: false });
+  if (!depsOk) {
+    throw new Error("Missing required dependency: tmux. See above for installation instructions.");
+  }
   const config = await loadConfig(options.configPath, options.workingDirectory);
+  loadApiKeysIntoEnv();
   if (options.workingDirectory) {
     config.resolvedWorkingDirectory = options.workingDirectory;
   }
-  if (!existsSync5(config.resolvedWorkingDirectory)) {
-    mkdirSync(config.resolvedWorkingDirectory, { recursive: true });
-    console.log(`\u{1F4C1} Created agent workspace: ${config.resolvedWorkingDirectory}`);
+  if (!existsSync6(config.resolvedWorkingDirectory)) {
+    mkdirSync2(config.resolvedWorkingDirectory, { recursive: true });
+    if (!options.quiet) console.log(`\u{1F4C1} Created agent workspace: ${config.resolvedWorkingDirectory}`);
   }
   initDatabase(config.resolvedDatabasePath);
   const port = options.port || config.server.port;
   const host = options.host || config.server.host || "0.0.0.0";
-  const app = await createApp();
-  console.log(`
-\u{1F680} Sparkecoder API Server`);
-  console.log(`   \u2192 Running at http://${host}:${port}`);
-  console.log(`   \u2192 Working directory: ${config.resolvedWorkingDirectory}`);
-  console.log(`   \u2192 Default model: ${config.defaultModel}`);
-  console.log(`   \u2192 OpenAPI spec: http://${host}:${port}/openapi.json
+  const app = await createApp({ quiet: options.quiet });
+  if (!options.quiet) {
+    console.log(`
+\u{1F680} SparkECoder API Server`);
+    console.log(`   \u2192 Running at http://${host}:${port}`);
+    console.log(`   \u2192 Working directory: ${config.resolvedWorkingDirectory}`);
+    console.log(`   \u2192 Default model: ${config.defaultModel}`);
+    console.log(`   \u2192 OpenAPI spec: http://${host}:${port}/openapi.json
 `);
+  }
   serverInstance = serve({
     fetch: app.fetch,
     port,
     hostname: host
   });
-  return { app, port, host };
+  let webPort;
+  if (options.webUI !== false) {
+    const result = await startWebUI(port, options.webPort || DEFAULT_WEB_PORT, options.quiet);
+    webPort = result.port;
+  }
+  return { app, port, host, webPort };
 }
 function stopServer() {
-  try {
-    const manager = getTerminalManager();
-    manager.cleanup();
-  } catch (e) {
-  }
+  stopWebUI();
+  listSessions().then(async (sessions3) => {
+    for (const id of sessions3) {
+      await killTerminal(id);
+    }
+  }).catch(() => {
+  });
   if (serverInstance) {
     serverInstance.close();
     serverInstance = null;
@@ -3001,7 +4145,7 @@ function generateOpenAPISpec() {
   return {
     openapi: "3.1.0",
     info: {
-      title: "Sparkecoder API",
+      title: "SparkECoder API",
       version: "0.1.0",
       description: "A powerful coding agent CLI with HTTP API for development environments. Supports streaming responses following the Vercel AI SDK data stream protocol."
     },
@@ -3453,6 +4597,7 @@ function generateOpenAPISpec() {
 export {
   createApp,
   startServer,
-  stopServer
+  stopServer,
+  stopWebUI
 };
 //# sourceMappingURL=index.js.map