@hasna/todos 0.11.82 → 0.11.84

package/dist/cli/index.js

@@ -8580,9 +8580,277 @@ async function cloudCountTasks(client, filter = {}) {
   const tasks = await cloudListTasks(client, rest);
   return tasks.length;
 }
-var _cache;
+async function cloudRegisterAgent(client, input) {
+  const raw = await client.transport.post("/agents", input);
+  if (raw && typeof raw === "object" && "agent" in raw) {
+    return raw.agent;
+  }
+  return raw;
+}
+async function cloudLockTask(client, id, agentId) {
+  const raw = await client.transport.post(`/tasks/${encodeURIComponent(id)}/lock`, { agent_id: agentId });
+  if (raw && typeof raw === "object" && "result" in raw) {
+    return raw.result;
+  }
+  return raw ?? { success: true };
+}
+async function cloudUnlockTask(client, id, agentId) {
+  const raw = await client.transport.post(`/tasks/${encodeURIComponent(id)}/unlock`, agentId ? { agent_id: agentId } : {});
+  if (raw && typeof raw === "object" && "success" in raw) {
+    return Boolean(raw.success);
+  }
+  return true;
+}
+async function cloudGetDependencies(client, id) {
+  const raw = await client.transport.get(`/tasks/${encodeURIComponent(id)}/dependencies`);
+  const env = raw ?? {};
+  return { dependencies: env.dependencies ?? [], blocked_by: env.blocked_by ?? [] };
+}
+async function cloudAddDependency(client, id, dependsOn) {
+  const raw = await client.transport.post(`/tasks/${encodeURIComponent(id)}/dependencies`, { depends_on: dependsOn });
+  if (raw && typeof raw === "object" && "dependency" in raw) {
+    return raw.dependency;
+  }
+  return raw;
+}
+async function cloudRemoveDependency(client, id, dependsOn) {
+  const raw = await client.transport.del(`/tasks/${encodeURIComponent(id)}/dependencies/${encodeURIComponent(dependsOn)}`);
+  if (raw && typeof raw === "object" && "removed" in raw) {
+    return Boolean(raw.removed);
+  }
+  return true;
+}
+async function cloudRecordVerification(client, id, input) {
+  const raw = await client.transport.post(`/tasks/${encodeURIComponent(id)}/verifications`, input);
+  if (raw && typeof raw === "object" && "verification" in raw) {
+    return raw.verification;
+  }
+  return raw;
+}
+function priorityRank(priority) {
+  return PRIORITY_RANK[priority ?? ""] ?? 4;
+}
+async function cloudActiveTasks(client, filter = {}) {
+  const [pending, inProgress] = await Promise.all([
+    cloudListTasks(client, { ...filter, status: "pending" }),
+    cloudListTasks(client, { ...filter, status: "in_progress" })
+  ]);
+  return [...pending, ...inProgress];
+}
+async function cloudActiveWork(client, filter = {}) {
+  const tasks = await cloudListTasks(client, { ...filter, status: "in_progress" });
+  return tasks.sort((a, b) => priorityRank(a.priority) - priorityRank(b.priority) || (b.updated_at ?? "").localeCompare(a.updated_at ?? ""));
+}
+async function cloudStaleTasks(client, minutes, filter = {}) {
+  const cutoff = new Date(Date.now() - minutes * 60 * 1000).toISOString();
+  const tasks = await cloudListTasks(client, { ...filter, status: "in_progress" });
+  return tasks.filter((t) => (t.updated_at ?? "") < cutoff || t.locked_at != null && t.locked_at < cutoff).sort((a, b) => (a.updated_at ?? "").localeCompare(b.updated_at ?? ""));
+}
+async function cloudOverdueTasks(client, projectId, at = new Date) {
+  const nowStr = at.toISOString();
+  const filter = projectId ? { project_id: projectId } : {};
+  const active = await cloudActiveTasks(client, filter);
+  return active.filter((t) => !t.archived_at && t.due_at != null && t.due_at < nowStr).sort((a, b) => (a.due_at ?? "").localeCompare(b.due_at ?? ""));
+}
+async function cloudEscalatedTasks(client, opts = {}, at = new Date) {
+  const nowMs = at.getTime();
+  const filter = {};
+  if (opts.project_id)
+    filter.project_id = opts.project_id;
+  const active = await cloudActiveTasks(client, filter);
+  return active.filter((t) => !t.archived_at && (opts.agent_id ? t.assigned_to === opts.agent_id : true)).map((task) => {
+    const reasons = [];
+    const breachedTimes = [];
+    if (task.due_at) {
+      const dueMs = new Date(task.due_at).getTime();
+      if (Number.isFinite(dueMs) && dueMs < nowMs) {
+        reasons.push("overdue");
+        breachedTimes.push(dueMs);
+      }
+    }
+    if (task.sla_minutes != null) {
+      const startMs = new Date(task.started_at ?? task.created_at).getTime();
+      const breachedMs = startMs + task.sla_minutes * 60000;
+      if (Number.isFinite(breachedMs) && breachedMs < nowMs) {
+        reasons.push("sla_breached");
+        breachedTimes.push(breachedMs);
+      }
+    }
+    if (reasons.length === 0)
+      return null;
+    return { task, reasons, breached_at: new Date(Math.min(...breachedTimes)).toISOString() };
+  }).filter((item) => item !== null).sort((a, b) => (a.task.due_at ?? "").localeCompare(b.task.due_at ?? "") || a.task.created_at.localeCompare(b.task.created_at));
+}
+async function cloudChangedSince(client, since, filter = {}) {
+  const tasks = await cloudListTasks(client, filter);
+  return tasks.filter((t) => (t.updated_at ?? "") > since).sort((a, b) => (b.updated_at ?? "").localeCompare(a.updated_at ?? ""));
+}
+async function cloudTaskStats(client, filter = {}) {
+  const tasks = await cloudListTasks(client, filter);
+  const by_status = {};
+  const by_priority = {};
+  const by_agent = {};
+  for (const t of tasks) {
+    by_status[t.status] = (by_status[t.status] ?? 0) + 1;
+    by_priority[t.priority] = (by_priority[t.priority] ?? 0) + 1;
+    const agent = t.assigned_to ?? t.agent_id ?? "unassigned";
+    by_agent[agent] = (by_agent[agent] ?? 0) + 1;
+  }
+  const completed = by_status["completed"] ?? 0;
+  return {
+    total: tasks.length,
+    by_status,
+    by_priority,
+    by_agent,
+    completion_rate: tasks.length > 0 ? Math.round(completed / tasks.length * 100) : 0
+  };
+}
+async function cloudRecentActivity(client, limit = 50) {
+  const raw = await client.transport.get("/activity", { query: { limit } });
+  const envelope = raw ?? {};
+  if (Array.isArray(envelope.activity))
+    return envelope.activity;
+  if (Array.isArray(envelope.entries))
+    return envelope.entries;
+  return Array.isArray(raw) ? raw : [];
+}
+async function cloudListTaskLists(client, projectId) {
+  const query = projectId ? { project_id: projectId } : {};
+  const raw = await client.transport.get("/task-lists", { query });
+  const envelope = raw ?? {};
+  if (Array.isArray(envelope.task_lists))
+    return envelope.task_lists;
+  if (Array.isArray(envelope.taskLists))
+    return envelope.taskLists;
+  return Array.isArray(raw) ? raw : [];
+}
+async function cloudNextTask(client, agent, filters) {
+  const query = {};
+  if (agent)
+    query["agent"] = agent;
+  if (filters?.project_id)
+    query["project_id"] = filters.project_id;
+  if (filters?.task_list_id)
+    query["task_list_id"] = filters.task_list_id;
+  if (filters?.plan_id)
+    query["plan_id"] = filters.plan_id;
+  const raw = await client.transport.get("/next", { query });
+  if (raw == null)
+    return null;
+  const task = unwrapTask(raw);
+  return task && task.id ? task : null;
+}
+async function cloudAllDependencies(client) {
+  const raw = await client.transport.get("/dependencies");
+  const envelope = raw ?? {};
+  if (Array.isArray(envelope.dependencies))
+    return envelope.dependencies;
+  return Array.isArray(raw) ? raw : [];
+}
+async function cloudGetTasksByIds(client, ids) {
+  const unique = Array.from(new Set(ids));
+  const map = new Map;
+  const CONCURRENCY = 8;
+  for (let i = 0;i < unique.length; i += CONCURRENCY) {
+    const batch = unique.slice(i, i + CONCURRENCY);
+    const tasks = await Promise.all(batch.map((id) => cloudGetTask(client, id)));
+    for (const task of tasks)
+      if (task && task.id)
+        map.set(task.id, task);
+  }
+  return map;
+}
+async function cloudBlockingDepsMap(client, candidates) {
+  const result = new Map;
+  if (candidates.length === 0)
+    return result;
+  const edges = await cloudAllDependencies(client);
+  const dependsByTask = new Map;
+  for (const edge of edges) {
+    if (!edge.task_id || !edge.depends_on)
+      continue;
+    const arr = dependsByTask.get(edge.task_id) ?? [];
+    arr.push(edge.depends_on);
+    dependsByTask.set(edge.task_id, arr);
+  }
+  const candidateIds = new Set(candidates.map((t) => t.id));
+  const blockerIds = new Set;
+  for (const id of candidateIds)
+    for (const dep of dependsByTask.get(id) ?? [])
+      blockerIds.add(dep);
+  const blockers = await cloudGetTasksByIds(client, Array.from(blockerIds));
+  for (const task of candidates) {
+    const deps = dependsByTask.get(task.id) ?? [];
+    const incomplete = deps.map((depId) => blockers.get(depId)).filter((b) => b != null && b.status !== "completed");
+    if (incomplete.length > 0)
+      result.set(task.id, incomplete);
+  }
+  return result;
+}
+async function cloudRecap(client, hours, projectId) {
+  const since = new Date(Date.now() - hours * 60 * 60 * 1000).toISOString();
+  const staleWindow = new Date(Date.now() - 30 * 60 * 1000).toISOString();
+  const filter = projectId ? { project_id: projectId } : {};
+  const [all, agents] = await Promise.all([cloudListTasks(client, filter), cloudListAgents(client)]);
+  const completed = all.filter((t) => t.status === "completed" && t.completed_at != null && t.completed_at > since).sort((a, b) => (b.completed_at ?? "").localeCompare(a.completed_at ?? "")).map((t) => ({
+    ...t,
+    duration_minutes: t.started_at && t.completed_at ? Math.round((new Date(t.completed_at).getTime() - new Date(t.started_at).getTime()) / 60000) : null
+  }));
+  const created = all.filter((t) => t.created_at > since).sort((a, b) => b.created_at.localeCompare(a.created_at));
+  const in_progress = all.filter((t) => t.status === "in_progress").sort((a, b) => (b.updated_at ?? "").localeCompare(a.updated_at ?? ""));
+  const stale = in_progress.filter((t) => (t.updated_at ?? "") < staleWindow).sort((a, b) => (a.updated_at ?? "").localeCompare(b.updated_at ?? ""));
+  const pending = all.filter((t) => t.status === "pending");
+  const blockedMap = await cloudBlockingDepsMap(client, pending);
+  const blocked = pending.filter((t) => blockedMap.has(t.id));
+  const sinceMs = new Date(since).getTime();
+  const agentSummaries = agents.map((agent) => {
+    const owned = all.filter((t) => t.assigned_to === agent.id || t.agent_id === agent.id);
+    return {
+      name: agent.name,
+      completed_count: owned.filter((t) => t.status === "completed" && t.completed_at != null && t.completed_at > since).length,
+      in_progress_count: owned.filter((t) => t.status === "in_progress").length,
+      last_seen_at: agent.last_seen_at
+    };
+  }).filter((a) => a.last_seen_at != null && new Date(a.last_seen_at).getTime() > sinceMs).sort((a, b) => b.completed_count - a.completed_count);
+  return { hours, since, completed, created, in_progress, blocked, stale, agents: agentSummaries };
+}
+async function cloudTimeline(client, options = {}) {
+  const activity = await cloudRecentActivity(client, 5000);
+  let entries = activity.map((h) => ({
+    id: h.id,
+    source: "task_history",
+    event_type: h.action,
+    entity_type: "task",
+    entity_id: h.task_id,
+    task_id: h.task_id,
+    project_id: null,
+    plan_id: null,
+    run_id: null,
+    agent_id: h.agent_id ?? null,
+    created_at: h.created_at,
+    title: "",
+    message: h.field ? `${h.field}: ${h.old_value ?? ""}${h.new_value != null ? ` -> ${h.new_value}` : ""}`.trim() : null,
+    metadata: {}
+  }));
+  if (options.entity_type && options.entity_type !== "task") {
+    entries = [];
+  } else if (options.entity_type === "task" && options.entity_id) {
+    entries = entries.filter((e) => e.task_id === options.entity_id);
+  }
+  if (options.since)
+    entries = entries.filter((e) => e.created_at >= options.since);
+  if (options.until)
+    entries = entries.filter((e) => e.created_at <= options.until);
+  entries.sort((a, b) => options.order === "asc" ? a.created_at.localeCompare(b.created_at) : b.created_at.localeCompare(a.created_at));
+  const total = entries.length;
+  const offset = options.offset ?? 0;
+  const limit = options.limit ?? 50;
+  return { entries: entries.slice(offset, offset + limit), total, limit, offset };
+}
+var _cache, PRIORITY_RANK;
 var init_cloud_router = __esm(() => {
   init_storage();
+  PRIORITY_RANK = { critical: 0, high: 1, medium: 2, low: 3 };
 });
 
 // src/db/migrations.ts
