@hasna/todos 0.11.84 → 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) {
@@ -21094,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) {
@@ -22033,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);
@@ -33132,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) => {
@@ -33152,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) => {
@@ -38697,6 +38845,16 @@ function createPostgresTodosStorageAdapter(options) {
       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),
@@ -38717,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),
@@ -39247,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];
 }
@@ -39393,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", {
@@ -40277,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") {
@@ -40389,6 +40682,30 @@ 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");
@@ -40418,6 +40735,22 @@ async function handleV1Request(req, url) {
       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`);
@@ -45774,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);
@@ -45811,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)
   ];
@@ -45846,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:
@@ -55660,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) {
@@ -55704,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();
@@ -55873,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;
@@ -63244,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 };
@@ -63266,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 };
@@ -71789,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();
@@ -71840,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) => {