@hasna/todos 0.11.84 → 0.11.86

package/dist/cli/index.js

@@ -8571,6 +8571,21 @@ async function cloudAddComment(client, taskId, input) {
   }
   return raw;
 }
+async function cloudTaskHistory(client, taskId) {
+  const raw = await client.transport.get(`/tasks/${encodeURIComponent(taskId)}/history`);
+  const envelope = raw ?? {};
+  if (Array.isArray(envelope.history))
+    return envelope.history;
+  return Array.isArray(raw) ? raw : [];
+}
+async function cloudUpsertTaskByFingerprint(client, input) {
+  const raw = await client.transport.post("/tasks/upsert", input);
+  const envelope = raw ?? {};
+  return {
+    task: unwrapTask(envelope.task ?? raw),
+    created: Boolean(envelope.created)
+  };
+}
 async function cloudCountTasks(client, filter = {}) {
   const { limit: _drop, offset: _o, ...rest } = filter;
   const res = await client.list("tasks", { query: { ...toListQuery(rest), limit: 1 } });
@@ -8587,6 +8602,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) {
@@ -20430,7 +20493,7 @@ function registerTaskCommands(program2) {
     }
   });
   const task = program2.command("task").description("Task subcommands for deterministic automation");
-  task.command("upsert").description("Create or update a task by stable metadata fingerprint").requiredOption("--fingerprint <key>", "Stable dedupe fingerprint").requiredOption("--title <text>", "Task title").option("-d, --description <text>", "Task description").option("-p, --priority <level>", "Priority: low, medium, high, critical").option("-s, --status <status>", "Task status").option("--list <id>", "Task list ID").option("--task-list <id>", "Task list ID (alias for --list)").option("-t, --tags <tags>", "Comma-separated tags").option("--tag <tags>", "Comma-separated tags (alias for --tags)").option("--metadata-json <json>", "JSON object merged into task metadata").option("--working-dir <path>", "Working directory to store on create/update").option("--project <id>", "Assign to project by ID, slug, or path").option("--assign <agent>", "Assign to agent").option("--expectation-id <id>", "Expectation metadata ID").option("--expectation-fingerprint <key>", "Expectation metadata fingerprint").option("--evidence-paths <paths>", "Comma-separated evidence paths").option("--origin-loop-id <id>", "Origin loop ID").option("--origin-run-id <id>", "Origin run ID").option("--expected <json-or-text>", "Expected value metadata").option("--observed <json-or-text>", "Observed value metadata").option("--acceptance <json-or-text>", "Acceptance metadata").action((opts) => {
+  task.command("upsert").description("Create or update a task by stable metadata fingerprint").requiredOption("--fingerprint <key>", "Stable dedupe fingerprint").requiredOption("--title <text>", "Task title").option("-d, --description <text>", "Task description").option("-p, --priority <level>", "Priority: low, medium, high, critical").option("-s, --status <status>", "Task status").option("--list <id>", "Task list ID").option("--task-list <id>", "Task list ID (alias for --list)").option("-t, --tags <tags>", "Comma-separated tags").option("--tag <tags>", "Comma-separated tags (alias for --tags)").option("--metadata-json <json>", "JSON object merged into task metadata").option("--working-dir <path>", "Working directory to store on create/update").option("--project <id>", "Assign to project by ID, slug, or path").option("--assign <agent>", "Assign to agent").option("--expectation-id <id>", "Expectation metadata ID").option("--expectation-fingerprint <key>", "Expectation metadata fingerprint").option("--evidence-paths <paths>", "Comma-separated evidence paths").option("--origin-loop-id <id>", "Origin loop ID").option("--origin-run-id <id>", "Origin run ID").option("--expected <json-or-text>", "Expected value metadata").option("--observed <json-or-text>", "Observed value metadata").option("--acceptance <json-or-text>", "Acceptance metadata").action(async (opts) => {
     const globalOpts = program2.opts();
     opts.tags = opts.tags || opts.tag;
     opts.list = opts.list || opts.taskList;
@@ -20445,6 +20508,34 @@ function registerTaskCommands(program2) {
       }
       return id;
     })() : undefined;
+    const cloud = getTodosCloudClient();
+    if (cloud) {
+      let cloudResult;
+      try {
+        cloudResult = await cloudUpsertTaskByFingerprint(cloud, {
+          fingerprint: opts.fingerprint,
+          title: opts.title,
+          description: opts.description,
+          priority: parsePriority(opts.priority),
+          status: parseStatus(opts.status),
+          task_list_id: taskListId,
+          tags: parseTags(opts.tags),
+          metadata: buildExpectationMetadata(opts),
+          working_dir: opts.workingDir ? resolve9(opts.workingDir) : process.cwd(),
+          project_id: projectId,
+          assigned_to: opts.assign
+        });
+      } catch (e) {
+        handleError(e);
+      }
+      if (globalOpts.json) {
+        output(cloudResult, true);
+      } else {
+        console.log(chalk2.green(cloudResult.created ? "Task created:" : "Task updated:"));
+        console.log(formatTaskLine(cloudResult.task));
+      }
+      return;
+    }
     let result;
     try {
       result = upsertTaskByFingerprint({
@@ -20937,8 +21028,18 @@ ${chalk2.cyan(sid)} ${statusColor(task2.status)} ${prioColor(task2.priority)} ${
   program2.command("history <id>").description("Show change history for a task (audit log)").action(async (id) => {
     const globalOpts = program2.opts();
     const resolvedId = resolveTaskId(id);
-    const { getTaskHistory: getTaskHistory2 } = await Promise.resolve().then(() => (init_audit(), exports_audit));
-    const history = getTaskHistory2(resolvedId);
+    const cloud = getTodosCloudClient();
+    let history;
+    if (cloud) {
+      try {
+        history = await cloudTaskHistory(cloud, resolvedId);
+      } catch (e) {
+        handleError(e);
+      }
+    } else {
+      const { getTaskHistory: getTaskHistory2 } = await Promise.resolve().then(() => (init_audit(), exports_audit));
+      history = getTaskHistory2(resolvedId);
+    }
     if (globalOpts.json) {
       output(history, true);
       return;
@@ -21094,28 +21195,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) {
@@ -21218,7 +21345,7 @@ ${chalk2.cyan(sid)} ${statusColor(task2.status)} ${prioColor(task2.priority)} ${
       process.exit(1);
     }
   });
-  program2.command("bulk <action> <ids...>").description("Bulk operation on multiple tasks (done, start, delete, plan)").option("--plan <id>", "Plan ID for the plan/move-plan action").option("--clear-plan", "Remove plan assignment for the plan/move-plan action").action((action, ids, opts) => {
+  program2.command("bulk <action> <ids...>").description("Bulk operation on multiple tasks (done, start, delete, plan)").option("--plan <id>", "Plan ID for the plan/move-plan action").option("--clear-plan", "Remove plan assignment for the plan/move-plan action").action(async (action, ids, opts) => {
     const globalOpts = program2.opts();
     const results = [];
     const isPlanAction = action === "plan" || action === "move-plan";
@@ -21227,6 +21354,45 @@ ${chalk2.cyan(sid)} ${statusColor(task2.status)} ${prioColor(task2.priority)} ${
       process.exit(1);
     }
     const planId = isPlanAction ? opts.plan ? resolvePlanId(opts.plan) : null : undefined;
+    const knownActions = new Set(["done", "complete", "start", "delete", "plan", "move-plan"]);
+    if (!knownActions.has(action)) {
+      console.error(chalk2.red(`Unknown action: ${action}. Use: done, start, delete, plan`));
+      process.exit(1);
+    }
+    const cloud = getTodosCloudClient();
+    if (cloud) {
+      for (const rawId of ids) {
+        try {
+          const resolvedId = resolveTaskId(rawId);
+          if (action === "done" || action === "complete") {
+            await cloudTaskAction(cloud, resolvedId, "complete", { agent_id: globalOpts.agent });
+          } else if (action === "start") {
+            await cloudTaskAction(cloud, resolvedId, "start", { agent_id: globalOpts.agent || "cli" });
+          } else if (action === "delete") {
+            await cloudDeleteTask(cloud, resolvedId);
+          } else {
+            const current = await cloudGetTask(cloud, resolvedId);
+            if (!current)
+              throw new Error(`Task not found: ${rawId}`);
+            await cloudUpdateTask(cloud, resolvedId, { version: current.version, plan_id: planId });
+          }
+          results.push({ id: resolvedId, success: true });
+        } catch (e) {
+          results.push({ id: rawId, success: false, error: e instanceof Error ? e.message : String(e) });
+        }
+      }
+      const succeededCloud = results.filter((r) => r.success).length;
+      const failedCloud = results.filter((r) => !r.success).length;
+      if (globalOpts.json) {
+        output({ results, succeeded: succeededCloud, failed: failedCloud }, true);
+      } else {
+        console.log(chalk2.green(`${action}: ${succeededCloud} succeeded, ${failedCloud} failed`));
+        for (const r of results.filter((r2) => !r2.success)) {
+          console.log(chalk2.red(`  ${r.id}: ${r.error}`));
+        }
+      }
+      return;
+    }
     for (const rawId of ids) {
       try {
         const resolvedId = resolveTaskId(rawId);
@@ -22033,6 +22199,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 +33332,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 +33370,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) => {
@@ -38685,7 +38925,8 @@ function createPostgresTodosStorageAdapter(options) {
       getActiveWork: (filters) => getActiveWork2(filters, store),
       getChangedSince: (since, filters) => getChangedSince(since, filters, store),
       lock: (id, agentId) => lockTask2(id, agentId, store),
-      unlock: (id, agentId) => unlockTask2(id, agentId, store)
+      unlock: (id, agentId) => unlockTask2(id, agentId, store),
+      getByFingerprint: (fingerprint) => store.getTaskByFingerprint(fingerprint)
     },
     dependencies: {
       add: (taskId, dependsOn, context) => addDependency2(taskId, dependsOn, store, context),
@@ -38697,6 +38938,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 +38968,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),
@@ -38862,6 +39115,17 @@ class PostgresJsonRecordStore {
     const result = await this.options.client.query(sql, params);
     return result.rows.map((row) => payloadRecord2(row.payload));
   }
+  async getTaskByFingerprint(fingerprint) {
+    await this.ensureSchema();
+    const sql = `/* todos:task-by-fingerprint */ SELECT payload FROM ${this.tableName}
+      WHERE service = $1 AND object_type = $2 AND deleted_at IS NULL
+        AND payload->'metadata'->>'fingerprint' = $3
+      ORDER BY payload->>'created_at' ASC
+      LIMIT 1`;
+    const result = await this.options.client.query(sql, [this.service, "tasks", fingerprint]);
+    const row = result.rows[0];
+    return row ? payloadRecord2(row.payload) : null;
+  }
   async countTasks(filter) {
     await this.ensureSchema();
     const { where, params } = this.buildTaskFilterSql(filter);
@@ -39247,6 +39511,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 +39704,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", {
@@ -40141,6 +40474,61 @@ async function handleV1Request(req, url) {
           missing
         });
       }
+      if (id === "upsert" && !action) {
+        if (method !== "POST")
+          return error(405, `method ${method} not allowed on /v1/tasks/upsert`);
+        if (typeof store.tasks.getByFingerprint !== "function") {
+          return error(501, "fingerprint upsert is not supported by this storage backend");
+        }
+        const body = await readJson(req) ?? {};
+        const fingerprint = typeof body.fingerprint === "string" ? body.fingerprint.trim() : "";
+        if (!fingerprint)
+          return error(400, "fingerprint is required");
+        if (typeof body.title !== "string" || !body.title.trim())
+          return error(400, "title is required");
+        const existing = await store.tasks.getByFingerprint(fingerprint);
+        const metadata = {
+          ...existing?.metadata ?? {},
+          ...body.metadata ?? {},
+          fingerprint
+        };
+        const fields = { metadata };
+        for (const key of [
+          "title",
+          "description",
+          "priority",
+          "status",
+          "project_id",
+          "assigned_to",
+          "working_dir",
+          "plan_id",
+          "task_list_id",
+          "tags",
+          "due_at",
+          "estimated_minutes",
+          "sla_minutes",
+          "requires_approval",
+          "recurrence_rule",
+          "task_type"
+        ]) {
+          const bag = body;
+          if (bag[key] !== undefined)
+            fields[key] = bag[key];
+        }
+        if (!existing) {
+          const task = await store.tasks.create({ ...fields, title: body.title }, contextFromPrincipal(principal, body));
+          return json2({ task, created: true }, 201);
+        }
+        try {
+          const task = await store.tasks.update(existing.id, { ...fields, version: existing.version }, contextFromPrincipal(principal, body));
+          return json2({ task, created: false });
+        } catch (e) {
+          const msg = e.message || "";
+          if (msg.includes("version conflict"))
+            return error(409, msg);
+          throw e;
+        }
+      }
       if (!id) {
         if (method === "GET") {
           const filter = {
@@ -40194,6 +40582,14 @@ async function handleV1Request(req, url) {
           }
           return error(405, `method ${method} not allowed on /v1/tasks/:id/comments`);
         }
+        if (action === "history") {
+          if (method !== "GET")
+            return error(405, `method ${method} not allowed on /v1/tasks/:id/history`);
+          if (!await store.tasks.get(id))
+            return error(404, "task not found");
+          const history = await store.audit.getTaskHistory(id);
+          return json2({ history, count: history.length });
+        }
         if (action === "lock" || action === "unlock") {
           if (method !== "POST")
             return error(405, `method ${method} not allowed on /v1/tasks/:id/${action}`);
@@ -40277,6 +40673,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 +40849,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 +40902,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 +46274,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 +46311,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 +46346,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 +56160,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 +56204,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 +56373,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 +63744,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 +63779,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 +72318,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 +72399,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) => {