@hasna/todos 0.9.38 → 0.9.40

package/dist/server/index.js

@@ -29,7 +29,7 @@ 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 VersionConflictError, TaskNotFoundError, ProjectNotFoundError, PlanNotFoundError, LockError, DependencyCycleError, CompletionGuardError;
 var init_types = __esm(() => {
   VersionConflictError = class VersionConflictError extends Error {
     taskId;
@@ -87,6 +87,18 @@ var init_types = __esm(() => {
       this.name = "LockError";
     }
   };
+  DependencyCycleError = class DependencyCycleError extends Error {
+    taskId;
+    dependsOn;
+    static code = "DEPENDENCY_CYCLE";
+    static suggestion = "Check the dependency chain with get_task to avoid circular references.";
+    constructor(taskId, dependsOn) {
+      super(`Adding dependency ${taskId} -> ${dependsOn} would create a cycle`);
+      this.taskId = taskId;
+      this.dependsOn = dependsOn;
+      this.name = "DependencyCycleError";
+    }
+  };
   CompletionGuardError = class CompletionGuardError extends Error {
     reason;
     retryAfterSeconds;
@@ -715,6 +727,107 @@ var init_projects = __esm(() => {
   init_database();
 });
 
+// src/lib/sync-utils.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync, readdirSync, statSync, writeFileSync } from "fs";
+function readJsonFile(path) {
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+var HOME;
+var init_sync_utils = __esm(() => {
+  HOME = process.env["HOME"] || process.env["USERPROFILE"] || "~";
+});
+
+// src/lib/config.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join2 } from "path";
+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;
+}
+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;
+}
+var CONFIG_PATH, cached = null, GUARD_DEFAULTS;
+var init_config = __esm(() => {
+  init_sync_utils();
+  CONFIG_PATH = join2(HOME, ".todos", "config.json");
+  GUARD_DEFAULTS = {
+    enabled: false,
+    min_work_seconds: 30,
+    max_completions_per_window: 5,
+    window_minutes: 10,
+    cooldown_seconds: 60
+  };
+});
+
+// src/lib/completion-guard.ts
+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);
+      }
+    }
+  }
+}
+var init_completion_guard = __esm(() => {
+  init_types();
+  init_config();
+  init_projects();
+});
+
 // src/db/audit.ts
 var exports_audit = {};
 __export(exports_audit, {
@@ -742,6 +855,96 @@ var init_audit = __esm(() => {
   init_database();
 });
 
+// src/lib/recurrence.ts
+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}"`);
+}
+var DAY_NAMES;
+var init_recurrence = __esm(() => {
+  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
+  };
+});
+
 // src/db/webhooks.ts
 var exports_webhooks = {};
 __export(exports_webhooks, {
@@ -793,847 +996,1215 @@ var init_webhooks = __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
+// src/db/tasks.ts
+var exports_tasks = {};
+__export(exports_tasks, {
+  updateTask: () => updateTask,
+  unlockTask: () => unlockTask,
+  startTask: () => startTask,
+  removeDependency: () => removeDependency,
+  moveTask: () => moveTask,
+  lockTask: () => lockTask,
+  listTasks: () => listTasks,
+  getTasksChangedSince: () => getTasksChangedSince,
+  getTaskWithRelations: () => getTaskWithRelations,
+  getTaskStats: () => getTaskStats,
+  getTaskGraph: () => getTaskGraph,
+  getTaskDependents: () => getTaskDependents,
+  getTaskDependencies: () => getTaskDependencies,
+  getTask: () => getTask,
+  getStatus: () => getStatus,
+  getStaleTasks: () => getStaleTasks,
+  getNextTask: () => getNextTask,
+  getBlockingDeps: () => getBlockingDeps,
+  getActiveWork: () => getActiveWork,
+  failTask: () => failTask,
+  deleteTask: () => deleteTask,
+  createTask: () => createTask,
+  countTasks: () => countTasks,
+  completeTask: () => completeTask,
+  cloneTask: () => cloneTask,
+  claimNextTask: () => claimNextTask,
+  bulkUpdateTasks: () => bulkUpdateTasks,
+  bulkCreateTasks: () => bulkCreateTasks,
+  addDependency: () => addDependency
 });
-function shortUuid() {
-  return crypto.randomUUID().slice(0, 8);
-}
-function rowToAgent(row) {
+function rowToTask(row) {
   return {
     ...row,
-    permissions: JSON.parse(row.permissions || '["*"]'),
-    metadata: JSON.parse(row.metadata || "{}")
+    tags: JSON.parse(row.tags || "[]"),
+    metadata: JSON.parse(row.metadata || "{}"),
+    status: row.status,
+    priority: row.priority,
+    requires_approval: !!row.requires_approval
   };
 }
-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);
+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);
   }