@@ -16391,11 +16659,11 @@ function listTasks(filter = {}, db) {
     }
   }
   addMetadataConditions(filter.metadata, conditions, params);
-  const PRIORITY_RANK = `CASE priority WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 WHEN 'low' THEN 3 END`;
+  const PRIORITY_RANK2 = `CASE priority WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 WHEN 'low' THEN 3 END`;
   if (filter.cursor) {
     try {
       const decoded = JSON.parse(Buffer.from(filter.cursor, "base64").toString("utf8"));
-      conditions.push(`(${PRIORITY_RANK} > ? OR (${PRIORITY_RANK} = ? AND created_at < ?) OR (${PRIORITY_RANK} = ? AND created_at = ? AND id > ?))`);
+      conditions.push(`(${PRIORITY_RANK2} > ? OR (${PRIORITY_RANK2} = ? AND created_at < ?) OR (${PRIORITY_RANK2} = ? AND created_at = ? AND id > ?))`);
       params.push(decoded.p, decoded.p, decoded.c, decoded.p, decoded.c, decoded.i);
     } catch {}
   }
@@ -16412,7 +16680,7 @@ function listTasks(filter = {}, db) {
       params.push(filter.offset);
     }
   }
-  const rows = d.query(`SELECT * FROM tasks ${where} ORDER BY ${PRIORITY_RANK}, created_at DESC, id ASC${limitClause}`).all(...params);
+  const rows = d.query(`SELECT * FROM tasks ${where} ORDER BY ${PRIORITY_RANK2}, created_at DESC, id ASC${limitClause}`).all(...params);
   return rows.map(rowToTask);
 }
 function getTaskByFingerprint(fingerprint, db) {
@@ -20886,13 +21154,14 @@ ${chalk2.cyan(sid)} ${statusColor(task2.status)} ${prioColor(task2.priority)} ${
       console.log(formatTaskLine(task2));
     }
   });
