sparkecoder 0.1.24 → 0.1.26

package/dist/agent/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,498 +471,278 @@ 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
-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" })
-});
+import { z as z11 } from "zod";
+import { nanoid as nanoid3 } from "nanoid";
 
-// src/db/index.ts
-var db = null;
-function getDb() {
-  if (!db) {
-    throw new Error("Database not initialized. Call initDatabase first.");
+// src/db/remote.ts
+var remoteServerUrl = null;
+var authKey = 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 db;
+  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 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 getDb() {
+  if (!initialized) {
+    throw new Error("Database not initialized. Call initDatabase first.");
+  }
+  return {};
+}
+var sessionQueries = remoteSessionQueries;
+var messageQueries = remoteMessageQueries;
+var toolExecutionQueries = remoteToolExecutionQueries;
+var todoQueries = remoteTodoQueries;
+var skillQueries = remoteSkillQueries;
+var fileBackupQueries = remoteFileBackupQueries;
+var subagentQueries = remoteSubagentQueries;
+var indexStatusQueries = remoteIndexStatusQueries;
+
 // src/config/index.ts
 init_types();
 init_types();
@@ -978,8 +810,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);
@@ -991,7 +823,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";
@@ -1011,7 +843,7 @@ async function isTmuxAvailable() {
   }
 }
 function generateTerminalId() {
-  return "t" + nanoid2(9);
+  return "t" + nanoid(9);
 }
 function getSessionName(terminalId) {
   return `${SESSION_PREFIX}${terminalId}`;
@@ -1615,7 +1447,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;
@@ -1628,7 +1460,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,
@@ -2385,7 +2217,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",
@@ -2394,7 +2226,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,
@@ -2422,7 +2254,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,
@@ -2436,7 +2268,7 @@ Best practices:
             };
           }
           case "clear": {
-            const count = todoQueries.clearSession(options.sessionId);
+            const count = await todoQueries.clearSession(options.sessionId);
             return {
               success: true,
               action: "clear",
@@ -2510,7 +2342,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`
@@ -2525,7 +2357,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",
@@ -2753,7 +2585,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;
@@ -2766,8 +2598,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
@@ -2775,7 +2607,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,
@@ -2784,12 +2616,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,
@@ -2859,7 +2691,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,
@@ -2874,7 +2706,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,
@@ -3184,7 +3016,7 @@ Keep your responses concise and focused on actionable information.`;
       })
     };
   }
-  parseResult(text2, steps) {
+  parseResult(text, steps) {
     const findings = [];
     let filesSearched = 0;
     let matchCount = 0;
@@ -3228,7 +3060,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,
@@ -3359,9 +3191,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,
@@ -3393,6 +3578,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
@@ -3445,7 +3644,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 platform2 = 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" });
@@ -3687,7 +3886,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);
@@ -3707,13 +3906,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}`;
@@ -3737,36 +3936,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;
   }
 };
@@ -3786,7 +3985,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,
@@ -3804,13 +4003,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,
@@ -3823,7 +4022,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
@@ -3899,7 +4098,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,
@@ -3908,14 +4107,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
@@ -3963,14 +4162,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
@@ -4003,11 +4202,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,
@@ -4016,19 +4215,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((resolve9) => {
             approvalResolvers.set(toolCallId, { resolve: resolve9, sessionId: this.session.id });
           });
           const resolverData = approvalResolvers.get(toolCallId);
           approvalResolvers.delete(toolCallId);
           this.pendingApprovals.delete(toolCallId);
+          const exec5 = 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(exec5.id);
+            await sessionQueries.updateStatus(this.session.id, "active");
             return {
               status: "rejected",
               toolCallId,
@@ -4037,14 +4237,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(exec5.id);
+          await sessionQueries.updateStatus(this.session.id, "active");
           try {
             const result = await originalTool.execute(input, toolOptions);
-            toolExecutionQueries.complete(execution.id, result);
+            await toolExecutionQueries.complete(exec5.id, result);
             return result;
           } catch (error) {
-            toolExecutionQueries.complete(execution.id, null, error.message);
+            await toolExecutionQueries.complete(exec5.id, null, error.message);
             throw error;
           }
         }
@@ -4067,36 +4267,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);
   }
   /**