@hasna/todos 0.11.15 → 0.11.16

package/dist/cli/index.js

@@ -2260,6 +2260,13 @@ function ensureSchema(db) {
       created_at TEXT NOT NULL DEFAULT (datetime('now')),
       UNIQUE(source_id, source_type, target_id, target_type, relation_type)
     )`);
+  ensureTable("machines", `
+    CREATE TABLE machines (
+      id TEXT PRIMARY KEY, name TEXT NOT NULL UNIQUE, hostname TEXT, platform TEXT,
+      last_seen_at TEXT NOT NULL DEFAULT (datetime('now')),
+      metadata TEXT DEFAULT '{}',
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )`);
   ensureColumn("projects", "task_list_id", "TEXT");
   ensureColumn("projects", "task_prefix", "TEXT");
   ensureColumn("projects", "task_counter", "INTEGER NOT NULL DEFAULT 0");
@@ -2360,6 +2367,38 @@ function ensureSchema(db) {
   ensureIndex("CREATE INDEX IF NOT EXISTS idx_webhook_deliveries_event ON webhook_deliveries(event)");
   ensureColumn("task_comments", "type", "TEXT DEFAULT 'comment'");
   ensureColumn("task_comments", "progress_pct", "INTEGER");
+  ensureColumn("projects", "machine_id", "TEXT");
+  ensureColumn("projects", "synced_at", "TEXT");
+  ensureColumn("tasks", "machine_id", "TEXT");
+  ensureColumn("tasks", "synced_at", "TEXT");
+  ensureColumn("agents", "machine_id", "TEXT");
+  ensureColumn("agents", "synced_at", "TEXT");
+  ensureColumn("task_lists", "machine_id", "TEXT");
+  ensureColumn("task_lists", "synced_at", "TEXT");
+  ensureColumn("plans", "machine_id", "TEXT");
+  ensureColumn("plans", "synced_at", "TEXT");
+  ensureColumn("task_comments", "machine_id", "TEXT");
+  ensureColumn("task_comments", "synced_at", "TEXT");
+  ensureColumn("sessions", "machine_id", "TEXT");
+  ensureColumn("sessions", "synced_at", "TEXT");
+  ensureColumn("task_history", "machine_id", "TEXT");
+  ensureColumn("webhooks", "machine_id", "TEXT");
+  ensureColumn("webhooks", "synced_at", "TEXT");
+  ensureColumn("task_templates", "machine_id", "TEXT");
+  ensureColumn("task_templates", "synced_at", "TEXT");
+  ensureColumn("orgs", "machine_id", "TEXT");
+  ensureColumn("orgs", "synced_at", "TEXT");
+  ensureColumn("handoffs", "machine_id", "TEXT");
+  ensureColumn("handoffs", "synced_at", "TEXT");
+  ensureColumn("task_checklists", "machine_id", "TEXT");
+  ensureColumn("project_sources", "machine_id", "TEXT");
+  ensureColumn("project_sources", "synced_at", "TEXT");
+  ensureColumn("task_files", "machine_id", "TEXT");
+  ensureColumn("task_relationships", "machine_id", "TEXT");
+  ensureColumn("kg_edges", "machine_id", "TEXT");
+  ensureColumn("project_agent_roles", "machine_id", "TEXT");
+  ensureColumn("dispatches", "machine_id", "TEXT");
+  ensureColumn("dispatches", "synced_at", "TEXT");
   ensureIndex("CREATE INDEX IF NOT EXISTS idx_tasks_plan ON tasks(plan_id)");
   ensureIndex("CREATE INDEX IF NOT EXISTS idx_tasks_task_list ON tasks(task_list_id)");
   ensureIndex("CREATE INDEX IF NOT EXISTS idx_tasks_due_at ON tasks(due_at)");
@@ -2388,6 +2427,10 @@ function ensureSchema(db) {
   ensureIndex("CREATE INDEX IF NOT EXISTS idx_kg_source ON kg_edges(source_id, source_type)");
   ensureIndex("CREATE INDEX IF NOT EXISTS idx_kg_target ON kg_edges(target_id, target_type)");
   ensureIndex("CREATE INDEX IF NOT EXISTS idx_kg_relation ON kg_edges(relation_type)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_tasks_machine ON tasks(machine_id)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_tasks_synced ON tasks(synced_at)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_projects_machine ON projects(machine_id)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_agents_machine ON agents(machine_id)");
 }
 function backfillTaskTags(db) {
   try {
@@ -3039,10 +3082,163 @@ var init_schema = __esm(() => {
   CREATE INDEX IF NOT EXISTS idx_dispatch_logs_dispatch ON dispatch_logs(dispatch_id);
 
   INSERT OR IGNORE INTO _migrations (id) VALUES (40);
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS machines (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL UNIQUE,
+    hostname TEXT,
+    platform TEXT,
+    last_seen_at TEXT NOT NULL DEFAULT (datetime('now')),
+    metadata TEXT DEFAULT '{}',
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  ALTER TABLE projects ADD COLUMN machine_id TEXT;
+  ALTER TABLE projects ADD COLUMN synced_at TEXT;
+  ALTER TABLE tasks ADD COLUMN machine_id TEXT;
+  ALTER TABLE tasks ADD COLUMN synced_at TEXT;
+  ALTER TABLE agents ADD COLUMN machine_id TEXT;
+  ALTER TABLE agents ADD COLUMN synced_at TEXT;
+  ALTER TABLE task_lists ADD COLUMN machine_id TEXT;
+  ALTER TABLE task_lists ADD COLUMN synced_at TEXT;
+  ALTER TABLE plans ADD COLUMN machine_id TEXT;
+  ALTER TABLE plans ADD COLUMN synced_at TEXT;
+  ALTER TABLE task_comments ADD COLUMN machine_id TEXT;
+  ALTER TABLE task_comments ADD COLUMN synced_at TEXT;
+  ALTER TABLE sessions ADD COLUMN machine_id TEXT;
+  ALTER TABLE sessions ADD COLUMN synced_at TEXT;
+  ALTER TABLE task_history ADD COLUMN machine_id TEXT;
+  ALTER TABLE webhooks ADD COLUMN machine_id TEXT;
+  ALTER TABLE webhooks ADD COLUMN synced_at TEXT;
+  ALTER TABLE task_templates ADD COLUMN machine_id TEXT;
+  ALTER TABLE task_templates ADD COLUMN synced_at TEXT;
+  ALTER TABLE orgs ADD COLUMN machine_id TEXT;
+  ALTER TABLE orgs ADD COLUMN synced_at TEXT;
+  ALTER TABLE handoffs ADD COLUMN machine_id TEXT;
+  ALTER TABLE handoffs ADD COLUMN synced_at TEXT;
+  ALTER TABLE task_checklists ADD COLUMN machine_id TEXT;
+  ALTER TABLE project_sources ADD COLUMN machine_id TEXT;
+  ALTER TABLE project_sources ADD COLUMN synced_at TEXT;
+  ALTER TABLE task_files ADD COLUMN machine_id TEXT;
+  ALTER TABLE task_relationships ADD COLUMN machine_id TEXT;
+  ALTER TABLE kg_edges ADD COLUMN machine_id TEXT;
+  ALTER TABLE project_agent_roles ADD COLUMN machine_id TEXT;
+  ALTER TABLE dispatches ADD COLUMN machine_id TEXT;
+  ALTER TABLE dispatches ADD COLUMN synced_at TEXT;
+
+  CREATE INDEX IF NOT EXISTS idx_tasks_machine ON tasks(machine_id);
+  CREATE INDEX IF NOT EXISTS idx_tasks_synced ON tasks(synced_at);
+  CREATE INDEX IF NOT EXISTS idx_projects_machine ON projects(machine_id);
+  CREATE INDEX IF NOT EXISTS idx_agents_machine ON agents(machine_id);
+
+  INSERT OR IGNORE INTO _migrations (id) VALUES (41);
   `
   ];
 });
 