-  const id = shortUuid();
+}
+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();
-  d.run(`INSERT INTO agents (id, name, description, role, title, level, permissions, reports_to, org_id, metadata, created_at, last_seen_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+  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,
-    normalizedName,
+    shortId,
+    input.project_id || null,
+    input.parent_id || null,
+    input.plan_id || null,
+    input.task_list_id || null,
+    title,
     input.description || null,
-    input.role || "agent",
-    input.title || null,
-    input.level || null,
-    JSON.stringify(input.permissions || ["*"]),
-    input.reports_to || null,
-    input.org_id || 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
+    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
   ]);
-  return getAgent(id, d);
+  if (tags.length > 0) {
+    insertTaskTags(id, tags, d);
+  }
+  const task = getTask(id, d);
+  dispatchWebhook("task.created", { id: task.id, short_id: task.short_id, title: task.title, status: task.status, priority: task.priority, project_id: task.project_id, assigned_to: task.assigned_to }, d).catch(() => {});
+  return task;
 }
-function getAgent(id, db) {
+function getTask(id, db) {
   const d = db || getDatabase();
-  const row = d.query("SELECT * FROM agents WHERE id = ?").get(id);
-  return row ? rowToAgent(row) : null;
+  const row = d.query("SELECT * FROM tasks WHERE id = ?").get(id);
+  if (!row)
+    return null;
+  return rowToTask(row);
 }
-function getAgentByName(name, db) {
+function getTaskWithRelations(id, 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;
+  const task = getTask(id, d);
+  if (!task)
+    return null;
+  const subtaskRows = d.query("SELECT * FROM tasks WHERE parent_id = ? ORDER BY created_at").all(id);
+  const subtasks = subtaskRows.map(rowToTask);
+  const depRows = d.query(`SELECT t.* FROM tasks t
+       JOIN task_dependencies td ON td.depends_on = t.id
+       WHERE td.task_id = ?`).all(id);
+  const dependencies = depRows.map(rowToTask);
+  const blockedByRows = d.query(`SELECT t.* FROM tasks t
+       JOIN task_dependencies td ON td.task_id = t.id
+       WHERE td.depends_on = ?`).all(id);
+  const blocked_by = blockedByRows.map(rowToTask);
+  const comments = d.query("SELECT * FROM task_comments WHERE task_id = ? ORDER BY created_at").all(id);
+  const parent = task.parent_id ? getTask(task.parent_id, d) : null;
+  return {
+    ...task,
+    subtasks,
+    dependencies,
+    blocked_by,
+    comments,
+    parent
+  };
 }
-function listAgents(db) {
+function listTasks(filter = {}, db) {
   const d = db || getDatabase();
-  return d.query("SELECT * FROM agents ORDER BY name").all().map(rowToAgent);
+  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 updateAgentActivity(id, db) {
+function countTasks(filter = {}, db) {
   const d = db || getDatabase();
-  d.run("UPDATE agents SET last_seen_at = ? WHERE id = ?", [now(), id]);
+  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);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const row = d.query(`SELECT COUNT(*) as count FROM tasks ${where}`).get(...params);
+  return row.count;
 }
-function updateAgent(id, input, db) {
+function updateTask(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 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.name !== undefined) {
-    sets.push("name = ?");
-    params.push(input.name.trim().toLowerCase());
+  if (input.title !== undefined) {
+    sets.push("title = ?");
+    params.push(input.title);
   }
   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.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.level !== undefined) {
-    sets.push("level = ?");
-    params.push(input.level);
+  if (input.priority !== undefined) {
+    sets.push("priority = ?");
+    params.push(input.priority);
   }
-  if (input.reports_to !== undefined) {
-    sets.push("reports_to = ?");
-    params.push(input.reports_to);
+  if (input.assigned_to !== undefined) {
+    sets.push("assigned_to = ?");
+    params.push(input.assigned_to);
   }
-  if (input.org_id !== undefined) {
-    sets.push("org_id = ?");
-    params.push(input.org_id);
+  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));
   }
-  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);
+  if (input.plan_id !== undefined) {
+    sets.push("plan_id = ?");
+    params.push(input.plan_id);
   }
-  function buildTree(parentId) {
-    const children = byManager.get(parentId) || [];
-    return children.map((a) => ({ agent: a, reports: buildTree(a.id) }));
+  if (input.task_list_id !== undefined) {
+    sets.push("task_list_id = ?");
+    params.push(input.task_list_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);
+  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);
+  if (input.assigned_to !== undefined && input.assigned_to !== task.assigned_to) {
+    dispatchWebhook("task.assigned", { id, assigned_to: input.assigned_to, title: task.title }, d).catch(() => {});
+  }
+  if (input.status !== undefined && input.status !== task.status) {
+    dispatchWebhook("task.status_changed", { id, old_status: task.status, new_status: input.status, title: task.title }, d).catch(() => {});
+  }
+  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 getOrg(id, db) {
+function deleteTask(id, db) {
   const d = db || getDatabase();
-  const row = d.query("SELECT * FROM orgs WHERE id = ?").get(id);
-  return row ? rowToOrg(row) : null;
+  const result = d.run("DELETE FROM tasks WHERE id = ?", [id]);
+  return result.changes > 0;
 }
-function getOrgByName(name, db) {
+function getBlockingDeps(id, db) {
   const d = db || getDatabase();
-  const row = d.query("SELECT * FROM orgs WHERE name = ?").get(name);
-  return row ? rowToOrg(row) : null;
+  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 listOrgs(db) {
+function startTask(id, agentId, db) {
   const d = db || getDatabase();
-  return d.query("SELECT * FROM orgs ORDER BY name").all().map(rowToOrg);
+  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);
+  dispatchWebhook("task.started", { id, agent_id: agentId, title: task.title }, d).catch(() => {});
+  return { ...task, status: "in_progress", assigned_to: agentId, locked_by: agentId, locked_at: timestamp, version: task.version + 1, updated_at: timestamp };
 }
-function updateOrg(id, input, db) {
+function completeTask(id, agentId, db, options) {
   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);
+  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);
   }
-  if (input.description !== undefined) {
-    sets.push("description = ?");
-    params.push(input.description);
+  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, attachment_ids: options.attachment_ids } : undefined;
+  const hasEvidence = evidence && (evidence.files_changed || evidence.test_results || evidence.commit_hash || evidence.notes || evidence.attachment_ids);
+  if (hasEvidence) {
+    const meta2 = { ...task.metadata, _evidence: evidence };
+    d.run("UPDATE tasks SET metadata = ? WHERE id = ?", [JSON.stringify(meta2), id]);
   }
-  if (input.metadata !== undefined) {
-    sets.push("metadata = ?");
-    params.push(JSON.stringify(input.metadata));
+  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);
+  dispatchWebhook("task.completed", { id, agent_id: agentId, title: task.title, completed_at: timestamp }, d).catch(() => {});
+  let spawnedTask = null;
+  if (task.recurrence_rule && !options?.skip_recurrence) {
+    spawnedTask = spawnNextRecurrence(task, d);
   }
-  params.push(id);
-  d.run(`UPDATE orgs SET ${sets.join(", ")} WHERE id = ?`, params);
-  return getOrg(id, 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 deleteOrg(id, db) {
+function lockTask(id, agentId, db) {
   const d = db || getDatabase();
-  return d.run("DELETE FROM orgs WHERE id = ?", [id]).changes > 0;
+  const task = getTask(id, d);
+  if (!task)
+    throw new TaskNotFoundError(id);
+  if (task.locked_by === agentId && !isLockExpired(task.locked_at)) {
+    return { success: true, locked_by: agentId, locked_at: task.locked_at };
+  }
+  const cutoff = lockExpiryCutoff();
+  const timestamp = now();
+  const result = d.run(`UPDATE tasks SET locked_by = ?, locked_at = ?, version = version + 1, updated_at = ?
+     WHERE id = ? AND (locked_by IS NULL OR locked_by = ? OR locked_at < ?)`, [agentId, timestamp, timestamp, id, agentId, cutoff]);
+  if (result.changes === 0) {
+    const current = getTask(id, d);
+    if (!current)
+      throw new TaskNotFoundError(id);
+    if (current.locked_by && !isLockExpired(current.locked_at)) {
+      return {
+        success: false,
+        locked_by: current.locked_by,
+        locked_at: current.locked_at,
+        error: `Task is locked by ${current.locked_by}`
+      };
+    }
+  }
+  return { success: true, locked_by: agentId, locked_at: timestamp };
 }
-var init_orgs = __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 unlockTask(id, agentId, db) {
+  const d = db || getDatabase();
+  const task = getTask(id, d);
+  if (!task)
+    throw new TaskNotFoundError(id);
+  if (agentId && task.locked_by && task.locked_by !== agentId) {
+    throw new LockError(id, task.locked_by);
+  }
+  const timestamp = now();
+  d.run(`UPDATE tasks SET locked_by = NULL, locked_at = NULL, version = version + 1, updated_at = ?
+     WHERE id = ?`, [timestamp, id]);
+  return true;
 }
-function createTemplate(input, db) {
+function addDependency(taskId, dependsOn, 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);
+  if (!getTask(taskId, d))
+    throw new TaskNotFoundError(taskId);
+  if (!getTask(dependsOn, d))
+    throw new TaskNotFoundError(dependsOn);
+  if (wouldCreateCycle(taskId, dependsOn, d)) {
+    throw new DependencyCycleError(taskId, dependsOn);
+  }
+  d.run("INSERT OR IGNORE INTO task_dependencies (task_id, depends_on) VALUES (?, ?)", [taskId, dependsOn]);
 }
-function getTemplate(id, db) {
+function removeDependency(taskId, dependsOn, db) {
   const d = db || getDatabase();
-  const row = d.query("SELECT * FROM task_templates WHERE id = ?").get(id);
-  return row ? rowToTemplate(row) : null;
+  const result = d.run("DELETE FROM task_dependencies WHERE task_id = ? AND depends_on = ?", [taskId, dependsOn]);
+  return result.changes > 0;
 }
-function listTemplates(db) {
+function getTaskDependencies(taskId, db) {
   const d = db || getDatabase();
-  return d.query("SELECT * FROM task_templates ORDER BY name").all().map(rowToTemplate);
+  return d.query("SELECT * FROM task_dependencies WHERE task_id = ?").all(taskId);
 }
-function deleteTemplate(id, db) {
+function getTaskDependents(taskId, db) {
   const d = db || getDatabase();
-  return d.run("DELETE FROM task_templates WHERE id = ?", [id]).changes > 0;
+  return d.query("SELECT * FROM task_dependencies WHERE depends_on = ?").all(taskId);
 }
-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
+function cloneTask(taskId, overrides, db) {
+  const d = db || getDatabase();
+  const source = getTask(taskId, d);
+  if (!source)
+    throw new TaskNotFoundError(taskId);
+  const input = {
+    title: overrides?.title ?? source.title,
+    description: overrides?.description ?? source.description ?? undefined,
+    priority: overrides?.priority ?? source.priority,
+    project_id: overrides?.project_id ?? source.project_id ?? undefined,
+    parent_id: overrides?.parent_id ?? source.parent_id ?? undefined,
+    plan_id: overrides?.plan_id ?? source.plan_id ?? undefined,
+    task_list_id: overrides?.task_list_id ?? source.task_list_id ?? undefined,
+    status: overrides?.status ?? "pending",
+    agent_id: overrides?.agent_id ?? source.agent_id ?? undefined,
+    assigned_to: overrides?.assigned_to ?? source.assigned_to ?? undefined,
+    tags: overrides?.tags ?? source.tags,
+    metadata: overrides?.metadata ?? source.metadata,
+    estimated_minutes: overrides?.estimated_minutes ?? source.estimated_minutes ?? undefined,
+    recurrence_rule: overrides?.recurrence_rule ?? source.recurrence_rule ?? undefined
   };
+  return createTask(input, d);
 }
-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;
+function getTaskGraph(taskId, direction = "both", db) {
+  const d = db || getDatabase();
+  const task = getTask(taskId, d);
+  if (!task)
+    throw new TaskNotFoundError(taskId);
+  function toNode(t) {
+    const deps = getTaskDependencies(t.id, d);
+    const hasUnfinishedDeps = deps.some((dep) => {
+      const depTask = getTask(dep.depends_on, d);
+      return depTask && depTask.status !== "completed";
+    });
+    return { id: t.id, short_id: t.short_id, title: t.title, status: t.status, priority: t.priority, is_blocked: hasUnfinishedDeps };
+  }
+  function buildUp(id, visited) {
+    if (visited.has(id))
+      return [];
+    visited.add(id);
+    const deps = d.query("SELECT depends_on FROM task_dependencies WHERE task_id = ?").all(id);
+    return deps.map((dep) => {
+      const depTask = getTask(dep.depends_on, d);
+      if (!depTask)
+        return null;
+      return { task: toNode(depTask), depends_on: buildUp(dep.depends_on, visited), blocks: [] };
+    }).filter(Boolean);
+  }
+  function buildDown(id, visited) {
+    if (visited.has(id))
+      return [];
+    visited.add(id);
+    const dependents = d.query("SELECT task_id FROM task_dependencies WHERE depends_on = ?").all(id);
+    return dependents.map((dep) => {
+      const depTask = getTask(dep.task_id, d);
+      if (!depTask)
+        return null;
+      return { task: toNode(depTask), depends_on: [], blocks: buildDown(dep.task_id, visited) };
+    }).filter(Boolean);
+  }
+  const rootNode = toNode(task);
+  const depends_on = direction === "up" || direction === "both" ? buildUp(taskId, new Set) : [];
+  const blocks = direction === "down" || direction === "both" ? buildDown(taskId, new Set) : [];
+  return { task: rootNode, depends_on, blocks };
+}
+function moveTask(taskId, target, db) {
+  const d = db || getDatabase();
+  const task = getTask(taskId, d);
+  if (!task)
+    throw new TaskNotFoundError(taskId);
+  const sets = ["updated_at = ?", "version = version + 1"];
+  const params = [now()];
+  if (target.task_list_id !== undefined) {
+    sets.push("task_list_id = ?");
+    params.push(target.task_list_id);
   }
-}
-
-// 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;
+  if (target.project_id !== undefined) {
+    sets.push("project_id = ?");
+    params.push(target.project_id);
   }
-  const config = readJsonFile(CONFIG_PATH) || {};
-  if (typeof config.sync_agents === "string") {
-    config.sync_agents = config.sync_agents.split(",").map((a) => a.trim()).filter(Boolean);
+  if (target.plan_id !== undefined) {
+    sets.push("plan_id = ?");
+    params.push(target.plan_id);
   }
-  cached = config;
-  return cached;
+  params.push(taskId);
+  d.run(`UPDATE tasks SET ${sets.join(", ")} WHERE id = ?`, params);
+  return getTask(taskId, d);
 }
-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 };
+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);
   }
-  return global;
+  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/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);
+function claimNextTask(agentId, filters, db) {
+  const d = db || getDatabase();
+  const tx = d.transaction(() => {
+    const task = getNextTask(agentId, filters, d);
+    if (!task)
+      return null;
+    return startTask(task.id, agentId, d);
+  });
+  return tx();
+}
+function getNextTask(agentId, filters, db) {
+  const d = db || getDatabase();
+  clearExpiredLocks(d);
+  const conditions = ["status = 'pending'", "(locked_by IS NULL OR locked_at < ?)"];
+  const params = [lockExpiryCutoff()];
+  if (filters?.project_id) {
+    conditions.push("project_id = ?");
+    params.push(filters.project_id);
   }
-  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.`);
+  if (filters?.task_list_id) {
+    conditions.push("task_list_id = ?");
+    params.push(filters.task_list_id);
   }
