sparkecoder 0.1.24 → 0.1.26

package/dist/index.js

@@ -10,7 +10,7 @@ var __export = (target, all) => {
 
 // src/config/types.ts
 import { z } from "zod";
-var ToolApprovalConfigSchema, SkillMetadataSchema, SessionConfigSchema, SparkcoderConfigSchema;
+var ToolApprovalConfigSchema, SkillMetadataSchema, SessionConfigSchema, VectorGatewayConfigSchema, RemoteServerConfigSchema, SparkcoderConfigSchema;
 var init_types = __esm({
   "src/config/types.ts"() {
     "use strict";
@@ -35,6 +35,53 @@ var init_types = __esm({
       skillsDirectory: z.string().optional(),
       maxContextChars: z.number().optional().default(2e5)
     });
+    VectorGatewayConfigSchema = z.object({
+      // Redis URL for Vector Gateway (or use VECTOR_REDIS_URL env var)
+      redisUrl: z.string().optional(),
+      // HTTP URL for database operations (or use VECTOR_HTTP_URL env var)
+      httpUrl: z.string().optional(),
+      // Embedding model to use (default: text-embedding-3-small)
+      embeddingModel: z.string().default("gemini-embedding-001"),
+      // Custom namespace override (auto-generated from git remote if not set)
+      namespace: z.string().optional(),
+      // File patterns to include in indexing
+      include: z.array(z.string()).optional().default([
+        "**/*.ts",
+        "**/*.tsx",
+        "**/*.js",
+        "**/*.jsx",
+        "**/*.py",
+        "**/*.go",
+        "**/*.rs",
+        "**/*.java",
+        "**/*.md",
+        "**/*.mdx",
+        "**/*.txt"
+      ]),
+      // File patterns to exclude from indexing
+      exclude: z.array(z.string()).optional().default([
+        "**/node_modules/**",
+        "**/dist/**",
+        "**/build/**",
+        "**/.git/**",
+        "**/.next/**",
+        "**/*.min.js",
+        "**/*.bundle.js",
+        "**/pnpm-lock.yaml",
+        "**/package-lock.json",
+        "**/yarn.lock",
+        "**/.test-workspace/**",
+        "**/.semantic-test-workspace/**",
+        "**/.semantic-integration-test/**"
+      ])
+    }).optional();
+    RemoteServerConfigSchema = z.object({
+      // URL of the remote server (e.g., https://agent.sparkecode.com)
+      url: z.string().url().optional(),
+      // Auth key for the remote server (auto-generated on first use if not set)
+      // Can also be set via SPARKECODER_AUTH_KEY env var
+      authKey: z.string().optional()
+    }).optional();
     SparkcoderConfigSchema = z.object({
       // Default model to use (Vercel AI Gateway format)
       defaultModel: z.string().default("anthropic/claude-opus-4-5"),
@@ -68,8 +115,13 @@ var init_types = __esm({
         // If not set, defaults to http://{host}:{port}
         publicUrl: z.string().url().optional()
       }).default({ port: 3141, host: "127.0.0.1" }),
-      // Database path
-      databasePath: z.string().optional().default("./sparkecoder.db")
+      // Database path (used for local SQLite - ignored if remoteServer is configured)
+      databasePath: z.string().optional().default("./sparkecoder.db"),
+      // Remote server configuration (for centralized storage)
+      // If configured, uses remote MongoDB instead of local SQLite
+      remoteServer: RemoteServerConfigSchema,
+      // Vector Gateway configuration for semantic search
+      vectorGateway: VectorGatewayConfigSchema
     });
   }
 });
@@ -398,7 +450,7 @@ var init_skills = __esm({
 import {
   streamText as streamText2,
   generateText as generateText3,
-  tool as tool9,
+  tool as tool10,
   stepCountIs as stepCountIs2
 } from "ai";
 
@@ -419,730 +471,345 @@ var SUBAGENT_MODELS = {
 };
 
 // src/agent/index.ts
-import { z as z10 } from "zod";
-import { nanoid as nanoid4 } from "nanoid";
-
-// src/db/index.ts
-import Database from "better-sqlite3";
-import { drizzle } from "drizzle-orm/better-sqlite3";
-import { eq, desc, and, sql } from "drizzle-orm";
-import { nanoid } from "nanoid";
-
-// src/db/schema.ts
-var schema_exports = {};
-__export(schema_exports, {
-  activeStreams: () => activeStreams,
-  checkpoints: () => checkpoints,
-  fileBackups: () => fileBackups,
-  loadedSkills: () => loadedSkills,
-  messages: () => messages,
-  sessions: () => sessions,
-  subagentExecutions: () => subagentExecutions,
-  terminals: () => terminals,
-  todoItems: () => todoItems,
-  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 activeStreams = sqliteTable("active_streams", {
-  id: text("id").primaryKey(),
-  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
-  streamId: text("stream_id").notNull().unique(),
-  // Unique stream identifier
-  status: text("status", { enum: ["active", "finished", "error"] }).notNull().default("active"),
-  createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
-  finishedAt: integer("finished_at", { mode: "timestamp" })
-});
-var checkpoints = sqliteTable("checkpoints", {
-  id: text("id").primaryKey(),
-  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
-  // The message sequence number this checkpoint was created BEFORE
-  // (i.e., the state before this user message was processed)
-  messageSequence: integer("message_sequence").notNull(),
-  // Optional git commit hash if in a git repo
-  gitHead: text("git_head"),
-  createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
-});
-var fileBackups = sqliteTable("file_backups", {
-  id: text("id").primaryKey(),
-  checkpointId: text("checkpoint_id").notNull().references(() => checkpoints.id, { onDelete: "cascade" }),
-  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
-  // Relative path from working directory
-  filePath: text("file_path").notNull(),
-  // Original content (null means file didn't exist before)
-  originalContent: text("original_content"),
-  // Whether the file existed before this checkpoint
-  existed: integer("existed", { mode: "boolean" }).notNull().default(true),
-  createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
-});
-var subagentExecutions = sqliteTable("subagent_executions", {
-  id: text("id").primaryKey(),
-  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
-  toolCallId: text("tool_call_id").notNull(),
-  // The tool call that spawned this subagent
-  subagentType: text("subagent_type").notNull(),
-  // e.g., 'search', 'analyze', etc.
-  task: text("task").notNull(),
-  // The task/query given to the subagent
-  model: text("model").notNull(),
-  // The model used (e.g., 'gemini-2.0-flash')
-  status: text("status", { enum: ["running", "completed", "error", "cancelled"] }).notNull().default("running"),
-  // Steps taken by the subagent (stored as JSON array)
-  steps: text("steps", { mode: "json" }).$type().default([]),
-  // Final result/output
-  result: text("result", { mode: "json" }),
-  error: text("error"),
-  startedAt: integer("started_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
-  completedAt: integer("completed_at", { mode: "timestamp" })
-});
-
-// src/db/index.ts
-var db = null;
-var sqlite = null;
-function initDatabase(dbPath) {
-  sqlite = new Database(dbPath);
-  sqlite.pragma("journal_mode = WAL");
-  db = drizzle(sqlite, { schema: schema_exports });
-  sqlite.exec(`
-    CREATE TABLE IF NOT EXISTS sessions (
-      id TEXT PRIMARY KEY,
-      name TEXT,
-      working_directory TEXT NOT NULL,
-      model TEXT NOT NULL,
-      status TEXT NOT NULL DEFAULT 'active',
-      config TEXT,
-      created_at INTEGER NOT NULL,
-      updated_at INTEGER NOT NULL
-    );
-
-    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,
-      sequence INTEGER NOT NULL DEFAULT 0,
-      created_at INTEGER NOT NULL
-    );
-
-    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,
-      tool_name TEXT NOT NULL,
-      tool_call_id TEXT NOT NULL,
-      input TEXT,
-      output TEXT,
-      status TEXT NOT NULL DEFAULT 'pending',
-      requires_approval INTEGER NOT NULL DEFAULT 0,
-      error TEXT,
-      started_at INTEGER NOT NULL,
-      completed_at INTEGER
-    );
-
-    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,
-      status TEXT NOT NULL DEFAULT 'pending',
-      "order" INTEGER NOT NULL DEFAULT 0,
-      created_at INTEGER NOT NULL,
-      updated_at INTEGER NOT NULL
-    );
-
-    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 IF NOT EXISTS terminals (
-      id TEXT PRIMARY KEY,
-      session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
-      name TEXT,
-      command TEXT NOT NULL,
-      cwd TEXT NOT NULL,
-      pid INTEGER,
-      status TEXT NOT NULL DEFAULT 'running',
-      exit_code INTEGER,
-      error TEXT,
-      created_at INTEGER NOT NULL,
-      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
-    );
-
-    -- Checkpoints table - created before each user message
-    CREATE TABLE IF NOT EXISTS checkpoints (
-      id TEXT PRIMARY KEY,
-      session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
-      message_sequence INTEGER NOT NULL,
-      git_head TEXT,
-      created_at INTEGER NOT NULL
-    );
-
-    -- File backups table - stores original file content
-    CREATE TABLE IF NOT EXISTS file_backups (
-      id TEXT PRIMARY KEY,
-      checkpoint_id TEXT NOT NULL REFERENCES checkpoints(id) ON DELETE CASCADE,
-      session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
-      file_path TEXT NOT NULL,
-      original_content TEXT,
-      existed INTEGER NOT NULL DEFAULT 1,
-      created_at INTEGER NOT NULL
-    );
-
-    -- Subagent executions table - tracks subagent runs
-    CREATE TABLE IF NOT EXISTS subagent_executions (
-      id TEXT PRIMARY KEY,
-      session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
-      tool_call_id TEXT NOT NULL,
-      subagent_type TEXT NOT NULL,
-      task TEXT NOT NULL,
-      model TEXT NOT NULL,
-      status TEXT NOT NULL DEFAULT 'running',
-      steps TEXT DEFAULT '[]',
-      result TEXT,
-      error TEXT,
-      started_at INTEGER NOT NULL,
-      completed_at INTEGER
-    );
+import { z as z11 } from "zod";
+import { nanoid as nanoid3 } from "nanoid";
 
-    CREATE INDEX IF NOT EXISTS idx_messages_session ON messages(session_id);
-    CREATE INDEX IF NOT EXISTS idx_tool_executions_session ON tool_executions(session_id);
-    CREATE INDEX IF NOT EXISTS idx_todo_items_session ON todo_items(session_id);
-    CREATE INDEX IF NOT EXISTS idx_loaded_skills_session ON loaded_skills(session_id);
-    CREATE INDEX IF NOT EXISTS idx_terminals_session ON terminals(session_id);
-    CREATE INDEX IF NOT EXISTS idx_active_streams_session ON active_streams(session_id);
-    CREATE INDEX IF NOT EXISTS idx_checkpoints_session ON checkpoints(session_id);
-    CREATE INDEX IF NOT EXISTS idx_file_backups_checkpoint ON file_backups(checkpoint_id);
-    CREATE INDEX IF NOT EXISTS idx_file_backups_session ON file_backups(session_id);
-    CREATE INDEX IF NOT EXISTS idx_subagent_executions_session ON subagent_executions(session_id);
-    CREATE INDEX IF NOT EXISTS idx_subagent_executions_tool_call ON subagent_executions(tool_call_id);
-  `);
-  return db;
+// src/db/remote.ts
+var remoteServerUrl = null;
+var authKey = null;
+function initRemoteDatabase(serverUrl, key) {
+  remoteServerUrl = serverUrl.replace(/\/$/, "");
+  authKey = key;
 }
-function getDb() {
-  if (!db) {
-    throw new Error("Database not initialized. Call initDatabase first.");
-  }
-  return db;
+function closeRemoteDatabase() {
+  remoteServerUrl = null;
+  authKey = null;
 }
-function closeDatabase() {
-  if (sqlite) {
-    sqlite.close();
-    sqlite = null;
-    db = null;
+var DATE_FIELDS = ["createdAt", "updatedAt", "startedAt", "completedAt", "stoppedAt", "finishedAt", "loadedAt", "indexedAt", "lastFullIndex", "lastIncrementalIndex"];
+function parseDates(obj) {
+  if (obj === null || obj === void 0) return obj;
+  if (Array.isArray(obj)) return obj.map(parseDates);
+  if (typeof obj !== "object") return obj;
+  const result = { ...obj };
+  for (const key of Object.keys(result)) {
+    if (DATE_FIELDS.includes(key) && typeof result[key] === "string") {
+      result[key] = new Date(result[key]);
+    } else if (typeof result[key] === "object") {
+      result[key] = parseDates(result[key]);
+    }
+  }
+  return result;
+}
+async function api(path, options = {}) {
+  if (!remoteServerUrl || !authKey) {
+    throw new Error("Remote database not initialized");
+  }
+  const url = `${remoteServerUrl}/db${path}`;
+  const init = {
+    method: options.method || "GET",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${authKey}`
+    }
+  };
+  if (options.body) {
+    init.body = JSON.stringify(options.body);
   }
+  const response = await fetch(url, init);
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ error: "Unknown error" }));
+    throw new Error(error.error || `HTTP ${response.status}`);
+  }
+  const text = await response.text();
+  if (!text || text === "null") {
+    return null;
+  }
+  return parseDates(JSON.parse(text));
 }
-var sessionQueries = {
+var remoteSessionQueries = {
   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;
+    return api("/sessions", { method: "POST", body: data });
   },
   getById(id) {
-    return getDb().select().from(sessions).where(eq(sessions.id, id)).get();
+    return api(`/sessions/${id}`).catch(() => void 0);
   },
   list(limit = 50, offset = 0) {
-    return getDb().select().from(sessions).orderBy(desc(sessions.createdAt)).limit(limit).offset(offset).all();
+    return api(`/sessions?limit=${limit}&offset=${offset}`);
   },
   updateStatus(id, status) {
-    return getDb().update(sessions).set({ status, updatedAt: /* @__PURE__ */ new Date() }).where(eq(sessions.id, id)).returning().get();
+    return api(`/sessions/${id}`, { method: "PATCH", body: { status } });
   },
   updateModel(id, model) {
-    return getDb().update(sessions).set({ model, updatedAt: /* @__PURE__ */ new Date() }).where(eq(sessions.id, id)).returning().get();
+    return api(`/sessions/${id}`, { method: "PATCH", body: { model } });
   },
   update(id, updates) {
-    return getDb().update(sessions).set({ ...updates, updatedAt: /* @__PURE__ */ new Date() }).where(eq(sessions.id, id)).returning().get();
+    return api(`/sessions/${id}`, { method: "PATCH", body: updates });
   },
   delete(id) {
-    const result = getDb().delete(sessions).where(eq(sessions.id, id)).run();
-    return result.changes > 0;
+    return api(`/sessions/${id}`, { method: "DELETE" }).then((r) => r?.success ?? false);
   }
 };
-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;
+var remoteMessageQueries = {
+  async getNextSequence(sessionId) {
+    const result = await api(`/messages/session/${sessionId}/next-sequence`);
+    return result.nextSequence;
   },
-  /**
-   * 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;
+    return api("/messages", { method: "POST", body: { sessionId, modelMessage } });
   },
-  /**
-   * 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;
+    return api("/messages/batch", { method: "POST", body: { sessionId, modelMessages } });
   },
-  /**
-   * 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();
+    return api(`/messages/session/${sessionId}`);
   },
-  /**
-   * Get ModelMessages directly (for passing to AI SDK)
-   */
   getModelMessages(sessionId) {
-    const messages2 = this.getBySession(sessionId);
-    return messages2.map((m) => m.modelMessage);
+    return api(`/messages/session/${sessionId}/model-messages`);
   },
-  getRecentBySession(sessionId, limit = 50) {
-    return getDb().select().from(messages).where(eq(messages.sessionId, sessionId)).orderBy(desc(messages.sequence)).limit(limit).all().reverse();
+  async getRecentBySession(sessionId, limit = 50) {
+    const messages = await api(`/messages/session/${sessionId}`);
+    return messages.slice(-limit);
   },
-  countBySession(sessionId) {
-    const result = getDb().select({ count: sql`count(*)` }).from(messages).where(eq(messages.sessionId, sessionId)).get();
-    return result?.count ?? 0;
+  async countBySession(sessionId) {
+    const result = await api(`/messages/session/${sessionId}/count`);
+    return result.count;
   },
-  deleteBySession(sessionId) {
-    const result = getDb().delete(messages).where(eq(messages.sessionId, sessionId)).run();
-    return result.changes;
+  async deleteBySession(sessionId) {
+    const result = await api(`/messages/session/${sessionId}`, { method: "DELETE" });
+    return result.deleted;
   },
-  /**
-   * Delete all messages with sequence >= the given sequence number
-   * (Used when reverting to a checkpoint)
-   */
-  deleteFromSequence(sessionId, fromSequence) {
-    const result = getDb().delete(messages).where(
-      and(
-        eq(messages.sessionId, sessionId),
-        sql`sequence >= ${fromSequence}`
-      )
-    ).run();
-    return result.changes;
+  async deleteFromSequence(sessionId, fromSequence) {
+    const result = await api(
+      `/messages/session/${sessionId}/from-sequence/${fromSequence}`,
+      { method: "DELETE" }
+    );
+    return result.deleted;
   }
 };
-var toolExecutionQueries = {
+var remoteToolExecutionQueries = {
   create(data) {
-    const id = nanoid();
-    const result = getDb().insert(toolExecutions).values({
-      id,
-      ...data,
-      startedAt: /* @__PURE__ */ new Date()
-    }).returning().get();
-    return result;
+    return api("/tool-executions", { method: "POST", body: data });
   },
   getById(id) {
-    return getDb().select().from(toolExecutions).where(eq(toolExecutions.id, id)).get();
+    return api(`/tool-executions/${id}`).catch(() => void 0);
   },
   getByToolCallId(toolCallId) {
-    return getDb().select().from(toolExecutions).where(eq(toolExecutions.toolCallId, toolCallId)).get();
+    return api(`/tool-executions/by-tool-call-id/${toolCallId}`).catch(() => void 0);
   },
   getPendingApprovals(sessionId) {
-    return getDb().select().from(toolExecutions).where(
-      and(
-        eq(toolExecutions.sessionId, sessionId),
-        eq(toolExecutions.status, "pending"),
-        eq(toolExecutions.requiresApproval, true)
-      )
-    ).all();
+    return api(`/tool-executions/session/${sessionId}/pending`);
   },
   approve(id) {
-    return getDb().update(toolExecutions).set({ status: "approved" }).where(eq(toolExecutions.id, id)).returning().get();
+    return api(`/tool-executions/${id}`, { method: "PATCH", body: { status: "approved" } });
   },
   reject(id) {
-    return getDb().update(toolExecutions).set({ status: "rejected" }).where(eq(toolExecutions.id, id)).returning().get();
+    return api(`/tool-executions/${id}`, { method: "PATCH", body: { status: "rejected" } });
   },
   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();
+    return api(`/tool-executions/${id}`, {
+      method: "PATCH",
+      body: { status: error ? "error" : "completed", output, error }
+    });
   },
   getBySession(sessionId) {
-    return getDb().select().from(toolExecutions).where(eq(toolExecutions.sessionId, sessionId)).orderBy(toolExecutions.startedAt).all();
+    return api(`/tool-executions/session/${sessionId}`);
   },
-  /**
-   * Delete all tool executions after a given timestamp
-   * (Used when reverting to a checkpoint)
-   */
-  deleteAfterTime(sessionId, afterTime) {
-    const result = getDb().delete(toolExecutions).where(
-      and(
-        eq(toolExecutions.sessionId, sessionId),
-        sql`started_at > ${afterTime.getTime()}`
-      )
-    ).run();
-    return result.changes;
+  async deleteAfterTime(sessionId, afterTime) {
+    const timestamp = afterTime instanceof Date ? afterTime.getTime() : new Date(afterTime).getTime();
+    const result = await api(
+      `/tool-executions/session/${sessionId}/after/${timestamp}`,
+      { method: "DELETE" }
+    );
+    return result.deleted;
   }
 };
-var todoQueries = {
+var remoteTodoQueries = {
   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;
+    return api("/todos", { method: "POST", body: data });
   },
   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();
+    return api("/todos/batch", { method: "POST", body: { sessionId, items } });
   },
   getBySession(sessionId) {
-    return getDb().select().from(todoItems).where(eq(todoItems.sessionId, sessionId)).orderBy(todoItems.order).all();
+    return api(`/todos/session/${sessionId}`);
   },
   updateStatus(id, status) {
-    return getDb().update(todoItems).set({ status, updatedAt: /* @__PURE__ */ new Date() }).where(eq(todoItems.id, id)).returning().get();
+    return api(`/todos/${id}`, { method: "PATCH", body: { status } });
   },
-  delete(id) {
-    const result = getDb().delete(todoItems).where(eq(todoItems.id, id)).run();
-    return result.changes > 0;
+  async delete(id) {
+    const result = await api(`/todos/${id}`, { method: "DELETE" });
+    return result?.success ?? false;
   },
-  clearSession(sessionId) {
-    const result = getDb().delete(todoItems).where(eq(todoItems.sessionId, sessionId)).run();
-    return result.changes;
+  async clearSession(sessionId) {
+    const result = await api(`/todos/session/${sessionId}`, { method: "DELETE" });
+    return result.deleted;
   }
 };
-var skillQueries = {
+var remoteSkillQueries = {
   load(sessionId, skillName) {
-    const id = nanoid();
-    const result = getDb().insert(loadedSkills).values({
-      id,
-      sessionId,
-      skillName,
-      loadedAt: /* @__PURE__ */ new Date()
-    }).returning().get();
-    return result;
+    return api("/skills", { method: "POST", body: { sessionId, skillName } });
   },
   getBySession(sessionId) {
-    return getDb().select().from(loadedSkills).where(eq(loadedSkills.sessionId, sessionId)).orderBy(loadedSkills.loadedAt).all();
+    return api(`/skills/session/${sessionId}`);
   },
-  isLoaded(sessionId, skillName) {
-    const result = getDb().select().from(loadedSkills).where(
-      and(
-        eq(loadedSkills.sessionId, sessionId),
-        eq(loadedSkills.skillName, skillName)
-      )
-    ).get();
-    return !!result;
+  async isLoaded(sessionId, skillName) {
+    const result = await api(`/skills/session/${sessionId}/is-loaded/${skillName}`);
+    return result.isLoaded;
   }
 };
-var activeStreamQueries = {
+var remoteActiveStreamQueries = {
   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;
+    return api("/streams", { method: "POST", body: { sessionId, streamId } });
   },
   getBySessionId(sessionId) {
-    return getDb().select().from(activeStreams).where(
-      and(
-        eq(activeStreams.sessionId, sessionId),
-        eq(activeStreams.status, "active")
-      )
-    ).get();
+    return api(`/streams/session/${sessionId}`).then((r) => r ?? void 0);
   },
   getByStreamId(streamId) {
-    return getDb().select().from(activeStreams).where(eq(activeStreams.streamId, streamId)).get();
+    return api(`/streams/by-stream-id/${streamId}`).catch(() => void 0);
   },
   finish(streamId) {
-    return getDb().update(activeStreams).set({ status: "finished", finishedAt: /* @__PURE__ */ new Date() }).where(eq(activeStreams.streamId, streamId)).returning().get();
+    return api(`/streams/by-stream-id/${streamId}`, { method: "PATCH", body: { status: "finished" } });
   },
   markError(streamId) {
-    return getDb().update(activeStreams).set({ status: "error", finishedAt: /* @__PURE__ */ new Date() }).where(eq(activeStreams.streamId, streamId)).returning().get();
+    return api(`/streams/by-stream-id/${streamId}`, { method: "PATCH", body: { status: "error" } });
   },
-  deleteBySession(sessionId) {
-    const result = getDb().delete(activeStreams).where(eq(activeStreams.sessionId, sessionId)).run();
-    return result.changes;
+  async deleteBySession(sessionId) {
+    const result = await api(`/streams/session/${sessionId}`, { method: "DELETE" });
+    return result.deleted;
   }
 };
-var checkpointQueries = {
+var remoteCheckpointQueries = {
   create(data) {
-    const id = nanoid();
-    const result = getDb().insert(checkpoints).values({
-      id,
-      sessionId: data.sessionId,
-      messageSequence: data.messageSequence,
-      gitHead: data.gitHead,
-      createdAt: /* @__PURE__ */ new Date()
-    }).returning().get();
-    return result;
+    return api("/checkpoints", { method: "POST", body: data });
   },
   getById(id) {
-    return getDb().select().from(checkpoints).where(eq(checkpoints.id, id)).get();
+    return api(`/checkpoints/${id}`).catch(() => void 0);
   },
   getBySession(sessionId) {
-    return getDb().select().from(checkpoints).where(eq(checkpoints.sessionId, sessionId)).orderBy(checkpoints.messageSequence).all();
+    return api(`/checkpoints/session/${sessionId}`);
   },
   getByMessageSequence(sessionId, messageSequence) {
-    return getDb().select().from(checkpoints).where(
-      and(
-        eq(checkpoints.sessionId, sessionId),
-        eq(checkpoints.messageSequence, messageSequence)
-      )
-    ).get();
+    return api(`/checkpoints/session/${sessionId}/by-sequence/${messageSequence}`).then((r) => r ?? void 0);
   },
   getLatest(sessionId) {
-    return getDb().select().from(checkpoints).where(eq(checkpoints.sessionId, sessionId)).orderBy(desc(checkpoints.messageSequence)).limit(1).get();
+    return api(`/checkpoints/session/${sessionId}/latest`).then((r) => r ?? void 0);
   },
-  /**
-   * Delete all checkpoints after a given sequence number
-   * (Used when reverting to a checkpoint)
-   */
-  deleteAfterSequence(sessionId, messageSequence) {
-    const result = getDb().delete(checkpoints).where(
-      and(
-        eq(checkpoints.sessionId, sessionId),
-        sql`message_sequence > ${messageSequence}`
-      )
-    ).run();
-    return result.changes;
+  async deleteAfterSequence(sessionId, messageSequence) {
+    const result = await api(
+      `/checkpoints/session/${sessionId}/after-sequence/${messageSequence}`,
+      { method: "DELETE" }
+    );
+    return result.deleted;
   },
-  deleteBySession(sessionId) {
-    const result = getDb().delete(checkpoints).where(eq(checkpoints.sessionId, sessionId)).run();
-    return result.changes;
+  async deleteBySession(sessionId) {
+    const result = await api(`/checkpoints/session/${sessionId}`, { method: "DELETE" });
+    return result.deleted;
   }
 };
-var fileBackupQueries = {
+var remoteFileBackupQueries = {
   create(data) {
-    const id = nanoid();
-    const result = getDb().insert(fileBackups).values({
-      id,
-      checkpointId: data.checkpointId,
-      sessionId: data.sessionId,
-      filePath: data.filePath,
-      originalContent: data.originalContent,
-      existed: data.existed,
-      createdAt: /* @__PURE__ */ new Date()
-    }).returning().get();
-    return result;
+    return api("/file-backups", { method: "POST", body: data });
   },
   getByCheckpoint(checkpointId) {
-    return getDb().select().from(fileBackups).where(eq(fileBackups.checkpointId, checkpointId)).all();
+    return api(`/file-backups/checkpoint/${checkpointId}`);
   },
   getBySession(sessionId) {
-    return getDb().select().from(fileBackups).where(eq(fileBackups.sessionId, sessionId)).orderBy(fileBackups.createdAt).all();
+    return api(`/file-backups/session/${sessionId}`);
   },
-  /**
-   * Get all file backups from a given checkpoint sequence onwards (inclusive)
-   * (Used when reverting - need to restore these files)
-   * 
-   * When reverting to checkpoint X, we need backups from checkpoint X and all later ones
-   * because checkpoint X's backups represent the state BEFORE processing message X.
-   */
   getFromSequence(sessionId, messageSequence) {
-    const checkpointsFrom = getDb().select().from(checkpoints).where(
-      and(
-        eq(checkpoints.sessionId, sessionId),
-        sql`message_sequence >= ${messageSequence}`
-      )
-    ).all();
-    if (checkpointsFrom.length === 0) {
-      return [];
-    }
-    const checkpointIds = checkpointsFrom.map((c) => c.id);
-    const allBackups = [];
-    for (const cpId of checkpointIds) {
-      const backups = getDb().select().from(fileBackups).where(eq(fileBackups.checkpointId, cpId)).all();
-      allBackups.push(...backups);
-    }
-    return allBackups;
+    return api(`/file-backups/session/${sessionId}/from-sequence/${messageSequence}`);
   },
-  /**
-   * Check if a file already has a backup in the current checkpoint
-   */
-  hasBackup(checkpointId, filePath) {
-    const result = getDb().select().from(fileBackups).where(
-      and(
-        eq(fileBackups.checkpointId, checkpointId),
-        eq(fileBackups.filePath, filePath)
-      )
-    ).get();
-    return !!result;
+  async hasBackup(checkpointId, filePath) {
+    const result = await api(
+      `/file-backups/checkpoint/${checkpointId}/has-backup/${encodeURIComponent(filePath)}`
+    );
+    return result.hasBackup;
   },
-  deleteBySession(sessionId) {
-    const result = getDb().delete(fileBackups).where(eq(fileBackups.sessionId, sessionId)).run();
-    return result.changes;
+  async deleteBySession(sessionId) {
+    const result = await api(`/file-backups/session/${sessionId}`, { method: "DELETE" });
+    return result.deleted;
   }
 };
-var subagentQueries = {
+var remoteSubagentQueries = {
   create(data) {
-    const id = nanoid();
-    const result = getDb().insert(subagentExecutions).values({
-      id,
-      sessionId: data.sessionId,
-      toolCallId: data.toolCallId,
-      subagentType: data.subagentType,
-      task: data.task,
-      model: data.model,
-      status: "running",
-      steps: [],
-      startedAt: /* @__PURE__ */ new Date()
-    }).returning().get();
-    return result;
+    return api("/subagents", { method: "POST", body: data });
   },
   getById(id) {
-    return getDb().select().from(subagentExecutions).where(eq(subagentExecutions.id, id)).get();
+    return api(`/subagents/${id}`).catch(() => void 0);
   },
   getByToolCallId(toolCallId) {
-    return getDb().select().from(subagentExecutions).where(eq(subagentExecutions.toolCallId, toolCallId)).get();
+    return api(`/subagents/by-tool-call-id/${toolCallId}`).catch(() => void 0);
   },
   getBySession(sessionId) {
-    return getDb().select().from(subagentExecutions).where(eq(subagentExecutions.sessionId, sessionId)).orderBy(desc(subagentExecutions.startedAt)).all();
+    return api(`/subagents/session/${sessionId}`);
   },
   addStep(id, step) {
-    const existing = this.getById(id);
-    if (!existing) return void 0;
-    const currentSteps = existing.steps || [];
-    const newSteps = [...currentSteps, step];
-    return getDb().update(subagentExecutions).set({ steps: newSteps }).where(eq(subagentExecutions.id, id)).returning().get();
+    return api(`/subagents/${id}/add-step`, { method: "POST", body: { step } }).catch(() => void 0);
   },
   complete(id, result) {
-    return getDb().update(subagentExecutions).set({
-      status: "completed",
-      result,
-      completedAt: /* @__PURE__ */ new Date()
-    }).where(eq(subagentExecutions.id, id)).returning().get();
+    return api(`/subagents/${id}`, { method: "PATCH", body: { status: "completed", result } }).catch(() => void 0);
   },
   markError(id, error) {
-    return getDb().update(subagentExecutions).set({
-      status: "error",
-      error,
-      completedAt: /* @__PURE__ */ new Date()
-    }).where(eq(subagentExecutions.id, id)).returning().get();
+    return api(`/subagents/${id}`, { method: "PATCH", body: { status: "error", error } }).catch(() => void 0);
   },
   cancel(id) {
-    return getDb().update(subagentExecutions).set({
-      status: "cancelled",
-      completedAt: /* @__PURE__ */ new Date()
-    }).where(eq(subagentExecutions.id, id)).returning().get();
+    return api(`/subagents/${id}`, { method: "PATCH", body: { status: "cancelled" } }).catch(() => void 0);
+  },
+  async deleteBySession(sessionId) {
+    const result = await api(`/subagents/session/${sessionId}`, { method: "DELETE" });
+    return result.deleted;
+  }
+};
+var remoteIndexStatusQueries = {
+  upsert(_db, data) {
+    return api("/index-status", {
+      method: "POST",
+      body: {
+        ...data,
+        lastFullIndex: data.lastFullIndex?.toISOString(),
+        lastIncrementalIndex: data.lastIncrementalIndex?.toISOString()
+      }
+    });
+  },
+  get(_db, namespace) {
+    return api(`/index-status/namespace/${namespace}`).then((r) => r ?? void 0);
+  },
+  async delete(_db, namespace) {
+    const result = await api(`/index-status/namespace/${namespace}`, { method: "DELETE" });
+    return result?.success ?? false;
   },
-  deleteBySession(sessionId) {
-    const result = getDb().delete(subagentExecutions).where(eq(subagentExecutions.sessionId, sessionId)).run();
-    return result.changes;
+  list(_db) {
+    return api("/index-status");
   }
 };
 
+// src/db/index.ts
+var initialized = false;
+function initDatabase(config) {
+  initRemoteDatabase(config.url, config.authKey);
+  initialized = true;
+}
+function getDb() {
+  if (!initialized) {
+    throw new Error("Database not initialized. Call initDatabase first.");
+  }
+  return {};
+}
+function closeDatabase() {
+  closeRemoteDatabase();
+  initialized = false;
+}
+var sessionQueries = remoteSessionQueries;
+var messageQueries = remoteMessageQueries;
+var toolExecutionQueries = remoteToolExecutionQueries;
+var todoQueries = remoteTodoQueries;
+var skillQueries = remoteSkillQueries;
+var activeStreamQueries = remoteActiveStreamQueries;
+var checkpointQueries = remoteCheckpointQueries;
+var fileBackupQueries = remoteFileBackupQueries;
+var subagentQueries = remoteSubagentQueries;
+var indexStatusQueries = remoteIndexStatusQueries;
+
 // src/config/index.ts
 init_types();
 init_types();
@@ -1292,6 +959,48 @@ function loadConfig(configPath, workingDirectory) {
     const appDataDir = ensureAppDataDirectory();
     resolvedDatabasePath = join(appDataDir, "sparkecoder.db");
   }
+  const resolvedVectorGateway = {
+    redisUrl: process.env.VECTOR_REDIS_URL || config.vectorGateway?.redisUrl || null,
+    httpUrl: process.env.VECTOR_HTTP_URL || config.vectorGateway?.httpUrl || null,
+    embeddingModel: process.env.VECTOR_EMBEDDING_MODEL || config.vectorGateway?.embeddingModel || "gemini-embedding-001",
+    namespace: config.vectorGateway?.namespace || null,
+    include: config.vectorGateway?.include || [
+      "**/*.ts",
+      "**/*.tsx",
+      "**/*.js",
+      "**/*.jsx",
+      "**/*.py",
+      "**/*.go",
+      "**/*.rs",
+      "**/*.java",
+      "**/*.md",
+      "**/*.mdx",
+      "**/*.txt"
+    ],
+    exclude: config.vectorGateway?.exclude || [
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/build/**",
+      "**/.git/**",
+      "**/.next/**",
+      "**/*.min.js",
+      "**/*.bundle.js",
+      "**/pnpm-lock.yaml",
+      "**/package-lock.json",
+      "**/yarn.lock",
+      "**/.test-workspace/**",
+      "**/.semantic-test-workspace/**",
+      "**/.semantic-integration-test/**"
+    ]
+  };
+  const DEFAULT_REMOTE_URL = "https://agent-remote-server.sparkecode.com";
+  const remoteUrl = process.env.SPARKECODER_REMOTE_URL || config.remoteServer?.url || DEFAULT_REMOTE_URL;
+  const remoteAuthKey = process.env.SPARKECODER_AUTH_KEY || config.remoteServer?.authKey || loadStoredAuthKey();
+  const resolvedRemoteServer = {
+    url: remoteUrl,
+    authKey: remoteAuthKey,
+    isConfigured: !!remoteUrl && !!remoteAuthKey
+  };
   const resolved = {
     ...config,
     server: {
@@ -1302,7 +1011,9 @@ function loadConfig(configPath, workingDirectory) {
     resolvedWorkingDirectory,
     resolvedSkillsDirectories,
     resolvedDatabasePath,
-    discoveredSkills: discovered
+    discoveredSkills: discovered,
+    resolvedVectorGateway,
+    resolvedRemoteServer
   };
   cachedConfig = resolved;
   return resolved;
@@ -1327,6 +1038,55 @@ function requiresApproval(toolName, sessionConfig) {
   }
   return false;
 }
+var AUTH_KEY_FILE = "auth-key.json";
+function loadStoredAuthKey() {
+  const keysPath = join(getAppDataDirectory(), AUTH_KEY_FILE);
+  if (!existsSync(keysPath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(keysPath, "utf-8");
+    const data = JSON.parse(content);
+    return data.authKey || null;
+  } catch {
+    return null;
+  }
+}
+function saveAuthKey(authKey3, userId) {
+  const appDir = ensureAppDataDirectory();
+  const keysPath = join(appDir, AUTH_KEY_FILE);
+  const data = {
+    authKey: authKey3,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    userId
+  };
+  writeFileSync(keysPath, JSON.stringify(data, null, 2), { mode: 384 });
+}
+async function registerWithRemoteServer(serverUrl, name) {
+  const response = await fetch(`${serverUrl}/auth/register`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ name: name || `CLI ${(/* @__PURE__ */ new Date()).toISOString()}` })
+  });
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({}));
+    throw new Error(error.error || `Failed to register: HTTP ${response.status}`);
+  }
+  const data = await response.json();
+  saveAuthKey(data.authKey, data.userId);
+  return data;
+}
+async function ensureRemoteAuthKey(serverUrl) {
+  if (process.env.SPARKECODER_AUTH_KEY) {
+    return process.env.SPARKECODER_AUTH_KEY;
+  }
+  const storedKey = loadStoredAuthKey();
+  if (storedKey) {
+    return storedKey;
+  }
+  const { authKey: authKey3 } = await registerWithRemoteServer(serverUrl);
+  return authKey3;
+}
 var API_KEYS_FILE = "api-keys.json";
 var PROVIDER_ENV_MAP = {
   anthropic: "ANTHROPIC_API_KEY",
@@ -1440,8 +1200,8 @@ function truncateOutput(output, maxChars = MAX_OUTPUT_CHARS) {
 
 ` + output.slice(-halfMax);
 }
-function calculateContextSize(messages2) {
-  return messages2.reduce((total, msg) => {
+function calculateContextSize(messages) {
+  return messages.reduce((total, msg) => {
     const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
     return total + content.length;
   }, 0);
@@ -1470,7 +1230,7 @@ import { promisify } from "util";
 import { mkdir, writeFile, readFile } from "fs/promises";
 import { existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
 import { join as join2 } from "path";
-import { nanoid as nanoid2 } from "nanoid";
+import { nanoid } from "nanoid";
 var execAsync = promisify(exec);
 var SESSION_PREFIX = "spark_";
 var LOG_BASE_DIR = "sessions";
@@ -1490,7 +1250,7 @@ async function isTmuxAvailable() {
   }
 }
 function generateTerminalId() {
-  return "t" + nanoid2(9);
+  return "t" + nanoid(9);
 }
 function getSessionName(terminalId) {
   return `${SESSION_PREFIX}${terminalId}`;
@@ -1718,7 +1478,7 @@ async function getMeta(terminalId, workingDirectory, sessionId) {
 }
 async function listSessionTerminals(sessionId, workingDirectory) {
   const terminalsDir = join2(workingDirectory, LOG_BASE_DIR, sessionId, "terminals");
-  const terminals3 = [];
+  const terminals2 = [];
   try {
     const { readdir: readdir5 } = await import("fs/promises");
     const entries = await readdir5(terminalsDir, { withFileTypes: true });
@@ -1726,13 +1486,13 @@ async function listSessionTerminals(sessionId, workingDirectory) {
       if (entry.isDirectory()) {
         const meta = await getMeta(entry.name, workingDirectory, sessionId);
         if (meta) {
-          terminals3.push(meta);
+          terminals2.push(meta);
         }
       }
     }
   } catch {
   }
-  return terminals3;
+  return terminals2;
 }
 async function sendInput(terminalId, input, options = {}) {
   const session = getSessionName(terminalId);
@@ -2147,7 +1907,7 @@ function getCheckpointManager(sessionId, workingDirectory) {
 }
 async function createCheckpoint(sessionId, workingDirectory, messageSequence) {
   const gitHead = await getGitHead(workingDirectory);
-  const checkpoint = checkpointQueries.create({
+  const checkpoint = await checkpointQueries.create({
     sessionId,
     messageSequence,
     gitHead
@@ -2164,7 +1924,7 @@ async function backupFile(sessionId, workingDirectory, filePath) {
   }
   const absolutePath = resolve3(workingDirectory, filePath);
   const relativePath = relative2(workingDirectory, absolutePath);
-  if (fileBackupQueries.hasBackup(manager.currentCheckpointId, relativePath)) {
+  if (await fileBackupQueries.hasBackup(manager.currentCheckpointId, relativePath)) {
     return null;
   }
   let originalContent = null;
@@ -2177,7 +1937,7 @@ async function backupFile(sessionId, workingDirectory, filePath) {
       console.warn(`[checkpoint] Failed to read file for backup: ${error.message}`);
     }
   }
-  const backup = fileBackupQueries.create({
+  const backup = await fileBackupQueries.create({
     checkpointId: manager.currentCheckpointId,
     sessionId,
     filePath: relativePath,
@@ -2187,7 +1947,7 @@ async function backupFile(sessionId, workingDirectory, filePath) {
   return backup;
 }
 async function revertToCheckpoint(sessionId, checkpointId) {
-  const session = sessionQueries.getById(sessionId);
+  const session = await sessionQueries.getById(sessionId);
   if (!session) {
     return {
       success: false,
@@ -2198,7 +1958,7 @@ async function revertToCheckpoint(sessionId, checkpointId) {
       error: "Session not found"
     };
   }
-  const checkpoint = checkpointQueries.getById(checkpointId);
+  const checkpoint = await checkpointQueries.getById(checkpointId);
   if (!checkpoint || checkpoint.sessionId !== sessionId) {
     return {
       success: false,
@@ -2210,7 +1970,7 @@ async function revertToCheckpoint(sessionId, checkpointId) {
     };
   }
   const workingDirectory = session.workingDirectory;
-  const backupsToRevert = fileBackupQueries.getFromSequence(sessionId, checkpoint.messageSequence);
+  const backupsToRevert = await fileBackupQueries.getFromSequence(sessionId, checkpoint.messageSequence);
   const fileToEarliestBackup = /* @__PURE__ */ new Map();
   for (const backup of backupsToRevert) {
     if (!fileToEarliestBackup.has(backup.filePath)) {
@@ -2239,9 +1999,9 @@ async function revertToCheckpoint(sessionId, checkpointId) {
       console.error(`Failed to restore ${filePath}: ${error.message}`);
     }
   }
-  const messagesDeleted = messageQueries.deleteFromSequence(sessionId, checkpoint.messageSequence);
-  toolExecutionQueries.deleteAfterTime(sessionId, checkpoint.createdAt);
-  const checkpointsDeleted = checkpointQueries.deleteAfterSequence(sessionId, checkpoint.messageSequence);
+  const messagesDeleted = await messageQueries.deleteFromSequence(sessionId, checkpoint.messageSequence);
+  await toolExecutionQueries.deleteAfterTime(sessionId, checkpoint.createdAt);
+  const checkpointsDeleted = await checkpointQueries.deleteAfterSequence(sessionId, checkpoint.messageSequence);
   const manager = getCheckpointManager(sessionId, workingDirectory);
   manager.currentCheckpointId = checkpoint.id;
   return {
@@ -2252,16 +2012,16 @@ async function revertToCheckpoint(sessionId, checkpointId) {
     checkpointsDeleted
   };
 }
-function getCheckpoints(sessionId) {
+async function getCheckpoints(sessionId) {
   return checkpointQueries.getBySession(sessionId);
 }
 async function getSessionDiff(sessionId) {
-  const session = sessionQueries.getById(sessionId);
+  const session = await sessionQueries.getById(sessionId);
   if (!session) {
     return { files: [] };
   }
   const workingDirectory = session.workingDirectory;
-  const allBackups = fileBackupQueries.getBySession(sessionId);
+  const allBackups = await fileBackupQueries.getBySession(sessionId);
   const fileToOriginalBackup = /* @__PURE__ */ new Map();
   for (const backup of allBackups) {
     if (!fileToOriginalBackup.has(backup.filePath)) {
@@ -3048,7 +2808,7 @@ Best practices:
                 error: "No items provided. Include at least one todo item."
               };
             }
-            const created = todoQueries.createMany(options.sessionId, items);
+            const created = await todoQueries.createMany(options.sessionId, items);
             return {
               success: true,
               action: "add",
@@ -3057,7 +2817,7 @@ Best practices:
             };
           }
           case "list": {
-            const todos = todoQueries.getBySession(options.sessionId);
+            const todos = await todoQueries.getBySession(options.sessionId);
             const stats = {
               total: todos.length,
               pending: todos.filter((t) => t.status === "pending").length,
@@ -3085,7 +2845,7 @@ Best practices:
                 error: 'status is required for "mark" action'
               };
             }
-            const updated = todoQueries.updateStatus(todoId, status);
+            const updated = await todoQueries.updateStatus(todoId, status);
             if (!updated) {
               return {
                 success: false,
@@ -3099,7 +2859,7 @@ Best practices:
             };
           }
           case "clear": {
-            const count = todoQueries.clearSession(options.sessionId);
+            const count = await todoQueries.clearSession(options.sessionId);
             return {
               success: true,
               action: "clear",
@@ -3173,7 +2933,7 @@ Once loaded, a skill's content will be available in the conversation context.`,
                 error: 'skillName is required for "load" action'
               };
             }
-            if (skillQueries.isLoaded(options.sessionId, skillName)) {
+            if (await skillQueries.isLoaded(options.sessionId, skillName)) {
               return {
                 success: false,
                 error: `Skill "${skillName}" is already loaded in this session`
@@ -3188,7 +2948,7 @@ Once loaded, a skill's content will be available in the conversation context.`,
                 availableSkills: allSkills.map((s) => s.name)
               };
             }
-            skillQueries.load(options.sessionId, skillName);
+            await skillQueries.load(options.sessionId, skillName);
             return {
               success: true,
               action: "load",
@@ -3416,7 +3176,7 @@ import {
   generateText,
   stepCountIs
 } from "ai";
-import { nanoid as nanoid3 } from "nanoid";
+import { nanoid as nanoid2 } from "nanoid";
 var Subagent = class {
   /** Model to use (defaults to gemini-2.0-flash) */
   model;
@@ -3429,8 +3189,8 @@ var Subagent = class {
    * Parse the final result from the subagent's output.
    * Override this to structure the result for your subagent type.
    */
-  parseResult(text2, steps) {
-    return { text: text2, steps };
+  parseResult(text, steps) {
+    return { text, steps };
   }
   /**
    * Run the subagent with streaming progress updates
@@ -3438,7 +3198,7 @@ var Subagent = class {
   async run(options) {
     const { task, sessionId, toolCallId, onProgress, abortSignal } = options;
     const steps = [];
-    const execution = subagentQueries.create({
+    const execution = await subagentQueries.create({
       sessionId,
       toolCallId,
       subagentType: this.type,
@@ -3447,12 +3207,12 @@ var Subagent = class {
     });
     const addStep = async (step) => {
       const fullStep = {
-        id: nanoid3(8),
+        id: nanoid2(8),
         timestamp: Date.now(),
         ...step
       };
       steps.push(fullStep);
-      subagentQueries.addStep(execution.id, fullStep);
+      await subagentQueries.addStep(execution.id, fullStep);
       await onProgress?.({
         type: "step",
         subagentId: execution.id,
@@ -3522,7 +3282,7 @@ var Subagent = class {
         }
       });
       const parsedResult = this.parseResult(result.text, steps);
-      subagentQueries.complete(execution.id, parsedResult);
+      await subagentQueries.complete(execution.id, parsedResult);
       await onProgress?.({
         type: "complete",
         subagentId: execution.id,
@@ -3537,7 +3297,7 @@ var Subagent = class {
       };
     } catch (error) {
       const errorMessage = error.message || "Unknown error";
-      subagentQueries.markError(execution.id, errorMessage);
+      await subagentQueries.markError(execution.id, errorMessage);
       await onProgress?.({
         type: "error",
         subagentId: execution.id,
@@ -3847,7 +3607,7 @@ Keep your responses concise and focused on actionable information.`;
       })
     };
   }
-  parseResult(text2, steps) {
+  parseResult(text, steps) {
     const findings = [];
     let filesSearched = 0;
     let matchCount = 0;
@@ -3891,7 +3651,7 @@ Keep your responses concise and focused on actionable information.`;
     const query = steps.length > 0 ? steps.find((s) => s.type === "text")?.content || "" : "";
     return {
       query,
-      summary: text2,
+      summary: text,
       findings: findings.slice(0, 20),
       // Limit findings
       filesSearched,
@@ -4022,9 +3782,362 @@ Context: ${context}` : query;
   });
 }
 
+// src/tools/semantic-search.ts
+import { tool as tool9 } from "ai";
+import { z as z10 } from "zod";
+import { existsSync as existsSync11, readFileSync as readFileSync4 } from "fs";
+import { join as join5 } from "path";
+import { minimatch as minimatch3 } from "minimatch";
+
+// src/semantic/namespace.ts
+import { execSync } from "child_process";
+function getGitRemoteUrl(workingDirectory) {
+  try {
+    const result = execSync("git remote get-url origin", {
+      cwd: workingDirectory,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return result.trim();
+  } catch {
+    return null;
+  }
+}
+function parseGitRemoteUrl(url) {
+  const cleanUrl = url.replace(/\.git$/, "");
+  const sshMatch = cleanUrl.match(/git@[^:]+:([^/]+)\/(.+)$/);
+  if (sshMatch) {
+    return { org: sshMatch[1], repo: sshMatch[2] };
+  }
+  const httpsMatch = cleanUrl.match(/https?:\/\/[^/]+\/([^/]+)\/(.+)$/);
+  if (httpsMatch) {
+    return { org: httpsMatch[1], repo: httpsMatch[2] };
+  }
+  const sshProtoMatch = cleanUrl.match(/ssh:\/\/[^/]+\/([^/]+)\/(.+)$/);
+  if (sshProtoMatch) {
+    return { org: sshProtoMatch[1], repo: sshProtoMatch[2] };
+  }
+  return null;
+}
+function sanitizeForNamespace(str) {
+  return str.toLowerCase().replace(/[^a-z0-9]/g, "_").replace(/^_+|_+$/g, "").replace(/_+/g, "_");
+}
+async function getRepoNamespace(workingDirectory, configuredNamespace) {
+  if (configuredNamespace) {
+    return configuredNamespace;
+  }
+  const remoteUrl = getGitRemoteUrl(workingDirectory);
+  if (!remoteUrl) {
+    return null;
+  }
+  const parsed = parseGitRemoteUrl(remoteUrl);
+  if (!parsed) {
+    return null;
+  }
+  const org = sanitizeForNamespace(parsed.org);
+  const repo = sanitizeForNamespace(parsed.repo);
+  return `sparkecoder_${org}_${repo}`;
+}
+
+// src/semantic/hasher.ts
+import { createHash } from "crypto";
+
+// src/semantic/chunker.ts
+import { extname as extname6, basename as basename2 } from "path";
+
+// src/semantic/client.ts
+var remoteServerUrl2 = null;
+var authKey2 = null;
+function initVectorClient(serverUrl, key) {
+  remoteServerUrl2 = serverUrl.replace(/\/$/, "");
+  authKey2 = key;
+}
+function isVectorClientConfigured() {
+  return !!remoteServerUrl2 && !!authKey2;
+}
+async function vectorApi(path, options = {}) {
+  if (!remoteServerUrl2 || !authKey2) {
+    throw new Error("Vector client not initialized - remote server not configured");
+  }
+  const url = `${remoteServerUrl2}/vectors${path}`;
+  const init = {
+    method: options.method || "GET",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${authKey2}`
+    }
+  };
+  if (options.body) {
+    init.body = JSON.stringify(options.body);
+  }
+  const response = await fetch(url, init);
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ error: "Unknown error" }));
+    throw new Error(error.error || `HTTP ${response.status}`);
+  }
+  return response.json();
+}
+var remoteVectorClient = {
+  embeddings: {
+    /**
+     * Create embeddings and store in vector DB
+     */
+    async createAndWait(texts, options) {
+      return vectorApi("/embed", {
+        method: "POST",
+        body: {
+          texts,
+          namespace: options.namespace,
+          embeddingModel: options.embeddingModel
+        }
+      });
+    }
+  },
+  search: {
+    /**
+     * Query vectors using semantic search
+     */
+    async queryAndWait(query, options) {
+      return vectorApi("/search", {
+        method: "POST",
+        body: {
+          query,
+          namespace: options.namespace,
+          topK: options.topK || 10,
+          embeddingModel: options.embeddingModel
+        }
+      });
+    }
+  },
+  /**
+   * Delete a namespace (if supported)
+   */
+  async deleteNamespace(namespace) {
+    await vectorApi(`/namespace/${encodeURIComponent(namespace)}`, {
+      method: "DELETE"
+    });
+  },
+  /**
+   * Close client (no-op for HTTP client)
+   */
+  async close() {
+  }
+};
+function getVectorClient() {
+  if (!isVectorClientConfigured()) {
+    try {
+      const config = getConfig();
+      if (config.resolvedRemoteServer.url && config.resolvedRemoteServer.authKey) {
+        initVectorClient(config.resolvedRemoteServer.url, config.resolvedRemoteServer.authKey);
+      } else {
+        return null;
+      }
+    } catch {
+      return null;
+    }
+  }
+  return remoteVectorClient;
+}
+async function closeVectorClient() {
+}
+function isVectorGatewayConfigured() {
+  try {
+    const config = getConfig();
+    return !!(config.resolvedRemoteServer.url && config.resolvedRemoteServer.authKey);
+  } catch {
+    return false;
+  }
+}
+function getEmbeddingModel() {
+  try {
+    const config = getConfig();
+    return config.resolvedVectorGateway.embeddingModel;
+  } catch {
+    return "gemini-embedding-001";
+  }
+}
+
+// src/semantic/indexer.ts
+import { readFileSync as readFileSync3, statSync } from "fs";
+import { relative as relative7 } from "path";
+import { minimatch as minimatch2 } from "minimatch";
+var MAX_FILE_SIZE3 = 1024 * 1024;
+async function getIndexStatus(workingDirectory) {
+  const config = getConfig();
+  const namespace = await getRepoNamespace(
+    workingDirectory,
+    config.resolvedVectorGateway.namespace
+  );
+  const isConfigured = !!config.resolvedVectorGateway.redisUrl;
+  if (!namespace) {
+    return {
+      namespace: "",
+      totalChunks: 0,
+      lastFullIndex: null,
+      lastIncrementalIndex: null,
+      isConfigured
+    };
+  }
+  try {
+    const db = getDb();
+    const status = await indexStatusQueries.get(db, namespace);
+    if (!status) {
+      return {
+        namespace,
+        totalChunks: 0,
+        lastFullIndex: null,
+        lastIncrementalIndex: null,
+        isConfigured
+      };
+    }
+    return {
+      namespace,
+      totalChunks: status.totalChunks ?? 0,
+      lastFullIndex: status.lastFullIndex ?? null,
+      lastIncrementalIndex: status.lastIncrementalIndex ?? null,
+      isConfigured
+    };
+  } catch {
+    return {
+      namespace,
+      totalChunks: 0,
+      lastFullIndex: null,
+      lastIncrementalIndex: null,
+      isConfigured
+    };
+  }
+}
+async function checkIndexExists(workingDirectory) {
+  const status = await getIndexStatus(workingDirectory);
+  return status.totalChunks > 0;
+}
+
+// src/tools/semantic-search.ts
+var semanticSearchInputSchema = z10.object({
+  query: z10.string().describe("Natural language search query describing what you want to find"),
+  topK: z10.number().optional().default(10).describe("Number of results to return (default: 10, max: 50)"),
+  filePattern: z10.string().optional().describe('Filter results by file glob pattern (e.g., "*.ts", "src/**/*.py")'),
+  language: z10.string().optional().describe('Filter by programming language (e.g., "typescript", "python")')
+});
+function createSemanticSearchTool(options) {
+  return tool9({
+    description: `Search the codebase using semantic similarity. This tool finds code by understanding its meaning, not just matching text.
+
+Use this tool when:
+- You need to understand how something works in the codebase
+- You're looking for code related to a concept (e.g., "authentication", "database queries")
+- You want to find implementations of features
+- The user asks "where is X?" or "how does Y work?"
+
+This tool requires the repository to be indexed first with 'sparkecoder index'.
+
+Returns matching code snippets with file paths, line numbers, and relevance scores.`,
+    inputSchema: semanticSearchInputSchema,
+    execute: async ({
+      query,
+      topK,
+      filePattern,
+      language
+    }) => {
+      const startTime = Date.now();
+      try {
+        const config = getConfig();
+        const namespace = await getRepoNamespace(
+          options.workingDirectory,
+          config.resolvedVectorGateway.namespace
+        );
+        if (!namespace) {
+          return {
+            success: false,
+            error: "Repository namespace not found. Ensure this is a git repository with a remote configured."
+          };
+        }
+        const client = getVectorClient();
+        if (!client) {
+          return {
+            success: false,
+            error: 'Vector Gateway not configured. Run "sparkecoder index --status" for setup instructions.'
+          };
+        }
+        try {
+          const limitedTopK = Math.min(Math.max(1, topK), 50);
+          const embeddingModel = getEmbeddingModel();
+          const result = await client.search.queryAndWait(query, {
+            namespace,
+            topK: limitedTopK * 2,
+            includeMetadata: true,
+            embeddingModel
+          });
+          const matches = [];
+          for (const match of result.matches) {
+            const metadata = match.metadata;
+            if (!metadata) continue;
+            const filePath = metadata.filePath;
+            const startLine = metadata.startLine;
+            const endLine = metadata.endLine;
+            const matchLanguage = metadata.language;
+            const symbolName = metadata.symbolName;
+            if (filePattern) {
+              const matchesPattern = minimatch3(filePath, filePattern, { dot: true });
+              if (!matchesPattern) continue;
+            }
+            if (language && matchLanguage !== language.toLowerCase()) {
+              continue;
+            }
+            const fullPath = join5(options.workingDirectory, filePath);
+            if (!existsSync11(fullPath)) {
+              continue;
+            }
+            let snippet = "";
+            try {
+              const content = readFileSync4(fullPath, "utf-8");
+              const lines = content.split("\n");
+              const snippetLines = lines.slice(
+                Math.max(0, startLine - 1),
+                Math.min(lines.length, endLine)
+              );
+              snippet = snippetLines.join("\n");
+              if (snippet.length > 500) {
+                snippet = snippet.slice(0, 500) + "\n... (truncated)";
+              }
+            } catch {
+            }
+            matches.push({
+              filePath,
+              startLine,
+              endLine,
+              score: match.score,
+              snippet,
+              symbolName,
+              language: matchLanguage
+            });
+            if (matches.length >= limitedTopK) {
+              break;
+            }
+          }
+          return {
+            success: true,
+            query,
+            matches,
+            totalMatches: matches.length,
+            duration: Date.now() - startTime
+          };
+        } finally {
+          await closeVectorClient();
+        }
+      } catch (error) {
+        return {
+          success: false,
+          error: `Semantic search failed: ${error instanceof Error ? error.message : String(error)}`
+        };
+      }
+    }
+  });
+}
+
 // src/tools/index.ts
-function createTools(options) {
-  return {
+async function createTools(options) {
+  const tools = {
     bash: createBashTool({
       workingDirectory: options.workingDirectory,
       sessionId: options.sessionId,
@@ -4056,6 +4169,20 @@ function createTools(options) {
       onProgress: options.onSearchProgress
     })
   };
+  if (options.enableSemanticSearch !== false) {
+    try {
+      if (isVectorGatewayConfigured()) {
+        const hasIndex = await checkIndexExists(options.workingDirectory);
+        if (hasIndex) {
+          tools.semantic_search = createSemanticSearchTool({
+            workingDirectory: options.workingDirectory
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  return tools;
 }
 
 // src/agent/context.ts
@@ -4108,7 +4235,7 @@ async function buildSystemPrompt(options) {
     const skills = await loadAllSkills2(skillsDirectories);
     onDemandSkillsContext = formatSkillsForContext(skills);
   }
-  const todos = todoQueries.getBySession(sessionId);
+  const todos = await todoQueries.getBySession(sessionId);
   const todosContext = formatTodosForContext(todos);
   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" });
@@ -4350,7 +4477,7 @@ var ContextManager = class {
    * Returns ModelMessage[] that can be passed directly to streamText/generateText
    */
   async getMessages() {
-    let modelMessages = messageQueries.getModelMessages(this.sessionId);
+    let modelMessages = await messageQueries.getModelMessages(this.sessionId);
     const contextSize = calculateContextSize(modelMessages);
     if (this.autoSummarize && contextSize > this.maxContextChars) {
       modelMessages = await this.summarizeContext(modelMessages);
@@ -4370,13 +4497,13 @@ ${this.summary}`
   /**
    * Summarize older messages to reduce context size
    */
-  async summarizeContext(messages2) {
-    if (messages2.length <= this.keepRecentMessages) {
-      return messages2;
+  async summarizeContext(messages) {
+    if (messages.length <= this.keepRecentMessages) {
+      return messages;
     }
-    const splitIndex = messages2.length - this.keepRecentMessages;
-    const oldMessages = messages2.slice(0, splitIndex);
-    const recentMessages = messages2.slice(splitIndex);
+    const splitIndex = messages.length - this.keepRecentMessages;
+    const oldMessages = messages.slice(0, splitIndex);
+    const recentMessages = messages.slice(splitIndex);
     const historyText = oldMessages.map((msg) => {
       const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
       return `[${msg.role}]: ${content}`;
@@ -4400,36 +4527,36 @@ ${this.summary}`
    * Add a user message to the context
    * Content can be a string or an array of content parts (for messages with images/files)
    */
-  addUserMessage(content) {
+  async addUserMessage(content) {
     const userMessage = {
       role: "user",
       content
     };
-    messageQueries.create(this.sessionId, userMessage);
+    await messageQueries.create(this.sessionId, userMessage);
   }
   /**
    * Add response messages from AI SDK directly
    * This is the preferred method - use result.response.messages from streamText/generateText
    */
-  addResponseMessages(messages2) {
-    messageQueries.addMany(this.sessionId, messages2);
+  async addResponseMessages(messages) {
+    await messageQueries.addMany(this.sessionId, messages);
   }
   /**
    * Get current context statistics
    */
-  getStats() {
-    const messages2 = messageQueries.getModelMessages(this.sessionId);
+  async getStats() {
+    const messages = await messageQueries.getModelMessages(this.sessionId);
     return {
-      messageCount: messages2.length,
-      contextChars: calculateContextSize(messages2),
+      messageCount: messages.length,
+      contextChars: calculateContextSize(messages),
       hasSummary: this.summary !== null
     };
   }
   /**
    * Clear all messages in the context
    */
-  clear() {
-    messageQueries.deleteBySession(this.sessionId);
+  async clear() {
+    await messageQueries.deleteBySession(this.sessionId);
     this.summary = null;
   }
 };
@@ -4449,7 +4576,7 @@ var Agent = class _Agent {
   /**
    * Create tools with optional progress callbacks
    */
-  createToolsWithCallbacks(options) {
+  async createToolsWithCallbacks(options) {
     const config = getConfig();
     return createTools({
       sessionId: this.session.id,
@@ -4467,13 +4594,13 @@ var Agent = class _Agent {
     const config = getConfig();
     let session;
     if (options.sessionId) {
-      const existing = sessionQueries.getById(options.sessionId);
+      const existing = await sessionQueries.getById(options.sessionId);
       if (!existing) {
         throw new Error(`Session not found: ${options.sessionId}`);
       }
       session = existing;
     } else {
-      session = sessionQueries.create({
+      session = await sessionQueries.create({
         name: options.name,
         workingDirectory: options.workingDirectory || config.resolvedWorkingDirectory,
         model: options.model || config.defaultModel,
@@ -4486,7 +4613,7 @@ var Agent = class _Agent {
       keepRecentMessages: config.context?.keepRecentMessages || 10,
       autoSummarize: config.context?.autoSummarize ?? true
     });
-    const tools = createTools({
+    const tools = await createTools({
       sessionId: session.id,
       workingDirectory: session.workingDirectory,
       skillsDirectories: config.resolvedSkillsDirectories
@@ -4562,7 +4689,7 @@ ${prompt}` });
     if (!options.skipSaveUserMessage) {
       this.context.addUserMessage(userContent);
     }
-    sessionQueries.updateStatus(this.session.id, "active");
+    await sessionQueries.updateStatus(this.session.id, "active");
     const systemPrompt = await buildSystemPrompt({
       workingDirectory: this.session.workingDirectory,
       skillsDirectories: config.resolvedSkillsDirectories,
@@ -4571,14 +4698,14 @@ ${prompt}` });
       // TODO: Pass activeFiles from client for glob matching
       activeFiles: []
     });
-    const messages2 = await this.context.getMessages();
-    const tools = options.onToolProgress ? this.createToolsWithCallbacks({ onToolProgress: options.onToolProgress }) : this.baseTools;
+    const messages = await this.context.getMessages();
+    const tools = options.onToolProgress ? await this.createToolsWithCallbacks({ onToolProgress: options.onToolProgress }) : this.baseTools;
     const wrappedTools = this.wrapToolsWithApproval(options, tools);
     const useAnthropic = isAnthropicModel(this.session.model);
     const stream = streamText2({
       model: resolveModel(this.session.model),
       system: systemPrompt,
-      messages: messages2,
+      messages,
       tools: wrappedTools,
       stopWhen: stepCountIs2(500),
       // Forward abort signal if provided
@@ -4626,14 +4753,14 @@ ${prompt}` });
       discoveredSkills: config.discoveredSkills,
       activeFiles: []
     });
-    const messages2 = await this.context.getMessages();
-    const tools = options.onToolProgress ? this.createToolsWithCallbacks({ onToolProgress: options.onToolProgress }) : this.baseTools;
+    const messages = await this.context.getMessages();
+    const tools = options.onToolProgress ? await this.createToolsWithCallbacks({ onToolProgress: options.onToolProgress }) : this.baseTools;
     const wrappedTools = this.wrapToolsWithApproval(options, tools);
     const useAnthropic = isAnthropicModel(this.session.model);
     const result = await generateText3({
       model: resolveModel(this.session.model),
       system: systemPrompt,
-      messages: messages2,
+      messages,
       tools: wrappedTools,
       stopWhen: stepCountIs2(500),
       // Enable extended thinking/reasoning for models that support it
@@ -4666,11 +4793,11 @@ ${prompt}` });
         wrappedTools[name] = originalTool;
         continue;
       }
-      wrappedTools[name] = tool9({
+      wrappedTools[name] = tool10({
         description: originalTool.description || "",
-        inputSchema: originalTool.inputSchema || z10.object({}),
+        inputSchema: originalTool.inputSchema || z11.object({}),
         execute: async (input, toolOptions) => {
-          const toolCallId = toolOptions.toolCallId || nanoid4();
+          const toolCallId = toolOptions.toolCallId || nanoid3();
           const execution = toolExecutionQueries.create({
             sessionId: this.session.id,
             toolName: name,
@@ -4679,19 +4806,20 @@ ${prompt}` });
             requiresApproval: true,
             status: "pending"
           });
-          this.pendingApprovals.set(toolCallId, execution);
-          options.onApprovalRequired?.(execution);
-          sessionQueries.updateStatus(this.session.id, "waiting");
+          this.pendingApprovals.set(toolCallId, await execution);
+          options.onApprovalRequired?.(await execution);
+          await sessionQueries.updateStatus(this.session.id, "waiting");
           const approved = await new Promise((resolve10) => {
             approvalResolvers.set(toolCallId, { resolve: resolve10, sessionId: this.session.id });
           });
           const resolverData = approvalResolvers.get(toolCallId);
           approvalResolvers.delete(toolCallId);
           this.pendingApprovals.delete(toolCallId);
+          const exec6 = await execution;
           if (!approved) {
             const reason = resolverData?.reason || "User rejected the tool execution";
-            toolExecutionQueries.reject(execution.id);
-            sessionQueries.updateStatus(this.session.id, "active");
+            await toolExecutionQueries.reject(exec6.id);
+            await sessionQueries.updateStatus(this.session.id, "active");
             return {
               status: "rejected",
               toolCallId,
@@ -4700,14 +4828,14 @@ ${prompt}` });
               message: `Tool "${name}" was rejected by the user. Reason: ${reason}`
             };
           }
-          toolExecutionQueries.approve(execution.id);
-          sessionQueries.updateStatus(this.session.id, "active");
+          await toolExecutionQueries.approve(exec6.id);
+          await sessionQueries.updateStatus(this.session.id, "active");
           try {
             const result = await originalTool.execute(input, toolOptions);
-            toolExecutionQueries.complete(execution.id, result);
+            await toolExecutionQueries.complete(exec6.id, result);
             return result;
           } catch (error) {
-            toolExecutionQueries.complete(execution.id, null, error.message);
+            await toolExecutionQueries.complete(exec6.id, null, error.message);
             throw error;
           }
         }
@@ -4730,36 +4858,36 @@ ${prompt}` });
       resolver.resolve(true);
       return { approved: true };
     }
-    const pendingFromDb = toolExecutionQueries.getPendingApprovals(this.session.id);
+    const pendingFromDb = await toolExecutionQueries.getPendingApprovals(this.session.id);
     const execution = pendingFromDb.find((e) => e.toolCallId === toolCallId);
     if (!execution) {
       throw new Error(`No pending approval for tool call: ${toolCallId}`);
     }
-    toolExecutionQueries.approve(execution.id);
+    await toolExecutionQueries.approve(execution.id);
     return { approved: true };
   }
   /**
    * Reject a pending tool execution
    */
-  reject(toolCallId, reason) {
+  async reject(toolCallId, reason) {
     const resolver = approvalResolvers.get(toolCallId);
     if (resolver) {
       resolver.reason = reason;
       resolver.resolve(false);
       return { rejected: true };
     }
-    const pendingFromDb = toolExecutionQueries.getPendingApprovals(this.session.id);
+    const pendingFromDb = await toolExecutionQueries.getPendingApprovals(this.session.id);
     const execution = pendingFromDb.find((e) => e.toolCallId === toolCallId);
     if (!execution) {
       throw new Error(`No pending approval for tool call: ${toolCallId}`);
     }
-    toolExecutionQueries.reject(execution.id);
+    await toolExecutionQueries.reject(execution.id);
     return { rejected: true };
   }
   /**
    * Get pending approvals
    */
-  getPendingApprovals() {
+  async getPendingApprovals() {
     return toolExecutionQueries.getPendingApprovals(this.session.id);
   }
   /**
@@ -4782,8 +4910,8 @@ 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 existsSync13, mkdirSync as mkdirSync5, writeFileSync as writeFileSync4 } from "fs";
-import { resolve as resolve9, dirname as dirname7, join as join7 } from "path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync5, writeFileSync as writeFileSync4 } from "fs";
+import { resolve as resolve9, dirname as dirname7, join as join9 } from "path";
 import { spawn as spawn2 } from "child_process";
 import { createServer as createNetServer } from "net";
 import { fileURLToPath as fileURLToPath3 } from "url";
@@ -4791,35 +4919,35 @@ import { fileURLToPath as fileURLToPath3 } from "url";
 // src/server/routes/sessions.ts
 import { Hono } from "hono";
 import { zValidator } from "@hono/zod-validator";
-import { z as z11 } from "zod";
-import { existsSync as existsSync11, mkdirSync as mkdirSync3, writeFileSync as writeFileSync2, readdirSync, statSync, unlinkSync } from "fs";
+import { z as z12 } from "zod";
+import { existsSync as existsSync12, mkdirSync as mkdirSync3, writeFileSync as writeFileSync2, readdirSync, statSync as statSync2, unlinkSync } from "fs";
 import { readdir as readdir4 } from "fs/promises";
-import { join as join4, basename as basename2, extname as extname6, relative as relative7 } from "path";
-import { nanoid as nanoid5 } from "nanoid";
-var sessions2 = new Hono();
-var createSessionSchema = z11.object({
-  name: z11.string().optional(),
-  workingDirectory: z11.string().optional(),
-  model: z11.string().optional(),
-  toolApprovals: z11.record(z11.string(), z11.boolean()).optional()
+import { join as join6, basename as basename3, extname as extname7, relative as relative8 } from "path";
+import { nanoid as nanoid4 } from "nanoid";
+var sessions = new Hono();
+var createSessionSchema = z12.object({
+  name: z12.string().optional(),
+  workingDirectory: z12.string().optional(),
+  model: z12.string().optional(),
+  toolApprovals: z12.record(z12.string(), z12.boolean()).optional()
 });
-var paginationQuerySchema = z11.object({
-  limit: z11.string().optional(),
-  offset: z11.string().optional()
+var paginationQuerySchema = z12.object({
+  limit: z12.string().optional(),
+  offset: z12.string().optional()
 });
-var messagesQuerySchema = z11.object({
-  limit: z11.string().optional()
+var messagesQuerySchema = z12.object({
+  limit: z12.string().optional()
 });
-sessions2.get(
+sessions.get(
   "/",
   zValidator("query", paginationQuerySchema),
   async (c) => {
     const query = c.req.valid("query");
     const limit = parseInt(query.limit || "50");
     const offset = parseInt(query.offset || "0");
-    const allSessions = sessionQueries.list(limit, offset);
-    const sessionsWithStreamInfo = allSessions.map((s) => {
-      const activeStream = activeStreamQueries.getBySessionId(s.id);
+    const allSessions = await sessionQueries.list(limit, offset);
+    const sessionsWithStreamInfo = await Promise.all(allSessions.map(async (s) => {
+      const activeStream = await activeStreamQueries.getBySessionId(s.id);
       return {
         id: s.id,
         name: s.name,
@@ -4831,7 +4959,7 @@ sessions2.get(
         createdAt: s.createdAt.toISOString(),
         updatedAt: s.updatedAt.toISOString()
       };
-    });
+    }));
     return c.json({
       sessions: sessionsWithStreamInfo,
       count: allSessions.length,
@@ -4840,7 +4968,7 @@ sessions2.get(
     });
   }
 );
-sessions2.post(
+sessions.post(
   "/",
   zValidator("json", createSessionSchema),
   async (c) => {
@@ -4863,9 +4991,9 @@ sessions2.post(
     }, 201);
   }
 );
-sessions2.get("/:id", async (c) => {
+sessions.get("/:id", async (c) => {
   const id = c.req.param("id");
-  const session = sessionQueries.getById(id);
+  const session = await sessionQueries.getById(id);
   if (!session) {
     return c.json({ error: "Session not found" }, 404);
   }
@@ -4873,8 +5001,8 @@ sessions2.get("/:id", async (c) => {
     const agent = await Agent.create({ sessionId: id });
     return agent.getContextStats();
   })();
-  const todos = todoQueries.getBySession(id);
-  const pendingApprovals = toolExecutionQueries.getPendingApprovals(id);
+  const todos = await todoQueries.getBySession(id);
+  const pendingApprovals = await toolExecutionQueries.getPendingApprovals(id);
   return c.json({
     id: session.id,
     name: session.name,
@@ -4899,37 +5027,37 @@ sessions2.get("/:id", async (c) => {
     }))
   });
 });
-sessions2.get(
+sessions.get(
   "/:id/messages",
   zValidator("query", messagesQuerySchema),
   async (c) => {
     const id = c.req.param("id");
     const query = c.req.valid("query");
     const limit = parseInt(query.limit || "100");
-    const session = sessionQueries.getById(id);
+    const session = await sessionQueries.getById(id);
     if (!session) {
       return c.json({ error: "Session not found" }, 404);
     }
-    const messages2 = messageQueries.getRecentBySession(id, limit);
+    const messages = await messageQueries.getRecentBySession(id, limit);
     return c.json({
       sessionId: id,
-      messages: messages2.map((m) => ({
+      messages: messages.map((m) => ({
         id: m.id,
         ...m.modelMessage,
         // Spread the AI SDK ModelMessage (role, content)
         createdAt: m.createdAt.toISOString()
       })),
-      count: messages2.length
+      count: messages.length
     });
   }
 );
-sessions2.get("/:id/tools", async (c) => {
+sessions.get("/:id/tools", async (c) => {
   const id = c.req.param("id");
-  const session = sessionQueries.getById(id);
+  const session = await sessionQueries.getById(id);
   if (!session) {
     return c.json({ error: "Session not found" }, 404);
   }
-  const executions = toolExecutionQueries.getBySession(id);
+  const executions = await toolExecutionQueries.getBySession(id);
   return c.json({
     sessionId: id,
     executions: executions.map((e) => ({
@@ -4947,18 +5075,18 @@ sessions2.get("/:id/tools", async (c) => {
     count: executions.length
   });
 });
-var updateSessionSchema = z11.object({
-  model: z11.string().optional(),
-  name: z11.string().optional(),
-  toolApprovals: z11.record(z11.string(), z11.boolean()).optional()
+var updateSessionSchema = z12.object({
+  model: z12.string().optional(),
+  name: z12.string().optional(),
+  toolApprovals: z12.record(z12.string(), z12.boolean()).optional()
 });
-sessions2.patch(
+sessions.patch(
   "/:id",
   zValidator("json", updateSessionSchema),
   async (c) => {
     const id = c.req.param("id");
     const body = c.req.valid("json");
-    const session = sessionQueries.getById(id);
+    const session = await sessionQueries.getById(id);
     if (!session) {
       return c.json({ error: "Session not found" }, 404);
     }
@@ -4976,7 +5104,7 @@ sessions2.patch(
         }
       };
     }
-    const updatedSession = Object.keys(updates).length > 0 ? sessionQueries.update(id, updates) || session : session;
+    const updatedSession = Object.keys(updates).length > 0 ? await sessionQueries.update(id, updates) || session : session;
     return c.json({
       id: updatedSession.id,
       name: updatedSession.name,
@@ -4988,10 +5116,10 @@ sessions2.patch(
     });
   }
 );
-sessions2.delete("/:id", async (c) => {
+sessions.delete("/:id", async (c) => {
   const id = c.req.param("id");
   try {
-    const session = sessionQueries.getById(id);
+    const session = await sessionQueries.getById(id);
     if (session) {
       const terminalIds = await listSessions();
       for (const tid of terminalIds) {
@@ -5004,29 +5132,29 @@ sessions2.delete("/:id", async (c) => {
   } catch (e) {
   }
   clearCheckpointManager(id);
-  const deleted = sessionQueries.delete(id);
+  const deleted = await sessionQueries.delete(id);
   if (!deleted) {
     return c.json({ error: "Session not found" }, 404);
   }
   return c.json({ success: true, id });
 });
-sessions2.post("/:id/clear", async (c) => {
+sessions.post("/:id/clear", async (c) => {
   const id = c.req.param("id");
-  const session = sessionQueries.getById(id);
+  const session = await sessionQueries.getById(id);
   if (!session) {
     return c.json({ error: "Session not found" }, 404);
   }
   const agent = await Agent.create({ sessionId: id });
-  agent.clearContext();
+  await agent.clearContext();
   return c.json({ success: true, sessionId: id });
 });
-sessions2.get("/:id/todos", async (c) => {
+sessions.get("/:id/todos", async (c) => {
   const id = c.req.param("id");
-  const session = sessionQueries.getById(id);
+  const session = await sessionQueries.getById(id);
   if (!session) {
     return c.json({ error: "Session not found" }, 404);
   }
-  const todos = todoQueries.getBySession(id);
+  const todos = await 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");
@@ -5055,32 +5183,32 @@ sessions2.get("/:id/todos", async (c) => {
     } : null
   });
 });
-sessions2.get("/:id/checkpoints", async (c) => {
+sessions.get("/:id/checkpoints", async (c) => {
   const id = c.req.param("id");
-  const session = sessionQueries.getById(id);
+  const session = await sessionQueries.getById(id);
   if (!session) {
     return c.json({ error: "Session not found" }, 404);
   }
-  const checkpoints2 = getCheckpoints(id);
+  const checkpoints = await getCheckpoints(id);
   return c.json({
     sessionId: id,
-    checkpoints: checkpoints2.map((cp) => ({
+    checkpoints: checkpoints.map((cp) => ({
       id: cp.id,
       messageSequence: cp.messageSequence,
       gitHead: cp.gitHead,
       createdAt: cp.createdAt.toISOString()
     })),
-    count: checkpoints2.length
+    count: checkpoints.length
   });
 });
-sessions2.post("/:id/revert/:checkpointId", async (c) => {
+sessions.post("/:id/revert/:checkpointId", async (c) => {
   const sessionId = c.req.param("id");
   const checkpointId = c.req.param("checkpointId");
-  const session = sessionQueries.getById(sessionId);
+  const session = await sessionQueries.getById(sessionId);
   if (!session) {
     return c.json({ error: "Session not found" }, 404);
   }
-  const activeStream = activeStreamQueries.getBySessionId(sessionId);
+  const activeStream = await activeStreamQueries.getBySessionId(sessionId);
   if (activeStream) {
     return c.json({
       error: "Cannot revert while a stream is active. Stop the stream first.",
@@ -5101,9 +5229,9 @@ sessions2.post("/:id/revert/:checkpointId", async (c) => {
     checkpointsDeleted: result.checkpointsDeleted
   });
 });
-sessions2.get("/:id/diff", async (c) => {
+sessions.get("/:id/diff", async (c) => {
   const id = c.req.param("id");
-  const session = sessionQueries.getById(id);
+  const session = await sessionQueries.getById(id);
   if (!session) {
     return c.json({ error: "Session not found" }, 404);
   }
@@ -5127,10 +5255,10 @@ sessions2.get("/:id/diff", async (c) => {
     }
   });
 });
-sessions2.get("/:id/diff/:filePath", async (c) => {
+sessions.get("/:id/diff/:filePath", async (c) => {
   const sessionId = c.req.param("id");
   const filePath = decodeURIComponent(c.req.param("filePath"));
-  const session = sessionQueries.getById(sessionId);
+  const session = await sessionQueries.getById(sessionId);
   if (!session) {
     return c.json({ error: "Session not found" }, 404);
   }
@@ -5149,29 +5277,29 @@ sessions2.get("/:id/diff/:filePath", async (c) => {
 });
 function getAttachmentsDir(sessionId) {
   const appDataDir = getAppDataDirectory();
-  return join4(appDataDir, "attachments", sessionId);
+  return join6(appDataDir, "attachments", sessionId);
 }
 function ensureAttachmentsDir(sessionId) {
   const dir = getAttachmentsDir(sessionId);
-  if (!existsSync11(dir)) {
+  if (!existsSync12(dir)) {
     mkdirSync3(dir, { recursive: true });
   }
   return dir;
 }
-sessions2.get("/:id/attachments", async (c) => {
+sessions.get("/:id/attachments", async (c) => {
   const sessionId = c.req.param("id");
-  const session = sessionQueries.getById(sessionId);
+  const session = await sessionQueries.getById(sessionId);
   if (!session) {
     return c.json({ error: "Session not found" }, 404);
   }
   const dir = getAttachmentsDir(sessionId);
-  if (!existsSync11(dir)) {
+  if (!existsSync12(dir)) {
     return c.json({ sessionId, attachments: [], count: 0 });
   }
   const files = readdirSync(dir);
   const attachments = files.map((filename) => {
-    const filePath = join4(dir, filename);
-    const stats = statSync(filePath);
+    const filePath = join6(dir, filename);
+    const stats = statSync2(filePath);
     return {
       id: filename.split("_")[0],
       // Extract the nanoid prefix
@@ -5187,9 +5315,9 @@ sessions2.get("/:id/attachments", async (c) => {
     count: attachments.length
   });
 });
-sessions2.post("/:id/attachments", async (c) => {
+sessions.post("/:id/attachments", async (c) => {
   const sessionId = c.req.param("id");
-  const session = sessionQueries.getById(sessionId);
+  const session = await sessionQueries.getById(sessionId);
   if (!session) {
     return c.json({ error: "Session not found" }, 404);
   }
@@ -5202,10 +5330,10 @@ sessions2.post("/:id/attachments", async (c) => {
         return c.json({ error: "No file provided" }, 400);
       }
       const dir = ensureAttachmentsDir(sessionId);
-      const id = nanoid5(10);
-      const ext = extname6(file.name) || "";
-      const safeFilename = `${id}_${basename2(file.name).replace(/[^a-zA-Z0-9._-]/g, "_")}`;
-      const filePath = join4(dir, safeFilename);
+      const id = nanoid4(10);
+      const ext = extname7(file.name) || "";
+      const safeFilename = `${id}_${basename3(file.name).replace(/[^a-zA-Z0-9._-]/g, "_")}`;
+      const filePath = join6(dir, safeFilename);
       const arrayBuffer = await file.arrayBuffer();
       writeFileSync2(filePath, Buffer.from(arrayBuffer));
       return c.json({
@@ -5228,10 +5356,10 @@ sessions2.post("/:id/attachments", async (c) => {
       return c.json({ error: "Missing filename or data" }, 400);
     }
     const dir = ensureAttachmentsDir(sessionId);
-    const id = nanoid5(10);
-    const ext = extname6(body.filename) || "";
-    const safeFilename = `${id}_${basename2(body.filename).replace(/[^a-zA-Z0-9._-]/g, "_")}`;
-    const filePath = join4(dir, safeFilename);
+    const id = nanoid4(10);
+    const ext = extname7(body.filename) || "";
+    const safeFilename = `${id}_${basename3(body.filename).replace(/[^a-zA-Z0-9._-]/g, "_")}`;
+    const filePath = join6(dir, safeFilename);
     let base64Data = body.data;
     if (base64Data.includes(",")) {
       base64Data = base64Data.split(",")[1];
@@ -5252,15 +5380,15 @@ sessions2.post("/:id/attachments", async (c) => {
     return c.json({ error: "Failed to upload file" }, 500);
   }
 });
-sessions2.delete("/:id/attachments/:attachmentId", async (c) => {
+sessions.delete("/:id/attachments/:attachmentId", async (c) => {
   const sessionId = c.req.param("id");
   const attachmentId = c.req.param("attachmentId");
-  const session = sessionQueries.getById(sessionId);
+  const session = await sessionQueries.getById(sessionId);
   if (!session) {
     return c.json({ error: "Session not found" }, 404);
   }
   const dir = getAttachmentsDir(sessionId);
-  if (!existsSync11(dir)) {
+  if (!existsSync12(dir)) {
     return c.json({ error: "Attachment not found" }, 404);
   }
   const files = readdirSync(dir);
@@ -5268,14 +5396,14 @@ sessions2.delete("/:id/attachments/:attachmentId", async (c) => {
   if (!file) {
     return c.json({ error: "Attachment not found" }, 404);
   }
-  const filePath = join4(dir, file);
+  const filePath = join6(dir, file);
   unlinkSync(filePath);
   return c.json({ success: true, id: attachmentId });
 });
-var filesQuerySchema = z11.object({
-  query: z11.string().optional(),
+var filesQuerySchema = z12.object({
+  query: z12.string().optional(),
   // Filter query (e.g., "src/com" to match "src/components")
-  limit: z11.string().optional()
+  limit: z12.string().optional()
   // Max results (default 50)
 });
 var IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
@@ -5351,15 +5479,15 @@ async function listWorkspaceFiles(baseDir, currentDir, query, limit, results = [
     const entries = await readdir4(currentDir, { withFileTypes: true });
     for (const entry of entries) {
       if (results.length >= limit * 2) break;
-      const fullPath = join4(currentDir, entry.name);
-      const relativePath = relative7(baseDir, fullPath);
+      const fullPath = join6(currentDir, entry.name);
+      const relativePath = relative8(baseDir, fullPath);
       if (entry.isDirectory() && IGNORED_DIRECTORIES.has(entry.name)) {
         continue;
       }
       if (entry.name.startsWith(".")) {
         continue;
       }
-      const ext = extname6(entry.name).toLowerCase();
+      const ext = extname7(entry.name).toLowerCase();
       if (IGNORED_EXTENSIONS.has(ext)) {
         continue;
       }
@@ -5387,19 +5515,19 @@ async function listWorkspaceFiles(baseDir, currentDir, query, limit, results = [
   }
   return results;
 }
-sessions2.get(
+sessions.get(
   "/:id/files",
   zValidator("query", filesQuerySchema),
   async (c) => {
     const sessionId = c.req.param("id");
     const { query = "", limit: limitStr = "50" } = c.req.valid("query");
     const limit = Math.min(parseInt(limitStr) || 50, 100);
-    const session = sessionQueries.getById(sessionId);
+    const session = await sessionQueries.getById(sessionId);
     if (!session) {
       return c.json({ error: "Session not found" }, 404);
     }
     const workingDirectory = session.workingDirectory;
-    if (!existsSync11(workingDirectory)) {
+    if (!existsSync12(workingDirectory)) {
       return c.json({
         sessionId,
         workingDirectory,
@@ -5452,9 +5580,9 @@ sessions2.get(
 // src/server/routes/agents.ts
 import { Hono as Hono2 } from "hono";
 import { zValidator as zValidator2 } from "@hono/zod-validator";
-import { z as z12 } from "zod";
-import { existsSync as existsSync12, mkdirSync as mkdirSync4, writeFileSync as writeFileSync3 } from "fs";
-import { join as join5 } from "path";
+import { z as z13 } from "zod";
+import { existsSync as existsSync13, mkdirSync as mkdirSync4, writeFileSync as writeFileSync3 } from "fs";
+import { join as join7 } from "path";
 
 // src/server/resumable-stream.ts
 import { createResumableStreamContext } from "resumable-stream/generic";
@@ -5529,7 +5657,7 @@ var streamContext = createResumableStreamContext({
 });
 
 // src/server/routes/agents.ts
-import { nanoid as nanoid6 } from "nanoid";
+import { nanoid as nanoid5 } from "nanoid";
 var MAX_TOOL_INPUT_LENGTH = 8 * 1024;
 var MAX_TOOL_INPUT_PREVIEW = 2 * 1024;
 var MAX_TOOL_ARGS_CHUNK = 2 * 1024;
@@ -5597,39 +5725,39 @@ async function emitSyntheticToolStreaming(writeSSE, toolCallStarts, toolCallId,
   }
 }
 var agents = new Hono2();
-var attachmentSchema = z12.object({
-  type: z12.enum(["image", "file"]),
-  data: z12.string(),
+var attachmentSchema = z13.object({
+  type: z13.enum(["image", "file"]),
+  data: z13.string(),
   // base64 data URL or raw base64
-  mediaType: z12.string().optional(),
-  filename: z12.string().optional()
+  mediaType: z13.string().optional(),
+  filename: z13.string().optional()
 });
-var runPromptSchema = z12.object({
-  prompt: z12.string(),
+var runPromptSchema = z13.object({
+  prompt: z13.string(),
   // Can be empty if attachments are provided
-  attachments: z12.array(attachmentSchema).optional()
+  attachments: z13.array(attachmentSchema).optional()
 }).refine(
   (data) => data.prompt.trim().length > 0 || data.attachments && data.attachments.length > 0,
   { message: "Either prompt or attachments must be provided" }
 );
-var quickStartSchema = z12.object({
-  prompt: z12.string().min(1),
-  name: z12.string().optional(),
-  workingDirectory: z12.string().optional(),
-  model: z12.string().optional(),
-  toolApprovals: z12.record(z12.string(), z12.boolean()).optional()
+var quickStartSchema = z13.object({
+  prompt: z13.string().min(1),
+  name: z13.string().optional(),
+  workingDirectory: z13.string().optional(),
+  model: z13.string().optional(),
+  toolApprovals: z13.record(z13.string(), z13.boolean()).optional()
 });
-var rejectSchema = z12.object({
-  reason: z12.string().optional()
+var rejectSchema = z13.object({
+  reason: z13.string().optional()
 }).optional();
 var streamAbortControllers = /* @__PURE__ */ new Map();
 function getAttachmentsDirectory(sessionId) {
   const appDataDir = getAppDataDirectory();
-  return join5(appDataDir, "attachments", sessionId);
+  return join7(appDataDir, "attachments", sessionId);
 }
 function saveAttachmentToDisk(sessionId, attachment, index) {
   const attachmentsDir = getAttachmentsDirectory(sessionId);
-  if (!existsSync12(attachmentsDir)) {
+  if (!existsSync13(attachmentsDir)) {
     mkdirSync4(attachmentsDir, { recursive: true });
   }
   let filename = attachment.filename;
@@ -5641,7 +5769,7 @@ function saveAttachmentToDisk(sessionId, attachment, index) {
   if (base64Data.includes(",")) {
     base64Data = base64Data.split(",")[1];
   }
-  const filePath = join5(attachmentsDir, filename);
+  const filePath = join7(attachmentsDir, filename);
   const buffer = Buffer.from(base64Data, "base64");
   writeFileSync3(filePath, buffer);
   return filePath;
@@ -5903,7 +6031,7 @@ ${prompt}` });
           await writeSSE(JSON.stringify({ type: "finish" }));
         }
         try {
-          activeStreamQueries.finish(streamId);
+          await activeStreamQueries.finish(streamId);
         } catch {
         }
       } catch (error) {
@@ -5913,7 +6041,7 @@ ${prompt}` });
           console.error("Agent error:", error);
           await writeSSE(JSON.stringify({ type: "error", errorText: error.message }));
           try {
-            activeStreamQueries.markError(streamId);
+            await activeStreamQueries.markError(streamId);
           } catch {
           }
         }
@@ -5932,11 +6060,11 @@ agents.post(
   async (c) => {
     const id = c.req.param("id");
     const { prompt, attachments } = c.req.valid("json");
-    const session = sessionQueries.getById(id);
+    const session = await sessionQueries.getById(id);
     if (!session) {
       return c.json({ error: "Session not found" }, 404);
     }
-    const nextSequence = messageQueries.getNextSequence(id);
+    const nextSequence = await messageQueries.getNextSequence(id);
     await createCheckpoint(id, session.workingDirectory, nextSequence);
     let userMessageContent;
     const streamAttachments = attachments;
@@ -5993,9 +6121,9 @@ ${prompt}` });
     } else {
       userMessageContent = prompt;
     }
-    messageQueries.create(id, { role: "user", content: userMessageContent });
-    const streamId = `stream_${id}_${nanoid6(10)}`;
-    activeStreamQueries.create(id, streamId);
+    await messageQueries.create(id, { role: "user", content: userMessageContent });
+    const streamId = `stream_${id}_${nanoid5(10)}`;
+    await activeStreamQueries.create(id, streamId);
     const stream = await streamContext.resumableStream(
       streamId,
       createAgentStreamProducer(id, prompt, streamId, streamAttachments)
@@ -6019,13 +6147,13 @@ 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);
+  const session = await sessionQueries.getById(sessionId);
   if (!session) {
     return c.json({ error: "Session not found" }, 404);
   }
   let streamId = explicitStreamId;
   if (!streamId) {
-    const activeStream = activeStreamQueries.getBySessionId(sessionId);
+    const activeStream = await 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);
     }
@@ -6055,11 +6183,11 @@ agents.get("/:id/watch", async (c) => {
 });
 agents.get("/:id/stream", async (c) => {
   const sessionId = c.req.param("id");
-  const session = sessionQueries.getById(sessionId);
+  const session = await sessionQueries.getById(sessionId);
   if (!session) {
     return c.json({ error: "Session not found" }, 404);
   }
-  const activeStream = activeStreamQueries.getBySessionId(sessionId);
+  const activeStream = await activeStreamQueries.getBySessionId(sessionId);
   return c.json({
     sessionId,
     hasActiveStream: !!activeStream,
@@ -6077,7 +6205,7 @@ agents.post(
   async (c) => {
     const id = c.req.param("id");
     const { prompt } = c.req.valid("json");
-    const session = sessionQueries.getById(id);
+    const session = await sessionQueries.getById(id);
     if (!session) {
       return c.json({ error: "Session not found" }, 404);
     }
@@ -6097,7 +6225,7 @@ agents.post(
 agents.post("/:id/approve/:toolCallId", async (c) => {
   const sessionId = c.req.param("id");
   const toolCallId = c.req.param("toolCallId");
-  const session = sessionQueries.getById(sessionId);
+  const session = await sessionQueries.getById(sessionId);
   if (!session) {
     return c.json({ error: "Session not found" }, 404);
   }
@@ -6120,7 +6248,7 @@ agents.post(
     const sessionId = c.req.param("id");
     const toolCallId = c.req.param("toolCallId");
     const body = c.req.valid("json");
-    const session = sessionQueries.getById(sessionId);
+    const session = await sessionQueries.getById(sessionId);
     if (!session) {
       return c.json({ error: "Session not found" }, 404);
     }
@@ -6139,11 +6267,11 @@ agents.post(
 );
 agents.get("/:id/approvals", async (c) => {
   const sessionId = c.req.param("id");
-  const session = sessionQueries.getById(sessionId);
+  const session = await sessionQueries.getById(sessionId);
   if (!session) {
     return c.json({ error: "Session not found" }, 404);
   }
-  const pendingApprovals = toolExecutionQueries.getPendingApprovals(sessionId);
+  const pendingApprovals = await toolExecutionQueries.getPendingApprovals(sessionId);
   return c.json({
     sessionId,
     pendingApprovals: pendingApprovals.map((p) => ({
@@ -6158,11 +6286,11 @@ agents.get("/:id/approvals", async (c) => {
 });
 agents.post("/:id/abort", async (c) => {
   const sessionId = c.req.param("id");
-  const session = sessionQueries.getById(sessionId);
+  const session = await sessionQueries.getById(sessionId);
   if (!session) {
     return c.json({ error: "Session not found" }, 404);
   }
-  const activeStream = activeStreamQueries.getBySessionId(sessionId);
+  const activeStream = await activeStreamQueries.getBySessionId(sessionId);
   if (!activeStream) {
     return c.json({ error: "No active stream for this session" }, 404);
   }
@@ -6191,9 +6319,9 @@ agents.post(
       sessionConfig: body.toolApprovals ? { toolApprovals: body.toolApprovals } : void 0
     });
     const session = agent.getSession();
-    const streamId = `stream_${session.id}_${nanoid6(10)}`;
+    const streamId = `stream_${session.id}_${nanoid5(10)}`;
     await createCheckpoint(session.id, session.workingDirectory, 0);
-    activeStreamQueries.create(session.id, streamId);
+    await activeStreamQueries.create(session.id, streamId);
     const createQuickStreamProducer = () => {
       const { readable, writable } = new TransformStream();
       const writer = writable.getWriter();
@@ -6363,14 +6491,14 @@ agents.post(
           } else {
             await writeSSE(JSON.stringify({ type: "finish" }));
           }
-          activeStreamQueries.finish(streamId);
+          await 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);
+            await activeStreamQueries.markError(streamId);
           }
         } finally {
           cleanupAbortController();
@@ -6404,23 +6532,23 @@ agents.post(
 // src/server/routes/health.ts
 import { Hono as Hono3 } from "hono";
 import { zValidator as zValidator3 } from "@hono/zod-validator";
-import { z as z13 } from "zod";
-import { readFileSync as readFileSync3 } from "fs";
+import { z as z14 } from "zod";
+import { readFileSync as readFileSync5 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname6, join as join6 } from "path";
+import { dirname as dirname6, join as join8 } from "path";
 var __filename = fileURLToPath2(import.meta.url);
 var __dirname = dirname6(__filename);
 var possiblePaths = [
-  join6(__dirname, "../../package.json"),
+  join8(__dirname, "../../package.json"),
   // From dist/server (bundled)
-  join6(__dirname, "../../../package.json")
+  join8(__dirname, "../../../package.json")
   // From dist/server/routes or src/server/routes
 ];
 var currentVersion = "0.0.0";
 var packageName = "sparkecoder";
 for (const packageJsonPath of possiblePaths) {
   try {
-    const packageJson = JSON.parse(readFileSync3(packageJsonPath, "utf-8"));
+    const packageJson = JSON.parse(readFileSync5(packageJsonPath, "utf-8"));
     if (packageJson.name === "sparkecoder" || packageJson.name?.startsWith("sparkecoder")) {
       currentVersion = packageJson.version || "0.0.0";
       packageName = packageJson.name || "sparkecoder";
@@ -6510,9 +6638,9 @@ health.get("/api-keys", async (c) => {
     supportedProviders: SUPPORTED_PROVIDERS
   });
 });
-var setApiKeySchema = z13.object({
-  provider: z13.string(),
-  apiKey: z13.string().min(1)
+var setApiKeySchema = z14.object({
+  provider: z14.string(),
+  apiKey: z14.string().min(1)
 });
 health.post(
   "/api-keys",
@@ -6551,20 +6679,20 @@ health.delete("/api-keys/:provider", async (c) => {
 // src/server/routes/terminals.ts
 import { Hono as Hono4 } from "hono";
 import { zValidator as zValidator4 } from "@hono/zod-validator";
-import { z as z14 } from "zod";
-var terminals2 = new Hono4();
-var spawnSchema = z14.object({
-  command: z14.string(),
-  cwd: z14.string().optional(),
-  name: z14.string().optional()
+import { z as z15 } from "zod";
+var terminals = new Hono4();
+var spawnSchema = z15.object({
+  command: z15.string(),
+  cwd: z15.string().optional(),
+  name: z15.string().optional()
 });
-terminals2.post(
+terminals.post(
   "/:sessionId/terminals",
   zValidator4("json", spawnSchema),
   async (c) => {
     const sessionId = c.req.param("sessionId");
     const body = c.req.valid("json");
-    const session = sessionQueries.getById(sessionId);
+    const session = await sessionQueries.getById(sessionId);
     if (!session) {
       return c.json({ error: "Session not found" }, 404);
     }
@@ -6588,9 +6716,9 @@ terminals2.post(
     }, 201);
   }
 );
-terminals2.get("/:sessionId/terminals", async (c) => {
+terminals.get("/:sessionId/terminals", async (c) => {
   const sessionId = c.req.param("sessionId");
-  const session = sessionQueries.getById(sessionId);
+  const session = await sessionQueries.getById(sessionId);
   if (!session) {
     return c.json({ error: "Session not found" }, 404);
   }
@@ -6615,10 +6743,10 @@ terminals2.get("/:sessionId/terminals", async (c) => {
     running: terminalList.filter((t) => t.status === "running").length
   });
 });
-terminals2.get("/:sessionId/terminals/:terminalId", async (c) => {
+terminals.get("/:sessionId/terminals/:terminalId", async (c) => {
   const sessionId = c.req.param("sessionId");
   const terminalId = c.req.param("terminalId");
-  const session = sessionQueries.getById(sessionId);
+  const session = await sessionQueries.getById(sessionId);
   if (!session) {
     return c.json({ error: "Session not found" }, 404);
   }
@@ -6637,17 +6765,17 @@ terminals2.get("/:sessionId/terminals/:terminalId", async (c) => {
     // We don't track exit codes in tmux mode
   });
 });
-var logsQuerySchema = z14.object({
-  tail: z14.string().optional().transform((v) => v ? parseInt(v, 10) : void 0)
+var logsQuerySchema = z15.object({
+  tail: z15.string().optional().transform((v) => v ? parseInt(v, 10) : void 0)
 });
-terminals2.get(
+terminals.get(
   "/:sessionId/terminals/:terminalId/logs",
   zValidator4("query", logsQuerySchema),
   async (c) => {
     const sessionId = c.req.param("sessionId");
     const terminalId = c.req.param("terminalId");
     const query = c.req.valid("query");
-    const session = sessionQueries.getById(sessionId);
+    const session = await sessionQueries.getById(sessionId);
     if (!session) {
       return c.json({ error: "Session not found" }, 404);
     }
@@ -6662,10 +6790,10 @@ terminals2.get(
     });
   }
 );
-var killSchema = z14.object({
-  signal: z14.enum(["SIGTERM", "SIGKILL"]).optional()
+var killSchema = z15.object({
+  signal: z15.enum(["SIGTERM", "SIGKILL"]).optional()
 });
-terminals2.post(
+terminals.post(
   "/:sessionId/terminals/:terminalId/kill",
   zValidator4("json", killSchema.optional()),
   async (c) => {
@@ -6677,10 +6805,10 @@ terminals2.post(
     return c.json({ success: true, message: "Terminal killed" });
   }
 );
-var writeSchema = z14.object({
-  input: z14.string()
+var writeSchema = z15.object({
+  input: z15.string()
 });
-terminals2.post(
+terminals.post(
   "/:sessionId/terminals/:terminalId/write",
   zValidator4("json", writeSchema),
   async (c) => {
@@ -6697,9 +6825,9 @@ terminals2.post(
     return c.json({ success: true, written: body.input.length });
   }
 );
-terminals2.post("/:sessionId/terminals/kill-all", async (c) => {
+terminals.post("/:sessionId/terminals/kill-all", async (c) => {
   const sessionId = c.req.param("sessionId");
-  const session = sessionQueries.getById(sessionId);
+  const session = await sessionQueries.getById(sessionId);
   if (!session) {
     return c.json({ error: "Session not found" }, 404);
   }
@@ -6714,13 +6842,13 @@ terminals2.post("/:sessionId/terminals/kill-all", async (c) => {
   }
   return c.json({ success: true, killed });
 });
-terminals2.get("/stream/:terminalId", async (c) => {
+terminals.get("/stream/:terminalId", async (c) => {
   const terminalId = c.req.param("terminalId");
-  const sessions3 = sessionQueries.list();
+  const sessions2 = await sessionQueries.list();
   let terminalMeta = null;
   let workingDirectory = process.cwd();
   let foundSessionId;
-  for (const session of sessions3) {
+  for (const session of sessions2) {
     terminalMeta = await getMeta(terminalId, session.workingDirectory, session.id);
     if (terminalMeta) {
       workingDirectory = session.workingDirectory;
@@ -6729,7 +6857,7 @@ terminals2.get("/stream/:terminalId", async (c) => {
     }
   }
   if (!terminalMeta) {
-    for (const session of sessions3) {
+    for (const session of sessions2) {
       terminalMeta = await getMeta(terminalId, session.workingDirectory);
       if (terminalMeta) {
         workingDirectory = session.workingDirectory;
@@ -6799,10 +6927,10 @@ data: ${JSON.stringify({ status: "stopped" })}
     }
   );
 });
-terminals2.get("/:sessionId/terminals/:terminalId/stream", async (c) => {
+terminals.get("/:sessionId/terminals/:terminalId/stream", async (c) => {
   const sessionId = c.req.param("sessionId");
   const terminalId = c.req.param("terminalId");
-  const session = sessionQueries.getById(sessionId);
+  const session = await sessionQueries.getById(sessionId);
   if (!session) {
     return c.json({ error: "Session not found" }, 404);
   }
@@ -6945,11 +7073,11 @@ function getWebDirectory() {
   try {
     const currentDir = dirname7(fileURLToPath3(import.meta.url));
     const webDir = resolve9(currentDir, "..", "web");
-    if (existsSync13(webDir) && existsSync13(join7(webDir, "package.json"))) {
+    if (existsSync14(webDir) && existsSync14(join9(webDir, "package.json"))) {
       return webDir;
     }
     const altWebDir = resolve9(currentDir, "..", "..", "web");
-    if (existsSync13(altWebDir) && existsSync13(join7(altWebDir, "package.json"))) {
+    if (existsSync14(altWebDir) && existsSync14(join9(altWebDir, "package.json"))) {
       return altWebDir;
     }
     return null;
@@ -7007,23 +7135,23 @@ async function findWebPort(preferredPort) {
   return { port: preferredPort, alreadyRunning: false };
 }
 function hasProductionBuild(webDir) {
-  const buildIdPath = join7(webDir, ".next", "BUILD_ID");
-  return existsSync13(buildIdPath);
+  const buildIdPath = join9(webDir, ".next", "BUILD_ID");
+  return existsSync14(buildIdPath);
 }
 function hasSourceFiles(webDir) {
-  const appDir = join7(webDir, "src", "app");
-  const pagesDir = join7(webDir, "src", "pages");
-  const rootAppDir = join7(webDir, "app");
-  const rootPagesDir = join7(webDir, "pages");
-  return existsSync13(appDir) || existsSync13(pagesDir) || existsSync13(rootAppDir) || existsSync13(rootPagesDir);
+  const appDir = join9(webDir, "src", "app");
+  const pagesDir = join9(webDir, "src", "pages");
+  const rootAppDir = join9(webDir, "app");
+  const rootPagesDir = join9(webDir, "pages");
+  return existsSync14(appDir) || existsSync14(pagesDir) || existsSync14(rootAppDir) || existsSync14(rootPagesDir);
 }
 function getStandaloneServerPath(webDir) {
   const possiblePaths2 = [
-    join7(webDir, ".next", "standalone", "server.js"),
-    join7(webDir, ".next", "standalone", "web", "server.js")
+    join9(webDir, ".next", "standalone", "server.js"),
+    join9(webDir, ".next", "standalone", "web", "server.js")
   ];
   for (const serverPath of possiblePaths2) {
-    if (existsSync13(serverPath)) {
+    if (existsSync14(serverPath)) {
       return serverPath;
     }
   }
@@ -7063,13 +7191,13 @@ async function startWebUI(apiPort, webPort = DEFAULT_WEB_PORT, quiet = false, pu
     if (!quiet) console.log(`  \u2713 Web UI already running at http://localhost:${actualPort}`);
     return { process: null, port: actualPort };
   }
-  const usePnpm = existsSync13(join7(webDir, "pnpm-lock.yaml"));
-  const useNpm = !usePnpm && existsSync13(join7(webDir, "package-lock.json"));
+  const usePnpm = existsSync14(join9(webDir, "pnpm-lock.yaml"));
+  const useNpm = !usePnpm && existsSync14(join9(webDir, "package-lock.json"));
   const pkgManager = usePnpm ? "pnpm" : useNpm ? "npm" : "npx";
   const { NODE_OPTIONS, TSX_TSCONFIG_PATH, ...cleanEnv } = process.env;
   const apiUrl = publicUrl || `http://127.0.0.1:${apiPort}`;
   const runtimeConfig = { apiBaseUrl: apiUrl };
-  const runtimeConfigPath = join7(webDir, "runtime-config.json");
+  const runtimeConfigPath = join9(webDir, "runtime-config.json");
   try {
     writeFileSync4(runtimeConfigPath, JSON.stringify(runtimeConfig, null, 2));
     if (!quiet) console.log(`  \u{1F4DD} Runtime config written to ${runtimeConfigPath}`);
@@ -7205,10 +7333,10 @@ async function createApp(options = {}) {
     app.use("*", logger());
   }
   app.route("/health", health);
-  app.route("/sessions", sessions2);
+  app.route("/sessions", sessions);
   app.route("/agents", agents);
-  app.route("/sessions", terminals2);
-  app.route("/terminals", terminals2);
+  app.route("/sessions", terminals);
+  app.route("/terminals", terminals);
   app.get("/openapi.json", async (c) => {
     return c.json(generateOpenAPISpec());
   });
@@ -7261,11 +7389,21 @@ async function startServer(options = {}) {
   if (options.workingDirectory) {
     config.resolvedWorkingDirectory = options.workingDirectory;
   }
-  if (!existsSync13(config.resolvedWorkingDirectory)) {
+  if (!existsSync14(config.resolvedWorkingDirectory)) {
     mkdirSync5(config.resolvedWorkingDirectory, { recursive: true });
     if (!options.quiet) console.log(`\u{1F4C1} Created agent workspace: ${config.resolvedWorkingDirectory}`);
   }
-  initDatabase(config.resolvedDatabasePath);
+  if (!config.resolvedRemoteServer.url) {
+    throw new Error("Remote server not configured. Set REMOTE_SERVER_URL environment variable or remoteServer.url in config");
+  }
+  let authKey3 = config.resolvedRemoteServer.authKey;
+  if (!authKey3) {
+    if (!options.quiet) console.log("\u{1F4E1} Registering with remote server...");
+    authKey3 = await ensureRemoteAuthKey(config.resolvedRemoteServer.url);
+    if (!options.quiet) console.log("\u2713 Registered with remote server");
+  }
+  initDatabase({ url: config.resolvedRemoteServer.url, authKey: authKey3 });
+  if (!options.quiet) console.log(`\u{1F4E1} Using remote database: ${config.resolvedRemoteServer.url}`);
   const port = options.port || config.server.port;
   const host = options.host || config.server.host || "0.0.0.0";
   const publicUrl = options.publicUrl || config.server.publicUrl;
@@ -7298,8 +7436,8 @@ async function startServer(options = {}) {
 }
 function stopServer() {
   stopWebUI();
-  listSessions().then(async (sessions3) => {
-    for (const id of sessions3) {
+  listSessions().then(async (sessions2) => {
+    for (const id of sessions2) {
       await killTerminal(id);
     }
   }).catch(() => {