-  program2.command("lock <id>").description("Acquire exclusive lock on a task").action((id) => {
+  program2.command("lock <id>").description("Acquire exclusive lock on a task").action(async (id) => {
     const globalOpts = program2.opts();
     const agentId = globalOpts.agent || "cli";
+    const cloud = getTodosCloudClient();
     const resolvedId = resolveTaskId(id);
     let result;
     try {
-      result = lockTask(resolvedId, agentId);
+      result = cloud ? await cloudLockTask(cloud, resolvedId, agentId) : lockTask(resolvedId, agentId);
     } catch (e) {
       handleError(e);
     }
@@ -20905,11 +21174,15 @@ ${chalk2.cyan(sid)} ${statusColor(task2.status)} ${prioColor(task2.priority)} ${
       process.exit(1);
     }
   });
-  program2.command("unlock <id>").description("Release lock on a task").action((id) => {
+  program2.command("unlock <id>").description("Release lock on a task").action(async (id) => {
     const globalOpts = program2.opts();
+    const cloud = getTodosCloudClient();
     const resolvedId = resolveTaskId(id);
     try {
-      unlockTask(resolvedId, globalOpts.agent);
+      if (cloud)
+        await cloudUnlockTask(cloud, resolvedId, globalOpts.agent);
+      else
+        unlockTask(resolvedId, globalOpts.agent);
     } catch (e) {
       handleError(e);
     }
@@ -29655,11 +29928,11 @@ function taskSummary(task, blockers) {
   const firstLine = task.description?.split(/\r?\n/).map((line) => line.trim()).find(Boolean);
   return firstLine || undefined;
 }
-function priorityRank(priority) {
+function priorityRank2(priority) {
   return { critical: 0, high: 1, medium: 2, low: 3 }[priority];
 }
 function sortActionableTasks(a, b) {
-  const priority = priorityRank(a.priority) - priorityRank(b.priority);
+  const priority = priorityRank2(a.priority) - priorityRank2(b.priority);
   if (priority !== 0)
     return priority;
   return b.updated_at.localeCompare(a.updated_at);
@@ -31573,6 +31846,49 @@ function registerProjectCommands(program2) {
   });
   program2.command("deps <id>").description("Manage task dependencies").option("--needs <dep-id>", "Add dependency (this task needs dep-id)").option("--remove <dep-id>", "Remove dependency").option("--graph", "Show the dependency graph instead of direct edges").option("--direction <direction>", "Graph direction: up, down, or both", "both").action(async (id, opts) => {
     const globalOpts = program2.opts();
+    const cloud = getTodosCloudClient();
+    if (cloud) {
+      const cloudId = resolveTaskId(id);
+      if (opts.needs) {
+        try {
+          const dep = await cloudAddDependency(cloud, cloudId, resolveTaskId(opts.needs));
+          if (globalOpts.json)
+            output(dep, true);
+          else
+            console.log(chalk4.green("Dependency added."));
+        } catch (e) {
+          handleError(e);
+        }
+        return;
+      }
+      if (opts.remove) {
+        const removed = await cloudRemoveDependency(cloud, cloudId, resolveTaskId(opts.remove));
+        if (globalOpts.json)
+          output({ removed }, true);
+        else
+          console.log(removed ? chalk4.green("Dependency removed.") : chalk4.red("Dependency not found."));
+        return;
+      }
+      const edges = await cloudGetDependencies(cloud, cloudId);
+      if (globalOpts.json) {
+        output(edges, true);
+        return;
+      }
+      if (edges.dependencies.length > 0) {
+        console.log(chalk4.bold("Depends on:"));
+        for (const dep of edges.dependencies)
+          console.log(`  ${chalk4.cyan(dep.depends_on)}`);
+      }
+      if (edges.blocked_by.length > 0) {
+        console.log(chalk4.bold("Blocks:"));
+        for (const b of edges.blocked_by)
+          console.log(`  ${chalk4.cyan(b.task_id)}`);
+      }
+      if (edges.dependencies.length === 0 && edges.blocked_by.length === 0) {
+        console.log(chalk4.dim("No dependencies."));
+      }
+      return;
+    }
     const { addDependency: addDependency2, removeDependency: removeDependency2, getTaskGraph: getTaskGraph2, getTaskWithRelations: getTaskWithRelations2 } = await Promise.resolve().then(() => (init_tasks(), exports_tasks));
     const resolvedId = resolveTaskId(id);
     if (opts.needs) {
@@ -32789,8 +33105,9 @@ function registerAgentCommands(program2) {
   program2.command("init <name>").description("Register an agents and get a short UUID").option("-d, --description <text>", "Agent description").action(async (name, opts) => {
     const globalOpts = program2.opts();
     try {
-      const { registerAgent: registerAgent2, isAgentConflict: isAgentConflict2 } = await Promise.resolve().then(() => (init_agents(), exports_agents));
-      const result = registerAgent2({ name, description: opts.description });
+      const cloud = getTodosCloudClient();
+      const result = cloud ? await cloudRegisterAgent(cloud, { name, description: opts.description }) : (await Promise.resolve().then(() => (init_agents(), exports_agents))).registerAgent({ name, description: opts.description });
+      const { isAgentConflict: isAgentConflict2 } = await Promise.resolve().then(() => (init_agents(), exports_agents));
       if (isAgentConflict2(result)) {
         console.error(chalk5.red("CONFLICT:"), result.message);
         process.exit(1);
@@ -32947,14 +33264,15 @@ Use ${chalk5.cyan(`--agent ${result.id}`)} on future commands.`);
   });
   program2.command("agent <name>").description("Show all info about an agent: tasks, status, last seen, stats").option("-j, --json", "Output as JSON").action(async (name, opts) => {
     const globalOpts = program2.opts();
+    const cloud = getTodosCloudClient();
     const { getAgentByName: findByName } = await Promise.resolve().then(() => (init_agents(), exports_agents));
-    const agent = findByName(name);
+    const agent = cloud ? (await cloudListAgents(cloud)).find((a) => a.name === name || a.id === name) ?? null : findByName(name);
     if (!agent) {
       console.error(chalk5.red(`Agent not found: ${name}`));
       process.exit(1);
     }
-    const byAssigned = listTasks({ assigned_to: agent.name });
-    const byId = listTasks({ agent_id: agent.id });
+    const byAssigned = cloud ? await cloudListTasks(cloud, { assigned_to: agent.name }) : listTasks({ assigned_to: agent.name });
+    const byId = cloud ? await cloudListTasks(cloud, { agent_id: agent.id }) : listTasks({ agent_id: agent.id });
     const seen = new Set;
     const allTasks = [...byAssigned, ...byId].filter((t) => {
       if (seen.has(t.id))
@@ -33092,7 +33410,8 @@ ${isOnline ? chalk5.green("\u25CF") : chalk5.dim("\u25CB")} ${chalk5.bold(agent.
         console.log(chalk5.green("Task list deleted."));
         return;
       }
-      const lists = listTaskLists(projectId);
+      const cloud = getTodosCloudClient();
+      const lists = cloud ? await cloudListTaskLists(cloud, projectId ?? undefined) : listTaskLists(projectId);
       if (globalOpts.json) {
         output(lists, true);
         return;
@@ -38364,7 +38683,19 @@ function createPostgresTodosStorageAdapter(options) {
       claimNext: (agentId, filters) => claimNextTask2(agentId, filters, store),
       getNext: (_agentId, filters) => getNextTask2(filters, store),
       getActiveWork: (filters) => getActiveWork2(filters, store),
-      getChangedSince: (since, filters) => getChangedSince(since, filters, store)
+      getChangedSince: (since, filters) => getChangedSince(since, filters, store),
+      lock: (id, agentId) => lockTask2(id, agentId, store),
+      unlock: (id, agentId) => unlockTask2(id, agentId, store)
+    },
+    dependencies: {
+      add: (taskId, dependsOn, context) => addDependency2(taskId, dependsOn, store, context),
+      remove: (taskId, dependsOn) => removeDependency2(taskId, dependsOn, store),
+      list: (taskId) => listDependencies(taskId, store),
+      listAll: () => store.list("dependencies")
+    },
+    verifications: {
+      add: (input, context) => addVerification(input, store, context),
+      list: (taskId) => listVerifications(taskId, store)
     },
     projects: {
       create: (input, context) => createProject2(input, store, context),
@@ -38819,6 +39150,103 @@ async function patchTask(task, patch, store) {
   await store.upsert("tasks", updated);
   return updated;
 }
+function cloudLockExpired(lockedAt) {
+  if (!lockedAt)
+    return true;
+  return new Date(lockedAt).getTime() + CLOUD_LOCK_EXPIRY_MINUTES * 60 * 1000 < Date.now();
+}
+function cloudLockExpiresAt(lockedAt) {
+  return new Date(new Date(lockedAt).getTime() + CLOUD_LOCK_EXPIRY_MINUTES * 60 * 1000).toISOString();
+}
+async function lockTask2(id, agentId, store) {
+  const task = await requireRecord("tasks", id, store);
+  if (task.status === "completed" || task.status === "cancelled") {
+    return { success: false, error: `Task is ${task.status} and cannot be locked` };
+  }
+  if (task.locked_by && task.locked_by !== agentId && !cloudLockExpired(task.locked_at)) {
+    return { success: false, locked_by: task.locked_by, locked_at: task.locked_at ?? undefined, error: `Task is locked by ${task.locked_by}` };
+  }
+  const timestamp = new Date().toISOString();
+  await patchTask(task, { locked_by: agentId, locked_at: timestamp }, store);
+  return { success: true, locked_by: agentId, locked_at: timestamp, expires_at: cloudLockExpiresAt(timestamp) };
+}
+async function unlockTask2(id, agentId, store) {
+  const task = await requireRecord("tasks", id, store);
+  if (agentId && task.locked_by && task.locked_by !== agentId) {
+    throw new Error(`Task ${id} is locked by ${task.locked_by}, not ${agentId}`);
+  }
+  await patchTask(task, { locked_by: null, locked_at: null }, store);
+  return true;
+}
+function dependencyId(taskId, dependsOn) {
+  return `${taskId}::${dependsOn}`;
+}
+async function addDependency2(taskId, dependsOn, store, context) {
+  if (taskId === dependsOn)
+    throw new Error("A task cannot depend on itself");
+  if (!await store.get("tasks", taskId))
+    throw new Error(`Task not found: ${taskId}`);
+  if (!await store.get("tasks", dependsOn))
+    throw new Error(`Task not found: ${dependsOn}`);
+  const edges = await store.list("dependencies");
+  const adjacency = new Map;
+  for (const edge of edges) {
+    if (!adjacency.has(edge.task_id))
+      adjacency.set(edge.task_id, []);
+    adjacency.get(edge.task_id).push(edge.depends_on);
+  }
+  const queue = [dependsOn];
+  const seen = new Set;
+  while (queue.length) {
+    const node = queue.shift();
+    if (node === taskId)
+      throw new Error(`Adding dependency ${taskId} -> ${dependsOn} would create a cycle`);
+    if (seen.has(node))
+      continue;
+    seen.add(node);
+    for (const next of adjacency.get(node) ?? [])
+      queue.push(next);
+  }
+  const timestamp = new Date().toISOString();
+  const record = { id: dependencyId(taskId, dependsOn), task_id: taskId, depends_on: dependsOn, created_at: timestamp, updated_at: timestamp };
+  await store.upsert("dependencies", record, context);
+  return { task_id: taskId, depends_on: dependsOn };
+}
+async function removeDependency2(taskId, dependsOn, store) {
+  const existing = await store.get("dependencies", dependencyId(taskId, dependsOn));
+  if (!existing)
+    return false;
+  await store.delete("dependencies", dependencyId(taskId, dependsOn));
+  return true;
+}
+async function listDependencies(taskId, store) {
+  const edges = await store.list("dependencies");
+  return {
+    dependencies: edges.filter((edge) => edge.task_id === taskId).map((edge) => ({ task_id: edge.task_id, depends_on: edge.depends_on })),
+    blocked_by: edges.filter((edge) => edge.depends_on === taskId).map((edge) => ({ task_id: edge.task_id, depends_on: edge.depends_on }))
+  };
+}
+async function addVerification(input, store, context) {
+  if (!await store.get("tasks", input.task_id))
+    throw new Error(`Task not found: ${input.task_id}`);
+  const timestamp = new Date().toISOString();
+  const verification = {
+    id: randomUUID3(),
+    task_id: input.task_id,
+    command: input.command,
+    status: input.status ?? "unknown",
+    output_summary: input.output_summary ?? null,
+    artifact_path: input.artifact_path ?? null,
+    agent_id: input.agent_id ?? context?.agentId ?? null,
+    run_at: timestamp,
+    created_at: timestamp
+  };
+  await store.upsert("verifications", { ...verification, updated_at: timestamp }, context);
+  return verification;
+}
+async function listVerifications(taskId, store) {
+  return (await store.list("verifications")).filter((verification) => verification.task_id === taskId).sort((a, b) => b.run_at.localeCompare(a.run_at));
+}
 function toFilterArray(value) {
   return Array.isArray(value) ? value : [value];
 }
@@ -39192,7 +39620,7 @@ function compareClock(left, right) {
 function numberValue2(value) {
   return typeof value === "number" && Number.isSafeInteger(value) ? value : null;
 }
-var TASK_ORDER_BY = "ORDER BY CASE payload->>'priority' WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 WHEN 'low' THEN 3 ELSE 4 END ASC, payload->>'created_at' ASC, payload->>'id' ASC";
+var CLOUD_LOCK_EXPIRY_MINUTES = 30, TASK_ORDER_BY = "ORDER BY CASE payload->>'priority' WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 WHEN 'low' THEN 3 ELSE 4 END ASC, payload->>'created_at' ASC, payload->>'id' ASC";
 var init_postgres_adapter = () => {};
 
 // src/server/cloud.ts
@@ -39690,6 +40118,7 @@ async function handleV1Request(req, url) {
   const resource = segments[1];
   const id = segments[2];
   const action = segments[3];
+  const subId = segments[4];
   try {
     if (resource === "tasks") {
       if (id === "exists" && !action) {
@@ -39765,6 +40194,89 @@ async function handleV1Request(req, url) {
           }
           return error(405, `method ${method} not allowed on /v1/tasks/:id/comments`);
         }
+        if (action === "lock" || action === "unlock") {
+          if (method !== "POST")
+            return error(405, `method ${method} not allowed on /v1/tasks/:id/${action}`);
+          if (typeof store.tasks.lock !== "function" || typeof store.tasks.unlock !== "function") {
+            return error(501, "task locking is not supported by this storage backend");
+          }
+          const body2 = await readJson(req) ?? {};
+          if (!await store.tasks.get(id))
+            return error(404, "task not found");
+          if (action === "lock") {
+            const agentId2 = body2.agent_id || principal.agent || "todos-serve";
+            return json2({ result: await store.tasks.lock(id, agentId2) });
+          }
+          const released = await store.tasks.unlock(id, body2.agent_id || principal.agent || undefined);
+          return json2({ success: released });
+        }
+        if (action === "dependencies") {
+          if (!store.dependencies)
+            return error(501, "dependencies are not supported by this storage backend");
+          if (method === "GET") {
+            if (!await store.tasks.get(id))
+              return error(404, "task not found");
+            const edges = await store.dependencies.list(id);
+            return json2(edges);
+          }
+          if (method === "POST") {
+            const body2 = await readJson(req) ?? {};
+            if (typeof body2.depends_on !== "string" || !body2.depends_on.trim()) {
+              return error(400, "depends_on is required");
+            }
+            try {
+              const dependency = await store.dependencies.add(id, body2.depends_on, contextFromPrincipal(principal));
+              return json2({ dependency }, 201);
+            } catch (e) {
+              const msg = e.message || "";
+              if (msg.includes("not found"))
+                return error(404, msg);
+              if (msg.includes("cycle") || msg.includes("itself"))
+                return error(409, msg);
+              throw e;
+            }
+          }
+          if (method === "DELETE") {
+            if (!subId)
+              return error(400, "dependency target id is required (/v1/tasks/:id/dependencies/:dep)");
+            const removed = await store.dependencies.remove(id, subId);
+            return json2({ removed });
+          }
+          return error(405, `method ${method} not allowed on /v1/tasks/:id/dependencies`);
+        }
+        if (action === "verifications") {
+          if (!store.verifications)
+            return error(501, "verifications are not supported by this storage backend");
+          if (method === "GET") {
+            if (!await store.tasks.get(id))
+              return error(404, "task not found");
+            const verifications = await store.verifications.list(id);
+            return json2({ verifications, count: verifications.length });
+          }
+          if (method === "POST") {
+            const body2 = await readJson(req) ?? {};
+            if (typeof body2.command !== "string" || !body2.command.trim()) {
+              return error(400, "command is required");
+            }
+            try {
+              const verification = await store.verifications.add({
+                task_id: id,
+                command: body2.command,
+                status: body2.status,
+                output_summary: body2.output_summary,
+                artifact_path: body2.artifact_path,
+                agent_id: body2.agent_id
+              }, contextFromPrincipal(principal, body2));
+              return json2({ verification }, 201);
+            } catch (e) {
+              const msg = e.message || "";
+              if (msg.includes("not found"))
+                return error(404, msg);
+              throw e;
+            }
+          }
+          return error(405, `method ${method} not allowed on /v1/tasks/:id/verifications`);
+        }
         const body = await readJson(req) ?? {};
         const agentId = body.agent_id || principal.agent || "todos-serve";
         if (action === "start" && method === "POST") {
@@ -39869,16 +40381,55 @@ async function handleV1Request(req, url) {
       }
       if (!id && method === "POST") {
         const body = await readJson(req);
-        if (!body || typeof body.name !== "string")
+        if (!body || typeof body.name !== "string" || !body.name.trim())
           return error(400, "name is required");
-        const agent = await store.agents.register(body, contextFromPrincipal(principal));
-        return json2({ agent }, 201);
+        const result = await store.agents.register(body, contextFromPrincipal(principal));
+        if (result && typeof result === "object" && "conflict" in result) {
+          return error(409, result.message ?? "agent name conflict", { conflict: true });
+        }
+        return json2({ agent: result }, 201);
       }
       if (id && method === "GET") {
         const agent = await store.agents.get(id);
         return agent ? json2({ agent }) : error(404, "agent not found");
       }
     }
+    if (resource === "activity" && !id) {
+      if (method !== "GET")
+        return error(405, `method ${method} not allowed on /v1/activity`);
+      const limitParam = url.searchParams.get("limit");
+      const limit = limitParam ? Math.max(1, Math.min(1e4, Number(limitParam) || 50)) : 50;
+      const activity = await store.audit.getRecentActivity(limit);
+      return json2({ activity, count: activity.length });
+    }
+    if (resource === "task-lists" && !id) {
+      if (method !== "GET")
+        return error(405, `method ${method} not allowed on /v1/task-lists`);
+      const projectId = url.searchParams.get("project_id") ?? undefined;
+      const taskLists = await store.taskLists.list(projectId);
+      return json2({ task_lists: taskLists, count: taskLists.length });
+    }
+    if (resource === "dependencies" && !id) {
+      if (method !== "GET")
+        return error(405, `method ${method} not allowed on /v1/dependencies`);
+      if (typeof store.dependencies?.listAll !== "function") {
+        return error(501, "dependency edge listing is not supported by this storage backend");
+      }
+      const dependencies = await store.dependencies.listAll();
+      return json2({ dependencies, count: dependencies.length });
+    }
+    if (resource === "next" && !id) {
+      if (method !== "GET")
+        return error(405, `method ${method} not allowed on /v1/next`);
+      const agent = url.searchParams.get("agent") ?? undefined;
+      const filters = {
+        ...url.searchParams.get("project_id") ? { project_id: url.searchParams.get("project_id") } : {},
+        ...url.searchParams.get("task_list_id") ? { task_list_id: url.searchParams.get("task_list_id") } : {},
+        ...url.searchParams.get("plan_id") ? { plan_id: url.searchParams.get("plan_id") } : {}
+      };
+      const task = await store.tasks.getNext(agent, filters);
+      return json2({ task: task ?? null });
+    }
     if (resource === "stats" && method === "GET") {
       const [tasks, tasksAll, projects] = await Promise.all([
         store.tasks.count(),
@@ -62399,6 +62950,33 @@ function registerAgentTools(server, { shouldRegisterTool, resolveId, formatError
       force: exports_external3.boolean().optional().describe("Force takeover of an active agent's name. Use with caution \u2014 only when you know the previous session is dead.")
     }, async ({ name, description, role, title, level, permissions, capabilities, session_id, working_dir, force }) => {
       try {
+        const cloud = getTodosCloudClient();
+        if (cloud) {
+          const agent2 = await cloudRegisterAgent(cloud, {
+            name,
+            description,
+            role,
+            title,
+            level,
+            permissions,
+            capabilities,
+            session_id,
+            working_dir,
+            force
+          });
+          return {
+            content: [{
+              type: "text",
+              text: `Agent registered:
+ID: ${agent2.id}
+Name: ${agent2.name}${agent2.description ? `
+Description: ${agent2.description}` : ""}
+Session: ${agent2.session_id ?? "unbound"}
+Created: ${agent2.created_at}
+Last seen: ${agent2.last_seen_at}`
+            }]
+          };
+        }
         const pool = getAgentPoolForProject(working_dir);
         const result = registerAgent({ name, description, role, title, level, permissions, capabilities, session_id, working_dir, force, pool: pool || undefined });
         if (isAgentConflict(result)) {
@@ -68322,7 +68900,8 @@ function registerQueryCommands(program2) {
       if (pid)
         filters.project_id = pid;
     }
-    const task2 = getNextTask(opts.agent, Object.keys(filters).length ? filters : undefined, db);
+    const cloud = getTodosCloudClient();
+    const task2 = cloud ? await cloudNextTask(cloud, opts.agent, Object.keys(filters).length ? filters : undefined) : getNextTask(opts.agent, Object.keys(filters).length ? filters : undefined, db);
     if (!task2) {
       if (json3) {
         console.log(JSON.stringify(null));
@@ -68443,9 +69022,10 @@ Next up:`));
       console.log(`  ${chalk7.cyan(t.short_id || t.id.slice(0, 8))} ${chalk7.yellow(t.priority)} ${t.title}`);
     }
   });
-  program2.command("recap").description("Show what happened in the last N hours \u2014 completed tasks, new tasks, agent activity, blockers").option("--hours <n>", "Look back N hours (default: 8)", "8").option("--project <id>", "Filter to project").action((opts) => {
+  program2.command("recap").description("Show what happened in the last N hours \u2014 completed tasks, new tasks, agent activity, blockers").option("--hours <n>", "Look back N hours (default: 8)", "8").option("--project <id>", "Filter to project").action(async (opts) => {
     const globalOpts = program2.opts();
-    const recap = getRecap(parseInt(opts.hours, 10), opts.project);
+    const cloud = getTodosCloudClient();
+    const recap = cloud ? await cloudRecap(cloud, parseInt(opts.hours, 10), opts.project) : getRecap(parseInt(opts.hours, 10), opts.project);
     if (globalOpts.json) {
       output(recap, true);
       return;
@@ -68508,11 +69088,12 @@ Agents:`));
     }
     console.log();
   });
-  program2.command("standup").description("Generate standup notes \u2014 completed since yesterday, in progress, blocked. Grouped by agent.").option("--since <date>", "ISO date or 'yesterday' (default: yesterday)").option("--project <id>", "Filter to project").action((opts) => {
+  program2.command("standup").description("Generate standup notes \u2014 completed since yesterday, in progress, blocked. Grouped by agent.").option("--since <date>", "ISO date or 'yesterday' (default: yesterday)").option("--project <id>", "Filter to project").action(async (opts) => {
     const globalOpts = program2.opts();
     const sinceDate = opts.since === "yesterday" || !opts.since ? new Date(Date.now() - 24 * 60 * 60 * 1000) : new Date(opts.since);
     const hours = Math.max(1, Math.round((Date.now() - sinceDate.getTime()) / (60 * 60 * 1000)));
-    const recap = getRecap(hours, opts.project);
+    const cloud = getTodosCloudClient();
+    const recap = cloud ? await cloudRecap(cloud, hours, opts.project) : getRecap(hours, opts.project);
     if (globalOpts.json) {
       output(recap, true);
       return;
@@ -68582,7 +69163,8 @@ Blocked:`));
     const filters = {};
     if (opts.project)
       filters.project_id = opts.project;
-    const work = getActiveWork(Object.keys(filters).length ? filters : undefined, db);
+    const cloud = getTodosCloudClient();
+    const work = cloud ? await cloudActiveWork(cloud, Object.keys(filters).length ? filters : {}) : getActiveWork(Object.keys(filters).length ? filters : undefined, db);
     if (json3) {
       console.log(JSON.stringify(work, null, 2));
       return;
@@ -68605,7 +69187,8 @@ Blocked:`));
     const filters = {};
     if (opts.project)
       filters.project_id = opts.project;
-    const tasks = getStaleTasks(parseInt(opts.minutes, 10), Object.keys(filters).length ? filters : undefined, db);
+    const cloud = getTodosCloudClient();
+    const tasks = cloud ? await cloudStaleTasks(cloud, parseInt(opts.minutes, 10), Object.keys(filters).length ? filters : {}) : getStaleTasks(parseInt(opts.minutes, 10), Object.keys(filters).length ? filters : undefined, db);
     if (json3) {
       console.log(JSON.stringify(tasks, null, 2));
       return;
@@ -68757,12 +69340,13 @@ No task claimed (nothing available).`));
       filter.project_id = projectId;
     if (opts.agent)
       filter.assigned_to = opts.agent;
+    const cloud = getTodosCloudClient();
     const { getTasksChangedSince: getTasksChangedSince2 } = await Promise.resolve().then(() => (init_tasks(), exports_tasks));
-    const changed = getTasksChangedSince2(since, Object.keys(filter).length ? filter : undefined, db);
+    const changed = cloud ? await cloudChangedSince(cloud, since, filter) : getTasksChangedSince2(since, Object.keys(filter).length ? filter : undefined, db);
     const completed = changed.filter((t) => t.status === "completed");
     const inProgress = changed.filter((t) => t.status === "in_progress");
     const failed = changed.filter((t) => t.status === "failed");
-    const allTasks = listTasks({ ...filter, status: "pending" });
+    const allTasks = cloud ? await cloudListTasks(cloud, { ...filter, status: "pending" }) : listTasks({ ...filter, status: "pending" });
     if (opts.json || globalOpts.json) {
       console.log(JSON.stringify({ completed, in_progress: inProgress, failed, pending: allTasks.length, period_days: days }, null, 2));
       return;
@@ -69029,12 +69613,13 @@ Findings`));
     const filter = {};
     if (projectId)
       filter.project_id = projectId;
+    const cloud = getTodosCloudClient();
     const { getTasksChangedSince: getTasksChangedSince2, getTaskStats: getTaskStats2 } = await Promise.resolve().then(() => (init_tasks(), exports_tasks));
-    const changed = getTasksChangedSince2(since, Object.keys(filter).length ? filter : undefined, db);
+    const changed = cloud ? await cloudChangedSince(cloud, since, filter) : getTasksChangedSince2(since, Object.keys(filter).length ? filter : undefined, db);
     const completed = changed.filter((t) => t.status === "completed");
     const failed = changed.filter((t) => t.status === "failed");
-    const all = listTasks(filter);
-    const stats2 = getTaskStats2(Object.keys(filter).length ? filter : undefined, db);
+    const all = cloud ? await cloudListTasks(cloud, filter) : listTasks(filter);
+    const stats2 = cloud ? await cloudTaskStats(cloud, filter) : getTaskStats2(Object.keys(filter).length ? filter : undefined, db);
     const byDay = {};
     for (const t of changed) {
       const day = t.updated_at.slice(0, 10);
@@ -69088,10 +69673,11 @@ Findings`));
   program2.command("today").description("Show task activity from today").option("-j, --json", "Output as JSON").action(async (opts) => {
     const globalOpts = program2.opts();
     const db = getDatabase();
+    const cloud = getTodosCloudClient();
     const { getTasksChangedSince: getTasksChangedSince2 } = await Promise.resolve().then(() => (init_tasks(), exports_tasks));
     const start = new Date;
     start.setHours(0, 0, 0, 0);
-    const tasks = getTasksChangedSince2(start.toISOString(), undefined, db);
+    const tasks = cloud ? await cloudChangedSince(cloud, start.toISOString()) : getTasksChangedSince2(start.toISOString(), undefined, db);
     const completed = tasks.filter((t) => t.status === "completed");
     const started = tasks.filter((t) => t.status === "in_progress");
     const other = tasks.filter((t) => t.status !== "completed" && t.status !== "in_progress");
@@ -69118,13 +69704,14 @@ Findings`));
   program2.command("yesterday").description("Show task activity from yesterday").option("-j, --json", "Output as JSON").action(async (opts) => {
     const globalOpts = program2.opts();
     const db = getDatabase();
+    const cloud = getTodosCloudClient();
     const { getTasksChangedSince: getTasksChangedSince2 } = await Promise.resolve().then(() => (init_tasks(), exports_tasks));
     const start = new Date;
     start.setDate(start.getDate() - 1);
     start.setHours(0, 0, 0, 0);
     const end = new Date(start);
     end.setHours(23, 59, 59, 999);
-    const allChanged = getTasksChangedSince2(start.toISOString(), undefined, db);
+    const allChanged = cloud ? await cloudChangedSince(cloud, start.toISOString()) : getTasksChangedSince2(start.toISOString(), undefined, db);
     const tasks = allChanged.filter((t) => t.updated_at <= end.toISOString());
     const completed = tasks.filter((t) => t.status === "completed");
     const started = tasks.filter((t) => t.status === "in_progress");
@@ -69152,14 +69739,15 @@ Findings`));
     const globalOpts = program2.opts();
     const db = getDatabase();
     const projectId = globalOpts.project ? autoProject(globalOpts) || undefined : undefined;
+    const cloud = getTodosCloudClient();
     const filter = { assigned_to: agent };
     if (projectId)
       filter.project_id = projectId;
-    const tasks = listTasks(filter, db);
+    const tasks = cloud ? await cloudListTasks(cloud, filter) : listTasks(filter, db);
     const filterByAgent = { agent_id: agent };
     if (projectId)
       filterByAgent.project_id = projectId;
-    const agentTasks = listTasks(filterByAgent, db);
+    const agentTasks = cloud ? await cloudListTasks(cloud, filterByAgent) : listTasks(filterByAgent, db);
     const seen = new Set(tasks.map((t) => t.id));
     for (const t of agentTasks) {
       if (!seen.has(t.id)) {
@@ -69201,17 +69789,27 @@ Findings`));
   program2.command("blocked").description("Show tasks blocked by incomplete dependencies").option("-j, --json", "Output as JSON").option("--project <id>", "Filter to project").action(async (opts) => {
     const globalOpts = program2.opts();
     const db = getDatabase();
-    const { getBlockingDeps: getBlockingDeps2 } = await Promise.resolve().then(() => (init_tasks(), exports_tasks));
+    const cloud = getTodosCloudClient();
     const projectId = autoProject(globalOpts) || opts.project || undefined;
     const filter = { status: "pending" };
     if (projectId)
       filter.project_id = projectId;
-    const allPending = listTasks(filter, db);
+    const allPending = cloud ? await cloudListTasks(cloud, filter) : listTasks(filter, db);
     const blockedTasks = [];
-    for (const t of allPending) {
-      const blockers = getBlockingDeps2(t.id, db);
-      if (blockers.length > 0)
-        blockedTasks.push({ task: t, blockers });
+    if (cloud) {
+      const map = await cloudBlockingDepsMap(cloud, allPending);
+      for (const t of allPending) {
+        const blockers = map.get(t.id);
+        if (blockers && blockers.length > 0)
+          blockedTasks.push({ task: t, blockers });
+      }
+    } else {
+      const { getBlockingDeps: getBlockingDeps2 } = await Promise.resolve().then(() => (init_tasks(), exports_tasks));
+      for (const t of allPending) {
+        const blockers = getBlockingDeps2(t.id, db);
+        if (blockers.length > 0)
+          blockedTasks.push({ task: t, blockers });
+      }
     }
     if (opts.json || globalOpts.json) {
       console.log(JSON.stringify(blockedTasks.map((b) => ({ ...b.task, blocked_by: b.blockers.map((bl) => ({ id: bl.id, short_id: bl.short_id, title: bl.title, status: bl.status })) }))));
@@ -69233,8 +69831,9 @@ Findings`));
   program2.command("overdue").description("Show tasks past their due date").option("-j, --json", "Output as JSON").option("--project <id>", "Filter to project").action(async (opts) => {
     const globalOpts = program2.opts();
     const projectId = autoProject(globalOpts) || opts.project || undefined;
+    const cloud = getTodosCloudClient();
     const { getOverdueTasks: getOverdueTasks2 } = await Promise.resolve().then(() => (init_tasks(), exports_tasks));
-    const tasks = getOverdueTasks2(projectId);
+    const tasks = cloud ? await cloudOverdueTasks(cloud, projectId) : getOverdueTasks2(projectId);
     if (opts.json || globalOpts.json) {
       console.log(JSON.stringify(tasks));
       return;
@@ -69255,10 +69854,8 @@ Findings`));
   program2.command("sla").description("Show overdue or SLA-breached tasks that need escalation").option("-j, --json", "Output as JSON").option("--project <id>", "Filter to project").option("--agent <id>", "Filter to assigned agent").option("--limit <n>", "Max tasks to show", "50").action(async (opts) => {
     const globalOpts = program2.opts();
     const projectId = autoProject(globalOpts) || opts.project || undefined;
-    const escalations = getEscalatedTasks({
-      project_id: projectId,
-      agent_id: opts.agent
-    }).slice(0, parseInt(opts.limit, 10));
+    const cloud = getTodosCloudClient();
+    const escalations = (cloud ? await cloudEscalatedTasks(cloud, { project_id: projectId, agent_id: opts.agent }) : getEscalatedTasks({ project_id: projectId, agent_id: opts.agent })).slice(0, parseInt(opts.limit, 10));
     if (opts.json || globalOpts.json) {
       console.log(JSON.stringify(escalations));
       return;
@@ -69278,12 +69875,13 @@ Findings`));
   program2.command("week").description("Show task activity from the past 7 days").option("-j, --json", "Output as JSON").action(async (opts) => {
     const globalOpts = program2.opts();
     const db = getDatabase();
+    const cloud = getTodosCloudClient();
     const { getTasksChangedSince: getTasksChangedSince2 } = await Promise.resolve().then(() => (init_tasks(), exports_tasks));
     const now4 = new Date;
     const start = new Date(now4);
     start.setDate(start.getDate() - 7);
     start.setHours(0, 0, 0, 0);
-    const tasks = getTasksChangedSince2(start.toISOString(), undefined, db);
+    const tasks = cloud ? await cloudChangedSince(cloud, start.toISOString()) : getTasksChangedSince2(start.toISOString(), undefined, db);
     const days = {};
     for (let i = 0;i < 7; i++) {
       const d = new Date(now4);
@@ -69331,9 +69929,10 @@ Findings`));
   program2.command("burndown").description("Show task completion velocity over the past 7 days").option("--days <n>", "Number of days", "7").option("-j, --json", "Output as JSON").action(async (opts) => {
     const globalOpts = program2.opts();
     const db = getDatabase();
+    const cloud = getTodosCloudClient();
     const { getRecentActivity: getRecentActivity2 } = await Promise.resolve().then(() => (init_audit(), exports_audit));
     const numDays = parseInt(opts.days, 10);
-    const entries = getRecentActivity2(5000, db);
+    const entries = cloud ? await cloudRecentActivity(cloud, 5000) : getRecentActivity2(5000, db);
     const now4 = new Date;
     const dayStats = [];
     for (let i = numDays - 1;i >= 0; i--) {
@@ -69373,8 +69972,9 @@ Findings`));
   program2.command("log").description("Show recent task activity log (git-log style)").option("--limit <n>", "Number of entries", "30").option("-j, --json", "Output as JSON").action(async (opts) => {
     const globalOpts = program2.opts();
     const db = getDatabase();
+    const cloud = getTodosCloudClient();
     const { getRecentActivity: getRecentActivity2 } = await Promise.resolve().then(() => (init_audit(), exports_audit));
-    const entries = getRecentActivity2(parseInt(opts.limit, 10), db);
+    const entries = cloud ? await cloudRecentActivity(cloud, parseInt(opts.limit, 10)) : getRecentActivity2(parseInt(opts.limit, 10), db);
     if (opts.json || globalOpts.json) {
       console.log(JSON.stringify(entries));
       return;
@@ -69417,6 +70017,39 @@ Findings`));
   program2.command("timeline").description("Show a unified local activity timeline for tasks, projects, plans, or runs").option("--task <id>", "Filter to a task").option("--project <id>", "Filter to a project").option("--plan <id>", "Filter to a plan").option("--run <id>", "Filter to a run ledger").option("--since <iso>", "Only include entries at or after this ISO timestamp").option("--until <iso>", "Only include entries at or before this ISO timestamp").option("--limit <n>", "Number of entries", "50").option("--offset <n>", "Entries to skip", "0").option("--order <order>", "Sort order: asc or desc", "desc").option("-j, --json", "Output as JSON").action(async (opts) => {
     const globalOpts = program2.opts();
     const db = getDatabase();
+    const cloud = getTodosCloudClient();
+    if (cloud) {
+      const cloudOptions = {
+        since: opts.since,
+        until: opts.until,
+        limit: parseInt(opts.limit, 10),
+        offset: parseInt(opts.offset, 10),
+        order: opts.order === "asc" ? "asc" : "desc",
+        ...opts.task ? { entity_type: "task", entity_id: opts.task } : {},
+        ...opts.project ? { entity_type: "project", entity_id: opts.project } : {},
+        ...opts.plan ? { entity_type: "plan", entity_id: opts.plan } : {},
+        ...opts.run ? { entity_type: "run", entity_id: opts.run } : {}
+      };
+      const timeline2 = await cloudTimeline(cloud, cloudOptions);
+      if (opts.json || globalOpts.json) {
+        console.log(JSON.stringify(timeline2, null, 2));
+        return;
+      }
+      if (timeline2.entries.length === 0) {
+        console.log(chalk7.dim("  No activity yet."));
+        return;
+      }
+      console.log(chalk7.bold(`Activity timeline (${timeline2.total}${timeline2.total > timeline2.entries.length ? `, showing ${timeline2.entries.length}` : ""}):
+`));
+      for (const entry2 of timeline2.entries) {
+        const time2 = entry2.created_at.replace("T", " ").slice(0, 16);
+        const ref = entry2.run_id ? `run ${entry2.run_id.slice(0, 8)}` : `task ${entry2.task_id.slice(0, 8)}`;
+        const agent = entry2.agent_id ? chalk7.dim(` (${entry2.agent_id})`) : "";
+        const message = entry2.message ? ` ${entry2.message}` : "";
+        console.log(`  ${chalk7.dim(time2)} ${chalk7.cyan(entry2.source)} ${chalk7.dim(ref)} ${entry2.event_type}${message}${agent}`);
+      }
+      return;
+    }
     const { getLocalActivityTimeline: getLocalActivityTimeline2 } = await Promise.resolve().then(() => (init_activity_timeline(), exports_activity_timeline));
     const { resolveTaskRunId: resolveTaskRunId2 } = await Promise.resolve().then(() => (init_task_runs(), exports_task_runs));
     const options = {
@@ -69501,21 +70134,35 @@ Findings`));
       return;
     }
     const db = getDatabase();
-    const { getBlockingDeps: getBlockingDeps2 } = await Promise.resolve().then(() => (init_tasks(), exports_tasks));
+    const cloud = getTodosCloudClient();
     const { isLockExpired: isLockExpired2 } = await Promise.resolve().then(() => (init_database(), exports_database));
     const projectId = autoProject(globalOpts) || opts.project || undefined;
     const filter = { status: "pending" };
     if (projectId)
       filter.project_id = projectId;
-    const pending = listTasks(filter, db);
-    const ready = pending.filter((t) => {
-      if (t.locked_by && !isLockExpired2(t.locked_at))
-        return false;
-      const blockers = getBlockingDeps2(t.id, db);
-      return blockers.length === 0;
-    });
+    const pending = cloud ? await cloudListTasks(cloud, filter) : listTasks(filter, db);
+    let ready;
+    if (cloud) {
+      const map = await cloudBlockingDepsMap(cloud, pending);
+      ready = pending.filter((t) => {
+        if (t.locked_by && !isLockExpired2(t.locked_at))
+          return false;
+        return !map.has(t.id);
+      });
+    } else {
+      const { getBlockingDeps: getBlockingDeps2 } = await Promise.resolve().then(() => (init_tasks(), exports_tasks));
+      ready = pending.filter((t) => {
+        if (t.locked_by && !isLockExpired2(t.locked_at))
+          return false;
+        return getBlockingDeps2(t.id, db).length === 0;
+      });
+    }
     const limited2 = ready.slice(0, parseInt(opts.limit, 10));
     if (opts.json || globalOpts.json) {
+      if (cloud) {
+        console.log(JSON.stringify(limited2));
+        return;
+      }
       const { getTaskRouteState: getTaskRouteState2 } = await Promise.resolve().then(() => (init_task_routing(), exports_task_routing));
       console.log(JSON.stringify(limited2.map((task2) => ({ ...task2, route_state: getTaskRouteState2(task2, db) }))));
       return;
@@ -69535,19 +70182,29 @@ Findings`));
   program2.command("sprint").description("Sprint dashboard: in-progress, next up, blockers, and overdue").option("-j, --json", "Output as JSON").option("--project <id>", "Filter to project").action(async (opts) => {
     const globalOpts = program2.opts();
     const db = getDatabase();
-    const { getBlockingDeps: getBlockingDeps2 } = await Promise.resolve().then(() => (init_tasks(), exports_tasks));
+    const cloud = getTodosCloudClient();
     const projectId = autoProject(globalOpts) || opts.project || undefined;
     const baseFilter = {};
     if (projectId)
       baseFilter.project_id = projectId;
-    const inProgress = listTasks({ ...baseFilter, status: "in_progress" }, db);
-    const pending = listTasks({ ...baseFilter, status: "pending" }, db);
+    const inProgress = cloud ? await cloudListTasks(cloud, { ...baseFilter, status: "in_progress" }) : listTasks({ ...baseFilter, status: "in_progress" }, db);
+    const pending = cloud ? await cloudListTasks(cloud, { ...baseFilter, status: "pending" }) : listTasks({ ...baseFilter, status: "pending" }, db);
     const nowStr = new Date().toISOString();
     const blocked = [];
-    for (const t of pending) {
-      const blockers = getBlockingDeps2(t.id, db);
-      if (blockers.length > 0)
-        blocked.push({ task: t, blockers });
+    if (cloud) {
+      const map = await cloudBlockingDepsMap(cloud, pending);
+      for (const t of pending) {
+        const blockers = map.get(t.id);
+        if (blockers && blockers.length > 0)
+          blocked.push({ task: t, blockers });
+      }
+    } else {
+      const { getBlockingDeps: getBlockingDeps2 } = await Promise.resolve().then(() => (init_tasks(), exports_tasks));
+      for (const t of pending) {
+        const blockers = getBlockingDeps2(t.id, db);
+        if (blockers.length > 0)
+          blocked.push({ task: t, blockers });
+      }
     }
     const overdue = [...inProgress, ...pending].filter((t) => t.due_at && t.due_at < nowStr);
     const blockedIds = new Set(blocked.map((b) => b.task.id));
@@ -69778,17 +70435,20 @@ Findings`));
   program2.command("priorities").description("Show task counts grouped by priority").option("-j, --json", "Output as JSON").option("--project <id>", "Filter to project").action(async (opts) => {
     const globalOpts = program2.opts();
     const db = getDatabase();
+    const cloud = getTodosCloudClient();
     const { countTasks: countTasks2 } = await Promise.resolve().then(() => (init_tasks(), exports_tasks));
+    const countFn = cloud ? (f) => cloudCountTasks(cloud, f) : (f) => Promise.resolve(countTasks2(f, db));
     const projectId = autoProject(globalOpts) || opts.project || undefined;
     const base = projectId ? { project_id: projectId } : {};
     const priorities = ["critical", "high", "medium", "low", "none"];
     const counts = {};
     for (const p of priorities) {
+      const base2 = { ...base, priority: p === "none" ? undefined : p };
       counts[p] = {
-        total: countTasks2({ ...base, priority: p === "none" ? undefined : p }, db),
-        pending: countTasks2({ ...base, priority: p === "none" ? undefined : p, status: "pending" }, db),
-        in_progress: countTasks2({ ...base, priority: p === "none" ? undefined : p, status: "in_progress" }, db),
-        completed: countTasks2({ ...base, priority: p === "none" ? undefined : p, status: "completed" }, db)
+        total: await countFn(base2),
+        pending: await countFn({ ...base2, status: "pending" }),
+        in_progress: await countFn({ ...base2, status: "in_progress" }),
+        completed: await countFn({ ...base2, status: "completed" })
       };
     }
     if (opts.json || globalOpts.json) {
@@ -71258,25 +71918,34 @@ Commands:`));
   });
   program2.command("record-verification <task-id> <command>").description("Record a verification command and result for a task").option("--status <status>", "Verification status: passed, failed, or unknown", "unknown").option("--summary <text>", "Short output summary").option("--artifact <path>", "Artifact or log path").option("--agent <name>", "Agent that ran the command").action(async (taskId, command, opts) => {
     const globalOpts = program2.opts();
-    const resolvedId = resolveTaskId(taskId);
     if (opts.status !== "passed" && opts.status !== "failed" && opts.status !== "unknown") {
       console.error(chalk8.red("--status must be passed, failed, or unknown"));
       process.exit(1);
     }
-    const { addTaskVerification: addTaskVerification2 } = await Promise.resolve().then(() => (init_task_commits(), exports_task_commits));
-    const verification = addTaskVerification2({
-      task_id: resolvedId,
-      command,
-      status: opts.status,
-      output_summary: opts.summary,
-      artifact_path: opts.artifact,
-      agent_id: opts.agent
-    });
-    if (globalOpts.json) {
-      output(verification, true);
-      return;
+    try {
+      const cloud = getTodosCloudClient();
+      const verification = cloud ? await cloudRecordVerification(cloud, resolveTaskId(taskId), {
+        command,
+        status: opts.status,
+        output_summary: opts.summary,
+        artifact_path: opts.artifact,
+        agent_id: opts.agent
+      }) : (await Promise.resolve().then(() => (init_task_commits(), exports_task_commits))).addTaskVerification({
+        task_id: resolveTaskId(taskId),
+        command,
+        status: opts.status,
+        output_summary: opts.summary,
+        artifact_path: opts.artifact,
+        agent_id: opts.agent
+      });
+      if (globalOpts.json) {
+        output(verification, true);
+        return;
+      }
+      console.log(chalk8.green(`Recorded ${verification.status} verification for task ${taskId}`));
+    } catch (e) {
+      handleError(e);
     }
-    console.log(chalk8.green(`Recorded ${verification.status} verification for task ${taskId}`));
   });
   program2.command("trace <task-id>").description("Show local git refs, commits, changed files, and verification commands for a task").action(async (taskId) => {
     const globalOpts = program2.opts();
@@ -71982,6 +72651,7 @@ var HOME2;
 var init_mcp_hooks_commands = __esm(() => {
   init_tasks();
   init_helpers();
+  init_cloud_router();
   HOME2 = process.env["HOME"] || process.env["USERPROFILE"] || "~";
 });