-  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 (filters?.plan_id) {
+    conditions.push("plan_id = ?");
+    params.push(filters.plan_id);
   }
-  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 (filters?.tags && filters.tags.length > 0) {
+    const placeholders = filters.tags.map(() => "?").join(",");
+    conditions.push(`id IN (SELECT task_id FROM task_tags WHERE tag IN (${placeholders}))`);
+    params.push(...filters.tags);
   }
-  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);
-      }
-    }
+  conditions.push("id NOT IN (SELECT td.task_id FROM task_dependencies td JOIN tasks dep ON dep.id = td.depends_on WHERE dep.status != 'completed')");
+  const where = conditions.join(" AND ");
+  let sql = `SELECT * FROM tasks WHERE ${where} ORDER BY `;
+  if (agentId) {
+    sql += `CASE WHEN assigned_to = ? THEN 0 WHEN assigned_to IS NULL THEN 1 ELSE 2 END, `;
+    params.push(agentId);
   }
+  sql += `CASE priority WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 WHEN 'low' THEN 3 END, created_at ASC LIMIT 1`;
+  const row = d.query(sql).get(...params);
+  return row ? rowToTask(row) : null;
 }
-
-// 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" };
+function getActiveWork(filters, db) {
+  const d = db || getDatabase();
+  clearExpiredLocks(d);
+  const conditions = ["status = 'in_progress'"];
+  const params = [];
+  if (filters?.project_id) {
+    conditions.push("project_id = ?");
+    params.push(filters.project_id);
   }
-  if (normalized === "every week" || normalized === "weekly") {
-    return { type: "interval", interval: 1, unit: "week" };
+  if (filters?.task_list_id) {
+    conditions.push("task_list_id = ?");
+    params.push(filters.task_list_id);
   }
-  if (normalized === "every month" || normalized === "monthly") {
-    return { type: "interval", interval: 1, unit: "month" };
+  const where = conditions.join(" AND ");
+  const rows = d.query(`SELECT id, short_id, title, priority, assigned_to, locked_by, locked_at, updated_at FROM tasks WHERE ${where} ORDER BY
+    CASE priority WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 WHEN 'low' THEN 3 END,
+    updated_at DESC`).all(...params);
+  return rows;
+}
+function getTasksChangedSince(since, filters, db) {
+  const d = db || getDatabase();
+  const conditions = ["updated_at > ?"];
+  const params = [since];
+  if (filters?.project_id) {
+    conditions.push("project_id = ?");
+    params.push(filters.project_id);
   }
-  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]
-    };
+  if (filters?.task_list_id) {
+    conditions.push("task_list_id = ?");
+    params.push(filters.task_list_id);
   }
-  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);
-      }
+  const where = conditions.join(" AND ");
+  const rows = d.query(`SELECT * FROM tasks WHERE ${where} ORDER BY updated_at DESC`).all(...params);
+  return rows.map(rowToTask);
+}
+function failTask(id, agentId, reason, options, db) {
+  const d = db || getDatabase();
+  const task = getTask(id, d);
+  if (!task)
+    throw new TaskNotFoundError(id);
+  const meta = {
+    ...task.metadata,
+    _failure: {
+      reason: reason || "Unknown failure",
+      error_code: options?.error_code || null,
+      failed_by: agentId || null,
+      failed_at: now(),
+      retry_requested: options?.retry || false
     }
-    if (days.length > 0) {
-      return { type: "specific_days", days: days.sort((a, b) => a - b) };
+  };
+  const timestamp = now();
+  d.run(`UPDATE tasks SET status = 'failed', locked_by = NULL, locked_at = NULL, metadata = ?, version = version + 1, updated_at = ?
+     WHERE id = ?`, [JSON.stringify(meta), timestamp, id]);
+  logTaskChange(id, "fail", "status", task.status, "failed", agentId || null, d);
+  dispatchWebhook("task.failed", { id, reason, error_code: options?.error_code, agent_id: agentId, title: task.title }, d).catch(() => {});
+  const failedTask = {
+    ...task,
+    status: "failed",
+    locked_by: null,
+    locked_at: null,
+    metadata: meta,
+    version: task.version + 1,
+    updated_at: timestamp
+  };
+  let retryTask;
+  if (options?.retry) {
+    let title = task.title;
+    if (task.short_id && title.startsWith(task.short_id + ": ")) {
+      title = title.slice(task.short_id.length + 2);
     }
+    retryTask = createTask({
+      title,
+      description: task.description ?? undefined,
+      priority: task.priority,
+      project_id: task.project_id ?? undefined,
+      task_list_id: task.task_list_id ?? undefined,
+      plan_id: task.plan_id ?? undefined,
+      assigned_to: task.assigned_to ?? undefined,
+      tags: task.tags,
+      metadata: { ...task.metadata, _retry: { original_id: task.id, retry_after: options.retry_after || null, failure_reason: reason } },
+      estimated_minutes: task.estimated_minutes ?? undefined,
+      recurrence_rule: task.recurrence_rule ?? undefined,
+      due_at: options.retry_after || task.due_at || undefined
+    }, d);
+  }
+  return { task: failedTask, retryTask };
+}
+function getStaleTasks(staleMinutes = 30, filters, db) {
+  const d = db || getDatabase();
+  const cutoff = new Date(Date.now() - staleMinutes * 60 * 1000).toISOString();
+  const conditions = [
+    "status = 'in_progress'",
+    "(updated_at < ? OR (locked_at IS NOT NULL AND locked_at < ?))"
+  ];
+  const params = [cutoff, cutoff];
+  if (filters?.project_id) {
+    conditions.push("project_id = ?");
+    params.push(filters.project_id);
   }
-  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"`);
+  if (filters?.task_list_id) {
+    conditions.push("task_list_id = ?");
+    params.push(filters.task_list_id);
+  }
+  const where = conditions.join(" AND ");
+  const rows = d.query(`SELECT * FROM tasks WHERE ${where} ORDER BY updated_at ASC`).all(...params);
+  return rows.map(rowToTask);
 }
-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();
+function getStatus(filters, agentId, db) {
+  const d = db || getDatabase();
+  const pending = countTasks({ ...filters, status: "pending" }, d);
+  const in_progress = countTasks({ ...filters, status: "in_progress" }, d);
+  const completed = countTasks({ ...filters, status: "completed" }, d);
+  const total = countTasks(filters || {}, d);
+  const active_work = getActiveWork(filters, d);
+  const next_task = getNextTask(agentId, filters, d);
+  const stale = getStaleTasks(30, filters, d);
+  const conditions = ["recurrence_rule IS NOT NULL", "status = 'pending'", "due_at < ?"];
+  const params = [now()];
+  if (filters?.project_id) {
+    conditions.push("project_id = ?");
+    params.push(filters.project_id);
   }
-  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();
+  if (filters?.task_list_id) {
+    conditions.push("task_list_id = ?");
+    params.push(filters.task_list_id);
   }
-  throw new Error(`Cannot calculate next occurrence for rule: "${rule}"`);
-}
-
-// src/db/tasks.ts
-init_webhooks();
-function rowToTask(row) {
+  const overdueRow = d.query(`SELECT COUNT(*) as count FROM tasks WHERE ${conditions.join(" AND ")}`).get(...params);
   return {
-    ...row,
-    tags: JSON.parse(row.tags || "[]"),
-    metadata: JSON.parse(row.metadata || "{}"),
-    status: row.status,
-    priority: row.priority,
-    requires_approval: !!row.requires_approval
+    pending,
+    in_progress,
+    completed,
+    total,
+    active_work,
+    next_task,
+    stale_count: stale.length,
+    overdue_recurring: overdueRow.count
   };
 }
-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 wouldCreateCycle(taskId, dependsOn, db) {
+  const visited = new Set;
+  const queue = [dependsOn];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (current === taskId)
+      return true;
+    if (visited.has(current))
+      continue;
+    visited.add(current);
+    const deps = db.query("SELECT depends_on FROM task_dependencies WHERE task_id = ?").all(current);
+    for (const dep of deps) {
+      queue.push(dep.depends_on);
+    }
   }
+  return false;
 }
