@hasna/todos 0.11.83 → 0.11.85

package/dist/cli/index.js

@@ -8587,6 +8587,54 @@ async function cloudRegisterAgent(client, input) {
   }
   return raw;
 }
+async function cloudHeartbeatAgent(client, idOrName) {
+  const raw = await client.transport.post(`/agents/${encodeURIComponent(idOrName)}/heartbeat`, {});
+  if (raw && typeof raw === "object" && "agent" in raw) {
+    return raw.agent;
+  }
+  return raw ?? null;
+}
+async function cloudReleaseAgent(client, idOrName, sessionId) {
+  const raw = await client.transport.post(`/agents/${encodeURIComponent(idOrName)}/release`, sessionId ? { session_id: sessionId } : {});
+  const env = raw ?? {};
+  return { agent: env.agent ?? null, released: env.released !== false };
+}
+async function cloudLinkCommit(client, taskId, input) {
+  const raw = await client.transport.post(`/tasks/${encodeURIComponent(taskId)}/commits`, input);
+  if (raw && typeof raw === "object" && "commit" in raw) {
+    return raw.commit;
+  }
+  return raw;
+}
+async function cloudFindCommit(client, sha) {
+  const raw = await client.transport.get(`/commits/${encodeURIComponent(sha)}`);
+  const env = raw ?? {};
+  return env.commit ?? null;
+}
+async function cloudLinkRef(client, taskId, input) {
+  const raw = await client.transport.post(`/tasks/${encodeURIComponent(taskId)}/refs`, input);
+  if (raw && typeof raw === "object" && "ref" in raw) {
+    return raw.ref;
+  }
+  return raw;
+}
+async function cloudFindRefs(client, ref) {
+  const raw = await client.transport.get(`/refs/${encodeURIComponent(ref)}`);
+  const env = raw ?? {};
+  return Array.isArray(env.refs) ? env.refs : [];
+}
+async function cloudResolvePlan(client, ref, projectId) {
+  const direct = await client.get("plans", ref).catch(() => null);
+  if (direct) {
+    const env = direct;
+    if (env.plan)
+      return env.plan;
+    if (direct.id)
+      return direct;
+  }
+  const plans = await cloudListPlans(client, projectId);
+  return plans.find((p) => p.id === ref) ?? plans.find((p) => p.slug === ref) ?? plans.find((p) => p.name === ref) ?? plans.find((p) => p.id.startsWith(ref)) ?? null;
+}
 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) {
@@ -8627,9 +8675,230 @@ async function cloudRecordVerification(client, id, input) {
   }
   return raw;
 }
-var _cache;
+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
@@ -16438,11 +16707,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 {}
   }
@@ -16459,7 +16728,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) {
@@ -20873,28 +21142,54 @@ ${chalk2.cyan(sid)} ${statusColor(task2.status)} ${prioColor(task2.priority)} ${
       console.log(formatTaskLine(task2));
     }
   });
