agor-live 0.3.7

package/dist/core/dist/index.cjs

@@ -0,0 +1,4653 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 });
+};
+var __copyProps = (to, from, except, desc2) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc2 = __getOwnPropDesc(from, key)) || desc2.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// 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
+});
+function generateId() {
+  return (0, import_uuidv7.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 import_uuidv7, IdResolutionError, ids_default;
+var init_ids = __esm({
+  "src/lib/ids.ts"() {
+    "use strict";
+    import_uuidv7 = require("uuidv7");
+    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/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AmbiguousIdError: () => AmbiguousIdError,
+  BoardCommentsRepository: () => BoardCommentsRepository,
+  BoardObjectRepository: () => BoardObjectRepository,
+  BoardRepository: () => BoardRepository,
+  CommentAttachmentType: () => CommentAttachmentType,
+  DATABASE: () => DATABASE,
+  DEFAULT_ADMIN_USER: () => DEFAULT_ADMIN_USER,
+  DEFAULT_DB_PATH: () => DEFAULT_DB_PATH,
+  DatabaseConnectionError: () => DatabaseConnectionError,
+  ENVIRONMENT: () => ENVIRONMENT,
+  EntityNotFoundError: () => EntityNotFoundError,
+  GIT: () => GIT,
+  IdResolutionError: () => IdResolutionError,
+  MCPServerRepository: () => MCPServerRepository,
+  MessageRole: () => MessageRole,
+  MessagesRepository: () => MessagesRepository,
+  MigrationError: () => MigrationError,
+  PermissionScope: () => PermissionScope,
+  PermissionStatus: () => PermissionStatus,
+  RepoRepository: () => RepoRepository,
+  RepositoryError: () => RepositoryError,
+  SESSION: () => SESSION,
+  SessionMCPServerRepository: () => SessionMCPServerRepository,
+  SessionRepository: () => SessionRepository,
+  SessionStatus: () => SessionStatus,
+  TaskRepository: () => TaskRepository,
+  TaskStatus: () => TaskStatus,
+  WEBSOCKET: () => WEBSOCKET,
+  WorktreeRepository: () => WorktreeRepository,
+  and: () => import_drizzle_orm14.and,
+  boardComments: () => boardComments,
+  boardObjects: () => boardObjects,
+  boards: () => boards,
+  clearContext: () => clearContext,
+  cloneRepo: () => cloneRepo,
+  compare: () => compare,
+  createClient: () => createClient,
+  createDatabase: () => createDatabase,
+  createDefaultAdminUser: () => createDefaultAdminUser,
+  createLocalDatabase: () => createLocalDatabase,
+  createUser: () => createUser,
+  createWorktree: () => createWorktree,
+  desc: () => import_drizzle_orm14.desc,
+  eq: () => import_drizzle_orm14.eq,
+  extractRepoName: () => extractRepoName,
+  extractSlugFromUrl: () => extractSlugFromUrl,
+  formatRepoReference: () => formatRepoReference,
+  formatShortId: () => formatShortId,
+  generateId: () => generateId,
+  getAgorHome: () => getAgorHome,
+  getAllContext: () => getAllContext,
+  getCommentAttachmentType: () => getCommentAttachmentType,
+  getConfigPath: () => getConfigPath,
+  getConfigValue: () => getConfigValue,
+  getContext: () => getContext,
+  getCurrentBranch: () => getCurrentBranch,
+  getCurrentSha: () => getCurrentSha,
+  getDaemonUrl: () => getDaemonUrl,
+  getDefaultBranch: () => getDefaultBranch,
+  getDefaultConfig: () => getDefaultConfig,
+  getDefaultPermissionMode: () => getDefaultPermissionMode,
+  getDefaultRepoReference: () => getDefaultRepoReference,
+  getEffectiveConfig: () => getEffectiveConfig,
+  getGitState: () => getGitState,
+  getGroupedRepoReferenceOptions: () => getGroupedRepoReferenceOptions,
+  getRemoteBranches: () => getRemoteBranches,
+  getRemoteUrl: () => getRemoteUrl,
+  getRepoReferenceOptions: () => getRepoReferenceOptions,
+  getReposDir: () => getReposDir,
+  getUserByEmail: () => getUserByEmail,
+  getWorktreePath: () => getWorktreePath,
+  getWorktreesDir: () => getWorktreesDir,
+  groupReactions: () => groupReactions,
+  hasRemoteBranch: () => hasRemoteBranch,
+  hash: () => hash,
+  inArray: () => import_drizzle_orm14.inArray,
+  initConfig: () => initConfig,
+  initializeDatabase: () => initializeDatabase,
+  isClean: () => isClean,
+  isDaemonRunning: () => isDaemonRunning,
+  isDefined: () => isDefined,
+  isGitRepo: () => isGitRepo,
+  isNonEmptyString: () => isNonEmptyString,
+  isReply: () => isReply,
+  isResolvable: () => isResolvable,
+  isThreadRoot: () => isThreadRoot,
+  isValidSlug: () => isValidSlug,
+  like: () => import_drizzle_orm14.like,
+  listWorktrees: () => listWorktrees,
+  loadConfig: () => loadConfig,
+  mcpServers: () => mcpServers,
+  messages: () => messages,
+  or: () => import_drizzle_orm14.or,
+  parseRepoReference: () => parseRepoReference,
+  pruneWorktrees: () => pruneWorktrees,
+  removeWorktree: () => removeWorktree,
+  repos: () => repos,
+  resolveRepoReference: () => resolveRepoReference,
+  resolveShortId: () => resolveShortId,
+  resolveValue: () => resolveValue,
+  resolveValues: () => resolveValues,
+  runMigrations: () => runMigrations,
+  saveConfig: () => saveConfig,
+  seedInitialData: () => seedInitialData,
+  sessionMcpServers: () => sessionMcpServers,
+  sessions: () => sessions,
+  setConfigValue: () => setConfigValue,
+  setContext: () => setContext,
+  sql: () => import_drizzle_orm14.sql,
+  tasks: () => tasks,
+  unsetConfigValue: () => unsetConfigValue,
+  unsetContext: () => unsetContext,
+  userExists: () => userExists,
+  users: () => users,
+  worktrees: () => worktrees
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/api/index.ts
+var import_authentication_client = __toESM(require("@feathersjs/authentication-client"), 1);
+var import_feathers = require("@feathersjs/feathers");
+var import_socketio_client = __toESM(require("@feathersjs/socketio-client"), 1);
+var import_socket = __toESM(require("socket.io-client"), 1);
+function createClient(url = "http://localhost:3030", autoConnect = true, options) {
+  const socket = (0, import_socket.default)(url, {
+    // Auto-connect by default for CLI, manual control for React hooks
+    autoConnect,
+    // Reconnection settings (less aggressive to prevent socket exhaustion)
+    reconnection: true,
+    reconnectionDelay: 1e3,
+    // Wait 1s before first reconnect attempt
+    reconnectionDelayMax: 2e3,
+    // Max 2s between attempts
+    reconnectionAttempts: 2,
+    // Only try 2 times before giving up (fast fail for CLI)
+    // Timeout settings
+    timeout: 2e3,
+    // 2s timeout for initial connection
+    // Transports (WebSocket preferred, fallback to polling)
+    transports: ["websocket", "polling"],
+    // Connection lifecycle settings
+    closeOnBeforeunload: true
+    // Close socket when page unloads
+  });
+  if (options?.verbose) {
+    let attemptCount = 0;
+    socket.on("connect_error", (error) => {
+      attemptCount++;
+      if (attemptCount === 1) {
+        console.error(`\u2717 Daemon not running at ${url}`);
+        console.error(`  Retrying connection (${attemptCount}/2)...`);
+      } else {
+        console.error(`  Retry ${attemptCount}/2 failed`);
+      }
+    });
+    socket.on("connect", () => {
+      if (attemptCount > 0) {
+        console.log("\u2713 Connected to daemon");
+      }
+    });
+  }
+  const client = (0, import_feathers.feathers)();
+  client.configure((0, import_socketio_client.default)(socket));
+  const storage = typeof globalThis !== "undefined" && "localStorage" in globalThis ? globalThis.localStorage : void 0;
+  client.configure((0, import_authentication_client.default)({ storage }));
+  client.io = socket;
+  return client;
+}
+async function isDaemonRunning(url = "http://localhost:3030") {
+  try {
+    const response = await fetch(`${url}/health`, { signal: AbortSignal.timeout(1e3) });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
+// src/config/config-manager.ts
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_node_os = __toESM(require("os"), 1);
+var import_node_path = __toESM(require("path"), 1);
+var import_js_yaml = __toESM(require("js-yaml"), 1);
+function getAgorHome() {
+  return import_node_path.default.join(import_node_os.default.homedir(), ".agor");
+}
+function getConfigPath() {
+  return import_node_path.default.join(getAgorHome(), "config.yaml");
+}
+async function ensureAgorHome() {
+  const agorHome = getAgorHome();
+  try {
+    await import_promises.default.access(agorHome);
+  } catch {
+    await import_promises.default.mkdir(agorHome, { recursive: true });
+  }
+}
+async function loadConfig() {
+  const configPath = getConfigPath();
+  try {
+    const content = await import_promises.default.readFile(configPath, "utf-8");
+    const config = import_js_yaml.default.load(content);
+    return config || {};
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return getDefaultConfig();
+    }
+    throw new Error(
+      `Failed to load config: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function saveConfig(config) {
+  await ensureAgorHome();
+  const configPath = getConfigPath();
+  const content = import_js_yaml.default.dump(config, {
+    indent: 2,
+    lineWidth: 120,
+    noRefs: true
+  });
+  await import_promises.default.writeFile(configPath, content, "utf-8");
+}
+function getDefaultConfig() {
+  return {
+    context: {},
+    defaults: {
+      board: "main",
+      agent: "claude-code"
+    },
+    display: {
+      tableStyle: "unicode",
+      colorOutput: true,
+      shortIdLength: 8
+    },
+    daemon: {
+      port: 3030,
+      host: "localhost",
+      allowAnonymous: true,
+      // Default: Allow anonymous access (local mode)
+      requireAuth: false
+      // Default: Do not require authentication
+    },
+    ui: {
+      port: 5173,
+      host: "localhost"
+    }
+  };
+}
+async function getContext(key) {
+  const config = await loadConfig();
+  return config.context?.[key];
+}
+async function setContext(key, value) {
+  const config = await loadConfig();
+  if (!config.context) {
+    config.context = {};
+  }
+  config.context[key] = value;
+  await saveConfig(config);
+}
+async function unsetContext(key) {
+  const config = await loadConfig();
+  if (config.context && key in config.context) {
+    delete config.context[key];
+    await saveConfig(config);
+  }
+}
+async function clearContext() {
+  const config = await loadConfig();
+  config.context = {};
+  await saveConfig(config);
+}
+async function getAllContext() {
+  const config = await loadConfig();
+  return config.context || {};
+}
+async function initConfig() {
+  const configPath = getConfigPath();
+  try {
+    await import_promises.default.access(configPath);
+  } catch {
+    await saveConfig(getDefaultConfig());
+  }
+}
+async function getConfigValue(key) {
+  const config = await loadConfig();
+  const defaults = getDefaultConfig();
+  const merged = {
+    ...defaults,
+    ...config,
+    defaults: { ...defaults.defaults, ...config.defaults },
+    display: { ...defaults.display, ...config.display },
+    daemon: { ...defaults.daemon, ...config.daemon },
+    ui: { ...defaults.ui, ...config.ui }
+  };
+  const parts = key.split(".");
+  let value = merged;
+  for (const part of parts) {
+    if (value && typeof value === "object" && part in value) {
+      value = value[part];
+    } else {
+      return void 0;
+    }
+  }
+  return value;
+}
+async function setConfigValue(key, value) {
+  const config = await loadConfig();
+  const parts = key.split(".");
+  if (parts.length === 1) {
+    if (!config.context) {
+      config.context = {};
+    }
+    config.context[parts[0]] = value;
+  } else {
+    const section = parts[0];
+    const _subKey = parts.slice(1).join(".");
+    if (!config[section]) {
+      config[section] = {};
+    }
+    if (parts.length === 2) {
+      config[section][parts[1]] = value;
+    } else {
+      throw new Error(`Nested keys beyond one level not supported: ${key}`);
+    }
+  }
+  await saveConfig(config);
+}
+async function unsetConfigValue(key) {
+  const config = await loadConfig();
+  const parts = key.split(".");
+  if (parts.length === 1) {
+    if (config.context && parts[0] in config.context) {
+      delete config.context[parts[0]];
+    }
+  } else if (parts.length === 2) {
+    const section = parts[0];
+    const subKey = parts[1];
+    if (config[section] && subKey in config[section]) {
+      delete config[section][subKey];
+    }
+  }
+  await saveConfig(config);
+}
+async function getDaemonUrl() {
+  const config = await loadConfig();
+  const defaults = getDefaultConfig();
+  const envPort = process.env.PORT ? Number.parseInt(process.env.PORT, 10) : void 0;
+  const port = envPort || config.daemon?.port || defaults.daemon?.port || 3030;
+  const host = config.daemon?.host || defaults.daemon?.host || "localhost";
+  return `http://${host}:${port}`;
+}
+
+// src/config/constants.ts
+var ENVIRONMENT = {
+  /**
+   * Health check interval in milliseconds
+   * How often to poll environment health when status is 'running'
+   */
+  HEALTH_CHECK_INTERVAL_MS: 5e3,
+  // 5 seconds
+  /**
+   * Health check timeout in milliseconds
+   * How long to wait for health check response before considering it failed
+   */
+  HEALTH_CHECK_TIMEOUT_MS: 1e3,
+  // 1 second
+  /**
+   * Maximum number of log lines to store per worktree
+   * (Not stored in DB - reference for future log file implementation)
+   */
+  MAX_LOG_LINES: 100,
+  /**
+   * Process startup grace period in milliseconds
+   * How long to wait after starting before running health checks
+   */
+  STARTUP_GRACE_PERIOD_MS: 3e3,
+  // 3 seconds
+  /**
+   * Maximum consecutive health check failures before marking as 'error'
+   */
+  MAX_HEALTH_CHECK_FAILURES: 3
+};
+var WEBSOCKET = {
+  /**
+   * Cursor position broadcast throttle in milliseconds
+   */
+  CURSOR_THROTTLE_MS: 100,
+  /**
+   * Presence timeout in milliseconds (when to mark user as stale)
+   */
+  PRESENCE_TIMEOUT_MS: 1e4
+  // 10 seconds
+};
+var DATABASE = {
+  /**
+   * Batch size for bulk message inserts
+   */
+  MESSAGE_BATCH_SIZE: 100,
+  /**
+   * Batch size for bulk task inserts
+   */
+  TASK_BATCH_SIZE: 100,
+  /**
+   * Default pagination limit
+   */
+  DEFAULT_PAGE_SIZE: 50,
+  /**
+   * Maximum pagination limit
+   */
+  MAX_PAGE_SIZE: 100
+};
+var GIT = {
+  /**
+   * Default worktree base path (relative to ~/.agor)
+   */
+  WORKTREE_BASE_PATH: "worktrees",
+  /**
+   * Default repo clone path (relative to ~/.agor)
+   */
+  REPO_BASE_PATH: "repos"
+};
+var SESSION = {
+  /**
+   * Maximum number of messages to load initially
+   */
+  INITIAL_MESSAGE_LOAD: 100,
+  /**
+   * Message streaming chunk size
+   */
+  STREAMING_CHUNK_SIZE: 1
+};
+
+// src/config/context-resolver.ts
+async function resolveValue(key, flagValue, config) {
+  if (flagValue !== void 0 && flagValue !== null && flagValue !== "") {
+    return flagValue;
+  }
+  const cfg = config || await loadConfig();
+  const contextValue = cfg.context?.[key];
+  if (contextValue !== void 0 && contextValue !== null && contextValue !== "") {
+    return contextValue;
+  }
+  const defaultValue = cfg.defaults?.[key];
+  if (defaultValue !== void 0 && defaultValue !== null && defaultValue !== "") {
+    return defaultValue;
+  }
+  return void 0;
+}
+async function resolveValues(keys, flagValues, config) {
+  const cfg = config || await loadConfig();
+  const resolved = {};
+  for (const key of keys) {
+    const value = await resolveValue(key, flagValues?.[key], cfg);
+    if (value !== void 0) {
+      resolved[key] = value;
+    }
+  }
+  return resolved;
+}
+async function getEffectiveConfig(config) {
+  const cfg = config || await loadConfig();
+  return {
+    // Context values
+    board: await resolveValue("board", void 0, cfg),
+    session: await resolveValue("session", void 0, cfg),
+    repo: await resolveValue("repo", void 0, cfg),
+    agent: await resolveValue("agent", void 0, cfg),
+    // Display settings
+    tableStyle: cfg.display?.tableStyle,
+    colorOutput: cfg.display?.colorOutput !== void 0 ? String(cfg.display.colorOutput) : void 0,
+    shortIdLength: cfg.display?.shortIdLength !== void 0 ? String(cfg.display.shortIdLength) : void 0
+  };
+}
+
+// src/config/repo-list.ts
+function getRepoReferenceOptions(repos2, worktrees2 = []) {
+  const options = [];
+  const repoMap = new Map(repos2.map((repo) => [repo.repo_id, repo]));
+  for (const repo of repos2) {
+    options.push({
+      label: repo.slug,
+      value: repo.repo_id,
+      // Use repo_id as value
+      type: "managed",
+      slug: repo.slug,
+      description: `${repo.name} (bare repo)`
+    });
+  }
+  for (const worktree of worktrees2) {
+    const repo = repoMap.get(worktree.repo_id);
+    if (!repo) continue;
+    const reference = `${repo.slug}:${worktree.name}`;
+    options.push({
+      label: reference,
+      value: worktree.worktree_id,
+      // Use worktree_id as value
+      type: "managed-worktree",
+      slug: repo.slug,
+      worktree: worktree.name,
+      description: `${repo.name} - ${worktree.name} (${worktree.ref})`
+    });
+  }
+  return options;
+}
+function getGroupedRepoReferenceOptions(repos2, worktrees2 = []) {
+  const grouped = {};
+  const repoMap = new Map(repos2.map((repo) => [repo.repo_id, repo]));
+  for (const repo of repos2) {
+    const options = [];
+    options.push({
+      label: repo.slug,
+      value: repo.repo_id,
+      // Use repo_id as value
+      type: "managed",
+      slug: repo.slug,
+      description: `${repo.name} (bare repo)`
+    });
+    grouped[repo.slug] = options;
+  }
+  for (const worktree of worktrees2) {
+    const repo = repoMap.get(worktree.repo_id);
+    if (!repo) continue;
+    const reference = `${repo.slug}:${worktree.name}`;
+    if (!grouped[repo.slug]) {
+      grouped[repo.slug] = [];
+    }
+    grouped[repo.slug].push({
+      label: reference,
+      value: worktree.worktree_id,
+      // Use worktree_id as value
+      type: "managed-worktree",
+      slug: repo.slug,
+      worktree: worktree.name,
+      description: `${repo.name} - ${worktree.name} (${worktree.ref})`
+    });
+  }
+  return grouped;
+}
+function getDefaultRepoReference(repos2) {
+  if (repos2.length === 0) return void 0;
+  const firstRepo = repos2[0];
+  return firstRepo.slug;
+}
+
+// src/config/repo-reference.ts
+function parseRepoReference(ref) {
+  if (ref.startsWith("/") || /^[A-Z]:\\/.test(ref)) {
+    return { type: "path", path: ref };
+  }
+  if (ref.includes(":")) {
+    const [slug, worktree] = ref.split(":", 2);
+    return { type: "managed-worktree", slug, worktree };
+  }
+  return { type: "managed", slug: ref };
+}
+function extractSlugFromUrl(url) {
+  const cleanUrl = url.endsWith(".git") ? url.slice(0, -4) : url;
+  if (cleanUrl.includes("@")) {
+    const match2 = cleanUrl.match(/:([^/]+\/[^/]+)$/);
+    if (match2) {
+      return match2[1];
+    }
+  }
+  const match = cleanUrl.match(/[:/]([^/]+\/[^/]+)$/);
+  if (match) {
+    return match[1];
+  }
+  const segments = cleanUrl.split("/").filter(Boolean);
+  if (segments.length >= 2) {
+    return `${segments[segments.length - 2]}/${segments[segments.length - 1]}`;
+  }
+  throw new Error(`Could not extract slug from URL: ${url}`);
+}
+function isValidSlug(slug) {
+  const slugPattern = /^[a-zA-Z0-9_-]+\/[a-zA-Z0-9_-]+$/;
+  return slugPattern.test(slug);
+}
+async function resolveRepoReference(ref) {
+  const parsed = parseRepoReference(ref);
+  if (parsed.type === "path") {
+    return {
+      cwd: parsed.path,
+      managed_worktree: false
+    };
+  }
+  throw new Error(
+    `Repository lookup not implemented in this context. Parsed reference: ${JSON.stringify(parsed)}`
+  );
+}
+function formatRepoReference(slug, worktreeName) {
+  if (worktreeName) {
+    return `${slug}:${worktreeName}`;
+  }
+  return slug;
+}
+
+// src/db/index.ts
+var import_drizzle_orm14 = require("drizzle-orm");
+var import_bcryptjs2 = __toESM(require("bcryptjs"), 1);
+init_ids();
+
+// src/db/client.ts
+var import_client = require("@libsql/client");
+var import_libsql = require("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
+});
+var import_drizzle_orm = require("drizzle-orm");
+var import_sqlite_core = require("drizzle-orm/sqlite-core");
+var sessions = (0, import_sqlite_core.sqliteTable)(
+  "sessions",
+  {
+    // Primary identity
+    session_id: (0, import_sqlite_core.text)("session_id", { length: 36 }).primaryKey(),
+    created_at: (0, import_sqlite_core.integer)("created_at", { mode: "timestamp_ms" }).notNull(),
+    updated_at: (0, import_sqlite_core.integer)("updated_at", { mode: "timestamp_ms" }),
+    // User attribution
+    created_by: (0, import_sqlite_core.text)("created_by", { length: 36 }).notNull().default("anonymous"),
+    // Materialized for filtering/joins (cross-DB compatible)
+    status: (0, import_sqlite_core.text)("status", {
+      enum: ["idle", "running", "completed", "failed"]
+    }).notNull(),
+    agentic_tool: (0, import_sqlite_core.text)("agentic_tool", {
+      enum: ["claude-code", "cursor", "codex", "gemini"]
+    }).notNull(),
+    board_id: (0, import_sqlite_core.text)("board_id", { length: 36 }),
+    // NULL = no board
+    // Genealogy (materialized for tree queries)
+    parent_session_id: (0, import_sqlite_core.text)("parent_session_id", { length: 36 }),
+    forked_from_session_id: (0, import_sqlite_core.text)("forked_from_session_id", { length: 36 }),
+    // Worktree reference (REQUIRED: all sessions must have a worktree)
+    worktree_id: (0, import_sqlite_core.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: (0, import_sqlite_core.text)("data", { mode: "json" }).$type().notNull()
+  },
+  (table) => ({
+    statusIdx: (0, import_sqlite_core.index)("sessions_status_idx").on(table.status),
+    agenticToolIdx: (0, import_sqlite_core.index)("sessions_agentic_tool_idx").on(table.agentic_tool),
+    boardIdx: (0, import_sqlite_core.index)("sessions_board_idx").on(table.board_id),
+    worktreeIdx: (0, import_sqlite_core.index)("sessions_worktree_idx").on(table.worktree_id),
+    createdIdx: (0, import_sqlite_core.index)("sessions_created_idx").on(table.created_at),
+    parentIdx: (0, import_sqlite_core.index)("sessions_parent_idx").on(table.parent_session_id),
+    forkedIdx: (0, import_sqlite_core.index)("sessions_forked_idx").on(table.forked_from_session_id)
+  })
+);
+var tasks = (0, import_sqlite_core.sqliteTable)(
+  "tasks",
+  {
+    task_id: (0, import_sqlite_core.text)("task_id", { length: 36 }).primaryKey(),
+    session_id: (0, import_sqlite_core.text)("session_id", { length: 36 }).notNull().references(() => sessions.session_id, { onDelete: "cascade" }),
+    created_at: (0, import_sqlite_core.integer)("created_at", { mode: "timestamp_ms" }).notNull(),
+    completed_at: (0, import_sqlite_core.integer)("completed_at", { mode: "timestamp_ms" }),
+    status: (0, import_sqlite_core.text)("status", {
+      enum: [
+        "created",
+        "running",
+        "stopping",
+        "awaiting_permission",
+        "completed",
+        "failed",
+        "stopped"
+      ]
+    }).notNull(),
+    // User attribution
+    created_by: (0, import_sqlite_core.text)("created_by", { length: 36 }).notNull().default("anonymous"),
+    data: (0, import_sqlite_core.text)("data", { mode: "json" }).$type().notNull()
+  },
+  (table) => ({
+    sessionIdx: (0, import_sqlite_core.index)("tasks_session_idx").on(table.session_id),
+    statusIdx: (0, import_sqlite_core.index)("tasks_status_idx").on(table.status),
+    createdIdx: (0, import_sqlite_core.index)("tasks_created_idx").on(table.created_at)
+  })
+);
+var messages = (0, import_sqlite_core.sqliteTable)(
+  "messages",
+  {
+    // Primary identity
+    message_id: (0, import_sqlite_core.text)("message_id", { length: 36 }).primaryKey(),
+    created_at: (0, import_sqlite_core.integer)("created_at", { mode: "timestamp_ms" }).notNull(),
+    // Foreign keys (materialized for indexes)
+    session_id: (0, import_sqlite_core.text)("session_id", { length: 36 }).notNull().references(() => sessions.session_id, { onDelete: "cascade" }),
+    task_id: (0, import_sqlite_core.text)("task_id", { length: 36 }).references(() => tasks.task_id, {
+      onDelete: "set null"
+    }),
+    // Materialized for queries
+    type: (0, import_sqlite_core.text)("type", {
+      enum: ["user", "assistant", "system", "file-history-snapshot", "permission_request"]
+    }).notNull(),
+    role: (0, import_sqlite_core.text)("role", {
+      enum: ["user", "assistant", "system"]
+    }).notNull(),
+    index: (0, import_sqlite_core.integer)("index").notNull(),
+    // Position in conversation (0-based)
+    timestamp: (0, import_sqlite_core.integer)("timestamp", { mode: "timestamp_ms" }).notNull(),
+    content_preview: (0, import_sqlite_core.text)("content_preview"),
+    // First 200 chars for list views
+    // Full data (JSON blob)
+    data: (0, import_sqlite_core.text)("data", { mode: "json" }).$type().notNull()
+  },
+  (table) => ({
+    // Indexes for efficient lookups
+    sessionIdx: (0, import_sqlite_core.index)("messages_session_id_idx").on(table.session_id),
+    taskIdx: (0, import_sqlite_core.index)("messages_task_id_idx").on(table.task_id),
+    sessionIndexIdx: (0, import_sqlite_core.index)("messages_session_index_idx").on(table.session_id, table.index)
+  })
+);
+var boards = (0, import_sqlite_core.sqliteTable)(
+  "boards",
+  {
+    board_id: (0, import_sqlite_core.text)("board_id", { length: 36 }).primaryKey(),
+    created_at: (0, import_sqlite_core.integer)("created_at", { mode: "timestamp_ms" }).notNull(),
+    updated_at: (0, import_sqlite_core.integer)("updated_at", { mode: "timestamp_ms" }),
+    // User attribution
+    created_by: (0, import_sqlite_core.text)("created_by", { length: 36 }).notNull().default("anonymous"),
+    // Materialized for lookups
+    name: (0, import_sqlite_core.text)("name").notNull(),
+    slug: (0, import_sqlite_core.text)("slug").unique(),
+    // JSON blob for the rest
+    data: (0, import_sqlite_core.text)("data", { mode: "json" }).$type().notNull()
+  },
+  (table) => ({
+    nameIdx: (0, import_sqlite_core.index)("boards_name_idx").on(table.name),
+    slugIdx: (0, import_sqlite_core.index)("boards_slug_idx").on(table.slug)
+  })
+);
+var repos = (0, import_sqlite_core.sqliteTable)(
+  "repos",
+  {
+    repo_id: (0, import_sqlite_core.text)("repo_id", { length: 36 }).primaryKey(),
+    created_at: (0, import_sqlite_core.integer)("created_at", { mode: "timestamp_ms" }).notNull(),
+    updated_at: (0, import_sqlite_core.integer)("updated_at", { mode: "timestamp_ms" }),
+    // Materialized for querying
+    slug: (0, import_sqlite_core.text)("slug").notNull().unique(),
+    data: (0, import_sqlite_core.text)("data", { mode: "json" }).$type().notNull()
+  },
+  (table) => ({
+    slugIdx: (0, import_sqlite_core.index)("repos_slug_idx").on(table.slug)
+  })
+);
+var worktrees = (0, import_sqlite_core.sqliteTable)(
+  "worktrees",
+  {
+    // Primary identity
+    worktree_id: (0, import_sqlite_core.text)("worktree_id", { length: 36 }).primaryKey(),
+    repo_id: (0, import_sqlite_core.text)("repo_id", { length: 36 }).notNull().references(() => repos.repo_id, { onDelete: "cascade" }),
+    created_at: (0, import_sqlite_core.integer)("created_at", { mode: "timestamp_ms" }).notNull(),
+    updated_at: (0, import_sqlite_core.integer)("updated_at", { mode: "timestamp_ms" }),
+    // User attribution
+    created_by: (0, import_sqlite_core.text)("created_by", { length: 36 }).notNull().default("anonymous"),
+    // Materialized for queries
+    name: (0, import_sqlite_core.text)("name").notNull(),
+    // "feat-auth", "main"
+    ref: (0, import_sqlite_core.text)("ref").notNull(),
+    // Current branch/tag/commit
+    worktree_unique_id: (0, import_sqlite_core.integer)("worktree_unique_id").notNull(),
+    // Auto-assigned sequential ID for templates
+    // Board relationship (nullable - worktrees can exist without boards)
+    board_id: (0, import_sqlite_core.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: (0, import_sqlite_core.text)("data", { mode: "json" }).$type().notNull()
+  },
+  (table) => ({
+    repoIdx: (0, import_sqlite_core.index)("worktrees_repo_idx").on(table.repo_id),
+    nameIdx: (0, import_sqlite_core.index)("worktrees_name_idx").on(table.name),
+    refIdx: (0, import_sqlite_core.index)("worktrees_ref_idx").on(table.ref),
+    boardIdx: (0, import_sqlite_core.index)("worktrees_board_idx").on(table.board_id),
+    createdIdx: (0, import_sqlite_core.index)("worktrees_created_idx").on(table.created_at),
+    updatedIdx: (0, import_sqlite_core.index)("worktrees_updated_idx").on(table.updated_at),
+    // Composite unique constraint (repo + name)
+    uniqueRepoName: (0, import_sqlite_core.index)("worktrees_repo_name_unique").on(table.repo_id, table.name)
+  })
+);
+var users = (0, import_sqlite_core.sqliteTable)(
+  "users",
+  {
+    // Primary identity
+    user_id: (0, import_sqlite_core.text)("user_id", { length: 36 }).primaryKey(),
+    created_at: (0, import_sqlite_core.integer)("created_at", { mode: "timestamp_ms" }).notNull(),
+    updated_at: (0, import_sqlite_core.integer)("updated_at", { mode: "timestamp_ms" }),
+    // Materialized for auth lookups
+    email: (0, import_sqlite_core.text)("email").unique().notNull(),
+    password: (0, import_sqlite_core.text)("password").notNull(),
+    // bcrypt hashed
+    // Basic profile (materialized for display)
+    name: (0, import_sqlite_core.text)("name"),
+    emoji: (0, import_sqlite_core.text)("emoji"),
+    role: (0, import_sqlite_core.text)("role", {
+      enum: ["owner", "admin", "member", "viewer"]
+    }).notNull().default("member"),
+    // Onboarding state
+    onboarding_completed: (0, import_sqlite_core.integer)("onboarding_completed", { mode: "boolean" }).notNull().default(false),
+    // JSON blob for profile/preferences
+    data: (0, import_sqlite_core.text)("data", { mode: "json" }).$type().notNull()
+  },
+  (table) => ({
+    emailIdx: (0, import_sqlite_core.index)("users_email_idx").on(table.email)
+  })
+);
+var mcpServers = (0, import_sqlite_core.sqliteTable)(
+  "mcp_servers",
+  {
+    // Primary identity
+    mcp_server_id: (0, import_sqlite_core.text)("mcp_server_id", { length: 36 }).primaryKey(),
+    created_at: (0, import_sqlite_core.integer)("created_at", { mode: "timestamp_ms" }).notNull(),
+    updated_at: (0, import_sqlite_core.integer)("updated_at", { mode: "timestamp_ms" }),
+    // Materialized for filtering
+    name: (0, import_sqlite_core.text)("name").notNull(),
+    // e.g., "filesystem", "sentry"
+    transport: (0, import_sqlite_core.text)("transport", {
+      enum: ["stdio", "http", "sse"]
+    }).notNull(),
+    scope: (0, import_sqlite_core.text)("scope", {
+      enum: ["global", "team", "repo", "session"]
+    }).notNull(),
+    enabled: (0, import_sqlite_core.integer)("enabled", { mode: "boolean" }).notNull().default(true),
+    // Scope foreign keys (materialized for indexes)
+    owner_user_id: (0, import_sqlite_core.text)("owner_user_id", { length: 36 }),
+    team_id: (0, import_sqlite_core.text)("team_id", { length: 36 }),
+    repo_id: (0, import_sqlite_core.text)("repo_id", { length: 36 }).references(() => repos.repo_id, {
+      onDelete: "cascade"
+    }),
+    session_id: (0, import_sqlite_core.text)("session_id", { length: 36 }).references(() => sessions.session_id, {
+      onDelete: "cascade"
+    }),
+    // Source tracking (materialized for queries)
+    source: (0, import_sqlite_core.text)("source", {
+      enum: ["user", "imported", "agor"]
+    }).notNull(),
+    // JSON blob for configuration and capabilities
+    data: (0, import_sqlite_core.text)("data", { mode: "json" }).$type().notNull()
+  },
+  (table) => ({
+    nameIdx: (0, import_sqlite_core.index)("mcp_servers_name_idx").on(table.name),
+    scopeIdx: (0, import_sqlite_core.index)("mcp_servers_scope_idx").on(table.scope),
+    ownerIdx: (0, import_sqlite_core.index)("mcp_servers_owner_idx").on(table.owner_user_id),
+    teamIdx: (0, import_sqlite_core.index)("mcp_servers_team_idx").on(table.team_id),
+    repoIdx: (0, import_sqlite_core.index)("mcp_servers_repo_idx").on(table.repo_id),
+    sessionIdx: (0, import_sqlite_core.index)("mcp_servers_session_idx").on(table.session_id),
+    enabledIdx: (0, import_sqlite_core.index)("mcp_servers_enabled_idx").on(table.enabled)
+  })
+);
+var boardObjects = (0, import_sqlite_core.sqliteTable)(
+  "board_objects",
+  {
+    // Primary identity
+    object_id: (0, import_sqlite_core.text)("object_id", { length: 36 }).primaryKey(),
+    board_id: (0, import_sqlite_core.text)("board_id", { length: 36 }).notNull().references(() => boards.board_id, { onDelete: "cascade" }),
+    created_at: (0, import_sqlite_core.integer)("created_at", { mode: "timestamp_ms" }).notNull(),
+    // Worktree reference
+    worktree_id: (0, import_sqlite_core.text)("worktree_id", { length: 36 }).notNull().references(() => worktrees.worktree_id, {
+      onDelete: "cascade"
+    }),
+    // Position data (JSON)
+    data: (0, import_sqlite_core.text)("data", { mode: "json" }).$type().notNull()
+  },
+  (table) => ({
+    boardIdx: (0, import_sqlite_core.index)("board_objects_board_idx").on(table.board_id),
+    worktreeIdx: (0, import_sqlite_core.index)("board_objects_worktree_idx").on(table.worktree_id)
+  })
+);
+var sessionMcpServers = (0, import_sqlite_core.sqliteTable)(
+  "session_mcp_servers",
+  {
+    session_id: (0, import_sqlite_core.text)("session_id", { length: 36 }).notNull().references(() => sessions.session_id, { onDelete: "cascade" }),
+    mcp_server_id: (0, import_sqlite_core.text)("mcp_server_id", { length: 36 }).notNull().references(() => mcpServers.mcp_server_id, { onDelete: "cascade" }),
+    enabled: (0, import_sqlite_core.integer)("enabled", { mode: "boolean" }).notNull().default(true),
+    added_at: (0, import_sqlite_core.integer)("added_at", { mode: "timestamp_ms" }).notNull()
+  },
+  (table) => ({
+    // Composite primary key
+    pk: (0, import_sqlite_core.index)("session_mcp_servers_pk").on(table.session_id, table.mcp_server_id),
+    // Indexes for queries
+    sessionIdx: (0, import_sqlite_core.index)("session_mcp_servers_session_idx").on(table.session_id),
+    serverIdx: (0, import_sqlite_core.index)("session_mcp_servers_server_idx").on(table.mcp_server_id),
+    enabledIdx: (0, import_sqlite_core.index)("session_mcp_servers_enabled_idx").on(table.session_id, table.enabled)
+  })
+);
+var boardComments = (0, import_sqlite_core.sqliteTable)(
+  "board_comments",
+  {
+    // Primary identity
+    comment_id: (0, import_sqlite_core.text)("comment_id", { length: 36 }).primaryKey(),
+    created_at: (0, import_sqlite_core.integer)("created_at", { mode: "timestamp_ms" }).notNull(),
+    updated_at: (0, import_sqlite_core.integer)("updated_at", { mode: "timestamp_ms" }),
+    // Scoping & authorship
+    board_id: (0, import_sqlite_core.text)("board_id", { length: 36 }).notNull().references(() => boards.board_id, { onDelete: "cascade" }),
+    created_by: (0, import_sqlite_core.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: (0, import_sqlite_core.text)("session_id", { length: 36 }).references(() => sessions.session_id, {
+      onDelete: "set null"
+    }),
+    task_id: (0, import_sqlite_core.text)("task_id", { length: 36 }).references(() => tasks.task_id, {
+      onDelete: "set null"
+    }),
+    message_id: (0, import_sqlite_core.text)("message_id", { length: 36 }).references(() => messages.message_id, {
+      onDelete: "set null"
+    }),
+    worktree_id: (0, import_sqlite_core.text)("worktree_id", { length: 36 }).references(() => worktrees.worktree_id, {
+      onDelete: "set null"
+    }),
+    // Content (materialized for display)
+    content: (0, import_sqlite_core.text)("content").notNull(),
+    // Markdown-supported text
+    content_preview: (0, import_sqlite_core.text)("content_preview").notNull(),
+    // First 200 chars
+    // Thread support (optional)
+    parent_comment_id: (0, import_sqlite_core.text)("parent_comment_id", { length: 36 }),
+    // Metadata (materialized for filtering)
+    resolved: (0, import_sqlite_core.integer)("resolved", { mode: "boolean" }).notNull().default(false),
+    edited: (0, import_sqlite_core.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: (0, import_sqlite_core.text)("reactions", { mode: "json" }).$type().notNull().default(import_drizzle_orm.sql`'[]'`),
+    // JSON blob for advanced features
+    data: (0, import_sqlite_core.text)("data", { mode: "json" }).$type().notNull()
+  },
+  (table) => ({
+    boardIdx: (0, import_sqlite_core.index)("board_comments_board_idx").on(table.board_id),
+    sessionIdx: (0, import_sqlite_core.index)("board_comments_session_idx").on(table.session_id),
+    taskIdx: (0, import_sqlite_core.index)("board_comments_task_idx").on(table.task_id),
+    messageIdx: (0, import_sqlite_core.index)("board_comments_message_idx").on(table.message_id),
+    worktreeIdx: (0, import_sqlite_core.index)("board_comments_worktree_idx").on(table.worktree_id),
+    createdByIdx: (0, import_sqlite_core.index)("board_comments_created_by_idx").on(table.created_by),
+    parentIdx: (0, import_sqlite_core.index)("board_comments_parent_idx").on(table.parent_comment_id),
+    createdIdx: (0, import_sqlite_core.index)("board_comments_created_idx").on(table.created_at),
+    resolvedIdx: (0, import_sqlite_core.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(path2) {
+  if (path2.startsWith("~/")) {
+    const home = process.env.HOME || process.env.USERPROFILE || "";
+    return path2.replace("~", home);
+  }
+  return path2;
+}
+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 (0, import_client.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 (0, import_libsql.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
+var import_drizzle_orm2 = require("drizzle-orm");
+var import_migrator = require("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(import_drizzle_orm2.sql`
+      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(import_drizzle_orm2.sql`
+      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(import_drizzle_orm2.sql`
+      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(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS sessions_status_idx ON sessions(status)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS sessions_agentic_tool_idx ON sessions(agentic_tool)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS sessions_board_idx ON sessions(board_id)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS sessions_worktree_idx ON sessions(worktree_id)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS sessions_created_idx ON sessions(created_at)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS sessions_parent_idx ON sessions(parent_session_id)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS sessions_forked_idx ON sessions(forked_from_session_id)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      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(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS tasks_session_idx ON tasks(session_id)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS tasks_status_idx ON tasks(status)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS tasks_created_idx ON tasks(created_at)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      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(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS boards_name_idx ON boards(name)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS boards_slug_idx ON boards(slug)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      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(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS repos_slug_idx ON repos(slug)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      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(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS worktrees_repo_idx ON worktrees(repo_id)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS worktrees_name_idx ON worktrees(name)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS worktrees_ref_idx ON worktrees(ref)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS worktrees_board_idx ON worktrees(board_id)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS worktrees_created_idx ON worktrees(created_at)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS worktrees_updated_idx ON worktrees(updated_at)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS worktrees_repo_name_unique ON worktrees(repo_id, name)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      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(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS messages_session_id_idx ON messages(session_id)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS messages_task_id_idx ON messages(task_id)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS messages_session_index_idx ON messages(session_id, "index")
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      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(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS users_email_idx ON users(email)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      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(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS mcp_servers_name_idx ON mcp_servers(name)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS mcp_servers_scope_idx ON mcp_servers(scope)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS mcp_servers_owner_idx ON mcp_servers(owner_user_id)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS mcp_servers_team_idx ON mcp_servers(team_id)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS mcp_servers_repo_idx ON mcp_servers(repo_id)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS mcp_servers_session_idx ON mcp_servers(session_id)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS mcp_servers_enabled_idx ON mcp_servers(enabled)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      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(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS session_mcp_servers_pk ON session_mcp_servers(session_id, mcp_server_id)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS session_mcp_servers_session_idx ON session_mcp_servers(session_id)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS session_mcp_servers_server_idx ON session_mcp_servers(mcp_server_id)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS session_mcp_servers_enabled_idx ON session_mcp_servers(session_id, enabled)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      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(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS board_objects_board_idx ON board_objects(board_id)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS board_objects_worktree_idx ON board_objects(worktree_id)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      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(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS board_comments_board_idx ON board_comments(board_id)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS board_comments_session_idx ON board_comments(session_id)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS board_comments_task_idx ON board_comments(task_id)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS board_comments_message_idx ON board_comments(message_id)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS board_comments_worktree_idx ON board_comments(worktree_id)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS board_comments_created_by_idx ON board_comments(created_by)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS board_comments_parent_idx ON board_comments(parent_comment_id)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      CREATE INDEX IF NOT EXISTS board_comments_created_idx ON board_comments(created_at)
+    `);
+    await db.run(import_drizzle_orm2.sql`
+      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 (0, import_migrator.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(import_drizzle_orm2.sql`
+          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(import_drizzle_orm2.sql`CREATE INDEX board_comments_board_idx ON board_comments(board_id)`);
+        await db.run(import_drizzle_orm2.sql`CREATE INDEX board_comments_session_idx ON board_comments(session_id)`);
+        await db.run(import_drizzle_orm2.sql`CREATE INDEX board_comments_task_idx ON board_comments(task_id)`);
+        await db.run(import_drizzle_orm2.sql`CREATE INDEX board_comments_message_idx ON board_comments(message_id)`);
+        await db.run(import_drizzle_orm2.sql`CREATE INDEX board_comments_worktree_idx ON board_comments(worktree_id)`);
+        await db.run(import_drizzle_orm2.sql`CREATE INDEX board_comments_created_by_idx ON board_comments(created_by)`);
+        await db.run(
+          import_drizzle_orm2.sql`CREATE INDEX board_comments_parent_idx ON board_comments(parent_comment_id)`
+        );
+        await db.run(import_drizzle_orm2.sql`CREATE INDEX board_comments_created_idx ON board_comments(created_at)`);
+        await db.run(import_drizzle_orm2.sql`CREATE INDEX board_comments_resolved_idx ON board_comments(resolved)`);
+        console.log("  \u2705 board_comments table added");
+      } else {
+        try {
+          const tableInfo = await db.run(import_drizzle_orm2.sql`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(import_drizzle_orm2.sql`
+              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(import_drizzle_orm2.sql`
+      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(import_drizzle_orm2.sql`
+        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
+var import_drizzle_orm3 = require("drizzle-orm");
+init_ids();
+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((0, import_drizzle_orm3.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((0, import_drizzle_orm3.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((0, import_drizzle_orm3.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((0, import_drizzle_orm3.eq)(boardComments.board_id, filters.board_id));
+      }
+      if (filters?.session_id !== void 0) {
+        if (filters.session_id === null) {
+          conditions.push((0, import_drizzle_orm3.isNull)(boardComments.session_id));
+        } else {
+          conditions.push((0, import_drizzle_orm3.eq)(boardComments.session_id, filters.session_id));
+        }
+      }
+      if (filters?.task_id !== void 0) {
+        if (filters.task_id === null) {
+          conditions.push((0, import_drizzle_orm3.isNull)(boardComments.task_id));
+        } else {
+          conditions.push((0, import_drizzle_orm3.eq)(boardComments.task_id, filters.task_id));
+        }
+      }
+      if (filters?.message_id !== void 0) {
+        if (filters.message_id === null) {
+          conditions.push((0, import_drizzle_orm3.isNull)(boardComments.message_id));
+        } else {
+          conditions.push((0, import_drizzle_orm3.eq)(boardComments.message_id, filters.message_id));
+        }
+      }
+      if (filters?.worktree_id !== void 0) {
+        if (filters.worktree_id === null) {
+          conditions.push((0, import_drizzle_orm3.isNull)(boardComments.worktree_id));
+        } else {
+          conditions.push((0, import_drizzle_orm3.eq)(boardComments.worktree_id, filters.worktree_id));
+        }
+      }
+      if (filters?.resolved !== void 0) {
+        conditions.push((0, import_drizzle_orm3.eq)(boardComments.resolved, filters.resolved));
+      }
+      if (filters?.created_by) {
+        conditions.push((0, import_drizzle_orm3.eq)(boardComments.created_by, filters.created_by));
+      }
+      if (conditions.length > 0) {
+        query = query.where((0, import_drizzle_orm3.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((0, import_drizzle_orm3.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((0, import_drizzle_orm3.eq)(boardComments.parent_comment_id, fullId)).run();
+      const result = await this.db.delete(boardComments).where((0, import_drizzle_orm3.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(
+        (0, import_drizzle_orm3.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
+var import_drizzle_orm4 = require("drizzle-orm");
+init_ids();
+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((0, import_drizzle_orm4.eq)(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((0, import_drizzle_orm4.eq)(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((0, import_drizzle_orm4.eq)(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((0, import_drizzle_orm4.eq)(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((0, import_drizzle_orm4.eq)(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((0, import_drizzle_orm4.eq)(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((0, import_drizzle_orm4.eq)(boardObjects.object_id, objectId));
+      const row = await this.db.select().from(boardObjects).where((0, import_drizzle_orm4.eq)(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((0, import_drizzle_orm4.eq)(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((0, import_drizzle_orm4.eq)(boardObjects.object_id, objectId));
+      const row = await this.db.select().from(boardObjects).where((0, import_drizzle_orm4.eq)(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((0, import_drizzle_orm4.eq)(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((0, import_drizzle_orm4.eq)(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
+var import_drizzle_orm5 = require("drizzle-orm");
+init_ids();
+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((0, import_drizzle_orm5.like)(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((0, import_drizzle_orm5.eq)(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((0, import_drizzle_orm5.eq)(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((0, import_drizzle_orm5.eq)(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((0, import_drizzle_orm5.eq)(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((0, import_drizzle_orm5.eq)(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
+var import_drizzle_orm6 = require("drizzle-orm");
+init_ids();
+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((0, import_drizzle_orm6.like)(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((0, import_drizzle_orm6.eq)(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((0, import_drizzle_orm6.eq)(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((0, import_drizzle_orm6.eq)(mcpServers.scope, filters.scope));
+      }
+      if (filters?.scopeId) {
+        if (filters.scope === "global") {
+          conditions.push((0, import_drizzle_orm6.eq)(mcpServers.owner_user_id, filters.scopeId));
+        } else if (filters.scope === "team") {
+          conditions.push((0, import_drizzle_orm6.eq)(mcpServers.team_id, filters.scopeId));
+        } else if (filters.scope === "repo") {
+          conditions.push((0, import_drizzle_orm6.eq)(mcpServers.repo_id, filters.scopeId));
+        } else if (filters.scope === "session") {
+          conditions.push((0, import_drizzle_orm6.eq)(mcpServers.session_id, filters.scopeId));
+        }
+      }
+      if (filters?.transport) {
+        conditions.push((0, import_drizzle_orm6.eq)(mcpServers.transport, filters.transport));
+      }
+      if (filters?.enabled !== void 0) {
+        conditions.push((0, import_drizzle_orm6.eq)(mcpServers.enabled, filters.enabled));
+      }
+      if (filters?.source) {
+        conditions.push((0, import_drizzle_orm6.eq)(mcpServers.source, filters.source));
+      }
+      if (conditions.length > 0) {
+        query = query.where((0, import_drizzle_orm6.and)(...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((0, import_drizzle_orm6.eq)(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((0, import_drizzle_orm6.eq)(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
+var import_drizzle_orm7 = require("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((0, import_drizzle_orm7.eq)(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((0, import_drizzle_orm7.eq)(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((0, import_drizzle_orm7.eq)(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((0, import_drizzle_orm7.eq)(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((0, import_drizzle_orm7.eq)(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((0, import_drizzle_orm7.eq)(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((0, import_drizzle_orm7.eq)(messages.session_id, sessionId));
+  }
+  /**
+   * Delete a single message
+   */
+  async delete(messageId) {
+    await this.db.delete(messages).where((0, import_drizzle_orm7.eq)(messages.message_id, messageId));
+  }
+};
+
+// src/db/repositories/repos.ts
+var import_drizzle_orm8 = require("drizzle-orm");
+init_ids();
+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((0, import_drizzle_orm8.like)(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((0, import_drizzle_orm8.eq)(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((0, import_drizzle_orm8.eq)(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((0, import_drizzle_orm8.eq)(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((0, import_drizzle_orm8.eq)(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((0, import_drizzle_orm8.eq)(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: import_drizzle_orm8.sql`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
+var import_drizzle_orm10 = require("drizzle-orm");
+
+// src/types/board-comment.ts
+var CommentAttachmentType = {
+  MESSAGE: "message",
+  TASK: "task",
+  SESSION_SPATIAL: "session-spatial",
+  SESSION: "session",
+  WORKTREE: "worktree",
+  BOARD_SPATIAL: "board-spatial",
+  BOARD: "board"
+};
+function getCommentAttachmentType(comment) {
+  if (comment.message_id) return CommentAttachmentType.MESSAGE;
+  if (comment.task_id) return CommentAttachmentType.TASK;
+  if (comment.session_id && comment.position?.relative)
+    return CommentAttachmentType.SESSION_SPATIAL;
+  if (comment.session_id) return CommentAttachmentType.SESSION;
+  if (comment.worktree_id) return CommentAttachmentType.WORKTREE;
+  if (comment.position?.absolute) return CommentAttachmentType.BOARD_SPATIAL;
+  return CommentAttachmentType.BOARD;
+}
+function isThreadRoot(comment) {
+  return !comment.parent_comment_id;
+}
+function isReply(comment) {
+  return !!comment.parent_comment_id;
+}
+function isResolvable(comment) {
+  return isThreadRoot(comment);
+}
+function groupReactions(reactions) {
+  const grouped = {};
+  for (const { emoji, user_id } of reactions) {
+    if (!grouped[emoji]) {
+      grouped[emoji] = [];
+    }
+    grouped[emoji].push(user_id);
+  }
+  return grouped;
+}
+
+// src/types/message.ts
+var MessageRole = /* @__PURE__ */ ((MessageRole2) => {
+  MessageRole2["USER"] = "user";
+  MessageRole2["ASSISTANT"] = "assistant";
+  MessageRole2["SYSTEM"] = "system";
+  return MessageRole2;
+})(MessageRole || {});
+var PermissionScope = /* @__PURE__ */ ((PermissionScope2) => {
+  PermissionScope2["ONCE"] = "once";
+  PermissionScope2["SESSION"] = "session";
+  PermissionScope2["PROJECT"] = "project";
+  return PermissionScope2;
+})(PermissionScope || {});
+var PermissionStatus = /* @__PURE__ */ ((PermissionStatus2) => {
+  PermissionStatus2["PENDING"] = "pending";
+  PermissionStatus2["APPROVED"] = "approved";
+  PermissionStatus2["DENIED"] = "denied";
+  return PermissionStatus2;
+})(PermissionStatus || {});
+
+// src/types/session.ts
+var SessionStatus = {
+  IDLE: "idle",
+  RUNNING: "running",
+  COMPLETED: "completed",
+  FAILED: "failed"
+};
+function getDefaultPermissionMode(agenticTool) {
+  switch (agenticTool) {
+    case "codex":
+      return "auto";
+    default:
+      return "acceptEdits";
+  }
+}
+
+// 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/types/utils.ts
+function isDefined(value) {
+  return value !== null && value !== void 0;
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+
+// src/db/repositories/sessions.ts
+var import_drizzle_orm9 = require("drizzle-orm");
+init_ids();
+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((0, import_drizzle_orm9.like)(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((0, import_drizzle_orm9.eq)(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((0, import_drizzle_orm9.eq)(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((0, import_drizzle_orm9.eq)(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(
+        (0, import_drizzle_orm9.or)(
+          import_drizzle_orm9.sql`json_extract(${sessions.data}, '$.genealogy.parent_session_id') = ${fullId}`,
+          import_drizzle_orm9.sql`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((0, import_drizzle_orm9.eq)(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((0, import_drizzle_orm9.eq)(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: import_drizzle_orm9.sql`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(
+        (0, import_drizzle_orm10.and)(
+          (0, import_drizzle_orm10.eq)(sessionMcpServers.session_id, sessionId),
+          (0, import_drizzle_orm10.eq)(sessionMcpServers.mcp_server_id, serverId)
+        )
+      ).get();
+      if (existing) {
+        await this.db.update(sessionMcpServers).set({ enabled: true }).where(
+          (0, import_drizzle_orm10.and)(
+            (0, import_drizzle_orm10.eq)(sessionMcpServers.session_id, sessionId),
+            (0, import_drizzle_orm10.eq)(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(
+        (0, import_drizzle_orm10.and)(
+          (0, import_drizzle_orm10.eq)(sessionMcpServers.session_id, sessionId),
+          (0, import_drizzle_orm10.eq)(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(
+        (0, import_drizzle_orm10.and)(
+          (0, import_drizzle_orm10.eq)(sessionMcpServers.session_id, sessionId),
+          (0, import_drizzle_orm10.eq)(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 = [(0, import_drizzle_orm10.eq)(sessionMcpServers.session_id, sessionId)];
+      if (enabledOnly) {
+        conditions.push((0, import_drizzle_orm10.eq)(sessionMcpServers.enabled, true));
+      }
+      const relationships = await this.db.select().from(sessionMcpServers).where((0, import_drizzle_orm10.and)(...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((0, import_drizzle_orm10.eq)(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(
+        (0, import_drizzle_orm10.and)(
+          (0, import_drizzle_orm10.eq)(sessionMcpServers.session_id, sessionId),
+          (0, import_drizzle_orm10.eq)(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
+var import_drizzle_orm11 = require("drizzle-orm");
+init_ids();
+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((0, import_drizzle_orm11.like)(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((0, import_drizzle_orm11.eq)(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(import_drizzle_orm11.sql`${tasks.task_id} IN ${import_drizzle_orm11.sql.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((0, import_drizzle_orm11.eq)(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((0, import_drizzle_orm11.eq)(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((0, import_drizzle_orm11.eq)(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((0, import_drizzle_orm11.eq)(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((0, import_drizzle_orm11.eq)(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((0, import_drizzle_orm11.eq)(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: import_drizzle_orm11.sql`count(*)` }).from(tasks).where((0, import_drizzle_orm11.eq)(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
+var import_drizzle_orm12 = require("drizzle-orm");
+init_ids();
+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((0, import_drizzle_orm12.eq)(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((0, import_drizzle_orm12.like)(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((0, import_drizzle_orm12.eq)(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((0, import_drizzle_orm12.eq)(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((0, import_drizzle_orm12.eq)(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(import_drizzle_orm12.sql`${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
+var import_bcryptjs = __toESM(require("bcryptjs"), 1);
+var import_drizzle_orm13 = require("drizzle-orm");
+init_ids();
+async function createUser(db, data) {
+  const existing = await db.select().from(users).where((0, import_drizzle_orm13.eq)(users.email, data.email)).get();
+  if (existing) {
+    throw new Error(`User with email ${data.email} already exists`);
+  }
+  const hashedPassword = await import_bcryptjs.default.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((0, import_drizzle_orm13.eq)(users.email, email)).get();
+  return !!existing;
+}
+async function getUserByEmail(db, email) {
+  const row = await db.select().from(users).where((0, import_drizzle_orm13.eq)(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 = import_bcryptjs2.default.compare;
+var hash = import_bcryptjs2.default.hash;
+
+// src/git/index.ts
+var import_node_fs = require("fs");
+var import_promises2 = require("fs/promises");
+var import_node_os2 = require("os");
+var import_node_path2 = require("path");
+var import_simple_git = require("simple-git");
+function getGitBinary() {
+  const commonPaths = [
+    "/opt/homebrew/bin/git",
+    // Homebrew on Apple Silicon
+    "/usr/local/bin/git",
+    // Homebrew on Intel
+    "/usr/bin/git"
+    // System git (Docker and Linux)
+  ];
+  for (const path2 of commonPaths) {
+    if ((0, import_node_fs.existsSync)(path2)) {
+      return path2;
+    }
+  }
+  return void 0;
+}
+function createGit(baseDir) {
+  const gitBinary = getGitBinary();
+  const config = [
+    "core.sshCommand=ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null"
+  ];
+  return (0, import_simple_git.simpleGit)({
+    baseDir,
+    binary: gitBinary,
+    config
+  });
+}
+function getReposDir() {
+  return (0, import_node_path2.join)((0, import_node_os2.homedir)(), ".agor", "repos");
+}
+function extractRepoName(url) {
+  const match = url.match(/\/([^/]+?)(?:\.git)?$/);
+  if (!match) {
+    throw new Error(`Could not extract repo name from URL: ${url}`);
+  }
+  return match[1];
+}
+async function cloneRepo(options) {
+  const repoName = extractRepoName(options.url);
+  const reposDir = getReposDir();
+  const targetPath = options.targetDir || (0, import_node_path2.join)(reposDir, repoName);
+  await (0, import_promises2.mkdir)(reposDir, { recursive: true });
+  if ((0, import_node_fs.existsSync)(targetPath)) {
+    const isValid = await isGitRepo(targetPath);
+    if (isValid) {
+      console.log(`Repository already exists at ${targetPath}, using existing clone`);
+      const defaultBranch2 = await getDefaultBranch(targetPath);
+      return {
+        path: targetPath,
+        repoName,
+        defaultBranch: defaultBranch2
+      };
+    } else {
+      throw new Error(
+        `Directory exists but is not a valid git repository: ${targetPath}
+Please delete this directory manually and try again.`
+      );
+    }
+  }
+  const git = createGit();
+  if (options.onProgress) {
+    git.outputHandler((_command, _stdout, _stderr) => {
+    });
+  }
+  await git.clone(options.url, targetPath, options.bare ? ["--bare"] : []);
+  const defaultBranch = await getDefaultBranch(targetPath);
+  return {
+    path: targetPath,
+    repoName,
+    defaultBranch
+  };
+}
+async function isGitRepo(path2) {
+  try {
+    const git = createGit(path2);
+    await git.status();
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getCurrentBranch(repoPath) {
+  const git = createGit(repoPath);
+  const status = await git.status();
+  return status.current || "";
+}
+async function getDefaultBranch(repoPath, remote = "origin") {
+  const git = createGit(repoPath);
+  try {
+    const result = await git.raw(["symbolic-ref", `refs/remotes/${remote}/HEAD`]);
+    const match = result.trim().match(/refs\/remotes\/[^/]+\/(.+)/);
+    if (match && match[1]) {
+      return match[1];
+    }
+  } catch {
+  }
+  try {
+    const branches = await git.branch();
+    return branches.current || "main";
+  } catch {
+    return "main";
+  }
+}
+async function getCurrentSha(repoPath) {
+  const git = createGit(repoPath);
+  const log = await git.log({ maxCount: 1 });
+  return log.latest?.hash || "";
+}
+async function isClean(repoPath) {
+  const git = createGit(repoPath);
+  const status = await git.status();
+  return status.isClean();
+}
+async function getRemoteUrl(repoPath, remote = "origin") {
+  const git = createGit(repoPath);
+  const remotes = await git.getRemotes(true);
+  const remoteObj = remotes.find((r) => r.name === remote);
+  return remoteObj?.refs.fetch || "";
+}
+function getWorktreesDir() {
+  return (0, import_node_path2.join)((0, import_node_os2.homedir)(), ".agor", "worktrees");
+}
+function getWorktreePath(repoSlug, worktreeName) {
+  return (0, import_node_path2.join)(getWorktreesDir(), repoSlug, worktreeName);
+}
+async function createWorktree(repoPath, worktreePath, ref, createBranch = false, pullLatest = true, sourceBranch) {
+  const git = createGit(repoPath);
+  let fetchSucceeded = false;
+  if (pullLatest) {
+    try {
+      await git.fetch(["origin"]);
+      fetchSucceeded = true;
+      console.log("\u2705 Fetched latest from origin");
+      if (!createBranch) {
+        try {
+          const branches = await git.branch();
+          const localBranchExists = branches.all.includes(ref);
+          if (localBranchExists) {
+            const remoteBranches = await git.branch(["-r"]);
+            const remoteBranchExists = remoteBranches.all.includes(`origin/${ref}`);
+            if (remoteBranchExists) {
+              await git.raw(["branch", "-f", ref, `origin/${ref}`]);
+              console.log(`\u2705 Updated local ${ref} to match origin/${ref}`);
+            }
+          }
+        } catch (error) {
+          console.warn(
+            `\u26A0\uFE0F  Failed to update local ${ref} branch:`,
+            error instanceof Error ? error.message : String(error)
+          );
+        }
+      }
+    } catch (error) {
+      console.warn(
+        "\u26A0\uFE0F  Failed to fetch from origin (will use local refs):",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  const args = [worktreePath];
+  if (createBranch) {
+    args.push("-b", ref);
+    if (sourceBranch) {
+      const baseRef = fetchSucceeded ? `origin/${sourceBranch}` : sourceBranch;
+      args.push(baseRef);
+    }
+  } else {
+    args.push(ref);
+  }
+  await git.raw(["worktree", "add", ...args]);
+}
+async function listWorktrees(repoPath) {
+  const git = createGit(repoPath);
+  const output = await git.raw(["worktree", "list", "--porcelain"]);
+  const worktrees2 = [];
+  const lines = output.split("\n");
+  let current = {};
+  for (const line of lines) {
+    if (line.startsWith("worktree ")) {
+      current.path = line.substring(9);
+      current.name = (0, import_node_path2.basename)(current.path);
+    } else if (line.startsWith("HEAD ")) {
+      current.sha = line.substring(5);
+    } else if (line.startsWith("branch ")) {
+      current.ref = line.substring(7).replace("refs/heads/", "");
+      current.detached = false;
+    } else if (line.startsWith("detached")) {
+      current.detached = true;
+    } else if (line === "") {
+      if (current.path && current.sha) {
+        worktrees2.push(current);
+      }
+      current = {};
+    }
+  }
+  if (current.path && current.sha) {
+    worktrees2.push(current);
+  }
+  return worktrees2;
+}
+async function removeWorktree(repoPath, worktreeName) {
+  const git = createGit(repoPath);
+  await git.raw(["worktree", "remove", worktreeName]);
+}
+async function pruneWorktrees(repoPath) {
+  const git = createGit(repoPath);
+  await git.raw(["worktree", "prune"]);
+}
+async function hasRemoteBranch(repoPath, branchName, remote = "origin") {
+  const git = createGit(repoPath);
+  const branches = await git.branch(["-r"]);
+  return branches.all.includes(`${remote}/${branchName}`);
+}
+async function getRemoteBranches(repoPath, remote = "origin") {
+  const git = createGit(repoPath);
+  const branches = await git.branch(["-r"]);
+  return branches.all.filter((b) => b.startsWith(`${remote}/`)).map((b) => b.replace(`${remote}/`, ""));
+}
+async function getGitState(repoPath) {
+  try {
+    if (!await isGitRepo(repoPath)) {
+      return "unknown";
+    }
+    const sha = await getCurrentSha(repoPath);
+    if (!sha) {
+      return "unknown";
+    }
+    const clean = await isClean(repoPath);
+    return clean ? sha : `${sha}-dirty`;
+  } catch (error) {
+    console.warn(`Failed to get git state for ${repoPath}:`, error);
+    return "unknown";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AmbiguousIdError,
+  BoardCommentsRepository,
+  BoardObjectRepository,
+  BoardRepository,
+  CommentAttachmentType,
+  DATABASE,
+  DEFAULT_ADMIN_USER,
+  DEFAULT_DB_PATH,
+  DatabaseConnectionError,
+  ENVIRONMENT,
+  EntityNotFoundError,
+  GIT,
+  IdResolutionError,
+  MCPServerRepository,
+  MessageRole,
+  MessagesRepository,
+  MigrationError,
+  PermissionScope,
+  PermissionStatus,
+  RepoRepository,
+  RepositoryError,
+  SESSION,
+  SessionMCPServerRepository,
+  SessionRepository,
+  SessionStatus,
+  TaskRepository,
+  TaskStatus,
+  WEBSOCKET,
+  WorktreeRepository,
+  and,
+  boardComments,
+  boardObjects,
+  boards,
+  clearContext,
+  cloneRepo,
+  compare,
+  createClient,
+  createDatabase,
+  createDefaultAdminUser,
+  createLocalDatabase,
+  createUser,
+  createWorktree,
+  desc,
+  eq,
+  extractRepoName,
+  extractSlugFromUrl,
+  formatRepoReference,
+  formatShortId,
+  generateId,
+  getAgorHome,
+  getAllContext,
+  getCommentAttachmentType,
+  getConfigPath,
+  getConfigValue,
+  getContext,
+  getCurrentBranch,
+  getCurrentSha,
+  getDaemonUrl,
+  getDefaultBranch,
+  getDefaultConfig,
+  getDefaultPermissionMode,
+  getDefaultRepoReference,
+  getEffectiveConfig,
+  getGitState,
+  getGroupedRepoReferenceOptions,
+  getRemoteBranches,
+  getRemoteUrl,
+  getRepoReferenceOptions,
+  getReposDir,
+  getUserByEmail,
+  getWorktreePath,
+  getWorktreesDir,
+  groupReactions,
+  hasRemoteBranch,
+  hash,
+  inArray,
+  initConfig,
+  initializeDatabase,
+  isClean,
+  isDaemonRunning,
+  isDefined,
+  isGitRepo,
+  isNonEmptyString,
+  isReply,
+  isResolvable,
+  isThreadRoot,
+  isValidSlug,
+  like,
+  listWorktrees,
+  loadConfig,
+  mcpServers,
+  messages,
+  or,
+  parseRepoReference,
+  pruneWorktrees,
+  removeWorktree,
+  repos,
+  resolveRepoReference,
+  resolveShortId,
+  resolveValue,
+  resolveValues,
+  runMigrations,
+  saveConfig,
+  seedInitialData,
+  sessionMcpServers,
+  sessions,
+  setConfigValue,
+  setContext,
+  sql,
+  tasks,
+  unsetConfigValue,
+  unsetContext,
+  userExists,
+  users,
+  worktrees
+});