@hasna/todos 0.9.33 → 0.9.35

package/dist/server/index.js

@@ -0,0 +1,2371 @@
+#!/usr/bin/env bun
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/types/index.ts
+var VersionConflictError, TaskNotFoundError, ProjectNotFoundError, PlanNotFoundError, LockError, CompletionGuardError;
+var init_types = __esm(() => {
+  VersionConflictError = class VersionConflictError extends Error {
+    taskId;
+    expectedVersion;
+    actualVersion;
+    static code = "VERSION_CONFLICT";
+    static suggestion = "Fetch the task with get_task to get the current version before updating.";
+    constructor(taskId, expectedVersion, actualVersion) {
+      super(`Version conflict for task ${taskId}: expected ${expectedVersion}, got ${actualVersion}`);
+      this.taskId = taskId;
+      this.expectedVersion = expectedVersion;
+      this.actualVersion = actualVersion;
+      this.name = "VersionConflictError";
+    }
+  };
+  TaskNotFoundError = class TaskNotFoundError extends Error {
+    taskId;
+    static code = "TASK_NOT_FOUND";
+    static suggestion = "Verify the task ID. Use list_tasks or search_tasks to find the correct ID.";
+    constructor(taskId) {
+      super(`Task not found: ${taskId}`);
+      this.taskId = taskId;
+      this.name = "TaskNotFoundError";
+    }
+  };
+  ProjectNotFoundError = class ProjectNotFoundError extends Error {
+    projectId;
+    static code = "PROJECT_NOT_FOUND";
+    static suggestion = "Use list_projects to see available projects.";
+    constructor(projectId) {
+      super(`Project not found: ${projectId}`);
+      this.projectId = projectId;
+      this.name = "ProjectNotFoundError";
+    }
+  };
+  PlanNotFoundError = class PlanNotFoundError extends Error {
+    planId;
+    static code = "PLAN_NOT_FOUND";
+    static suggestion = "Use list_plans to see available plans.";
+    constructor(planId) {
+      super(`Plan not found: ${planId}`);
+      this.planId = planId;
+      this.name = "PlanNotFoundError";
+    }
+  };
+  LockError = class LockError extends Error {
+    taskId;
+    lockedBy;
+    static code = "LOCK_ERROR";
+    static suggestion = "Wait for the lock to expire (30 min) or contact the lock holder.";
+    constructor(taskId, lockedBy) {
+      super(`Task ${taskId} is locked by ${lockedBy}`);
+      this.taskId = taskId;
+      this.lockedBy = lockedBy;
+      this.name = "LockError";
+    }
+  };
+  CompletionGuardError = class CompletionGuardError extends Error {
+    reason;
+    retryAfterSeconds;
+    static code = "COMPLETION_BLOCKED";
+    static suggestion = "Wait for the cooldown period, then retry.";
+    constructor(reason, retryAfterSeconds) {
+      super(reason);
+      this.reason = reason;
+      this.retryAfterSeconds = retryAfterSeconds;
+      this.name = "CompletionGuardError";
+    }
+  };
+});
+
+// src/db/database.ts
+import { Database } from "bun:sqlite";
+import { existsSync, mkdirSync } from "fs";
+import { dirname, join, resolve } from "path";
+function isInMemoryDb(path) {
+  return path === ":memory:" || path.startsWith("file::memory:");
+}
+function findNearestTodosDb(startDir) {
+  let dir = resolve(startDir);
+  while (true) {
+    const candidate = join(dir, ".todos", "todos.db");
+    if (existsSync(candidate))
+      return candidate;
+    const parent = dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return null;
+}
+function findGitRoot(startDir) {
+  let dir = resolve(startDir);
+  while (true) {
+    if (existsSync(join(dir, ".git")))
+      return dir;
+    const parent = dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return null;
+}
+function getDbPath() {
+  if (process.env["TODOS_DB_PATH"]) {
+    return process.env["TODOS_DB_PATH"];
+  }
+  const cwd = process.cwd();
+  const nearest = findNearestTodosDb(cwd);
+  if (nearest)
+    return nearest;
+  if (process.env["TODOS_DB_SCOPE"] === "project") {
+    const gitRoot = findGitRoot(cwd);
+    if (gitRoot) {
+      return join(gitRoot, ".todos", "todos.db");
+    }
+  }
+  const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
+  return join(home, ".todos", "todos.db");
+}
+function ensureDir(filePath) {
+  if (isInMemoryDb(filePath))
+    return;
+  const dir = dirname(resolve(filePath));
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+function getDatabase(dbPath) {
+  if (_db)
+    return _db;
+  const path = dbPath || getDbPath();
+  ensureDir(path);
+  _db = new Database(path, { create: true });
+  _db.run("PRAGMA journal_mode = WAL");
+  _db.run("PRAGMA busy_timeout = 5000");
+  _db.run("PRAGMA foreign_keys = ON");
+  runMigrations(_db);
+  backfillTaskTags(_db);
+  return _db;
+}
+function runMigrations(db) {
+  try {
+    const result = db.query("SELECT MAX(id) as max_id FROM _migrations").get();
+    const currentLevel = result?.max_id ?? 0;
+    for (let i = currentLevel;i < MIGRATIONS.length; i++) {
+      try {
+        db.exec(MIGRATIONS[i]);
+      } catch {}
+    }
+  } catch {
+    for (const migration of MIGRATIONS) {
+      try {
+        db.exec(migration);
+      } catch {}
+    }
+  }
+  ensureSchema(db);
+}
+function ensureSchema(db) {
+  const ensureColumn = (table, column, type) => {
+    try {
+      db.query(`SELECT ${column} FROM ${table} LIMIT 0`).get();
+    } catch {
+      try {
+        db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${type}`);
+      } catch {}
+    }
+  };
+  const ensureTable = (name, sql) => {
+    try {
+      const exists = db.query("SELECT name FROM sqlite_master WHERE type='table' AND name=?").get(name);
+      if (!exists)
+        db.exec(sql);
+    } catch {}
+  };
+  const ensureIndex = (sql) => {
+    try {
+      db.exec(sql);
+    } catch {}
+  };
+  ensureTable("orgs", `
+    CREATE TABLE orgs (
+      id TEXT PRIMARY KEY, name TEXT NOT NULL UNIQUE, description TEXT,
+      metadata TEXT DEFAULT '{}',
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )`);
+  ensureTable("agents", `
+    CREATE TABLE agents (
+      id TEXT PRIMARY KEY, name TEXT NOT NULL UNIQUE, description TEXT,
+      role TEXT DEFAULT 'agent', permissions TEXT DEFAULT '["*"]',
+      metadata TEXT DEFAULT '{}',
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      last_seen_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )`);
+  ensureTable("task_lists", `
+    CREATE TABLE task_lists (
+      id TEXT PRIMARY KEY, project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+      slug TEXT NOT NULL, name TEXT NOT NULL, description TEXT,
+      metadata TEXT DEFAULT '{}',
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      UNIQUE(project_id, slug)
+    )`);
+  ensureTable("plans", `
+    CREATE TABLE plans (
+      id TEXT PRIMARY KEY, project_id TEXT REFERENCES projects(id) ON DELETE CASCADE,
+      task_list_id TEXT, agent_id TEXT,
+      name TEXT NOT NULL, description TEXT,
+      status TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('active', 'completed', 'archived')),
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )`);
+  ensureTable("task_tags", `
+    CREATE TABLE task_tags (
+      task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+      tag TEXT NOT NULL, PRIMARY KEY (task_id, tag)
+    )`);
+  ensureTable("task_history", `
+    CREATE TABLE task_history (
+      id TEXT PRIMARY KEY, task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+      action TEXT NOT NULL, field TEXT, old_value TEXT, new_value TEXT, agent_id TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )`);
+  ensureTable("webhooks", `
+    CREATE TABLE webhooks (
+      id TEXT PRIMARY KEY, url TEXT NOT NULL, events TEXT NOT NULL DEFAULT '[]',
+      secret TEXT, active INTEGER NOT NULL DEFAULT 1,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )`);
+  ensureTable("task_templates", `
+    CREATE TABLE task_templates (
+      id TEXT PRIMARY KEY, name TEXT NOT NULL, title_pattern TEXT NOT NULL,
+      description TEXT, priority TEXT DEFAULT 'medium', tags TEXT DEFAULT '[]',
+      project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+      plan_id TEXT REFERENCES plans(id) ON DELETE SET NULL,
+      metadata TEXT DEFAULT '{}',
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )`);
+  ensureColumn("projects", "task_list_id", "TEXT");
+  ensureColumn("projects", "task_prefix", "TEXT");
+  ensureColumn("projects", "task_counter", "INTEGER NOT NULL DEFAULT 0");
+  ensureColumn("tasks", "plan_id", "TEXT REFERENCES plans(id) ON DELETE SET NULL");
+  ensureColumn("tasks", "task_list_id", "TEXT REFERENCES task_lists(id) ON DELETE SET NULL");
+  ensureColumn("tasks", "short_id", "TEXT");
+  ensureColumn("tasks", "due_at", "TEXT");
+  ensureColumn("tasks", "estimated_minutes", "INTEGER");
+  ensureColumn("tasks", "requires_approval", "INTEGER NOT NULL DEFAULT 0");
+  ensureColumn("tasks", "approved_by", "TEXT");
+  ensureColumn("tasks", "approved_at", "TEXT");
+  ensureColumn("tasks", "recurrence_rule", "TEXT");
+  ensureColumn("tasks", "recurrence_parent_id", "TEXT REFERENCES tasks(id) ON DELETE SET NULL");
+  ensureColumn("agents", "role", "TEXT DEFAULT 'agent'");
+  ensureColumn("agents", "permissions", `TEXT DEFAULT '["*"]'`);
+  ensureColumn("agents", "reports_to", "TEXT");
+  ensureColumn("agents", "title", "TEXT");
+  ensureColumn("agents", "level", "TEXT");
+  ensureColumn("agents", "org_id", "TEXT");
+  ensureColumn("projects", "org_id", "TEXT");
+  ensureColumn("plans", "task_list_id", "TEXT");
+  ensureColumn("plans", "agent_id", "TEXT");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_tasks_plan ON tasks(plan_id)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_tasks_task_list ON tasks(task_list_id)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_tasks_due_at ON tasks(due_at)");
+  ensureIndex("CREATE UNIQUE INDEX IF NOT EXISTS idx_tasks_short_id ON tasks(short_id) WHERE short_id IS NOT NULL");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_agents_name ON agents(name)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_task_lists_project ON task_lists(project_id)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_task_lists_slug ON task_lists(slug)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_task_tags_tag ON task_tags(tag)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_task_tags_task ON task_tags(task_id)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_plans_project ON plans(project_id)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_plans_status ON plans(status)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_plans_task_list ON plans(task_list_id)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_plans_agent ON plans(agent_id)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_task_history_task ON task_history(task_id)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_task_history_agent ON task_history(agent_id)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_tasks_recurrence_parent ON tasks(recurrence_parent_id)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_tasks_recurrence_rule ON tasks(recurrence_rule) WHERE recurrence_rule IS NOT NULL");
+}
+function backfillTaskTags(db) {
+  try {
+    const count = db.query("SELECT COUNT(*) as count FROM task_tags").get();
+    if (count && count.count > 0)
+      return;
+  } catch {
+    return;
+  }
+  try {
+    const rows = db.query("SELECT id, tags FROM tasks WHERE tags IS NOT NULL AND tags != '[]'").all();
+    if (rows.length === 0)
+      return;
+    const insert = db.prepare("INSERT OR IGNORE INTO task_tags (task_id, tag) VALUES (?, ?)");
+    for (const row of rows) {
+      if (!row.tags)
+        continue;
+      let tags = [];
+      try {
+        tags = JSON.parse(row.tags);
+      } catch {
+        continue;
+      }
+      for (const tag of tags) {
+        if (tag)
+          insert.run(row.id, tag);
+      }
+    }
+  } catch {}
+}
+function now() {
+  return new Date().toISOString();
+}
+function uuid() {
+  return crypto.randomUUID();
+}
+function isLockExpired(lockedAt) {
+  if (!lockedAt)
+    return true;
+  const lockTime = new Date(lockedAt).getTime();
+  const expiryMs = LOCK_EXPIRY_MINUTES * 60 * 1000;
+  return Date.now() - lockTime > expiryMs;
+}
+function lockExpiryCutoff(nowMs = Date.now()) {
+  const expiryMs = LOCK_EXPIRY_MINUTES * 60 * 1000;
+  return new Date(nowMs - expiryMs).toISOString();
+}
+function clearExpiredLocks(db) {
+  const cutoff = lockExpiryCutoff();
+  db.run("UPDATE tasks SET locked_by = NULL, locked_at = NULL WHERE locked_at IS NOT NULL AND locked_at < ?", [cutoff]);
+}
+var LOCK_EXPIRY_MINUTES = 30, MIGRATIONS, _db = null;
+var init_database = __esm(() => {
+  MIGRATIONS = [
+    `
+  CREATE TABLE IF NOT EXISTS projects (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    path TEXT UNIQUE NOT NULL,
+    description TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS tasks (
+    id TEXT PRIMARY KEY,
+    project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+    parent_id TEXT REFERENCES tasks(id) ON DELETE CASCADE,
+    title TEXT NOT NULL,
+    description TEXT,
+    status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending', 'in_progress', 'completed', 'failed', 'cancelled')),
+    priority TEXT NOT NULL DEFAULT 'medium' CHECK(priority IN ('low', 'medium', 'high', 'critical')),
+    agent_id TEXT,
+    assigned_to TEXT,
+    session_id TEXT,
+    working_dir TEXT,
+    tags TEXT DEFAULT '[]',
+    metadata TEXT DEFAULT '{}',
+    version INTEGER NOT NULL DEFAULT 1,
+    locked_by TEXT,
+    locked_at TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+    completed_at TEXT
+  );
+
+  CREATE TABLE IF NOT EXISTS task_dependencies (
+    task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    depends_on TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    PRIMARY KEY (task_id, depends_on),
+    CHECK (task_id != depends_on)
+  );
+
+  CREATE TABLE IF NOT EXISTS task_comments (
+    id TEXT PRIMARY KEY,
+    task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    agent_id TEXT,
+    session_id TEXT,
+    content TEXT NOT NULL,
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS sessions (
+    id TEXT PRIMARY KEY,
+    agent_id TEXT,
+    project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+    working_dir TEXT,
+    started_at TEXT NOT NULL DEFAULT (datetime('now')),
+    last_activity TEXT NOT NULL DEFAULT (datetime('now')),
+    metadata TEXT DEFAULT '{}'
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_tasks_project ON tasks(project_id);
+  CREATE INDEX IF NOT EXISTS idx_tasks_parent ON tasks(parent_id);
+  CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+  CREATE INDEX IF NOT EXISTS idx_tasks_priority ON tasks(priority);
+  CREATE INDEX IF NOT EXISTS idx_tasks_assigned ON tasks(assigned_to);
+  CREATE INDEX IF NOT EXISTS idx_tasks_agent ON tasks(agent_id);
+  CREATE INDEX IF NOT EXISTS idx_tasks_session ON tasks(session_id);
+  CREATE INDEX IF NOT EXISTS idx_comments_task ON task_comments(task_id);
+  CREATE INDEX IF NOT EXISTS idx_sessions_agent ON sessions(agent_id);
+  CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_id);
+
+  CREATE TABLE IF NOT EXISTS _migrations (
+    id INTEGER PRIMARY KEY,
+    applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  INSERT OR IGNORE INTO _migrations (id) VALUES (1);
+  `,
+    `
+  ALTER TABLE projects ADD COLUMN task_list_id TEXT;
+  INSERT OR IGNORE INTO _migrations (id) VALUES (2);
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS task_tags (
+    task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    tag TEXT NOT NULL,
+    PRIMARY KEY (task_id, tag)
+  );
+  CREATE INDEX IF NOT EXISTS idx_task_tags_tag ON task_tags(tag);
+  CREATE INDEX IF NOT EXISTS idx_task_tags_task ON task_tags(task_id);
+
+  INSERT OR IGNORE INTO _migrations (id) VALUES (3);
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS plans (
+    id TEXT PRIMARY KEY,
+    project_id TEXT REFERENCES projects(id) ON DELETE CASCADE,
+    name TEXT NOT NULL,
+    description TEXT,
+    status TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('active', 'completed', 'archived')),
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+  CREATE INDEX IF NOT EXISTS idx_plans_project ON plans(project_id);
+  CREATE INDEX IF NOT EXISTS idx_plans_status ON plans(status);
+  ALTER TABLE tasks ADD COLUMN plan_id TEXT REFERENCES plans(id) ON DELETE SET NULL;
+  CREATE INDEX IF NOT EXISTS idx_tasks_plan ON tasks(plan_id);
+  INSERT OR IGNORE INTO _migrations (id) VALUES (4);
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS agents (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL UNIQUE,
+    description TEXT,
+    metadata TEXT DEFAULT '{}',
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    last_seen_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+  CREATE INDEX IF NOT EXISTS idx_agents_name ON agents(name);
+
+  CREATE TABLE IF NOT EXISTS task_lists (
+    id TEXT PRIMARY KEY,
+    project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+    slug TEXT NOT NULL,
+    name TEXT NOT NULL,
+    description TEXT,
+    metadata TEXT DEFAULT '{}',
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+    UNIQUE(project_id, slug)
+  );
+  CREATE INDEX IF NOT EXISTS idx_task_lists_project ON task_lists(project_id);
+  CREATE INDEX IF NOT EXISTS idx_task_lists_slug ON task_lists(slug);
+
+  ALTER TABLE tasks ADD COLUMN task_list_id TEXT REFERENCES task_lists(id) ON DELETE SET NULL;
+  CREATE INDEX IF NOT EXISTS idx_tasks_task_list ON tasks(task_list_id);
+
+  INSERT OR IGNORE INTO _migrations (id) VALUES (5);
+  `,
+    `
+  ALTER TABLE projects ADD COLUMN task_prefix TEXT;
+  ALTER TABLE projects ADD COLUMN task_counter INTEGER NOT NULL DEFAULT 0;
+
+  ALTER TABLE tasks ADD COLUMN short_id TEXT;
+  CREATE UNIQUE INDEX IF NOT EXISTS idx_tasks_short_id ON tasks(short_id) WHERE short_id IS NOT NULL;
+
+  INSERT OR IGNORE INTO _migrations (id) VALUES (6);
+  `,
+    `
+  ALTER TABLE tasks ADD COLUMN due_at TEXT;
+  CREATE INDEX IF NOT EXISTS idx_tasks_due_at ON tasks(due_at);
+  INSERT OR IGNORE INTO _migrations (id) VALUES (7);
+  `,
+    `
+  ALTER TABLE agents ADD COLUMN role TEXT DEFAULT 'agent';
+  INSERT OR IGNORE INTO _migrations (id) VALUES (8);
+  `,
+    `
+  ALTER TABLE plans ADD COLUMN task_list_id TEXT REFERENCES task_lists(id) ON DELETE SET NULL;
+  ALTER TABLE plans ADD COLUMN agent_id TEXT;
+  CREATE INDEX IF NOT EXISTS idx_plans_task_list ON plans(task_list_id);
+  CREATE INDEX IF NOT EXISTS idx_plans_agent ON plans(agent_id);
+  INSERT OR IGNORE INTO _migrations (id) VALUES (9);
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS task_history (
+    id TEXT PRIMARY KEY,
+    task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    action TEXT NOT NULL,
+    field TEXT,
+    old_value TEXT,
+    new_value TEXT,
+    agent_id TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+  CREATE INDEX IF NOT EXISTS idx_task_history_task ON task_history(task_id);
+  CREATE INDEX IF NOT EXISTS idx_task_history_agent ON task_history(agent_id);
+
+  CREATE TABLE IF NOT EXISTS webhooks (
+    id TEXT PRIMARY KEY,
+    url TEXT NOT NULL,
+    events TEXT NOT NULL DEFAULT '[]',
+    secret TEXT,
+    active INTEGER NOT NULL DEFAULT 1,
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS task_templates (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    title_pattern TEXT NOT NULL,
+    description TEXT,
+    priority TEXT DEFAULT 'medium',
+    tags TEXT DEFAULT '[]',
+    project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+    plan_id TEXT REFERENCES plans(id) ON DELETE SET NULL,
+    metadata TEXT DEFAULT '{}',
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  ALTER TABLE tasks ADD COLUMN estimated_minutes INTEGER;
+  ALTER TABLE tasks ADD COLUMN requires_approval INTEGER NOT NULL DEFAULT 0;
+  ALTER TABLE tasks ADD COLUMN approved_by TEXT;
+  ALTER TABLE tasks ADD COLUMN approved_at TEXT;
+
+  ALTER TABLE agents ADD COLUMN permissions TEXT DEFAULT '["*"]';
+
+  INSERT OR IGNORE INTO _migrations (id) VALUES (10);
+  `,
+    `
+  ALTER TABLE agents ADD COLUMN reports_to TEXT;
+  ALTER TABLE agents ADD COLUMN title TEXT;
+  ALTER TABLE agents ADD COLUMN level TEXT;
+  INSERT OR IGNORE INTO _migrations (id) VALUES (11);
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS orgs (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL UNIQUE,
+    description TEXT,
+    metadata TEXT DEFAULT '{}',
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+  ALTER TABLE agents ADD COLUMN org_id TEXT REFERENCES orgs(id) ON DELETE SET NULL;
+  ALTER TABLE projects ADD COLUMN org_id TEXT REFERENCES orgs(id) ON DELETE SET NULL;
+  INSERT OR IGNORE INTO _migrations (id) VALUES (12);
+  `,
+    `
+  ALTER TABLE tasks ADD COLUMN recurrence_rule TEXT;
+  ALTER TABLE tasks ADD COLUMN recurrence_parent_id TEXT REFERENCES tasks(id) ON DELETE SET NULL;
+  CREATE INDEX IF NOT EXISTS idx_tasks_recurrence_parent ON tasks(recurrence_parent_id);
+  CREATE INDEX IF NOT EXISTS idx_tasks_recurrence_rule ON tasks(recurrence_rule) WHERE recurrence_rule IS NOT NULL;
+  INSERT OR IGNORE INTO _migrations (id) VALUES (13);
+  `
+  ];
+});
+
+// src/db/projects.ts
+var exports_projects = {};
+__export(exports_projects, {
+  updateProject: () => updateProject,
+  slugify: () => slugify,
+  nextTaskShortId: () => nextTaskShortId,
+  listProjects: () => listProjects,
+  getProjectByPath: () => getProjectByPath,
+  getProject: () => getProject,
+  ensureProject: () => ensureProject,
+  deleteProject: () => deleteProject,
+  createProject: () => createProject
+});
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function generatePrefix(name, db) {
+  const words = name.replace(/[^a-zA-Z0-9\s]/g, "").trim().split(/\s+/);
+  let prefix;
+  if (words.length >= 3) {
+    prefix = words.slice(0, 3).map((w) => w[0].toUpperCase()).join("");
+  } else if (words.length === 2) {
+    prefix = (words[0].slice(0, 2) + words[1][0]).toUpperCase();
+  } else {
+    prefix = words[0].slice(0, 3).toUpperCase();
+  }
+  let candidate = prefix;
+  let suffix = 1;
+  while (true) {
+    const existing = db.query("SELECT id FROM projects WHERE task_prefix = ?").get(candidate);
+    if (!existing)
+      return candidate;
+    suffix++;
+    candidate = `${prefix}${suffix}`;
+  }
+}
+function createProject(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  const taskListId = input.task_list_id ?? `todos-${slugify(input.name)}`;
+  const taskPrefix = input.task_prefix || generatePrefix(input.name, d);
+  d.run(`INSERT INTO projects (id, name, path, description, task_list_id, task_prefix, task_counter, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, 0, ?, ?)`, [id, input.name, input.path, input.description || null, taskListId, taskPrefix, timestamp, timestamp]);
+  return getProject(id, d);
+}
+function getProject(id, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM projects WHERE id = ?").get(id);
+  return row;
+}
+function getProjectByPath(path, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM projects WHERE path = ?").get(path);
+  return row;
+}
+function listProjects(db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM projects ORDER BY name").all();
+}
+function updateProject(id, input, db) {
+  const d = db || getDatabase();
+  const project = getProject(id, d);
+  if (!project)
+    throw new ProjectNotFoundError(id);
+  const sets = ["updated_at = ?"];
+  const params = [now()];
+  if (input.name !== undefined) {
+    sets.push("name = ?");
+    params.push(input.name);
+  }
+  if (input.description !== undefined) {
+    sets.push("description = ?");
+    params.push(input.description);
+  }
+  if (input.task_list_id !== undefined) {
+    sets.push("task_list_id = ?");
+    params.push(input.task_list_id);
+  }
+  params.push(id);
+  d.run(`UPDATE projects SET ${sets.join(", ")} WHERE id = ?`, params);
+  return getProject(id, d);
+}
+function deleteProject(id, db) {
+  const d = db || getDatabase();
+  const result = d.run("DELETE FROM projects WHERE id = ?", [id]);
+  return result.changes > 0;
+}
+function nextTaskShortId(projectId, db) {
+  const d = db || getDatabase();
+  const project = getProject(projectId, d);
+  if (!project || !project.task_prefix)
+    return null;
+  d.run("UPDATE projects SET task_counter = task_counter + 1, updated_at = ? WHERE id = ?", [now(), projectId]);
+  const updated = getProject(projectId, d);
+  const padded = String(updated.task_counter).padStart(5, "0");
+  return `${updated.task_prefix}-${padded}`;
+}
+function ensureProject(name, path, db) {
+  const d = db || getDatabase();
+  const existing = getProjectByPath(path, d);
+  if (existing) {
+    if (!existing.task_prefix) {
+      const prefix = generatePrefix(existing.name, d);
+      d.run("UPDATE projects SET task_prefix = ?, updated_at = ? WHERE id = ?", [prefix, now(), existing.id]);
+      return getProject(existing.id, d);
+    }
+    return existing;
+  }
+  return createProject({ name, path }, d);
+}
+var init_projects = __esm(() => {
+  init_types();
+  init_database();
+});
+
+// src/db/audit.ts
+var exports_audit = {};
+__export(exports_audit, {
+  logTaskChange: () => logTaskChange,
+  getTaskHistory: () => getTaskHistory,
+  getRecentActivity: () => getRecentActivity
+});
+function logTaskChange(taskId, action, field, oldValue, newValue, agentId, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  d.run(`INSERT INTO task_history (id, task_id, action, field, old_value, new_value, agent_id, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [id, taskId, action, field || null, oldValue ?? null, newValue ?? null, agentId || null, timestamp]);
+  return { id, task_id: taskId, action, field: field || null, old_value: oldValue ?? null, new_value: newValue ?? null, agent_id: agentId || null, created_at: timestamp };
+}
+function getTaskHistory(taskId, db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM task_history WHERE task_id = ? ORDER BY created_at DESC").all(taskId);
+}
+function getRecentActivity(limit = 50, db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM task_history ORDER BY created_at DESC LIMIT ?").all(limit);
+}
+var init_audit = __esm(() => {
+  init_database();
+});
+
+// src/db/agents.ts
+var exports_agents = {};
+__export(exports_agents, {
+  updateAgentActivity: () => updateAgentActivity,
+  updateAgent: () => updateAgent,
+  registerAgent: () => registerAgent,
+  listAgents: () => listAgents,
+  getOrgChart: () => getOrgChart,
+  getDirectReports: () => getDirectReports,
+  getAgentByName: () => getAgentByName,
+  getAgent: () => getAgent,
+  deleteAgent: () => deleteAgent
+});
+function shortUuid() {
+  return crypto.randomUUID().slice(0, 8);
+}
+function rowToAgent(row) {
+  return {
+    ...row,
+    permissions: JSON.parse(row.permissions || '["*"]'),
+    metadata: JSON.parse(row.metadata || "{}")
+  };
+}
+function registerAgent(input, db) {
+  const d = db || getDatabase();
+  const normalizedName = input.name.trim().toLowerCase();
+  const existing = getAgentByName(normalizedName, d);
+  if (existing) {
+    d.run("UPDATE agents SET last_seen_at = ? WHERE id = ?", [now(), existing.id]);
+    return getAgent(existing.id, d);
+  }
+  const id = shortUuid();
+  const timestamp = now();
+  d.run(`INSERT INTO agents (id, name, description, role, title, level, permissions, reports_to, org_id, metadata, created_at, last_seen_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+    id,
+    normalizedName,
+    input.description || null,
+    input.role || "agent",
+    input.title || null,
+    input.level || null,
+    JSON.stringify(input.permissions || ["*"]),
+    input.reports_to || null,
+    input.org_id || null,
+    JSON.stringify(input.metadata || {}),
+    timestamp,
+    timestamp
+  ]);
+  return getAgent(id, d);
+}
+function getAgent(id, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM agents WHERE id = ?").get(id);
+  return row ? rowToAgent(row) : null;
+}
+function getAgentByName(name, db) {
+  const d = db || getDatabase();
+  const normalizedName = name.trim().toLowerCase();
+  const row = d.query("SELECT * FROM agents WHERE LOWER(name) = ?").get(normalizedName);
+  return row ? rowToAgent(row) : null;
+}
+function listAgents(db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM agents ORDER BY name").all().map(rowToAgent);
+}
+function updateAgentActivity(id, db) {
+  const d = db || getDatabase();
+  d.run("UPDATE agents SET last_seen_at = ? WHERE id = ?", [now(), id]);
+}
+function updateAgent(id, input, db) {
+  const d = db || getDatabase();
+  const agent = getAgent(id, d);
+  if (!agent)
+    throw new Error(`Agent not found: ${id}`);
+  const sets = ["last_seen_at = ?"];
+  const params = [now()];
+  if (input.name !== undefined) {
+    sets.push("name = ?");
+    params.push(input.name.trim().toLowerCase());
+  }
+  if (input.description !== undefined) {
+    sets.push("description = ?");
+    params.push(input.description);
+  }
+  if (input.role !== undefined) {
+    sets.push("role = ?");
+    params.push(input.role);
+  }
+  if (input.permissions !== undefined) {
+    sets.push("permissions = ?");
+    params.push(JSON.stringify(input.permissions));
+  }
+  if (input.title !== undefined) {
+    sets.push("title = ?");
+    params.push(input.title);
+  }
+  if (input.level !== undefined) {
+    sets.push("level = ?");
+    params.push(input.level);
+  }
+  if (input.reports_to !== undefined) {
+    sets.push("reports_to = ?");
+    params.push(input.reports_to);
+  }
+  if (input.org_id !== undefined) {
+    sets.push("org_id = ?");
+    params.push(input.org_id);
+  }
+  if (input.metadata !== undefined) {
+    sets.push("metadata = ?");
+    params.push(JSON.stringify(input.metadata));
+  }
+  params.push(id);
+  d.run(`UPDATE agents SET ${sets.join(", ")} WHERE id = ?`, params);
+  return getAgent(id, d);
+}
+function deleteAgent(id, db) {
+  const d = db || getDatabase();
+  return d.run("DELETE FROM agents WHERE id = ?", [id]).changes > 0;
+}
+function getDirectReports(agentId, db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM agents WHERE reports_to = ? ORDER BY name").all(agentId).map(rowToAgent);
+}
+function getOrgChart(db) {
+  const agents = listAgents(db);
+  const byManager = new Map;
+  for (const a of agents) {
+    const key = a.reports_to;
+    if (!byManager.has(key))
+      byManager.set(key, []);
+    byManager.get(key).push(a);
+  }
+  function buildTree(parentId) {
+    const children = byManager.get(parentId) || [];
+    return children.map((a) => ({ agent: a, reports: buildTree(a.id) }));
+  }
+  return buildTree(null);
+}
+var init_agents = __esm(() => {
+  init_database();
+});
+
+// src/db/orgs.ts
+var exports_orgs = {};
+__export(exports_orgs, {
+  updateOrg: () => updateOrg,
+  listOrgs: () => listOrgs,
+  getOrgByName: () => getOrgByName,
+  getOrg: () => getOrg,
+  deleteOrg: () => deleteOrg,
+  createOrg: () => createOrg
+});
+function rowToOrg(row) {
+  return { ...row, metadata: JSON.parse(row.metadata || "{}") };
+}
+function createOrg(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  d.run(`INSERT INTO orgs (id, name, description, metadata, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)`, [id, input.name, input.description || null, JSON.stringify(input.metadata || {}), timestamp, timestamp]);
+  return getOrg(id, d);
+}
+function getOrg(id, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM orgs WHERE id = ?").get(id);
+  return row ? rowToOrg(row) : null;
+}
+function getOrgByName(name, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM orgs WHERE name = ?").get(name);
+  return row ? rowToOrg(row) : null;
+}
+function listOrgs(db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM orgs ORDER BY name").all().map(rowToOrg);
+}
+function updateOrg(id, input, db) {
+  const d = db || getDatabase();
+  const org = getOrg(id, d);
+  if (!org)
+    throw new Error(`Org not found: ${id}`);
+  const sets = ["updated_at = ?"];
+  const params = [now()];
+  if (input.name !== undefined) {
+    sets.push("name = ?");
+    params.push(input.name);
+  }
+  if (input.description !== undefined) {
+    sets.push("description = ?");
+    params.push(input.description);
+  }
+  if (input.metadata !== undefined) {
+    sets.push("metadata = ?");
+    params.push(JSON.stringify(input.metadata));
+  }
+  params.push(id);
+  d.run(`UPDATE orgs SET ${sets.join(", ")} WHERE id = ?`, params);
+  return getOrg(id, d);
+}
+function deleteOrg(id, db) {
+  const d = db || getDatabase();
+  return d.run("DELETE FROM orgs WHERE id = ?", [id]).changes > 0;
+}
+var init_orgs = __esm(() => {
+  init_database();
+});
+
+// src/db/webhooks.ts
+var exports_webhooks = {};
+__export(exports_webhooks, {
+  listWebhooks: () => listWebhooks,
+  getWebhook: () => getWebhook,
+  dispatchWebhook: () => dispatchWebhook,
+  deleteWebhook: () => deleteWebhook,
+  createWebhook: () => createWebhook
+});
+function rowToWebhook(row) {
+  return { ...row, events: JSON.parse(row.events || "[]"), active: !!row.active };
+}
+function createWebhook(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  d.run(`INSERT INTO webhooks (id, url, events, secret, created_at) VALUES (?, ?, ?, ?, ?)`, [id, input.url, JSON.stringify(input.events || []), input.secret || null, now()]);
+  return getWebhook(id, d);
+}
+function getWebhook(id, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM webhooks WHERE id = ?").get(id);
+  return row ? rowToWebhook(row) : null;
+}
+function listWebhooks(db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM webhooks ORDER BY created_at DESC").all().map(rowToWebhook);
+}
+function deleteWebhook(id, db) {
+  const d = db || getDatabase();
+  return d.run("DELETE FROM webhooks WHERE id = ?", [id]).changes > 0;
+}
+async function dispatchWebhook(event, payload, db) {
+  const webhooks = listWebhooks(db).filter((w) => w.active && (w.events.length === 0 || w.events.includes(event)));
+  for (const wh of webhooks) {
+    try {
+      const body = JSON.stringify({ event, payload, timestamp: now() });
+      const headers = { "Content-Type": "application/json" };
+      if (wh.secret) {
+        const encoder = new TextEncoder;
+        const key = await crypto.subtle.importKey("raw", encoder.encode(wh.secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+        const sig = await crypto.subtle.sign("HMAC", key, encoder.encode(body));
+        headers["X-Webhook-Signature"] = Array.from(new Uint8Array(sig)).map((b) => b.toString(16).padStart(2, "0")).join("");
+      }
+      fetch(wh.url, { method: "POST", headers, body }).catch(() => {});
+    } catch {}
+  }
+}
+var init_webhooks = __esm(() => {
+  init_database();
+});
+
+// src/db/templates.ts
+var exports_templates = {};
+__export(exports_templates, {
+  taskFromTemplate: () => taskFromTemplate,
+  listTemplates: () => listTemplates,
+  getTemplate: () => getTemplate,
+  deleteTemplate: () => deleteTemplate,
+  createTemplate: () => createTemplate
+});
+function rowToTemplate(row) {
+  return {
+    ...row,
+    tags: JSON.parse(row.tags || "[]"),
+    metadata: JSON.parse(row.metadata || "{}"),
+    priority: row.priority || "medium"
+  };
+}
+function createTemplate(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  d.run(`INSERT INTO task_templates (id, name, title_pattern, description, priority, tags, project_id, plan_id, metadata, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+    id,
+    input.name,
+    input.title_pattern,
+    input.description || null,
+    input.priority || "medium",
+    JSON.stringify(input.tags || []),
+    input.project_id || null,
+    input.plan_id || null,
+    JSON.stringify(input.metadata || {}),
+    now()
+  ]);
+  return getTemplate(id, d);
+}
+function getTemplate(id, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM task_templates WHERE id = ?").get(id);
+  return row ? rowToTemplate(row) : null;
+}
+function listTemplates(db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM task_templates ORDER BY name").all().map(rowToTemplate);
+}
+function deleteTemplate(id, db) {
+  const d = db || getDatabase();
+  return d.run("DELETE FROM task_templates WHERE id = ?", [id]).changes > 0;
+}
+function taskFromTemplate(templateId, overrides = {}, db) {
+  const t = getTemplate(templateId, db);
+  if (!t)
+    throw new Error(`Template not found: ${templateId}`);
+  return {
+    title: overrides.title || t.title_pattern,
+    description: overrides.description ?? t.description ?? undefined,
+    priority: overrides.priority ?? t.priority,
+    tags: overrides.tags ?? t.tags,
+    project_id: overrides.project_id ?? t.project_id ?? undefined,
+    plan_id: overrides.plan_id ?? t.plan_id ?? undefined,
+    metadata: overrides.metadata ?? t.metadata,
+    ...overrides
+  };
+}
+var init_templates = __esm(() => {
+  init_database();
+});
+
+// src/server/serve.ts
+import { existsSync as existsSync4 } from "fs";
+import { join as join3, dirname as dirname2, extname } from "path";
+import { fileURLToPath } from "url";
+
+// src/db/tasks.ts
+init_types();
+init_database();
+init_projects();
+
+// src/lib/completion-guard.ts
+init_types();
+
+// src/lib/config.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join2 } from "path";
+
+// src/lib/sync-utils.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync, readdirSync, statSync, writeFileSync } from "fs";
+var HOME = process.env["HOME"] || process.env["USERPROFILE"] || "~";
+function readJsonFile(path) {
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+// src/lib/config.ts
+var CONFIG_PATH = join2(HOME, ".todos", "config.json");
+var cached = null;
+function loadConfig() {
+  if (cached)
+    return cached;
+  if (!existsSync3(CONFIG_PATH)) {
+    cached = {};
+    return cached;
+  }
+  const config = readJsonFile(CONFIG_PATH) || {};
+  if (typeof config.sync_agents === "string") {
+    config.sync_agents = config.sync_agents.split(",").map((a) => a.trim()).filter(Boolean);
+  }
+  cached = config;
+  return cached;
+}
+var GUARD_DEFAULTS = {
+  enabled: false,
+  min_work_seconds: 30,
+  max_completions_per_window: 5,
+  window_minutes: 10,
+  cooldown_seconds: 60
+};
+function getCompletionGuardConfig(projectPath) {
+  const config = loadConfig();
+  const global = { ...GUARD_DEFAULTS, ...config.completion_guard };
+  if (projectPath && config.project_overrides?.[projectPath]?.completion_guard) {
+    return { ...global, ...config.project_overrides[projectPath].completion_guard };
+  }
+  return global;
+}
+
+// src/lib/completion-guard.ts
+init_projects();
+function checkCompletionGuard(task, agentId, db, configOverride) {
+  let config;
+  if (configOverride) {
+    config = configOverride;
+  } else {
+    const projectPath = task.project_id ? getProject(task.project_id, db)?.path : null;
+    config = getCompletionGuardConfig(projectPath);
+  }
+  if (!config.enabled)
+    return;
+  if (task.status !== "in_progress") {
+    throw new CompletionGuardError(`Task must be in 'in_progress' status before completing (current: '${task.status}'). Use start_task first.`);
+  }
+  const agent = agentId || task.assigned_to || task.agent_id;
+  if (config.min_work_seconds && task.locked_at) {
+    const startedAt = new Date(task.locked_at).getTime();
+    const elapsedSeconds = (Date.now() - startedAt) / 1000;
+    if (elapsedSeconds < config.min_work_seconds) {
+      const remaining = Math.ceil(config.min_work_seconds - elapsedSeconds);
+      throw new CompletionGuardError(`Too fast: task was started ${Math.floor(elapsedSeconds)}s ago. Minimum work duration is ${config.min_work_seconds}s. Wait ${remaining}s.`, remaining);
+    }
+  }
+  if (agent && config.max_completions_per_window && config.window_minutes) {
+    const windowStart = new Date(Date.now() - config.window_minutes * 60 * 1000).toISOString();
+    const result = db.query(`SELECT COUNT(*) as count FROM tasks
+         WHERE completed_at > ? AND (assigned_to = ? OR agent_id = ?)`).get(windowStart, agent, agent);
+    if (result.count >= config.max_completions_per_window) {
+      throw new CompletionGuardError(`Rate limit: ${result.count} tasks completed in the last ${config.window_minutes} minutes (max ${config.max_completions_per_window}). Slow down.`);
+    }
+  }
+  if (agent && config.cooldown_seconds) {
+    const result = db.query(`SELECT MAX(completed_at) as last_completed FROM tasks
+         WHERE completed_at IS NOT NULL AND (assigned_to = ? OR agent_id = ?) AND id != ?`).get(agent, agent, task.id);
+    if (result.last_completed) {
+      const elapsedSeconds = (Date.now() - new Date(result.last_completed).getTime()) / 1000;
+      if (elapsedSeconds < config.cooldown_seconds) {
+        const remaining = Math.ceil(config.cooldown_seconds - elapsedSeconds);
+        throw new CompletionGuardError(`Cooldown: last completion was ${Math.floor(elapsedSeconds)}s ago. Wait ${remaining}s between completions.`, remaining);
+      }
+    }
+  }
+}
+
+// src/db/tasks.ts
+init_audit();
+
+// src/lib/recurrence.ts
+var DAY_NAMES = {
+  sunday: 0,
+  sun: 0,
+  monday: 1,
+  mon: 1,
+  tuesday: 2,
+  tue: 2,
+  wednesday: 3,
+  wed: 3,
+  thursday: 4,
+  thu: 4,
+  friday: 5,
+  fri: 5,
+  saturday: 6,
+  sat: 6
+};
+function parseRecurrenceRule(rule) {
+  const normalized = rule.trim().toLowerCase();
+  if (normalized === "every weekday" || normalized === "every weekdays") {
+    return { type: "specific_days", days: [1, 2, 3, 4, 5] };
+  }
+  if (normalized === "every day" || normalized === "daily") {
+    return { type: "interval", interval: 1, unit: "day" };
+  }
+  if (normalized === "every week" || normalized === "weekly") {
+    return { type: "interval", interval: 1, unit: "week" };
+  }
+  if (normalized === "every month" || normalized === "monthly") {
+    return { type: "interval", interval: 1, unit: "month" };
+  }
+  const intervalMatch = normalized.match(/^every\s+(\d+)\s+(day|week|month)s?$/);
+  if (intervalMatch) {
+    return {
+      type: "interval",
+      interval: parseInt(intervalMatch[1], 10),
+      unit: intervalMatch[2]
+    };
+  }
+  const daysMatch = normalized.match(/^every\s+(.+)$/);
+  if (daysMatch) {
+    const dayParts = daysMatch[1].split(/[,\s]+/).map((d) => d.trim()).filter(Boolean);
+    const days = [];
+    for (const part of dayParts) {
+      const dayNum = DAY_NAMES[part];
+      if (dayNum !== undefined) {
+        days.push(dayNum);
+      }
+    }
+    if (days.length > 0) {
+      return { type: "specific_days", days: days.sort((a, b) => a - b) };
+    }
+  }
+  throw new Error(`Invalid recurrence rule: "${rule}". Supported formats: "every day", "every weekday", "every week", "every 2 weeks", "every month", "every N days/weeks/months", "every monday", "every mon,wed,fri"`);
+}
+function nextOccurrence(rule, from) {
+  const parsed = parseRecurrenceRule(rule);
+  const base = from || new Date;
+  if (parsed.type === "interval") {
+    const next = new Date(base);
+    if (parsed.unit === "day") {
+      next.setDate(next.getDate() + parsed.interval);
+    } else if (parsed.unit === "week") {
+      next.setDate(next.getDate() + parsed.interval * 7);
+    } else if (parsed.unit === "month") {
+      next.setMonth(next.getMonth() + parsed.interval);
+    }
+    return next.toISOString();
+  }
+  if (parsed.type === "specific_days") {
+    const currentDay = base.getDay();
+    const days = parsed.days;
+    let daysToAdd = Infinity;
+    for (const day of days) {
+      let diff = day - currentDay;
+      if (diff <= 0)
+        diff += 7;
+      if (diff < daysToAdd)
+        daysToAdd = diff;
+    }
+    const next = new Date(base);
+    next.setDate(next.getDate() + daysToAdd);
+    return next.toISOString();
+  }
+  throw new Error(`Cannot calculate next occurrence for rule: "${rule}"`);
+}
+
+// src/db/tasks.ts
+function rowToTask(row) {
+  return {
+    ...row,
+    tags: JSON.parse(row.tags || "[]"),
+    metadata: JSON.parse(row.metadata || "{}"),
+    status: row.status,
+    priority: row.priority,
+    requires_approval: !!row.requires_approval
+  };
+}
+function insertTaskTags(taskId, tags, db) {
+  if (tags.length === 0)
+    return;
+  const stmt = db.prepare("INSERT OR IGNORE INTO task_tags (task_id, tag) VALUES (?, ?)");
+  for (const tag of tags) {
+    if (tag)
+      stmt.run(taskId, tag);
+  }
+}
+function replaceTaskTags(taskId, tags, db) {
+  db.run("DELETE FROM task_tags WHERE task_id = ?", [taskId]);
+  insertTaskTags(taskId, tags, db);
+}
+function createTask(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  const tags = input.tags || [];
+  const shortId = input.project_id ? nextTaskShortId(input.project_id, d) : null;
+  const title = shortId ? `${shortId}: ${input.title}` : input.title;
+  d.run(`INSERT INTO tasks (id, short_id, project_id, parent_id, plan_id, task_list_id, title, description, status, priority, agent_id, assigned_to, session_id, working_dir, tags, metadata, version, created_at, updated_at, due_at, estimated_minutes, requires_approval, approved_by, approved_at, recurrence_rule, recurrence_parent_id)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+    id,
+    shortId,
+    input.project_id || null,
+    input.parent_id || null,
+    input.plan_id || null,
+    input.task_list_id || null,
+    title,
+    input.description || null,
+    input.status || "pending",
+    input.priority || "medium",
+    input.agent_id || null,
+    input.assigned_to || null,
+    input.session_id || null,
+    input.working_dir || null,
+    JSON.stringify(tags),
+    JSON.stringify(input.metadata || {}),
+    timestamp,
+    timestamp,
+    input.due_at || null,
+    input.estimated_minutes || null,
+    input.requires_approval ? 1 : 0,
+    null,
+    null,
+    input.recurrence_rule || null,
+    input.recurrence_parent_id || null
+  ]);
+  if (tags.length > 0) {
+    insertTaskTags(id, tags, d);
+  }
+  return getTask(id, d);
+}
+function getTask(id, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM tasks WHERE id = ?").get(id);
+  if (!row)
+    return null;
+  return rowToTask(row);
+}
+function listTasks(filter = {}, db) {
+  const d = db || getDatabase();
+  clearExpiredLocks(d);
+  const conditions = [];
+  const params = [];
+  if (filter.project_id) {
+    conditions.push("project_id = ?");
+    params.push(filter.project_id);
+  }
+  if (filter.parent_id !== undefined) {
+    if (filter.parent_id === null) {
+      conditions.push("parent_id IS NULL");
+    } else {
+      conditions.push("parent_id = ?");
+      params.push(filter.parent_id);
+    }
+  }
+  if (filter.status) {
+    if (Array.isArray(filter.status)) {
+      conditions.push(`status IN (${filter.status.map(() => "?").join(",")})`);
+      params.push(...filter.status);
+    } else {
+      conditions.push("status = ?");
+      params.push(filter.status);
+    }
+  }
+  if (filter.priority) {
+    if (Array.isArray(filter.priority)) {
+      conditions.push(`priority IN (${filter.priority.map(() => "?").join(",")})`);
+      params.push(...filter.priority);
+    } else {
+      conditions.push("priority = ?");
+      params.push(filter.priority);
+    }
+  }
+  if (filter.assigned_to) {
+    conditions.push("assigned_to = ?");
+    params.push(filter.assigned_to);
+  }
+  if (filter.agent_id) {
+    conditions.push("agent_id = ?");
+    params.push(filter.agent_id);
+  }
+  if (filter.session_id) {
+    conditions.push("session_id = ?");
+    params.push(filter.session_id);
+  }
+  if (filter.tags && filter.tags.length > 0) {
+    const placeholders = filter.tags.map(() => "?").join(",");
+    conditions.push(`id IN (SELECT task_id FROM task_tags WHERE tag IN (${placeholders}))`);
+    params.push(...filter.tags);
+  }
+  if (filter.plan_id) {
+    conditions.push("plan_id = ?");
+    params.push(filter.plan_id);
+  }
+  if (filter.task_list_id) {
+    conditions.push("task_list_id = ?");
+    params.push(filter.task_list_id);
+  }
+  if (filter.has_recurrence === true) {
+    conditions.push("recurrence_rule IS NOT NULL");
+  } else if (filter.has_recurrence === false) {
+    conditions.push("recurrence_rule IS NULL");
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  let limitClause = "";
+  if (filter.limit) {
+    limitClause = " LIMIT ?";
+    params.push(filter.limit);
+    if (filter.offset) {
+      limitClause += " OFFSET ?";
+      params.push(filter.offset);
+    }
+  }
+  const rows = d.query(`SELECT * FROM tasks ${where} ORDER BY
+       CASE priority WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 WHEN 'low' THEN 3 END,
+       created_at DESC${limitClause}`).all(...params);
+  return rows.map(rowToTask);
+}
+function updateTask(id, input, db) {
+  const d = db || getDatabase();
+  const task = getTask(id, d);
+  if (!task)
+    throw new TaskNotFoundError(id);
+  if (task.version !== input.version) {
+    throw new VersionConflictError(id, input.version, task.version);
+  }
+  const sets = ["version = version + 1", "updated_at = ?"];
+  const params = [now()];
+  if (input.title !== undefined) {
+    sets.push("title = ?");
+    params.push(input.title);
+  }
+  if (input.description !== undefined) {
+    sets.push("description = ?");
+    params.push(input.description);
+  }
+  if (input.status !== undefined) {
+    if (input.status === "completed") {
+      checkCompletionGuard(task, task.assigned_to || task.agent_id || null, d);
+    }
+    sets.push("status = ?");
+    params.push(input.status);
+    if (input.status === "completed") {
+      sets.push("completed_at = ?");
+      params.push(now());
+    }
+  }
+  if (input.priority !== undefined) {
+    sets.push("priority = ?");
+    params.push(input.priority);
+  }
+  if (input.assigned_to !== undefined) {
+    sets.push("assigned_to = ?");
+    params.push(input.assigned_to);
+  }
+  if (input.tags !== undefined) {
+    sets.push("tags = ?");
+    params.push(JSON.stringify(input.tags));
+  }
+  if (input.metadata !== undefined) {
+    sets.push("metadata = ?");
+    params.push(JSON.stringify(input.metadata));
+  }
+  if (input.plan_id !== undefined) {
+    sets.push("plan_id = ?");
+    params.push(input.plan_id);
+  }
+  if (input.task_list_id !== undefined) {
+    sets.push("task_list_id = ?");
+    params.push(input.task_list_id);
+  }
+  if (input.due_at !== undefined) {
+    sets.push("due_at = ?");
+    params.push(input.due_at);
+  }
+  if (input.estimated_minutes !== undefined) {
+    sets.push("estimated_minutes = ?");
+    params.push(input.estimated_minutes);
+  }
+  if (input.requires_approval !== undefined) {
+    sets.push("requires_approval = ?");
+    params.push(input.requires_approval ? 1 : 0);
+  }
+  if (input.approved_by !== undefined) {
+    sets.push("approved_by = ?");
+    params.push(input.approved_by);
+    sets.push("approved_at = ?");
+    params.push(now());
+  }
+  if (input.recurrence_rule !== undefined) {
+    sets.push("recurrence_rule = ?");
+    params.push(input.recurrence_rule);
+  }
+  params.push(id, input.version);
+  const result = d.run(`UPDATE tasks SET ${sets.join(", ")} WHERE id = ? AND version = ?`, params);
+  if (result.changes === 0) {
+    const current = getTask(id, d);
+    throw new VersionConflictError(id, input.version, current?.version ?? -1);
+  }
+  if (input.tags !== undefined) {
+    replaceTaskTags(id, input.tags, d);
+  }
+  const agentId = task.assigned_to || task.agent_id || null;
+  if (input.status !== undefined && input.status !== task.status)
+    logTaskChange(id, "update", "status", task.status, input.status, agentId, d);
+  if (input.priority !== undefined && input.priority !== task.priority)
+    logTaskChange(id, "update", "priority", task.priority, input.priority, agentId, d);
+  if (input.title !== undefined && input.title !== task.title)
+    logTaskChange(id, "update", "title", task.title, input.title, agentId, d);
+  if (input.assigned_to !== undefined && input.assigned_to !== task.assigned_to)
+    logTaskChange(id, "update", "assigned_to", task.assigned_to, input.assigned_to, agentId, d);
+  if (input.approved_by !== undefined)
+    logTaskChange(id, "approve", "approved_by", null, input.approved_by, agentId, d);
+  return {
+    ...task,
+    ...Object.fromEntries(Object.entries(input).filter(([, v]) => v !== undefined)),
+    tags: input.tags ?? task.tags,
+    metadata: input.metadata ?? task.metadata,
+    version: task.version + 1,
+    updated_at: now(),
+    completed_at: input.status === "completed" ? now() : task.completed_at,
+    requires_approval: input.requires_approval !== undefined ? input.requires_approval : task.requires_approval,
+    approved_by: input.approved_by ?? task.approved_by,
+    approved_at: input.approved_by ? now() : task.approved_at
+  };
+}
+function deleteTask(id, db) {
+  const d = db || getDatabase();
+  const result = d.run("DELETE FROM tasks WHERE id = ?", [id]);
+  return result.changes > 0;
+}
+function getBlockingDeps(id, db) {
+  const d = db || getDatabase();
+  const deps = getTaskDependencies(id, d);
+  if (deps.length === 0)
+    return [];
+  const blocking = [];
+  for (const dep of deps) {
+    const task = getTask(dep.depends_on, d);
+    if (task && task.status !== "completed")
+      blocking.push(task);
+  }
+  return blocking;
+}
+function startTask(id, agentId, db) {
+  const d = db || getDatabase();
+  const task = getTask(id, d);
+  if (!task)
+    throw new TaskNotFoundError(id);
+  const blocking = getBlockingDeps(id, d);
+  if (blocking.length > 0) {
+    const blockerIds = blocking.map((b) => b.id.slice(0, 8)).join(", ");
+    throw new Error(`Task is blocked by ${blocking.length} unfinished dependency(ies): ${blockerIds}`);
+  }
+  const cutoff = lockExpiryCutoff();
+  const timestamp = now();
+  const result = d.run(`UPDATE tasks SET status = 'in_progress', assigned_to = ?, locked_by = ?, locked_at = ?, version = version + 1, updated_at = ?
+     WHERE id = ? AND (locked_by IS NULL OR locked_by = ? OR locked_at < ?)`, [agentId, agentId, timestamp, timestamp, id, agentId, cutoff]);
+  if (result.changes === 0) {
+    if (task.locked_by && task.locked_by !== agentId && !isLockExpired(task.locked_at)) {
+      throw new LockError(id, task.locked_by);
+    }
+  }
+  logTaskChange(id, "start", "status", "pending", "in_progress", agentId, d);
+  return { ...task, status: "in_progress", assigned_to: agentId, locked_by: agentId, locked_at: timestamp, version: task.version + 1, updated_at: timestamp };
+}
+function completeTask(id, agentId, db, options) {
+  const d = db || getDatabase();
+  const task = getTask(id, d);
+  if (!task)
+    throw new TaskNotFoundError(id);
+  if (agentId && task.locked_by && task.locked_by !== agentId && !isLockExpired(task.locked_at)) {
+    throw new LockError(id, task.locked_by);
+  }
+  checkCompletionGuard(task, agentId || null, d);
+  const evidence = options ? { files_changed: options.files_changed, test_results: options.test_results, commit_hash: options.commit_hash, notes: options.notes } : undefined;
+  const hasEvidence = evidence && (evidence.files_changed || evidence.test_results || evidence.commit_hash || evidence.notes);
+  if (hasEvidence) {
+    const meta2 = { ...task.metadata, _evidence: evidence };
+    d.run("UPDATE tasks SET metadata = ? WHERE id = ?", [JSON.stringify(meta2), id]);
+  }
+  const timestamp = now();
+  d.run(`UPDATE tasks SET status = 'completed', locked_by = NULL, locked_at = NULL, completed_at = ?, version = version + 1, updated_at = ?
+     WHERE id = ?`, [timestamp, timestamp, id]);
+  logTaskChange(id, "complete", "status", task.status, "completed", agentId || null, d);
+  let spawnedTask = null;
+  if (task.recurrence_rule && !options?.skip_recurrence) {
+    spawnedTask = spawnNextRecurrence(task, d);
+  }
+  const meta = hasEvidence ? { ...task.metadata, _evidence: evidence } : task.metadata;
+  if (spawnedTask) {
+    meta._next_recurrence = { id: spawnedTask.id, short_id: spawnedTask.short_id, due_at: spawnedTask.due_at };
+  }
+  return { ...task, status: "completed", locked_by: null, locked_at: null, completed_at: timestamp, version: task.version + 1, updated_at: timestamp, metadata: meta };
+}
+function getTaskDependencies(taskId, db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM task_dependencies WHERE task_id = ?").all(taskId);
+}
+function spawnNextRecurrence(completedTask, db) {
+  const dueAt = nextOccurrence(completedTask.recurrence_rule, new Date);
+  let title = completedTask.title;
+  if (completedTask.short_id && title.startsWith(completedTask.short_id + ": ")) {
+    title = title.slice(completedTask.short_id.length + 2);
+  }
+  const recurrenceParentId = completedTask.recurrence_parent_id || completedTask.id;
+  return createTask({
+    title,
+    description: completedTask.description ?? undefined,
+    priority: completedTask.priority,
+    project_id: completedTask.project_id ?? undefined,
+    task_list_id: completedTask.task_list_id ?? undefined,
+    plan_id: completedTask.plan_id ?? undefined,
+    assigned_to: completedTask.assigned_to ?? undefined,
+    tags: completedTask.tags,
+    metadata: completedTask.metadata,
+    estimated_minutes: completedTask.estimated_minutes ?? undefined,
+    recurrence_rule: completedTask.recurrence_rule,
+    recurrence_parent_id: recurrenceParentId,
+    due_at: dueAt
+  }, db);
+}
+
+// src/server/serve.ts
+init_projects();
+init_agents();
+
+// src/db/plans.ts
+init_types();
+init_database();
+function createPlan(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  d.run(`INSERT INTO plans (id, project_id, task_list_id, agent_id, name, description, status, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+    id,
+    input.project_id || null,
+    input.task_list_id || null,
+    input.agent_id || null,
+    input.name,
+    input.description || null,
+    input.status || "active",
+    timestamp,
+    timestamp
+  ]);
+  return getPlan(id, d);
+}
+function getPlan(id, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM plans WHERE id = ?").get(id);
+  return row;
+}
+function listPlans(projectId, db) {
+  const d = db || getDatabase();
+  if (projectId) {
+    return d.query("SELECT * FROM plans WHERE project_id = ? ORDER BY created_at DESC").all(projectId);
+  }
+  return d.query("SELECT * FROM plans ORDER BY created_at DESC").all();
+}
+function updatePlan(id, input, db) {
+  const d = db || getDatabase();
+  const plan = getPlan(id, d);
+  if (!plan)
+    throw new PlanNotFoundError(id);
+  const sets = ["updated_at = ?"];
+  const params = [now()];
+  if (input.name !== undefined) {
+    sets.push("name = ?");
+    params.push(input.name);
+  }
+  if (input.description !== undefined) {
+    sets.push("description = ?");
+    params.push(input.description);
+  }
+  if (input.status !== undefined) {
+    sets.push("status = ?");
+    params.push(input.status);
+  }
+  if (input.task_list_id !== undefined) {
+    sets.push("task_list_id = ?");
+    params.push(input.task_list_id);
+  }
+  if (input.agent_id !== undefined) {
+    sets.push("agent_id = ?");
+    params.push(input.agent_id);
+  }
+  params.push(id);
+  d.run(`UPDATE plans SET ${sets.join(", ")} WHERE id = ?`, params);
+  return getPlan(id, d);
+}
+function deletePlan(id, db) {
+  const d = db || getDatabase();
+  const result = d.run("DELETE FROM plans WHERE id = ?", [id]);
+  return result.changes > 0;
+}
+
+// src/server/serve.ts
+init_database();
+function resolveDashboardDir() {
+  const candidates = [];
+  try {
+    const scriptDir = dirname2(fileURLToPath(import.meta.url));
+    candidates.push(join3(scriptDir, "..", "dashboard", "dist"));
+    candidates.push(join3(scriptDir, "..", "..", "dashboard", "dist"));
+  } catch {}
+  if (process.argv[1]) {
+    const mainDir = dirname2(process.argv[1]);
+    candidates.push(join3(mainDir, "..", "dashboard", "dist"));
+    candidates.push(join3(mainDir, "..", "..", "dashboard", "dist"));
+  }
+  candidates.push(join3(process.cwd(), "dashboard", "dist"));
+  for (const candidate of candidates) {
+    if (existsSync4(candidate))
+      return candidate;
+  }
+  return join3(process.cwd(), "dashboard", "dist");
+}
+var MIME_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript",
+  ".css": "text/css",
+  ".json": "application/json",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2"
+};
+var SECURITY_HEADERS = {
+  "X-Content-Type-Options": "nosniff",
+  "X-Frame-Options": "DENY"
+};
+function json(data, status = 200, port) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: {
+      "Content-Type": "application/json",
+      "Access-Control-Allow-Origin": port ? `http://localhost:${port}` : "*",
+      ...SECURITY_HEADERS
+    }
+  });
+}
+function serveStaticFile(filePath) {
+  if (!existsSync4(filePath))
+    return null;
+  const ext = extname(filePath);
+  const contentType = MIME_TYPES[ext] || "application/octet-stream";
+  return new Response(Bun.file(filePath), {
+    headers: { "Content-Type": contentType }
+  });
+}
+function taskToSummary(task, fields) {
+  const full = {
+    id: task.id,
+    short_id: task.short_id,
+    title: task.title,
+    description: task.description,
+    status: task.status,
+    priority: task.priority,
+    project_id: task.project_id,
+    plan_id: task.plan_id,
+    task_list_id: task.task_list_id,
+    agent_id: task.agent_id,
+    assigned_to: task.assigned_to,
+    locked_by: task.locked_by,
+    tags: task.tags,
+    version: task.version,
+    created_at: task.created_at,
+    updated_at: task.updated_at,
+    completed_at: task.completed_at,
+    due_at: task.due_at
+  };
+  if (!fields || fields.length === 0)
+    return full;
+  return Object.fromEntries(fields.map((f) => [f, full[f] ?? null]));
+}
+async function startServer(port, options) {
+  const shouldOpen = options?.open ?? true;
+  getDatabase();
+  const sseClients = new Set;
+  function broadcastEvent(event) {
+    const data = JSON.stringify({ ...event, timestamp: new Date().toISOString() });
+    for (const controller of sseClients) {
+      try {
+        controller.enqueue(`data: ${data}
+
+`);
+      } catch {
+        sseClients.delete(controller);
+      }
+    }
+  }
+  const dashboardDir = resolveDashboardDir();
+  const dashboardExists = existsSync4(dashboardDir);
+  if (!dashboardExists) {
+    console.error(`
+Dashboard not found at: ${dashboardDir}`);
+    console.error(`Run this to build it:
+`);
+    console.error(`  cd dashboard && bun install && bun run build
+`);
+  }
+  const server = Bun.serve({
+    port,
+    async fetch(req) {
+      const url = new URL(req.url);
+      const path = url.pathname;
+      const method = req.method;
+      if (method === "OPTIONS") {
+        return new Response(null, {
+          headers: {
+            "Access-Control-Allow-Origin": `http://localhost:${port}`,
+            "Access-Control-Allow-Methods": "GET, POST, PATCH, DELETE, OPTIONS",
+            "Access-Control-Allow-Headers": "Content-Type"
+          }
+        });
+      }
+      if (path === "/api/events" && method === "GET") {
+        const stream = new ReadableStream({
+          start(controller) {
+            sseClients.add(controller);
+            controller.enqueue(`data: ${JSON.stringify({ type: "connected", timestamp: new Date().toISOString() })}
+
+`);
+          },
+          cancel(controller) {
+            sseClients.delete(controller);
+          }
+        });
+        return new Response(stream, {
+          headers: {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive",
+            "Access-Control-Allow-Origin": `http://localhost:${port}`
+          }
+        });
+      }
+      if (path === "/api/stats" && method === "GET") {
+        const all = listTasks({ limit: 1e4 });
+        const projects = listProjects();
+        const agents = listAgents();
+        return json({
+          total_tasks: all.length,
+          pending: all.filter((t) => t.status === "pending").length,
+          in_progress: all.filter((t) => t.status === "in_progress").length,
+          completed: all.filter((t) => t.status === "completed").length,
+          failed: all.filter((t) => t.status === "failed").length,
+          cancelled: all.filter((t) => t.status === "cancelled").length,
+          projects: projects.length,
+          agents: agents.length
+        }, 200, port);
+      }
+      if (path === "/api/tasks" && method === "GET") {
+        const status = url.searchParams.get("status") || undefined;
+        const projectId = url.searchParams.get("project_id") || undefined;
+        const limitParam = url.searchParams.get("limit");
+        const fieldsParam = url.searchParams.get("fields");
+        const fields = fieldsParam ? fieldsParam.split(",").map((f) => f.trim()).filter(Boolean) : undefined;
+        const tasks = listTasks({
+          status,
+          project_id: projectId,
+          limit: limitParam ? parseInt(limitParam, 10) : undefined
+        });
+        return json(tasks.map((t) => taskToSummary(t, fields)), 200, port);
+      }
+      if (path === "/api/tasks" && method === "POST") {
+        try {
+          const body = await req.json();
+          if (!body.title)
+            return json({ error: "Missing 'title'" }, 400, port);
+          const task = createTask({
+            title: body.title,
+            description: body.description,
+            priority: body.priority,
+            project_id: body.project_id
+          });
+          broadcastEvent({ type: "task", task_id: task.id, action: "created", agent_id: task.agent_id });
+          return json(taskToSummary(task), 201, port);
+        } catch (e) {
+          return json({ error: e instanceof Error ? e.message : "Failed to create task" }, 500, port);
+        }
+      }
+      if (path === "/api/tasks/export" && method === "GET") {
+        const format = url.searchParams.get("format") || "json";
+        const status = url.searchParams.get("status") || undefined;
+        const projectId = url.searchParams.get("project_id") || undefined;
+        const tasks = listTasks({ status, project_id: projectId, limit: 1e4 });
+        const summaries = tasks.map((t) => taskToSummary(t));
+        if (format === "csv") {
+          const headers = ["id", "short_id", "title", "status", "priority", "project_id", "assigned_to", "agent_id", "created_at", "updated_at", "completed_at", "due_at"];
+          const rows = summaries.map((t) => headers.map((h) => {
+            const val = t[h];
+            if (val === null || val === undefined)
+              return "";
+            const str = String(val);
+            return str.includes(",") || str.includes('"') || str.includes(`
+`) ? `"${str.replace(/"/g, '""')}"` : str;
+          }).join(","));
+          const csv = [headers.join(","), ...rows].join(`
+`);
+          return new Response(csv, {
+            headers: {
+              "Content-Type": "text/csv",
+              "Content-Disposition": "attachment; filename=tasks.csv",
+              ...SECURITY_HEADERS
+            }
+          });
+        }
+        return new Response(JSON.stringify(summaries, null, 2), {
+          headers: {
+            "Content-Type": "application/json",
+            "Content-Disposition": "attachment; filename=tasks.json",
+            ...SECURITY_HEADERS
+          }
+        });
+      }
+      if (path === "/api/tasks/bulk" && method === "POST") {
+        try {
+          const body = await req.json();
+          if (!body.ids?.length || !body.action)
+            return json({ error: "Missing ids or action" }, 400, port);
+          const results = [];
+          for (const id of body.ids) {
+            try {
+              if (body.action === "delete") {
+                deleteTask(id);
+                results.push({ id, success: true });
+              } else if (body.action === "start") {
+                startTask(id, "dashboard");
+                results.push({ id, success: true });
+              } else if (body.action === "complete") {
+                completeTask(id, "dashboard");
+                results.push({ id, success: true });
+              }
+            } catch (e) {
+              results.push({ id, success: false, error: e instanceof Error ? e.message : "Failed" });
+            }
+          }
+          return json({ results, succeeded: results.filter((r) => r.success).length, failed: results.filter((r) => !r.success).length }, 200, port);
+        } catch (e) {
+          return json({ error: e instanceof Error ? e.message : "Failed" }, 500, port);
+        }
+      }
+      const taskMatch = path.match(/^\/api\/tasks\/([^/]+)$/);
+      if (taskMatch) {
+        const id = taskMatch[1];
+        if (method === "GET") {
+          const task = getTask(id);
+          if (!task)
+            return json({ error: "Task not found" }, 404, port);
+          return json(taskToSummary(task), 200, port);
+        }
+        if (method === "PATCH") {
+          try {
+            const body = await req.json();
+            const task = getTask(id);
+            if (!task)
+              return json({ error: "Task not found" }, 404, port);
+            const updated = updateTask(id, {
+              ...body,
+              version: task.version
+            });
+            return json(taskToSummary(updated), 200, port);
+          } catch (e) {
+            return json({ error: e instanceof Error ? e.message : "Failed to update task" }, 500, port);
+          }
+        }
+        if (method === "DELETE") {
+          const deleted = deleteTask(id);
+          if (!deleted)
+            return json({ error: "Task not found" }, 404, port);
+          return json({ success: true }, 200, port);
+        }
+      }
+      const startMatch = path.match(/^\/api\/tasks\/([^/]+)\/start$/);
+      if (startMatch && method === "POST") {
+        const id = startMatch[1];
+        try {
+          const task = startTask(id, "dashboard");
+          broadcastEvent({ type: "task", task_id: task.id, action: "started", agent_id: "dashboard" });
+          return json(taskToSummary(task), 200, port);
+        } catch (e) {
+          return json({ error: e instanceof Error ? e.message : "Failed to start task" }, 500, port);
+        }
+      }
+      const completeMatch = path.match(/^\/api\/tasks\/([^/]+)\/complete$/);
+      if (completeMatch && method === "POST") {
+        const id = completeMatch[1];
+        try {
+          const task = completeTask(id, "dashboard");
+          broadcastEvent({ type: "task", task_id: task.id, action: "completed", agent_id: "dashboard" });
+          return json(taskToSummary(task), 200, port);
+        } catch (e) {
+          return json({ error: e instanceof Error ? e.message : "Failed to complete task" }, 500, port);
+        }
+      }
+      if (path === "/api/projects" && method === "GET") {
+        return json(listProjects(), 200, port);
+      }
+      if (path === "/api/agents/me" && method === "GET") {
+        const name = url.searchParams.get("name");
+        if (!name)
+          return json({ error: "Missing name param" }, 400, port);
+        const { registerAgent: registerAgent2 } = await Promise.resolve().then(() => (init_agents(), exports_agents));
+        const agent = registerAgent2({ name });
+        const tasks = listTasks({ assigned_to: name });
+        const agentIdTasks = listTasks({ agent_id: agent.id });
+        const allTasks = [...tasks, ...agentIdTasks.filter((t) => !tasks.some((tt) => tt.id === t.id))];
+        const pending = allTasks.filter((t) => t.status === "pending");
+        const inProgress = allTasks.filter((t) => t.status === "in_progress");
+        const completed = allTasks.filter((t) => t.status === "completed");
+        return json({
+          agent,
+          pending_tasks: pending.map((t) => taskToSummary(t)),
+          in_progress_tasks: inProgress.map((t) => taskToSummary(t)),
+          stats: {
+            total: allTasks.length,
+            pending: pending.length,
+            in_progress: inProgress.length,
+            completed: completed.length,
+            completion_rate: allTasks.length > 0 ? Math.round(completed.length / allTasks.length * 100) : 0
+          }
+        }, 200, port);
+      }
+      const queueMatch = path.match(/^\/api\/agents\/([^/]+)\/queue$/);
+      if (queueMatch && method === "GET") {
+        const agentId = decodeURIComponent(queueMatch[1]);
+        const pending = listTasks({ status: "pending" });
+        const queue = pending.filter((t) => t.assigned_to === agentId || t.agent_id === agentId || !t.assigned_to && !t.locked_by);
+        const order = { critical: 0, high: 1, medium: 2, low: 3 };
+        queue.sort((a, b) => (order[a.priority] ?? 4) - (order[b.priority] ?? 4) || new Date(a.created_at).getTime() - new Date(b.created_at).getTime());
+        return json(queue.map((t) => taskToSummary(t)), 200, port);
+      }
+      if (path === "/api/tasks/claim" && method === "POST") {
+        try {
+          const body = await req.json();
+          const agentId = body.agent_id || "anonymous";
+          const pending = listTasks({ status: "pending", project_id: body.project_id });
+          const available = pending.filter((t) => !t.locked_by);
+          if (available.length === 0)
+            return json({ task: null }, 200, port);
+          const order = { critical: 0, high: 1, medium: 2, low: 3 };
+          available.sort((a, b) => (order[a.priority] ?? 4) - (order[b.priority] ?? 4));
+          const target = available[0];
+          try {
+            const claimed = startTask(target.id, agentId);
+            return json({ task: taskToSummary(claimed) }, 200, port);
+          } catch (e) {
+            const next = available[1] || null;
+            return json({
+              task: null,
+              locked_by: target.locked_by,
+              locked_since: target.locked_at,
+              suggested_task: next ? taskToSummary(next) : null
+            }, 200, port);
+          }
+        } catch (e) {
+          return json({ error: e instanceof Error ? e.message : "Failed to claim" }, 500, port);
+        }
+      }
+      if (path === "/api/orgs" && method === "GET") {
+        const { listOrgs: listOrgs2 } = await Promise.resolve().then(() => (init_orgs(), exports_orgs));
+        return json(listOrgs2(), 200, port);
+      }
+      if (path === "/api/orgs" && method === "POST") {
+        try {
+          const body = await req.json();
+          if (!body.name)
+            return json({ error: "Missing name" }, 400, port);
+          const { createOrg: createOrg2 } = await Promise.resolve().then(() => (init_orgs(), exports_orgs));
+          return json(createOrg2(body), 201, port);
+        } catch (e) {
+          return json({ error: e instanceof Error ? e.message : "Failed" }, 500, port);
+        }
+      }
+      const orgMatch = path.match(/^\/api\/orgs\/([^/]+)$/);
+      if (orgMatch && method === "PATCH") {
+        try {
+          const body = await req.json();
+          const { updateOrg: updateOrg2 } = await Promise.resolve().then(() => (init_orgs(), exports_orgs));
+          return json(updateOrg2(orgMatch[1], body), 200, port);
+        } catch (e) {
+          return json({ error: e instanceof Error ? e.message : "Failed" }, 500, port);
+        }
+      }
+      if (orgMatch && method === "DELETE") {
+        const { deleteOrg: deleteOrg2 } = await Promise.resolve().then(() => (init_orgs(), exports_orgs));
+        const deleted = deleteOrg2(orgMatch[1]);
+        return json(deleted ? { success: true } : { error: "Not found" }, deleted ? 200 : 404, port);
+      }
+      if (path === "/api/org" && method === "GET") {
+        const { getOrgChart: getOrgChart2 } = await Promise.resolve().then(() => (init_agents(), exports_agents));
+        return json(getOrgChart2(), 200, port);
+      }
+      const teamMatch = path.match(/^\/api\/agents\/([^/]+)\/team$/);
+      if (teamMatch && method === "GET") {
+        const agentId = decodeURIComponent(teamMatch[1]);
+        const { getDirectReports: getDirectReports2 } = await Promise.resolve().then(() => (init_agents(), exports_agents));
+        return json(getDirectReports2(agentId), 200, port);
+      }
+      if (path === "/api/agents" && method === "GET") {
+        return json(listAgents(), 200, port);
+      }
+      if (path === "/api/projects" && method === "POST") {
+        try {
+          const body = await req.json();
+          if (!body.name || !body.path)
+            return json({ error: "Missing name or path" }, 400, port);
+          const { createProject: createProject2 } = await Promise.resolve().then(() => (init_projects(), exports_projects));
+          const project = createProject2({ name: body.name, path: body.path, description: body.description });
+          return json(project, 201, port);
+        } catch (e) {
+          return json({ error: e instanceof Error ? e.message : "Failed to create project" }, 500, port);
+        }
+      }
+      const projectDeleteMatch = path.match(/^\/api\/projects\/([^/]+)$/);
+      if (projectDeleteMatch && method === "DELETE") {
+        const id = projectDeleteMatch[1];
+        const { deleteProject: deleteProject2 } = await Promise.resolve().then(() => (init_projects(), exports_projects));
+        const deleted = deleteProject2(id);
+        if (!deleted)
+          return json({ error: "Project not found" }, 404, port);
+        return json({ success: true }, 200, port);
+      }
+      if (path === "/api/agents" && method === "POST") {
+        try {
+          const body = await req.json();
+          if (!body.name)
+            return json({ error: "Missing name" }, 400, port);
+          const { registerAgent: registerAgent2 } = await Promise.resolve().then(() => (init_agents(), exports_agents));
+          const agent = registerAgent2({ name: body.name, description: body.description });
+          return json(agent, 201, port);
+        } catch (e) {
+          return json({ error: e instanceof Error ? e.message : "Failed to register agent" }, 500, port);
+        }
+      }
+      const agentMatch = path.match(/^\/api\/agents\/([^/]+)$/);
+      if (agentMatch && method === "PATCH") {
+        const id = agentMatch[1];
+        try {
+          const body = await req.json();
+          const { updateAgent: updateAgent2 } = await Promise.resolve().then(() => (init_agents(), exports_agents));
+          const agent = updateAgent2(id, body);
+          return json(agent, 200, port);
+        } catch (e) {
+          return json({ error: e instanceof Error ? e.message : "Failed to update agent" }, 500, port);
+        }
+      }
+      if (agentMatch && method === "DELETE") {
+        const id = agentMatch[1];
+        const { deleteAgent: deleteAgent2 } = await Promise.resolve().then(() => (init_agents(), exports_agents));
+        const deleted = deleteAgent2(id);
+        if (!deleted)
+          return json({ error: "Agent not found" }, 404, port);
+        return json({ success: true }, 200, port);
+      }
+      if (path === "/api/agents/bulk" && method === "POST") {
+        try {
+          const body = await req.json();
+          if (!body.ids?.length || body.action !== "delete")
+            return json({ error: "Missing ids or invalid action" }, 400, port);
+          const { deleteAgent: deleteAgent2 } = await Promise.resolve().then(() => (init_agents(), exports_agents));
+          let succeeded = 0;
+          for (const id of body.ids) {
+            if (deleteAgent2(id))
+              succeeded++;
+          }
+          return json({ succeeded, failed: body.ids.length - succeeded }, 200, port);
+        } catch (e) {
+          return json({ error: e instanceof Error ? e.message : "Failed" }, 500, port);
+        }
+      }
+      if (path === "/api/projects/bulk" && method === "POST") {
+        try {
+          const body = await req.json();
+          if (!body.ids?.length || body.action !== "delete")
+            return json({ error: "Missing ids or invalid action" }, 400, port);
+          const { deleteProject: deleteProject2 } = await Promise.resolve().then(() => (init_projects(), exports_projects));
+          let succeeded = 0;
+          for (const id of body.ids) {
+            if (deleteProject2(id))
+              succeeded++;
+          }
+          return json({ succeeded, failed: body.ids.length - succeeded }, 200, port);
+        } catch (e) {
+          return json({ error: e instanceof Error ? e.message : "Failed" }, 500, port);
+        }
+      }
+      if (path === "/api/activity" && method === "GET") {
+        const limit = parseInt(url.searchParams.get("limit") || "50", 10);
+        const { getRecentActivity: getRecentActivity2 } = await Promise.resolve().then(() => (init_audit(), exports_audit));
+        return json(getRecentActivity2(limit), 200, port);
+      }
+      const historyMatch = path.match(/^\/api\/tasks\/([^/]+)\/history$/);
+      if (historyMatch && method === "GET") {
+        const id = historyMatch[1];
+        const { getTaskHistory: getTaskHistory2 } = await Promise.resolve().then(() => (init_audit(), exports_audit));
+        return json(getTaskHistory2(id), 200, port);
+      }
+      if (path === "/api/webhooks" && method === "GET") {
+        const { listWebhooks: listWebhooks2 } = await Promise.resolve().then(() => (init_webhooks(), exports_webhooks));
+        return json(listWebhooks2(), 200, port);
+      }
+      if (path === "/api/webhooks" && method === "POST") {
+        try {
+          const body = await req.json();
+          if (!body.url)
+            return json({ error: "Missing url" }, 400, port);
+          const { createWebhook: createWebhook2 } = await Promise.resolve().then(() => (init_webhooks(), exports_webhooks));
+          return json(createWebhook2(body), 201, port);
+        } catch (e) {
+          return json({ error: e instanceof Error ? e.message : "Failed" }, 500, port);
+        }
+      }
+      const webhookMatch = path.match(/^\/api\/webhooks\/([^/]+)$/);
+      if (webhookMatch && method === "DELETE") {
+        const { deleteWebhook: deleteWebhook2 } = await Promise.resolve().then(() => (init_webhooks(), exports_webhooks));
+        const deleted = deleteWebhook2(webhookMatch[1]);
+        return json(deleted ? { success: true } : { error: "Not found" }, deleted ? 200 : 404, port);
+      }
+      if (path === "/api/templates" && method === "GET") {
+        const { listTemplates: listTemplates2 } = await Promise.resolve().then(() => (init_templates(), exports_templates));
+        return json(listTemplates2(), 200, port);
+      }
+      if (path === "/api/templates" && method === "POST") {
+        try {
+          const body = await req.json();
+          if (!body.name || !body.title_pattern)
+            return json({ error: "Missing name or title_pattern" }, 400, port);
+          const { createTemplate: createTemplate2 } = await Promise.resolve().then(() => (init_templates(), exports_templates));
+          return json(createTemplate2(body), 201, port);
+        } catch (e) {
+          return json({ error: e instanceof Error ? e.message : "Failed" }, 500, port);
+        }
+      }
+      const templateMatch = path.match(/^\/api\/templates\/([^/]+)$/);
+      if (templateMatch && method === "DELETE") {
+        const { deleteTemplate: deleteTemplate2 } = await Promise.resolve().then(() => (init_templates(), exports_templates));
+        const deleted = deleteTemplate2(templateMatch[1]);
+        return json(deleted ? { success: true } : { error: "Not found" }, deleted ? 200 : 404, port);
+      }
+      if (path === "/api/plans" && method === "GET") {
+        const projectId = url.searchParams.get("project_id") || undefined;
+        const plans = listPlans(projectId);
+        return json(plans, 200, port);
+      }
+      if (path === "/api/plans" && method === "POST") {
+        try {
+          const body = await req.json();
+          if (!body.name)
+            return json({ error: "Missing 'name'" }, 400, port);
+          const plan = createPlan({
+            name: body.name,
+            description: body.description,
+            project_id: body.project_id,
+            task_list_id: body.task_list_id,
+            agent_id: body.agent_id,
+            status: body.status
+          });
+          return json(plan, 201, port);
+        } catch (e) {
+          return json({ error: e instanceof Error ? e.message : "Failed to create plan" }, 500, port);
+        }
+      }
+      if (path === "/api/plans/bulk" && method === "POST") {
+        try {
+          const body = await req.json();
+          if (!body.ids?.length || body.action !== "delete")
+            return json({ error: "Missing ids or invalid action" }, 400, port);
+          let succeeded = 0;
+          for (const id of body.ids) {
+            if (deletePlan(id))
+              succeeded++;
+          }
+          return json({ succeeded, failed: body.ids.length - succeeded }, 200, port);
+        } catch (e) {
+          return json({ error: e instanceof Error ? e.message : "Failed" }, 500, port);
+        }
+      }
+      const planMatch = path.match(/^\/api\/plans\/([^/]+)$/);
+      if (planMatch) {
+        const id = planMatch[1];
+        if (method === "GET") {
+          const plan = getPlan(id);
+          if (!plan)
+            return json({ error: "Plan not found" }, 404, port);
+          const tasks = listTasks({ plan_id: id });
+          return json({ ...plan, tasks: tasks.map((t) => taskToSummary(t)) }, 200, port);
+        }
+        if (method === "PATCH") {
+          try {
+            const body = await req.json();
+            const plan = updatePlan(id, body);
+            return json(plan, 200, port);
+          } catch (e) {
+            return json({ error: e instanceof Error ? e.message : "Failed to update plan" }, 500, port);
+          }
+        }
+        if (method === "DELETE") {
+          const deleted = deletePlan(id);
+          if (!deleted)
+            return json({ error: "Plan not found" }, 404, port);
+          return json({ success: true }, 200, port);
+        }
+      }
+      if (dashboardExists && (method === "GET" || method === "HEAD")) {
+        if (path !== "/") {
+          const filePath = join3(dashboardDir, path);
+          const res2 = serveStaticFile(filePath);
+          if (res2)
+            return res2;
+        }
+        const indexPath = join3(dashboardDir, "index.html");
+        const res = serveStaticFile(indexPath);
+        if (res)
+          return res;
+      }
+      return json({ error: "Not found" }, 404, port);
+    }
+  });
+  const shutdown = () => {
+    server.stop();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  const serverUrl = `http://localhost:${port}`;
+  console.log(`Todos Dashboard running at ${serverUrl}`);
+  if (shouldOpen) {
+    try {
+      const { exec } = await import("child_process");
+      const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+      exec(`${openCmd} ${serverUrl}`);
+    } catch {}
+  }
+}
+
+// src/server/index.ts
+var DEFAULT_PORT = 19427;
+function parsePort() {
+  const portArg = process.argv.find((a) => a === "--port" || a.startsWith("--port="));
+  if (portArg) {
+    if (portArg.includes("=")) {
+      return parseInt(portArg.split("=")[1], 10) || DEFAULT_PORT;
+    }
+    const idx = process.argv.indexOf(portArg);
+    return parseInt(process.argv[idx + 1], 10) || DEFAULT_PORT;
+  }
+  return DEFAULT_PORT;
+}
+async function findFreePort(start) {
+  for (let port = start;port < start + 100; port++) {
+    try {
+      const server = Bun.serve({ port, fetch: () => new Response("") });
+      server.stop(true);
+      return port;
+    } catch {}
+  }
+  return start;
+}
+async function main() {
+  const requestedPort = parsePort();
+  const port = await findFreePort(requestedPort);
+  if (port !== requestedPort) {
+    console.log(`Port ${requestedPort} in use, using ${port}`);
+  }
+  startServer(port);
+}
+main();