+// src/db/machines.ts
+var exports_machines = {};
+__export(exports_machines, {
+  resetMachineId: () => resetMachineId,
+  listMachines: () => listMachines,
+  getOrCreateLocalMachine: () => getOrCreateLocalMachine,
+  getMachineId: () => getMachineId,
+  getMachineByName: () => getMachineByName,
+  getMachine: () => getMachine,
+  deleteMachine: () => deleteMachine,
+  backfillMachineId: () => backfillMachineId
+});
+import { hostname as osHostname, platform as osPlatform } from "os";
+function rowToMachine(row) {
+  return {
+    ...row,
+    metadata: row.metadata ? JSON.parse(row.metadata) : {}
+  };
+}
+function getOrCreateLocalMachine(db) {
+  const d = db || getDatabase();
+  const name = process.env["TODOS_MACHINE_NAME"] || osHostname();
+  const host = osHostname();
+  const plat = osPlatform();
+  const existing = d.query("SELECT * FROM machines WHERE name = ?").get(name);
+  if (existing) {
+    d.run("UPDATE machines SET hostname = ?, platform = ?, last_seen_at = ? WHERE id = ?", [host, plat, now(), existing.id]);
+    return rowToMachine({ ...existing, hostname: host, platform: plat, last_seen_at: now() });
+  }
+  const id = uuid();
+  const ts = now();
+  d.run("INSERT INTO machines (id, name, hostname, platform, last_seen_at, metadata, created_at) VALUES (?, ?, ?, ?, ?, '{}', ?)", [id, name, host, plat, ts, ts]);
+  return { id, name, hostname: host, platform: plat, last_seen_at: ts, metadata: {}, created_at: ts };
+}
+function getMachineId(db) {
+  if (_machineId)
+    return _machineId;
+  const machine = getOrCreateLocalMachine(db);
+  _machineId = machine.id;
+  return _machineId;
+}
+function resetMachineId() {
+  _machineId = null;
+}
+function getMachine(id, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM machines WHERE id = ?").get(id);
+  return row ? rowToMachine(row) : null;
+}
+function getMachineByName(name, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM machines WHERE name = ?").get(name);
+  return row ? rowToMachine(row) : null;
+}
+function listMachines(db) {
+  const d = db || getDatabase();
+  const rows = d.query("SELECT * FROM machines ORDER BY last_seen_at DESC").all();
+  return rows.map(rowToMachine);
+}
+function deleteMachine(id, db) {
+  const d = db || getDatabase();
+  const result = d.run("DELETE FROM machines WHERE id = ?", [id]);
+  return result.changes > 0;
+}
+function backfillMachineId(db, force = false) {
+  if (!force && process.env["TODOS_DB_PATH"] === ":memory:")
+    return;
+  try {
+    const machine = getOrCreateLocalMachine(db);
+    for (const table of TABLES_WITH_MACHINE_ID) {
+      try {
+        db.run(`UPDATE "${table}" SET machine_id = ? WHERE machine_id IS NULL`, [machine.id]);
+      } catch {}
+    }
+  } catch {}
+}
+var _machineId = null, TABLES_WITH_MACHINE_ID;
+var init_machines = __esm(() => {
+  init_database();
+  TABLES_WITH_MACHINE_ID = [
+    "projects",
+    "tasks",
+    "agents",
+    "task_lists",
+    "plans",
+    "task_comments",
+    "sessions",
+    "task_history",
+    "webhooks",
+    "task_templates",
+    "orgs",
+    "handoffs",
+    "task_checklists",
+    "project_sources",
+    "task_files",
+    "task_relationships",
+    "kg_edges",
+    "project_agent_roles",
+    "dispatches"
+  ];
+});
+
 // src/db/database.ts
 var exports_database = {};
 __export(exports_database, {
@@ -3132,6 +3328,7 @@ function getDatabase(dbPath) {
   _db.run("PRAGMA foreign_keys = ON");
   runMigrations(_db);
   backfillTaskTags(_db);
+  backfillMachineId(_db);
   return _db;
 }
 function closeDatabase() {
@@ -3197,6 +3394,7 @@ function resolvePartialId(db, table, partialId) {
 var LOCK_EXPIRY_MINUTES = 30, _db = null;
 var init_database = __esm(() => {
   init_schema();
+  init_machines();
 });
 
 // src/types/index.ts
@@ -22603,6 +22801,332 @@ See https://www.postgresql.org/docs/current/libpq-ssl.html for libpq SSL mode de
   init_adapter();
 });
 
+// src/mcp/tools/cloud.ts
+async function detectAndLogConflicts(local, cloud, table) {
+  if (!CONFLICT_TABLES.has(table))
+    return 0;
+  try {
+    const { detectConflicts: detectConflicts2, storeConflicts: storeConflicts2 } = await Promise.resolve().then(() => (init_dist(), exports_dist));
+    const localRows = local.all(`SELECT * FROM "${table}"`);
+    const remoteRows = await cloud.all(`SELECT * FROM "${table}"`);
+    if (localRows.length === 0 || remoteRows.length === 0)
+      return 0;
+    const conflicts = detectConflicts2(localRows, remoteRows, table, "id", "updated_at");
+    if (conflicts.length > 0) {
+      storeConflicts2(local, conflicts);
+    }
+    return conflicts.length;
+  } catch {
+    return 0;
+  }
+}
+function registerCloudSyncTools(server, { shouldRegisterTool, formatError }) {
+  if (shouldRegisterTool("todos_cloud_status")) {
+    server.tool("todos_cloud_status", "Show cloud configuration, connection health, and local machine info", {}, async () => {
+      try {
+        const { getCloudConfig: getCloudConfig2, getConnectionString: getConnectionString2, PgAdapterAsync: PgAdapterAsync2, listConflicts: listConflicts2, ensureConflictsTable: ensureConflictsTable2, SqliteAdapter: SqliteAdapter2, getDbPath: getDbPath3 } = await Promise.resolve().then(() => (init_dist(), exports_dist));
+        const config = getCloudConfig2();
+        const db = getDatabase();
+        const machineId = getMachineId(db);
+        const lines = [
+          `Mode: ${config.mode}`,
+          `Service: todos`,
+          `Machine ID: ${machineId}`,
+          `RDS Host: ${config.rds.host || "(not configured)"}`
+        ];
+        if (config.rds.host && config.rds.username) {
+          try {
+            const pg = new PgAdapterAsync2(getConnectionString2("postgres"));
+            await pg.get("SELECT 1 as ok");
+            lines.push("PostgreSQL: connected");
+            await pg.close();
+          } catch (err) {
+            lines.push(`PostgreSQL: failed \u2014 ${err?.message}`);
+          }
+        }
+        try {
+          const local = new SqliteAdapter2(getDbPath3("todos"));
+          ensureConflictsTable2(local);
+          const unresolved = listConflicts2(local, { resolved: false });
+          const resolved = listConflicts2(local, { resolved: true });
+          lines.push(`Sync conflicts: ${unresolved.length} unresolved, ${resolved.length} resolved`);
+          local.close();
+        } catch {}
+        return { content: [{ type: "text", text: lines.join(`
+`) }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("todos_cloud_push")) {
+    server.tool("todos_cloud_push", "Push local data to cloud PostgreSQL. Stamps machine_id on all rows, detects conflicts, and sets synced_at after successful push.", {
+      tables: exports_external.string().optional().describe("Comma-separated table names (default: all)")
+    }, async ({ tables: tablesStr }) => {
+      try {
+        const {
+          getCloudConfig: getCloudConfig2,
+          getConnectionString: getConnectionString2,
+          syncPush: syncPush2,
+          listSqliteTables: listSqliteTables2,
+          SqliteAdapter: SqliteAdapter2,
+          PgAdapterAsync: PgAdapterAsync2,
+          getDbPath: getDbPath3
+        } = await Promise.resolve().then(() => (init_dist(), exports_dist));
+        const config = getCloudConfig2();
+        if (config.mode === "local") {
+          return { content: [{ type: "text", text: "Error: cloud mode not configured." }], isError: true };
+        }
+        const db = getDatabase();
+        const machineId = getMachineId(db);
+        const localPath = getDbPath3("todos");
+        const local = new SqliteAdapter2(localPath);
+        const cloud = new PgAdapterAsync2(getConnectionString2("todos"));
+        const tableList = tablesStr ? tablesStr.split(",").map((t) => t.trim()) : listSqliteTables2(local).filter((t) => !t.startsWith("_"));
+        for (const table of tableList) {
+          try {
+            local.run(`UPDATE "${table}" SET machine_id = ? WHERE machine_id IS NULL`, machineId);
+          } catch {}
+        }
+        let totalConflicts = 0;
+        for (const table of tableList) {
+          totalConflicts += await detectAndLogConflicts(local, cloud, table);
+        }
+        const results = await syncPush2(local, cloud, { tables: tableList });
+        const syncTime = now();
+        for (const result of results) {
+          if (result.rowsWritten > 0) {
+            try {
+              local.run(`UPDATE "${result.table}" SET synced_at = ? WHERE machine_id = ?`, syncTime, machineId);
+            } catch {}
+          }
+        }
+        local.close();
+        await cloud.close();
+        const total = results.reduce((s, r) => s + r.rowsWritten, 0);
+        const errors2 = results.flatMap((r) => r.errors);
+        const lines = [`Pushed ${total} rows across ${tableList.length} table(s).`, `Machine: ${machineId}`];
+        if (totalConflicts > 0)
+          lines.push(`Conflicts detected: ${totalConflicts} (logged to _sync_conflicts)`);
+        if (errors2.length > 0)
+          lines.push(`Errors: ${errors2.join("; ")}`);
+        return { content: [{ type: "text", text: lines.join(`
+`) }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("todos_cloud_pull")) {
+    server.tool("todos_cloud_pull", "Pull cloud PostgreSQL data to local. Detects conflicts, merges by primary key with UPSERT, and logs conflict resolutions.", {
+      tables: exports_external.string().optional().describe("Comma-separated table names (default: all)")
+    }, async ({ tables: tablesStr }) => {
+      try {
+        const {
+          getCloudConfig: getCloudConfig2,
+          getConnectionString: getConnectionString2,
+          syncPull: syncPull2,
+          listPgTables: listPgTables2,
+          SqliteAdapter: SqliteAdapter2,
+          PgAdapterAsync: PgAdapterAsync2,
+          getDbPath: getDbPath3
+        } = await Promise.resolve().then(() => (init_dist(), exports_dist));
+        const config = getCloudConfig2();
+        if (config.mode === "local") {
+          return { content: [{ type: "text", text: "Error: cloud mode not configured." }], isError: true };
+        }
+        const local = new SqliteAdapter2(getDbPath3("todos"));
+        const cloud = new PgAdapterAsync2(getConnectionString2("todos"));
+        let tableList;
+        if (tablesStr) {
+          tableList = tablesStr.split(",").map((t) => t.trim());
+        } else {
+          try {
+            tableList = (await listPgTables2(cloud)).filter((t) => !t.startsWith("_"));
+          } catch {
+            local.close();
+            await cloud.close();
+            return { content: [{ type: "text", text: "Error: failed to list cloud tables." }], isError: true };
+          }
+        }
+        let totalConflicts = 0;
+        for (const table of tableList) {
+          totalConflicts += await detectAndLogConflicts(local, cloud, table);
+        }
+        const results = await syncPull2(cloud, local, { tables: tableList });
+        const syncTime = now();
+        for (const result of results) {
+          if (result.rowsWritten > 0) {
+            try {
+              local.run(`UPDATE "${result.table}" SET synced_at = ? WHERE synced_at IS NULL OR synced_at < ?`, syncTime, syncTime);
+            } catch {}
+          }
+        }
+        local.close();
+        await cloud.close();
+        const total = results.reduce((s, r) => s + r.rowsWritten, 0);
+        const errors2 = results.flatMap((r) => r.errors);
+        const lines = [`Pulled ${total} rows across ${tableList.length} table(s).`];
+        if (totalConflicts > 0)
+          lines.push(`Conflicts detected: ${totalConflicts} (logged to _sync_conflicts)`);
+        if (errors2.length > 0)
+          lines.push(`Errors: ${errors2.join("; ")}`);
+        return { content: [{ type: "text", text: lines.join(`
+`) }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("sync_all")) {
+    server.tool("sync_all", "Bidirectional cloud sync \u2014 pull remote changes then push local changes. Detects and logs conflicts.", {
+      tables: exports_external.string().optional().describe("Comma-separated table names (default: all)")
+    }, async ({ tables: tablesStr }) => {
+      try {
+        const {
+          getCloudConfig: getCloudConfig2,
+          getConnectionString: getConnectionString2,
+          syncPush: syncPush2,
+          syncPull: syncPull2,
+          listSqliteTables: listSqliteTables2,
+          listPgTables: listPgTables2,
+          SqliteAdapter: SqliteAdapter2,
+          PgAdapterAsync: PgAdapterAsync2,
+          getDbPath: getDbPath3
+        } = await Promise.resolve().then(() => (init_dist(), exports_dist));
+        const config = getCloudConfig2();
+        if (config.mode === "local") {
+          return { content: [{ type: "text", text: "Error: cloud mode not configured." }], isError: true };
+        }
+        const db = getDatabase();
+        const machineId = getMachineId(db);
+        const local = new SqliteAdapter2(getDbPath3("todos"));
+        const cloud = new PgAdapterAsync2(getConnectionString2("todos"));
+        let tableList;
+        if (tablesStr) {
+          tableList = tablesStr.split(",").map((t) => t.trim());
+        } else {
+          const localTables = new Set(listSqliteTables2(local).filter((t) => !t.startsWith("_")));
+          const remoteTables = new Set((await listPgTables2(cloud)).filter((t) => !t.startsWith("_")));
+          tableList = [...new Set([...localTables, ...remoteTables])];
+        }
+        let totalConflicts = 0;
+        for (const table of tableList) {
+          totalConflicts += await detectAndLogConflicts(local, cloud, table);
+        }
+        const pullResults = await syncPull2(cloud, local, { tables: tableList });
+        const pullTotal = pullResults.reduce((s, r) => s + r.rowsWritten, 0);
+        for (const table of tableList) {
+          try {
+            local.run(`UPDATE "${table}" SET machine_id = ? WHERE machine_id IS NULL`, machineId);
+          } catch {}
+        }
+        const pushResults = await syncPush2(local, cloud, { tables: tableList });
+        const pushTotal = pushResults.reduce((s, r) => s + r.rowsWritten, 0);
+        const syncTime = now();
+        for (const table of tableList) {
+          try {
+            local.run(`UPDATE "${table}" SET synced_at = ?`, syncTime);
+          } catch {}
+        }
+        local.close();
+        await cloud.close();
+        const allErrors = [
+          ...pullResults.flatMap((r) => r.errors.map((e) => `pull: ${e}`)),
+          ...pushResults.flatMap((r) => r.errors.map((e) => `push: ${e}`))
+        ];
+        const lines = [
+          `Sync complete: pulled ${pullTotal} rows, pushed ${pushTotal} rows across ${tableList.length} table(s).`,
+          `Machine: ${machineId}`
+        ];
+        if (totalConflicts > 0)
+          lines.push(`Conflicts detected: ${totalConflicts} (logged to _sync_conflicts)`);
+        if (allErrors.length > 0)
+          lines.push(`Errors: ${allErrors.join("; ")}`);
+        return { content: [{ type: "text", text: lines.join(`
+`) }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("todos_cloud_conflicts")) {
+    server.tool("todos_cloud_conflicts", "List sync conflicts detected during push/pull operations. Shows unresolved conflicts by default.", {
+      resolved: exports_external.boolean().optional().describe("Filter by resolved status. Default: false (unresolved only)"),
+      table: exports_external.string().optional().describe("Filter by table name"),
+      limit: exports_external.number().optional().describe("Max conflicts to return. Default: 20")
+    }, async ({ resolved, table, limit: maxResults }) => {
+      try {
+        const { listConflicts: listConflicts2, ensureConflictsTable: ensureConflictsTable2, SqliteAdapter: SqliteAdapter2, getDbPath: getDbPath3 } = await Promise.resolve().then(() => (init_dist(), exports_dist));
+        const local = new SqliteAdapter2(getDbPath3("todos"));
+        ensureConflictsTable2(local);
+        const conflicts = listConflicts2(local, {
+          resolved: resolved ?? false,
+          table
+        });
+        local.close();
+        const shown = conflicts.slice(0, maxResults ?? 20);
+        if (shown.length === 0) {
+          return { content: [{ type: "text", text: resolved ? "No resolved conflicts." : "No unresolved conflicts." }] };
+        }
+        const lines = [`${conflicts.length} conflict(s) found${conflicts.length > shown.length ? ` (showing ${shown.length})` : ""}:
+`];
+        for (const c of shown) {
+          lines.push(`[${c.id}] ${c.table_name}/${c.row_id}`);
+          lines.push(`  Local updated: ${c.local_updated_at}`);
+          lines.push(`  Remote updated: ${c.remote_updated_at}`);
+          if (c.resolution)
+            lines.push(`  Resolution: ${c.resolution} at ${c.resolved_at}`);
+          lines.push("");
+        }
+        return { content: [{ type: "text", text: lines.join(`
+`) }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("todos_cloud_feedback")) {
+    server.tool("todos_cloud_feedback", "Send feedback for this service", {
+      message: exports_external.string().describe("Feedback message"),
+      email: exports_external.string().optional().describe("Contact email")
+    }, async ({ message, email }) => {
+      try {
+        const { sendFeedback: sendFeedback2, createDatabase: createDatabase2 } = await Promise.resolve().then(() => (init_dist(), exports_dist));
+        const db = createDatabase2({ service: "cloud" });
+        const result = await sendFeedback2({ service: "todos", message, email }, db);
+        db.close();
+        return {
+          content: [{
+            type: "text",
+            text: result.sent ? `Feedback sent (id: ${result.id})` : `Saved locally (id: ${result.id}): ${result.error}`
+          }]
+        };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+}
+var CONFLICT_TABLES;
+var init_cloud = __esm(() => {
+  init_zod();
+  init_database();
+  init_machines();
+  CONFLICT_TABLES = new Set([
+    "projects",
+    "tasks",
+    "agents",
+    "task_lists",
+    "plans",
+    "orgs",
+    "task_templates",
+    "webhooks",
+    "project_sources",
+    "task_checklists"
+  ]);
+});
+
 // src/mcp/tools/dispatch.ts
 function registerDispatchTools(server, { shouldRegisterTool, resolveId, formatError }) {
   if (shouldRegisterTool("dispatch_tasks")) {
@@ -25488,7 +26012,7 @@ async function main() {
 var server, TODOS_PROFILE, MINIMAL_TOOLS, STANDARD_EXCLUDED, agentFocusMap;
 var init_mcp = __esm(() => {
   init_zod();
-  init_dist();
+  init_cloud();
   init_tasks();
   init_comments();
   init_projects();
@@ -29040,7 +29564,7 @@ ${result.errors.join(`
     });
   }
   registerDispatchTools(server, { shouldRegisterTool, resolveId, formatError });
-  registerCloudTools(server, "todos");
+  registerCloudSyncTools(server, { shouldRegisterTool, formatError });
   main().catch((err) => {
     console.error("MCP server error:", err);
     process.exit(1);
@@ -35282,5 +35806,329 @@ dbCmd.command("migrate-pg").description("Apply PostgreSQL migrations to the conf
     process.exit(1);
   }
 });
+var cloudCmd = program2.command("cloud").description("Cloud sync commands");
+cloudCmd.command("status").description("Show cloud config, connection health, machine registry, and sync status").option("--json", "Output as JSON").action(async (opts) => {
+  const globalOpts = program2.opts();
+  const useJson = opts.json || globalOpts.json;
+  try {
+    const { getCloudConfig: getCloudConfig2, getConnectionString: getConnectionString2, PgAdapterAsync: PgAdapterAsync2, SqliteAdapter: SqliteAdapter2, getDbPath: getDbPath3, listSqliteTables: listSqliteTables2, ensureConflictsTable: ensureConflictsTable2, listConflicts: listConflicts2 } = await Promise.resolve().then(() => (init_dist(), exports_dist));
+    const { getMachineId: getMachineId2, listMachines: listMachines2 } = await Promise.resolve().then(() => (init_machines(), exports_machines));
+    const config = getCloudConfig2();
+    const machineId = getMachineId2();
+    const machines = listMachines2();
+    const info = {
+      mode: config.mode,
+      service: "todos",
+      machine_id: machineId,
+      rds_host: config.rds.host || "(not configured)",
+      machines: machines.map((m) => ({ id: m.id, name: m.name, hostname: m.hostname, platform: m.platform, last_seen: m.last_seen_at }))
+    };
+    if (config.rds.host && config.rds.username) {
+      try {
+        const pg = new PgAdapterAsync2(getConnectionString2("postgres"));
+        await pg.get("SELECT 1 as ok");
+        info.postgresql = "connected";
+        await pg.close();
+      } catch (err) {
+        info.postgresql = `failed \u2014 ${err?.message}`;
+      }
+    }
+    const local = new SqliteAdapter2(getDbPath3("todos"));
+    const tables = listSqliteTables2(local).filter((t) => !t.startsWith("_"));
+    const syncHealth = [];
+    for (const table of tables) {
+      try {
+        const totalRow = local.get(`SELECT COUNT(*) as c FROM "${table}"`);
+        const unsyncedRow = local.get(`SELECT COUNT(*) as c FROM "${table}" WHERE synced_at IS NULL`);
+        const lastRow = local.get(`SELECT MAX(synced_at) as m FROM "${table}"`);
+        syncHealth.push({
+          table,
+          total: totalRow?.c ?? 0,
+          unsynced: unsyncedRow?.c ?? 0,
+          last_synced: lastRow?.m ?? null
+        });
+      } catch {}
+    }
+    info.sync_health = syncHealth.filter((s) => s.total > 0);
+    try {
+      ensureConflictsTable2(local);
+      const unresolved = listConflicts2(local, { resolved: false });
+      info.conflicts_unresolved = unresolved.length;
+    } catch {}
+    local.close();
+    if (useJson) {
+      console.log(JSON.stringify(info, null, 2));
+    } else {
+      console.log(chalk3.bold("Cloud Status"));
+      console.log(`  Mode: ${info.mode}`);
+      console.log(`  Machine: ${machineId}`);
+      console.log(`  RDS Host: ${info.rds_host}`);
+      if (info.postgresql)
+        console.log(`  PostgreSQL: ${info.postgresql}`);
+      if (machines.length > 0) {
+        console.log(chalk3.bold(`
+Machines`));
+        for (const m of machines) {
+          const current = m.id === machineId ? chalk3.green(" (this)") : "";
+          console.log(`  ${m.name}${current} \u2014 ${m.hostname || "?"} / ${m.platform || "?"} \u2014 last seen ${m.last_seen_at}`);
+        }
+      }
+      const healthItems = info.sync_health.filter((s) => s.total > 0);
+      if (healthItems.length > 0) {
+        console.log(chalk3.bold(`
+Sync Health`));
+        for (const s of healthItems) {
+          const pct = s.total > 0 ? Math.round((s.total - s.unsynced) / s.total * 100) : 100;
+          const color = pct === 100 ? chalk3.green : pct > 50 ? chalk3.yellow : chalk3.red;
+          console.log(`  ${s.table}: ${color(`${pct}%`)} synced (${s.unsynced} unsynced / ${s.total} total)${s.last_synced ? ` \u2014 last: ${s.last_synced}` : ""}`);
+        }
+      }
+      if (info.conflicts_unresolved > 0) {
+        console.log(chalk3.bold(`
+Conflicts`));
+        console.log(`  ${chalk3.yellow(`${info.conflicts_unresolved} unresolved`)} \u2014 run \`todos cloud conflicts\` to review`);
+      }
+    }
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    if (useJson) {
+      console.log(JSON.stringify({ error: msg }));
+    } else {
+      console.error(chalk3.red(msg));
+    }
+  }
+});
+cloudCmd.command("push").description("Push local data to cloud PostgreSQL").option("--tables <tables>", "Comma-separated table names (default: all)").option("--json", "Output as JSON").action(async (opts) => {
+  const globalOpts = program2.opts();
+  const useJson = opts.json || globalOpts.json;
+  try {
+    const { getCloudConfig: getCloudConfig2, getConnectionString: getConnectionString2, syncPush: syncPush2, listSqliteTables: listSqliteTables2, SqliteAdapter: SqliteAdapter2, PgAdapterAsync: PgAdapterAsync2, getDbPath: getDbPath3 } = await Promise.resolve().then(() => (init_dist(), exports_dist));
+    const { getMachineId: getMachineId2 } = await Promise.resolve().then(() => (init_machines(), exports_machines));
+    const { now: now2 } = await Promise.resolve().then(() => (init_database(), exports_database));
+    const config = getCloudConfig2();
+    if (config.mode === "local") {
+      const msg = "Error: cloud mode not configured.";
+      if (useJson) {
+        console.log(JSON.stringify({ error: msg }));
+      } else {
+        console.error(chalk3.red(msg));
+      }
+      process.exit(1);
+    }
+    const machineId = getMachineId2();
+    const local = new SqliteAdapter2(getDbPath3("todos"));
+    const cloud = new PgAdapterAsync2(getConnectionString2("todos"));
+    const tableList = opts.tables ? opts.tables.split(",").map((t) => t.trim()) : listSqliteTables2(local).filter((t) => !t.startsWith("_"));
+    for (const table of tableList) {
+      try {
+        local.run(`UPDATE "${table}" SET machine_id = ? WHERE machine_id IS NULL`, machineId);
+      } catch {}
+    }
+    const results = await syncPush2(local, cloud, {
+      tables: tableList,
+      onProgress: (p) => {
+        if (!useJson && p.phase === "done") {
+          console.log(`  ${p.table}: ${p.rowsWritten} rows pushed`);
+        }
+      }
+    });
+    const syncTime = now2();
+    for (const r of results) {
+      if (r.rowsWritten > 0) {
+        try {
+          local.run(`UPDATE "${r.table}" SET synced_at = ? WHERE machine_id = ?`, syncTime, machineId);
+        } catch {}
+      }
+    }
+    local.close();
+    await cloud.close();
+    const total = results.reduce((s, r) => s + r.rowsWritten, 0);
+    if (useJson) {
+      console.log(JSON.stringify({ total, machine_id: machineId, tables: results }));
+    } else {
+      console.log(chalk3.green(`Done. ${total} rows pushed (machine: ${machineId}).`));
+    }
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    if (useJson) {
+      console.log(JSON.stringify({ error: msg }));
+    } else {
+      console.error(chalk3.red(msg));
+    }
+    process.exit(1);
+  }
+});
+cloudCmd.command("pull").description("Pull cloud data to local \u2014 merges by primary key").option("--tables <tables>", "Comma-separated table names (default: all)").option("--json", "Output as JSON").action(async (opts) => {
+  const globalOpts = program2.opts();
+  const useJson = opts.json || globalOpts.json;
+  try {
+    const { getCloudConfig: getCloudConfig2, getConnectionString: getConnectionString2, syncPull: syncPull2, listPgTables: listPgTables2, SqliteAdapter: SqliteAdapter2, PgAdapterAsync: PgAdapterAsync2, getDbPath: getDbPath3 } = await Promise.resolve().then(() => (init_dist(), exports_dist));
+    const { now: now2 } = await Promise.resolve().then(() => (init_database(), exports_database));
+    const config = getCloudConfig2();
+    if (config.mode === "local") {
+      const msg = "Error: cloud mode not configured.";
+      if (useJson) {
+        console.log(JSON.stringify({ error: msg }));
+      } else {
+        console.error(chalk3.red(msg));
+      }
+      process.exit(1);
+    }
+    const local = new SqliteAdapter2(getDbPath3("todos"));
+    const cloud = new PgAdapterAsync2(getConnectionString2("todos"));
+    let tableList;
+    if (opts.tables) {
+      tableList = opts.tables.split(",").map((t) => t.trim());
+    } else {
+      tableList = (await listPgTables2(cloud)).filter((t) => !t.startsWith("_"));
+    }
+    const results = await syncPull2(cloud, local, {
+      tables: tableList,
+      onProgress: (p) => {
+        if (!useJson && p.phase === "done") {
+          console.log(`  ${p.table}: ${p.rowsWritten} rows pulled`);
+        }
+      }
+    });
+    const syncTime = now2();
+    for (const r of results) {
+      if (r.rowsWritten > 0) {
+        try {
+          local.run(`UPDATE "${r.table}" SET synced_at = ? WHERE synced_at IS NULL OR synced_at < ?`, syncTime, syncTime);
+        } catch {}
+      }
+    }
+    local.close();
+    await cloud.close();
+    const total = results.reduce((s, r) => s + r.rowsWritten, 0);
+    if (useJson) {
+      console.log(JSON.stringify({ total, tables: results }));
+    } else {
+      console.log(chalk3.green(`Done. ${total} rows pulled.`));
+    }
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    if (useJson) {
+      console.log(JSON.stringify({ error: msg }));
+    } else {
+      console.error(chalk3.red(msg));
+    }
+    process.exit(1);
+  }
+});
+cloudCmd.command("sync").description("Bidirectional sync \u2014 pull remote changes then push local changes").option("--tables <tables>", "Comma-separated table names (default: all)").option("--json", "Output as JSON").action(async (opts) => {
+  const globalOpts = program2.opts();
+  const useJson = opts.json || globalOpts.json;
+  try {
+    const { getCloudConfig: getCloudConfig2, getConnectionString: getConnectionString2, syncPush: syncPush2, syncPull: syncPull2, listSqliteTables: listSqliteTables2, listPgTables: listPgTables2, SqliteAdapter: SqliteAdapter2, PgAdapterAsync: PgAdapterAsync2, getDbPath: getDbPath3 } = await Promise.resolve().then(() => (init_dist(), exports_dist));
+    const { getMachineId: getMachineId2 } = await Promise.resolve().then(() => (init_machines(), exports_machines));
+    const { now: now2 } = await Promise.resolve().then(() => (init_database(), exports_database));
+    const config = getCloudConfig2();
+    if (config.mode === "local") {
+      const msg = "Error: cloud mode not configured.";
+      if (useJson) {
+        console.log(JSON.stringify({ error: msg }));
+      } else {
+        console.error(chalk3.red(msg));
+      }
+      process.exit(1);
+    }
+    const machineId = getMachineId2();
+    const local = new SqliteAdapter2(getDbPath3("todos"));
+    const cloud = new PgAdapterAsync2(getConnectionString2("todos"));
+    let tableList;
+    if (opts.tables) {
+      tableList = opts.tables.split(",").map((t) => t.trim());
+    } else {
+      const localTables = new Set(listSqliteTables2(local).filter((t) => !t.startsWith("_")));
+      const remoteTables = new Set((await listPgTables2(cloud)).filter((t) => !t.startsWith("_")));
+      tableList = [...new Set([...localTables, ...remoteTables])];
+    }
+    if (!useJson)
+      console.log(chalk3.bold("Pulling..."));
+    const pullResults = await syncPull2(cloud, local, {
+      tables: tableList,
+      onProgress: (p) => {
+        if (!useJson && p.phase === "done" && p.rowsWritten > 0)
+          console.log(`  \u2193 ${p.table}: ${p.rowsWritten} rows`);
+      }
+    });
+    const pullTotal = pullResults.reduce((s, r) => s + r.rowsWritten, 0);
+    for (const table of tableList) {
+      try {
+        local.run(`UPDATE "${table}" SET machine_id = ? WHERE machine_id IS NULL`, machineId);
+      } catch {}
+    }
+    if (!useJson)
+      console.log(chalk3.bold("Pushing..."));
+    const pushResults = await syncPush2(local, cloud, {
+      tables: tableList,
+      onProgress: (p) => {
+        if (!useJson && p.phase === "done" && p.rowsWritten > 0)
+          console.log(`  \u2191 ${p.table}: ${p.rowsWritten} rows`);
+      }
+    });
+    const pushTotal = pushResults.reduce((s, r) => s + r.rowsWritten, 0);
+    const syncTime = now2();
+    for (const table of tableList) {
+      try {
+        local.run(`UPDATE "${table}" SET synced_at = ?`, syncTime);
+      } catch {}
+    }
+    local.close();
+    await cloud.close();
+    if (useJson) {
+      console.log(JSON.stringify({ pulled: pullTotal, pushed: pushTotal, machine_id: machineId, tables: tableList.length }));
+    } else {
+      console.log(chalk3.green(`Done. Pulled ${pullTotal}, pushed ${pushTotal} rows across ${tableList.length} table(s) (machine: ${machineId}).`));
+    }
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    if (useJson) {
+      console.log(JSON.stringify({ error: msg }));
+    } else {
+      console.error(chalk3.red(msg));
+    }
+    process.exit(1);
+  }
+});
+cloudCmd.command("conflicts").description("List sync conflicts detected during push/pull").option("--resolved", "Show resolved conflicts instead of unresolved").option("--table <table>", "Filter by table name").option("--limit <n>", "Max conflicts to show", "20").option("--json", "Output as JSON").action(async (opts) => {
+  const globalOpts = program2.opts();
+  const useJson = opts.json || globalOpts.json;
+  try {
+    const { listConflicts: listConflicts2, ensureConflictsTable: ensureConflictsTable2, SqliteAdapter: SqliteAdapter2, getDbPath: getDbPath3 } = await Promise.resolve().then(() => (init_dist(), exports_dist));
+    const local = new SqliteAdapter2(getDbPath3("todos"));
+    ensureConflictsTable2(local);
+    const conflicts = listConflicts2(local, { resolved: !!opts.resolved, table: opts.table });
+    local.close();
+    const maxResults = parseInt(opts.limit, 10) || 20;
+    const shown = conflicts.slice(0, maxResults);
+    if (useJson) {
+      console.log(JSON.stringify({ total: conflicts.length, conflicts: shown }, null, 2));
+      return;
+    }
+    if (shown.length === 0) {
+      console.log(chalk3.dim(opts.resolved ? "No resolved conflicts." : "No unresolved conflicts."));
+      return;
+    }
+    console.log(`${conflicts.length} conflict(s)${conflicts.length > shown.length ? ` (showing ${shown.length})` : ""}:
+`);
+    for (const c of shown) {
+      console.log(chalk3.yellow(`[${c.id}]`) + ` ${c.table_name}/${c.row_id}`);
+      console.log(`  Local:  ${c.local_updated_at}`);
+      console.log(`  Remote: ${c.remote_updated_at}`);
+      if (c.resolution)
+        console.log(`  Resolution: ${chalk3.green(c.resolution)} at ${c.resolved_at}`);
+      console.log();
+    }
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    if (useJson) {
+      console.log(JSON.stringify({ error: msg }));
+    } else {
+      console.error(chalk3.red(msg));
+    }
+  }
+});
 registerDispatchCommands(program2);
 program2.parse();