@cospacehq/server 0.1.0

package/src/db.ts

@@ -0,0 +1,1197 @@
+import { DatabaseSync } from "node:sqlite";
+import fs from "node:fs";
+import path from "node:path";
+import { nanoid } from "nanoid";
+import type {
+  Agent,
+  Message,
+  Project,
+  ProjectThread,
+  ProviderKind,
+  SeenReceipt,
+  Task,
+  TaskEvent,
+  TaskEventType,
+  TaskActionPayload,
+  TaskActionType,
+  TaskApprovalStatus,
+  TaskStatus
+} from "@cospacehq/shared";
+
+const DEFAULT_PROJECT_ID = "project-general";
+
+const DEFAULT_AGENTS: Omit<Agent, "createdAt" | "status" | "providerKey" | "systemPrompt" | "seenEnabled" | "traceEnabled">[] = [
+  { id: "agent-pm", name: "Luna", title: "Project Manager", model: "gpt-5" },
+  { id: "agent-ui", name: "Rafi", title: "UI Designer", model: "claude-sonnet" },
+  { id: "agent-be", name: "Mako", title: "Backend Engineer", model: "gemini-2.0-pro" }
+];
+
+type FileActionStatus = "ok" | "error";
+
+type AgentRow = Omit<Agent, "seenEnabled" | "traceEnabled"> & {
+  seenEnabled: number;
+  traceEnabled: number;
+};
+
+type TaskRow = Omit<Task, "actionPayload"> & {
+  actionPayload: string | null;
+};
+
+type TaskEventRow = TaskEvent;
+
+export type ProviderRecord = {
+  id: string;
+  providerKey: string;
+  label: string;
+  kind: ProviderKind;
+  baseUrl: string;
+  defaultModel: string;
+  encryptedApiKey: string | null;
+  createdAt: string;
+  updatedAt: string;
+};
+
+function mapAgentRow(row: AgentRow): Agent {
+  return {
+    ...row,
+    seenEnabled: row.seenEnabled !== 0,
+    traceEnabled: row.traceEnabled !== 0
+  };
+}
+
+function parseTaskActionPayload(rawValue: string | null): TaskActionPayload | null {
+  if (!rawValue) {
+    return null;
+  }
+
+  try {
+    const parsed = JSON.parse(rawValue) as TaskActionPayload;
+    if (!parsed || typeof parsed !== "object") {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+function mapTaskRow(row: TaskRow): Task {
+  return {
+    ...row,
+    actionPayload: parseTaskActionPayload(row.actionPayload)
+  };
+}
+
+function mapTaskEventRow(row: TaskEventRow): TaskEvent {
+  return row;
+}
+
+export class CoSpaceStore {
+  private readonly db: DatabaseSync;
+  private readonly defaultProjectName: string;
+
+  public constructor(dbPath: string, options?: { projectName?: string }) {
+    fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+    this.db = new DatabaseSync(dbPath);
+    this.defaultProjectName = options?.projectName?.trim() ? options.projectName.trim() : "General";
+
+    this.initSchema();
+    this.applyMigrations();
+    this.seedDefaults();
+  }
+
+  public close(): void {
+    this.db.close();
+  }
+
+  public getProject(): Project {
+    const row = this.db
+      .prepare("SELECT id, name, created_at AS createdAt FROM projects ORDER BY created_at ASC LIMIT 1")
+      .get() as Project | undefined;
+
+    if (!row) {
+      throw new Error("No projects found");
+    }
+
+    return row;
+  }
+
+  public getProjectById(projectId: string): Project | null {
+    const row = this.db
+      .prepare("SELECT id, name, created_at AS createdAt FROM projects WHERE id = ? LIMIT 1")
+      .get(projectId) as Project | undefined;
+
+    return row ?? null;
+  }
+
+  public listProjectThreads(): ProjectThread[] {
+    type ProjectThreadRow = {
+      id: string;
+      name: string;
+      createdAt: string;
+      lastMessageId: string | null;
+      lastSenderRole: Message["senderRole"] | null;
+      lastSenderName: string | null;
+      lastBody: string | null;
+      lastAt: string | null;
+      assignedAgentCount: number;
+      lastSeenByCount: number;
+    };
+
+    const rows = this.db
+      .prepare(
+        [
+          "SELECT",
+          "  p.id AS id,",
+          "  p.name AS name,",
+          "  p.created_at AS createdAt,",
+          "  lm.id AS lastMessageId,",
+          "  lm.sender_role AS lastSenderRole,",
+          "  lm.sender_name AS lastSenderName,",
+          "  lm.body AS lastBody,",
+          "  lm.created_at AS lastAt,",
+          "  (",
+          "    SELECT COUNT(*)",
+          "    FROM project_agents pa",
+          "    INNER JOIN agents a ON a.id = pa.agent_id",
+          "    WHERE pa.project_id = p.id AND a.seen_enabled = 1",
+          "  ) AS assignedAgentCount,",
+          "  CASE",
+          "    WHEN lm.id IS NULL THEN 0",
+          "    ELSE (",
+          "      SELECT COUNT(*)",
+          "      FROM seen_receipts sr",
+          "      INNER JOIN project_agents pa ON pa.project_id = p.id AND pa.agent_id = sr.agent_id",
+          "      INNER JOIN agents a ON a.id = pa.agent_id AND a.seen_enabled = 1",
+          "      WHERE sr.message_id = lm.id",
+          "    )",
+          "  END AS lastSeenByCount",
+          "FROM projects p",
+          "LEFT JOIN messages lm ON lm.id = (",
+          "  SELECT m.id",
+          "  FROM messages m",
+          "  WHERE m.project_id = p.id",
+          "  ORDER BY m.created_at DESC",
+          "  LIMIT 1",
+          ")",
+          "ORDER BY COALESCE(lm.created_at, p.created_at) DESC, p.created_at DESC"
+        ].join(" ")
+      )
+      .all() as ProjectThreadRow[];
+
+    return rows.map((row) => ({
+      id: row.id,
+      name: row.name,
+      createdAt: row.createdAt,
+      assignedAgentCount: Number(row.assignedAgentCount ?? 0),
+      lastSeenByCount: Number(row.lastSeenByCount ?? 0),
+      lastMessage:
+        row.lastMessageId && row.lastSenderName && row.lastBody && row.lastAt
+          ? {
+              messageId: row.lastMessageId,
+              senderRole: row.lastSenderRole ?? "human",
+              senderName: row.lastSenderName,
+              body: row.lastBody,
+              createdAt: row.lastAt
+            }
+          : null
+    }));
+  }
+
+  public listProjectAgentIdsByProject(): Record<string, string[]> {
+    const projects = this.db
+      .prepare("SELECT id FROM projects ORDER BY created_at ASC")
+      .all() as Array<{ id: string }>;
+
+    const grouped: Record<string, string[]> = {};
+    for (const project of projects) {
+      grouped[project.id] = [];
+    }
+
+    const rows = this.db
+      .prepare(
+        [
+          "SELECT pa.project_id AS projectId, pa.agent_id AS agentId",
+          "FROM project_agents pa",
+          "INNER JOIN agents a ON a.id = pa.agent_id",
+          "ORDER BY pa.project_id ASC, a.created_at ASC"
+        ].join(" ")
+      )
+      .all() as Array<{ projectId: string; agentId: string }>;
+
+    for (const row of rows) {
+      if (!grouped[row.projectId]) {
+        grouped[row.projectId] = [];
+      }
+      grouped[row.projectId].push(row.agentId);
+    }
+
+    return grouped;
+  }
+
+  public createProject(input: { name: string }): Project {
+    const createdAt = new Date().toISOString();
+    const project: Project = {
+      id: `project-${nanoid(10)}`,
+      name: input.name.trim(),
+      createdAt
+    };
+
+    this.db
+      .prepare("INSERT INTO projects (id, name, created_at) VALUES (?, ?, ?)")
+      .run(project.id, project.name, project.createdAt);
+
+    const agentIds = this.listAgents().map((agent) => agent.id);
+    this.setProjectAgentIds(project.id, agentIds);
+
+    return project;
+  }
+
+  public listAgents(): Agent[] {
+    const rows = this.db
+      .prepare(
+        [
+          "SELECT",
+          "  a.id,",
+          "  a.name,",
+          "  a.title,",
+          "  COALESCE(ab.model, pc.default_model, a.model) AS model,",
+          "  ab.provider_key AS providerKey,",
+          "  a.system_prompt AS systemPrompt,",
+          "  a.seen_enabled AS seenEnabled,",
+          "  a.trace_enabled AS traceEnabled,",
+          "  a.status,",
+          "  a.created_at AS createdAt",
+          "FROM agents a",
+          "LEFT JOIN agent_model_bindings ab ON ab.agent_id = a.id",
+          "LEFT JOIN provider_configs pc ON pc.provider_key = ab.provider_key",
+          "ORDER BY a.created_at ASC"
+        ].join(" ")
+      )
+      .all() as AgentRow[];
+
+    return rows.map(mapAgentRow);
+  }
+
+  public getAgentById(agentId: string): Agent | null {
+    const row = this.db
+      .prepare(
+        [
+          "SELECT",
+          "  a.id,",
+          "  a.name,",
+          "  a.title,",
+          "  COALESCE(ab.model, pc.default_model, a.model) AS model,",
+          "  ab.provider_key AS providerKey,",
+          "  a.system_prompt AS systemPrompt,",
+          "  a.seen_enabled AS seenEnabled,",
+          "  a.trace_enabled AS traceEnabled,",
+          "  a.status,",
+          "  a.created_at AS createdAt",
+          "FROM agents a",
+          "LEFT JOIN agent_model_bindings ab ON ab.agent_id = a.id",
+          "LEFT JOIN provider_configs pc ON pc.provider_key = ab.provider_key",
+          "WHERE a.id = ?",
+          "LIMIT 1"
+        ].join(" ")
+      )
+      .get(agentId) as AgentRow | undefined;
+
+    return row ? mapAgentRow(row) : null;
+  }
+
+  public listProjectAgentIds(projectId: string): string[] {
+    const rows = this.db
+      .prepare(
+        [
+          "SELECT pa.agent_id AS agentId",
+          "FROM project_agents pa",
+          "INNER JOIN agents a ON a.id = pa.agent_id",
+          "WHERE pa.project_id = ?",
+          "ORDER BY a.created_at ASC"
+        ].join(" ")
+      )
+      .all(projectId) as Array<{ agentId: string }>;
+
+    return rows.map((row) => row.agentId);
+  }
+
+  public listAgentsForProject(projectId: string): Agent[] {
+    const rows = this.db
+      .prepare(
+        [
+          "SELECT",
+          "  a.id,",
+          "  a.name,",
+          "  a.title,",
+          "  COALESCE(ab.model, pc.default_model, a.model) AS model,",
+          "  ab.provider_key AS providerKey,",
+          "  a.system_prompt AS systemPrompt,",
+          "  a.seen_enabled AS seenEnabled,",
+          "  a.trace_enabled AS traceEnabled,",
+          "  a.status,",
+          "  a.created_at AS createdAt",
+          "FROM project_agents pa",
+          "INNER JOIN agents a ON a.id = pa.agent_id",
+          "LEFT JOIN agent_model_bindings ab ON ab.agent_id = a.id",
+          "LEFT JOIN provider_configs pc ON pc.provider_key = ab.provider_key",
+          "WHERE pa.project_id = ?",
+          "ORDER BY a.created_at ASC"
+        ].join(" ")
+      )
+      .all(projectId) as AgentRow[];
+
+    return rows.map(mapAgentRow);
+  }
+
+  public createAgent(input: {
+    name: string;
+    title: string;
+    model: string;
+    providerKey: string | null;
+    systemPrompt: string | null;
+    seenEnabled: boolean;
+    traceEnabled: boolean;
+    projectId?: string;
+  }): Agent {
+    const createdAt = new Date().toISOString();
+    const id = `agent-${nanoid(10)}`;
+
+    this.db.exec("BEGIN");
+    try {
+      this.db
+        .prepare(
+          [
+            "INSERT INTO agents",
+            "(id, name, title, model, status, system_prompt, seen_enabled, trace_enabled, created_at)",
+            "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)"
+          ].join(" ")
+        )
+        .run(
+          id,
+          input.name.trim(),
+          input.title.trim(),
+          input.model.trim(),
+          "idle",
+          input.systemPrompt,
+          input.seenEnabled ? 1 : 0,
+          input.traceEnabled ? 1 : 0,
+          createdAt
+        );
+
+      if (input.providerKey) {
+        this.setAgentBinding({
+          agentId: id,
+          providerKey: input.providerKey,
+          model: input.model.trim()
+        });
+      }
+
+      if (input.projectId) {
+        this.assignAgentToProject(input.projectId, id);
+      }
+
+      this.db.exec("COMMIT");
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
+
+    const created = this.getAgentById(id);
+    if (!created) {
+      throw new Error(`Failed to create agent ${id}`);
+    }
+    return created;
+  }
+
+  public assignAgentToProject(projectId: string, agentId: string): void {
+    this.db
+      .prepare("INSERT OR IGNORE INTO project_agents (project_id, agent_id, created_at) VALUES (?, ?, ?)")
+      .run(projectId, agentId, new Date().toISOString());
+  }
+
+  public setProjectAgentIds(projectId: string, agentIds: string[]): string[] {
+    const uniqueIds = Array.from(new Set(agentIds));
+    this.db.exec("BEGIN");
+
+    try {
+      this.db.prepare("DELETE FROM project_agents WHERE project_id = ?").run(projectId);
+
+      if (uniqueIds.length > 0) {
+        const insert = this.db.prepare(
+          "INSERT INTO project_agents (project_id, agent_id, created_at) VALUES (?, ?, ?)"
+        );
+        const createdAt = new Date().toISOString();
+
+        for (const agentId of uniqueIds) {
+          insert.run(projectId, agentId, createdAt);
+        }
+      }
+
+      this.db.exec("COMMIT");
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
+
+    return this.listProjectAgentIds(projectId);
+  }
+
+  public listMessages(projectId: string): Message[] {
+    return this.db
+      .prepare(
+        [
+          "SELECT",
+          "  id,",
+          "  project_id AS projectId,",
+          "  sender_id AS senderId,",
+          "  sender_name AS senderName,",
+          "  sender_role AS senderRole,",
+          "  body,",
+          "  internal_trace AS internalTrace,",
+          "  created_at AS createdAt",
+          "FROM messages",
+          "WHERE project_id = ?",
+          "ORDER BY created_at ASC"
+        ].join(" ")
+      )
+      .all(projectId) as Message[];
+  }
+
+  public listRecentMessages(projectId: string, limit: number): Message[] {
+    return this.db
+      .prepare(
+        [
+          "SELECT",
+          "  id,",
+          "  project_id AS projectId,",
+          "  sender_id AS senderId,",
+          "  sender_name AS senderName,",
+          "  sender_role AS senderRole,",
+          "  body,",
+          "  internal_trace AS internalTrace,",
+          "  created_at AS createdAt",
+          "FROM messages",
+          "WHERE project_id = ?",
+          "ORDER BY created_at DESC",
+          "LIMIT ?"
+        ].join(" ")
+      )
+      .all(projectId, limit)
+      .reverse() as Message[];
+  }
+
+  public listReceiptsByProject(projectId: string): Record<string, SeenReceipt[]> {
+    const rows = this.db
+      .prepare(
+        [
+          "SELECT",
+          "  sr.id AS id,",
+          "  sr.message_id AS messageId,",
+          "  sr.agent_id AS agentId,",
+          "  sr.agent_name AS agentName,",
+          "  sr.model AS model,",
+          "  sr.seen_at AS seenAt",
+          "FROM seen_receipts sr",
+          "INNER JOIN messages m ON m.id = sr.message_id",
+          "WHERE m.project_id = ?",
+          "ORDER BY sr.seen_at ASC"
+        ].join(" ")
+      )
+      .all(projectId) as SeenReceipt[];
+
+    const grouped: Record<string, SeenReceipt[]> = {};
+
+    for (const row of rows) {
+      if (!grouped[row.messageId]) {
+        grouped[row.messageId] = [];
+      }
+      grouped[row.messageId].push(row);
+    }
+
+    return grouped;
+  }
+
+  public listReceiptsForMessage(messageId: string): SeenReceipt[] {
+    return this.db
+      .prepare(
+        [
+          "SELECT id, message_id AS messageId, agent_id AS agentId, agent_name AS agentName, model, seen_at AS seenAt",
+          "FROM seen_receipts",
+          "WHERE message_id = ?",
+          "ORDER BY seen_at ASC"
+        ].join(" ")
+      )
+      .all(messageId) as SeenReceipt[];
+  }
+
+  public createHumanMessage(input: { projectId: string; senderName: string; body: string }): Message {
+    const createdAt = new Date().toISOString();
+    const message: Message = {
+      id: nanoid(12),
+      projectId: input.projectId,
+      senderId: "human-user",
+      senderName: input.senderName,
+      senderRole: "human",
+      body: input.body,
+      internalTrace: null,
+      createdAt
+    };
+
+    this.db
+      .prepare(
+        [
+          "INSERT INTO messages (id, project_id, sender_id, sender_name, sender_role, body, internal_trace, created_at)",
+          "VALUES (?, ?, ?, ?, ?, ?, ?, ?)"
+        ].join(" ")
+      )
+      .run(
+        message.id,
+        message.projectId,
+        message.senderId,
+        message.senderName,
+        message.senderRole,
+        message.body,
+        message.internalTrace,
+        message.createdAt
+      );
+
+    return message;
+  }
+
+  public createAgentMessage(input: {
+    projectId: string;
+    senderId: string;
+    senderName: string;
+    body: string;
+    internalTrace: string | null;
+  }): Message {
+    const createdAt = new Date().toISOString();
+    const message: Message = {
+      id: nanoid(12),
+      projectId: input.projectId,
+      senderId: input.senderId,
+      senderName: input.senderName,
+      senderRole: "agent",
+      body: input.body,
+      internalTrace: input.internalTrace,
+      createdAt
+    };
+
+    this.db
+      .prepare(
+        [
+          "INSERT INTO messages (id, project_id, sender_id, sender_name, sender_role, body, internal_trace, created_at)",
+          "VALUES (?, ?, ?, ?, ?, ?, ?, ?)"
+        ].join(" ")
+      )
+      .run(
+        message.id,
+        message.projectId,
+        message.senderId,
+        message.senderName,
+        message.senderRole,
+        message.body,
+        message.internalTrace,
+        message.createdAt
+      );
+
+    return message;
+  }
+
+  public createSeenReceipt(input: {
+    messageId: string;
+    agentId: string;
+    agentName: string;
+    model: string;
+  }): SeenReceipt {
+    const receipt: SeenReceipt = {
+      id: nanoid(12),
+      messageId: input.messageId,
+      agentId: input.agentId,
+      agentName: input.agentName,
+      model: input.model,
+      seenAt: new Date().toISOString()
+    };
+
+    this.db
+      .prepare(
+        "INSERT INTO seen_receipts (id, message_id, agent_id, agent_name, model, seen_at) VALUES (?, ?, ?, ?, ?, ?)"
+      )
+      .run(receipt.id, receipt.messageId, receipt.agentId, receipt.agentName, receipt.model, receipt.seenAt);
+
+    return receipt;
+  }
+
+  public updateAgentStatus(agentId: string, status: Agent["status"]): void {
+    this.db.prepare("UPDATE agents SET status = ? WHERE id = ?").run(status, agentId);
+  }
+
+  public listTasksByProject(projectId: string): Task[] {
+    const rows = this.db
+      .prepare(
+        [
+          "SELECT",
+          "  t.id AS id,",
+          "  t.project_id AS projectId,",
+          "  t.title AS title,",
+          "  t.description AS description,",
+          "  t.status AS status,",
+          "  t.approval_status AS approvalStatus,",
+          "  t.action_type AS actionType,",
+          "  t.action_payload AS actionPayload,",
+          "  t.assignee_agent_id AS assigneeAgentId,",
+          "  a.name AS assigneeAgentName,",
+          "  t.delegated_by_message_id AS delegatedByMessageId,",
+          "  t.created_by AS createdBy,",
+          "  t.created_at AS createdAt,",
+          "  t.updated_at AS updatedAt,",
+          "  t.completed_at AS completedAt,",
+          "  t.error_message AS errorMessage",
+          "FROM tasks t",
+          "LEFT JOIN agents a ON a.id = t.assignee_agent_id",
+          "WHERE t.project_id = ?",
+          "ORDER BY t.created_at DESC"
+        ].join(" ")
+      )
+      .all(projectId) as TaskRow[];
+
+    return rows.map(mapTaskRow);
+  }
+
+  public listTaskEventsByProject(projectId: string): Record<string, TaskEvent[]> {
+    const rows = this.db
+      .prepare(
+        [
+          "SELECT",
+          "  id AS id,",
+          "  task_id AS taskId,",
+          "  project_id AS projectId,",
+          "  event_type AS eventType,",
+          "  actor_id AS actorId,",
+          "  detail AS detail,",
+          "  created_at AS createdAt",
+          "FROM task_events",
+          "WHERE project_id = ?",
+          "ORDER BY created_at ASC"
+        ].join(" ")
+      )
+      .all(projectId) as TaskEventRow[];
+
+    const grouped: Record<string, TaskEvent[]> = {};
+    for (const row of rows.map(mapTaskEventRow)) {
+      if (!grouped[row.taskId]) {
+        grouped[row.taskId] = [];
+      }
+      grouped[row.taskId].push(row);
+    }
+    return grouped;
+  }
+
+  public getTaskById(taskId: string): Task | null {
+    const row = this.db
+      .prepare(
+        [
+          "SELECT",
+          "  t.id AS id,",
+          "  t.project_id AS projectId,",
+          "  t.title AS title,",
+          "  t.description AS description,",
+          "  t.status AS status,",
+          "  t.approval_status AS approvalStatus,",
+          "  t.action_type AS actionType,",
+          "  t.action_payload AS actionPayload,",
+          "  t.assignee_agent_id AS assigneeAgentId,",
+          "  a.name AS assigneeAgentName,",
+          "  t.delegated_by_message_id AS delegatedByMessageId,",
+          "  t.created_by AS createdBy,",
+          "  t.created_at AS createdAt,",
+          "  t.updated_at AS updatedAt,",
+          "  t.completed_at AS completedAt,",
+          "  t.error_message AS errorMessage",
+          "FROM tasks t",
+          "LEFT JOIN agents a ON a.id = t.assignee_agent_id",
+          "WHERE t.id = ?",
+          "LIMIT 1"
+        ].join(" ")
+      )
+      .get(taskId) as TaskRow | undefined;
+
+    return row ? mapTaskRow(row) : null;
+  }
+
+  public createTask(input: {
+    projectId: string;
+    title: string;
+    description: string | null;
+    status: TaskStatus;
+    approvalStatus: TaskApprovalStatus;
+    actionType: TaskActionType;
+    actionPayload: TaskActionPayload | null;
+    assigneeAgentId: string | null;
+    delegatedByMessageId: string | null;
+    createdBy: string;
+  }): Task {
+    const id = `task-${nanoid(10)}`;
+    const now = new Date().toISOString();
+    const completedAt = input.status === "done" || input.status === "cancelled" ? now : null;
+
+    this.db
+      .prepare(
+        [
+          "INSERT INTO tasks",
+          "(",
+          "id, project_id, title, description, status, approval_status, action_type, action_payload,",
+          "assignee_agent_id, delegated_by_message_id, created_by, created_at, updated_at, completed_at, error_message",
+          ")",
+          "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
+        ].join(" ")
+      )
+      .run(
+        id,
+        input.projectId,
+        input.title,
+        input.description,
+        input.status,
+        input.approvalStatus,
+        input.actionType,
+        input.actionPayload ? JSON.stringify(input.actionPayload) : null,
+        input.assigneeAgentId,
+        input.delegatedByMessageId,
+        input.createdBy,
+        now,
+        now,
+        completedAt,
+        null
+      );
+
+    const created = this.getTaskById(id);
+    if (!created) {
+      throw new Error(`Failed to create task ${id}`);
+    }
+    return created;
+  }
+
+  public updateTaskState(input: {
+    taskId: string;
+    status?: TaskStatus;
+    approvalStatus?: TaskApprovalStatus;
+    errorMessage?: string | null;
+    completedAt?: string | null;
+  }): Task {
+    const existing = this.getTaskById(input.taskId);
+    if (!existing) {
+      throw new Error(`Task ${input.taskId} not found`);
+    }
+
+    const nextStatus = input.status ?? existing.status;
+    const nextApprovalStatus = input.approvalStatus ?? existing.approvalStatus;
+    const nextCompletedAt =
+      input.completedAt !== undefined
+        ? input.completedAt
+        : nextStatus === "done" || nextStatus === "cancelled"
+          ? existing.completedAt ?? new Date().toISOString()
+          : null;
+    const nextErrorMessage = input.errorMessage !== undefined ? input.errorMessage : existing.errorMessage;
+    const updatedAt = new Date().toISOString();
+
+    this.db
+      .prepare(
+        [
+          "UPDATE tasks",
+          "SET status = ?,",
+          "    approval_status = ?,",
+          "    updated_at = ?,",
+          "    completed_at = ?,",
+          "    error_message = ?",
+          "WHERE id = ?"
+        ].join(" ")
+      )
+      .run(nextStatus, nextApprovalStatus, updatedAt, nextCompletedAt, nextErrorMessage, input.taskId);
+
+    const updated = this.getTaskById(input.taskId);
+    if (!updated) {
+      throw new Error(`Task ${input.taskId} disappeared after update`);
+    }
+    return updated;
+  }
+
+  public listProviderRecords(): ProviderRecord[] {
+    return this.db
+      .prepare(
+        [
+          "SELECT",
+          "  id,",
+          "  provider_key AS providerKey,",
+          "  label,",
+          "  kind,",
+          "  base_url AS baseUrl,",
+          "  default_model AS defaultModel,",
+          "  encrypted_api_key AS encryptedApiKey,",
+          "  created_at AS createdAt,",
+          "  updated_at AS updatedAt",
+          "FROM provider_configs",
+          "ORDER BY created_at ASC"
+        ].join(" ")
+      )
+      .all() as ProviderRecord[];
+  }
+
+  public getProviderRecord(providerKey: string): ProviderRecord | null {
+    const row = this.db
+      .prepare(
+        [
+          "SELECT",
+          "  id,",
+          "  provider_key AS providerKey,",
+          "  label,",
+          "  kind,",
+          "  base_url AS baseUrl,",
+          "  default_model AS defaultModel,",
+          "  encrypted_api_key AS encryptedApiKey,",
+          "  created_at AS createdAt,",
+          "  updated_at AS updatedAt",
+          "FROM provider_configs",
+          "WHERE provider_key = ?",
+          "LIMIT 1"
+        ].join(" ")
+      )
+      .get(providerKey) as ProviderRecord | undefined;
+
+    return row ?? null;
+  }
+
+  public upsertProviderRecord(input: {
+    providerKey: string;
+    label: string;
+    kind: ProviderKind;
+    baseUrl: string;
+    defaultModel: string;
+    encryptedApiKey?: string | null;
+  }): ProviderRecord {
+    const now = new Date().toISOString();
+    const existing = this.getProviderRecord(input.providerKey);
+
+    if (!existing) {
+      const id = nanoid(12);
+      this.db
+        .prepare(
+          [
+            "INSERT INTO provider_configs",
+            "(id, provider_key, label, kind, base_url, default_model, encrypted_api_key, created_at, updated_at)",
+            "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)"
+          ].join(" ")
+        )
+        .run(
+          id,
+          input.providerKey,
+          input.label,
+          input.kind,
+          input.baseUrl,
+          input.defaultModel,
+          input.encryptedApiKey ?? null,
+          now,
+          now
+        );
+    } else {
+      this.db
+        .prepare(
+          [
+            "UPDATE provider_configs",
+            "SET label = ?,",
+            "    kind = ?,",
+            "    base_url = ?,",
+            "    default_model = ?,",
+            "    encrypted_api_key = ?,",
+            "    updated_at = ?",
+            "WHERE provider_key = ?"
+          ].join(" ")
+        )
+        .run(
+          input.label,
+          input.kind,
+          input.baseUrl,
+          input.defaultModel,
+          input.encryptedApiKey === undefined ? existing.encryptedApiKey : input.encryptedApiKey,
+          now,
+          input.providerKey
+        );
+    }
+
+    const updated = this.getProviderRecord(input.providerKey);
+    if (!updated) {
+      throw new Error(`Failed to upsert provider ${input.providerKey}`);
+    }
+
+    return updated;
+  }
+
+  public setAgentBinding(input: { agentId: string; providerKey: string | null; model: string | null }): void {
+    if (input.providerKey === null && input.model === null) {
+      this.db.prepare("DELETE FROM agent_model_bindings WHERE agent_id = ?").run(input.agentId);
+      return;
+    }
+
+    const now = new Date().toISOString();
+    this.db
+      .prepare(
+        [
+          "INSERT INTO agent_model_bindings (agent_id, provider_key, model, updated_at)",
+          "VALUES (?, ?, ?, ?)",
+          "ON CONFLICT(agent_id) DO UPDATE SET",
+          "  provider_key = excluded.provider_key,",
+          "  model = excluded.model,",
+          "  updated_at = excluded.updated_at"
+        ].join(" ")
+      )
+      .run(input.agentId, input.providerKey, input.model, now);
+  }
+
+  public setAgentVisibility(input: { agentId: string; seenEnabled: boolean; traceEnabled: boolean }): void {
+    this.db
+      .prepare("UPDATE agents SET seen_enabled = ?, trace_enabled = ? WHERE id = ?")
+      .run(input.seenEnabled ? 1 : 0, input.traceEnabled ? 1 : 0, input.agentId);
+  }
+
+  public recordTaskEvent(input: {
+    taskId: string;
+    projectId: string;
+    eventType: TaskEventType;
+    actorId: string;
+    detail: string | null;
+  }): TaskEvent {
+    const event: TaskEvent = {
+      id: nanoid(12),
+      taskId: input.taskId,
+      projectId: input.projectId,
+      eventType: input.eventType,
+      actorId: input.actorId,
+      detail: input.detail,
+      createdAt: new Date().toISOString()
+    };
+
+    this.db
+      .prepare(
+        [
+          "INSERT INTO task_events",
+          "(id, task_id, project_id, event_type, actor_id, detail, created_at)",
+          "VALUES (?, ?, ?, ?, ?, ?, ?)"
+        ].join(" ")
+      )
+      .run(
+        event.id,
+        event.taskId,
+        event.projectId,
+        event.eventType,
+        event.actorId,
+        event.detail,
+        event.createdAt
+      );
+
+    return event;
+  }
+
+  public recordFileAction(input: {
+    actorId: string;
+    action: string;
+    targetPath: string;
+    status: FileActionStatus;
+    errorMessage: string | null;
+  }): void {
+    this.db
+      .prepare(
+        [
+          "INSERT INTO file_actions (id, actor_id, action, target_path, status, error_message, created_at)",
+          "VALUES (?, ?, ?, ?, ?, ?, ?)"
+        ].join(" ")
+      )
+      .run(
+        nanoid(12),
+        input.actorId,
+        input.action,
+        input.targetPath,
+        input.status,
+        input.errorMessage,
+        new Date().toISOString()
+      );
+  }
+
+  private initSchema(): void {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS projects (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        created_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS agents (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        title TEXT NOT NULL,
+        model TEXT NOT NULL,
+        status TEXT NOT NULL,
+        system_prompt TEXT,
+        seen_enabled INTEGER NOT NULL DEFAULT 1,
+        trace_enabled INTEGER NOT NULL DEFAULT 1,
+        created_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS messages (
+        id TEXT PRIMARY KEY,
+        project_id TEXT NOT NULL,
+        sender_id TEXT NOT NULL,
+        sender_name TEXT NOT NULL,
+        sender_role TEXT NOT NULL,
+        body TEXT NOT NULL,
+        internal_trace TEXT,
+        created_at TEXT NOT NULL,
+        FOREIGN KEY (project_id) REFERENCES projects(id)
+      );
+
+      CREATE TABLE IF NOT EXISTS seen_receipts (
+        id TEXT PRIMARY KEY,
+        message_id TEXT NOT NULL,
+        agent_id TEXT NOT NULL,
+        agent_name TEXT NOT NULL,
+        model TEXT NOT NULL,
+        seen_at TEXT NOT NULL,
+        FOREIGN KEY (message_id) REFERENCES messages(id)
+      );
+
+      CREATE TABLE IF NOT EXISTS file_actions (
+        id TEXT PRIMARY KEY,
+        actor_id TEXT NOT NULL,
+        action TEXT NOT NULL,
+        target_path TEXT NOT NULL,
+        status TEXT NOT NULL,
+        error_message TEXT,
+        created_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS tasks (
+        id TEXT PRIMARY KEY,
+        project_id TEXT NOT NULL,
+        title TEXT NOT NULL,
+        description TEXT,
+        status TEXT NOT NULL,
+        approval_status TEXT NOT NULL,
+        action_type TEXT NOT NULL,
+        action_payload TEXT,
+        assignee_agent_id TEXT,
+        delegated_by_message_id TEXT,
+        created_by TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        completed_at TEXT,
+        error_message TEXT,
+        FOREIGN KEY (project_id) REFERENCES projects(id),
+        FOREIGN KEY (assignee_agent_id) REFERENCES agents(id),
+        FOREIGN KEY (delegated_by_message_id) REFERENCES messages(id)
+      );
+
+      CREATE TABLE IF NOT EXISTS task_events (
+        id TEXT PRIMARY KEY,
+        task_id TEXT NOT NULL,
+        project_id TEXT NOT NULL,
+        event_type TEXT NOT NULL,
+        actor_id TEXT NOT NULL,
+        detail TEXT,
+        created_at TEXT NOT NULL,
+        FOREIGN KEY (task_id) REFERENCES tasks(id),
+        FOREIGN KEY (project_id) REFERENCES projects(id)
+      );
+
+      CREATE TABLE IF NOT EXISTS provider_configs (
+        id TEXT PRIMARY KEY,
+        provider_key TEXT NOT NULL UNIQUE,
+        label TEXT NOT NULL,
+        kind TEXT NOT NULL,
+        base_url TEXT NOT NULL,
+        default_model TEXT NOT NULL,
+        encrypted_api_key TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS agent_model_bindings (
+        agent_id TEXT PRIMARY KEY,
+        provider_key TEXT,
+        model TEXT,
+        updated_at TEXT NOT NULL,
+        FOREIGN KEY (agent_id) REFERENCES agents(id),
+        FOREIGN KEY (provider_key) REFERENCES provider_configs(provider_key)
+      );
+
+      CREATE TABLE IF NOT EXISTS project_agents (
+        project_id TEXT NOT NULL,
+        agent_id TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        PRIMARY KEY (project_id, agent_id),
+        FOREIGN KEY (project_id) REFERENCES projects(id),
+        FOREIGN KEY (agent_id) REFERENCES agents(id)
+      );
+    `);
+  }
+
+  private applyMigrations(): void {
+    const agentColumns = this.db
+      .prepare("PRAGMA table_info(agents)")
+      .all() as Array<{ name: string }>;
+
+    const hasSystemPrompt = agentColumns.some((column) => column.name === "system_prompt");
+    if (!hasSystemPrompt) {
+      this.db.exec("ALTER TABLE agents ADD COLUMN system_prompt TEXT");
+    }
+
+    const hasSeenEnabled = agentColumns.some((column) => column.name === "seen_enabled");
+    if (!hasSeenEnabled) {
+      this.db.exec("ALTER TABLE agents ADD COLUMN seen_enabled INTEGER NOT NULL DEFAULT 1");
+    }
+
+    const hasTraceEnabled = agentColumns.some((column) => column.name === "trace_enabled");
+    if (!hasTraceEnabled) {
+      this.db.exec("ALTER TABLE agents ADD COLUMN trace_enabled INTEGER NOT NULL DEFAULT 1");
+    }
+  }
+
+  private seedDefaults(): void {
+    const projectCount = this.db.prepare("SELECT COUNT(*) AS count FROM projects").get() as { count: number };
+    if (projectCount.count === 0) {
+      const defaultProject: Project = {
+        id: DEFAULT_PROJECT_ID,
+        name: this.defaultProjectName,
+        createdAt: new Date().toISOString()
+      };
+      this.db
+        .prepare("INSERT INTO projects (id, name, created_at) VALUES (?, ?, ?)")
+        .run(defaultProject.id, defaultProject.name, defaultProject.createdAt);
+    }
+
+    const agentCount = this.db.prepare("SELECT COUNT(*) AS count FROM agents").get() as { count: number };
+    if (agentCount.count === 0) {
+      const stmt = this.db.prepare(
+        "INSERT INTO agents (id, name, title, model, status, system_prompt, seen_enabled, trace_enabled, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)"
+      );
+      const createdAt = new Date().toISOString();
+
+      for (const agent of DEFAULT_AGENTS) {
+        stmt.run(agent.id, agent.name, agent.title, agent.model, "idle", null, 1, 1, createdAt);
+      }
+    }
+
+    const projectRows = this.db
+      .prepare("SELECT id FROM projects ORDER BY created_at ASC")
+      .all() as Array<{ id: string }>;
+    const agentIds = this.listAgents().map((agent) => agent.id);
+
+    for (const project of projectRows) {
+      const assignmentCount = this.db
+        .prepare("SELECT COUNT(*) AS count FROM project_agents WHERE project_id = ?")
+        .get(project.id) as { count: number };
+
+      if (assignmentCount.count === 0 && agentIds.length > 0) {
+        this.setProjectAgentIds(project.id, agentIds);
+      }
+    }
+  }
+}