-  program2.command("approve <id>").description("Approve a task that requires approval").action((id) => {
+  program2.command("approve <id>").description("Approve a task that requires approval").action(async (id) => {
     const globalOpts = program2.opts();
-    const resolvedId = resolveTaskId(id);
-    const task2 = getTask(resolvedId);
-    if (!task2) {
-      console.error(chalk2.red(`Task not found: ${id}`));
-      process.exit(1);
-    }
-    if (!task2.requires_approval) {
-      console.log(chalk2.yellow("This task does not require approval."));
-      return;
-    }
-    if (task2.approved_by) {
-      console.log(chalk2.yellow(`Already approved by ${task2.approved_by}.`));
-      return;
-    }
+    const approver = globalOpts.agent || "cli";
     try {
-      const updated = updateTask(resolvedId, { approved_by: globalOpts.agent || "cli", version: task2.version });
+      const cloud = getTodosCloudClient();
+      if (cloud) {
+        const cloudId = resolveTaskId(id);
+        const task3 = await cloudGetTask(cloud, cloudId);
+        if (!task3) {
+          console.error(chalk2.red(`Task not found: ${id}`));
+          process.exit(1);
+        }
+        if (!task3.requires_approval) {
+          console.log(chalk2.yellow("This task does not require approval."));
+          return;
+        }
+        if (task3.approved_by) {
+          console.log(chalk2.yellow(`Already approved by ${task3.approved_by}.`));
+          return;
+        }
+        const updated2 = await cloudUpdateTask(cloud, cloudId, { approved_by: approver, version: task3.version });
+        if (globalOpts.json) {
+          output(updated2, true);
+        } else {
+          console.log(chalk2.green(`Task approved by ${approver}:`));
+          console.log(formatTaskLine(updated2));
+        }
+        return;
+      }
+      const resolvedId = resolveTaskId(id);
+      const task2 = getTask(resolvedId);
+      if (!task2) {
+        console.error(chalk2.red(`Task not found: ${id}`));
+        process.exit(1);
+      }
+      if (!task2.requires_approval) {
+        console.log(chalk2.yellow("This task does not require approval."));
+        return;
+      }
+      if (task2.approved_by) {
+        console.log(chalk2.yellow(`Already approved by ${task2.approved_by}.`));
+        return;
+      }
+      const updated = updateTask(resolvedId, { approved_by: approver, version: task2.version });
       if (globalOpts.json) {
         output(updated, true);
       } else {
-        console.log(chalk2.green(`Task approved by ${globalOpts.agent || "cli"}:`));
+        console.log(chalk2.green(`Task approved by ${approver}:`));
         console.log(formatTaskLine(updated));
       }
     } catch (e) {
@@ -21812,6 +22107,40 @@ function registerPlanTemplateCommands(program2) {
       return;
     }
     if (opts.show) {
+      if (cloud) {
+        const plan2 = await cloudResolvePlan(cloud, opts.show, projectId);
+        if (!plan2) {
+          console.error(chalk3.red(`Plan not found: ${opts.show}`));
+          process.exit(1);
+        }
+        const tasks2 = await cloudListTasks(cloud, { plan_id: plan2.id });
+        if (globalOpts.json) {
+          output({ plan: plan2, tasks: tasks2, artifact: null }, true);
+          return;
+        }
+        console.log(chalk3.bold(`Plan Details:
+`));
+        console.log(`  ${chalk3.dim("ID:")}       ${plan2.id}`);
+        if (plan2.slug)
+          console.log(`  ${chalk3.dim("Slug:")}     ${plan2.slug}`);
+        console.log(`  ${chalk3.dim("Name:")}     ${plan2.name}`);
+        console.log(`  ${chalk3.dim("Status:")}   ${chalk3.cyan(plan2.status)}`);
+        if (plan2.description)
+          console.log(`  ${chalk3.dim("Desc:")}     ${plan2.description}`);
+        if (plan2.project_id)
+          console.log(`  ${chalk3.dim("Project:")}  ${plan2.project_id}`);
+        console.log(`  ${chalk3.dim("Created:")}  ${plan2.created_at}`);
+        if (tasks2.length > 0) {
+          console.log(chalk3.bold(`
+  Tasks (${tasks2.length}):`));
+          for (const t of tasks2)
+            console.log(`    ${formatTaskLine(t)}`);
+        } else {
+          console.log(chalk3.dim(`
+  No tasks in this plan.`));
+        }
+        return;
+      }
       const db = getDatabase();
       const resolvedId = resolvePlanCliRef(opts.show, projectId);
       const plan = getPlan(resolvedId);
@@ -29707,11 +30036,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);
@@ -32911,17 +33240,35 @@ Use ${chalk5.cyan(`--agent ${result.id}`)} on future commands.`);
       console.error(chalk5.red("Agent ID required. Use --agent or pass as argument."));
       process.exit(1);
     }
-    const { updateAgentActivity: updateAgentActivity2, getAgent: getAgent2, getAgentByName: getAgentByName2 } = await Promise.resolve().then(() => (init_agents(), exports_agents));
-    const a = getAgent2(agentId) || getAgentByName2(agentId);
-    if (!a) {
-      console.error(chalk5.red(`Agent not found: ${agentId}`));
-      process.exit(1);
-    }
-    updateAgentActivity2(a.id);
-    if (globalOpts.json) {
-      console.log(JSON.stringify({ agent_id: a.id, name: a.name, last_seen_at: new Date().toISOString() }));
-    } else {
-      console.log(chalk5.green(`\u2665 ${a.name} (${a.id.slice(0, 8)}) \u2014 heartbeat sent`));
+    try {
+      const cloud = getTodosCloudClient();
+      if (cloud) {
+        const a2 = await cloudHeartbeatAgent(cloud, agentId);
+        if (!a2) {
+          console.error(chalk5.red(`Agent not found: ${agentId}`));
+          process.exit(1);
+        }
+        if (globalOpts.json) {
+          console.log(JSON.stringify({ agent_id: a2.id, name: a2.name, last_seen_at: a2.last_seen_at }));
+        } else {
+          console.log(chalk5.green(`\u2665 ${a2.name} (${a2.id.slice(0, 8)}) \u2014 heartbeat sent`));
+        }
+        return;
+      }
+      const { updateAgentActivity: updateAgentActivity2, getAgent: getAgent2, getAgentByName: getAgentByName2 } = await Promise.resolve().then(() => (init_agents(), exports_agents));
+      const a = getAgent2(agentId) || getAgentByName2(agentId);
+      if (!a) {
+        console.error(chalk5.red(`Agent not found: ${agentId}`));
+        process.exit(1);
+      }
+      updateAgentActivity2(a.id);
+      if (globalOpts.json) {
+        console.log(JSON.stringify({ agent_id: a.id, name: a.name, last_seen_at: new Date().toISOString() }));
+      } else {
+        console.log(chalk5.green(`\u2665 ${a.name} (${a.id.slice(0, 8)}) \u2014 heartbeat sent`));
+      }
+    } catch (e) {
+      handleError(e);
     }
   });
   program2.command("release [agent]").description("Release/logout an agent \u2014 clears session binding so the name is immediately available").option("--session-id <id>", "Only release if session ID matches").action(async (agent, opts) => {
@@ -32931,21 +33278,43 @@ Use ${chalk5.cyan(`--agent ${result.id}`)} on future commands.`);
       console.error(chalk5.red("Agent ID or name required. Use --agent or pass as argument."));
       process.exit(1);
     }
-    const { getAgent: getAgent2, getAgentByName: getAgentByName2 } = await Promise.resolve().then(() => (init_agents(), exports_agents));
-    const a = getAgent2(agentId) || getAgentByName2(agentId);
-    if (!a) {
-      console.error(chalk5.red(`Agent not found: ${agentId}`));
-      process.exit(1);
-    }
-    const released = releaseAgent(a.id, opts?.sessionId);
-    if (!released) {
-      console.error(chalk5.red("Release denied: session_id does not match agent's current session."));
-      process.exit(1);
-    }
-    if (globalOpts.json) {
-      console.log(JSON.stringify({ agent_id: a.id, name: a.name, released: true }));
-    } else {
-      console.log(chalk5.green(`\u2713 ${a.name} (${a.id}) released \u2014 name is now available.`));
+    try {
+      const cloud = getTodosCloudClient();
+      if (cloud) {
+        const result = await cloudReleaseAgent(cloud, agentId, opts?.sessionId);
+        if (!result.agent) {
+          console.error(chalk5.red(`Agent not found: ${agentId}`));
+          process.exit(1);
+        }
+        if (!result.released) {
+          console.error(chalk5.red("Release denied: session_id does not match agent's current session."));
+          process.exit(1);
+        }
+        if (globalOpts.json) {
+          console.log(JSON.stringify({ agent_id: result.agent.id, name: result.agent.name, released: true }));
+        } else {
+          console.log(chalk5.green(`\u2713 ${result.agent.name} (${result.agent.id}) released \u2014 name is now available.`));
+        }
+        return;
+      }
+      const { getAgent: getAgent2, getAgentByName: getAgentByName2 } = await Promise.resolve().then(() => (init_agents(), exports_agents));
+      const a = getAgent2(agentId) || getAgentByName2(agentId);
+      if (!a) {
+        console.error(chalk5.red(`Agent not found: ${agentId}`));
+        process.exit(1);
+      }
+      const released = releaseAgent(a.id, opts?.sessionId);
+      if (!released) {
+        console.error(chalk5.red("Release denied: session_id does not match agent's current session."));
+        process.exit(1);
+      }
+      if (globalOpts.json) {
+        console.log(JSON.stringify({ agent_id: a.id, name: a.name, released: true }));
+      } else {
+        console.log(chalk5.green(`\u2713 ${a.name} (${a.id}) released \u2014 name is now available.`));
+      }
+    } catch (e) {
+      handleError(e);
     }
   });
   program2.command("focus [project]").description("Focus on a project (or clear focus if no project given)").action(async (project) => {
@@ -33043,14 +33412,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))
@@ -33188,7 +33558,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;
@@ -38467,12 +38838,23 @@ function createPostgresTodosStorageAdapter(options) {
     dependencies: {
       add: (taskId, dependsOn, context) => addDependency2(taskId, dependsOn, store, context),
       remove: (taskId, dependsOn) => removeDependency2(taskId, dependsOn, store),
-      list: (taskId) => listDependencies(taskId, store)
+      list: (taskId) => listDependencies(taskId, store),
+      listAll: () => store.list("dependencies")
     },
     verifications: {
       add: (input, context) => addVerification(input, store, context),
       list: (taskId) => listVerifications(taskId, store)
     },
+    commits: {
+      add: (input, context) => addCommit(input, store, context),
+      list: (taskId) => listCommits(taskId, store),
+      find: (sha) => findCommit(sha, store)
+    },
+    gitRefs: {
+      add: (input, context) => addGitRef(input, store, context),
+      list: (taskId) => listGitRefs(taskId, store),
+      find: (ref) => findGitRefs(ref, store)
+    },
     projects: {
       create: (input, context) => createProject2(input, store, context),
       get: (id) => store.get("projects", id),
@@ -38493,7 +38875,9 @@ function createPostgresTodosStorageAdapter(options) {
       get: (id) => store.get("agents", id),
       getByName: async (name) => (await store.list("agents")).find((agent) => agent.name === name) ?? null,
       list: async (options2) => (await store.list("agents")).filter((agent) => options2?.include_archived || agent.status !== "archived").sort((a, b) => a.name.localeCompare(b.name)),
-      update: (id, input) => updateAgent2(id, input, store)
+      update: (id, input) => updateAgent2(id, input, store),
+      heartbeat: (idOrName, context) => heartbeatAgent(idOrName, store, context),
+      release: (idOrName, sessionId, context) => releaseAgent2(idOrName, sessionId, store, context)
     },
     taskLists: {
       create: (input, context) => createTaskList2(input, store, context),
@@ -39023,6 +39407,53 @@ async function addVerification(input, store, context) {
 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));
 }
+async function addCommit(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 commit = {
+    id: randomUUID3(),
+    task_id: input.task_id,
+    sha: input.sha,
+    message: input.message ?? null,
+    author: input.author ?? null,
+    files_changed: input.files_changed ?? null,
+    created_at: timestamp
+  };
+  await store.upsert("commits", { ...commit, updated_at: timestamp }, context);
+  return commit;
+}
+async function listCommits(taskId, store) {
+  return (await store.list("commits")).filter((commit) => commit.task_id === taskId).sort((a, b) => b.created_at.localeCompare(a.created_at));
+}
+async function findCommit(sha, store) {
+  const matches = (await store.list("commits")).filter((commit) => commit.sha === sha || commit.sha.startsWith(sha) || sha.startsWith(commit.sha)).sort((a, b) => b.created_at.localeCompare(a.created_at));
+  return matches[0] ?? null;
+}
+async function addGitRef(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 gitRef = {
+    id: randomUUID3(),
+    task_id: input.task_id,
+    ref_type: input.ref_type,
+    name: input.name,
+    url: input.url ?? null,
+    provider: input.provider ?? null,
+    metadata: input.metadata ?? {},
+    created_at: timestamp,
+    updated_at: timestamp
+  };
+  await store.upsert("refs", gitRef, context);
+  return gitRef;
+}
+async function listGitRefs(taskId, store) {
+  return (await store.list("refs")).filter((ref) => ref.task_id === taskId).sort((a, b) => b.created_at.localeCompare(a.created_at));
+}
+async function findGitRefs(ref, store) {
+  return (await store.list("refs")).filter((r) => r.name === ref).sort((a, b) => b.created_at.localeCompare(a.created_at));
+}
 function toFilterArray(value) {
   return Array.isArray(value) ? value : [value];
 }
@@ -39169,6 +39600,28 @@ async function updateAgent2(id, input, store) {
     last_seen_at: new Date().toISOString()
   });
 }
+async function resolveAgent(idOrName, store) {
+  const byId = await store.get("agents", idOrName);
+  if (byId)
+    return byId;
+  return (await store.list("agents")).find((agent) => agent.name === idOrName) ?? null;
+}
+async function heartbeatAgent(idOrName, store, context) {
+  const agent = await resolveAgent(idOrName, store);
+  if (!agent)
+    return null;
+  return store.upsert("agents", { ...agent, last_seen_at: new Date().toISOString() }, context);
+}
+async function releaseAgent2(idOrName, sessionId, store, context) {
+  const agent = await resolveAgent(idOrName, store);
+  if (!agent)
+    return null;
+  if (sessionId && agent.session_id && agent.session_id !== sessionId) {
+    return { agent, released: false };
+  }
+  const updated = await store.upsert("agents", { ...agent, session_id: null, last_seen_at: new Date().toISOString() }, context);
+  return { agent: updated, released: true };
+}
 async function createTaskList2(input, store, context) {
   const timestamp = new Date().toISOString();
   return store.upsert("task_lists", {
@@ -40053,6 +40506,70 @@ async function handleV1Request(req, url) {
           }
           return error(405, `method ${method} not allowed on /v1/tasks/:id/verifications`);
         }
+        if (action === "commits") {
+          if (!store.commits)
+            return error(501, "commit links are not supported by this storage backend");
+          if (method === "GET") {
+            if (!await store.tasks.get(id))
+              return error(404, "task not found");
+            const commits = await store.commits.list(id);
+            return json2({ commits, count: commits.length });
+          }
+          if (method === "POST") {
+            const body2 = await readJson(req) ?? {};
+            if (typeof body2.sha !== "string" || !body2.sha.trim())
+              return error(400, "sha is required");
+            try {
+              const commit = await store.commits.add({
+                task_id: id,
+                sha: body2.sha,
+                message: body2.message,
+                author: body2.author,
+                files_changed: Array.isArray(body2.files_changed) ? body2.files_changed : undefined
+              }, contextFromPrincipal(principal));
+              return json2({ commit }, 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/commits`);
+        }
+        if (action === "refs") {
+          if (!store.gitRefs)
+            return error(501, "git ref links are not supported by this storage backend");
+          if (method === "GET") {
+            if (!await store.tasks.get(id))
+              return error(404, "task not found");
+            const refs = await store.gitRefs.list(id);
+            return json2({ refs, count: refs.length });
+          }
+          if (method === "POST") {
+            const body2 = await readJson(req) ?? {};
+            const refType = body2.ref_type === "pull_request" || body2.ref_type === "branch" ? body2.ref_type : "branch";
+            if (typeof body2.name !== "string" || !body2.name.trim())
+              return error(400, "name is required");
+            try {
+              const ref = await store.gitRefs.add({
+                task_id: id,
+                ref_type: refType,
+                name: body2.name,
+                url: body2.url,
+                provider: body2.provider,
+                metadata: body2.metadata
+              }, contextFromPrincipal(principal));
+              return json2({ ref }, 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/refs`);
+        }
         const body = await readJson(req) ?? {};
         const agentId = body.agent_id || principal.agent || "todos-serve";
         if (action === "start" && method === "POST") {
@@ -40165,11 +40682,87 @@ async function handleV1Request(req, url) {
         }
         return json2({ agent: result }, 201);
       }
+      if (id && action === "heartbeat") {
+        if (method !== "POST")
+          return error(405, `method ${method} not allowed on /v1/agents/:id/heartbeat`);
+        if (typeof store.agents.heartbeat !== "function") {
+          return error(501, "agent heartbeat is not supported by this storage backend");
+        }
+        const agent = await store.agents.heartbeat(id, contextFromPrincipal(principal));
+        return agent ? json2({ agent }) : error(404, "agent not found");
+      }
+      if (id && action === "release") {
+        if (method !== "POST")
+          return error(405, `method ${method} not allowed on /v1/agents/:id/release`);
+        if (typeof store.agents.release !== "function") {
+          return error(501, "agent release is not supported by this storage backend");
+        }
+        const body = await readJson(req) ?? {};
+        const result = await store.agents.release(id, body.session_id, contextFromPrincipal(principal));
+        if (!result)
+          return error(404, "agent not found");
+        if (!result.released) {
+          return error(409, "release denied: session_id does not match agent's current session", { released: false });
+        }
+        return json2({ agent: result.agent, released: true });
+      }
       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 === "commits" && id) {
+      if (method !== "GET")
+        return error(405, `method ${method} not allowed on /v1/commits/:sha`);
+      if (!store.commits)
+        return error(501, "commit links are not supported by this storage backend");
+      const commit = await store.commits.find(id);
+      return json2({ commit: commit ?? null });
+    }
+    if (resource === "refs" && id) {
+      if (method !== "GET")
+        return error(405, `method ${method} not allowed on /v1/refs/:ref`);
+      if (!store.gitRefs)
+        return error(501, "git ref links are not supported by this storage backend");
+      const refs = await store.gitRefs.find(id);
+      return json2({ refs, count: refs.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(),
@@ -45514,7 +46107,7 @@ function resolveRun(parsed, db) {
   }
   return resolution;
 }
-function resolveAgent(parsed, db) {
+function resolveAgent2(parsed, db) {
   const resolution = blankResolution(parsed);
   const id = resolvePartialId(db, "agents", parsed.target);
   const agent = id ? getAgent(id, db) : getAgentByName(parsed.target, db);
@@ -45551,7 +46144,7 @@ function resolveTask(parsed, db) {
 function resolveUnknown(parsed, workspace, db, maxSymbolMatches) {
   const attempts = [
     () => resolveTask({ ...parsed, kind: "task" }, db),
-    () => resolveAgent({ ...parsed, kind: "agent" }, db),
+    () => resolveAgent2({ ...parsed, kind: "agent" }, db),
     () => resolvePlan({ ...parsed, kind: "plan" }, db),
     () => resolveSymbol({ ...parsed, kind: "symbol" }, workspace, maxSymbolMatches)
   ];
@@ -45586,7 +46179,7 @@ function resolveMentions(input, db) {
       case "run":
         return resolveRun(parsed, d);
       case "agent":
-        return resolveAgent(parsed, d);
+        return resolveAgent2(parsed, d);
       case "task":
         return resolveTask(parsed, d);
       default:
@@ -55400,7 +55993,7 @@ function resolveProjectId(value, db) {
     return null;
   return resolvePartialId(db, "projects", value) || value;
 }
-function resolveAgent2(agentId, db) {
+function resolveAgent3(agentId, db) {
   return db.query("SELECT id, name FROM agents WHERE id = ? OR LOWER(name) = LOWER(?)").get(agentId, agentId);
 }
 function agentTaskWhere(agent, options, db) {
@@ -55444,7 +56037,7 @@ function scoreHandoffs(created, withTaskRefs, withBlockers) {
 }
 function getAgentReliabilityScorecard(agentId, options = {}, db) {
   const d = db || getDatabase();
-  const agent = resolveAgent2(agentId, d);
+  const agent = resolveAgent3(agentId, d);
   if (!agent)
     return null;
   const generatedAt = now();
@@ -55613,7 +56206,7 @@ function getAgentReliabilityScorecard(agentId, options = {}, db) {
 }
 function listAgentReliabilityScorecards(options = {}, db) {
   const d = db || getDatabase();
-  const agents = options.agent_id ? resolveAgent2(options.agent_id, d) ? [resolveAgent2(options.agent_id, d)] : [] : d.query("SELECT id, name FROM agents ORDER BY name").all();
+  const agents = options.agent_id ? resolveAgent3(options.agent_id, d) ? [resolveAgent3(options.agent_id, d)] : [] : d.query("SELECT id, name FROM agents ORDER BY name").all();
   const limit = Number.isFinite(options.limit) && options.limit > 0 ? Math.min(Math.floor(options.limit), 500) : 50;
   return agents.map((agent) => getAgentReliabilityScorecard(agent.id, options, d)).filter((scorecard) => Boolean(scorecard)).filter((scorecard) => {
     const signals = scorecard.signals;
@@ -62984,6 +63577,19 @@ ID: ${updated.id}${taskNote}`
       agent_id: exports_external3.string().describe("Your agent ID or name.")
     }, async ({ agent_id }) => {
       try {
+        const cloud = getTodosCloudClient();
+        if (cloud) {
+          const a = await cloudHeartbeatAgent(cloud, agent_id);
+          if (!a) {
+            return { content: [{ type: "text", text: `Agent not found: ${agent_id}` }], isError: true };
+          }
+          return {
+            content: [{
+              type: "text",
+              text: `Heartbeat: ${a.name} (${a.id}) \u2014 last_seen_at updated to ${a.last_seen_at}`
+            }]
+          };
+        }
         const agent = getAgent(agent_id) || getAgentByName(agent_id);
         if (!agent) {
           return { content: [{ type: "text", text: `Agent not found: ${agent_id}` }], isError: true };
@@ -63006,6 +63612,22 @@ ID: ${updated.id}${taskNote}`
       session_id: exports_external3.string().optional().describe("Your session ID \u2014 if provided, release only succeeds if it matches (prevents other sessions from releasing your agent).")
     }, async ({ agent_id, session_id }) => {
       try {
+        const cloud = getTodosCloudClient();
+        if (cloud) {
+          const result = await cloudReleaseAgent(cloud, agent_id, session_id);
+          if (!result.agent) {
+            return { content: [{ type: "text", text: `Agent not found: ${agent_id}` }], isError: true };
+          }
+          if (!result.released) {
+            return { content: [{ type: "text", text: `Release denied: session_id does not match agent's current session.` }], isError: true };
+          }
+          return {
+            content: [{
+              type: "text",
+              text: `Agent released: ${result.agent.name} (${result.agent.id}) \u2014 session cleared, name is now available.`
+            }]
+          };
+        }
         const agent = getAgent(agent_id) || getAgentByName(agent_id);
         if (!agent) {
           return { content: [{ type: "text", text: `Agent not found: ${agent_id}` }], isError: true };
@@ -68640,7 +69262,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));
@@ -68761,9 +69384,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;
@@ -68826,11 +69450,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;
@@ -68900,7 +69525,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;
@@ -68923,7 +69549,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;
@@ -69075,12 +69702,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;
@@ -69347,12 +69975,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);
@@ -69406,10 +70035,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");
@@ -69436,13 +70066,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");
@@ -69470,14 +70101,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)) {
@@ -69519,17 +70151,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 })) }))));
@@ -69551,8 +70193,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;
@@ -69573,10 +70216,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;
@@ -69596,12 +70237,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);
@@ -69649,9 +70291,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--) {
@@ -69691,8 +70334,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;
@@ -69735,6 +70379,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 = {
@@ -69819,21 +70496,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;
@@ -69853,19 +70544,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));
@@ -70096,17 +70797,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) {
@@ -71447,38 +72151,68 @@ exit 0
   program2.command("link-commit <task-id> <sha>").description("Link a git commit to a task").option("--message <text>", "Commit message").option("--author <name>", "Commit author").option("--files <list>", "Comma-separated list of changed files").action(async (taskId, sha, opts) => {
     const globalOpts = program2.opts();
     const resolvedId = resolveTaskId(taskId);
-    const { linkTaskToCommit: linkTaskToCommit2 } = await Promise.resolve().then(() => (init_task_commits(), exports_task_commits));
-    const commit = linkTaskToCommit2({
-      task_id: resolvedId,
-      sha,
-      message: opts.message,
-      author: opts.author,
-      files_changed: opts.files ? opts.files.split(",").filter(Boolean) : undefined
-    });
-    if (globalOpts.json) {
-      output(commit, true);
-      return;
+    const files = opts.files ? opts.files.split(",").filter(Boolean) : undefined;
+    try {
+      const cloud = getTodosCloudClient();
+      const commit = cloud ? await cloudLinkCommit(cloud, resolvedId, {
+        sha,
+        ...opts.message !== undefined ? { message: opts.message } : {},
+        ...opts.author !== undefined ? { author: opts.author } : {},
+        ...files ? { files_changed: files } : {}
+      }) : (await Promise.resolve().then(() => (init_task_commits(), exports_task_commits))).linkTaskToCommit({
+        task_id: resolvedId,
+        sha,
+        message: opts.message,
+        author: opts.author,
+        files_changed: files
+      });
+      if (globalOpts.json) {
+        output(commit, true);
+        return;
+      }
+      console.log(chalk8.green(`Linked commit ${sha.slice(0, 7)} to task ${taskId}`));
+    } catch (e) {
+      handleError(e);
     }
-    console.log(chalk8.green(`Linked commit ${sha.slice(0, 7)} to task ${taskId}`));
   });
   program2.command("find-commit <sha>").description("Find which task explains a git commit SHA").action(async (sha) => {
     const globalOpts = program2.opts();
-    const { findTaskByCommit: findTaskByCommit2 } = await Promise.resolve().then(() => (init_task_commits(), exports_task_commits));
-    const { getTask: getTask3 } = await Promise.resolve().then(() => (init_tasks(), exports_tasks));
-    const result = findTaskByCommit2(sha);
-    if (globalOpts.json) {
-      output(result, true);
-      return;
-    }
-    if (!result) {
-      console.log(chalk8.dim(`No task linked to commit ${sha}.`));
-      return;
+    try {
+      const cloud = getTodosCloudClient();
+      if (cloud) {
+        const commit = await cloudFindCommit(cloud, sha);
+        if (globalOpts.json) {
+          output(commit ? { task_id: commit.task_id, commit } : null, true);
+          return;
+        }
+        if (!commit) {
+          console.log(chalk8.dim(`No task linked to commit ${sha}.`));
+          return;
+        }
+        console.log(`${chalk8.yellow(commit.sha.slice(0, 7))} -> ${chalk8.cyan(commit.task_id)}`);
+        if (commit.message)
+          console.log(chalk8.dim(`  ${commit.message}`));
+        return;
+      }
+      const { findTaskByCommit: findTaskByCommit2 } = await Promise.resolve().then(() => (init_task_commits(), exports_task_commits));
+      const { getTask: getTask3 } = await Promise.resolve().then(() => (init_tasks(), exports_tasks));
+      const result = findTaskByCommit2(sha);
+      if (globalOpts.json) {
+        output(result, true);
+        return;
+      }
+      if (!result) {
+        console.log(chalk8.dim(`No task linked to commit ${sha}.`));
+        return;
+      }
+      const task2 = getTask3(result.task_id);
+      const taskLabel = task2 ? `${task2.short_id || task2.id.slice(0, 8)} ${task2.title}` : result.task_id;
+      console.log(`${chalk8.yellow(result.commit.sha.slice(0, 7))} -> ${chalk8.cyan(taskLabel)}`);
+      if (result.commit.message)
+        console.log(chalk8.dim(`  ${result.commit.message}`));
+    } catch (e) {
+      handleError(e);
     }
-    const task2 = getTask3(result.task_id);
-    const taskLabel = task2 ? `${task2.short_id || task2.id.slice(0, 8)} ${task2.title}` : result.task_id;
-    console.log(`${chalk8.yellow(result.commit.sha.slice(0, 7))} -> ${chalk8.cyan(taskLabel)}`);
-    if (result.commit.message)
-      console.log(chalk8.dim(`  ${result.commit.message}`));
   });
   program2.command("link-ref <task-id> <ref>").description("Link a git branch or pull request to a task").option("--type <type>", "Ref type: branch or pull_request", "branch").option("--url <url>", "Remote URL for the branch or pull request").option("--provider <name>", "Provider name, e.g. git or github").option("--metadata <json>", "Additional JSON metadata").action(async (taskId, ref, opts) => {
     const globalOpts = program2.opts();
@@ -71498,38 +72232,70 @@ exit 0
         process.exit(1);
       }
     }
-    const gitRef = linkTaskGitRef2({
-      task_id: resolvedId,
-      ref_type: refType,
-      name: ref,
-      url: opts.url,
-      provider: opts.provider,
-      metadata
-    });
-    if (globalOpts.json) {
-      output(gitRef, true);
-      return;
+    try {
+      const cloud = getTodosCloudClient();
+      const gitRef = cloud ? await cloudLinkRef(cloud, resolvedId, {
+        ref_type: refType,
+        name: ref,
+        ...opts.url !== undefined ? { url: opts.url } : {},
+        ...opts.provider !== undefined ? { provider: opts.provider } : {},
+        ...metadata ? { metadata } : {}
+      }) : linkTaskGitRef2({
+        task_id: resolvedId,
+        ref_type: refType,
+        name: ref,
+        url: opts.url,
+        provider: opts.provider,
+        metadata
+      });
+      if (globalOpts.json) {
+        output(gitRef, true);
+        return;
+      }
+      console.log(chalk8.green(`Linked ${gitRef.ref_type} ${gitRef.name} to task ${taskId}`));
+    } catch (e) {
+      handleError(e);
     }
-    console.log(chalk8.green(`Linked ${gitRef.ref_type} ${gitRef.name} to task ${taskId}`));
   });
   program2.command("find-ref <ref>").description("Find tasks linked to a git branch or pull request").action(async (ref) => {
     const globalOpts = program2.opts();
-    const { findTasksByGitRef: findTasksByGitRef2 } = await Promise.resolve().then(() => (init_task_commits(), exports_task_commits));
-    const { getTask: getTask3 } = await Promise.resolve().then(() => (init_tasks(), exports_tasks));
-    const refs = findTasksByGitRef2(ref);
-    if (globalOpts.json) {
-      output(refs, true);
-      return;
-    }
-    if (refs.length === 0) {
-      console.log(chalk8.dim(`No tasks linked to ${ref}.`));
-      return;
-    }
-    for (const gitRef of refs) {
-      const task2 = getTask3(gitRef.task_id);
-      const label = task2 ? `${task2.short_id || task2.id.slice(0, 8)} ${task2.title}` : gitRef.task_id;
-      const url = gitRef.url ? chalk8.dim(` ${gitRef.url}`) : "";
-      console.log(`${chalk8.cyan(label)} <- ${gitRef.ref_type} ${chalk8.yellow(gitRef.name)}${url}`);
+    try {
+      const cloud = getTodosCloudClient();
+      if (cloud) {
+        const refs2 = await cloudFindRefs(cloud, ref);
+        if (globalOpts.json) {
+          output(refs2, true);
+          return;
+        }
+        if (refs2.length === 0) {
+          console.log(chalk8.dim(`No tasks linked to ${ref}.`));
+          return;
+        }
+        for (const gitRef of refs2) {
+          const url = gitRef.url ? chalk8.dim(` ${gitRef.url}`) : "";
+          console.log(`${chalk8.cyan(gitRef.task_id)} <- ${gitRef.ref_type} ${chalk8.yellow(gitRef.name)}${url}`);
+        }
+        return;
+      }
+      const { findTasksByGitRef: findTasksByGitRef2 } = await Promise.resolve().then(() => (init_task_commits(), exports_task_commits));
+      const { getTask: getTask3 } = await Promise.resolve().then(() => (init_tasks(), exports_tasks));
+      const refs = findTasksByGitRef2(ref);
+      if (globalOpts.json) {
+        output(refs, true);
+        return;
+      }
+      if (refs.length === 0) {
+        console.log(chalk8.dim(`No tasks linked to ${ref}.`));
+        return;
+      }
+      for (const gitRef of refs) {
+        const task2 = getTask3(gitRef.task_id);
+        const label = task2 ? `${task2.short_id || task2.id.slice(0, 8)} ${task2.title}` : gitRef.task_id;
+        const url = gitRef.url ? chalk8.dim(` ${gitRef.url}`) : "";
+        console.log(`${chalk8.cyan(label)} <- ${gitRef.ref_type} ${chalk8.yellow(gitRef.name)}${url}`);
+      }
+    } catch (e) {
+      handleError(e);
     }
   });
   program2.command("branch-plan [task-id]").description("Create a local branch-safe work plan from task or plan files").requiredOption("--branch <name>", "Branch name to plan").option("--base <name>", "Base branch", "main").option("--plan <id>", "Plan ID scope instead of a single task").option("--path <list>", "Comma-separated extra paths expected for this branch").option("--root <path>", "Git root to inspect", process.cwd()).option("--no-git-status", "Skip local git status checks").action(async (taskId, opts) => {