-function replaceTaskTags(taskId, tags, db) {
-  db.run("DELETE FROM task_tags WHERE task_id = ?", [taskId]);
-  insertTaskTags(taskId, tags, db);
+function getTaskStats(filters, db) {
+  const d = db || getDatabase();
+  const conditions = [];
+  const params = [];
+  if (filters?.project_id) {
+    conditions.push("project_id = ?");
+    params.push(filters.project_id);
+  }
+  if (filters?.task_list_id) {
+    conditions.push("task_list_id = ?");
+    params.push(filters.task_list_id);
+  }
+  if (filters?.agent_id) {
+    conditions.push("(agent_id = ? OR assigned_to = ?)");
+    params.push(filters.agent_id, filters.agent_id);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const totalRow = d.query(`SELECT COUNT(*) as count FROM tasks ${where}`).get(...params);
+  const statusRows = d.query(`SELECT status, COUNT(*) as count FROM tasks ${where} GROUP BY status`).all(...params);
+  const by_status = {};
+  for (const r of statusRows)
+    by_status[r.status] = r.count;
+  const priorityRows = d.query(`SELECT priority, COUNT(*) as count FROM tasks ${where} GROUP BY priority`).all(...params);
+  const by_priority = {};
+  for (const r of priorityRows)
+    by_priority[r.priority] = r.count;
+  const agentRows = d.query(`SELECT COALESCE(assigned_to, agent_id, 'unassigned') as agent, COUNT(*) as count FROM tasks ${where} GROUP BY agent`).all(...params);
+  const by_agent = {};
+  for (const r of agentRows)
+    by_agent[r.agent] = r.count;
+  const completed = by_status["completed"] || 0;
+  const completion_rate = totalRow.count > 0 ? Math.round(completed / totalRow.count * 100) : 0;
+  return { total: totalRow.count, by_status, by_priority, completion_rate, by_agent };
+}
+function bulkCreateTasks(inputs, db) {
+  const d = db || getDatabase();
+  const tempIdToRealId = new Map;
+  const created = [];
+  const tx = d.transaction(() => {
+    for (const input of inputs) {
+      const { temp_id, depends_on_temp_ids: _deps, ...createInput } = input;
+      const task = createTask(createInput, d);
+      if (temp_id)
+        tempIdToRealId.set(temp_id, task.id);
+      created.push({ temp_id: temp_id || null, id: task.id, short_id: task.short_id, title: task.title });
+    }
+    for (const input of inputs) {
+      if (input.depends_on_temp_ids && input.depends_on_temp_ids.length > 0) {
+        const taskId = input.temp_id ? tempIdToRealId.get(input.temp_id) : null;
+        if (!taskId)
+          continue;
+        for (const depTempId of input.depends_on_temp_ids) {
+          const depRealId = tempIdToRealId.get(depTempId);
+          if (depRealId) {
+            addDependency(taskId, depRealId, d);
+          }
+        }
+      }
+    }
+  });
+  tx();
+  return { created };
 }
-function createTask(input, db) {
+function bulkUpdateTasks(taskIds, updates, 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),
+  let updated = 0;
+  const failed = [];
+  const tx = d.transaction(() => {
+    for (const id of taskIds) {
+      try {
+        const task = getTask(id, d);
+        if (!task) {
+          failed.push({ id, error: "Task not found" });
+          continue;
+        }
+        updateTask(id, { ...updates, version: task.version }, d);
+        updated++;
+      } catch (e) {
+        failed.push({ id, error: e instanceof Error ? e.message : String(e) });
+      }
+    }
+  });
+  tx();
+  return { updated, failed };
+}
+var init_tasks = __esm(() => {
+  init_types();
+  init_database();
+  init_projects();
+  init_completion_guard();
+  init_audit();
+  init_recurrence();
+  init_webhooks();
+});
+
+// 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,
-    input.due_at || null,
-    input.estimated_minutes || null,
-    input.requires_approval ? 1 : 0,
-    null,
-    null,
-    input.recurrence_rule || null,
-    input.recurrence_parent_id || null
+    timestamp
   ]);
