@hasna/todos 0.9.34 → 0.9.35

package/dist/index.js

@@ -283,6 +283,13 @@ var MIGRATIONS = [
   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);
   `
 ];
 var _db = null;
@@ -409,6 +416,8 @@ function ensureSchema(db) {
   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");
@@ -433,6 +442,8 @@ function ensureSchema(db) {
   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 {
@@ -533,6 +544,8 @@ 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;
@@ -544,6 +557,8 @@ class VersionConflictError extends Error {
 
 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;
@@ -553,6 +568,8 @@ class TaskNotFoundError extends Error {
 
 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;
@@ -562,6 +579,8 @@ class ProjectNotFoundError extends Error {
 
 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;
@@ -572,6 +591,8 @@ class PlanNotFoundError extends Error {
 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;
@@ -582,6 +603,8 @@ class LockError extends Error {
 
 class AgentNotFoundError extends Error {
   agentId;
+  static code = "AGENT_NOT_FOUND";
+  static suggestion = "Use register_agent to create the agent first, or list_agents to find existing ones.";
   constructor(agentId) {
     super(`Agent not found: ${agentId}`);
     this.agentId = agentId;
@@ -591,6 +614,8 @@ class AgentNotFoundError extends Error {
 
 class TaskListNotFoundError extends Error {
   taskListId;
+  static code = "TASK_LIST_NOT_FOUND";
+  static suggestion = "Use list_task_lists to see available lists.";
   constructor(taskListId) {
     super(`Task list not found: ${taskListId}`);
     this.taskListId = taskListId;
@@ -601,6 +626,8 @@ class TaskListNotFoundError extends Error {
 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;
@@ -612,6 +639,8 @@ class DependencyCycleError extends Error {
 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;
@@ -891,6 +920,101 @@ function getRecentActivity(limit = 50, db) {
   return d.query("SELECT * FROM task_history ORDER BY created_at DESC LIMIT ?").all(limit);
 }
 
+// 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 isValidRecurrenceRule(rule) {
+  try {
+    parseRecurrenceRule(rule);
+    return true;
+  } catch {
+    return false;
+  }
+}
+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 {
@@ -922,8 +1046,8 @@ function createTask(input, db) {
   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)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?, ?, ?, ?, ?, ?)`, [
+  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,
@@ -946,7 +1070,9 @@ function createTask(input, db) {
     input.estimated_minutes || null,
     input.requires_approval ? 1 : 0,
     null,
-    null
+    null,
+    input.recurrence_rule || null,
+    input.recurrence_parent_id || null
   ]);
   if (tags.length > 0) {
     insertTaskTags(id, tags, d);
@@ -1046,6 +1172,11 @@ function listTasks(filter = {}, db) {
     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) {
@@ -1061,6 +1192,69 @@ function listTasks(filter = {}, db) {
        created_at DESC${limitClause}`).all(...params);
   return rows.map(rowToTask);
 }
+function countTasks(filter = {}, db) {
+  const d = db || getDatabase();
+  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 updateTask(id, input, db) {
   const d = db || getDatabase();
   const task = getTask(id, d);
@@ -1132,6 +1326,10 @@ function updateTask(id, input, db) {
     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) {
@@ -1205,7 +1403,7 @@ function startTask(id, agentId, db) {
   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, evidence) {
+function completeTask(id, agentId, db, options) {
   const d = db || getDatabase();
   const task = getTask(id, d);
   if (!task)
@@ -1214,7 +1412,9 @@ function completeTask(id, agentId, db, evidence) {
     throw new LockError(id, task.locked_by);
   }
   checkCompletionGuard(task, agentId || null, d);
-  if (evidence) {
+  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]);
   }
@@ -1222,7 +1422,14 @@ function completeTask(id, agentId, db, evidence) {
   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);
-  const meta = evidence ? { ...task.metadata, _evidence: evidence } : task.metadata;
+  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 lockTask(id, agentId, db) {
@@ -1289,6 +1496,266 @@ function getTaskDependents(taskId, db) {
   const d = db || getDatabase();
   return d.query("SELECT * FROM task_dependencies WHERE depends_on = ?").all(taskId);
 }
+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);
+}
+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);
+  }
+  if (target.project_id !== undefined) {
+    sets.push("project_id = ?");
+    params.push(target.project_id);
+  }
+  if (target.plan_id !== undefined) {
+    sets.push("plan_id = ?");
+    params.push(target.plan_id);
+  }
+  params.push(taskId);
+  d.run(`UPDATE tasks SET ${sets.join(", ")} WHERE id = ?`, params);
+  return getTask(taskId, d);
+}
+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 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 (filters?.task_list_id) {
+    conditions.push("task_list_id = ?");
+    params.push(filters.task_list_id);
+  }
+  if (filters?.plan_id) {
+    conditions.push("plan_id = ?");
+    params.push(filters.plan_id);
+  }
+  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);
+  }
+  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;
+}
+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 (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 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);
+  }
+  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 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
+    }
+  };
+  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);
+  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);
+  }
+  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 wouldCreateCycle(taskId, dependsOn, db) {
   const visited = new Set;
   const queue = [dependsOn];
@@ -1306,6 +1773,91 @@ function wouldCreateCycle(taskId, dependsOn, db) {
   }
   return false;
 }
+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 bulkUpdateTasks(taskIds, updates, db) {
+  const d = db || getDatabase();
+  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 };
+}
 // src/db/plans.ts
 function createPlan(input, db) {
   const d = db || getDatabase();
@@ -1811,19 +2363,64 @@ function rowToTask2(row) {
     requires_approval: Boolean(row.requires_approval)
   };
 }
-function searchTasks(query, projectId, taskListId, db) {
+function searchTasks(options, projectId, taskListId, db) {
+  const opts = typeof options === "string" ? { query: options, project_id: projectId, task_list_id: taskListId } : options;
   const d = db || getDatabase();
   clearExpiredLocks(d);
-  const pattern = `%${query}%`;
+  const pattern = `%${opts.query}%`;
   let sql = `SELECT * FROM tasks WHERE (title LIKE ? OR description LIKE ? OR EXISTS (SELECT 1 FROM task_tags WHERE task_tags.task_id = tasks.id AND tag LIKE ?))`;
   const params = [pattern, pattern, pattern];
-  if (projectId) {
+  if (opts.project_id) {
     sql += " AND project_id = ?";
-    params.push(projectId);
+    params.push(opts.project_id);
   }
-  if (taskListId) {
+  if (opts.task_list_id) {
     sql += " AND task_list_id = ?";
-    params.push(taskListId);
+    params.push(opts.task_list_id);
+  }
+  if (opts.status) {
+    if (Array.isArray(opts.status)) {
+      sql += ` AND status IN (${opts.status.map(() => "?").join(",")})`;
+      params.push(...opts.status);
+    } else {
+      sql += " AND status = ?";
+      params.push(opts.status);
+    }
+  }
+  if (opts.priority) {
+    if (Array.isArray(opts.priority)) {
+      sql += ` AND priority IN (${opts.priority.map(() => "?").join(",")})`;
+      params.push(...opts.priority);
+    } else {
+      sql += " AND priority = ?";
+      params.push(opts.priority);
+    }
+  }
+  if (opts.assigned_to) {
+    sql += " AND assigned_to = ?";
+    params.push(opts.assigned_to);
+  }
+  if (opts.agent_id) {
+    sql += " AND agent_id = ?";
+    params.push(opts.agent_id);
+  }
+  if (opts.created_after) {
+    sql += " AND created_at > ?";
+    params.push(opts.created_after);
+  }
+  if (opts.updated_after) {
+    sql += " AND updated_at > ?";
+    params.push(opts.updated_after);
+  }
+  if (opts.has_dependencies === true) {
+    sql += " AND id IN (SELECT task_id FROM task_dependencies)";
+  } else if (opts.has_dependencies === false) {
+    sql += " AND id NOT IN (SELECT task_id FROM task_dependencies)";
+  }
+  if (opts.is_blocked === true) {
+    sql += " AND id IN (SELECT td.task_id FROM task_dependencies td JOIN tasks dep ON dep.id = td.depends_on WHERE dep.status != 'completed')";
+  } else if (opts.is_blocked === false) {
+    sql += " AND id NOT IN (SELECT td.task_id FROM task_dependencies td JOIN tasks dep ON dep.id = td.depends_on WHERE dep.status != 'completed')";
   }
   sql += ` ORDER BY
     CASE priority WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 WHEN 'low' THEN 3 END,
@@ -2368,8 +2965,11 @@ export {
   resetDatabase,
   removeDependency,
   registerAgent,
+  parseRecurrenceRule,
   now,
   nextTaskShortId,
+  nextOccurrence,
+  moveTask,
   logTaskChange,
   lockTask,
   loadConfig,
@@ -2383,15 +2983,20 @@ export {
   listOrgs,
   listComments,
   listAgents,
+  isValidRecurrenceRule,
   getWebhook,
   getTemplate,
+  getTasksChangedSince,
   getTaskWithRelations,
+  getTaskStats,
   getTaskListBySlug,
   getTaskList,
   getTaskHistory,
+  getTaskGraph,
   getTaskDependents,
   getTaskDependencies,
   getTask,
+  getStaleTasks,
   getSession,
   getRecentActivity,
   getProjectByPath,
@@ -2400,6 +3005,7 @@ export {
   getOrgChart,
   getOrgByName,
   getOrg,
+  getNextTask,
   getDirectReports,
   getDatabase,
   getCompletionGuardConfig,
@@ -2407,6 +3013,8 @@ export {
   getBlockingDeps,
   getAgentByName,
   getAgent,
+  getActiveWork,
+  failTask,
   ensureTaskList,
   ensureProject,
   dispatchWebhook,
@@ -2429,9 +3037,14 @@ export {
   createProject,
   createPlan,
   createOrg,
+  countTasks,
   completeTask,
   closeDatabase,
+  cloneTask,
+  claimNextTask,
   checkCompletionGuard,
+  bulkUpdateTasks,
+  bulkCreateTasks,
   addDependency,
   addComment,
   VersionConflictError,