@hasna/todos 0.11.81 → 0.11.83

package/dist/cli/index.js

@@ -8548,6 +8548,29 @@ async function cloudGetStats(client) {
   const raw = await client.transport.get("/stats");
   return raw ?? {};
 }
+async function cloudListAgents(client) {
+  const res = await client.list("agents");
+  const envelope = res.raw;
+  return Array.isArray(envelope?.agents) ? envelope.agents : res.items;
+}
+async function cloudListProjects(client) {
+  const res = await client.list("projects");
+  const envelope = res.raw;
+  return Array.isArray(envelope?.projects) ? envelope.projects : res.items;
+}
+async function cloudListPlans(client, projectId) {
+  const query = projectId ? { project_id: projectId } : {};
+  const res = await client.list("plans", { query });
+  const envelope = res.raw;
+  return Array.isArray(envelope?.plans) ? envelope.plans : res.items;
+}
+async function cloudAddComment(client, taskId, input) {
+  const raw = await client.transport.post(`/tasks/${encodeURIComponent(taskId)}/comments`, input);
+  if (raw && typeof raw === "object" && "comment" in raw) {
+    return raw.comment;
+  }
+  return raw;
+}
 async function cloudCountTasks(client, filter = {}) {
   const { limit: _drop, offset: _o, ...rest } = filter;
   const res = await client.list("tasks", { query: { ...toListQuery(rest), limit: 1 } });
@@ -8557,6 +8580,53 @@ async function cloudCountTasks(client, filter = {}) {
   const tasks = await cloudListTasks(client, rest);
   return tasks.length;
 }
+async function cloudRegisterAgent(client, input) {
+  const raw = await client.transport.post("/agents", input);
+  if (raw && typeof raw === "object" && "agent" in raw) {
+    return raw.agent;
+  }
+  return raw;
+}
+async function cloudLockTask(client, id, agentId) {
+  const raw = await client.transport.post(`/tasks/${encodeURIComponent(id)}/lock`, { agent_id: agentId });
+  if (raw && typeof raw === "object" && "result" in raw) {
+    return raw.result;
+  }
+  return raw ?? { success: true };
+}
+async function cloudUnlockTask(client, id, agentId) {
+  const raw = await client.transport.post(`/tasks/${encodeURIComponent(id)}/unlock`, agentId ? { agent_id: agentId } : {});
+  if (raw && typeof raw === "object" && "success" in raw) {
+    return Boolean(raw.success);
+  }
+  return true;
+}
+async function cloudGetDependencies(client, id) {
+  const raw = await client.transport.get(`/tasks/${encodeURIComponent(id)}/dependencies`);
+  const env = raw ?? {};
+  return { dependencies: env.dependencies ?? [], blocked_by: env.blocked_by ?? [] };
+}
+async function cloudAddDependency(client, id, dependsOn) {
+  const raw = await client.transport.post(`/tasks/${encodeURIComponent(id)}/dependencies`, { depends_on: dependsOn });
+  if (raw && typeof raw === "object" && "dependency" in raw) {
+    return raw.dependency;
+  }
+  return raw;
+}
+async function cloudRemoveDependency(client, id, dependsOn) {
+  const raw = await client.transport.del(`/tasks/${encodeURIComponent(id)}/dependencies/${encodeURIComponent(dependsOn)}`);
+  if (raw && typeof raw === "object" && "removed" in raw) {
+    return Boolean(raw.removed);
+  }
+  return true;
+}
+async function cloudRecordVerification(client, id, input) {
+  const raw = await client.transport.post(`/tasks/${encodeURIComponent(id)}/verifications`, input);
+  if (raw && typeof raw === "object" && "verification" in raw) {
+    return raw.verification;
+  }
+  return raw;
+}
 var _cache;
 var init_cloud_router = __esm(() => {
   init_storage();
@@ -20505,11 +20575,23 @@ function registerTaskCommands(program2) {
       if (active.length > 0)
         resolvedId = active[0].id;
     }
+    const cloud = getTodosCloudClient();
+    if (!resolvedId && cloud && globalOpts.agent) {
+      const active = await cloudListTasks(cloud, { status: "in_progress", assigned_to: globalOpts.agent, limit: 1 });
+      if (active.length > 0)
+        resolvedId = active[0].id;
+    }
     if (!resolvedId) {
       console.error(chalk2.red("No task ID given and no active task found. Pass an ID or use --agent."));
       process.exit(1);
     }
-    const task2 = getTaskWithRelations(resolvedId);
+    let task2;
+    if (cloud) {
+      const remote = await cloudGetTask(cloud, resolvedId);
+      task2 = remote ? { subtasks: [], dependencies: [], blocked_by: [], comments: [], checklist: [], ...remote, tags: remote.tags ?? [] } : null;
+    } else {
+      task2 = getTaskWithRelations(resolvedId);
+    }
     if (!task2) {
       console.error(chalk2.red(`Task not found: ${id || resolvedId}`));
       process.exit(1);
@@ -20851,13 +20933,14 @@ ${chalk2.cyan(sid)} ${statusColor(task2.status)} ${prioColor(task2.priority)} ${
       console.log(formatTaskLine(task2));
     }
   });
-  program2.command("lock <id>").description("Acquire exclusive lock on a task").action((id) => {
+  program2.command("lock <id>").description("Acquire exclusive lock on a task").action(async (id) => {
     const globalOpts = program2.opts();
     const agentId = globalOpts.agent || "cli";
+    const cloud = getTodosCloudClient();
     const resolvedId = resolveTaskId(id);
     let result;
     try {
-      result = lockTask(resolvedId, agentId);
+      result = cloud ? await cloudLockTask(cloud, resolvedId, agentId) : lockTask(resolvedId, agentId);
     } catch (e) {
       handleError(e);
     }
@@ -20870,11 +20953,15 @@ ${chalk2.cyan(sid)} ${statusColor(task2.status)} ${prioColor(task2.priority)} ${
       process.exit(1);
     }
   });
-  program2.command("unlock <id>").description("Release lock on a task").action((id) => {
+  program2.command("unlock <id>").description("Release lock on a task").action(async (id) => {
     const globalOpts = program2.opts();
+    const cloud = getTodosCloudClient();
     const resolvedId = resolveTaskId(id);
     try {
-      unlockTask(resolvedId, globalOpts.agent);
+      if (cloud)
+        await cloudUnlockTask(cloud, resolvedId, globalOpts.agent);
+      else
+        unlockTask(resolvedId, globalOpts.agent);
     } catch (e) {
       handleError(e);
     }
@@ -21643,9 +21730,10 @@ function resolvePlanCliRef(ref, projectId) {
   process.exit(1);
 }
 function registerPlanTemplateCommands(program2) {
-  program2.command("plans").description("List and manage plans").option("--add <name>", "Create a plan").option("--slug <slug>", "Readable plan slug (with --add)").option("-d, --description <text>", "Plan description (with --add)").option("--show <id-or-slug>", "Show plan details with its tasks").option("--artifact <id-or-slug>", "Show local Markdown artifact diagnostics for a plan").option("--write-artifacts", "Write local Markdown artifacts for all project-scoped plans in scope").option("--delete <id>", "Delete a plan").option("--complete <id>", "Mark a plan as completed").action((opts) => {
+  program2.command("plans").description("List and manage plans").option("--add <name>", "Create a plan").option("--slug <slug>", "Readable plan slug (with --add)").option("-d, --description <text>", "Plan description (with --add)").option("--show <id-or-slug>", "Show plan details with its tasks").option("--artifact <id-or-slug>", "Show local Markdown artifact diagnostics for a plan").option("--write-artifacts", "Write local Markdown artifacts for all project-scoped plans in scope").option("--delete <id>", "Delete a plan").option("--complete <id>", "Mark a plan as completed").action(async (opts) => {
     const globalOpts = program2.opts();
-    const projectId = autoProject(globalOpts);
+    const cloud = getTodosCloudClient();
+    const projectId = cloud ? undefined : autoProject(globalOpts);
     if (opts.add) {
       let plan;
       try {
@@ -21804,7 +21892,7 @@ function registerPlanTemplateCommands(program2) {
       }
       return;
     }
-    const plans = listPlans(projectId);
+    const plans = cloud ? await cloudListPlans(cloud, projectId) : listPlans(projectId);
     if (globalOpts.json) {
       output(plans, true);
       return;
@@ -22129,6 +22217,7 @@ var init_plan_template_commands = __esm(() => {
   init_tasks();
   init_plan_artifacts();
   init_helpers();
+  init_cloud_router();
 });
 
 // src/lib/local-fields.ts
@@ -31376,10 +31465,11 @@ function registerProjectCommands(program2) {
       handleError(e);
     }
   });
-  program2.command("comment <id> <text>").alias("log-progress").description("Add a comment to a task (alias: log-progress, for recording intermediate progress)").option("--pct <percent>", "Progress percentage (0-100) to record alongside the note").action((id, text, opts) => {
+  program2.command("comment <id> <text>").alias("log-progress").description("Add a comment to a task (alias: log-progress, for recording intermediate progress)").option("--pct <percent>", "Progress percentage (0-100) to record alongside the note").action(async (id, text, opts) => {
     const globalOpts = program2.opts();
     const resolvedId = resolveTaskId(id);
     let content = text;
+    let progressPct;
     if (opts.pct !== undefined) {
       const pct = parseInt(opts.pct, 10);
       if (!Number.isFinite(pct) || pct < 0 || pct > 100) {
@@ -31387,17 +31477,28 @@ function registerProjectCommands(program2) {
         process.exit(1);
       }
       content = `[progress ${pct}%] ${text}`;
+      progressPct = pct;
     }
-    const comment = addComment({
-      task_id: resolvedId,
-      content,
-      agent_id: globalOpts.agent,
-      session_id: globalOpts.session
-    });
-    if (globalOpts.json) {
-      output(comment, true);
-    } else {
-      console.log(chalk4.green("Comment added."));
+    try {
+      const cloud = getTodosCloudClient();
+      const comment = cloud ? await cloudAddComment(cloud, resolvedId, {
+        content,
+        agent_id: globalOpts.agent,
+        session_id: globalOpts.session,
+        ...progressPct !== undefined ? { type: "progress", progress_pct: progressPct } : {}
+      }) : addComment({
+        task_id: resolvedId,
+        content,
+        agent_id: globalOpts.agent,
+        session_id: globalOpts.session
+      });
+      if (globalOpts.json) {
+        output(comment, true);
+      } else {
+        console.log(chalk4.green("Comment added."));
+      }
+    } catch (e) {
+      handleError(e);
     }
   });
   program2.command("search <query>").description("Search local tasks, or run/save a cross-entity search view").option("--status <status>", "Filter by status").option("--priority <p>", "Filter by priority").option("--assigned <agent>", "Filter by assigned agent").option("--agent-id <agent>", "Filter by creator/run/comment agent").option("--task-list <id>", "Filter by task list").option("--plan <id>", "Filter by plan").option("--task <id>", "Filter runs/comments by task").option("--tag <tag>", "Filter by task tag (repeatable or comma-separated)", collectOption, []).option("--field-label <label>", "Filter by local field label (repeatable or comma-separated)", collectOption, []).option("--field-owner <owner>", "Filter by local field owner").option("--field-area <area>", "Filter by local field area").option("--field-severity <severity>", "Filter by local field severity").option("--field-custom <json>", "Filter by local custom fields as JSON").option("--since <date>", "Only tasks updated after this date (ISO)").option("--created-after <date>", "Only records created after this date (ISO)").option("--blocked", "Only blocked tasks (incomplete dependencies)").option("--has-deps", "Only tasks with dependencies").option("--depends-on <id>", "Only tasks that depend on a task").option("--blocks <id>", "Only tasks that block a task").option("--scope <scope>", "Search scope: tasks, projects, plans, runs, comments, all", "tasks").option("--limit <n>", "Maximum results", "100").option("--filter <json>", "Merge an advanced saved-search filter JSON object").option("--save-as <name>", "Save this search as a named view").option("--description <text>", "Saved view description").option("--all-projects", "Do not auto-scope the search to the current project").action((query, opts) => {
@@ -31524,6 +31625,49 @@ function registerProjectCommands(program2) {
   });
   program2.command("deps <id>").description("Manage task dependencies").option("--needs <dep-id>", "Add dependency (this task needs dep-id)").option("--remove <dep-id>", "Remove dependency").option("--graph", "Show the dependency graph instead of direct edges").option("--direction <direction>", "Graph direction: up, down, or both", "both").action(async (id, opts) => {
     const globalOpts = program2.opts();
+    const cloud = getTodosCloudClient();
+    if (cloud) {
+      const cloudId = resolveTaskId(id);
+      if (opts.needs) {
+        try {
+          const dep = await cloudAddDependency(cloud, cloudId, resolveTaskId(opts.needs));
+          if (globalOpts.json)
+            output(dep, true);
+          else
+            console.log(chalk4.green("Dependency added."));
+        } catch (e) {
+          handleError(e);
+        }
+        return;
+      }
+      if (opts.remove) {
+        const removed = await cloudRemoveDependency(cloud, cloudId, resolveTaskId(opts.remove));
+        if (globalOpts.json)
+          output({ removed }, true);
+        else
+          console.log(removed ? chalk4.green("Dependency removed.") : chalk4.red("Dependency not found."));
+        return;
+      }
+      const edges = await cloudGetDependencies(cloud, cloudId);
+      if (globalOpts.json) {
+        output(edges, true);
+        return;
+      }
+      if (edges.dependencies.length > 0) {
+        console.log(chalk4.bold("Depends on:"));
+        for (const dep of edges.dependencies)
+          console.log(`  ${chalk4.cyan(dep.depends_on)}`);
+      }
+      if (edges.blocked_by.length > 0) {
+        console.log(chalk4.bold("Blocks:"));
+        for (const b of edges.blocked_by)
+          console.log(`  ${chalk4.cyan(b.task_id)}`);
+      }
+      if (edges.dependencies.length === 0 && edges.blocked_by.length === 0) {
+        console.log(chalk4.dim("No dependencies."));
+      }
+      return;
+    }
     const { addDependency: addDependency2, removeDependency: removeDependency2, getTaskGraph: getTaskGraph2, getTaskWithRelations: getTaskWithRelations2 } = await Promise.resolve().then(() => (init_tasks(), exports_tasks));
     const resolvedId = resolveTaskId(id);
     if (opts.needs) {
@@ -31651,7 +31795,8 @@ function registerProjectCommands(program2) {
       }
       return;
     }
-    const projects = listProjects();
+    const cloud = getTodosCloudClient();
+    const projects = cloud ? await cloudListProjects(cloud) : listProjects();
     if (globalOpts.json) {
       output(projects, true);
       return;
@@ -32057,6 +32202,7 @@ var init_project_commands = __esm(() => {
   init_database();
   init_projects();
   init_comments();
+  init_cloud_router();
   init_saved_search_views();
   init_sync();
   init_config2();
@@ -32738,8 +32884,9 @@ function registerAgentCommands(program2) {
   program2.command("init <name>").description("Register an agents and get a short UUID").option("-d, --description <text>", "Agent description").action(async (name, opts) => {
     const globalOpts = program2.opts();
     try {
-      const { registerAgent: registerAgent2, isAgentConflict: isAgentConflict2 } = await Promise.resolve().then(() => (init_agents(), exports_agents));
-      const result = registerAgent2({ name, description: opts.description });
+      const cloud = getTodosCloudClient();
+      const result = cloud ? await cloudRegisterAgent(cloud, { name, description: opts.description }) : (await Promise.resolve().then(() => (init_agents(), exports_agents))).registerAgent({ name, description: opts.description });
+      const { isAgentConflict: isAgentConflict2 } = await Promise.resolve().then(() => (init_agents(), exports_agents));
       if (isAgentConflict2(result)) {
         console.error(chalk5.red("CONFLICT:"), result.message);
         process.exit(1);
@@ -32826,7 +32973,8 @@ Use ${chalk5.cyan(`--agent ${result.id}`)} on future commands.`);
   program2.command("agents").description("List registered agents").action(async () => {
     const globalOpts = program2.opts();
     try {
-      const agents = listAgents();
+      const cloud = getTodosCloudClient();
+      const agents = cloud ? await cloudListAgents(cloud) : listAgents();
       if (globalOpts.json) {
         output(agents, true);
         return;
@@ -33095,6 +33243,7 @@ var init_agent_commands = __esm(() => {
   init_task_lists();
   init_tasks();
   init_helpers();
+  init_cloud_router();
 });
 
 // src/lib/retention-cleanup.ts
@@ -37343,6 +37492,7 @@ function createLocalSqliteTodosStorageAdapter(options = {}) {
     audit: {
       logTaskChange: (taskId, action, field, oldValue, newValue, agentId) => logTaskChange(taskId, action, field, oldValue, newValue, agentId, database()),
       addComment: (input) => addComment(input, database()),
+      getComments: (taskId) => listComments(taskId, database()),
       getTaskHistory: (taskId) => getTaskHistory(taskId, database()),
       getRecentActivity: (limit) => getRecentActivity(limit, database())
     },
@@ -38310,7 +38460,18 @@ function createPostgresTodosStorageAdapter(options) {
       claimNext: (agentId, filters) => claimNextTask2(agentId, filters, store),
       getNext: (_agentId, filters) => getNextTask2(filters, store),
       getActiveWork: (filters) => getActiveWork2(filters, store),
-      getChangedSince: (since, filters) => getChangedSince(since, filters, store)
+      getChangedSince: (since, filters) => getChangedSince(since, filters, store),
+      lock: (id, agentId) => lockTask2(id, agentId, store),
+      unlock: (id, agentId) => unlockTask2(id, agentId, store)
+    },
+    dependencies: {
+      add: (taskId, dependsOn, context) => addDependency2(taskId, dependsOn, store, context),
+      remove: (taskId, dependsOn) => removeDependency2(taskId, dependsOn, store),
+      list: (taskId) => listDependencies(taskId, store)
+    },
+    verifications: {
+      add: (input, context) => addVerification(input, store, context),
+      list: (taskId) => listVerifications(taskId, store)
     },
     projects: {
       create: (input, context) => createProject2(input, store, context),
@@ -38356,6 +38517,7 @@ function createPostgresTodosStorageAdapter(options) {
     audit: {
       logTaskChange: (taskId, action, field, oldValue, newValue, agentId, context) => logTaskChange2(taskId, action, field, oldValue, newValue, agentId, store, context),
       addComment: (input, context) => addComment2(input, store, context),
+      getComments: async (taskId) => (await store.list("comments")).filter((comment) => comment.task_id === taskId).sort((a, b) => a.created_at.localeCompare(b.created_at)),
       getTaskHistory: async (taskId) => (await store.list("audit_history")).filter((entry2) => entry2.task_id === taskId).sort((a, b) => a.created_at.localeCompare(b.created_at)),
       getRecentActivity: async (limit = 20) => (await store.list("audit_history")).sort((a, b) => b.created_at.localeCompare(a.created_at)).slice(0, limit)
     },
@@ -38764,6 +38926,103 @@ async function patchTask(task, patch, store) {
   await store.upsert("tasks", updated);
   return updated;
 }
+function cloudLockExpired(lockedAt) {
+  if (!lockedAt)
+    return true;
+  return new Date(lockedAt).getTime() + CLOUD_LOCK_EXPIRY_MINUTES * 60 * 1000 < Date.now();
+}
+function cloudLockExpiresAt(lockedAt) {
+  return new Date(new Date(lockedAt).getTime() + CLOUD_LOCK_EXPIRY_MINUTES * 60 * 1000).toISOString();
+}
+async function lockTask2(id, agentId, store) {
+  const task = await requireRecord("tasks", id, store);
+  if (task.status === "completed" || task.status === "cancelled") {
+    return { success: false, error: `Task is ${task.status} and cannot be locked` };
+  }
+  if (task.locked_by && task.locked_by !== agentId && !cloudLockExpired(task.locked_at)) {
+    return { success: false, locked_by: task.locked_by, locked_at: task.locked_at ?? undefined, error: `Task is locked by ${task.locked_by}` };
+  }
+  const timestamp = new Date().toISOString();
+  await patchTask(task, { locked_by: agentId, locked_at: timestamp }, store);
+  return { success: true, locked_by: agentId, locked_at: timestamp, expires_at: cloudLockExpiresAt(timestamp) };
+}
+async function unlockTask2(id, agentId, store) {
+  const task = await requireRecord("tasks", id, store);
+  if (agentId && task.locked_by && task.locked_by !== agentId) {
+    throw new Error(`Task ${id} is locked by ${task.locked_by}, not ${agentId}`);
+  }
+  await patchTask(task, { locked_by: null, locked_at: null }, store);
+  return true;
+}
+function dependencyId(taskId, dependsOn) {
+  return `${taskId}::${dependsOn}`;
+}
+async function addDependency2(taskId, dependsOn, store, context) {
+  if (taskId === dependsOn)
+    throw new Error("A task cannot depend on itself");
+  if (!await store.get("tasks", taskId))
+    throw new Error(`Task not found: ${taskId}`);
+  if (!await store.get("tasks", dependsOn))
+    throw new Error(`Task not found: ${dependsOn}`);
+  const edges = await store.list("dependencies");
+  const adjacency = new Map;
+  for (const edge of edges) {
+    if (!adjacency.has(edge.task_id))
+      adjacency.set(edge.task_id, []);
+    adjacency.get(edge.task_id).push(edge.depends_on);
+  }
+  const queue = [dependsOn];
+  const seen = new Set;
+  while (queue.length) {
+    const node = queue.shift();
+    if (node === taskId)
+      throw new Error(`Adding dependency ${taskId} -> ${dependsOn} would create a cycle`);
+    if (seen.has(node))
+      continue;
+    seen.add(node);
+    for (const next of adjacency.get(node) ?? [])
+      queue.push(next);
+  }
+  const timestamp = new Date().toISOString();
+  const record = { id: dependencyId(taskId, dependsOn), task_id: taskId, depends_on: dependsOn, created_at: timestamp, updated_at: timestamp };
+  await store.upsert("dependencies", record, context);
+  return { task_id: taskId, depends_on: dependsOn };
+}
+async function removeDependency2(taskId, dependsOn, store) {
+  const existing = await store.get("dependencies", dependencyId(taskId, dependsOn));
+  if (!existing)
+    return false;
+  await store.delete("dependencies", dependencyId(taskId, dependsOn));
+  return true;
+}
+async function listDependencies(taskId, store) {
+  const edges = await store.list("dependencies");
+  return {
+    dependencies: edges.filter((edge) => edge.task_id === taskId).map((edge) => ({ task_id: edge.task_id, depends_on: edge.depends_on })),
+    blocked_by: edges.filter((edge) => edge.depends_on === taskId).map((edge) => ({ task_id: edge.task_id, depends_on: edge.depends_on }))
+  };
+}
+async function addVerification(input, store, context) {
+  if (!await store.get("tasks", input.task_id))
+    throw new Error(`Task not found: ${input.task_id}`);
+  const timestamp = new Date().toISOString();
+  const verification = {
+    id: randomUUID3(),
+    task_id: input.task_id,
+    command: input.command,
+    status: input.status ?? "unknown",
+    output_summary: input.output_summary ?? null,
+    artifact_path: input.artifact_path ?? null,
+    agent_id: input.agent_id ?? context?.agentId ?? null,
+    run_at: timestamp,
+    created_at: timestamp
+  };
+  await store.upsert("verifications", { ...verification, updated_at: timestamp }, context);
+  return verification;
+}
+async function listVerifications(taskId, store) {
+  return (await store.list("verifications")).filter((verification) => verification.task_id === taskId).sort((a, b) => b.run_at.localeCompare(a.run_at));
+}
 function toFilterArray(value) {
   return Array.isArray(value) ? value : [value];
 }
@@ -39137,7 +39396,7 @@ function compareClock(left, right) {
 function numberValue2(value) {
   return typeof value === "number" && Number.isSafeInteger(value) ? value : null;
 }
-var TASK_ORDER_BY = "ORDER BY CASE payload->>'priority' WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 WHEN 'low' THEN 3 ELSE 4 END ASC, payload->>'created_at' ASC, payload->>'id' ASC";
+var CLOUD_LOCK_EXPIRY_MINUTES = 30, TASK_ORDER_BY = "ORDER BY CASE payload->>'priority' WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 WHEN 'low' THEN 3 ELSE 4 END ASC, payload->>'created_at' ASC, payload->>'id' ASC";
 var init_postgres_adapter = () => {};
 
 // src/server/cloud.ts
@@ -39635,6 +39894,7 @@ async function handleV1Request(req, url) {
   const resource = segments[1];
   const id = segments[2];
   const action = segments[3];
+  const subId = segments[4];
   try {
     if (resource === "tasks") {
       if (id === "exists" && !action) {
@@ -39685,6 +39945,114 @@ async function handleV1Request(req, url) {
         return error(405, `method ${method} not allowed on /v1/tasks`);
       }
       if (action) {
+        if (action === "comments") {
+          if (method === "GET") {
+            const comments = await store.audit.getComments(id);
+            return json2({ comments, count: comments.length });
+          }
+          if (method === "POST") {
+            const body2 = await readJson(req) ?? {};
+            if (typeof body2.content !== "string" || !body2.content.trim()) {
+              return error(400, "content is required");
+            }
+            const target = await store.tasks.get(id);
+            if (!target)
+              return error(404, "task not found");
+            const comment = await store.audit.addComment({
+              task_id: id,
+              content: body2.content,
+              agent_id: body2.agent_id ?? principal.agent ?? undefined,
+              session_id: body2.session_id,
+              type: body2.type,
+              progress_pct: body2.progress_pct
+            }, contextFromPrincipal(principal, body2));
+            return json2({ comment }, 201);
+          }
+          return error(405, `method ${method} not allowed on /v1/tasks/:id/comments`);
+        }
+        if (action === "lock" || action === "unlock") {
+          if (method !== "POST")
+            return error(405, `method ${method} not allowed on /v1/tasks/:id/${action}`);
+          if (typeof store.tasks.lock !== "function" || typeof store.tasks.unlock !== "function") {
+            return error(501, "task locking is not supported by this storage backend");
+          }
+          const body2 = await readJson(req) ?? {};
+          if (!await store.tasks.get(id))
+            return error(404, "task not found");
+          if (action === "lock") {
+            const agentId2 = body2.agent_id || principal.agent || "todos-serve";
+            return json2({ result: await store.tasks.lock(id, agentId2) });
+          }
+          const released = await store.tasks.unlock(id, body2.agent_id || principal.agent || undefined);
+          return json2({ success: released });
+        }
+        if (action === "dependencies") {
+          if (!store.dependencies)
+            return error(501, "dependencies are not supported by this storage backend");
+          if (method === "GET") {
+            if (!await store.tasks.get(id))
+              return error(404, "task not found");
+            const edges = await store.dependencies.list(id);
+            return json2(edges);
+          }
+          if (method === "POST") {
+            const body2 = await readJson(req) ?? {};
+            if (typeof body2.depends_on !== "string" || !body2.depends_on.trim()) {
+              return error(400, "depends_on is required");
+            }
+            try {
+              const dependency = await store.dependencies.add(id, body2.depends_on, contextFromPrincipal(principal));
+              return json2({ dependency }, 201);
+            } catch (e) {
+              const msg = e.message || "";
+              if (msg.includes("not found"))
+                return error(404, msg);
+              if (msg.includes("cycle") || msg.includes("itself"))
+                return error(409, msg);
+              throw e;
+            }
+          }
+          if (method === "DELETE") {
+            if (!subId)
+              return error(400, "dependency target id is required (/v1/tasks/:id/dependencies/:dep)");
+            const removed = await store.dependencies.remove(id, subId);
+            return json2({ removed });
+          }
+          return error(405, `method ${method} not allowed on /v1/tasks/:id/dependencies`);
+        }
+        if (action === "verifications") {
+          if (!store.verifications)
+            return error(501, "verifications are not supported by this storage backend");
+          if (method === "GET") {
+            if (!await store.tasks.get(id))
+              return error(404, "task not found");
+            const verifications = await store.verifications.list(id);
+            return json2({ verifications, count: verifications.length });
+          }
+          if (method === "POST") {
+            const body2 = await readJson(req) ?? {};
+            if (typeof body2.command !== "string" || !body2.command.trim()) {
+              return error(400, "command is required");
+            }
+            try {
+              const verification = await store.verifications.add({
+                task_id: id,
+                command: body2.command,
+                status: body2.status,
+                output_summary: body2.output_summary,
+                artifact_path: body2.artifact_path,
+                agent_id: body2.agent_id
+              }, contextFromPrincipal(principal, body2));
+              return json2({ verification }, 201);
+            } catch (e) {
+              const msg = e.message || "";
+              if (msg.includes("not found"))
+                return error(404, msg);
+              throw e;
+            }
+          }
+          return error(405, `method ${method} not allowed on /v1/tasks/:id/verifications`);
+        }
         const body = await readJson(req) ?? {};
         const agentId = body.agent_id || principal.agent || "todos-serve";
         if (action === "start" && method === "POST") {
@@ -39789,10 +40157,13 @@ async function handleV1Request(req, url) {
       }
       if (!id && method === "POST") {
         const body = await readJson(req);
-        if (!body || typeof body.name !== "string")
+        if (!body || typeof body.name !== "string" || !body.name.trim())
           return error(400, "name is required");
-        const agent = await store.agents.register(body, contextFromPrincipal(principal));
-        return json2({ agent }, 201);
+        const result = await store.agents.register(body, contextFromPrincipal(principal));
+        if (result && typeof result === "object" && "conflict" in result) {
+          return error(409, result.message ?? "agent name conflict", { conflict: true });
+        }
+        return json2({ agent: result }, 201);
       }
       if (id && method === "GET") {
         const agent = await store.agents.get(id);
@@ -49865,6 +50236,11 @@ Tasks:` : null,
       author: exports_external3.string().optional().describe("Author agent ID or name")
     }, async ({ task_id, body, author }) => {
       try {
+        const cloud = getTodosCloudClient();
+        if (cloud) {
+          await cloudAddComment(cloud, task_id, { content: body, agent_id: author });
+          return { content: [{ type: "text", text: `Comment added to ${task_id.slice(0, 8)}: ${body.slice(0, 50)}${body.length > 50 ? "..." : ""}` }] };
+        }
         const resolvedId = resolveId(task_id);
         const resolvedAuthor = author ? resolveId(author, "agents") : undefined;
         const comment = addComment({ task_id: resolvedId, content: body, agent_id: resolvedAuthor });
@@ -50775,6 +51151,56 @@ function registerTaskWorkflowTools(server, ctx) {
       max_description_chars: exports_external3.number().optional().describe("Max task description chars in compact mode (default: 180)")
     }, async ({ agent_id, project_id, task_list_id, explain_blocked, detail, max_description_chars }) => {
       try {
+        const cloud = getTodosCloudClient();
+        if (cloud) {
+          const baseFilter = {};
+          if (project_id)
+            baseFilter.project_id = project_id;
+          if (task_list_id)
+            baseFilter.task_list_id = task_list_id;
+          const [stats, pending, in_progress, completed, activeTasks, nextTasks] = await Promise.all([
+            cloudGetStats(cloud),
+            cloudCountTasks(cloud, { ...baseFilter, status: "pending" }),
+            cloudCountTasks(cloud, { ...baseFilter, status: "in_progress" }),
+            cloudCountTasks(cloud, { ...baseFilter, status: "completed" }),
+            cloudListTasks(cloud, { ...baseFilter, status: "in_progress", limit: 5 }),
+            cloudListTasks(cloud, { ...baseFilter, status: "pending", limit: 1 })
+          ]);
+          const cloudStatus = {
+            source: "cloud",
+            total: stats.tasks ?? pending + in_progress + completed,
+            pending,
+            in_progress,
+            completed,
+            active_work: activeTasks,
+            next_task: nextTasks[0] ?? null,
+            stale_count: 0,
+            overdue_recurring: 0
+          };
+          const next_task2 = nextTasks[0] ?? null;
+          const payload2 = {
+            status: cloudStatus,
+            next_task: next_task2,
+            overdue_count: 0,
+            latest_handoff: null,
+            as_of: new Date().toISOString()
+          };
+          if (detail === "full") {
+            return { content: [{ type: "text", text: JSON.stringify(payload2, null, 2) }] };
+          }
+          return {
+            content: [{
+              type: "text",
+              text: compactJson({
+                status: compactStatus(cloudStatus),
+                next_task: next_task2 ? compactTask(next_task2, max_description_chars || 180) : null,
+                overdue_count: 0,
+                latest_handoff: null,
+                as_of: payload2.as_of
+              })
+            }]
+          };
+        }
         const { getStatus: getStatus2, getNextTask: getNextTask3, getOverdueTasks: getOverdueTasks2 } = (init_tasks(), __toCommonJS(exports_tasks));
         const { getLatestHandoff: getLatestHandoff2 } = (init_handoffs(), __toCommonJS(exports_handoffs));
         const filters = {};
@@ -51210,6 +51636,27 @@ ${lines.join(`
   if (shouldRegisterTool("get_health")) {
     server.tool("get_health", "Get system health: task counts by status, active agents, project summary.", async () => {
       try {
+        const cloud = getTodosCloudClient();
+        if (cloud) {
+          const [stats, pending2, inProgress2, completed2, cancelled2, projects2, agents2] = await Promise.all([
+            cloudGetStats(cloud),
+            cloudCountTasks(cloud, { status: "pending" }),
+            cloudCountTasks(cloud, { status: "in_progress" }),
+            cloudCountTasks(cloud, { status: "completed" }),
+            cloudCountTasks(cloud, { status: "cancelled" }),
+            cloudListProjects(cloud),
+            cloudListAgents(cloud)
+          ]);
+          const projectCount = stats.projects ?? projects2.length;
+          const lines2 = [
+            `=== System Health (cloud) ===`,
+            `Tasks: ${pending2} pending | ${inProgress2} in progress | ${completed2} completed | ${cancelled2} cancelled`,
+            `Projects: ${projectCount} total`,
+            `Agents: ${agents2.length} registered`
+          ];
+          return { content: [{ type: "text", text: lines2.join(`
+`) }] };
+        }
         const { countTasks: countTasks2 } = (init_tasks(), __toCommonJS(exports_tasks));
         const { listProjects: listProjects2 } = (init_projects(), __toCommonJS(exports_projects));
         const { listAgents: listAgents2 } = (init_agents(), __toCommonJS(exports_agents));
@@ -51248,6 +51695,7 @@ ${lines.join(`
 }
 var init_task_auto_tools = __esm(() => {
   init_zod();
+  init_cloud_router();
 });
 
 // src/lib/context-packs.ts
@@ -52570,6 +53018,11 @@ No blocked tasks.`,
       author: exports_external3.string().optional().describe("Author agent ID or name")
     }, async ({ task_id, body, author }) => {
       try {
+        const cloud = getTodosCloudClient();
+        if (cloud) {
+          await cloudAddComment(cloud, task_id, { content: body, agent_id: author });
+          return { content: [{ type: "text", text: `Comment added to ${task_id.slice(0, 8)}` }] };
+        }
         const { addComment: addComment3 } = (init_comments(), __toCommonJS(exports_comments));
         const resolvedId = resolveId(task_id);
         const resolvedAuthor = author ? resolveId(author, "agents") : undefined;
@@ -62237,6 +62690,33 @@ function registerAgentTools(server, { shouldRegisterTool, resolveId, formatError
       force: exports_external3.boolean().optional().describe("Force takeover of an active agent's name. Use with caution \u2014 only when you know the previous session is dead.")
     }, async ({ name, description, role, title, level, permissions, capabilities, session_id, working_dir, force }) => {
       try {
+        const cloud = getTodosCloudClient();
+        if (cloud) {
+          const agent2 = await cloudRegisterAgent(cloud, {
+            name,
+            description,
+            role,
+            title,
+            level,
+            permissions,
+            capabilities,
+            session_id,
+            working_dir,
+            force
+          });
+          return {
+            content: [{
+              type: "text",
+              text: `Agent registered:
+ID: ${agent2.id}
+Name: ${agent2.name}${agent2.description ? `
+Description: ${agent2.description}` : ""}
+Session: ${agent2.session_id ?? "unbound"}
+Created: ${agent2.created_at}
+Last seen: ${agent2.last_seen_at}`
+            }]
+          };
+        }
         const pool = getAgentPoolForProject(working_dir);
         const result = registerAgent({ name, description, role, title, level, permissions, capabilities, session_id, working_dir, force, pool: pool || undefined });
         if (isAgentConflict(result)) {
@@ -62330,7 +62810,8 @@ No names available. Wait for an active agent to go stale (30min timeout).`
       include_archived: exports_external3.boolean().optional().describe("Include archived agents in the list (default: false)")
     }, async ({ include_archived }) => {
       try {
-        const agents = listAgents({ include_archived: include_archived ?? false });
+        const cloud = getTodosCloudClient();
+        const agents = cloud ? await cloudListAgents(cloud) : listAgents({ include_archived: include_archived ?? false });
         if (agents.length === 0) {
           return { content: [{ type: "text", text: "No agents registered." }] };
         }
@@ -62550,6 +63031,7 @@ var init_agents2 = __esm(() => {
   init_agents();
   init_config2();
   init_database();
+  init_cloud_router();
 });
 
 // src/mcp/tools/templates.ts
@@ -68219,11 +68701,42 @@ function registerQueryCommands(program2) {
   program2.command("status").description("Show full project health snapshot").option("--agent <id>", "Include next task for this agent").option("--project <id>", "Filter to project").option("-j, --json", "Output as JSON").action(async (opts) => {
     const globalOpts = program2.opts();
     const json3 = opts.json || globalOpts.json;
-    const db = getDatabase();
     const filters = {};
     if (opts.project)
       filters.project_id = opts.project;
-    const s = getStatus(Object.keys(filters).length ? filters : undefined, opts.agent, undefined, db);
+    const cloud = getTodosCloudClient();
+    let s;
+    if (cloud) {
+      const baseFilter = opts.project ? { project_id: opts.project } : {};
+      const [stats2, pending, in_progress, completed, activeTasks, nextTasks] = await Promise.all([
+        cloudGetStats(cloud),
+        cloudCountTasks(cloud, { ...baseFilter, status: "pending" }),
+        cloudCountTasks(cloud, { ...baseFilter, status: "in_progress" }),
+        cloudCountTasks(cloud, { ...baseFilter, status: "completed" }),
+        cloudListTasks(cloud, { ...baseFilter, status: "in_progress", limit: 5 }),
+        cloudListTasks(cloud, { ...baseFilter, status: "pending", limit: 1 })
+      ]);
+      s = {
+        source: "cloud",
+        pending,
+        in_progress,
+        completed,
+        total: stats2.tasks ?? pending + in_progress + completed,
+        active_work: activeTasks.map((t) => ({
+          id: t.id,
+          short_id: t.short_id ?? null,
+          title: t.title,
+          assigned_to: t.assigned_to ?? null,
+          locked_by: t.locked_by ?? null
+        })),
+        next_task: nextTasks[0] ?? null,
+        stale_count: 0,
+        overdue_recurring: 0
+      };
+    } else {
+      const db = getDatabase();
+      s = getStatus(Object.keys(filters).length ? filters : undefined, opts.agent, undefined, db);
+    }
     if (json3) {
       console.log(JSON.stringify(s, null, 2));
       return;
@@ -70617,6 +71130,7 @@ var init_query_commands = __esm(() => {
   init_workflow_states();
   init_local_reports();
   init_helpers();
+  init_cloud_router();
   init_types();
 });
 
@@ -71062,25 +71576,34 @@ Commands:`));
   });
   program2.command("record-verification <task-id> <command>").description("Record a verification command and result for a task").option("--status <status>", "Verification status: passed, failed, or unknown", "unknown").option("--summary <text>", "Short output summary").option("--artifact <path>", "Artifact or log path").option("--agent <name>", "Agent that ran the command").action(async (taskId, command, opts) => {
     const globalOpts = program2.opts();
-    const resolvedId = resolveTaskId(taskId);
     if (opts.status !== "passed" && opts.status !== "failed" && opts.status !== "unknown") {
       console.error(chalk8.red("--status must be passed, failed, or unknown"));
       process.exit(1);
     }
-    const { addTaskVerification: addTaskVerification2 } = await Promise.resolve().then(() => (init_task_commits(), exports_task_commits));
-    const verification = addTaskVerification2({
-      task_id: resolvedId,
-      command,
-      status: opts.status,
-      output_summary: opts.summary,
-      artifact_path: opts.artifact,
-      agent_id: opts.agent
-    });
-    if (globalOpts.json) {
-      output(verification, true);
-      return;
+    try {
+      const cloud = getTodosCloudClient();
+      const verification = cloud ? await cloudRecordVerification(cloud, resolveTaskId(taskId), {
+        command,
+        status: opts.status,
+        output_summary: opts.summary,
+        artifact_path: opts.artifact,
+        agent_id: opts.agent
+      }) : (await Promise.resolve().then(() => (init_task_commits(), exports_task_commits))).addTaskVerification({
+        task_id: resolveTaskId(taskId),
+        command,
+        status: opts.status,
+        output_summary: opts.summary,
+        artifact_path: opts.artifact,
+        agent_id: opts.agent
+      });
+      if (globalOpts.json) {
+        output(verification, true);
+        return;
+      }
+      console.log(chalk8.green(`Recorded ${verification.status} verification for task ${taskId}`));
+    } catch (e) {
+      handleError(e);
     }
-    console.log(chalk8.green(`Recorded ${verification.status} verification for task ${taskId}`));
   });
   program2.command("trace <task-id>").description("Show local git refs, commits, changed files, and verification commands for a task").action(async (taskId) => {
     const globalOpts = program2.opts();
@@ -71786,6 +72309,7 @@ var HOME2;
 var init_mcp_hooks_commands = __esm(() => {
   init_tasks();
   init_helpers();
+  init_cloud_router();
   HOME2 = process.env["HOME"] || process.env["USERPROFILE"] || "~";
 });