-  if (tags.length > 0) {
-    insertTaskTags(id, tags, d);
-  }
-  const task = getTask(id, d);
-  dispatchWebhook("task.created", { id: task.id, short_id: task.short_id, title: task.title, status: task.status, priority: task.priority, project_id: task.project_id, assigned_to: task.assigned_to }, d).catch(() => {});
-  return task;
+  return getAgent(id, d);
 }
-function getTask(id, db) {
+function getAgent(id, db) {
   const d = db || getDatabase();
-  const row = d.query("SELECT * FROM tasks WHERE id = ?").get(id);
-  if (!row)
-    return null;
-  return rowToTask(row);
+  const row = d.query("SELECT * FROM agents WHERE id = ?").get(id);
+  return row ? rowToAgent(row) : null;
 }
-function listTasks(filter = {}, db) {
+function getAgentByName(name, 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);
-    }
+  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 (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 (input.description !== undefined) {
+    sets.push("description = ?");
+    params.push(input.description);
   }
-  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 (input.role !== undefined) {
+    sets.push("role = ?");
+    params.push(input.role);
   }
-  if (filter.assigned_to) {
-    conditions.push("assigned_to = ?");
-    params.push(filter.assigned_to);
+  if (input.permissions !== undefined) {
+    sets.push("permissions = ?");
+    params.push(JSON.stringify(input.permissions));
   }
-  if (filter.agent_id) {
-    conditions.push("agent_id = ?");
-    params.push(filter.agent_id);
+  if (input.title !== undefined) {
+    sets.push("title = ?");
+    params.push(input.title);
   }
-  if (filter.session_id) {
-    conditions.push("session_id = ?");
-    params.push(filter.session_id);
+  if (input.level !== undefined) {
+    sets.push("level = ?");
+    params.push(input.level);
   }
-  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 (input.reports_to !== undefined) {
+    sets.push("reports_to = ?");
+    params.push(input.reports_to);
   }
-  if (filter.plan_id) {
-    conditions.push("plan_id = ?");
-    params.push(filter.plan_id);
+  if (input.org_id !== undefined) {
+    sets.push("org_id = ?");
+    params.push(input.org_id);
   }
-  if (filter.task_list_id) {
-    conditions.push("task_list_id = ?");
-    params.push(filter.task_list_id);
+  if (input.metadata !== undefined) {
+    sets.push("metadata = ?");
+    params.push(JSON.stringify(input.metadata));
   }
-  if (filter.has_recurrence === true) {
-    conditions.push("recurrence_rule IS NOT NULL");
-  } else if (filter.has_recurrence === false) {
-    conditions.push("recurrence_rule IS NULL");
+  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);
   }
-  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);
-    }
+  function buildTree(parentId) {
+    const children = byManager.get(parentId) || [];
+    return children.map((a) => ({ agent: a, reports: buildTree(a.id) }));
   }
-  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);
+  return buildTree(null);
 }
-function updateTask(id, input, db) {
+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 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 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.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.name !== undefined) {
+    sets.push("name = ?");
+    params.push(input.name);
   }
-  if (input.tags !== undefined) {
-    sets.push("tags = ?");
-    params.push(JSON.stringify(input.tags));
+  if (input.description !== undefined) {
+    sets.push("description = ?");
+    params.push(input.description);
   }
   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);
-  if (input.assigned_to !== undefined && input.assigned_to !== task.assigned_to) {
-    dispatchWebhook("task.assigned", { id, assigned_to: input.assigned_to, title: task.title }, d).catch(() => {});
-  }
-  if (input.status !== undefined && input.status !== task.status) {
-    dispatchWebhook("task.status_changed", { id, old_status: task.status, new_status: input.status, title: task.title }, d).catch(() => {});
-  }
-  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
-  };
+  params.push(id);
+  d.run(`UPDATE orgs SET ${sets.join(", ")} WHERE id = ?`, params);
+  return getOrg(id, d);
 }
