agor-live 0.3.7

package/dist/core/dist/db/index.js

@@ -0,0 +1,3649 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/lib/ids.ts
+var ids_exports = {};
+__export(ids_exports, {
+  IdResolutionError: () => IdResolutionError,
+  default: () => ids_default,
+  expandPrefix: () => expandPrefix,
+  findMinimumPrefixLength: () => findMinimumPrefixLength,
+  formatIdForDisplay: () => formatIdForDisplay,
+  formatShortId: () => formatShortId,
+  generateId: () => generateId,
+  isUniquePrefix: () => isUniquePrefix,
+  isValidShortID: () => isValidShortID,
+  isValidUUID: () => isValidUUID,
+  resolveShortId: () => resolveShortId,
+  shortId: () => shortId
+});
+import { uuidv7 } from "uuidv7";
+function generateId() {
+  return uuidv7();
+}
+function isValidUUID(value) {
+  const uuidv7Pattern = /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+  return uuidv7Pattern.test(value);
+}
+function isValidShortID(value) {
+  return /^[0-9a-f]{8,32}$/i.test(value);
+}
+function shortId(uuid, length = 8) {
+  const cleanUuid = uuid.replace(/-/g, "");
+  return cleanUuid.slice(0, Math.min(length, 32));
+}
+function formatShortId(uuid, length = 8) {
+  return shortId(uuid, length);
+}
+function formatIdForDisplay(uuid, options = {}) {
+  if (options.verbose) {
+    return uuid;
+  }
+  return shortId(uuid, options.length);
+}
+function expandPrefix(prefix) {
+  const clean = prefix.replace(/-/g, "").toLowerCase();
+  if (clean.length === 0) {
+    throw new Error("ID prefix cannot be empty");
+  }
+  if (!isValidShortID(clean)) {
+    throw new Error(`Invalid ID prefix: ${prefix} (must be hexadecimal)`);
+  }
+  if (clean.length === 32) {
+    return formatUUIDWithHyphens(clean);
+  }
+  let formatted = "";
+  let pos = 0;
+  const sections = [8, 4, 4, 4, 12];
+  let offset = 0;
+  for (const sectionLength of sections) {
+    if (pos >= clean.length) break;
+    const section = clean.slice(pos, pos + sectionLength);
+    formatted += (offset > 0 ? "-" : "") + section;
+    pos += section.length;
+    if (section.length < sectionLength) {
+      return `${formatted}%`;
+    }
+    offset++;
+  }
+  return `${formatted}%`;
+}
+function formatUUIDWithHyphens(hex) {
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+}
+function resolveShortId(prefix, entities) {
+  const cleanPrefix = prefix.replace(/-/g, "").toLowerCase();
+  const matches = entities.filter((e) => {
+    const cleanId = e.id.replace(/-/g, "").toLowerCase();
+    return cleanId.startsWith(cleanPrefix);
+  });
+  if (matches.length === 0) {
+    throw new IdResolutionError(
+      `No entity found with ID prefix: ${prefix}
+
+Use 'agor <entity> list' to see available IDs.`,
+      "not_found",
+      prefix
+    );
+  }
+  if (matches.length === 1) {
+    return matches[0];
+  }
+  const suggestions = matches.slice(0, 10).map((m) => {
+    const description = getEntityDescription(m);
+    return `  - ${shortId(m.id, 12)}: ${description}`;
+  }).join("\n");
+  const ellipsis = matches.length > 10 ? `
+  ... and ${matches.length - 10} more` : "";
+  throw new IdResolutionError(
+    `Ambiguous ID prefix: ${prefix}
+
+${matches.length} matches found:
+${suggestions}${ellipsis}
+
+Use a longer prefix to disambiguate.`,
+    "ambiguous",
+    prefix,
+    matches.map((m) => ({ id: m.id }))
+  );
+}
+function getEntityDescription(entity) {
+  if (entity.description) return entity.description;
+  if (entity.full_prompt) return truncate(entity.full_prompt, 60);
+  if (entity.name) return entity.name;
+  if (entity.agent) return `(${entity.agent} session)`;
+  return "(no description)";
+}
+function truncate(str, maxLength) {
+  if (str.length <= maxLength) return str;
+  return `${str.slice(0, maxLength - 3)}...`;
+}
+function findMinimumPrefixLength(ids) {
+  if (ids.length <= 1) return 8;
+  for (let length = 8; length <= 32; length++) {
+    const prefixes = new Set(ids.map((id) => shortId(id, length)));
+    if (prefixes.size === ids.length) {
+      return length;
+    }
+  }
+  return 32;
+}
+function isUniquePrefix(prefix, entities) {
+  try {
+    resolveShortId(prefix, entities);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var IdResolutionError, ids_default;
+var init_ids = __esm({
+  "src/lib/ids.ts"() {
+    "use strict";
+    IdResolutionError = class extends Error {
+      constructor(message, type, prefix, candidates) {
+        super(message);
+        this.type = type;
+        this.prefix = prefix;
+        this.candidates = candidates;
+        this.name = "IdResolutionError";
+      }
+    };
+    ids_default = {
+      generateId,
+      isValidUUID,
+      isValidShortID,
+      shortId,
+      formatShortId,
+      formatIdForDisplay,
+      expandPrefix,
+      resolveShortId,
+      findMinimumPrefixLength,
+      isUniquePrefix
+    };
+  }
+});
+
+// src/db/index.ts
+init_ids();
+import { and as and4, desc, eq as eq12, inArray, like as like8, or as or2, sql as sql7 } from "drizzle-orm";
+import bcryptjs from "bcryptjs";
+
+// src/db/client.ts
+import { createClient } from "@libsql/client";
+import { drizzle } from "drizzle-orm/libsql";
+
+// src/db/schema.ts
+var schema_exports = {};
+__export(schema_exports, {
+  boardComments: () => boardComments,
+  boardObjects: () => boardObjects,
+  boards: () => boards,
+  mcpServers: () => mcpServers,
+  messages: () => messages,
+  repos: () => repos,
+  sessionMcpServers: () => sessionMcpServers,
+  sessions: () => sessions,
+  tasks: () => tasks,
+  users: () => users,
+  worktrees: () => worktrees
+});
+import { sql } from "drizzle-orm";
+import { index, integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+var sessions = sqliteTable(
+  "sessions",
+  {
+    // Primary identity
+    session_id: text("session_id", { length: 36 }).primaryKey(),
+    created_at: integer("created_at", { mode: "timestamp_ms" }).notNull(),
+    updated_at: integer("updated_at", { mode: "timestamp_ms" }),
+    // User attribution
+    created_by: text("created_by", { length: 36 }).notNull().default("anonymous"),
+    // Materialized for filtering/joins (cross-DB compatible)
+    status: text("status", {
+      enum: ["idle", "running", "completed", "failed"]
+    }).notNull(),
+    agentic_tool: text("agentic_tool", {
+      enum: ["claude-code", "cursor", "codex", "gemini"]
+    }).notNull(),
+    board_id: text("board_id", { length: 36 }),
+    // NULL = no board
+    // Genealogy (materialized for tree queries)
+    parent_session_id: text("parent_session_id", { length: 36 }),
+    forked_from_session_id: text("forked_from_session_id", { length: 36 }),
+    // Worktree reference (REQUIRED: all sessions must have a worktree)
+    worktree_id: text("worktree_id", { length: 36 }).notNull().references(() => worktrees.worktree_id, {
+      onDelete: "cascade"
+      // Cascade delete sessions when worktree is deleted
+    }),
+    // JSON blob for everything else (cross-DB via json() type)
+    data: text("data", { mode: "json" }).$type().notNull()
+  },
+  (table) => ({
+    statusIdx: index("sessions_status_idx").on(table.status),
+    agenticToolIdx: index("sessions_agentic_tool_idx").on(table.agentic_tool),
+    boardIdx: index("sessions_board_idx").on(table.board_id),
+    worktreeIdx: index("sessions_worktree_idx").on(table.worktree_id),
+    createdIdx: index("sessions_created_idx").on(table.created_at),
+    parentIdx: index("sessions_parent_idx").on(table.parent_session_id),
+    forkedIdx: index("sessions_forked_idx").on(table.forked_from_session_id)
+  })
+);
+var tasks = sqliteTable(
+  "tasks",
+  {
+    task_id: text("task_id", { length: 36 }).primaryKey(),
+    session_id: text("session_id", { length: 36 }).notNull().references(() => sessions.session_id, { onDelete: "cascade" }),
+    created_at: integer("created_at", { mode: "timestamp_ms" }).notNull(),
+    completed_at: integer("completed_at", { mode: "timestamp_ms" }),
+    status: text("status", {
+      enum: [
+        "created",
+        "running",
+        "stopping",
+        "awaiting_permission",
+        "completed",
+        "failed",
+        "stopped"
+      ]
+    }).notNull(),
+    // User attribution
+    created_by: text("created_by", { length: 36 }).notNull().default("anonymous"),
+    data: text("data", { mode: "json" }).$type().notNull()
+  },
+  (table) => ({
+    sessionIdx: index("tasks_session_idx").on(table.session_id),
+    statusIdx: index("tasks_status_idx").on(table.status),
+    createdIdx: index("tasks_created_idx").on(table.created_at)
+  })
+);
+var messages = sqliteTable(
+  "messages",
+  {
+    // Primary identity
+    message_id: text("message_id", { length: 36 }).primaryKey(),
+    created_at: integer("created_at", { mode: "timestamp_ms" }).notNull(),
+    // Foreign keys (materialized for indexes)
+    session_id: text("session_id", { length: 36 }).notNull().references(() => sessions.session_id, { onDelete: "cascade" }),
+    task_id: text("task_id", { length: 36 }).references(() => tasks.task_id, {
+      onDelete: "set null"
+    }),
+    // Materialized for queries
+    type: text("type", {
+      enum: ["user", "assistant", "system", "file-history-snapshot", "permission_request"]
+    }).notNull(),
+    role: text("role", {
+      enum: ["user", "assistant", "system"]
+    }).notNull(),
+    index: integer("index").notNull(),
+    // Position in conversation (0-based)
+    timestamp: integer("timestamp", { mode: "timestamp_ms" }).notNull(),
+    content_preview: text("content_preview"),
+    // First 200 chars for list views
+    // Full data (JSON blob)
+    data: text("data", { mode: "json" }).$type().notNull()
+  },
+  (table) => ({
+    // Indexes for efficient lookups
+    sessionIdx: index("messages_session_id_idx").on(table.session_id),
+    taskIdx: index("messages_task_id_idx").on(table.task_id),
+    sessionIndexIdx: index("messages_session_index_idx").on(table.session_id, table.index)
+  })
+);
+var boards = sqliteTable(
+  "boards",
+  {
+    board_id: text("board_id", { length: 36 }).primaryKey(),
+    created_at: integer("created_at", { mode: "timestamp_ms" }).notNull(),
+    updated_at: integer("updated_at", { mode: "timestamp_ms" }),
+    // User attribution
+    created_by: text("created_by", { length: 36 }).notNull().default("anonymous"),
+    // Materialized for lookups
+    name: text("name").notNull(),
+    slug: text("slug").unique(),
+    // JSON blob for the rest
+    data: text("data", { mode: "json" }).$type().notNull()
+  },
+  (table) => ({
+    nameIdx: index("boards_name_idx").on(table.name),
+    slugIdx: index("boards_slug_idx").on(table.slug)
+  })
+);
+var repos = sqliteTable(
+  "repos",
+  {
+    repo_id: text("repo_id", { length: 36 }).primaryKey(),
+    created_at: integer("created_at", { mode: "timestamp_ms" }).notNull(),
+    updated_at: integer("updated_at", { mode: "timestamp_ms" }),
+    // Materialized for querying
+    slug: text("slug").notNull().unique(),
+    data: text("data", { mode: "json" }).$type().notNull()
+  },
+  (table) => ({
+    slugIdx: index("repos_slug_idx").on(table.slug)
+  })
+);
+var worktrees = sqliteTable(
+  "worktrees",
+  {
+    // Primary identity
+    worktree_id: text("worktree_id", { length: 36 }).primaryKey(),
+    repo_id: text("repo_id", { length: 36 }).notNull().references(() => repos.repo_id, { onDelete: "cascade" }),
+    created_at: integer("created_at", { mode: "timestamp_ms" }).notNull(),
+    updated_at: integer("updated_at", { mode: "timestamp_ms" }),
+    // User attribution
+    created_by: text("created_by", { length: 36 }).notNull().default("anonymous"),
+    // Materialized for queries
+    name: text("name").notNull(),
+    // "feat-auth", "main"
+    ref: text("ref").notNull(),
+    // Current branch/tag/commit
+    worktree_unique_id: integer("worktree_unique_id").notNull(),
+    // Auto-assigned sequential ID for templates
+    // Board relationship (nullable - worktrees can exist without boards)
+    board_id: text("board_id", { length: 36 }).references(() => boards.board_id, {
+      onDelete: "set null"
+      // If board is deleted, worktree remains but loses board association
+    }),
+    // JSON blob for everything else
+    data: text("data", { mode: "json" }).$type().notNull()
+  },
+  (table) => ({
+    repoIdx: index("worktrees_repo_idx").on(table.repo_id),
+    nameIdx: index("worktrees_name_idx").on(table.name),
+    refIdx: index("worktrees_ref_idx").on(table.ref),
+    boardIdx: index("worktrees_board_idx").on(table.board_id),
+    createdIdx: index("worktrees_created_idx").on(table.created_at),
+    updatedIdx: index("worktrees_updated_idx").on(table.updated_at),
+    // Composite unique constraint (repo + name)
+    uniqueRepoName: index("worktrees_repo_name_unique").on(table.repo_id, table.name)
+  })
+);
+var users = sqliteTable(
+  "users",
+  {
+    // Primary identity
+    user_id: text("user_id", { length: 36 }).primaryKey(),
+    created_at: integer("created_at", { mode: "timestamp_ms" }).notNull(),
+    updated_at: integer("updated_at", { mode: "timestamp_ms" }),
+    // Materialized for auth lookups
+    email: text("email").unique().notNull(),
+    password: text("password").notNull(),
+    // bcrypt hashed
+    // Basic profile (materialized for display)
+    name: text("name"),
+    emoji: text("emoji"),
+    role: text("role", {
+      enum: ["owner", "admin", "member", "viewer"]
+    }).notNull().default("member"),
+    // Onboarding state
+    onboarding_completed: integer("onboarding_completed", { mode: "boolean" }).notNull().default(false),
+    // JSON blob for profile/preferences
+    data: text("data", { mode: "json" }).$type().notNull()
+  },
+  (table) => ({
+    emailIdx: index("users_email_idx").on(table.email)
+  })
+);
+var mcpServers = sqliteTable(
+  "mcp_servers",
+  {
+    // Primary identity
+    mcp_server_id: text("mcp_server_id", { length: 36 }).primaryKey(),
+    created_at: integer("created_at", { mode: "timestamp_ms" }).notNull(),
+    updated_at: integer("updated_at", { mode: "timestamp_ms" }),
+    // Materialized for filtering
+    name: text("name").notNull(),
+    // e.g., "filesystem", "sentry"
+    transport: text("transport", {
+      enum: ["stdio", "http", "sse"]
+    }).notNull(),
+    scope: text("scope", {
+      enum: ["global", "team", "repo", "session"]
+    }).notNull(),
+    enabled: integer("enabled", { mode: "boolean" }).notNull().default(true),
+    // Scope foreign keys (materialized for indexes)
+    owner_user_id: text("owner_user_id", { length: 36 }),
+    team_id: text("team_id", { length: 36 }),
+    repo_id: text("repo_id", { length: 36 }).references(() => repos.repo_id, {
+      onDelete: "cascade"
+    }),
+    session_id: text("session_id", { length: 36 }).references(() => sessions.session_id, {
+      onDelete: "cascade"
+    }),
+    // Source tracking (materialized for queries)
+    source: text("source", {
+      enum: ["user", "imported", "agor"]
+    }).notNull(),
+    // JSON blob for configuration and capabilities
+    data: text("data", { mode: "json" }).$type().notNull()
+  },
+  (table) => ({
+    nameIdx: index("mcp_servers_name_idx").on(table.name),
+    scopeIdx: index("mcp_servers_scope_idx").on(table.scope),
+    ownerIdx: index("mcp_servers_owner_idx").on(table.owner_user_id),
+    teamIdx: index("mcp_servers_team_idx").on(table.team_id),
+    repoIdx: index("mcp_servers_repo_idx").on(table.repo_id),
+    sessionIdx: index("mcp_servers_session_idx").on(table.session_id),
+    enabledIdx: index("mcp_servers_enabled_idx").on(table.enabled)
+  })
+);
+var boardObjects = sqliteTable(
+  "board_objects",
+  {
+    // Primary identity
+    object_id: text("object_id", { length: 36 }).primaryKey(),
+    board_id: text("board_id", { length: 36 }).notNull().references(() => boards.board_id, { onDelete: "cascade" }),
+    created_at: integer("created_at", { mode: "timestamp_ms" }).notNull(),
+    // Worktree reference
+    worktree_id: text("worktree_id", { length: 36 }).notNull().references(() => worktrees.worktree_id, {
+      onDelete: "cascade"
+    }),
+    // Position data (JSON)
+    data: text("data", { mode: "json" }).$type().notNull()
+  },
+  (table) => ({
+    boardIdx: index("board_objects_board_idx").on(table.board_id),
+    worktreeIdx: index("board_objects_worktree_idx").on(table.worktree_id)
+  })
+);
+var sessionMcpServers = sqliteTable(
+  "session_mcp_servers",
+  {
+    session_id: text("session_id", { length: 36 }).notNull().references(() => sessions.session_id, { onDelete: "cascade" }),
+    mcp_server_id: text("mcp_server_id", { length: 36 }).notNull().references(() => mcpServers.mcp_server_id, { onDelete: "cascade" }),
+    enabled: integer("enabled", { mode: "boolean" }).notNull().default(true),
+    added_at: integer("added_at", { mode: "timestamp_ms" }).notNull()
+  },
+  (table) => ({
+    // Composite primary key
+    pk: index("session_mcp_servers_pk").on(table.session_id, table.mcp_server_id),
+    // Indexes for queries
+    sessionIdx: index("session_mcp_servers_session_idx").on(table.session_id),
+    serverIdx: index("session_mcp_servers_server_idx").on(table.mcp_server_id),
+    enabledIdx: index("session_mcp_servers_enabled_idx").on(table.session_id, table.enabled)
+  })
+);
+var boardComments = sqliteTable(
+  "board_comments",
+  {
+    // Primary identity
+    comment_id: text("comment_id", { length: 36 }).primaryKey(),
+    created_at: integer("created_at", { mode: "timestamp_ms" }).notNull(),
+    updated_at: integer("updated_at", { mode: "timestamp_ms" }),
+    // Scoping & authorship
+    board_id: text("board_id", { length: 36 }).notNull().references(() => boards.board_id, { onDelete: "cascade" }),
+    created_by: text("created_by", { length: 36 }).notNull().default("anonymous"),
+    // FLEXIBLE ATTACHMENTS (all optional)
+    // Phase 1: board-level only (all NULL)
+    // Phase 2: object attachments (session, task, message, worktree)
+    // Phase 3: spatial positioning
+    session_id: text("session_id", { length: 36 }).references(() => sessions.session_id, {
+      onDelete: "set null"
+    }),
+    task_id: text("task_id", { length: 36 }).references(() => tasks.task_id, {
+      onDelete: "set null"
+    }),
+    message_id: text("message_id", { length: 36 }).references(() => messages.message_id, {
+      onDelete: "set null"
+    }),
+    worktree_id: text("worktree_id", { length: 36 }).references(() => worktrees.worktree_id, {
+      onDelete: "set null"
+    }),
+    // Content (materialized for display)
+    content: text("content").notNull(),
+    // Markdown-supported text
+    content_preview: text("content_preview").notNull(),
+    // First 200 chars
+    // Thread support (optional)
+    parent_comment_id: text("parent_comment_id", { length: 36 }),
+    // Metadata (materialized for filtering)
+    resolved: integer("resolved", { mode: "boolean" }).notNull().default(false),
+    edited: integer("edited", { mode: "boolean" }).notNull().default(false),
+    // Reactions (for BOTH thread roots and replies)
+    // Stored as JSON array: [{ user_id: "abc", emoji: "👍" }, ...]
+    // Display grouped by emoji: { "👍": ["alice", "bob"], "🎉": ["charlie"] }
+    reactions: text("reactions", { mode: "json" }).$type().notNull().default(sql`'[]'`),
+    // JSON blob for advanced features
+    data: text("data", { mode: "json" }).$type().notNull()
+  },
+  (table) => ({
+    boardIdx: index("board_comments_board_idx").on(table.board_id),
+    sessionIdx: index("board_comments_session_idx").on(table.session_id),
+    taskIdx: index("board_comments_task_idx").on(table.task_id),
+    messageIdx: index("board_comments_message_idx").on(table.message_id),
+    worktreeIdx: index("board_comments_worktree_idx").on(table.worktree_id),
+    createdByIdx: index("board_comments_created_by_idx").on(table.created_by),
+    parentIdx: index("board_comments_parent_idx").on(table.parent_comment_id),
+    createdIdx: index("board_comments_created_idx").on(table.created_at),
+    resolvedIdx: index("board_comments_resolved_idx").on(table.resolved)
+  })
+);
+
+// src/db/client.ts
+var DatabaseConnectionError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "DatabaseConnectionError";
+  }
+};
+function expandPath(path) {
+  if (path.startsWith("~/")) {
+    const home = process.env.HOME || process.env.USERPROFILE || "";
+    return path.replace("~", home);
+  }
+  return path;
+}
+function createLibSQLClient(config) {
+  try {
+    let url = config.url;
+    if (url.startsWith("file:")) {
+      const filePath = url.slice(5);
+      const expandedPath = expandPath(filePath);
+      url = `file:${expandedPath}`;
+    }
+    const clientConfig = { url };
+    if (config.authToken) {
+      clientConfig.authToken = config.authToken;
+    }
+    if (config.syncUrl) {
+      clientConfig.syncUrl = config.syncUrl;
+      clientConfig.syncInterval = config.syncInterval ?? 60;
+    }
+    return createClient(clientConfig);
+  } catch (error) {
+    throw new DatabaseConnectionError(
+      `Failed to create LibSQL client: ${error instanceof Error ? error.message : String(error)}`,
+      error
+    );
+  }
+}
+function createDatabase(config) {
+  const client = createLibSQLClient(config);
+  return drizzle(client, { schema: schema_exports });
+}
+var DEFAULT_DB_PATH = "file:~/.agor/agor.db";
+function createLocalDatabase(customPath) {
+  return createDatabase({ url: customPath ?? DEFAULT_DB_PATH });
+}
+
+// src/db/migrate.ts
+import { sql as sql2 } from "drizzle-orm";
+import { migrate } from "drizzle-orm/libsql/migrator";
+var MigrationError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "MigrationError";
+  }
+};
+async function tablesExist(db) {
+  try {
+    const result = await db.run(sql2`
+      SELECT name FROM sqlite_master
+      WHERE type='table' AND name IN ('sessions', 'tasks', 'boards', 'repos', 'worktrees', 'messages', 'users', 'board_comments')
+    `);
+    return result.rows.length > 0;
+  } catch (error) {
+    throw new MigrationError(
+      `Failed to check if tables exist: ${error instanceof Error ? error.message : String(error)}`,
+      error
+    );
+  }
+}
+async function tableExists(db, tableName) {
+  try {
+    const result = await db.run(sql2`
+      SELECT name FROM sqlite_master
+      WHERE type='table' AND name = ${tableName}
+    `);
+    return result.rows.length > 0;
+  } catch (error) {
+    throw new MigrationError(
+      `Failed to check if table ${tableName} exists: ${error instanceof Error ? error.message : String(error)}`,
+      error
+    );
+  }
+}
+async function createInitialSchema(db) {
+  try {
+    await db.run(sql2`
+      CREATE TABLE IF NOT EXISTS sessions (
+        session_id TEXT PRIMARY KEY,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER,
+        created_by TEXT NOT NULL DEFAULT 'anonymous',
+        status TEXT NOT NULL CHECK(status IN ('idle', 'running', 'completed', 'failed')),
+        agentic_tool TEXT NOT NULL CHECK(agentic_tool IN ('claude-code', 'cursor', 'codex', 'gemini')),
+        board_id TEXT,
+        parent_session_id TEXT,
+        forked_from_session_id TEXT,
+        worktree_id TEXT NOT NULL,
+        data TEXT NOT NULL,
+        FOREIGN KEY (worktree_id) REFERENCES worktrees(worktree_id) ON DELETE CASCADE
+      )
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS sessions_status_idx ON sessions(status)
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS sessions_agentic_tool_idx ON sessions(agentic_tool)
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS sessions_board_idx ON sessions(board_id)
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS sessions_worktree_idx ON sessions(worktree_id)
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS sessions_created_idx ON sessions(created_at)
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS sessions_parent_idx ON sessions(parent_session_id)
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS sessions_forked_idx ON sessions(forked_from_session_id)
+    `);
+    await db.run(sql2`
+      CREATE TABLE IF NOT EXISTS tasks (
+        task_id TEXT PRIMARY KEY,
+        session_id TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        completed_at INTEGER,
+        status TEXT NOT NULL CHECK(status IN ('created', 'running', 'stopping', 'awaiting_permission', 'completed', 'failed', 'stopped')),
+        created_by TEXT NOT NULL DEFAULT 'anonymous',
+        data TEXT NOT NULL,
+        FOREIGN KEY (session_id) REFERENCES sessions(session_id) ON DELETE CASCADE
+      )
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS tasks_session_idx ON tasks(session_id)
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS tasks_status_idx ON tasks(status)
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS tasks_created_idx ON tasks(created_at)
+    `);
+    await db.run(sql2`
+      CREATE TABLE IF NOT EXISTS boards (
+        board_id TEXT PRIMARY KEY,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER,
+        created_by TEXT NOT NULL DEFAULT 'anonymous',
+        name TEXT NOT NULL,
+        slug TEXT UNIQUE,
+        data TEXT NOT NULL
+      )
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS boards_name_idx ON boards(name)
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS boards_slug_idx ON boards(slug)
+    `);
+    await db.run(sql2`
+      CREATE TABLE IF NOT EXISTS repos (
+        repo_id TEXT PRIMARY KEY,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER,
+        slug TEXT NOT NULL UNIQUE,
+        data TEXT NOT NULL
+      )
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS repos_slug_idx ON repos(slug)
+    `);
+    await db.run(sql2`
+      CREATE TABLE IF NOT EXISTS worktrees (
+        worktree_id TEXT PRIMARY KEY,
+        repo_id TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER,
+        created_by TEXT NOT NULL DEFAULT 'anonymous',
+        name TEXT NOT NULL,
+        ref TEXT NOT NULL,
+        worktree_unique_id INTEGER NOT NULL,
+        board_id TEXT,
+        data TEXT NOT NULL,
+        FOREIGN KEY (repo_id) REFERENCES repos(repo_id) ON DELETE CASCADE,
+        FOREIGN KEY (board_id) REFERENCES boards(board_id) ON DELETE SET NULL
+      )
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS worktrees_repo_idx ON worktrees(repo_id)
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS worktrees_name_idx ON worktrees(name)
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS worktrees_ref_idx ON worktrees(ref)
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS worktrees_board_idx ON worktrees(board_id)
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS worktrees_created_idx ON worktrees(created_at)
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS worktrees_updated_idx ON worktrees(updated_at)
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS worktrees_repo_name_unique ON worktrees(repo_id, name)
+    `);
+    await db.run(sql2`
+      CREATE TABLE IF NOT EXISTS messages (
+        message_id TEXT PRIMARY KEY,
+        created_at INTEGER NOT NULL,
+        session_id TEXT NOT NULL,
+        task_id TEXT,
+        type TEXT NOT NULL CHECK(type IN ('user', 'assistant', 'system', 'file-history-snapshot', 'permission_request')),
+        role TEXT NOT NULL CHECK(role IN ('user', 'assistant', 'system')),
+        "index" INTEGER NOT NULL,
+        timestamp INTEGER NOT NULL,
+        content_preview TEXT,
+        data TEXT NOT NULL,
+        FOREIGN KEY (session_id) REFERENCES sessions(session_id) ON DELETE CASCADE,
+        FOREIGN KEY (task_id) REFERENCES tasks(task_id) ON DELETE SET NULL
+      )
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS messages_session_id_idx ON messages(session_id)
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS messages_task_id_idx ON messages(task_id)
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS messages_session_index_idx ON messages(session_id, "index")
+    `);
+    await db.run(sql2`
+      CREATE TABLE IF NOT EXISTS users (
+        user_id TEXT PRIMARY KEY,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER,
+        email TEXT UNIQUE NOT NULL,
+        password TEXT NOT NULL,
+        name TEXT,
+        emoji TEXT,
+        role TEXT NOT NULL DEFAULT 'member' CHECK(role IN ('owner', 'admin', 'member', 'viewer')),
+        onboarding_completed INTEGER NOT NULL DEFAULT 0,
+        data TEXT NOT NULL
+      )
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS users_email_idx ON users(email)
+    `);
+    await db.run(sql2`
+      CREATE TABLE IF NOT EXISTS mcp_servers (
+        mcp_server_id TEXT PRIMARY KEY,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER,
+        name TEXT NOT NULL,
+        transport TEXT NOT NULL CHECK(transport IN ('stdio', 'http', 'sse')),
+        scope TEXT NOT NULL CHECK(scope IN ('global', 'team', 'repo', 'session')),
+        enabled INTEGER NOT NULL DEFAULT 1,
+        owner_user_id TEXT,
+        team_id TEXT,
+        repo_id TEXT,
+        session_id TEXT,
+        source TEXT NOT NULL CHECK(source IN ('user', 'imported', 'agor')),
+        data TEXT NOT NULL,
+        FOREIGN KEY (repo_id) REFERENCES repos(repo_id) ON DELETE CASCADE,
+        FOREIGN KEY (session_id) REFERENCES sessions(session_id) ON DELETE CASCADE
+      )
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS mcp_servers_name_idx ON mcp_servers(name)
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS mcp_servers_scope_idx ON mcp_servers(scope)
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS mcp_servers_owner_idx ON mcp_servers(owner_user_id)
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS mcp_servers_team_idx ON mcp_servers(team_id)
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS mcp_servers_repo_idx ON mcp_servers(repo_id)
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS mcp_servers_session_idx ON mcp_servers(session_id)
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS mcp_servers_enabled_idx ON mcp_servers(enabled)
+    `);
+    await db.run(sql2`
+      CREATE TABLE IF NOT EXISTS session_mcp_servers (
+        session_id TEXT NOT NULL,
+        mcp_server_id TEXT NOT NULL,
+        enabled INTEGER NOT NULL DEFAULT 1,
+        added_at INTEGER NOT NULL,
+        FOREIGN KEY (session_id) REFERENCES sessions(session_id) ON DELETE CASCADE,
+        FOREIGN KEY (mcp_server_id) REFERENCES mcp_servers(mcp_server_id) ON DELETE CASCADE
+      )
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS session_mcp_servers_pk ON session_mcp_servers(session_id, mcp_server_id)
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS session_mcp_servers_session_idx ON session_mcp_servers(session_id)
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS session_mcp_servers_server_idx ON session_mcp_servers(mcp_server_id)
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS session_mcp_servers_enabled_idx ON session_mcp_servers(session_id, enabled)
+    `);
+    await db.run(sql2`
+      CREATE TABLE IF NOT EXISTS board_objects (
+        object_id TEXT PRIMARY KEY,
+        board_id TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        worktree_id TEXT NOT NULL,
+        data TEXT NOT NULL,
+        FOREIGN KEY (board_id) REFERENCES boards(board_id) ON DELETE CASCADE,
+        FOREIGN KEY (worktree_id) REFERENCES worktrees(worktree_id) ON DELETE CASCADE
+      )
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS board_objects_board_idx ON board_objects(board_id)
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS board_objects_worktree_idx ON board_objects(worktree_id)
+    `);
+    await db.run(sql2`
+      CREATE TABLE IF NOT EXISTS board_comments (
+        comment_id TEXT PRIMARY KEY,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER,
+        board_id TEXT NOT NULL,
+        created_by TEXT NOT NULL DEFAULT 'anonymous',
+        session_id TEXT,
+        task_id TEXT,
+        message_id TEXT,
+        worktree_id TEXT,
+        content TEXT NOT NULL,
+        content_preview TEXT NOT NULL,
+        parent_comment_id TEXT,
+        resolved INTEGER NOT NULL DEFAULT 0,
+        edited INTEGER NOT NULL DEFAULT 0,
+        reactions TEXT NOT NULL DEFAULT '[]',
+        data TEXT NOT NULL,
+        FOREIGN KEY (board_id) REFERENCES boards(board_id) ON DELETE CASCADE,
+        FOREIGN KEY (session_id) REFERENCES sessions(session_id) ON DELETE SET NULL,
+        FOREIGN KEY (task_id) REFERENCES tasks(task_id) ON DELETE SET NULL,
+        FOREIGN KEY (message_id) REFERENCES messages(message_id) ON DELETE SET NULL,
+        FOREIGN KEY (worktree_id) REFERENCES worktrees(worktree_id) ON DELETE SET NULL
+      )
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS board_comments_board_idx ON board_comments(board_id)
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS board_comments_session_idx ON board_comments(session_id)
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS board_comments_task_idx ON board_comments(task_id)
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS board_comments_message_idx ON board_comments(message_id)
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS board_comments_worktree_idx ON board_comments(worktree_id)
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS board_comments_created_by_idx ON board_comments(created_by)
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS board_comments_parent_idx ON board_comments(parent_comment_id)
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS board_comments_created_idx ON board_comments(created_at)
+    `);
+    await db.run(sql2`
+      CREATE INDEX IF NOT EXISTS board_comments_resolved_idx ON board_comments(resolved)
+    `);
+  } catch (error) {
+    throw new MigrationError(
+      `Failed to create initial schema: ${error instanceof Error ? error.message : String(error)}`,
+      error
+    );
+  }
+}
+async function runMigrations(db, migrationsFolder = "./migrations") {
+  try {
+    const exists = await tablesExist(db);
+    if (!exists) {
+      console.log("Creating initial database schema...");
+      await createInitialSchema(db);
+      console.log("Initial schema created successfully");
+    } else {
+      console.log("Running migrations...");
+      await migrate(db, { migrationsFolder });
+      console.log("Migrations applied successfully");
+    }
+  } catch (error) {
+    throw new MigrationError(
+      `Migration failed: ${error instanceof Error ? error.message : String(error)}`,
+      error
+    );
+  }
+}
+async function initializeDatabase(db) {
+  try {
+    const exists = await tablesExist(db);
+    if (!exists) {
+      console.log("Initializing database schema...");
+      await createInitialSchema(db);
+      console.log("Database initialized successfully");
+    } else {
+      console.log("Checking for schema updates...");
+      const hasBoardComments = await tableExists(db, "board_comments");
+      if (!hasBoardComments) {
+        console.log("  Adding board_comments table...");
+        await db.run(sql2`
+          CREATE TABLE board_comments (
+            comment_id TEXT PRIMARY KEY,
+            created_at INTEGER NOT NULL,
+            updated_at INTEGER,
+            board_id TEXT NOT NULL,
+            created_by TEXT NOT NULL DEFAULT 'anonymous',
+            session_id TEXT,
+            task_id TEXT,
+            message_id TEXT,
+            worktree_id TEXT,
+            content TEXT NOT NULL,
+            content_preview TEXT NOT NULL,
+            parent_comment_id TEXT,
+            resolved INTEGER NOT NULL DEFAULT 0,
+            edited INTEGER NOT NULL DEFAULT 0,
+            reactions TEXT NOT NULL DEFAULT '[]',
+            data TEXT NOT NULL,
+            FOREIGN KEY (board_id) REFERENCES boards(board_id) ON DELETE CASCADE,
+            FOREIGN KEY (session_id) REFERENCES sessions(session_id) ON DELETE SET NULL,
+            FOREIGN KEY (task_id) REFERENCES tasks(task_id) ON DELETE SET NULL,
+            FOREIGN KEY (message_id) REFERENCES messages(message_id) ON DELETE SET NULL,
+            FOREIGN KEY (worktree_id) REFERENCES worktrees(worktree_id) ON DELETE SET NULL
+          )
+        `);
+        await db.run(sql2`CREATE INDEX board_comments_board_idx ON board_comments(board_id)`);
+        await db.run(sql2`CREATE INDEX board_comments_session_idx ON board_comments(session_id)`);
+        await db.run(sql2`CREATE INDEX board_comments_task_idx ON board_comments(task_id)`);
+        await db.run(sql2`CREATE INDEX board_comments_message_idx ON board_comments(message_id)`);
+        await db.run(sql2`CREATE INDEX board_comments_worktree_idx ON board_comments(worktree_id)`);
+        await db.run(sql2`CREATE INDEX board_comments_created_by_idx ON board_comments(created_by)`);
+        await db.run(
+          sql2`CREATE INDEX board_comments_parent_idx ON board_comments(parent_comment_id)`
+        );
+        await db.run(sql2`CREATE INDEX board_comments_created_idx ON board_comments(created_at)`);
+        await db.run(sql2`CREATE INDEX board_comments_resolved_idx ON board_comments(resolved)`);
+        console.log("  \u2705 board_comments table added");
+      } else {
+        try {
+          const tableInfo = await db.run(sql2`PRAGMA table_info(board_comments)`);
+          const hasReactionsColumn = tableInfo.rows.some(
+            (row) => row.name === "reactions"
+          );
+          if (!hasReactionsColumn) {
+            console.log("  Adding reactions column to board_comments...");
+            await db.run(sql2`
+              ALTER TABLE board_comments ADD COLUMN reactions TEXT NOT NULL DEFAULT '[]'
+            `);
+            console.log("  \u2705 reactions column added");
+          }
+        } catch (error) {
+          console.error("  \u26A0\uFE0F Failed to add reactions column:", error);
+        }
+      }
+      console.log("Schema up to date");
+    }
+  } catch (error) {
+    throw new MigrationError(
+      `Database initialization failed: ${error instanceof Error ? error.message : String(error)}`,
+      error
+    );
+  }
+}
+async function seedInitialData(db) {
+  try {
+    const result = await db.run(sql2`
+      SELECT board_id FROM boards WHERE slug = 'default'
+    `);
+    if (result.rows.length === 0) {
+      const { generateId: generateId2 } = await Promise.resolve().then(() => (init_ids(), ids_exports));
+      const boardId = generateId2();
+      const now = Date.now();
+      await db.run(sql2`
+        INSERT INTO boards (board_id, name, slug, created_at, updated_at, created_by, data)
+        VALUES (
+          ${boardId},
+          ${"Main Board"},
+          ${"default"},
+          ${now},
+          ${now},
+          ${"anonymous"},
+          ${JSON.stringify({
+        description: "Main board for all sessions",
+        sessions: [],
+        color: "#1677ff",
+        icon: "\u2B50"
+      })}
+        )
+      `);
+      console.log("Main Board created");
+    }
+  } catch (error) {
+    throw new MigrationError(
+      `Failed to seed initial data: ${error instanceof Error ? error.message : String(error)}`,
+      error
+    );
+  }
+}
+
+// src/db/repositories/base.ts
+var RepositoryError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "RepositoryError";
+  }
+};
+var EntityNotFoundError = class extends RepositoryError {
+  constructor(entityType, id) {
+    super(`${entityType} with ID '${id}' not found`);
+    this.entityType = entityType;
+    this.id = id;
+    this.name = "EntityNotFoundError";
+  }
+};
+var AmbiguousIdError = class extends RepositoryError {
+  constructor(entityType, prefix, matches) {
+    super(
+      `Ambiguous ID prefix '${prefix}' for ${entityType} (${matches.length} matches: ${matches.slice(0, 3).join(", ")}${matches.length > 3 ? "..." : ""})`
+    );
+    this.entityType = entityType;
+    this.prefix = prefix;
+    this.matches = matches;
+    this.name = "AmbiguousIdError";
+  }
+};
+
+// src/db/repositories/board-comments.ts
+init_ids();
+import { and, eq, isNull, like } from "drizzle-orm";
+function generatePreview(content) {
+  return content.length > 200 ? content.slice(0, 200) + "..." : content;
+}
+var BoardCommentsRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  /**
+   * Convert database row to BoardComment type
+   */
+  rowToComment(row) {
+    const data = row.data;
+    const reactions = row.reactions ? typeof row.reactions === "string" ? JSON.parse(row.reactions) : row.reactions : [];
+    return {
+      comment_id: row.comment_id,
+      board_id: row.board_id,
+      created_by: row.created_by,
+      content: row.content,
+      content_preview: row.content_preview,
+      session_id: row.session_id ? row.session_id : void 0,
+      task_id: row.task_id ? row.task_id : void 0,
+      message_id: row.message_id ? row.message_id : void 0,
+      worktree_id: row.worktree_id ? row.worktree_id : void 0,
+      parent_comment_id: row.parent_comment_id ? row.parent_comment_id : void 0,
+      resolved: Boolean(row.resolved),
+      edited: Boolean(row.edited),
+      reactions,
+      position: data.position,
+      mentions: data.mentions ? data.mentions : void 0,
+      created_at: new Date(row.created_at),
+      updated_at: row.updated_at ? new Date(row.updated_at) : void 0
+    };
+  }
+  /**
+   * Convert BoardComment to database insert format
+   */
+  commentToInsert(comment) {
+    const now = Date.now();
+    const commentId = comment.comment_id ?? generateId();
+    const contentPreview = comment.content_preview ?? (comment.content ? generatePreview(comment.content) : "");
+    return {
+      comment_id: commentId,
+      board_id: comment.board_id,
+      created_by: comment.created_by ?? "anonymous",
+      content: comment.content ?? "",
+      content_preview: contentPreview,
+      session_id: comment.session_id ?? null,
+      task_id: comment.task_id ?? null,
+      message_id: comment.message_id ?? null,
+      worktree_id: comment.worktree_id ?? null,
+      parent_comment_id: comment.parent_comment_id ?? null,
+      resolved: comment.resolved ?? false,
+      edited: comment.edited ?? false,
+      reactions: comment.reactions ?? [],
+      created_at: new Date(comment.created_at ?? now),
+      updated_at: comment.updated_at ? new Date(comment.updated_at) : null,
+      data: {
+        position: comment.position,
+        mentions: comment.mentions
+      }
+    };
+  }
+  /**
+   * Resolve short ID to full ID
+   */
+  async resolveId(id) {
+    if (id.length === 36 && id.includes("-")) {
+      return id;
+    }
+    const normalized = id.replace(/-/g, "").toLowerCase();
+    const pattern = `${normalized}%`;
+    const results = await this.db.select({ comment_id: boardComments.comment_id }).from(boardComments).where(like(boardComments.comment_id, pattern)).all();
+    if (results.length === 0) {
+      throw new EntityNotFoundError("BoardComment", id);
+    }
+    if (results.length > 1) {
+      throw new AmbiguousIdError(
+        "BoardComment",
+        id,
+        results.map((r) => formatShortId(r.comment_id))
+      );
+    }
+    return results[0].comment_id;
+  }
+  /**
+   * Create a new comment
+   */
+  async create(data) {
+    try {
+      const insert = this.commentToInsert(data);
+      await this.db.insert(boardComments).values(insert);
+      const row = await this.db.select().from(boardComments).where(eq(boardComments.comment_id, insert.comment_id)).get();
+      if (!row) {
+        throw new RepositoryError("Failed to retrieve created comment");
+      }
+      return this.rowToComment(row);
+    } catch (error) {
+      if (error instanceof RepositoryError) throw error;
+      throw new RepositoryError(
+        `Failed to create comment: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Find comment by ID (supports short ID)
+   */
+  async findById(id) {
+    try {
+      const fullId = await this.resolveId(id);
+      const row = await this.db.select().from(boardComments).where(eq(boardComments.comment_id, fullId)).get();
+      return row ? this.rowToComment(row) : null;
+    } catch (error) {
+      if (error instanceof EntityNotFoundError) return null;
+      if (error instanceof AmbiguousIdError) throw error;
+      throw new RepositoryError(
+        `Failed to find comment: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Find all comments (optionally filtered by board, session, task, etc.)
+   */
+  async findAll(filters) {
+    try {
+      let query = this.db.select().from(boardComments);
+      const conditions = [];
+      if (filters?.board_id) {
+        conditions.push(eq(boardComments.board_id, filters.board_id));
+      }
+      if (filters?.session_id !== void 0) {
+        if (filters.session_id === null) {
+          conditions.push(isNull(boardComments.session_id));
+        } else {
+          conditions.push(eq(boardComments.session_id, filters.session_id));
+        }
+      }
+      if (filters?.task_id !== void 0) {
+        if (filters.task_id === null) {
+          conditions.push(isNull(boardComments.task_id));
+        } else {
+          conditions.push(eq(boardComments.task_id, filters.task_id));
+        }
+      }
+      if (filters?.message_id !== void 0) {
+        if (filters.message_id === null) {
+          conditions.push(isNull(boardComments.message_id));
+        } else {
+          conditions.push(eq(boardComments.message_id, filters.message_id));
+        }
+      }
+      if (filters?.worktree_id !== void 0) {
+        if (filters.worktree_id === null) {
+          conditions.push(isNull(boardComments.worktree_id));
+        } else {
+          conditions.push(eq(boardComments.worktree_id, filters.worktree_id));
+        }
+      }
+      if (filters?.resolved !== void 0) {
+        conditions.push(eq(boardComments.resolved, filters.resolved));
+      }
+      if (filters?.created_by) {
+        conditions.push(eq(boardComments.created_by, filters.created_by));
+      }
+      if (conditions.length > 0) {
+        query = query.where(and(...conditions));
+      }
+      const rows = await query.all();
+      return rows.map((row) => this.rowToComment(row));
+    } catch (error) {
+      throw new RepositoryError(
+        `Failed to find comments: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Update comment by ID
+   */
+  async update(id, updates) {
+    try {
+      const fullId = await this.resolveId(id);
+      const current = await this.findById(fullId);
+      if (!current) {
+        throw new EntityNotFoundError("BoardComment", id);
+      }
+      const merged = { ...current, ...updates };
+      if (updates.content && !updates.content_preview) {
+        merged.content_preview = generatePreview(updates.content);
+      }
+      if (updates.content && updates.content !== current.content) {
+        merged.edited = true;
+      }
+      const insert = this.commentToInsert(merged);
+      await this.db.update(boardComments).set({
+        content: insert.content,
+        content_preview: insert.content_preview,
+        session_id: insert.session_id,
+        task_id: insert.task_id,
+        message_id: insert.message_id,
+        worktree_id: insert.worktree_id,
+        parent_comment_id: insert.parent_comment_id,
+        resolved: insert.resolved,
+        edited: insert.edited,
+        reactions: insert.reactions,
+        updated_at: /* @__PURE__ */ new Date(),
+        data: insert.data
+      }).where(eq(boardComments.comment_id, fullId));
+      const updated = await this.findById(fullId);
+      if (!updated) {
+        throw new RepositoryError("Failed to retrieve updated comment");
+      }
+      return updated;
+    } catch (error) {
+      if (error instanceof RepositoryError) throw error;
+      if (error instanceof EntityNotFoundError) throw error;
+      throw new RepositoryError(
+        `Failed to update comment: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Delete comment by ID
+   * If deleting a thread root, also deletes all replies (cascade)
+   */
+  async delete(id) {
+    try {
+      const fullId = await this.resolveId(id);
+      await this.db.delete(boardComments).where(eq(boardComments.parent_comment_id, fullId)).run();
+      const result = await this.db.delete(boardComments).where(eq(boardComments.comment_id, fullId)).run();
+      if (result.rowsAffected === 0) {
+        throw new EntityNotFoundError("BoardComment", id);
+      }
+    } catch (error) {
+      if (error instanceof EntityNotFoundError) throw error;
+      throw new RepositoryError(
+        `Failed to delete comment: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Resolve comment (mark as resolved)
+   */
+  async resolve(id) {
+    return this.update(id, { resolved: true });
+  }
+  /**
+   * Unresolve comment (mark as unresolved)
+   */
+  async unresolve(id) {
+    return this.update(id, { resolved: false });
+  }
+  /**
+   * Find comments by board ID with optional filters
+   */
+  async findByBoard(boardId, filters) {
+    return this.findAll({ board_id: boardId, ...filters });
+  }
+  /**
+   * Find comments for a specific session
+   */
+  async findBySession(sessionId) {
+    return this.findAll({ session_id: sessionId });
+  }
+  /**
+   * Find comments for a specific task
+   */
+  async findByTask(taskId) {
+    return this.findAll({ task_id: taskId });
+  }
+  /**
+   * Find comments mentioning a specific user
+   */
+  async findMentions(userId, boardId) {
+    const comments = await this.findAll({ board_id: boardId });
+    return comments.filter((comment) => comment.mentions?.includes(userId));
+  }
+  /**
+   * Batch create comments (for bulk operations)
+   */
+  async bulkCreate(comments) {
+    try {
+      const inserts = comments.map((comment) => this.commentToInsert(comment));
+      await this.db.insert(boardComments).values(inserts);
+      const commentIds = inserts.map((insert) => insert.comment_id);
+      const rows = await this.db.select().from(boardComments).where(
+        eq(
+          boardComments.comment_id,
+          commentIds[0]
+          // TODO: Support proper IN clause when available
+        )
+      ).all();
+      return rows.map((row) => this.rowToComment(row));
+    } catch (error) {
+      throw new RepositoryError(
+        `Failed to bulk create comments: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  // ============================================================================
+  // Phase 2: Threading + Reactions
+  // ============================================================================
+  /**
+   * Toggle a reaction on a comment
+   * If user has already reacted with this emoji, remove it. Otherwise, add it.
+   */
+  async toggleReaction(commentId, userId, emoji) {
+    try {
+      const comment = await this.findById(commentId);
+      if (!comment) {
+        throw new EntityNotFoundError("BoardComment", commentId);
+      }
+      const reactions = comment.reactions || [];
+      const existingIndex = reactions.findIndex((r) => r.user_id === userId && r.emoji === emoji);
+      let updatedReactions;
+      if (existingIndex >= 0) {
+        updatedReactions = reactions.filter((_, i) => i !== existingIndex);
+      } else {
+        updatedReactions = [...reactions, { user_id: userId, emoji }];
+      }
+      return this.update(commentId, { reactions: updatedReactions });
+    } catch (error) {
+      if (error instanceof EntityNotFoundError) throw error;
+      throw new RepositoryError(
+        `Failed to toggle reaction: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Create a reply to a comment (thread root)
+   * Validates that parent exists and is a thread root
+   */
+  async createReply(parentId, data) {
+    try {
+      const parent = await this.findById(parentId);
+      if (!parent) {
+        throw new EntityNotFoundError("BoardComment", parentId);
+      }
+      if (parent.parent_comment_id) {
+        throw new RepositoryError(
+          "Cannot reply to a reply. Replies can only be added to thread roots (2-layer limit)."
+        );
+      }
+      const reply = {
+        ...data,
+        parent_comment_id: parent.comment_id,
+        board_id: parent.board_id,
+        // Inherit board_id from parent
+        // Replies don't have attachments - they inherit context from parent
+        session_id: void 0,
+        task_id: void 0,
+        message_id: void 0,
+        worktree_id: void 0,
+        position: void 0
+      };
+      return this.create(reply);
+    } catch (error) {
+      if (error instanceof EntityNotFoundError) throw error;
+      if (error instanceof RepositoryError) throw error;
+      throw new RepositoryError(
+        `Failed to create reply: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+};
+
+// src/db/repositories/board-objects.ts
+init_ids();
+import { eq as eq2 } from "drizzle-orm";
+var BoardObjectRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  /**
+   * Find all board objects
+   */
+  async findAll() {
+    try {
+      const rows = await this.db.select().from(boardObjects).all();
+      return rows.map(this.rowToEntity);
+    } catch (error) {
+      throw new RepositoryError(
+        `Failed to find all board objects: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Find all board objects for a board
+   */
+  async findByBoardId(boardId) {
+    try {
+      const rows = await this.db.select().from(boardObjects).where(eq2(boardObjects.board_id, boardId)).all();
+      return rows.map(this.rowToEntity);
+    } catch (error) {
+      throw new RepositoryError(
+        `Failed to find board objects: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Find board object by object ID
+   */
+  async findByObjectId(objectId) {
+    try {
+      const row = await this.db.select().from(boardObjects).where(eq2(boardObjects.object_id, objectId)).get();
+      return row ? this.rowToEntity(row) : null;
+    } catch (error) {
+      throw new RepositoryError(
+        `Failed to find board object by object_id: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Find board object by worktree ID
+   */
+  async findByWorktreeId(worktreeId) {
+    try {
+      const row = await this.db.select().from(boardObjects).where(eq2(boardObjects.worktree_id, worktreeId)).get();
+      return row ? this.rowToEntity(row) : null;
+    } catch (error) {
+      throw new RepositoryError(
+        `Failed to find board object by worktree: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Create a board object (add worktree to board)
+   */
+  async create(data) {
+    try {
+      const existing = await this.db.select().from(boardObjects).where(eq2(boardObjects.worktree_id, data.worktree_id)).get();
+      if (existing) {
+        throw new RepositoryError(`Worktree already on a board (object_id: ${existing.object_id})`);
+      }
+      const insert = {
+        object_id: generateId(),
+        board_id: data.board_id,
+        worktree_id: data.worktree_id,
+        created_at: /* @__PURE__ */ new Date(),
+        data: {
+          position: data.position,
+          zone_id: data.zone_id
+        }
+      };
+      await this.db.insert(boardObjects).values(insert);
+      const row = await this.db.select().from(boardObjects).where(eq2(boardObjects.object_id, insert.object_id)).get();
+      if (!row) {
+        throw new RepositoryError("Failed to retrieve created board object");
+      }
+      return this.rowToEntity(row);
+    } catch (error) {
+      if (error instanceof RepositoryError) throw error;
+      throw new RepositoryError(
+        `Failed to create board object: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Update position of board object (preserves zone_id)
+   */
+  async updatePosition(objectId, position) {
+    try {
+      const existing = await this.db.select().from(boardObjects).where(eq2(boardObjects.object_id, objectId)).get();
+      if (!existing) {
+        throw new EntityNotFoundError("BoardObject", objectId);
+      }
+      const existingData = typeof existing.data === "string" ? JSON.parse(existing.data) : existing.data;
+      await this.db.update(boardObjects).set({
+        data: {
+          position,
+          zone_id: existingData.zone_id
+        }
+      }).where(eq2(boardObjects.object_id, objectId));
+      const row = await this.db.select().from(boardObjects).where(eq2(boardObjects.object_id, objectId)).get();
+      if (!row) {
+        throw new RepositoryError("Failed to retrieve updated board object");
+      }
+      return this.rowToEntity(row);
+    } catch (error) {
+      if (error instanceof EntityNotFoundError) throw error;
+      throw new RepositoryError(
+        `Failed to update board object position: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Update zone pinning for board object
+   */
+  async updateZone(objectId, zoneId) {
+    try {
+      const existing = await this.db.select().from(boardObjects).where(eq2(boardObjects.object_id, objectId)).get();
+      if (!existing) {
+        throw new EntityNotFoundError("BoardObject", objectId);
+      }
+      const existingData = typeof existing.data === "string" ? JSON.parse(existing.data) : existing.data;
+      await this.db.update(boardObjects).set({
+        data: {
+          position: existingData.position,
+          // Convert null to undefined for consistency
+          zone_id: zoneId === null ? void 0 : zoneId
+        }
+      }).where(eq2(boardObjects.object_id, objectId));
+      const row = await this.db.select().from(boardObjects).where(eq2(boardObjects.object_id, objectId)).get();
+      if (!row) {
+        throw new RepositoryError("Failed to retrieve updated board object");
+      }
+      return this.rowToEntity(row);
+    } catch (error) {
+      if (error instanceof EntityNotFoundError) throw error;
+      throw new RepositoryError(
+        `Failed to update board object zone: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Remove board object (remove entity from board)
+   */
+  async remove(objectId) {
+    try {
+      const result = await this.db.delete(boardObjects).where(eq2(boardObjects.object_id, objectId)).run();
+      if (result.rowsAffected === 0) {
+        throw new EntityNotFoundError("BoardObject", objectId);
+      }
+    } catch (error) {
+      if (error instanceof EntityNotFoundError) throw error;
+      throw new RepositoryError(
+        `Failed to remove board object: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Remove all board objects for a worktree
+   */
+  async removeByWorktreeId(worktreeId) {
+    try {
+      await this.db.delete(boardObjects).where(eq2(boardObjects.worktree_id, worktreeId));
+    } catch (error) {
+      throw new RepositoryError(
+        `Failed to remove board objects by worktree: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Convert database row to entity
+   */
+  rowToEntity(row) {
+    const data = typeof row.data === "string" ? JSON.parse(row.data) : row.data;
+    return {
+      object_id: row.object_id,
+      board_id: row.board_id,
+      worktree_id: row.worktree_id,
+      position: data.position,
+      zone_id: data.zone_id,
+      created_at: new Date(row.created_at).toISOString()
+    };
+  }
+};
+
+// src/db/repositories/boards.ts
+init_ids();
+import { eq as eq3, like as like2 } from "drizzle-orm";
+var BoardRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  /**
+   * Convert database row to Board type
+   */
+  rowToBoard(row) {
+    const data = row.data;
+    return {
+      board_id: row.board_id,
+      name: row.name,
+      slug: row.slug || void 0,
+      created_at: new Date(row.created_at).toISOString(),
+      last_updated: row.updated_at ? new Date(row.updated_at).toISOString() : new Date(row.created_at).toISOString(),
+      created_by: row.created_by,
+      ...data
+    };
+  }
+  /**
+   * Convert Board to database insert format
+   */
+  boardToInsert(board) {
+    const now = Date.now();
+    const boardId = board.board_id ?? generateId();
+    return {
+      board_id: boardId,
+      name: board.name ?? "Untitled Board",
+      slug: board.slug ?? null,
+      created_at: new Date(board.created_at ?? now),
+      updated_at: board.last_updated ? new Date(board.last_updated) : new Date(now),
+      created_by: board.created_by ?? "anonymous",
+      data: {
+        description: board.description,
+        color: board.color,
+        icon: board.icon,
+        objects: board.objects,
+        custom_context: board.custom_context
+      }
+    };
+  }
+  /**
+   * Resolve short ID to full ID
+   */
+  async resolveId(id) {
+    if (id.length === 36 && id.includes("-")) {
+      return id;
+    }
+    const normalized = id.replace(/-/g, "").toLowerCase();
+    const pattern = `${normalized}%`;
+    const results = await this.db.select({ board_id: boards.board_id }).from(boards).where(like2(boards.board_id, pattern)).all();
+    if (results.length === 0) {
+      throw new EntityNotFoundError("Board", id);
+    }
+    if (results.length > 1) {
+      throw new AmbiguousIdError(
+        "Board",
+        id,
+        results.map((r) => formatShortId(r.board_id))
+      );
+    }
+    return results[0].board_id;
+  }
+  /**
+   * Create a new board
+   */
+  async create(data) {
+    try {
+      const insert = this.boardToInsert(data);
+      await this.db.insert(boards).values(insert);
+      const row = await this.db.select().from(boards).where(eq3(boards.board_id, insert.board_id)).get();
+      if (!row) {
+        throw new RepositoryError("Failed to retrieve created board");
+      }
+      return this.rowToBoard(row);
+    } catch (error) {
+      if (error instanceof RepositoryError) throw error;
+      throw new RepositoryError(
+        `Failed to create board: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Find board by ID (supports short ID)
+   */
+  async findById(id) {
+    try {
+      const fullId = await this.resolveId(id);
+      const row = await this.db.select().from(boards).where(eq3(boards.board_id, fullId)).get();
+      return row ? this.rowToBoard(row) : null;
+    } catch (error) {
+      if (error instanceof EntityNotFoundError) return null;
+      if (error instanceof AmbiguousIdError) throw error;
+      throw new RepositoryError(
+        `Failed to find board: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Find board by slug
+   */
+  async findBySlug(slug) {
+    try {
+      const row = await this.db.select().from(boards).where(eq3(boards.slug, slug)).get();
+      return row ? this.rowToBoard(row) : null;
+    } catch (error) {
+      throw new RepositoryError(
+        `Failed to find board by slug: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Find all boards
+   */
+  async findAll() {
+    try {
+      const rows = await this.db.select().from(boards).all();
+      return rows.map((row) => this.rowToBoard(row));
+    } catch (error) {
+      throw new RepositoryError(
+        `Failed to find all boards: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Update board by ID
+   */
+  async update(id, updates) {
+    try {
+      const fullId = await this.resolveId(id);
+      const current = await this.findById(fullId);
+      if (!current) {
+        throw new EntityNotFoundError("Board", id);
+      }
+      const merged = { ...current, ...updates };
+      const insert = this.boardToInsert(merged);
+      await this.db.update(boards).set({
+        name: insert.name,
+        slug: insert.slug,
+        updated_at: /* @__PURE__ */ new Date(),
+        data: insert.data
+      }).where(eq3(boards.board_id, fullId));
+      const updated = await this.findById(fullId);
+      if (!updated) {
+        throw new RepositoryError("Failed to retrieve updated board");
+      }
+      return updated;
+    } catch (error) {
+      if (error instanceof RepositoryError) throw error;
+      if (error instanceof EntityNotFoundError) throw error;
+      throw new RepositoryError(
+        `Failed to update board: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Delete board by ID
+   */
+  async delete(id) {
+    try {
+      const fullId = await this.resolveId(id);
+      const result = await this.db.delete(boards).where(eq3(boards.board_id, fullId)).run();
+      if (result.rowsAffected === 0) {
+        throw new EntityNotFoundError("Board", id);
+      }
+    } catch (error) {
+      if (error instanceof EntityNotFoundError) throw error;
+      throw new RepositoryError(
+        `Failed to delete board: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * DEPRECATED: Add session to board
+   * Use board-objects service instead
+   */
+  // async addSession(boardId: string, sessionId: string): Promise<Board> {
+  //   throw new RepositoryError('addSession is deprecated - use board-objects service');
+  // }
+  /**
+   * DEPRECATED: Remove session from board
+   * Use board-objects service instead
+   */
+  // async removeSession(boardId: string, sessionId: string): Promise<Board> {
+  //   throw new RepositoryError('removeSession is deprecated - use board-objects service');
+  // }
+  /**
+   * Get default board (or create if doesn't exist)
+   */
+  async getDefault() {
+    try {
+      const defaultBoard = await this.findBySlug("default");
+      if (defaultBoard) {
+        return defaultBoard;
+      }
+      return this.create({
+        name: "Main Board",
+        slug: "default",
+        description: "Main board for all sessions",
+        color: "#1677ff",
+        icon: "\u2B50"
+      });
+    } catch (error) {
+      throw new RepositoryError(
+        `Failed to get default board: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Atomically add or update a board object (text label or zone)
+   *
+   * Uses read-modify-write approach with proper serialization via update() method.
+   */
+  async upsertBoardObject(boardId, objectId, objectData) {
+    try {
+      const fullId = await this.resolveId(boardId);
+      const current = await this.findById(fullId);
+      if (!current) {
+        throw new EntityNotFoundError("Board", boardId);
+      }
+      const updatedObjects = { ...current.objects || {}, [objectId]: objectData };
+      return this.update(fullId, { objects: updatedObjects });
+    } catch (error) {
+      if (error instanceof RepositoryError) throw error;
+      if (error instanceof EntityNotFoundError) throw error;
+      throw new RepositoryError(
+        `Failed to upsert board object: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Atomically remove a board object
+   */
+  async removeBoardObject(boardId, objectId) {
+    try {
+      const fullId = await this.resolveId(boardId);
+      const current = await this.findById(fullId);
+      if (!current) {
+        throw new EntityNotFoundError("Board", boardId);
+      }
+      const updatedObjects = { ...current.objects || {} };
+      delete updatedObjects[objectId];
+      return this.update(fullId, { objects: updatedObjects });
+    } catch (error) {
+      if (error instanceof RepositoryError) throw error;
+      if (error instanceof EntityNotFoundError) throw error;
+      throw new RepositoryError(
+        `Failed to remove board object: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Batch upsert multiple objects (sequential atomic updates)
+   *
+   * Note: Not a single transaction - each object is updated atomically.
+   * This is safe for independent objects but may have partial failures.
+   */
+  async batchUpsertBoardObjects(boardId, objects) {
+    try {
+      for (const [objectId, objectData] of Object.entries(objects)) {
+        await this.upsertBoardObject(boardId, objectId, objectData);
+      }
+      const fullId = await this.resolveId(boardId);
+      const updated = await this.findById(fullId);
+      if (!updated) {
+        throw new RepositoryError("Failed to retrieve updated board");
+      }
+      return updated;
+    } catch (error) {
+      if (error instanceof RepositoryError) throw error;
+      if (error instanceof EntityNotFoundError) throw error;
+      throw new RepositoryError(
+        `Failed to batch upsert board objects: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * DEPRECATED: Delete a zone and handle associated sessions
+   * TODO: Reimplement using board-objects table
+   */
+  async deleteZone(boardId, objectId, _deleteAssociatedSessions) {
+    const updatedBoard = await this.removeBoardObject(boardId, objectId);
+    return {
+      board: updatedBoard,
+      affectedSessions: []
+      // No sessions to track yet
+    };
+  }
+};
+
+// src/db/repositories/mcp-servers.ts
+init_ids();
+import { and as and2, eq as eq4, like as like3 } from "drizzle-orm";
+var MCPServerRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  /**
+   * Convert database row to MCPServer type
+   */
+  rowToMCPServer(row) {
+    return {
+      mcp_server_id: row.mcp_server_id,
+      name: row.name,
+      transport: row.transport,
+      scope: row.scope,
+      enabled: Boolean(row.enabled),
+      source: row.source,
+      created_at: new Date(row.created_at),
+      updated_at: row.updated_at ? new Date(row.updated_at) : new Date(row.created_at),
+      // Optional fields from JSON data
+      display_name: row.data.display_name,
+      description: row.data.description,
+      import_path: row.data.import_path,
+      // Transport config
+      command: row.data.command,
+      args: row.data.args,
+      url: row.data.url,
+      env: row.data.env,
+      // Scope foreign keys (nullable UUID strings - DB stores null, types expect undefined)
+      owner_user_id: row.owner_user_id ?? void 0,
+      team_id: row.team_id ?? void 0,
+      repo_id: row.repo_id ?? void 0,
+      session_id: row.session_id ?? void 0,
+      // Capabilities
+      tools: row.data.tools,
+      resources: row.data.resources,
+      prompts: row.data.prompts
+    };
+  }
+  /**
+   * Convert MCPServer to database insert format
+   */
+  mcpServerToInsert(data) {
+    const now = Date.now();
+    const serverId = "mcp_server_id" in data && data.mcp_server_id ? data.mcp_server_id : generateId();
+    return {
+      mcp_server_id: serverId,
+      created_at: new Date(now),
+      updated_at: new Date(now),
+      // Materialized columns
+      name: data.name,
+      transport: data.transport,
+      scope: data.scope,
+      enabled: data.enabled ?? true,
+      source: data.source ?? "user",
+      // Scope foreign keys
+      owner_user_id: data.owner_user_id ?? null,
+      team_id: data.team_id ?? null,
+      repo_id: data.repo_id ?? null,
+      session_id: data.session_id ?? null,
+      // JSON blob
+      data: {
+        display_name: data.display_name,
+        description: data.description,
+        import_path: data.import_path,
+        command: data.command,
+        args: data.args,
+        url: data.url,
+        env: data.env,
+        tools: "tools" in data ? data.tools : void 0,
+        resources: "resources" in data ? data.resources : void 0,
+        prompts: "prompts" in data ? data.prompts : void 0
+      }
+    };
+  }
+  /**
+   * Resolve short ID to full ID
+   */
+  async resolveId(id) {
+    if (id.length === 36 && id.includes("-")) {
+      return id;
+    }
+    const normalized = id.replace(/-/g, "").toLowerCase();
+    const pattern = `${normalized}%`;
+    const results = await this.db.select({ mcp_server_id: mcpServers.mcp_server_id }).from(mcpServers).where(like3(mcpServers.mcp_server_id, pattern)).all();
+    if (results.length === 0) {
+      throw new EntityNotFoundError("MCPServer", id);
+    }
+    if (results.length > 1) {
+      throw new AmbiguousIdError(
+        "MCPServer",
+        id,
+        results.map((r) => formatShortId(r.mcp_server_id))
+      );
+    }
+    return results[0].mcp_server_id;
+  }
+  /**
+   * Create a new MCP server
+   */
+  async create(data) {
+    try {
+      const insert = this.mcpServerToInsert(data);
+      await this.db.insert(mcpServers).values(insert);
+      const row = await this.db.select().from(mcpServers).where(eq4(mcpServers.mcp_server_id, insert.mcp_server_id)).get();
+      if (!row) {
+        throw new RepositoryError("Failed to retrieve created MCP server");
+      }
+      return this.rowToMCPServer(row);
+    } catch (error) {
+      if (error instanceof RepositoryError) throw error;
+      throw new RepositoryError(
+        `Failed to create MCP server: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Find MCP server by ID (supports short ID)
+   */
+  async findById(id) {
+    try {
+      const fullId = await this.resolveId(id);
+      const row = await this.db.select().from(mcpServers).where(eq4(mcpServers.mcp_server_id, fullId)).get();
+      return row ? this.rowToMCPServer(row) : null;
+    } catch (error) {
+      if (error instanceof EntityNotFoundError) return null;
+      if (error instanceof AmbiguousIdError) throw error;
+      throw new RepositoryError(
+        `Failed to find MCP server: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Find all MCP servers
+   */
+  async findAll(filters) {
+    try {
+      let query = this.db.select().from(mcpServers);
+      const conditions = [];
+      if (filters?.scope) {
+        conditions.push(eq4(mcpServers.scope, filters.scope));
+      }
+      if (filters?.scopeId) {
+        if (filters.scope === "global") {
+          conditions.push(eq4(mcpServers.owner_user_id, filters.scopeId));
+        } else if (filters.scope === "team") {
+          conditions.push(eq4(mcpServers.team_id, filters.scopeId));
+        } else if (filters.scope === "repo") {
+          conditions.push(eq4(mcpServers.repo_id, filters.scopeId));
+        } else if (filters.scope === "session") {
+          conditions.push(eq4(mcpServers.session_id, filters.scopeId));
+        }
+      }
+      if (filters?.transport) {
+        conditions.push(eq4(mcpServers.transport, filters.transport));
+      }
+      if (filters?.enabled !== void 0) {
+        conditions.push(eq4(mcpServers.enabled, filters.enabled));
+      }
+      if (filters?.source) {
+        conditions.push(eq4(mcpServers.source, filters.source));
+      }
+      if (conditions.length > 0) {
+        query = query.where(and2(...conditions));
+      }
+      const rows = await query.all();
+      return rows.map((row) => this.rowToMCPServer(row));
+    } catch (error) {
+      throw new RepositoryError(
+        `Failed to find MCP servers: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Find MCP servers by scope
+   */
+  async findByScope(scope, scopeId) {
+    return this.findAll({ scope, scopeId });
+  }
+  /**
+   * Update MCP server by ID
+   */
+  async update(id, updates) {
+    try {
+      const fullId = await this.resolveId(id);
+      const current = await this.findById(fullId);
+      if (!current) {
+        throw new EntityNotFoundError("MCPServer", id);
+      }
+      const merged = { ...current, ...updates };
+      const insert = this.mcpServerToInsert(merged);
+      await this.db.update(mcpServers).set({
+        enabled: insert.enabled,
+        updated_at: /* @__PURE__ */ new Date(),
+        data: insert.data
+      }).where(eq4(mcpServers.mcp_server_id, fullId));
+      const updated = await this.findById(fullId);
+      if (!updated) {
+        throw new RepositoryError("Failed to retrieve updated MCP server");
+      }
+      return updated;
+    } catch (error) {
+      if (error instanceof RepositoryError) throw error;
+      if (error instanceof EntityNotFoundError) throw error;
+      throw new RepositoryError(
+        `Failed to update MCP server: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Delete MCP server by ID
+   */
+  async delete(id) {
+    try {
+      const fullId = await this.resolveId(id);
+      const result = await this.db.delete(mcpServers).where(eq4(mcpServers.mcp_server_id, fullId)).run();
+      if (result.rowsAffected === 0) {
+        throw new EntityNotFoundError("MCPServer", id);
+      }
+    } catch (error) {
+      if (error instanceof EntityNotFoundError) throw error;
+      throw new RepositoryError(
+        `Failed to delete MCP server: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Count total MCP servers
+   */
+  async count(filters) {
+    try {
+      const servers = await this.findAll(filters);
+      return servers.length;
+    } catch (error) {
+      throw new RepositoryError(
+        `Failed to count MCP servers: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+};
+
+// src/db/repositories/messages.ts
+import { eq as eq5 } from "drizzle-orm";
+var MessagesRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  /**
+   * Convert database row to Message type
+   */
+  rowToMessage(row) {
+    return {
+      message_id: row.message_id,
+      session_id: row.session_id,
+      task_id: row.task_id ? row.task_id : void 0,
+      type: row.type,
+      role: row.role,
+      index: row.index,
+      timestamp: new Date(row.timestamp).toISOString(),
+      content_preview: row.content_preview || "",
+      content: row.data.content,
+      tool_uses: row.data.tool_uses,
+      metadata: row.data.metadata
+    };
+  }
+  /**
+   * Convert Message to database row
+   */
+  messageToRow(message) {
+    return {
+      message_id: message.message_id,
+      created_at: /* @__PURE__ */ new Date(),
+      session_id: message.session_id,
+      task_id: message.task_id,
+      type: message.type,
+      role: message.role,
+      index: message.index,
+      timestamp: new Date(message.timestamp),
+      content_preview: message.content_preview,
+      data: {
+        content: message.content,
+        tool_uses: message.tool_uses,
+        metadata: message.metadata
+      }
+    };
+  }
+  /**
+   * Create a single message
+   */
+  async create(message) {
+    const row = this.messageToRow(message);
+    const [inserted] = await this.db.insert(messages).values(row).returning();
+    return this.rowToMessage(inserted);
+  }
+  /**
+   * Bulk insert messages (optimized for session loading)
+   */
+  async createMany(messageList) {
+    const rows = messageList.map((m) => this.messageToRow(m));
+    const inserted = await this.db.insert(messages).values(rows).returning();
+    return inserted.map((r) => this.rowToMessage(r));
+  }
+  /**
+   * Get message by ID
+   */
+  async findById(messageId) {
+    const rows = await this.db.select().from(messages).where(eq5(messages.message_id, messageId)).limit(1);
+    return rows[0] ? this.rowToMessage(rows[0]) : null;
+  }
+  /**
+   * Get all messages (used by FeathersJS service adapter)
+   */
+  async findAll() {
+    const rows = await this.db.select().from(messages).orderBy(messages.index);
+    return rows.map((r) => this.rowToMessage(r));
+  }
+  /**
+   * Get all messages for a session (ordered by index)
+   */
+  async findBySessionId(sessionId) {
+    const rows = await this.db.select().from(messages).where(eq5(messages.session_id, sessionId)).orderBy(messages.index);
+    return rows.map((r) => this.rowToMessage(r));
+  }
+  /**
+   * Get all messages for a task (ordered by index)
+   */
+  async findByTaskId(taskId) {
+    const rows = await this.db.select().from(messages).where(eq5(messages.task_id, taskId)).orderBy(messages.index);
+    return rows.map((r) => this.rowToMessage(r));
+  }
+  /**
+   * Get messages in a range for a session
+   * Used for task message_range queries
+   */
+  async findByRange(sessionId, startIndex, endIndex) {
+    const rows = await this.db.select().from(messages).where(eq5(messages.session_id, sessionId)).orderBy(messages.index);
+    return rows.filter((r) => r.index >= startIndex && r.index <= endIndex).map((r) => this.rowToMessage(r));
+  }
+  /**
+   * Update message (used by FeathersJS service adapter)
+   */
+  async update(messageId, updates) {
+    const existing = await this.findById(messageId);
+    if (!existing) {
+      throw new Error(`Message ${messageId} not found`);
+    }
+    const updated = { ...existing, ...updates };
+    const row = this.messageToRow(updated);
+    const [result] = await this.db.update(messages).set(row).where(eq5(messages.message_id, messageId)).returning();
+    return this.rowToMessage(result);
+  }
+  /**
+   * Update message task assignment
+   */
+  async assignToTask(messageId, taskId) {
+    const [updated] = await this.db.update(messages).set({ task_id: taskId }).where(eq5(messages.message_id, messageId)).returning();
+    return this.rowToMessage(updated);
+  }
+  /**
+   * Delete all messages for a session (cascades automatically via FK)
+   */
+  async deleteBySessionId(sessionId) {
+    await this.db.delete(messages).where(eq5(messages.session_id, sessionId));
+  }
+  /**
+   * Delete a single message
+   */
+  async delete(messageId) {
+    await this.db.delete(messages).where(eq5(messages.message_id, messageId));
+  }
+};
+
+// src/db/repositories/repos.ts
+init_ids();
+import { eq as eq6, like as like4, sql as sql3 } from "drizzle-orm";
+var RepoRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  /**
+   * Convert database row to Repo type
+   */
+  rowToRepo(row) {
+    return {
+      repo_id: row.repo_id,
+      slug: row.slug,
+      created_at: new Date(row.created_at).toISOString(),
+      last_updated: row.updated_at ? new Date(row.updated_at).toISOString() : new Date(row.created_at).toISOString(),
+      ...row.data
+    };
+  }
+  /**
+   * Convert Repo to database insert format
+   */
+  repoToInsert(repo) {
+    const now = Date.now();
+    const repoId = repo.repo_id ?? generateId();
+    if (!repo.slug) {
+      throw new RepositoryError("slug is required when creating a repo");
+    }
+    if (!repo.remote_url) {
+      throw new RepositoryError("Repo must have a remote_url");
+    }
+    return {
+      repo_id: repoId,
+      slug: repo.slug,
+      created_at: new Date(repo.created_at ?? now),
+      updated_at: repo.last_updated ? new Date(repo.last_updated) : new Date(now),
+      data: {
+        name: repo.name ?? repo.slug,
+        remote_url: repo.remote_url,
+        local_path: repo.local_path ?? "",
+        default_branch: repo.default_branch,
+        environment_config: repo.environment_config
+      }
+    };
+  }
+  /**
+   * Resolve short ID to full ID
+   */
+  async resolveId(id) {
+    if (id.length === 36 && id.includes("-")) {
+      return id;
+    }
+    const normalized = id.replace(/-/g, "").toLowerCase();
+    const pattern = `${normalized}%`;
+    const results = await this.db.select({ repo_id: repos.repo_id }).from(repos).where(like4(repos.repo_id, pattern)).all();
+    if (results.length === 0) {
+      throw new EntityNotFoundError("Repo", id);
+    }
+    if (results.length > 1) {
+      throw new AmbiguousIdError(
+        "Repo",
+        id,
+        results.map((r) => formatShortId(r.repo_id))
+      );
+    }
+    return results[0].repo_id;
+  }
+  /**
+   * Create a new repo
+   */
+  async create(data) {
+    try {
+      const insert = this.repoToInsert(data);
+      await this.db.insert(repos).values(insert);
+      const row = await this.db.select().from(repos).where(eq6(repos.repo_id, insert.repo_id)).get();
+      if (!row) {
+        throw new RepositoryError("Failed to retrieve created repo");
+      }
+      return this.rowToRepo(row);
+    } catch (error) {
+      if (error instanceof RepositoryError) throw error;
+      throw new RepositoryError(
+        `Failed to create repo: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Find repo by ID (supports short ID)
+   */
+  async findById(id) {
+    try {
+      const fullId = await this.resolveId(id);
+      const row = await this.db.select().from(repos).where(eq6(repos.repo_id, fullId)).get();
+      return row ? this.rowToRepo(row) : null;
+    } catch (error) {
+      if (error instanceof EntityNotFoundError) return null;
+      if (error instanceof AmbiguousIdError) throw error;
+      throw new RepositoryError(
+        `Failed to find repo: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Find repo by slug (exact match)
+   */
+  async findBySlug(slug) {
+    try {
+      const row = await this.db.select().from(repos).where(eq6(repos.slug, slug)).get();
+      return row ? this.rowToRepo(row) : null;
+    } catch (error) {
+      throw new RepositoryError(
+        `Failed to find repo by slug: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Find all repos
+   */
+  async findAll() {
+    try {
+      const rows = await this.db.select().from(repos).all();
+      return rows.map((row) => this.rowToRepo(row));
+    } catch (error) {
+      throw new RepositoryError(
+        `Failed to find all repos: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Find managed repos only (DEPRECATED: all repos are managed now)
+   *
+   * Kept for backwards compatibility - returns all repos.
+   */
+  async findManaged() {
+    return this.findAll();
+  }
+  /**
+   * Update repo by ID
+   */
+  async update(id, updates) {
+    try {
+      const fullId = await this.resolveId(id);
+      const current = await this.findById(fullId);
+      if (!current) {
+        throw new EntityNotFoundError("Repo", id);
+      }
+      const merged = { ...current, ...updates };
+      const insert = this.repoToInsert(merged);
+      await this.db.update(repos).set({
+        slug: insert.slug,
+        updated_at: /* @__PURE__ */ new Date(),
+        data: insert.data
+      }).where(eq6(repos.repo_id, fullId));
+      const updated = await this.findById(fullId);
+      if (!updated) {
+        throw new RepositoryError("Failed to retrieve updated repo");
+      }
+      return updated;
+    } catch (error) {
+      if (error instanceof RepositoryError) throw error;
+      if (error instanceof EntityNotFoundError) throw error;
+      throw new RepositoryError(
+        `Failed to update repo: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Delete repo by ID
+   */
+  async delete(id) {
+    try {
+      const fullId = await this.resolveId(id);
+      const result = await this.db.delete(repos).where(eq6(repos.repo_id, fullId)).run();
+      if (result.rowsAffected === 0) {
+        throw new EntityNotFoundError("Repo", id);
+      }
+    } catch (error) {
+      if (error instanceof EntityNotFoundError) throw error;
+      throw new RepositoryError(
+        `Failed to delete repo: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * @deprecated Worktrees are now first-class entities in their own table.
+   * Use WorktreeRepository instead.
+   */
+  async addWorktree() {
+    throw new Error("addWorktree is deprecated. Use WorktreeRepository.create() instead.");
+  }
+  /**
+   * @deprecated Worktrees are now first-class entities in their own table.
+   * Use WorktreeRepository instead.
+   */
+  async removeWorktree() {
+    throw new Error("removeWorktree is deprecated. Use WorktreeRepository.delete() instead.");
+  }
+  /**
+   * Count total repos
+   */
+  async count() {
+    try {
+      const result = await this.db.select({ count: sql3`count(*)` }).from(repos).get();
+      return result?.count ?? 0;
+    } catch (error) {
+      throw new RepositoryError(
+        `Failed to count repos: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+};
+
+// src/db/repositories/session-mcp-servers.ts
+import { and as and3, eq as eq8 } from "drizzle-orm";
+
+// src/types/session.ts
+var SessionStatus = {
+  IDLE: "idle",
+  RUNNING: "running",
+  COMPLETED: "completed",
+  FAILED: "failed"
+};
+
+// src/types/task.ts
+var TaskStatus = {
+  CREATED: "created",
+  RUNNING: "running",
+  STOPPING: "stopping",
+  // Stop requested, waiting for SDK to halt
+  AWAITING_PERMISSION: "awaiting_permission",
+  COMPLETED: "completed",
+  FAILED: "failed",
+  STOPPED: "stopped"
+  // User-requested stop (distinct from failed)
+};
+
+// src/db/repositories/sessions.ts
+init_ids();
+import { eq as eq7, like as like5, or, sql as sql4 } from "drizzle-orm";
+var SessionRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  /**
+   * Convert database row to Session type
+   */
+  rowToSession(row) {
+    const genealogyData = row.data.genealogy || { children: [] };
+    return {
+      session_id: row.session_id,
+      status: row.status,
+      agentic_tool: row.agentic_tool,
+      created_at: new Date(row.created_at).toISOString(),
+      last_updated: row.updated_at ? new Date(row.updated_at).toISOString() : new Date(row.created_at).toISOString(),
+      created_by: row.created_by,
+      worktree_id: row.worktree_id,
+      ...row.data,
+      tasks: row.data.tasks.map((id) => id),
+      genealogy: {
+        parent_session_id: row.parent_session_id,
+        forked_from_session_id: row.forked_from_session_id,
+        fork_point_task_id: genealogyData.fork_point_task_id,
+        spawn_point_task_id: genealogyData.spawn_point_task_id,
+        children: genealogyData.children.map((id) => id)
+      },
+      permission_config: row.data.permission_config
+    };
+  }
+  /**
+   * Convert Session to database insert format
+   */
+  sessionToInsert(session) {
+    const now = Date.now();
+    const sessionId = session.session_id ?? generateId();
+    if (!session.worktree_id) {
+      throw new RepositoryError("Session must have a worktree_id");
+    }
+    return {
+      session_id: sessionId,
+      created_at: new Date(session.created_at ? session.created_at : now),
+      updated_at: session.last_updated ? new Date(session.last_updated) : new Date(now),
+      status: session.status ?? SessionStatus.IDLE,
+      agentic_tool: session.agentic_tool ?? "claude-code",
+      created_by: session.created_by ?? "anonymous",
+      board_id: null,
+      // Board ID tracked separately in boards.sessions array
+      parent_session_id: session.genealogy?.parent_session_id ?? null,
+      forked_from_session_id: session.genealogy?.forked_from_session_id ?? null,
+      worktree_id: session.worktree_id,
+      data: {
+        agentic_tool_version: session.agentic_tool_version,
+        sdk_session_id: session.sdk_session_id,
+        // Preserve SDK session ID for conversation continuity
+        mcp_token: session.mcp_token,
+        // MCP authentication token for Agor self-access
+        title: session.title,
+        description: session.description,
+        git_state: session.git_state ?? {
+          ref: "main",
+          base_sha: "",
+          current_sha: ""
+        },
+        genealogy: session.genealogy ?? {
+          children: []
+        },
+        contextFiles: session.contextFiles ?? [],
+        tasks: session.tasks ?? [],
+        message_count: session.message_count ?? 0,
+        tool_use_count: session.tool_use_count ?? 0,
+        permission_config: session.permission_config,
+        model_config: session.model_config,
+        custom_context: session.custom_context
+      }
+    };
+  }
+  /**
+   * Resolve short ID to full ID
+   */
+  async resolveId(id) {
+    if (id.length === 36 && id.includes("-")) {
+      return id;
+    }
+    const normalized = id.replace(/-/g, "").toLowerCase();
+    const pattern = `${normalized}%`;
+    const results = await this.db.select({ session_id: sessions.session_id }).from(sessions).where(like5(sessions.session_id, pattern)).all();
+    if (results.length === 0) {
+      throw new EntityNotFoundError("Session", id);
+    }
+    if (results.length > 1) {
+      throw new AmbiguousIdError(
+        "Session",
+        id,
+        results.map((r) => formatShortId(r.session_id))
+      );
+    }
+    return results[0].session_id;
+  }
+  /**
+   * Create a new session
+   */
+  async create(data) {
+    try {
+      const insert = this.sessionToInsert(data);
+      await this.db.insert(sessions).values(insert);
+      const row = await this.db.select().from(sessions).where(eq7(sessions.session_id, insert.session_id)).get();
+      if (!row) {
+        throw new RepositoryError("Failed to retrieve created session");
+      }
+      return this.rowToSession(row);
+    } catch (error) {
+      if (error instanceof RepositoryError) throw error;
+      throw new RepositoryError(
+        `Failed to create session: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Find session by ID (supports short ID)
+   */
+  async findById(id) {
+    try {
+      const fullId = await this.resolveId(id);
+      const row = await this.db.select().from(sessions).where(eq7(sessions.session_id, fullId)).get();
+      return row ? this.rowToSession(row) : null;
+    } catch (error) {
+      if (error instanceof EntityNotFoundError) return null;
+      if (error instanceof AmbiguousIdError) throw error;
+      throw new RepositoryError(
+        `Failed to find session: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Find all sessions
+   */
+  async findAll() {
+    try {
+      const rows = await this.db.select().from(sessions).all();
+      return rows.map((row) => this.rowToSession(row));
+    } catch (error) {
+      throw new RepositoryError(
+        `Failed to find all sessions: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Find sessions by status
+   */
+  async findByStatus(status) {
+    try {
+      const rows = await this.db.select().from(sessions).where(eq7(sessions.status, status)).all();
+      return rows.map((row) => this.rowToSession(row));
+    } catch (error) {
+      throw new RepositoryError(
+        `Failed to find sessions by status: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Find sessions by board ID
+   */
+  async findByBoard(_boardId) {
+    try {
+      const rows = await this.db.select().from(sessions).all();
+      return rows.map((row) => this.rowToSession(row));
+    } catch (error) {
+      throw new RepositoryError(
+        `Failed to find sessions by board: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Find child sessions (forked or spawned from this session)
+   */
+  async findChildren(sessionId) {
+    try {
+      const fullId = await this.resolveId(sessionId);
+      const rows = await this.db.select().from(sessions).where(
+        or(
+          sql4`json_extract(${sessions.data}, '$.genealogy.parent_session_id') = ${fullId}`,
+          sql4`json_extract(${sessions.data}, '$.genealogy.forked_from_session_id') = ${fullId}`
+        )
+      ).all();
+      return rows.map((row) => this.rowToSession(row));
+    } catch (error) {
+      throw new RepositoryError(
+        `Failed to find child sessions: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Find ancestor sessions (parent chain)
+   */
+  async findAncestors(sessionId) {
+    try {
+      const fullId = await this.resolveId(sessionId);
+      const ancestors = [];
+      let currentSession = await this.findById(fullId);
+      while (currentSession) {
+        const parentId = currentSession.genealogy?.parent_session_id || currentSession.genealogy?.forked_from_session_id;
+        if (!parentId) break;
+        const parent = await this.findById(parentId);
+        if (!parent) break;
+        ancestors.push(parent);
+        currentSession = parent;
+      }
+      return ancestors;
+    } catch (error) {
+      throw new RepositoryError(
+        `Failed to find ancestor sessions: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Update session by ID
+   */
+  async update(id, updates) {
+    try {
+      const fullId = await this.resolveId(id);
+      const current = await this.findById(fullId);
+      if (!current) {
+        throw new EntityNotFoundError("Session", id);
+      }
+      const merged = {
+        ...current,
+        ...updates
+      };
+      if (updates.permission_config) {
+        console.log(`\u{1F4DD} [SessionRepository] Merging permission_config update`);
+        console.log(
+          `   Before merge - current.permission_config: ${JSON.stringify(current.permission_config)}`
+        );
+        console.log(`   Update permission_config: ${JSON.stringify(updates.permission_config)}`);
+        console.log(
+          `   After merge - merged.permission_config: ${JSON.stringify(merged.permission_config)}`
+        );
+      }
+      const insert = this.sessionToInsert(merged);
+      console.log(`\u{1F5C4}\uFE0F  [SessionRepository] Writing to DB:`);
+      console.log(
+        `   insert.data.permission_config: ${JSON.stringify(insert.data.permission_config)}`
+      );
+      await this.db.update(sessions).set({
+        status: insert.status,
+        updated_at: /* @__PURE__ */ new Date(),
+        data: insert.data
+      }).where(eq7(sessions.session_id, fullId));
+      console.log(`\u2705 [SessionRepository] DB update complete`);
+      const updated = await this.findById(fullId);
+      if (!updated) {
+        throw new RepositoryError("Failed to retrieve updated session");
+      }
+      return updated;
+    } catch (error) {
+      if (error instanceof RepositoryError) throw error;
+      if (error instanceof EntityNotFoundError) throw error;
+      throw new RepositoryError(
+        `Failed to update session: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Delete session by ID
+   */
+  async delete(id) {
+    try {
+      const fullId = await this.resolveId(id);
+      const result = await this.db.delete(sessions).where(eq7(sessions.session_id, fullId)).run();
+      if (result.rowsAffected === 0) {
+        throw new EntityNotFoundError("Session", id);
+      }
+    } catch (error) {
+      if (error instanceof EntityNotFoundError) throw error;
+      throw new RepositoryError(
+        `Failed to delete session: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Find sessions with running tasks
+   */
+  async findRunning() {
+    return this.findByStatus(SessionStatus.RUNNING);
+  }
+  /**
+   * Count total sessions
+   */
+  async count() {
+    try {
+      const result = await this.db.select({ count: sql4`count(*)` }).from(sessions).get();
+      return result?.count ?? 0;
+    } catch (error) {
+      throw new RepositoryError(
+        `Failed to count sessions: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+};
+
+// src/db/repositories/session-mcp-servers.ts
+var SessionMCPServerRepository = class {
+  constructor(db) {
+    this.db = db;
+    this.sessionRepo = new SessionRepository(db);
+    this.mcpServerRepo = new MCPServerRepository(db);
+  }
+  sessionRepo;
+  mcpServerRepo;
+  /**
+   * Add MCP server to session
+   */
+  async addServer(sessionId, serverId) {
+    try {
+      const session = await this.sessionRepo.findById(sessionId);
+      if (!session) {
+        throw new EntityNotFoundError("Session", sessionId);
+      }
+      const server = await this.mcpServerRepo.findById(serverId);
+      if (!server) {
+        throw new EntityNotFoundError("MCPServer", serverId);
+      }
+      const existing = await this.db.select().from(sessionMcpServers).where(
+        and3(
+          eq8(sessionMcpServers.session_id, sessionId),
+          eq8(sessionMcpServers.mcp_server_id, serverId)
+        )
+      ).get();
+      if (existing) {
+        await this.db.update(sessionMcpServers).set({ enabled: true }).where(
+          and3(
+            eq8(sessionMcpServers.session_id, sessionId),
+            eq8(sessionMcpServers.mcp_server_id, serverId)
+          )
+        );
+        return;
+      }
+      const insert = {
+        session_id: sessionId,
+        mcp_server_id: serverId,
+        enabled: true,
+        added_at: /* @__PURE__ */ new Date()
+      };
+      await this.db.insert(sessionMcpServers).values(insert);
+    } catch (error) {
+      if (error instanceof EntityNotFoundError) throw error;
+      throw new RepositoryError(
+        `Failed to add MCP server to session: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Remove MCP server from session
+   */
+  async removeServer(sessionId, serverId) {
+    try {
+      const result = await this.db.delete(sessionMcpServers).where(
+        and3(
+          eq8(sessionMcpServers.session_id, sessionId),
+          eq8(sessionMcpServers.mcp_server_id, serverId)
+        )
+      ).run();
+      if (result.rowsAffected === 0) {
+        throw new EntityNotFoundError("SessionMCPServer", `${sessionId}/${serverId}`);
+      }
+    } catch (error) {
+      if (error instanceof EntityNotFoundError) throw error;
+      throw new RepositoryError(
+        `Failed to remove MCP server from session: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Toggle MCP server enabled state for session
+   */
+  async toggleServer(sessionId, serverId, enabled) {
+    try {
+      const result = await this.db.update(sessionMcpServers).set({ enabled }).where(
+        and3(
+          eq8(sessionMcpServers.session_id, sessionId),
+          eq8(sessionMcpServers.mcp_server_id, serverId)
+        )
+      ).run();
+      if (result.rowsAffected === 0) {
+        throw new EntityNotFoundError("SessionMCPServer", `${sessionId}/${serverId}`);
+      }
+    } catch (error) {
+      if (error instanceof EntityNotFoundError) throw error;
+      throw new RepositoryError(
+        `Failed to toggle MCP server: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * List MCP servers for a session
+   */
+  async listServers(sessionId, enabledOnly = false) {
+    try {
+      const conditions = [eq8(sessionMcpServers.session_id, sessionId)];
+      if (enabledOnly) {
+        conditions.push(eq8(sessionMcpServers.enabled, true));
+      }
+      const relationships = await this.db.select().from(sessionMcpServers).where(and3(...conditions)).all();
+      const servers = [];
+      for (const rel of relationships) {
+        const server = await this.mcpServerRepo.findById(rel.mcp_server_id);
+        if (server) {
+          servers.push(server);
+        }
+      }
+      return servers;
+    } catch (error) {
+      throw new RepositoryError(
+        `Failed to list MCP servers for session: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Set MCP servers for a session (bulk operation)
+   * Replaces existing relationships with new ones
+   */
+  async setServers(sessionId, serverIds) {
+    try {
+      const session = await this.sessionRepo.findById(sessionId);
+      if (!session) {
+        throw new EntityNotFoundError("Session", sessionId);
+      }
+      await this.db.delete(sessionMcpServers).where(eq8(sessionMcpServers.session_id, sessionId));
+      if (serverIds.length > 0) {
+        const inserts = serverIds.map((serverId) => ({
+          session_id: sessionId,
+          mcp_server_id: serverId,
+          enabled: true,
+          added_at: /* @__PURE__ */ new Date()
+        }));
+        await this.db.insert(sessionMcpServers).values(inserts);
+      }
+    } catch (error) {
+      if (error instanceof EntityNotFoundError) throw error;
+      throw new RepositoryError(
+        `Failed to set MCP servers for session: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Get relationship details
+   */
+  async getRelationship(sessionId, serverId) {
+    try {
+      const row = await this.db.select().from(sessionMcpServers).where(
+        and3(
+          eq8(sessionMcpServers.session_id, sessionId),
+          eq8(sessionMcpServers.mcp_server_id, serverId)
+        )
+      ).get();
+      if (!row) {
+        return null;
+      }
+      return {
+        session_id: row.session_id,
+        mcp_server_id: row.mcp_server_id,
+        enabled: Boolean(row.enabled),
+        added_at: new Date(row.added_at)
+      };
+    } catch (error) {
+      throw new RepositoryError(
+        `Failed to get relationship: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Count MCP servers for a session
+   */
+  async count(sessionId, enabledOnly = false) {
+    try {
+      const servers = await this.listServers(sessionId, enabledOnly);
+      return servers.length;
+    } catch (error) {
+      throw new RepositoryError(
+        `Failed to count MCP servers: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+};
+
+// src/db/repositories/tasks.ts
+init_ids();
+import { eq as eq9, like as like6, sql as sql5 } from "drizzle-orm";
+var TaskRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  /**
+   * Convert database row to Task type
+   */
+  rowToTask(row) {
+    return {
+      task_id: row.task_id,
+      session_id: row.session_id,
+      status: row.status,
+      created_at: new Date(row.created_at).toISOString(),
+      completed_at: row.completed_at ? new Date(row.completed_at).toISOString() : void 0,
+      created_by: row.created_by,
+      ...row.data
+    };
+  }
+  /**
+   * Convert Task to database insert format
+   */
+  taskToInsert(task) {
+    const now = Date.now();
+    const taskId = task.task_id ?? generateId();
+    if (!task.session_id) {
+      throw new RepositoryError("session_id is required when creating a task");
+    }
+    const git_state = task.git_state ?? {
+      ref_at_start: "unknown",
+      sha_at_start: "unknown"
+    };
+    return {
+      task_id: taskId,
+      session_id: task.session_id,
+      created_at: new Date(now),
+      // Always use server timestamp, ignore client-provided value
+      completed_at: task.completed_at ? new Date(task.completed_at) : void 0,
+      status: task.status ?? TaskStatus.CREATED,
+      created_by: task.created_by ?? "anonymous",
+      data: {
+        description: task.description ?? "",
+        full_prompt: task.full_prompt ?? task.description ?? "",
+        message_range: task.message_range ?? {
+          start_index: 0,
+          end_index: 0,
+          start_timestamp: new Date(now).toISOString()
+        },
+        git_state,
+        model: task.model ?? "claude-sonnet-4-5",
+        tool_use_count: task.tool_use_count ?? 0,
+        usage: task.usage,
+        // Token usage and cost tracking
+        duration_ms: task.duration_ms,
+        // Task execution duration
+        agent_session_id: task.agent_session_id,
+        // SDK session ID
+        context_window: task.context_window,
+        // Context window usage
+        context_window_limit: task.context_window_limit,
+        // Max context window
+        report: task.report,
+        permission_request: task.permission_request
+        // Permission state for UI approval flow
+      }
+    };
+  }
+  /**
+   * Resolve short ID to full ID
+   */
+  async resolveId(id) {
+    if (id.length === 36 && id.includes("-")) {
+      return id;
+    }
+    const normalized = id.replace(/-/g, "").toLowerCase();
+    const pattern = `${normalized}%`;
+    const results = await this.db.select({ task_id: tasks.task_id }).from(tasks).where(like6(tasks.task_id, pattern)).all();
+    if (results.length === 0) {
+      throw new EntityNotFoundError("Task", id);
+    }
+    if (results.length > 1) {
+      throw new AmbiguousIdError(
+        "Task",
+        id,
+        results.map((r) => formatShortId(r.task_id))
+      );
+    }
+    return results[0].task_id;
+  }
+  /**
+   * Create a new task
+   */
+  async create(data) {
+    try {
+      const insert = this.taskToInsert(data);
+      await this.db.insert(tasks).values(insert);
+      const row = await this.db.select().from(tasks).where(eq9(tasks.task_id, insert.task_id)).get();
+      if (!row) {
+        throw new RepositoryError("Failed to retrieve created task");
+      }
+      return this.rowToTask(row);
+    } catch (error) {
+      if (error instanceof RepositoryError) throw error;
+      throw new RepositoryError(
+        `Failed to create task: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Bulk create multiple tasks (for imports)
+   */
+  async createMany(taskList) {
+    try {
+      const inserts = taskList.map((task) => this.taskToInsert(task));
+      await this.db.insert(tasks).values(inserts);
+      const taskIds = inserts.map((t) => t.task_id);
+      const rows = await this.db.select().from(tasks).where(sql5`${tasks.task_id} IN ${sql5.raw(`(${taskIds.map((id) => `'${id}'`).join(",")})`)}`);
+      return rows.map((row) => this.rowToTask(row));
+    } catch (error) {
+      throw new RepositoryError(
+        `Failed to bulk create tasks: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Find task by ID (supports short ID)
+   */
+  async findById(id) {
+    try {
+      const fullId = await this.resolveId(id);
+      const row = await this.db.select().from(tasks).where(eq9(tasks.task_id, fullId)).get();
+      return row ? this.rowToTask(row) : null;
+    } catch (error) {
+      if (error instanceof EntityNotFoundError) return null;
+      if (error instanceof AmbiguousIdError) throw error;
+      throw new RepositoryError(
+        `Failed to find task: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Find all tasks
+   */
+  async findAll() {
+    try {
+      const rows = await this.db.select().from(tasks).all();
+      return rows.map((row) => this.rowToTask(row));
+    } catch (error) {
+      throw new RepositoryError(
+        `Failed to find all tasks: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Find all tasks for a session
+   */
+  async findBySession(sessionId) {
+    try {
+      const rows = await this.db.select().from(tasks).where(eq9(tasks.session_id, sessionId)).orderBy(tasks.created_at).all();
+      return rows.map((row) => this.rowToTask(row));
+    } catch (error) {
+      throw new RepositoryError(
+        `Failed to find tasks by session: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Find running tasks across all sessions
+   */
+  async findRunning() {
+    try {
+      const rows = await this.db.select().from(tasks).where(eq9(tasks.status, TaskStatus.RUNNING)).all();
+      return rows.map((row) => this.rowToTask(row));
+    } catch (error) {
+      throw new RepositoryError(
+        `Failed to find running tasks: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Find tasks by status
+   */
+  async findByStatus(status) {
+    try {
+      const rows = await this.db.select().from(tasks).where(eq9(tasks.status, status)).all();
+      return rows.map((row) => this.rowToTask(row));
+    } catch (error) {
+      throw new RepositoryError(
+        `Failed to find tasks by status: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Update task by ID
+   */
+  async update(id, updates) {
+    try {
+      const fullId = await this.resolveId(id);
+      const current = await this.findById(fullId);
+      if (!current) {
+        throw new EntityNotFoundError("Task", id);
+      }
+      const merged = { ...current, ...updates };
+      const insert = this.taskToInsert(merged);
+      await this.db.update(tasks).set({
+        status: insert.status,
+        completed_at: insert.completed_at,
+        data: insert.data
+      }).where(eq9(tasks.task_id, fullId));
+      const updated = await this.findById(fullId);
+      if (!updated) {
+        throw new RepositoryError("Failed to retrieve updated task");
+      }
+      return updated;
+    } catch (error) {
+      if (error instanceof RepositoryError) throw error;
+      if (error instanceof EntityNotFoundError) throw error;
+      throw new RepositoryError(
+        `Failed to update task: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Delete task by ID
+   */
+  async delete(id) {
+    try {
+      const fullId = await this.resolveId(id);
+      const result = await this.db.delete(tasks).where(eq9(tasks.task_id, fullId)).run();
+      if (result.rowsAffected === 0) {
+        throw new EntityNotFoundError("Task", id);
+      }
+    } catch (error) {
+      if (error instanceof EntityNotFoundError) throw error;
+      throw new RepositoryError(
+        `Failed to delete task: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  /**
+   * Count tasks for a session
+   */
+  async countBySession(sessionId) {
+    try {
+      const result = await this.db.select({ count: sql5`count(*)` }).from(tasks).where(eq9(tasks.session_id, sessionId)).get();
+      return result?.count ?? 0;
+    } catch (error) {
+      throw new RepositoryError(
+        `Failed to count tasks: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+};
+
+// src/db/repositories/worktrees.ts
+init_ids();
+import { eq as eq10, like as like7, sql as sql6 } from "drizzle-orm";
+var WorktreeRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  /**
+   * Convert database row to Worktree type
+   */
+  rowToWorktree(row) {
+    return {
+      worktree_id: row.worktree_id,
+      repo_id: row.repo_id,
+      created_at: new Date(row.created_at).toISOString(),
+      updated_at: row.updated_at ? new Date(row.updated_at).toISOString() : new Date(row.created_at).toISOString(),
+      created_by: row.created_by,
+      name: row.name,
+      ref: row.ref,
+      worktree_unique_id: row.worktree_unique_id,
+      board_id: row.board_id ?? void 0,
+      // Top-level column
+      ...row.data,
+      sessions: row.data.sessions || []
+    };
+  }
+  /**
+   * Convert Worktree to database insert format
+   */
+  worktreeToInsert(worktree) {
+    const now = Date.now();
+    const worktreeId = worktree.worktree_id ?? generateId();
+    return {
+      worktree_id: worktreeId,
+      repo_id: worktree.repo_id,
+      created_at: worktree.created_at ? new Date(worktree.created_at) : new Date(now),
+      updated_at: new Date(now),
+      created_by: worktree.created_by ?? "anonymous",
+      name: worktree.name,
+      ref: worktree.ref,
+      worktree_unique_id: worktree.worktree_unique_id,
+      // Required field
+      // Explicitly convert undefined to null for Drizzle (undefined values are ignored in set())
+      board_id: worktree.board_id === void 0 ? null : worktree.board_id || null,
+      data: {
+        path: worktree.path,
+        base_ref: worktree.base_ref,
+        base_sha: worktree.base_sha,
+        last_commit_sha: worktree.last_commit_sha,
+        tracking_branch: worktree.tracking_branch,
+        new_branch: worktree.new_branch ?? false,
+        issue_url: worktree.issue_url,
+        pull_request_url: worktree.pull_request_url,
+        notes: worktree.notes,
+        environment_instance: worktree.environment_instance,
+        sessions: worktree.sessions || [],
+        last_used: worktree.last_used ?? new Date(now).toISOString(),
+        custom_context: worktree.custom_context
+      }
+    };
+  }
+  /**
+   * Create a new worktree
+   */
+  async create(worktree) {
+    const insert = this.worktreeToInsert(worktree);
+    const [row] = await this.db.insert(worktrees).values(insert).returning();
+    return this.rowToWorktree(row);
+  }
+  /**
+   * Find worktree by exact ID or short ID prefix
+   */
+  async findById(id) {
+    if (id.length === 36 && id.includes("-")) {
+      const [row] = await this.db.select().from(worktrees).where(eq10(worktrees.worktree_id, id)).limit(1);
+      return row ? this.rowToWorktree(row) : null;
+    }
+    const prefix = id.replace(/-/g, "").toLowerCase();
+    const matches = await this.db.select().from(worktrees).where(like7(worktrees.worktree_id, `${prefix}%`)).limit(2);
+    if (matches.length === 0) return null;
+    if (matches.length > 1) {
+      throw new AmbiguousIdError(
+        "Worktree",
+        prefix,
+        matches.map((m) => formatShortId(m.worktree_id))
+      );
+    }
+    return this.rowToWorktree(matches[0]);
+  }
+  /**
+   * Find all worktrees (with optional filters)
+   */
+  async findAll(filter) {
+    if (filter?.repo_id) {
+      const rows2 = await this.db.select().from(worktrees).where(eq10(worktrees.repo_id, filter.repo_id));
+      return rows2.map((row) => this.rowToWorktree(row));
+    }
+    const rows = await this.db.select().from(worktrees);
+    return rows.map((row) => this.rowToWorktree(row));
+  }
+  /**
+   * Update worktree by ID
+   */
+  async update(id, updates) {
+    const existing = await this.findById(id);
+    if (!existing) {
+      throw new EntityNotFoundError("Worktree", id);
+    }
+    const merged = {
+      ...existing,
+      ...updates,
+      worktree_id: existing.worktree_id,
+      repo_id: existing.repo_id,
+      created_at: existing.created_at,
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const insert = this.worktreeToInsert(merged);
+    const [row] = await this.db.update(worktrees).set(insert).where(eq10(worktrees.worktree_id, existing.worktree_id)).returning();
+    return this.rowToWorktree(row);
+  }
+  /**
+   * Delete worktree by ID
+   */
+  async delete(id) {
+    const existing = await this.findById(id);
+    if (!existing) {
+      throw new EntityNotFoundError("Worktree", id);
+    }
+    await this.db.delete(worktrees).where(eq10(worktrees.worktree_id, existing.worktree_id));
+  }
+  /**
+   * Find worktree by repo_id and name
+   */
+  async findByRepoAndName(repoId, name) {
+    const [row] = await this.db.select().from(worktrees).where(sql6`${worktrees.repo_id} = ${repoId} AND ${worktrees.name} = ${name}`).limit(1);
+    return row ? this.rowToWorktree(row) : null;
+  }
+  /**
+   * Add session to worktree's sessions array
+   */
+  async addSession(worktreeId, sessionId) {
+    const worktree = await this.findById(worktreeId);
+    if (!worktree) {
+      throw new EntityNotFoundError("Worktree", worktreeId);
+    }
+    const sessions2 = worktree.sessions || [];
+    if (!sessions2.includes(sessionId)) {
+      sessions2.push(sessionId);
+    }
+    return this.update(worktreeId, {
+      sessions: sessions2,
+      last_used: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  /**
+   * Remove session from worktree's sessions array
+   */
+  async removeSession(worktreeId, sessionId) {
+    const worktree = await this.findById(worktreeId);
+    if (!worktree) {
+      throw new EntityNotFoundError("Worktree", worktreeId);
+    }
+    const sessions2 = (worktree.sessions || []).filter((id) => id !== sessionId);
+    return this.update(worktreeId, { sessions: sessions2 });
+  }
+};
+
+// src/db/user-utils.ts
+init_ids();
+import bcrypt from "bcryptjs";
+import { eq as eq11 } from "drizzle-orm";
+async function createUser(db, data) {
+  const existing = await db.select().from(users).where(eq11(users.email, data.email)).get();
+  if (existing) {
+    throw new Error(`User with email ${data.email} already exists`);
+  }
+  const hashedPassword = await bcrypt.hash(data.password, 10);
+  const now = /* @__PURE__ */ new Date();
+  const user_id = generateId();
+  const role = data.role || "member";
+  const defaultEmoji = role === "admin" ? "\u2B50" : "\u{1F464}";
+  const row = await db.insert(users).values({
+    user_id,
+    email: data.email,
+    password: hashedPassword,
+    name: data.name,
+    emoji: defaultEmoji,
+    role,
+    created_at: now,
+    updated_at: now,
+    data: {
+      preferences: {}
+    }
+  }).returning().get();
+  const userData = row.data;
+  return {
+    user_id: row.user_id,
+    email: row.email,
+    name: row.name ?? void 0,
+    role: row.role,
+    avatar: userData.avatar,
+    preferences: userData.preferences,
+    onboarding_completed: !!row.onboarding_completed,
+    created_at: row.created_at,
+    updated_at: row.updated_at ?? void 0
+  };
+}
+async function userExists(db, email) {
+  const existing = await db.select().from(users).where(eq11(users.email, email)).get();
+  return !!existing;
+}
+async function getUserByEmail(db, email) {
+  const row = await db.select().from(users).where(eq11(users.email, email)).get();
+  if (!row) {
+    return null;
+  }
+  const userData = row.data;
+  return {
+    user_id: row.user_id,
+    email: row.email,
+    name: row.name ?? void 0,
+    role: row.role,
+    avatar: userData.avatar,
+    preferences: userData.preferences,
+    onboarding_completed: !!row.onboarding_completed,
+    created_at: row.created_at,
+    updated_at: row.updated_at ?? void 0
+  };
+}
+var DEFAULT_ADMIN_USER = {
+  email: "admin@agor.live",
+  password: "admin",
+  name: "Admin",
+  role: "admin"
+};
+async function createDefaultAdminUser(db) {
+  const existing = await getUserByEmail(db, DEFAULT_ADMIN_USER.email);
+  if (existing) {
+    throw new Error(`Admin user already exists (email: ${DEFAULT_ADMIN_USER.email})`);
+  }
+  return createUser(db, DEFAULT_ADMIN_USER);
+}
+
+// src/db/index.ts
+var compare = bcryptjs.compare;
+var hash = bcryptjs.hash;
+export {
+  AmbiguousIdError,
+  BoardCommentsRepository,
+  BoardObjectRepository,
+  BoardRepository,
+  DEFAULT_ADMIN_USER,
+  DEFAULT_DB_PATH,
+  DatabaseConnectionError,
+  EntityNotFoundError,
+  IdResolutionError,
+  MCPServerRepository,
+  MessagesRepository,
+  MigrationError,
+  RepoRepository,
+  RepositoryError,
+  SessionMCPServerRepository,
+  SessionRepository,
+  TaskRepository,
+  WorktreeRepository,
+  and4 as and,
+  boardComments,
+  boardObjects,
+  boards,
+  compare,
+  createDatabase,
+  createDefaultAdminUser,
+  createLocalDatabase,
+  createUser,
+  desc,
+  eq12 as eq,
+  formatShortId,
+  generateId,
+  getUserByEmail,
+  hash,
+  inArray,
+  initializeDatabase,
+  like8 as like,
+  mcpServers,
+  messages,
+  or2 as or,
+  repos,
+  resolveShortId,
+  runMigrations,
+  seedInitialData,
+  sessionMcpServers,
+  sessions,
+  sql7 as sql,
+  tasks,
+  userExists,
+  users,
+  worktrees
+};