-function deleteTask(id, db) {
+function deleteOrg(id, db) {
   const d = db || getDatabase();
-  const result = d.run("DELETE FROM tasks WHERE id = ?", [id]);
-  return result.changes > 0;
+  return d.run("DELETE FROM orgs WHERE id = ?", [id]).changes > 0;
 }
-function getBlockingDeps(id, db) {
+var init_orgs = __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 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;
+  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 startTask(id, agentId, db) {
+function getTemplate(id, 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);
-  dispatchWebhook("task.started", { id, agent_id: agentId, title: task.title }, d).catch(() => {});
-  return { ...task, status: "in_progress", assigned_to: agentId, locked_by: agentId, locked_at: timestamp, version: task.version + 1, updated_at: timestamp };
+  const row = d.query("SELECT * FROM task_templates WHERE id = ?").get(id);
+  return row ? rowToTemplate(row) : null;
 }
-function completeTask(id, agentId, db, options) {
+function listTemplates(db) {
   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);
-  dispatchWebhook("task.completed", { id, agent_id: agentId, title: task.title, completed_at: timestamp }, d).catch(() => {});
-  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 };
+  return d.query("SELECT * FROM task_templates ORDER BY name").all().map(rowToTemplate);
 }
-function getTaskDependencies(taskId, db) {
+function deleteTemplate(id, db) {
   const d = db || getDatabase();
-  return d.query("SELECT * FROM task_dependencies WHERE task_id = ?").all(taskId);
+  return d.run("DELETE FROM task_templates WHERE id = ?", [id]).changes > 0;
 }
-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);
+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
+init_tasks();
 init_projects();
 init_agents();
+import { existsSync as existsSync4 } from "fs";
+import { join as join3, dirname as dirname2, extname } from "path";
+import { fileURLToPath } from "url";
 
 // src/db/plans.ts
 init_types();
@@ -1954,6 +2525,62 @@ Dashboard not found at: ${dashboardDir}`);
           return json({ error: e instanceof Error ? e.message : "Failed" }, 500, port);
         }
       }
+      if (path === "/api/tasks/status" && method === "GET") {
+        try {
+          const projectId = url.searchParams.get("project_id") || undefined;
+          const agentId = url.searchParams.get("agent_id") || undefined;
+          const { getStatus: getStatus2 } = await Promise.resolve().then(() => (init_tasks(), exports_tasks));
+          const status = getStatus2(projectId ? { project_id: projectId } : undefined, agentId);
+          return json(status, 200, port);
+        } catch (e) {
+          return json({ error: e instanceof Error ? e.message : "Failed" }, 500, port);
+        }
+      }
+      if (path === "/api/tasks/next" && method === "GET") {
+        try {
+          const projectId = url.searchParams.get("project_id") || undefined;
+          const agentId = url.searchParams.get("agent_id") || undefined;
+          const { getNextTask: getNextTask2 } = await Promise.resolve().then(() => (init_tasks(), exports_tasks));
+          const task = getNextTask2(agentId, projectId ? { project_id: projectId } : undefined);
+          return json({ task: task ? taskToSummary(task) : null }, 200, port);
+        } catch (e) {
+          return json({ error: e instanceof Error ? e.message : "Failed" }, 500, port);
+        }
+      }
+      if (path === "/api/tasks/active" && method === "GET") {
+        try {
+          const projectId = url.searchParams.get("project_id") || undefined;
+          const { getActiveWork: getActiveWork2 } = await Promise.resolve().then(() => (init_tasks(), exports_tasks));
+          const work = getActiveWork2(projectId ? { project_id: projectId } : undefined);
+          return json({ active: work, count: work.length }, 200, port);
+        } catch (e) {
+          return json({ error: e instanceof Error ? e.message : "Failed" }, 500, port);
+        }
+      }
+      if (path === "/api/tasks/stale" && method === "GET") {
+        try {
+          const projectId = url.searchParams.get("project_id") || undefined;
+          const minutes = parseInt(url.searchParams.get("minutes") || "30", 10);
+          const { getStaleTasks: getStaleTasks2 } = await Promise.resolve().then(() => (init_tasks(), exports_tasks));
+          const tasks = getStaleTasks2(minutes, projectId ? { project_id: projectId } : undefined);
+          return json({ tasks: tasks.map((t) => taskToSummary(t)), count: tasks.length }, 200, port);
+        } catch (e) {
+          return json({ error: e instanceof Error ? e.message : "Failed" }, 500, port);
+        }
+      }
+      if (path === "/api/tasks/changed" && method === "GET") {
+        try {
+          const since = url.searchParams.get("since");
+          if (!since)
+            return json({ error: "since parameter required (ISO date string)" }, 400, port);
+          const projectId = url.searchParams.get("project_id") || undefined;
+          const { getTasksChangedSince: getTasksChangedSince2 } = await Promise.resolve().then(() => (init_tasks(), exports_tasks));
+          const tasks = getTasksChangedSince2(since, projectId ? { project_id: projectId } : undefined);
+          return json({ tasks: tasks.map((t) => taskToSummary(t)), count: tasks.length, since }, 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];
@@ -2048,25 +2675,9 @@ Dashboard not found at: ${dashboardDir}`);
         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);
-          }
+          const { claimNextTask: claimNextTask2 } = await Promise.resolve().then(() => (init_tasks(), exports_tasks));
+          const task = claimNextTask2(agentId, body.project_id ? { project_id: body.project_id } : undefined);
+          return json({ task: task ? taskToSummary(task) : null }, 200, port);
         } catch (e) {
           return json({ error: e instanceof Error ? e.message : "Failed to claim" }, 500, port);
         }