@hasna/todos 0.11.7 → 0.11.8

package/dist/mcp/index.js

@@ -40,6 +40,64 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
 // node_modules/@hasna/cloud/dist/index.js
+var exports_dist = {};
+__export(exports_dist, {
+  translateSql: () => translateSql,
+  translateParams: () => translateParams,
+  translateDdl: () => translateDdl,
+  syncPush: () => syncPush,
+  syncPull: () => syncPull,
+  storeConflicts: () => storeConflicts,
+  setupAutoSync: () => setupAutoSync,
+  sendFeedback: () => sendFeedback,
+  saveFeedback: () => saveFeedback,
+  saveCloudConfig: () => saveCloudConfig,
+  runScheduledSync: () => runScheduledSync,
+  resolveConflicts: () => resolveConflicts,
+  resolveConflict: () => resolveConflict,
+  resetSyncMeta: () => resetSyncMeta,
+  resetAllSyncMeta: () => resetAllSyncMeta,
+  removeSyncSchedule: () => removeSyncSchedule,
+  registerSyncSchedule: () => registerSyncSchedule,
+  registerCloudTools: () => registerCloudTools,
+  registerCloudCommands: () => registerCloudCommands,
+  purgeResolvedConflicts: () => purgeResolvedConflicts,
+  parseInterval: () => parseInterval,
+  minutesToCron: () => minutesToCron,
+  migrateDotfile: () => migrateDotfile,
+  listSqliteTables: () => listSqliteTables,
+  listPgTables: () => listPgTables,
+  listFeedback: () => listFeedback,
+  listConflicts: () => listConflicts,
+  incrementalSyncPush: () => incrementalSyncPush,
+  incrementalSyncPull: () => incrementalSyncPull,
+  hasLegacyDotfile: () => hasLegacyDotfile,
+  getWinningData: () => getWinningData,
+  getSyncScheduleStatus: () => getSyncScheduleStatus,
+  getSyncMetaForTable: () => getSyncMetaForTable,
+  getSyncMetaAll: () => getSyncMetaAll,
+  getHasnaDir: () => getHasnaDir,
+  getDbPath: () => getDbPath,
+  getDataDir: () => getDataDir,
+  getConnectionString: () => getConnectionString,
+  getConflict: () => getConflict,
+  getConfigPath: () => getConfigPath,
+  getConfigDir: () => getConfigDir,
+  getCloudConfig: () => getCloudConfig,
+  getAutoSyncConfig: () => getAutoSyncConfig,
+  ensureSyncMetaTable: () => ensureSyncMetaTable,
+  ensureFeedbackTable: () => ensureFeedbackTable,
+  ensureConflictsTable: () => ensureConflictsTable,
+  enableAutoSync: () => enableAutoSync,
+  discoverSyncableServices: () => discoverSyncableServices,
+  detectConflicts: () => detectConflicts,
+  createDatabase: () => createDatabase,
+  SyncProgressTracker: () => SyncProgressTracker,
+  SqliteAdapter: () => SqliteAdapter,
+  PgAdapterAsync: () => PgAdapterAsync,
+  PgAdapter: () => PgAdapter,
+  CloudConfigSchema: () => CloudConfigSchema
+});
 import { createRequire } from "module";
 import { Database } from "bun:sqlite";
 import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync, writeFileSync } from "fs";
@@ -54,8 +112,12 @@ import {
 import { homedir } from "os";
 import { join, relative } from "path";
 import { hostname } from "os";
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
 import { homedir as homedir3 } from "os";
 import { join as join3 } from "path";
+import { existsSync as existsSync4, readdirSync as readdirSync2 } from "fs";
+import { join as join4 } from "path";
+import { join as join5, dirname } from "path";
 function __accessProp2(key) {
   return this[key];
 }
@@ -96,6 +158,17 @@ function sqliteToPostgres(sql) {
   out = out.replace(/INSERT\s+OR\s+IGNORE\s+INTO/gi, "INSERT INTO");
   return out;
 }
+function translateDdl(ddl, dialect) {
+  if (dialect === "sqlite")
+    return ddl;
+  let out = ddl;
+  out = out.replace(/\bINTEGER\s+PRIMARY\s+KEY\s+AUTOINCREMENT\b/gi, "BIGSERIAL PRIMARY KEY");
+  out = out.replace(/\bAUTOINCREMENT\b/gi, "");
+  out = out.replace(/\bREAL\b/gi, "DOUBLE PRECISION");
+  out = out.replace(/\bBLOB\b/gi, "BYTEA");
+  out = sqliteToPostgres(out);
+  return out;
+}
 
 class SqliteAdapter {
   db;
@@ -919,6 +992,45 @@ function getDbPath(serviceName) {
   const dir = getDataDir(serviceName);
   return join(dir, `${serviceName}.db`);
 }
+function migrateDotfile(serviceName) {
+  const legacyDir = join(homedir(), `.${serviceName}`);
+  const newDir = join(HASNA_DIR, serviceName);
+  if (!existsSync(legacyDir))
+    return [];
+  if (existsSync(newDir))
+    return [];
+  mkdirSync(newDir, { recursive: true });
+  const migrated = [];
+  copyDirRecursive(legacyDir, newDir, legacyDir, migrated);
+  return migrated;
+}
+function copyDirRecursive(src, dest, root, migrated) {
+  const entries = readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = join(src, entry.name);
+    const destPath = join(dest, entry.name);
+    if (entry.isDirectory()) {
+      mkdirSync(destPath, { recursive: true });
+      copyDirRecursive(srcPath, destPath, root, migrated);
+    } else {
+      copyFileSync(srcPath, destPath);
+      migrated.push(relative(root, srcPath));
+    }
+  }
+}
+function hasLegacyDotfile(serviceName) {
+  return existsSync(join(homedir(), `.${serviceName}`));
+}
+function getHasnaDir() {
+  mkdirSync(HASNA_DIR, { recursive: true });
+  return HASNA_DIR;
+}
+function getConfigDir() {
+  return CONFIG_DIR;
+}
+function getConfigPath() {
+  return CONFIG_PATH;
+}
 function getCloudConfig() {
   if (!existsSync2(CONFIG_PATH)) {
     return CloudConfigSchema.parse({});
@@ -930,6 +1042,11 @@ function getCloudConfig() {
     return CloudConfigSchema.parse({});
   }
 }
+function saveCloudConfig(config) {
+  mkdirSync2(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + `
+`, "utf-8");
+}
 function getConnectionString(dbName) {
   const config = getCloudConfig();
   const { host, port, username, password_env, ssl } = config.rds;
@@ -1079,42 +1196,100 @@ async function syncTransfer(source, target, options, _direction) {
     primaryKey: pkOption
   } = options;
   const results = [];
-  for (let i = 0;i < tables.length; i++) {
-    const table = tables[i];
-    const result = {
-      table,
-      rowsRead: 0,
-      rowsWritten: 0,
-      rowsSkipped: 0,
-      errors: []
-    };
+  const sqliteTarget = !isAsyncAdapter(target) ? target : null;
+  if (sqliteTarget) {
     try {
-      onProgress?.({
+      sqliteTarget.exec("PRAGMA foreign_keys = OFF");
+    } catch {}
+  }
+  try {
+    for (let i = 0;i < tables.length; i++) {
+      const table = tables[i];
+      const result = {
         table,
-        phase: "reading",
         rowsRead: 0,
         rowsWritten: 0,
-        totalTables: tables.length,
-        currentTableIndex: i
-      });
-      const rows = await readAll(source, `SELECT * FROM "${table}"`);
-      result.rowsRead = rows.length;
-      if (rows.length === 0) {
+        rowsSkipped: 0,
+        errors: []
+      };
+      try {
         onProgress?.({
           table,
-          phase: "done",
+          phase: "reading",
           rowsRead: 0,
           rowsWritten: 0,
           totalTables: tables.length,
           currentTableIndex: i
         });
-        results.push(result);
-        continue;
-      }
-      const pkColumns = await resolvePrimaryKeys(source, target, table, pkOption);
-      const columns = Object.keys(rows[0]);
-      if (pkColumns.length === 0) {
-        result.errors.push(`Table "${table}" has no primary key \u2014 inserting without conflict handling`);
+        const rows = await readAll(source, `SELECT * FROM "${table}"`);
+        result.rowsRead = rows.length;
+        if (rows.length === 0) {
+          onProgress?.({
+            table,
+            phase: "done",
+            rowsRead: 0,
+            rowsWritten: 0,
+            totalTables: tables.length,
+            currentTableIndex: i
+          });
+          results.push(result);
+          continue;
+        }
+        const pkColumns = await resolvePrimaryKeys(source, target, table, pkOption);
+        const sourceColumns = Object.keys(rows[0]);
+        let targetColumns = null;
+        if (!isAsyncAdapter(target)) {
+          try {
+            const colInfo = target.all(`PRAGMA table_info("${table}")`);
+            targetColumns = new Set(colInfo.map((c) => c.name));
+          } catch {}
+        } else {
+          try {
+            const colInfo = await target.all(`SELECT column_name FROM information_schema.columns WHERE table_schema = 'public' AND table_name = '${table}'`);
+            targetColumns = new Set(colInfo.map((c) => c.column_name));
+          } catch {}
+        }
+        const columns = targetColumns ? sourceColumns.filter((c) => targetColumns.has(c)) : sourceColumns;
+        if (pkColumns.length === 0) {
+          result.errors.push(`Table "${table}" has no primary key \u2014 inserting without conflict handling`);
+          onProgress?.({
+            table,
+            phase: "writing",
+            rowsRead: result.rowsRead,
+            rowsWritten: 0,
+            totalTables: tables.length,
+            currentTableIndex: i
+          });
+          for (let offset = 0;offset < rows.length; offset += batchSize) {
+            const batch = rows.slice(offset, offset + batchSize);
+            try {
+              if (isAsyncAdapter(target)) {
+                await batchInsertPg(target, table, columns, batch);
+              } else {
+                batchInsertSqlite(target, table, columns, batch);
+              }
+              result.rowsWritten += batch.length;
+            } catch (err) {
+              result.errors.push(`Batch at offset ${offset}: ${err?.message ?? String(err)}`);
+            }
+          }
+          onProgress?.({
+            table,
+            phase: "done",
+            rowsRead: result.rowsRead,
+            rowsWritten: result.rowsWritten,
+            totalTables: tables.length,
+            currentTableIndex: i
+          });
+          results.push(result);
+          continue;
+        }
+        const missingPks = pkColumns.filter((pk) => !columns.includes(pk));
+        if (missingPks.length > 0) {
+          result.errors.push(`Table "${table}" missing PK columns in data: ${missingPks.join(", ")} \u2014 skipping`);
+          results.push(result);
+          continue;
+        }
         onProgress?.({
           table,
           phase: "writing",
@@ -1123,18 +1298,27 @@ async function syncTransfer(source, target, options, _direction) {
           totalTables: tables.length,
           currentTableIndex: i
         });
+        const updateCols = columns.filter((c) => !pkColumns.includes(c));
         for (let offset = 0;offset < rows.length; offset += batchSize) {
           const batch = rows.slice(offset, offset + batchSize);
           try {
             if (isAsyncAdapter(target)) {
-              await batchInsertPg(target, table, columns, batch);
+              await batchUpsertPg(target, table, columns, updateCols, pkColumns, batch);
             } else {
-              batchInsertSqlite(target, table, columns, batch);
+              batchUpsertSqlite(target, table, columns, updateCols, pkColumns, batch);
             }
             result.rowsWritten += batch.length;
           } catch (err) {
             result.errors.push(`Batch at offset ${offset}: ${err?.message ?? String(err)}`);
           }
+          onProgress?.({
+            table,
+            phase: "writing",
+            rowsRead: result.rowsRead,
+            rowsWritten: result.rowsWritten,
+            totalTables: tables.length,
+            currentTableIndex: i
+          });
         }
         onProgress?.({
           table,
@@ -1144,57 +1328,27 @@ async function syncTransfer(source, target, options, _direction) {
           totalTables: tables.length,
           currentTableIndex: i
         });
-        results.push(result);
-        continue;
-      }
-      const missingPks = pkColumns.filter((pk) => !columns.includes(pk));
-      if (missingPks.length > 0) {
-        result.errors.push(`Table "${table}" missing PK columns in data: ${missingPks.join(", ")} \u2014 skipping`);
-        results.push(result);
-        continue;
+      } catch (err) {
+        result.errors.push(`Table "${table}": ${err?.message ?? String(err)}`);
       }
-      onProgress?.({
-        table,
-        phase: "writing",
-        rowsRead: result.rowsRead,
-        rowsWritten: 0,
-        totalTables: tables.length,
-        currentTableIndex: i
-      });
-      const updateCols = columns.filter((c) => !pkColumns.includes(c));
-      for (let offset = 0;offset < rows.length; offset += batchSize) {
-        const batch = rows.slice(offset, offset + batchSize);
-        try {
-          if (isAsyncAdapter(target)) {
-            await batchUpsertPg(target, table, columns, updateCols, pkColumns, batch);
-          } else {
-            batchUpsertSqlite(target, table, columns, updateCols, pkColumns, batch);
+      results.push(result);
+    }
+  } finally {
+    if (sqliteTarget) {
+      try {
+        sqliteTarget.exec("PRAGMA foreign_keys = ON");
+      } catch {}
+      try {
+        const violations = sqliteTarget.all("PRAGMA foreign_key_check");
+        if (violations.length > 0) {
+          const tables2 = [...new Set(violations.map((v) => v.table))];
+          const msg = `FK integrity check: ${violations.length} violation(s) in table(s): ${tables2.join(", ")}`;
+          if (results.length > 0) {
+            results[results.length - 1].errors.push(msg);
           }
-          result.rowsWritten += batch.length;
-        } catch (err) {
-          result.errors.push(`Batch at offset ${offset}: ${err?.message ?? String(err)}`);
         }
-        onProgress?.({
-          table,
-          phase: "writing",
-          rowsRead: result.rowsRead,
-          rowsWritten: result.rowsWritten,
-          totalTables: tables.length,
-          currentTableIndex: i
-        });
-      }
-      onProgress?.({
-        table,
-        phase: "done",
-        rowsRead: result.rowsRead,
-        rowsWritten: result.rowsWritten,
-        totalTables: tables.length,
-        currentTableIndex: i
-      });
-    } catch (err) {
-      result.errors.push(`Table "${table}": ${err?.message ?? String(err)}`);
+      } catch {}
     }
-    results.push(result);
   }
   return results;
 }
@@ -1222,7 +1376,7 @@ function batchUpsertSqlite(target, table, columns, updateCols, primaryKeys, batc
   const setClause = updateCols.length > 0 ? updateCols.map((c) => `"${c}" = EXCLUDED."${c}"`).join(", ") : `"${primaryKeys[0]}" = EXCLUDED."${primaryKeys[0]}"`;
   const sql = `INSERT INTO "${table}" (${colList}) VALUES ${valuePlaceholders}
     ON CONFLICT (${pkList}) DO UPDATE SET ${setClause}`;
-  const params = batch.flatMap((row) => columns.map((c) => row[c] ?? null));
+  const params = batch.flatMap((row) => columns.map((c) => coerceForSqlite(row[c])));
   target.run(sql, ...params);
 }
 async function batchInsertPg(target, table, columns, batch) {
@@ -1243,9 +1397,22 @@ function batchInsertSqlite(target, table, columns, batch) {
   const colList = columns.map((c) => `"${c}"`).join(", ");
   const valuePlaceholders = batch.map(() => `(${columns.map(() => "?").join(", ")})`).join(", ");
   const sql = `INSERT INTO "${table}" (${colList}) VALUES ${valuePlaceholders}`;
-  const params = batch.flatMap((row) => columns.map((c) => row[c] ?? null));
+  const params = batch.flatMap((row) => columns.map((c) => coerceForSqlite(row[c])));
   target.run(sql, ...params);
 }
+function coerceForSqlite(value) {
+  if (value === null || value === undefined)
+    return null;
+  if (typeof value === "string" || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean")
+    return value;
+  if (value instanceof Date)
+    return value.toISOString();
+  if (Buffer.isBuffer(value) || value instanceof Uint8Array)
+    return value;
+  if (typeof value === "object")
+    return JSON.stringify(value);
+  return String(value);
+}
 function isAsyncAdapter(adapter) {
   return adapter.constructor.name === "PgAdapterAsync" || typeof adapter.raw?.connect === "function";
 }
@@ -1313,6 +1480,10 @@ async function sendFeedback(feedback, db) {
     return { sent: false, id, error: errorMsg };
   }
 }
+function listFeedback(db) {
+  ensureFeedbackTable(db);
+  return db.all(`SELECT id, service, version, message, email, machine_id, created_at FROM feedback ORDER BY created_at DESC`);
+}
 
 class SyncProgressTracker {
   db;
@@ -1433,105 +1604,749 @@ class SyncProgressTracker {
     }
   }
 }
-function registerCloudTools(server, serviceName) {
-  server.tool(`${serviceName}_cloud_status`, "Show cloud configuration and connection health", {}, async () => {
-    const config = getCloudConfig();
-    const lines = [
-      `Mode: ${config.mode}`,
-      `Service: ${serviceName}`,
-      `RDS Host: ${config.rds.host || "(not configured)"}`
-    ];
-    if (config.rds.host && config.rds.username) {
-      try {
-        const pg2 = new PgAdapterAsync(getConnectionString("postgres"));
-        await pg2.get("SELECT 1 as ok");
-        lines.push("PostgreSQL: connected");
-        await pg2.close();
-      } catch (err) {
-        lines.push(`PostgreSQL: failed \u2014 ${err?.message}`);
-      }
+function detectConflicts(local, remote, table, primaryKey = "id", conflictColumn = "updated_at") {
+  const conflicts = [];
+  const remoteMap = new Map;
+  for (const row of remote) {
+    const key = String(row[primaryKey]);
+    remoteMap.set(key, row);
+  }
+  for (const localRow of local) {
+    const key = String(localRow[primaryKey]);
+    const remoteRow = remoteMap.get(key);
+    if (!remoteRow)
+      continue;
+    const localTs = localRow[conflictColumn];
+    const remoteTs = remoteRow[conflictColumn];
+    if (localTs !== remoteTs) {
+      conflicts.push({
+        table,
+        row_id: key,
+        local_updated_at: String(localTs ?? ""),
+        remote_updated_at: String(remoteTs ?? ""),
+        local_data: { ...localRow },
+        remote_data: { ...remoteRow },
+        resolved: false
+      });
     }
-    return { content: [{ type: "text", text: lines.join(`
-`) }] };
-  });
-  server.tool(`${serviceName}_cloud_push`, "Push local data to cloud PostgreSQL", {
-    tables: exports_external2.string().optional().describe("Comma-separated table names (default: all)")
-  }, async ({ tables: tablesStr }) => {
-    const config = getCloudConfig();
-    if (config.mode === "local") {
-      return {
-        content: [
-          { type: "text", text: "Error: cloud mode not configured." }
-        ],
-        isError: true
-      };
+  }
+  return conflicts;
+}
+function resolveConflicts(conflicts, strategy = "newest-wins") {
+  return conflicts.map((conflict) => {
+    const resolved = { ...conflict, resolved: true, resolution: strategy };
+    switch (strategy) {
+      case "local-wins":
+        break;
+      case "remote-wins":
+        break;
+      case "newest-wins": {
+        const localTime = new Date(conflict.local_updated_at).getTime();
+        const remoteTime = new Date(conflict.remote_updated_at).getTime();
+        if (remoteTime > localTime) {
+          resolved.resolution = "newest-wins";
+        } else {
+          resolved.resolution = "newest-wins";
+        }
+        break;
+      }
     }
-    const local = new SqliteAdapter(getDbPath(serviceName));
-    const cloud = new PgAdapterAsync(getConnectionString(serviceName));
-    const tableList = tablesStr ? tablesStr.split(",").map((t) => t.trim()) : listSqliteTables(local);
-    const results = await syncPush(local, cloud, { tables: tableList });
-    local.close();
-    await cloud.close();
-    const total = results.reduce((s, r) => s + r.rowsWritten, 0);
-    return {
-      content: [{ type: "text", text: `Pushed ${total} rows across ${tableList.length} table(s).` }]
-    };
+    return resolved;
   });
-  server.tool(`${serviceName}_cloud_pull`, "Pull cloud PostgreSQL data to local", {
-    tables: exports_external2.string().optional().describe("Comma-separated table names (default: all)")
-  }, async ({ tables: tablesStr }) => {
-    const config = getCloudConfig();
-    if (config.mode === "local") {
-      return {
-        content: [
-          { type: "text", text: "Error: cloud mode not configured." }
-        ],
-        isError: true
-      };
-    }
-    const local = new SqliteAdapter(getDbPath(serviceName));
-    const cloud = new PgAdapterAsync(getConnectionString(serviceName));
-    let tableList;
-    if (tablesStr) {
-      tableList = tablesStr.split(",").map((t) => t.trim());
+}
+function getWinningData(conflict) {
+  if (!conflict.resolved || !conflict.resolution) {
+    throw new Error(`Conflict for row ${conflict.row_id} is not resolved`);
+  }
+  switch (conflict.resolution) {
+    case "local-wins":
+      return conflict.local_data;
+    case "remote-wins":
+      return conflict.remote_data;
+    case "newest-wins": {
+      const localTime = new Date(conflict.local_updated_at).getTime();
+      const remoteTime = new Date(conflict.remote_updated_at).getTime();
+      return remoteTime >= localTime ? conflict.remote_data : conflict.local_data;
+    }
+    case "manual":
+      return conflict.local_data;
+    default:
+      return conflict.local_data;
+  }
+}
+function ensureConflictsTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS _sync_conflicts (
+      id TEXT PRIMARY KEY,
+      table_name TEXT,
+      row_id TEXT,
+      local_data TEXT,
+      remote_data TEXT,
+      local_updated_at TEXT,
+      remote_updated_at TEXT,
+      resolution TEXT,
+      resolved_at TEXT,
+      created_at TEXT DEFAULT (datetime('now'))
+    )
+  `);
+}
+function storeConflicts(db, conflicts) {
+  ensureConflictsTable(db);
+  for (const conflict of conflicts) {
+    const id = `${conflict.table}:${conflict.row_id}:${Date.now()}`;
+    db.run(`INSERT INTO _sync_conflicts (id, table_name, row_id, local_data, remote_data, local_updated_at, remote_updated_at, resolution, resolved_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, id, conflict.table, conflict.row_id, JSON.stringify(conflict.local_data), JSON.stringify(conflict.remote_data), conflict.local_updated_at, conflict.remote_updated_at, conflict.resolution ?? null, conflict.resolved ? new Date().toISOString() : null);
+  }
+}
+function listConflicts(db, opts) {
+  ensureConflictsTable(db);
+  let sql = `SELECT * FROM _sync_conflicts WHERE 1=1`;
+  const params = [];
+  if (opts?.resolved !== undefined) {
+    if (opts.resolved) {
+      sql += ` AND resolution IS NOT NULL AND resolved_at IS NOT NULL`;
     } else {
-      try {
-        tableList = await listPgTables(cloud);
-      } catch {
-        local.close();
-        await cloud.close();
-        return {
-          content: [
-            { type: "text", text: "Error: failed to list cloud tables." }
-          ],
-          isError: true
-        };
+      sql += ` AND (resolution IS NULL OR resolved_at IS NULL)`;
+    }
+  }
+  if (opts?.table) {
+    sql += ` AND table_name = ?`;
+    params.push(opts.table);
+  }
+  sql += ` ORDER BY created_at DESC`;
+  return db.all(sql, ...params);
+}
+function resolveConflict(db, conflictId, strategy) {
+  ensureConflictsTable(db);
+  const row = db.get(`SELECT * FROM _sync_conflicts WHERE id = ?`, conflictId);
+  if (!row)
+    return null;
+  db.run(`UPDATE _sync_conflicts SET resolution = ?, resolved_at = datetime('now') WHERE id = ?`, strategy, conflictId);
+  return db.get(`SELECT * FROM _sync_conflicts WHERE id = ?`, conflictId);
+}
+function getConflict(db, conflictId) {
+  ensureConflictsTable(db);
+  return db.get(`SELECT * FROM _sync_conflicts WHERE id = ?`, conflictId);
+}
+function purgeResolvedConflicts(db) {
+  ensureConflictsTable(db);
+  const result = db.run(`DELETE FROM _sync_conflicts WHERE resolution IS NOT NULL AND resolved_at IS NOT NULL`);
+  return result.changes;
+}
+function ensureSyncMetaTable(db) {
+  db.exec(SYNC_META_TABLE_SQL);
+}
+function getSyncMeta(db, table) {
+  ensureSyncMetaTable(db);
+  return db.get(`SELECT table_name, last_synced_at, last_synced_row_count, direction FROM _sync_meta WHERE table_name = ?`, table) ?? null;
+}
+function upsertSyncMeta(db, meta) {
+  ensureSyncMetaTable(db);
+  const existing = db.get(`SELECT table_name FROM _sync_meta WHERE table_name = ?`, meta.table_name);
+  if (existing) {
+    db.run(`UPDATE _sync_meta SET last_synced_at = ?, last_synced_row_count = ?, direction = ? WHERE table_name = ?`, meta.last_synced_at, meta.last_synced_row_count, meta.direction, meta.table_name);
+  } else {
+    db.run(`INSERT INTO _sync_meta (table_name, last_synced_at, last_synced_row_count, direction) VALUES (?, ?, ?, ?)`, meta.table_name, meta.last_synced_at, meta.last_synced_row_count, meta.direction);
+  }
+}
+function transferRows(source, target, table, rows, options) {
+  const { primaryKey = "id", conflictColumn = "updated_at" } = options;
+  let written = 0;
+  let skipped = 0;
+  const errors2 = [];
+  if (rows.length === 0)
+    return { written, skipped, errors: errors2 };
+  const columns = Object.keys(rows[0]);
+  const hasConflictCol = columns.includes(conflictColumn);
+  const hasPrimaryKey = columns.includes(primaryKey);
+  if (!hasPrimaryKey) {
+    errors2.push(`Table "${table}" has no "${primaryKey}" column -- skipping`);
+    return { written, skipped, errors: errors2 };
+  }
+  for (const row of rows) {
+    try {
+      const existing = target.get(`SELECT "${primaryKey}"${hasConflictCol ? `, "${conflictColumn}"` : ""} FROM "${table}" WHERE "${primaryKey}" = ?`, row[primaryKey]);
+      if (existing) {
+        if (hasConflictCol && existing[conflictColumn] && row[conflictColumn]) {
+          const existingTime = new Date(existing[conflictColumn]).getTime();
+          const incomingTime = new Date(row[conflictColumn]).getTime();
+          if (existingTime >= incomingTime) {
+            skipped++;
+            continue;
+          }
+        }
+        const setClauses = columns.filter((c) => c !== primaryKey).map((c) => `"${c}" = ?`).join(", ");
+        const values = columns.filter((c) => c !== primaryKey).map((c) => row[c]);
+        values.push(row[primaryKey]);
+        target.run(`UPDATE "${table}" SET ${setClauses} WHERE "${primaryKey}" = ?`, ...values);
+      } else {
+        const placeholders = columns.map(() => "?").join(", ");
+        const colList = columns.map((c) => `"${c}"`).join(", ");
+        const values = columns.map((c) => row[c]);
+        target.run(`INSERT INTO "${table}" (${colList}) VALUES (${placeholders})`, ...values);
       }
+      written++;
+    } catch (err) {
+      errors2.push(`Row ${row[primaryKey]}: ${err?.message ?? String(err)}`);
     }
-    const results = await syncPull(cloud, local, { tables: tableList });
-    local.close();
-    await cloud.close();
-    const total = results.reduce((s, r) => s + r.rowsWritten, 0);
-    return {
-      content: [{ type: "text", text: `Pulled ${total} rows across ${tableList.length} table(s).` }]
+  }
+  return { written, skipped, errors: errors2 };
+}
+function incrementalSyncPush(local, remote, tables, options = {}) {
+  const { conflictColumn = "updated_at", batchSize = 500 } = options;
+  const results = [];
+  ensureSyncMetaTable(local);
+  for (const table of tables) {
+    const stat = {
+      table,
+      total_rows: 0,
+      synced_rows: 0,
+      skipped_rows: 0,
+      errors: [],
+      first_sync: false
     };
-  });
-  server.tool(`${serviceName}_cloud_feedback`, "Send feedback for this service", {
-    message: exports_external2.string().describe("Feedback message"),
-    email: exports_external2.string().optional().describe("Contact email")
-  }, async ({ message, email }) => {
-    const db = createDatabase({ service: "cloud" });
-    const result = await sendFeedback({ service: serviceName, message, email }, db);
-    db.close();
-    return {
-      content: [
-        {
-          type: "text",
-          text: result.sent ? `Feedback sent (id: ${result.id})` : `Saved locally (id: ${result.id}): ${result.error}`
+    try {
+      const countResult = local.get(`SELECT COUNT(*) as cnt FROM "${table}"`);
+      stat.total_rows = countResult?.cnt ?? 0;
+      const meta = getSyncMeta(local, table);
+      let rows;
+      if (meta?.last_synced_at) {
+        try {
+          rows = local.all(`SELECT * FROM "${table}" WHERE "${conflictColumn}" > ?`, meta.last_synced_at);
+        } catch {
+          rows = local.all(`SELECT * FROM "${table}"`);
+          stat.first_sync = true;
         }
-      ]
+      } else {
+        rows = local.all(`SELECT * FROM "${table}"`);
+        stat.first_sync = true;
+      }
+      for (let offset = 0;offset < rows.length; offset += batchSize) {
+        const batch = rows.slice(offset, offset + batchSize);
+        const result = transferRows(local, remote, table, batch, options);
+        stat.synced_rows += result.written;
+        stat.skipped_rows += result.skipped;
+        stat.errors.push(...result.errors);
+      }
+      if (rows.length === 0) {
+        stat.skipped_rows = stat.total_rows;
+      }
+      const now = new Date().toISOString();
+      upsertSyncMeta(local, {
+        table_name: table,
+        last_synced_at: now,
+        last_synced_row_count: stat.synced_rows,
+        direction: "push"
+      });
+    } catch (err) {
+      stat.errors.push(`Table "${table}": ${err?.message ?? String(err)}`);
+    }
+    results.push(stat);
+  }
+  return results;
+}
+function incrementalSyncPull(remote, local, tables, options = {}) {
+  const { conflictColumn = "updated_at", batchSize = 500 } = options;
+  const results = [];
+  ensureSyncMetaTable(local);
+  for (const table of tables) {
+    const stat = {
+      table,
+      total_rows: 0,
+      synced_rows: 0,
+      skipped_rows: 0,
+      errors: [],
+      first_sync: false
     };
-  });
+    try {
+      const countResult = remote.get(`SELECT COUNT(*) as cnt FROM "${table}"`);
+      stat.total_rows = countResult?.cnt ?? 0;
+      const meta = getSyncMeta(local, table);
+      let rows;
+      if (meta?.last_synced_at) {
+        try {
+          rows = remote.all(`SELECT * FROM "${table}" WHERE "${conflictColumn}" > ?`, meta.last_synced_at);
+        } catch {
+          rows = remote.all(`SELECT * FROM "${table}"`);
+          stat.first_sync = true;
+        }
+      } else {
+        rows = remote.all(`SELECT * FROM "${table}"`);
+        stat.first_sync = true;
+      }
+      for (let offset = 0;offset < rows.length; offset += batchSize) {
+        const batch = rows.slice(offset, offset + batchSize);
+        const result = transferRows(remote, local, table, batch, options);
+        stat.synced_rows += result.written;
+        stat.skipped_rows += result.skipped;
+        stat.errors.push(...result.errors);
+      }
+      if (rows.length === 0) {
+        stat.skipped_rows = stat.total_rows;
+      }
+      const now = new Date().toISOString();
+      upsertSyncMeta(local, {
+        table_name: table,
+        last_synced_at: now,
+        last_synced_row_count: stat.synced_rows,
+        direction: "pull"
+      });
+    } catch (err) {
+      stat.errors.push(`Table "${table}": ${err?.message ?? String(err)}`);
+    }
+    results.push(stat);
+  }
+  return results;
+}
+function getSyncMetaAll(db) {
+  ensureSyncMetaTable(db);
+  return db.all(`SELECT table_name, last_synced_at, last_synced_row_count, direction FROM _sync_meta ORDER BY table_name`);
+}
+function getSyncMetaForTable(db, table) {
+  return getSyncMeta(db, table);
+}
+function resetSyncMeta(db, table) {
+  ensureSyncMetaTable(db);
+  db.run(`DELETE FROM _sync_meta WHERE table_name = ?`, table);
+}
+function resetAllSyncMeta(db) {
+  ensureSyncMetaTable(db);
+  db.run(`DELETE FROM _sync_meta`);
+}
+function getAutoSyncConfig() {
+  try {
+    if (!existsSync3(AUTO_SYNC_CONFIG_PATH)) {
+      return { ...DEFAULT_AUTO_SYNC_CONFIG };
+    }
+    const raw = JSON.parse(readFileSync2(AUTO_SYNC_CONFIG_PATH, "utf-8"));
+    return {
+      auto_sync_on_start: typeof raw.auto_sync_on_start === "boolean" ? raw.auto_sync_on_start : DEFAULT_AUTO_SYNC_CONFIG.auto_sync_on_start,
+      auto_sync_on_stop: typeof raw.auto_sync_on_stop === "boolean" ? raw.auto_sync_on_stop : DEFAULT_AUTO_SYNC_CONFIG.auto_sync_on_stop
+    };
+  } catch {
+    return { ...DEFAULT_AUTO_SYNC_CONFIG };
+  }
+}
+function executeAutoSync(event, local, remote, tables) {
+  const direction = event === "start" ? "pull" : "push";
+  const result = {
+    event,
+    direction,
+    success: false,
+    tables_synced: 0,
+    total_rows_synced: 0,
+    errors: []
+  };
+  try {
+    const stats = direction === "pull" ? incrementalSyncPull(remote, local, tables) : incrementalSyncPush(local, remote, tables);
+    for (const s of stats) {
+      if (s.errors.length === 0) {
+        result.tables_synced++;
+      }
+      result.total_rows_synced += s.synced_rows;
+      result.errors.push(...s.errors);
+    }
+    result.success = result.errors.length === 0;
+  } catch (err) {
+    result.errors.push(err?.message ?? String(err));
+  }
+  return result;
+}
+function installSignalHandlers() {
+  if (signalHandlersInstalled)
+    return;
+  signalHandlersInstalled = true;
+  const handleExit = () => {
+    for (const fn of cleanupHandlers) {
+      try {
+        fn();
+      } catch {}
+    }
+  };
+  process.on("SIGTERM", () => {
+    handleExit();
+    process.exit(0);
+  });
+  process.on("SIGINT", () => {
+    handleExit();
+    process.exit(0);
+  });
+  process.on("beforeExit", () => {
+    handleExit();
+  });
+}
+function setupAutoSync(serviceName, server, local, remote, tables) {
+  const config = getAutoSyncConfig();
+  const cloudConfig = getCloudConfig();
+  const isSyncEnabled = cloudConfig.mode === "hybrid" || cloudConfig.mode === "cloud";
+  const syncOnStart = () => {
+    if (!config.auto_sync_on_start || !isSyncEnabled)
+      return null;
+    return executeAutoSync("start", local, remote, tables);
+  };
+  const syncOnStop = () => {
+    if (!config.auto_sync_on_stop || !isSyncEnabled)
+      return null;
+    return executeAutoSync("stop", local, remote, tables);
+  };
+  if (server && typeof server.onconnect === "function") {
+    const origOnConnect = server.onconnect;
+    server.onconnect = (...args) => {
+      syncOnStart();
+      return origOnConnect.apply(server, args);
+    };
+  } else if (server && typeof server.on === "function") {
+    server.on("connect", () => {
+      syncOnStart();
+    });
+  }
+  if (server && typeof server.ondisconnect === "function") {
+    const origOnDisconnect = server.ondisconnect;
+    server.ondisconnect = (...args) => {
+      syncOnStop();
+      return origOnDisconnect.apply(server, args);
+    };
+  } else if (server && typeof server.on === "function") {
+    server.on("disconnect", () => {
+      syncOnStop();
+    });
+  }
+  installSignalHandlers();
+  cleanupHandlers.push(() => {
+    syncOnStop();
+  });
+  return { syncOnStart, syncOnStop, config };
+}
+function enableAutoSync(serviceName, mcpServer, local, remote, tables) {
+  setupAutoSync(serviceName, mcpServer, local, remote, tables);
+}
+function discoverSyncableServices() {
+  const hasnaDir = getHasnaDir();
+  const services = [];
+  try {
+    const entries = readdirSync2(hasnaDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory())
+        continue;
+      const dbPath = join4(hasnaDir, entry.name, `${entry.name}.db`);
+      if (existsSync4(dbPath)) {
+        services.push(entry.name);
+      }
+    }
+  } catch {}
+  return services;
+}
+async function runScheduledSync() {
+  const config = getCloudConfig();
+  if (config.mode === "local")
+    return [];
+  const services = discoverSyncableServices();
+  const results = [];
+  let remote = null;
+  for (const service of services) {
+    const result = {
+      service,
+      tables_synced: 0,
+      total_rows_synced: 0,
+      errors: []
+    };
+    try {
+      const dbPath = join4(getDataDir(service), `${service}.db`);
+      if (!existsSync4(dbPath)) {
+        continue;
+      }
+      const local = new SqliteAdapter(dbPath);
+      const tables = listSqliteTables(local).filter((t) => !t.startsWith("_") && !t.startsWith("sqlite_"));
+      if (tables.length === 0) {
+        local.close();
+        continue;
+      }
+      try {
+        const connStr = getConnectionString(service);
+        remote = new PgAdapterAsync(connStr);
+      } catch (err) {
+        result.errors.push(`Connection failed: ${err?.message ?? String(err)}`);
+        local.close();
+        results.push(result);
+        continue;
+      }
+      const stats = incrementalSyncPush(local, remote, tables);
+      for (const s of stats) {
+        if (s.errors.length === 0) {
+          result.tables_synced++;
+        }
+        result.total_rows_synced += s.synced_rows;
+        result.errors.push(...s.errors);
+      }
+      local.close();
+      await remote.close();
+      remote = null;
+    } catch (err) {
+      result.errors.push(err?.message ?? String(err));
+    }
+    results.push(result);
+  }
+  if (remote) {
+    try {
+      await remote.close();
+    } catch {}
+  }
+  return results;
+}
+function getWorkerPath() {
+  const dir = typeof import.meta.dir === "string" ? import.meta.dir : dirname(import.meta.url.replace("file://", ""));
+  const tsPath = join5(dir, "scheduled-sync.ts");
+  const jsPath = join5(dir, "scheduled-sync.js");
+  try {
+    const { existsSync: existsSync5 } = __require("fs");
+    if (existsSync5(tsPath))
+      return tsPath;
+  } catch {}
+  return jsPath;
+}
+function parseInterval(input) {
+  const trimmed = input.trim().toLowerCase();
+  const hourMatch = trimmed.match(/^(\d+)\s*h$/);
+  if (hourMatch) {
+    const hours = parseInt(hourMatch[1], 10);
+    if (hours <= 0) {
+      throw new Error(`Invalid interval "${input}". Value must be greater than 0.`);
+    }
+    return hours * 60;
+  }
+  const minMatch = trimmed.match(/^(\d+)\s*m$/);
+  if (minMatch) {
+    const mins = parseInt(minMatch[1], 10);
+    if (mins <= 0) {
+      throw new Error(`Invalid interval "${input}". Value must be greater than 0.`);
+    }
+    return mins;
+  }
+  const plain = parseInt(trimmed, 10);
+  if (!isNaN(plain) && plain > 0) {
+    return plain;
+  }
+  throw new Error(`Invalid interval "${input}". Use formats like: 5m, 10m, 1h, or a plain number of minutes.`);
+}
+function minutesToCron(minutes) {
+  if (minutes <= 0) {
+    throw new Error("Interval must be greater than 0 minutes.");
+  }
+  if (minutes < 60) {
+    return `*/${minutes} * * * *`;
+  }
+  const hours = Math.floor(minutes / 60);
+  const remainderMins = minutes % 60;
+  if (remainderMins === 0 && hours <= 24) {
+    return `0 */${hours} * * *`;
+  }
+  return `*/${minutes} * * * *`;
+}
+async function registerSyncSchedule(intervalMinutes) {
+  if (intervalMinutes <= 0) {
+    throw new Error("Interval must be a positive number of minutes.");
+  }
+  const cronExpr = minutesToCron(intervalMinutes);
+  const workerPath = getWorkerPath();
+  await Bun.cron(workerPath, cronExpr, CRON_TITLE);
+  const config = getCloudConfig();
+  config.sync.schedule_minutes = intervalMinutes;
+  saveCloudConfig(config);
+}
+async function removeSyncSchedule() {
+  await Bun.cron.remove(CRON_TITLE);
+  const config = getCloudConfig();
+  config.sync.schedule_minutes = 0;
+  saveCloudConfig(config);
+}
+function getSyncScheduleStatus() {
+  const config = getCloudConfig();
+  const minutes = config.sync.schedule_minutes;
+  const registered = minutes > 0;
+  return {
+    registered,
+    schedule_minutes: minutes,
+    cron_expression: registered ? minutesToCron(minutes) : null
+  };
+}
+function registerCloudTools(server, serviceName) {
+  server.tool(`${serviceName}_cloud_status`, "Show cloud configuration and connection health", {}, async () => {
+    const config = getCloudConfig();
+    const lines = [
+      `Mode: ${config.mode}`,
+      `Service: ${serviceName}`,
+      `RDS Host: ${config.rds.host || "(not configured)"}`
+    ];
+    if (config.rds.host && config.rds.username) {
+      try {
+        const pg2 = new PgAdapterAsync(getConnectionString("postgres"));
+        await pg2.get("SELECT 1 as ok");
+        lines.push("PostgreSQL: connected");
+        await pg2.close();
+      } catch (err) {
+        lines.push(`PostgreSQL: failed \u2014 ${err?.message}`);
+      }
+    }
+    return { content: [{ type: "text", text: lines.join(`
+`) }] };
+  });
+  server.tool(`${serviceName}_cloud_push`, "Push local data to cloud PostgreSQL", {
+    tables: exports_external2.string().optional().describe("Comma-separated table names (default: all)")
+  }, async ({ tables: tablesStr }) => {
+    const config = getCloudConfig();
+    if (config.mode === "local") {
+      return {
+        content: [
+          { type: "text", text: "Error: cloud mode not configured." }
+        ],
+        isError: true
+      };
+    }
+    const local = new SqliteAdapter(getDbPath(serviceName));
+    const cloud = new PgAdapterAsync(getConnectionString(serviceName));
+    const tableList = tablesStr ? tablesStr.split(",").map((t) => t.trim()) : listSqliteTables(local);
+    const results = await syncPush(local, cloud, { tables: tableList });
+    local.close();
+    await cloud.close();
+    const total = results.reduce((s, r) => s + r.rowsWritten, 0);
+    return {
+      content: [{ type: "text", text: `Pushed ${total} rows across ${tableList.length} table(s).` }]
+    };
+  });
+  server.tool(`${serviceName}_cloud_pull`, "Pull cloud PostgreSQL data to local", {
+    tables: exports_external2.string().optional().describe("Comma-separated table names (default: all)")
+  }, async ({ tables: tablesStr }) => {
+    const config = getCloudConfig();
+    if (config.mode === "local") {
+      return {
+        content: [
+          { type: "text", text: "Error: cloud mode not configured." }
+        ],
+        isError: true
+      };
+    }
+    const local = new SqliteAdapter(getDbPath(serviceName));
+    const cloud = new PgAdapterAsync(getConnectionString(serviceName));
+    let tableList;
+    if (tablesStr) {
+      tableList = tablesStr.split(",").map((t) => t.trim());
+    } else {
+      try {
+        tableList = await listPgTables(cloud);
+      } catch {
+        local.close();
+        await cloud.close();
+        return {
+          content: [
+            { type: "text", text: "Error: failed to list cloud tables." }
+          ],
+          isError: true
+        };
+      }
+    }
+    const results = await syncPull(cloud, local, { tables: tableList });
+    local.close();
+    await cloud.close();
+    const total = results.reduce((s, r) => s + r.rowsWritten, 0);
+    return {
+      content: [{ type: "text", text: `Pulled ${total} rows across ${tableList.length} table(s).` }]
+    };
+  });
+  server.tool(`${serviceName}_cloud_feedback`, "Send feedback for this service", {
+    message: exports_external2.string().describe("Feedback message"),
+    email: exports_external2.string().optional().describe("Contact email")
+  }, async ({ message, email }) => {
+    const db = createDatabase({ service: "cloud" });
+    const result = await sendFeedback({ service: serviceName, message, email }, db);
+    db.close();
+    return {
+      content: [
+        {
+          type: "text",
+          text: result.sent ? `Feedback sent (id: ${result.id})` : `Saved locally (id: ${result.id}): ${result.error}`
+        }
+      ]
+    };
+  });
+}
+function registerCloudCommands(program, serviceName) {
+  const cloudCmd = program.command("cloud").description("Cloud sync and feedback commands");
+  cloudCmd.command("status").description("Show cloud config and connection health").action(async () => {
+    const config = getCloudConfig();
+    console.log("Mode:", config.mode);
+    console.log("RDS Host:", config.rds.host || "(not configured)");
+    console.log("Service:", serviceName);
+    if (config.rds.host && config.rds.username) {
+      try {
+        const connStr = getConnectionString("postgres");
+        const pg2 = new PgAdapterAsync(connStr);
+        await pg2.get("SELECT 1 as ok");
+        console.log("PostgreSQL: connected");
+        await pg2.close();
+      } catch (err) {
+        console.log("PostgreSQL: connection failed \u2014", err?.message);
+      }
+    }
+  });
+  cloudCmd.command("push").description("Push local data to cloud").option("--tables <tables>", "Comma-separated table names").action(async (opts) => {
+    const config = getCloudConfig();
+    if (config.mode === "local") {
+      console.error("Error: mode is 'local'. Run `cloud setup` first.");
+      process.exit(1);
+    }
+    const local = new SqliteAdapter(getDbPath(serviceName));
+    const cloud = new PgAdapterAsync(getConnectionString(serviceName));
+    const tables = opts.tables ? opts.tables.split(",").map((t) => t.trim()) : listSqliteTables(local);
+    const results = await syncPush(local, cloud, {
+      tables,
+      onProgress: (p) => {
+        if (p.phase === "done") {
+          console.log(`  ${p.table}: ${p.rowsWritten} rows pushed`);
+        }
+      }
+    });
+    local.close();
+    await cloud.close();
+    const total = results.reduce((s, r) => s + r.rowsWritten, 0);
+    console.log(`Done. ${total} rows pushed.`);
+  });
+  cloudCmd.command("pull").description("Pull cloud data to local").option("--tables <tables>", "Comma-separated table names").action(async (opts) => {
+    const config = getCloudConfig();
+    if (config.mode === "local") {
+      console.error("Error: mode is 'local'. Run `cloud setup` first.");
+      process.exit(1);
+    }
+    const local = new SqliteAdapter(getDbPath(serviceName));
+    const cloud = new PgAdapterAsync(getConnectionString(serviceName));
+    let tables;
+    if (opts.tables) {
+      tables = opts.tables.split(",").map((t) => t.trim());
+    } else {
+      tables = await listPgTables(cloud);
+    }
+    const results = await syncPull(cloud, local, {
+      tables,
+      onProgress: (p) => {
+        if (p.phase === "done") {
+          console.log(`  ${p.table}: ${p.rowsWritten} rows pulled`);
+        }
+      }
+    });
+    local.close();
+    await cloud.close();
+    const total = results.reduce((s, r) => s + r.rowsWritten, 0);
+    console.log(`Done. ${total} rows pulled.`);
+  });
+  cloudCmd.command("feedback").description("Send feedback").requiredOption("--message <msg>", "Feedback message").option("--email <email>", "Contact email").action(async (opts) => {
+    const db = createDatabase({ service: "cloud" });
+    const result = await sendFeedback({ service: serviceName, message: opts.message, email: opts.email }, db);
+    db.close();
+    if (result.sent) {
+      console.log(`Feedback sent (id: ${result.id})`);
+    } else {
+      console.log(`Feedback saved locally (id: ${result.id}): ${result.error}`);
+    }
+  });
 }
 var __create, __getProtoOf, __defProp2, __getOwnPropNames2, __hasOwnProp2, __toESMCache_node, __toESMCache_esm, __toESM = (mod, isNodeMode, target) => {
   var canCache = mod != null && typeof mod === "object";
@@ -1785,7 +2600,13 @@ CREATE TABLE IF NOT EXISTS feedback (
   email TEXT DEFAULT '',
   machine_id TEXT DEFAULT '',
   created_at TEXT DEFAULT (datetime('now'))
-)`, AUTO_SYNC_CONFIG_PATH;
+)`, SYNC_META_TABLE_SQL = `
+CREATE TABLE IF NOT EXISTS _sync_meta (
+  table_name TEXT PRIMARY KEY,
+  last_synced_at TEXT,
+  last_synced_row_count INTEGER DEFAULT 0,
+  direction TEXT DEFAULT 'push'
+)`, AUTO_SYNC_CONFIG_PATH, DEFAULT_AUTO_SYNC_CONFIG, cleanupHandlers, signalHandlersInstalled = false, CRON_TITLE = "hasna-cloud-sync";
 var init_dist = __esm(() => {
   __create = Object.create;
   __getProtoOf = Object.getPrototypeOf;
@@ -9724,11 +10545,19 @@ See https://www.postgresql.org/docs/current/libpq-ssl.html for libpq SSL mode de
     }).default({}),
     mode: exports_external2.enum(["local", "cloud", "hybrid"]).default("local"),
     auto_sync_interval_minutes: exports_external2.number().default(0),
-    feedback_endpoint: exports_external2.string().default("https://feedback.hasna.com/api/v1/feedback")
+    feedback_endpoint: exports_external2.string().default("https://feedback.hasna.com/api/v1/feedback"),
+    sync: exports_external2.object({
+      schedule_minutes: exports_external2.number().default(0)
+    }).default({})
   });
   CONFIG_DIR = join2(homedir2(), ".hasna", "cloud");
   CONFIG_PATH = join2(CONFIG_DIR, "config.json");
   AUTO_SYNC_CONFIG_PATH = join3(homedir3(), ".hasna", "cloud", "config.json");
+  DEFAULT_AUTO_SYNC_CONFIG = {
+    auto_sync_on_start: true,
+    auto_sync_on_stop: true
+  };
+  cleanupHandlers = [];
 });
 
 // src/types/index.ts
@@ -9851,18 +10680,18 @@ __export(exports_database, {
   LOCK_EXPIRY_MINUTES: () => LOCK_EXPIRY_MINUTES
 });
 import { Database as Database2 } from "bun:sqlite";
-import { existsSync as existsSync3, mkdirSync as mkdirSync3 } from "fs";
-import { dirname, join as join4, resolve } from "path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3 } from "fs";
+import { dirname as dirname2, join as join6, resolve } from "path";
 function isInMemoryDb(path) {
   return path === ":memory:" || path.startsWith("file::memory:");
 }
 function findNearestTodosDb(startDir) {
   let dir = resolve(startDir);
   while (true) {
-    const candidate = join4(dir, ".todos", "todos.db");
-    if (existsSync3(candidate))
+    const candidate = join6(dir, ".todos", "todos.db");
+    if (existsSync5(candidate))
       return candidate;
-    const parent = dirname(dir);
+    const parent = dirname2(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -9872,9 +10701,9 @@ function findNearestTodosDb(startDir) {
 function findGitRoot(startDir) {
   let dir = resolve(startDir);
   while (true) {
-    if (existsSync3(join4(dir, ".git")))
+    if (existsSync5(join6(dir, ".git")))
       return dir;
-    const parent = dirname(dir);
+    const parent = dirname2(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -9895,13 +10724,13 @@ function getDbPath2() {
   if (process.env["TODOS_DB_SCOPE"] === "project") {
     const gitRoot = findGitRoot(cwd);
     if (gitRoot) {
-      return join4(gitRoot, ".todos", "todos.db");
+      return join6(gitRoot, ".todos", "todos.db");
     }
   }
   const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
-  const newPath = join4(home, ".hasna", "todos", "todos.db");
-  const legacyPath = join4(home, ".todos", "todos.db");
-  if (!existsSync3(newPath) && existsSync3(legacyPath)) {
+  const newPath = join6(home, ".hasna", "todos", "todos.db");
+  const legacyPath = join6(home, ".todos", "todos.db");
+  if (!existsSync5(newPath) && existsSync5(legacyPath)) {
     return legacyPath;
   }
   return newPath;
@@ -9909,8 +10738,8 @@ function getDbPath2() {
 function ensureDir(filePath) {
   if (isInMemoryDb(filePath))
     return;
-  const dir = dirname(resolve(filePath));
-  if (!existsSync3(dir)) {
+  const dir = dirname2(resolve(filePath));
+  if (!existsSync5(dir)) {
     mkdirSync3(dir, { recursive: true });
   }
 }
@@ -10877,20 +11706,20 @@ var init_projects = __esm(() => {
 });
 
 // src/lib/sync-utils.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync2, readdirSync as readdirSync2, statSync, writeFileSync as writeFileSync2 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync5, readFileSync as readFileSync3, readdirSync as readdirSync3, statSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join8 } from "path";
 function ensureDir2(dir) {
-  if (!existsSync5(dir))
+  if (!existsSync7(dir))
     mkdirSync5(dir, { recursive: true });
 }
 function listJsonFiles(dir) {
-  if (!existsSync5(dir))
+  if (!existsSync7(dir))
     return [];
-  return readdirSync2(dir).filter((f) => f.endsWith(".json"));
+  return readdirSync3(dir).filter((f) => f.endsWith(".json"));
 }
 function readJsonFile(path) {
   try {
-    return JSON.parse(readFileSync2(path, "utf-8"));
+    return JSON.parse(readFileSync3(path, "utf-8"));
   } catch {
     return null;
   }
@@ -10900,14 +11729,14 @@ function writeJsonFile(path, data) {
 `);
 }
 function readHighWaterMark(dir) {
-  const path = join6(dir, ".highwatermark");
-  if (!existsSync5(path))
+  const path = join8(dir, ".highwatermark");
+  if (!existsSync7(path))
     return 1;
-  const val = parseInt(readFileSync2(path, "utf-8").trim(), 10);
+  const val = parseInt(readFileSync3(path, "utf-8").trim(), 10);
   return isNaN(val) ? 1 : val;
 }
 function writeHighWaterMark(dir, value) {
-  writeFileSync2(join6(dir, ".highwatermark"), String(value));
+  writeFileSync2(join8(dir, ".highwatermark"), String(value));
 }
 function getFileMtimeMs(path) {
   try {
@@ -10933,18 +11762,18 @@ var init_sync_utils = __esm(() => {
 });
 
 // src/lib/config.ts
-import { existsSync as existsSync6 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync8 } from "fs";
+import { join as join9 } from "path";
 function getTodosGlobalDir() {
   const home = process.env["HOME"] || HOME;
-  const newDir = join7(home, ".hasna", "todos");
-  const legacyDir = join7(home, ".todos");
-  if (!existsSync6(newDir) && existsSync6(legacyDir))
+  const newDir = join9(home, ".hasna", "todos");
+  const legacyDir = join9(home, ".todos");
+  if (!existsSync8(newDir) && existsSync8(legacyDir))
     return legacyDir;
   return newDir;
 }
-function getConfigPath() {
-  return join7(getTodosGlobalDir(), "config.json");
+function getConfigPath2() {
+  return join9(getTodosGlobalDir(), "config.json");
 }
 function normalizeAgent(agent) {
   return agent.trim().toLowerCase();
@@ -10952,11 +11781,11 @@ function normalizeAgent(agent) {
 function loadConfig() {
   if (cached)
     return cached;
-  if (!existsSync6(getConfigPath())) {
+  if (!existsSync8(getConfigPath2())) {
     cached = {};
     return cached;
   }
-  const config = readJsonFile(getConfigPath()) || {};
+  const config = readJsonFile(getConfigPath2()) || {};
   if (typeof config.sync_agents === "string") {
     config.sync_agents = config.sync_agents.split(",").map((a) => a.trim()).filter(Boolean);
   }
@@ -11268,6 +12097,7 @@ var init_webhooks = __esm(() => {
 // src/db/templates.ts
 var exports_templates = {};
 __export(exports_templates, {
+  updateTemplate: () => updateTemplate,
   taskFromTemplate: () => taskFromTemplate,
   listTemplates: () => listTemplates,
   getTemplate: () => getTemplate,
@@ -11282,6 +12112,9 @@ function rowToTemplate(row) {
     priority: row.priority || "medium"
   };
 }
+function resolveTemplateId(id, d) {
+  return resolvePartialId(d, "task_templates", id);
+}
 function createTemplate(input, db) {
   const d = db || getDatabase();
   const id = uuid();
@@ -11302,7 +12135,10 @@ function createTemplate(input, db) {
 }
 function getTemplate(id, db) {
   const d = db || getDatabase();
-  const row = d.query("SELECT * FROM task_templates WHERE id = ?").get(id);
+  const resolved = resolveTemplateId(id, d);
+  if (!resolved)
+    return null;
+  const row = d.query("SELECT * FROM task_templates WHERE id = ?").get(resolved);
   return row ? rowToTemplate(row) : null;
 }
 function listTemplates(db) {
@@ -11311,15 +12147,63 @@ function listTemplates(db) {
 }
 function deleteTemplate(id, db) {
   const d = db || getDatabase();
-  return d.run("DELETE FROM task_templates WHERE id = ?", [id]).changes > 0;
+  const resolved = resolveTemplateId(id, d);
+  if (!resolved)
+    return false;
+  return d.run("DELETE FROM task_templates WHERE id = ?", [resolved]).changes > 0;
 }
-function taskFromTemplate(templateId, overrides = {}, db) {
-  const t = getTemplate(templateId, db);
-  if (!t)
-    throw new Error(`Template not found: ${templateId}`);
-  return {
-    title: overrides.title || t.title_pattern,
-    description: overrides.description ?? t.description ?? undefined,
+function updateTemplate(id, updates, db) {
+  const d = db || getDatabase();
+  const resolved = resolveTemplateId(id, d);
+  if (!resolved)
+    return null;
+  const sets = [];
+  const values = [];
+  if (updates.name !== undefined) {
+    sets.push("name = ?");
+    values.push(updates.name);
+  }
+  if (updates.title_pattern !== undefined) {
+    sets.push("title_pattern = ?");
+    values.push(updates.title_pattern);
+  }
+  if (updates.description !== undefined) {
+    sets.push("description = ?");
+    values.push(updates.description);
+  }
+  if (updates.priority !== undefined) {
+    sets.push("priority = ?");
+    values.push(updates.priority);
+  }
+  if (updates.tags !== undefined) {
+    sets.push("tags = ?");
+    values.push(JSON.stringify(updates.tags));
+  }
+  if (updates.project_id !== undefined) {
+    sets.push("project_id = ?");
+    values.push(updates.project_id);
+  }
+  if (updates.plan_id !== undefined) {
+    sets.push("plan_id = ?");
+    values.push(updates.plan_id);
+  }
+  if (updates.metadata !== undefined) {
+    sets.push("metadata = ?");
+    values.push(JSON.stringify(updates.metadata));
+  }
+  if (sets.length === 0)
+    return getTemplate(resolved, d);
+  values.push(resolved);
+  d.run(`UPDATE task_templates SET ${sets.join(", ")} WHERE id = ?`, values);
+  return getTemplate(resolved, d);
+}
+function taskFromTemplate(templateId, overrides = {}, db) {
+  const t = getTemplate(templateId, db);
+  if (!t)
+    throw new Error(`Template not found: ${templateId}`);
+  return {
+    title: overrides.title || t.title_pattern,
+    description: overrides.description ?? t.description ?? undefined,
     priority: overrides.priority ?? t.priority,
     tags: overrides.tags ?? t.tags,
     project_id: overrides.project_id ?? t.project_id ?? undefined,
@@ -14358,210 +15242,795 @@ var init_agent_metrics = __esm(() => {
   init_database();
 });
 
-// src/lib/extract.ts
-var exports_extract = {};
-__export(exports_extract, {
-  tagToPriority: () => tagToPriority,
-  extractTodos: () => extractTodos,
-  extractFromSource: () => extractFromSource,
-  EXTRACT_TAGS: () => EXTRACT_TAGS
+// src/lib/extract.ts
+var exports_extract = {};
+__export(exports_extract, {
+  tagToPriority: () => tagToPriority,
+  extractTodos: () => extractTodos,
+  extractFromSource: () => extractFromSource,
+  EXTRACT_TAGS: () => EXTRACT_TAGS
+});
+import { readFileSync as readFileSync6, statSync as statSync2 } from "fs";
+import { relative as relative2, resolve as resolve2, join as join12 } from "path";
+function tagToPriority(tag) {
+  switch (tag) {
+    case "BUG":
+    case "FIXME":
+      return "high";
+    case "HACK":
+    case "XXX":
+      return "medium";
+    case "TODO":
+      return "medium";
+    case "NOTE":
+      return "low";
+  }
+}
+function buildTagRegex(tags) {
+  const tagPattern = tags.join("|");
+  return new RegExp(`(?:^|\\s)(?:\\/\\/|\\/\\*|#|\\*|--|;;|%|<!--|\\{-)\\s*(?:@?)(${tagPattern})\\s*[:(]?\\s*(.*)$`, "i");
+}
+function extractFromSource(source, filePath, tags = [...EXTRACT_TAGS]) {
+  const regex = buildTagRegex(tags);
+  const results = [];
+  const lines = source.split(`
+`);
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    const match = line.match(regex);
+    if (match) {
+      const tag = match[1].toUpperCase();
+      let message = match[2].trim();
+      message = message.replace(/\s*\*\/\s*$/, "").replace(/\s*-->\s*$/, "").replace(/\s*-\}\s*$/, "").trim();
+      if (message) {
+        results.push({
+          tag,
+          message,
+          file: filePath,
+          line: i + 1,
+          raw: line
+        });
+      }
+    }
+  }
+  return results;
+}
+function collectFiles(basePath, extensions) {
+  const stat = statSync2(basePath);
+  if (stat.isFile()) {
+    return [basePath];
+  }
+  const glob = new Bun.Glob("**/*");
+  const files = [];
+  for (const entry of glob.scanSync({ cwd: basePath, onlyFiles: true, dot: false })) {
+    const parts = entry.split("/");
+    if (parts.some((p) => SKIP_DIRS.has(p)))
+      continue;
+    const dotIdx = entry.lastIndexOf(".");
+    if (dotIdx === -1)
+      continue;
+    const ext = entry.slice(dotIdx);
+    if (!extensions.has(ext))
+      continue;
+    files.push(entry);
+  }
+  return files.sort();
+}
+function extractTodos(options, db) {
+  const basePath = resolve2(options.path);
+  const tags = options.patterns || [...EXTRACT_TAGS];
+  const extensions = options.extensions ? new Set(options.extensions.map((e) => e.startsWith(".") ? e : `.${e}`)) : DEFAULT_EXTENSIONS;
+  const files = collectFiles(basePath, extensions);
+  const allComments = [];
+  for (const file of files) {
+    const fullPath = statSync2(basePath).isFile() ? basePath : join12(basePath, file);
+    try {
+      const source = readFileSync6(fullPath, "utf-8");
+      const relPath = statSync2(basePath).isFile() ? relative2(resolve2(basePath, ".."), fullPath) : file;
+      const comments = extractFromSource(source, relPath, tags);
+      allComments.push(...comments);
+    } catch {}
+  }
+  if (options.dry_run) {
+    return { comments: allComments, tasks: [], skipped: 0 };
+  }
+  const tasks = [];
+  let skipped = 0;
+  const existingTasks = options.project_id ? listTasks({ project_id: options.project_id, tags: ["extracted"] }, db) : listTasks({ tags: ["extracted"] }, db);
+  const existingKeys = new Set;
+  for (const t of existingTasks) {
+    const meta = t.metadata;
+    if (meta?.["source_file"] && meta?.["source_line"]) {
+      existingKeys.add(`${meta["source_file"]}:${meta["source_line"]}`);
+    }
+  }
+  for (const comment of allComments) {
+    const dedupKey = `${comment.file}:${comment.line}`;
+    if (existingKeys.has(dedupKey)) {
+      skipped++;
+      continue;
+    }
+    const taskTags = ["extracted", comment.tag.toLowerCase(), ...options.tags || []];
+    const task = createTask({
+      title: `[${comment.tag}] ${comment.message}`,
+      description: `Extracted from code comment in \`${comment.file}\` at line ${comment.line}:
+\`\`\`
+${comment.raw.trim()}
+\`\`\``,
+      priority: tagToPriority(comment.tag),
+      project_id: options.project_id,
+      task_list_id: options.task_list_id,
+      assigned_to: options.assigned_to,
+      agent_id: options.agent_id,
+      tags: taskTags,
+      metadata: {
+        source: "code_comment",
+        comment_type: comment.tag,
+        source_file: comment.file,
+        source_line: comment.line
+      }
+    }, db);
+    addTaskFile({
+      task_id: task.id,
+      path: comment.file,
+      note: `Line ${comment.line}: ${comment.tag} comment`
+    }, db);
+    tasks.push(task);
+    existingKeys.add(dedupKey);
+  }
+  return { comments: allComments, tasks, skipped };
+}
+var EXTRACT_TAGS, DEFAULT_EXTENSIONS, SKIP_DIRS;
+var init_extract = __esm(() => {
+  init_tasks();
+  init_task_files();
+  EXTRACT_TAGS = ["TODO", "FIXME", "HACK", "XXX", "BUG", "NOTE"];
+  DEFAULT_EXTENSIONS = new Set([
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".py",
+    ".rb",
+    ".go",
+    ".rs",
+    ".c",
+    ".cpp",
+    ".h",
+    ".hpp",
+    ".java",
+    ".kt",
+    ".swift",
+    ".cs",
+    ".php",
+    ".sh",
+    ".bash",
+    ".zsh",
+    ".lua",
+    ".sql",
+    ".r",
+    ".R",
+    ".yaml",
+    ".yml",
+    ".toml",
+    ".css",
+    ".scss",
+    ".less",
+    ".vue",
+    ".svelte",
+    ".ex",
+    ".exs",
+    ".erl",
+    ".hs",
+    ".ml",
+    ".mli",
+    ".clj",
+    ".cljs"
+  ]);
+  SKIP_DIRS = new Set([
+    "node_modules",
+    ".git",
+    "dist",
+    "build",
+    "out",
+    ".next",
+    ".turbo",
+    "coverage",
+    "__pycache__",
+    ".venv",
+    "venv",
+    "vendor",
+    "target",
+    ".cache",
+    ".parcel-cache"
+  ]);
+});
+
+// src/db/pg-migrations.ts
+var PG_MIGRATIONS;
+var init_pg_migrations = __esm(() => {
+  PG_MIGRATIONS = [
+    `
+  CREATE TABLE IF NOT EXISTS projects (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    path TEXT UNIQUE NOT NULL,
+    description TEXT,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+
+  CREATE TABLE IF NOT EXISTS tasks (
+    id TEXT PRIMARY KEY,
+    project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+    parent_id TEXT REFERENCES tasks(id) ON DELETE CASCADE,
+    title TEXT NOT NULL,
+    description TEXT,
+    status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending', 'in_progress', 'completed', 'failed', 'cancelled')),
+    priority TEXT NOT NULL DEFAULT 'medium' CHECK(priority IN ('low', 'medium', 'high', 'critical')),
+    agent_id TEXT,
+    assigned_to TEXT,
+    session_id TEXT,
+    working_dir TEXT,
+    tags TEXT DEFAULT '[]',
+    metadata TEXT DEFAULT '{}',
+    version INTEGER NOT NULL DEFAULT 1,
+    locked_by TEXT,
+    locked_at TEXT,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    completed_at TEXT
+  );
+
+  CREATE TABLE IF NOT EXISTS task_dependencies (
+    task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    depends_on TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    PRIMARY KEY (task_id, depends_on),
+    CHECK (task_id != depends_on)
+  );
+
+  CREATE TABLE IF NOT EXISTS task_comments (
+    id TEXT PRIMARY KEY,
+    task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    agent_id TEXT,
+    session_id TEXT,
+    content TEXT NOT NULL,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+
+  CREATE TABLE IF NOT EXISTS sessions (
+    id TEXT PRIMARY KEY,
+    agent_id TEXT,
+    project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+    working_dir TEXT,
+    started_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    last_activity TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    metadata TEXT DEFAULT '{}'
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_tasks_project ON tasks(project_id);
+  CREATE INDEX IF NOT EXISTS idx_tasks_parent ON tasks(parent_id);
+  CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+  CREATE INDEX IF NOT EXISTS idx_tasks_priority ON tasks(priority);
+  CREATE INDEX IF NOT EXISTS idx_tasks_assigned ON tasks(assigned_to);
+  CREATE INDEX IF NOT EXISTS idx_tasks_agent ON tasks(agent_id);
+  CREATE INDEX IF NOT EXISTS idx_tasks_session ON tasks(session_id);
+  CREATE INDEX IF NOT EXISTS idx_comments_task ON task_comments(task_id);
+  CREATE INDEX IF NOT EXISTS idx_sessions_agent ON sessions(agent_id);
+  CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_id);
+
+  CREATE TABLE IF NOT EXISTS _migrations (
+    id INTEGER PRIMARY KEY,
+    applied_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+
+  INSERT INTO _migrations (id) VALUES (1) ON CONFLICT DO NOTHING;
+  `,
+    `
+  ALTER TABLE projects ADD COLUMN IF NOT EXISTS task_list_id TEXT;
+  INSERT INTO _migrations (id) VALUES (2) ON CONFLICT DO NOTHING;
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS task_tags (
+    task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    tag TEXT NOT NULL,
+    PRIMARY KEY (task_id, tag)
+  );
+  CREATE INDEX IF NOT EXISTS idx_task_tags_tag ON task_tags(tag);
+  CREATE INDEX IF NOT EXISTS idx_task_tags_task ON task_tags(task_id);
+
+  INSERT INTO _migrations (id) VALUES (3) ON CONFLICT DO NOTHING;
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS plans (
+    id TEXT PRIMARY KEY,
+    project_id TEXT REFERENCES projects(id) ON DELETE CASCADE,
+    name TEXT NOT NULL,
+    description TEXT,
+    status TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('active', 'completed', 'archived')),
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+  CREATE INDEX IF NOT EXISTS idx_plans_project ON plans(project_id);
+  CREATE INDEX IF NOT EXISTS idx_plans_status ON plans(status);
+  ALTER TABLE tasks ADD COLUMN IF NOT EXISTS plan_id TEXT REFERENCES plans(id) ON DELETE SET NULL;
+  CREATE INDEX IF NOT EXISTS idx_tasks_plan ON tasks(plan_id);
+  INSERT INTO _migrations (id) VALUES (4) ON CONFLICT DO NOTHING;
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS agents (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL UNIQUE,
+    description TEXT,
+    metadata TEXT DEFAULT '{}',
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    last_seen_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+  CREATE INDEX IF NOT EXISTS idx_agents_name ON agents(name);
+
+  CREATE TABLE IF NOT EXISTS task_lists (
+    id TEXT PRIMARY KEY,
+    project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+    slug TEXT NOT NULL,
+    name TEXT NOT NULL,
+    description TEXT,
+    metadata TEXT DEFAULT '{}',
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    UNIQUE(project_id, slug)
+  );
+  CREATE INDEX IF NOT EXISTS idx_task_lists_project ON task_lists(project_id);
+  CREATE INDEX IF NOT EXISTS idx_task_lists_slug ON task_lists(slug);
+
+  ALTER TABLE tasks ADD COLUMN IF NOT EXISTS task_list_id TEXT REFERENCES task_lists(id) ON DELETE SET NULL;
+  CREATE INDEX IF NOT EXISTS idx_tasks_task_list ON tasks(task_list_id);
+
+  INSERT INTO _migrations (id) VALUES (5) ON CONFLICT DO NOTHING;
+  `,
+    `
+  ALTER TABLE projects ADD COLUMN IF NOT EXISTS task_prefix TEXT;
+  ALTER TABLE projects ADD COLUMN IF NOT EXISTS task_counter INTEGER NOT NULL DEFAULT 0;
+
+  ALTER TABLE tasks ADD COLUMN IF NOT EXISTS short_id TEXT;
+  CREATE UNIQUE INDEX IF NOT EXISTS idx_tasks_short_id ON tasks(short_id) WHERE short_id IS NOT NULL;
+
+  INSERT INTO _migrations (id) VALUES (6) ON CONFLICT DO NOTHING;
+  `,
+    `
+  ALTER TABLE tasks ADD COLUMN IF NOT EXISTS due_at TEXT;
+  CREATE INDEX IF NOT EXISTS idx_tasks_due_at ON tasks(due_at);
+  INSERT INTO _migrations (id) VALUES (7) ON CONFLICT DO NOTHING;
+  `,
+    `
+  ALTER TABLE agents ADD COLUMN IF NOT EXISTS role TEXT DEFAULT 'agent';
+  INSERT INTO _migrations (id) VALUES (8) ON CONFLICT DO NOTHING;
+  `,
+    `
+  ALTER TABLE plans ADD COLUMN IF NOT EXISTS task_list_id TEXT REFERENCES task_lists(id) ON DELETE SET NULL;
+  ALTER TABLE plans ADD COLUMN IF NOT EXISTS agent_id TEXT;
+  CREATE INDEX IF NOT EXISTS idx_plans_task_list ON plans(task_list_id);
+  CREATE INDEX IF NOT EXISTS idx_plans_agent ON plans(agent_id);
+  INSERT INTO _migrations (id) VALUES (9) ON CONFLICT DO NOTHING;
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS task_history (
+    id TEXT PRIMARY KEY,
+    task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    action TEXT NOT NULL,
+    field TEXT,
+    old_value TEXT,
+    new_value TEXT,
+    agent_id TEXT,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+  CREATE INDEX IF NOT EXISTS idx_task_history_task ON task_history(task_id);
+  CREATE INDEX IF NOT EXISTS idx_task_history_agent ON task_history(agent_id);
+
+  CREATE TABLE IF NOT EXISTS webhooks (
+    id TEXT PRIMARY KEY,
+    url TEXT NOT NULL,
+    events TEXT NOT NULL DEFAULT '[]',
+    secret TEXT,
+    active BOOLEAN NOT NULL DEFAULT TRUE,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+
+  CREATE TABLE IF NOT EXISTS task_templates (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    title_pattern TEXT NOT NULL,
+    description TEXT,
+    priority TEXT DEFAULT 'medium',
+    tags TEXT DEFAULT '[]',
+    project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+    plan_id TEXT REFERENCES plans(id) ON DELETE SET NULL,
+    metadata TEXT DEFAULT '{}',
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+
+  ALTER TABLE tasks ADD COLUMN IF NOT EXISTS estimated_minutes INTEGER;
+  ALTER TABLE tasks ADD COLUMN IF NOT EXISTS requires_approval BOOLEAN NOT NULL DEFAULT FALSE;
+  ALTER TABLE tasks ADD COLUMN IF NOT EXISTS approved_by TEXT;
+  ALTER TABLE tasks ADD COLUMN IF NOT EXISTS approved_at TEXT;
+
+  ALTER TABLE agents ADD COLUMN IF NOT EXISTS permissions TEXT DEFAULT '["*"]';
+
+  INSERT INTO _migrations (id) VALUES (10) ON CONFLICT DO NOTHING;
+  `,
+    `
+  ALTER TABLE agents ADD COLUMN IF NOT EXISTS reports_to TEXT;
+  ALTER TABLE agents ADD COLUMN IF NOT EXISTS title TEXT;
+  ALTER TABLE agents ADD COLUMN IF NOT EXISTS level TEXT;
+  INSERT INTO _migrations (id) VALUES (11) ON CONFLICT DO NOTHING;
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS orgs (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL UNIQUE,
+    description TEXT,
+    metadata TEXT DEFAULT '{}',
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+  ALTER TABLE agents ADD COLUMN IF NOT EXISTS org_id TEXT REFERENCES orgs(id) ON DELETE SET NULL;
+  ALTER TABLE projects ADD COLUMN IF NOT EXISTS org_id TEXT REFERENCES orgs(id) ON DELETE SET NULL;
+  INSERT INTO _migrations (id) VALUES (12) ON CONFLICT DO NOTHING;
+  `,
+    `
+  ALTER TABLE tasks ADD COLUMN IF NOT EXISTS recurrence_rule TEXT;
+  ALTER TABLE tasks ADD COLUMN IF NOT EXISTS recurrence_parent_id TEXT REFERENCES tasks(id) ON DELETE SET NULL;
+  CREATE INDEX IF NOT EXISTS idx_tasks_recurrence_parent ON tasks(recurrence_parent_id);
+  CREATE INDEX IF NOT EXISTS idx_tasks_recurrence_rule ON tasks(recurrence_rule) WHERE recurrence_rule IS NOT NULL;
+  INSERT INTO _migrations (id) VALUES (13) ON CONFLICT DO NOTHING;
+  `,
+    `
+  ALTER TABLE task_comments ADD COLUMN IF NOT EXISTS type TEXT DEFAULT 'comment' CHECK(type IN ('comment', 'progress', 'note'));
+  ALTER TABLE task_comments ADD COLUMN IF NOT EXISTS progress_pct INTEGER CHECK(progress_pct IS NULL OR (progress_pct >= 0 AND progress_pct <= 100));
+  INSERT INTO _migrations (id) VALUES (14) ON CONFLICT DO NOTHING;
+  `,
+    `
+  -- PostgreSQL uses tsvector/tsquery instead of FTS5
+  -- Full-text search can be done with to_tsvector/to_tsquery on tasks table directly
+  -- No virtual table needed; add a generated tsvector column instead
+  ALTER TABLE tasks ADD COLUMN IF NOT EXISTS search_vector tsvector;
+
+  CREATE INDEX IF NOT EXISTS idx_tasks_search ON tasks USING GIN(search_vector);
+
+  -- Function to update search vector
+  CREATE OR REPLACE FUNCTION tasks_search_vector_update() RETURNS trigger AS $$
+  BEGIN
+    NEW.search_vector :=
+      setweight(to_tsvector('english', COALESCE(NEW.title, '')), 'A') ||
+      setweight(to_tsvector('english', COALESCE(NEW.description, '')), 'B') ||
+      setweight(to_tsvector('english', COALESCE(NEW.tags, '')), 'C');
+    RETURN NEW;
+  END;
+  $$ LANGUAGE plpgsql;
+
+  DROP TRIGGER IF EXISTS tasks_search_vector_trigger ON tasks;
+  CREATE TRIGGER tasks_search_vector_trigger
+    BEFORE INSERT OR UPDATE OF title, description, tags ON tasks
+    FOR EACH ROW EXECUTE FUNCTION tasks_search_vector_update();
+
+  -- Backfill existing rows
+  UPDATE tasks SET search_vector =
+    setweight(to_tsvector('english', COALESCE(title, '')), 'A') ||
+    setweight(to_tsvector('english', COALESCE(description, '')), 'B') ||
+    setweight(to_tsvector('english', COALESCE(tags, '')), 'C')
+  WHERE search_vector IS NULL;
+
+  INSERT INTO _migrations (id) VALUES (15) ON CONFLICT DO NOTHING;
+  `,
+    `
+  ALTER TABLE tasks ADD COLUMN IF NOT EXISTS spawns_template_id TEXT REFERENCES task_templates(id) ON DELETE SET NULL;
+  INSERT INTO _migrations (id) VALUES (16) ON CONFLICT DO NOTHING;
+  `,
+    `
+  ALTER TABLE agents ADD COLUMN IF NOT EXISTS session_id TEXT;
+  ALTER TABLE agents ADD COLUMN IF NOT EXISTS working_dir TEXT;
+  INSERT INTO _migrations (id) VALUES (17) ON CONFLICT DO NOTHING;
+  `,
+    `
+  ALTER TABLE tasks ADD COLUMN IF NOT EXISTS confidence DOUBLE PRECISION;
+  INSERT INTO _migrations (id) VALUES (18) ON CONFLICT DO NOTHING;
+  `,
+    `
+  ALTER TABLE tasks ADD COLUMN IF NOT EXISTS reason TEXT;
+  ALTER TABLE tasks ADD COLUMN IF NOT EXISTS spawned_from_session TEXT;
+  INSERT INTO _migrations (id) VALUES (19) ON CONFLICT DO NOTHING;
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS handoffs (
+    id TEXT PRIMARY KEY,
+    agent_id TEXT,
+    project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+    summary TEXT NOT NULL,
+    completed TEXT,
+    in_progress TEXT,
+    blockers TEXT,
+    next_steps TEXT,
+    created_at TIMESTAMPTZ NOT NULL
+  );
+  INSERT INTO _migrations (id) VALUES (20) ON CONFLICT DO NOTHING;
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS task_checklists (
+    id TEXT PRIMARY KEY,
+    task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    position INTEGER NOT NULL DEFAULT 0,
+    text TEXT NOT NULL,
+    checked BOOLEAN NOT NULL DEFAULT FALSE,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+  CREATE INDEX IF NOT EXISTS idx_task_checklists_task ON task_checklists(task_id);
+  INSERT INTO _migrations (id) VALUES (21) ON CONFLICT DO NOTHING;
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS project_sources (
+    id TEXT PRIMARY KEY,
+    project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+    type TEXT NOT NULL,
+    name TEXT NOT NULL,
+    uri TEXT NOT NULL,
+    description TEXT,
+    metadata TEXT DEFAULT '{}',
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+  CREATE INDEX IF NOT EXISTS idx_project_sources_project ON project_sources(project_id);
+  CREATE INDEX IF NOT EXISTS idx_project_sources_type ON project_sources(type);
+  INSERT INTO _migrations (id) VALUES (22) ON CONFLICT DO NOTHING;
+  `,
+    `
+  ALTER TABLE agents ADD COLUMN IF NOT EXISTS active_project_id TEXT;
+  INSERT INTO _migrations (id) VALUES (23) ON CONFLICT DO NOTHING;
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS resource_locks (
+    resource_type TEXT NOT NULL,
+    resource_id TEXT NOT NULL,
+    agent_id TEXT NOT NULL,
+    lock_type TEXT NOT NULL DEFAULT 'advisory',
+    locked_at TIMESTAMPTZ NOT NULL,
+    expires_at TIMESTAMPTZ NOT NULL,
+    UNIQUE(resource_type, resource_id, lock_type)
+  );
+  CREATE INDEX IF NOT EXISTS idx_resource_locks_type_id ON resource_locks(resource_type, resource_id);
+  CREATE INDEX IF NOT EXISTS idx_resource_locks_agent ON resource_locks(agent_id);
+  INSERT INTO _migrations (id) VALUES (24) ON CONFLICT DO NOTHING;
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS task_files (
+    id TEXT PRIMARY KEY,
+    task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    path TEXT NOT NULL,
+    status TEXT NOT NULL DEFAULT 'active',
+    agent_id TEXT,
+    note TEXT,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+  CREATE INDEX IF NOT EXISTS idx_task_files_task ON task_files(task_id);
+  CREATE INDEX IF NOT EXISTS idx_task_files_path ON task_files(path);
+  CREATE UNIQUE INDEX IF NOT EXISTS idx_task_files_task_path ON task_files(task_id, path);
+  INSERT INTO _migrations (id) VALUES (25) ON CONFLICT DO NOTHING;
+  `,
+    `
+  ALTER TABLE tasks ADD COLUMN IF NOT EXISTS assigned_by TEXT;
+  ALTER TABLE tasks ADD COLUMN IF NOT EXISTS assigned_from_project TEXT;
+  CREATE INDEX IF NOT EXISTS idx_tasks_assigned_by ON tasks(assigned_by);
+  INSERT INTO _migrations (id) VALUES (26) ON CONFLICT DO NOTHING;
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS task_relationships (
+    id TEXT PRIMARY KEY,
+    source_task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    target_task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    relationship_type TEXT NOT NULL CHECK(relationship_type IN ('related_to', 'conflicts_with', 'similar_to', 'duplicates', 'supersedes', 'modifies_same_file')),
+    metadata TEXT DEFAULT '{}',
+    created_by TEXT,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    CHECK (source_task_id != target_task_id)
+  );
+  CREATE INDEX IF NOT EXISTS idx_task_rel_source ON task_relationships(source_task_id);
+  CREATE INDEX IF NOT EXISTS idx_task_rel_target ON task_relationships(target_task_id);
+  CREATE INDEX IF NOT EXISTS idx_task_rel_type ON task_relationships(relationship_type);
+  INSERT INTO _migrations (id) VALUES (27) ON CONFLICT DO NOTHING;
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS kg_edges (
+    id TEXT PRIMARY KEY,
+    source_id TEXT NOT NULL,
+    source_type TEXT NOT NULL,
+    target_id TEXT NOT NULL,
+    target_type TEXT NOT NULL,
+    relation_type TEXT NOT NULL,
+    weight DOUBLE PRECISION NOT NULL DEFAULT 1.0,
+    metadata TEXT DEFAULT '{}',
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    UNIQUE(source_id, source_type, target_id, target_type, relation_type)
+  );
+  CREATE INDEX IF NOT EXISTS idx_kg_source ON kg_edges(source_id, source_type);
+  CREATE INDEX IF NOT EXISTS idx_kg_target ON kg_edges(target_id, target_type);
+  CREATE INDEX IF NOT EXISTS idx_kg_relation ON kg_edges(relation_type);
+  INSERT INTO _migrations (id) VALUES (28) ON CONFLICT DO NOTHING;
+  `,
+    `
+  ALTER TABLE agents ADD COLUMN IF NOT EXISTS capabilities TEXT DEFAULT '[]';
+  INSERT INTO _migrations (id) VALUES (29) ON CONFLICT DO NOTHING;
+  `,
+    `
+  ALTER TABLE agents ADD COLUMN IF NOT EXISTS status TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('active', 'archived'));
+  CREATE INDEX IF NOT EXISTS idx_agents_status ON agents(status);
+  INSERT INTO _migrations (id) VALUES (30) ON CONFLICT DO NOTHING;
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS project_agent_roles (
+    id TEXT PRIMARY KEY,
+    project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+    agent_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,
+    role TEXT NOT NULL,
+    is_lead BOOLEAN NOT NULL DEFAULT FALSE,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    UNIQUE(project_id, agent_id, role)
+  );
+  CREATE INDEX IF NOT EXISTS idx_project_agent_roles_project ON project_agent_roles(project_id);
+  CREATE INDEX IF NOT EXISTS idx_project_agent_roles_agent ON project_agent_roles(agent_id);
+  INSERT INTO _migrations (id) VALUES (31) ON CONFLICT DO NOTHING;
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS task_commits (
+    id TEXT PRIMARY KEY,
+    task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    sha TEXT NOT NULL,
+    message TEXT,
+    author TEXT,
+    files_changed TEXT,
+    committed_at TEXT,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    UNIQUE(task_id, sha)
+  );
+  CREATE INDEX IF NOT EXISTS idx_task_commits_task ON task_commits(task_id);
+  CREATE INDEX IF NOT EXISTS idx_task_commits_sha ON task_commits(sha);
+  INSERT INTO _migrations (id) VALUES (32) ON CONFLICT DO NOTHING;
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS file_locks (
+    id TEXT PRIMARY KEY,
+    path TEXT NOT NULL UNIQUE,
+    agent_id TEXT NOT NULL,
+    task_id TEXT REFERENCES tasks(id) ON DELETE SET NULL,
+    expires_at TIMESTAMPTZ NOT NULL,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+  CREATE INDEX IF NOT EXISTS idx_file_locks_path ON file_locks(path);
+  CREATE INDEX IF NOT EXISTS idx_file_locks_agent ON file_locks(agent_id);
+  CREATE INDEX IF NOT EXISTS idx_file_locks_expires ON file_locks(expires_at);
+  INSERT INTO _migrations (id) VALUES (33) ON CONFLICT DO NOTHING;
+  `,
+    `
+  ALTER TABLE tasks ADD COLUMN IF NOT EXISTS started_at TEXT;
+  INSERT INTO _migrations (id) VALUES (34) ON CONFLICT DO NOTHING;
+  `,
+    `
+  ALTER TABLE tasks ADD COLUMN IF NOT EXISTS task_type TEXT;
+  CREATE INDEX IF NOT EXISTS idx_tasks_task_type ON tasks(task_type);
+  ALTER TABLE tasks ADD COLUMN IF NOT EXISTS cost_tokens INTEGER DEFAULT 0;
+  ALTER TABLE tasks ADD COLUMN IF NOT EXISTS cost_usd DOUBLE PRECISION DEFAULT 0;
+  ALTER TABLE tasks ADD COLUMN IF NOT EXISTS delegated_from TEXT;
+  ALTER TABLE tasks ADD COLUMN IF NOT EXISTS delegation_depth INTEGER DEFAULT 0;
+  ALTER TABLE tasks ADD COLUMN IF NOT EXISTS retry_count INTEGER DEFAULT 0;
+  ALTER TABLE tasks ADD COLUMN IF NOT EXISTS max_retries INTEGER DEFAULT 3;
+  ALTER TABLE tasks ADD COLUMN IF NOT EXISTS retry_after TEXT;
+  ALTER TABLE tasks ADD COLUMN IF NOT EXISTS sla_minutes INTEGER;
+
+  CREATE TABLE IF NOT EXISTS task_traces (
+    id TEXT PRIMARY KEY,
+    task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    agent_id TEXT,
+    trace_type TEXT NOT NULL CHECK(trace_type IN ('tool_call','llm_call','error','handoff','custom')),
+    name TEXT,
+    input_summary TEXT,
+    output_summary TEXT,
+    duration_ms INTEGER,
+    tokens INTEGER,
+    cost_usd DOUBLE PRECISION,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+  CREATE INDEX IF NOT EXISTS idx_task_traces_task ON task_traces(task_id);
+  CREATE INDEX IF NOT EXISTS idx_task_traces_agent ON task_traces(agent_id);
+
+  CREATE TABLE IF NOT EXISTS context_snapshots (
+    id TEXT PRIMARY KEY,
+    agent_id TEXT,
+    task_id TEXT REFERENCES tasks(id) ON DELETE SET NULL,
+    project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+    snapshot_type TEXT NOT NULL CHECK(snapshot_type IN ('interrupt','complete','handoff','checkpoint')),
+    plan_summary TEXT,
+    files_open TEXT DEFAULT '[]',
+    attempts TEXT DEFAULT '[]',
+    blockers TEXT DEFAULT '[]',
+    next_steps TEXT,
+    metadata TEXT DEFAULT '{}',
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+  CREATE INDEX IF NOT EXISTS idx_snapshots_agent ON context_snapshots(agent_id);
+  CREATE INDEX IF NOT EXISTS idx_snapshots_task ON context_snapshots(task_id);
+
+  CREATE TABLE IF NOT EXISTS agent_budgets (
+    agent_id TEXT PRIMARY KEY,
+    max_concurrent INTEGER DEFAULT 5,
+    max_cost_usd DOUBLE PRECISION,
+    max_task_minutes INTEGER,
+    period_hours INTEGER DEFAULT 24,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+
+  INSERT INTO _migrations (id) VALUES (35) ON CONFLICT DO NOTHING;
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS feedback (
+    id TEXT PRIMARY KEY DEFAULT gen_random_uuid()::text,
+    message TEXT NOT NULL,
+    email TEXT,
+    category TEXT DEFAULT 'general',
+    version TEXT,
+    machine_id TEXT,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+
+  INSERT INTO _migrations (id) VALUES (36) ON CONFLICT DO NOTHING;
+  `
+  ];
+});
+
+// src/db/pg-migrate.ts
+var exports_pg_migrate = {};
+__export(exports_pg_migrate, {
+  applyPgMigrations: () => applyPgMigrations
 });
-import { readFileSync as readFileSync4, statSync as statSync2 } from "fs";
-import { relative as relative2, resolve as resolve2, join as join10 } from "path";
-function tagToPriority(tag) {
-  switch (tag) {
-    case "BUG":
-    case "FIXME":
-      return "high";
-    case "HACK":
-    case "XXX":
-      return "medium";
-    case "TODO":
-      return "medium";
-    case "NOTE":
-      return "low";
-  }
-}
-function buildTagRegex(tags) {
-  const tagPattern = tags.join("|");
-  return new RegExp(`(?:^|\\s)(?:\\/\\/|\\/\\*|#|\\*|--|;;|%|<!--|\\{-)\\s*(?:@?)(${tagPattern})\\s*[:(]?\\s*(.*)$`, "i");
-}
-function extractFromSource(source, filePath, tags = [...EXTRACT_TAGS]) {
-  const regex = buildTagRegex(tags);
-  const results = [];
-  const lines = source.split(`
-`);
-  for (let i = 0;i < lines.length; i++) {
-    const line = lines[i];
-    const match = line.match(regex);
-    if (match) {
-      const tag = match[1].toUpperCase();
-      let message = match[2].trim();
-      message = message.replace(/\s*\*\/\s*$/, "").replace(/\s*-->\s*$/, "").replace(/\s*-\}\s*$/, "").trim();
-      if (message) {
-        results.push({
-          tag,
-          message,
-          file: filePath,
-          line: i + 1,
-          raw: line
-        });
+async function applyPgMigrations(connectionString) {
+  const pg = new PgAdapterAsync(connectionString);
+  const result = {
+    applied: [],
+    alreadyApplied: [],
+    errors: [],
+    totalMigrations: PG_MIGRATIONS.length
+  };
+  try {
+    await pg.run(`CREATE TABLE IF NOT EXISTS _pg_migrations (
+        id SERIAL PRIMARY KEY,
+        version INT UNIQUE NOT NULL,
+        applied_at TIMESTAMPTZ DEFAULT NOW()
+      )`);
+    const applied = await pg.all("SELECT version FROM _pg_migrations ORDER BY version");
+    const appliedSet = new Set(applied.map((r) => r.version));
+    for (let i = 0;i < PG_MIGRATIONS.length; i++) {
+      if (appliedSet.has(i)) {
+        result.alreadyApplied.push(i);
+        continue;
       }
-    }
-  }
-  return results;
-}
-function collectFiles(basePath, extensions) {
-  const stat = statSync2(basePath);
-  if (stat.isFile()) {
-    return [basePath];
-  }
-  const glob = new Bun.Glob("**/*");
-  const files = [];
-  for (const entry of glob.scanSync({ cwd: basePath, onlyFiles: true, dot: false })) {
-    const parts = entry.split("/");
-    if (parts.some((p) => SKIP_DIRS.has(p)))
-      continue;
-    const dotIdx = entry.lastIndexOf(".");
-    if (dotIdx === -1)
-      continue;
-    const ext = entry.slice(dotIdx);
-    if (!extensions.has(ext))
-      continue;
-    files.push(entry);
-  }
-  return files.sort();
-}
-function extractTodos(options, db) {
-  const basePath = resolve2(options.path);
-  const tags = options.patterns || [...EXTRACT_TAGS];
-  const extensions = options.extensions ? new Set(options.extensions.map((e) => e.startsWith(".") ? e : `.${e}`)) : DEFAULT_EXTENSIONS;
-  const files = collectFiles(basePath, extensions);
-  const allComments = [];
-  for (const file of files) {
-    const fullPath = statSync2(basePath).isFile() ? basePath : join10(basePath, file);
-    try {
-      const source = readFileSync4(fullPath, "utf-8");
-      const relPath = statSync2(basePath).isFile() ? relative2(resolve2(basePath, ".."), fullPath) : file;
-      const comments = extractFromSource(source, relPath, tags);
-      allComments.push(...comments);
-    } catch {}
-  }
-  if (options.dry_run) {
-    return { comments: allComments, tasks: [], skipped: 0 };
-  }
-  const tasks = [];
-  let skipped = 0;
-  const existingTasks = options.project_id ? listTasks({ project_id: options.project_id, tags: ["extracted"] }, db) : listTasks({ tags: ["extracted"] }, db);
-  const existingKeys = new Set;
-  for (const t of existingTasks) {
-    const meta = t.metadata;
-    if (meta?.["source_file"] && meta?.["source_line"]) {
-      existingKeys.add(`${meta["source_file"]}:${meta["source_line"]}`);
-    }
-  }
-  for (const comment of allComments) {
-    const dedupKey = `${comment.file}:${comment.line}`;
-    if (existingKeys.has(dedupKey)) {
-      skipped++;
-      continue;
-    }
-    const taskTags = ["extracted", comment.tag.toLowerCase(), ...options.tags || []];
-    const task = createTask({
-      title: `[${comment.tag}] ${comment.message}`,
-      description: `Extracted from code comment in \`${comment.file}\` at line ${comment.line}:
-\`\`\`
-${comment.raw.trim()}
-\`\`\``,
-      priority: tagToPriority(comment.tag),
-      project_id: options.project_id,
-      task_list_id: options.task_list_id,
-      assigned_to: options.assigned_to,
-      agent_id: options.agent_id,
-      tags: taskTags,
-      metadata: {
-        source: "code_comment",
-        comment_type: comment.tag,
-        source_file: comment.file,
-        source_line: comment.line
+      try {
+        await pg.exec(PG_MIGRATIONS[i]);
+        await pg.run("INSERT INTO _pg_migrations (version) VALUES ($1) ON CONFLICT DO NOTHING", i);
+        result.applied.push(i);
+      } catch (err) {
+        result.errors.push(`Migration ${i}: ${err?.message ?? String(err)}`);
+        break;
       }
-    }, db);
-    addTaskFile({
-      task_id: task.id,
-      path: comment.file,
-      note: `Line ${comment.line}: ${comment.tag} comment`
-    }, db);
-    tasks.push(task);
-    existingKeys.add(dedupKey);
+    }
+  } finally {
+    await pg.close();
   }
-  return { comments: allComments, tasks, skipped };
+  return result;
 }
-var EXTRACT_TAGS, DEFAULT_EXTENSIONS, SKIP_DIRS;
-var init_extract = __esm(() => {
-  init_tasks();
-  init_task_files();
-  EXTRACT_TAGS = ["TODO", "FIXME", "HACK", "XXX", "BUG", "NOTE"];
-  DEFAULT_EXTENSIONS = new Set([
-    ".ts",
-    ".tsx",
-    ".js",
-    ".jsx",
-    ".mjs",
-    ".cjs",
-    ".py",
-    ".rb",
-    ".go",
-    ".rs",
-    ".c",
-    ".cpp",
-    ".h",
-    ".hpp",
-    ".java",
-    ".kt",
-    ".swift",
-    ".cs",
-    ".php",
-    ".sh",
-    ".bash",
-    ".zsh",
-    ".lua",
-    ".sql",
-    ".r",
-    ".R",
-    ".yaml",
-    ".yml",
-    ".toml",
-    ".css",
-    ".scss",
-    ".less",
-    ".vue",
-    ".svelte",
-    ".ex",
-    ".exs",
-    ".erl",
-    ".hs",
-    ".ml",
-    ".mli",
-    ".clj",
-    ".cljs"
-  ]);
-  SKIP_DIRS = new Set([
-    "node_modules",
-    ".git",
-    "dist",
-    "build",
-    "out",
-    ".next",
-    ".turbo",
-    "coverage",
-    "__pycache__",
-    ".venv",
-    "venv",
-    "vendor",
-    "target",
-    ".cache",
-    ".parcel-cache"
-  ]);
+var init_pg_migrate = __esm(() => {
+  init_dist();
+  init_pg_migrations();
 });
 
 // src/mcp/index.ts
@@ -18827,16 +20296,16 @@ function searchTasks(options, projectId, taskListId, db) {
 init_tasks();
 init_config();
 init_sync_utils();
-import { existsSync as existsSync7, readFileSync as readFileSync3, readdirSync as readdirSync3, writeFileSync as writeFileSync3 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync5, readdirSync as readdirSync5, writeFileSync as writeFileSync3 } from "fs";
+import { join as join10 } from "path";
 function getTaskListDir(taskListId) {
-  return join8(HOME, ".claude", "tasks", taskListId);
+  return join10(HOME, ".claude", "tasks", taskListId);
 }
 function readClaudeTask(dir, filename) {
-  return readJsonFile(join8(dir, filename));
+  return readJsonFile(join10(dir, filename));
 }
 function writeClaudeTask(dir, task) {
-  writeJsonFile(join8(dir, `${task.id}.json`), task);
+  writeJsonFile(join10(dir, `${task.id}.json`), task);
 }
 function toClaudeStatus(status) {
   if (status === "pending" || status === "in_progress" || status === "completed") {
@@ -18848,14 +20317,14 @@ function toSqliteStatus(status) {
   return status;
 }
 function readPrefixCounter(dir) {
-  const path = join8(dir, ".prefix-counter");
-  if (!existsSync7(path))
+  const path = join10(dir, ".prefix-counter");
+  if (!existsSync9(path))
     return 0;
-  const val = parseInt(readFileSync3(path, "utf-8").trim(), 10);
+  const val = parseInt(readFileSync5(path, "utf-8").trim(), 10);
   return isNaN(val) ? 0 : val;
 }
 function writePrefixCounter(dir, value) {
-  writeFileSync3(join8(dir, ".prefix-counter"), String(value));
+  writeFileSync3(join10(dir, ".prefix-counter"), String(value));
 }
 function formatPrefixedSubject(title, prefix, counter) {
   const padded = String(counter).padStart(5, "0");
@@ -18882,7 +20351,7 @@ function taskToClaudeTask(task, claudeTaskId, existingMeta) {
 }
 function pushToClaudeTaskList(taskListId, projectId, options = {}) {
   const dir = getTaskListDir(taskListId);
-  if (!existsSync7(dir))
+  if (!existsSync9(dir))
     ensureDir2(dir);
   const filter = {};
   if (projectId)
@@ -18891,7 +20360,7 @@ function pushToClaudeTaskList(taskListId, projectId, options = {}) {
   const existingByTodosId = new Map;
   const files = listJsonFiles(dir);
   for (const f of files) {
-    const path = join8(dir, f);
+    const path = join10(dir, f);
     const ct = readClaudeTask(dir, f);
     if (ct?.metadata?.["todos_id"]) {
       existingByTodosId.set(ct.metadata["todos_id"], { task: ct, mtimeMs: getFileMtimeMs(path) });
@@ -18978,10 +20447,10 @@ function pushToClaudeTaskList(taskListId, projectId, options = {}) {
 }
 function pullFromClaudeTaskList(taskListId, projectId, options = {}) {
   const dir = getTaskListDir(taskListId);
-  if (!existsSync7(dir)) {
+  if (!existsSync9(dir)) {
     return { pushed: 0, pulled: 0, errors: [`Task list directory not found: ${dir}`] };
   }
-  const files = readdirSync3(dir).filter((f) => f.endsWith(".json"));
+  const files = readdirSync5(dir).filter((f) => f.endsWith(".json"));
   let pulled = 0;
   const errors2 = [];
   const prefer = options.prefer || "remote";
@@ -18998,7 +20467,7 @@ function pullFromClaudeTaskList(taskListId, projectId, options = {}) {
   }
   for (const f of files) {
     try {
-      const filePath = join8(dir, f);
+      const filePath = join10(dir, f);
       const ct = readClaudeTask(dir, f);
       if (!ct)
         continue;
@@ -19069,27 +20538,27 @@ function syncClaudeTaskList(taskListId, projectId, options = {}) {
 init_tasks();
 init_sync_utils();
 init_config();
-import { existsSync as existsSync8 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { join as join11 } from "path";
 function getTodosGlobalDir2() {
-  const newDir = join9(HOME, ".hasna", "todos");
-  const legacyDir = join9(HOME, ".todos");
-  if (!existsSync8(newDir) && existsSync8(legacyDir))
+  const newDir = join11(HOME, ".hasna", "todos");
+  const legacyDir = join11(HOME, ".todos");
+  if (!existsSync10(newDir) && existsSync10(legacyDir))
     return legacyDir;
   return newDir;
 }
 function agentBaseDir(agent) {
   const key = `TODOS_${agent.toUpperCase()}_TASKS_DIR`;
-  return process.env[key] || getAgentTasksDir(agent) || process.env["TODOS_AGENT_TASKS_DIR"] || join9(getTodosGlobalDir2(), "agents");
+  return process.env[key] || getAgentTasksDir(agent) || process.env["TODOS_AGENT_TASKS_DIR"] || join11(getTodosGlobalDir2(), "agents");
 }
 function getTaskListDir2(agent, taskListId) {
-  return join9(agentBaseDir(agent), agent, taskListId);
+  return join11(agentBaseDir(agent), agent, taskListId);
 }
 function readAgentTask(dir, filename) {
-  return readJsonFile(join9(dir, filename));
+  return readJsonFile(join11(dir, filename));
 }
 function writeAgentTask(dir, task) {
-  writeJsonFile(join9(dir, `${task.id}.json`), task);
+  writeJsonFile(join11(dir, `${task.id}.json`), task);
 }
 function taskToAgentTask(task, externalId, existingMeta) {
   return {
@@ -19114,7 +20583,7 @@ function metadataKey(agent) {
 }
 function pushToAgentTaskList(agent, taskListId, projectId, options = {}) {
   const dir = getTaskListDir2(agent, taskListId);
-  if (!existsSync8(dir))
+  if (!existsSync10(dir))
     ensureDir2(dir);
   const filter = {};
   if (projectId)
@@ -19123,7 +20592,7 @@ function pushToAgentTaskList(agent, taskListId, projectId, options = {}) {
   const existingByTodosId = new Map;
   const files = listJsonFiles(dir);
   for (const f of files) {
-    const path = join9(dir, f);
+    const path = join11(dir, f);
     const at = readAgentTask(dir, f);
     if (at?.metadata?.["todos_id"]) {
       existingByTodosId.set(at.metadata["todos_id"], { task: at, mtimeMs: getFileMtimeMs(path) });
@@ -19197,7 +20666,7 @@ function pushToAgentTaskList(agent, taskListId, projectId, options = {}) {
 }
 function pullFromAgentTaskList(agent, taskListId, projectId, options = {}) {
   const dir = getTaskListDir2(agent, taskListId);
-  if (!existsSync8(dir)) {
+  if (!existsSync10(dir)) {
     return { pushed: 0, pulled: 0, errors: [`Task list directory not found: ${dir}`] };
   }
   const files = listJsonFiles(dir);
@@ -19216,7 +20685,7 @@ function pullFromAgentTaskList(agent, taskListId, projectId, options = {}) {
   }
   for (const f of files) {
     try {
-      const filePath = join9(dir, f);
+      const filePath = join11(dir, f);
       const at = readAgentTask(dir, f);
       if (!at)
         continue;
@@ -19359,14 +20828,14 @@ init_config();
 init_database();
 init_checklists();
 init_types();
-import { readFileSync as readFileSync5 } from "fs";
-import { join as join11, dirname as dirname2 } from "path";
+import { readFileSync as readFileSync7 } from "fs";
+import { join as join13, dirname as dirname3 } from "path";
 import { fileURLToPath } from "url";
 function getMcpVersion() {
   try {
-    const __dir = dirname2(fileURLToPath(import.meta.url));
-    const pkgPath = join11(__dir, "..", "package.json");
-    return JSON.parse(readFileSync5(pkgPath, "utf-8")).version || "0.0.0";
+    const __dir = dirname3(fileURLToPath(import.meta.url));
+    const pkgPath = join13(__dir, "..", "package.json");
+    return JSON.parse(readFileSync7(pkgPath, "utf-8")).version || "0.0.0";
   } catch {
     return "0.0.0";
   }
@@ -19402,6 +20871,7 @@ var STANDARD_EXCLUDED = new Set([
   "list_templates",
   "create_task_from_template",
   "delete_template",
+  "update_template",
   "approve_task"
 ]);
 function shouldRegisterTool(name) {
@@ -21223,7 +22693,8 @@ if (shouldRegisterTool("create_task_from_template")) {
   }, async (params) => {
     try {
       const { taskFromTemplate: taskFromTemplate2 } = await Promise.resolve().then(() => (init_templates(), exports_templates));
-      const input = taskFromTemplate2(params.template_id, {
+      const resolvedTemplateId = resolveId(params.template_id, "task_templates");
+      const input = taskFromTemplate2(resolvedTemplateId, {
         title: params.title,
         description: params.description,
         priority: params.priority,
@@ -21242,13 +22713,37 @@ if (shouldRegisterTool("delete_template")) {
   server.tool("delete_template", "Delete a task template by ID.", { id: exports_external.string() }, async ({ id }) => {
     try {
       const { deleteTemplate: deleteTemplate2 } = await Promise.resolve().then(() => (init_templates(), exports_templates));
-      const deleted = deleteTemplate2(id);
+      const resolvedId = resolveId(id, "task_templates");
+      const deleted = deleteTemplate2(resolvedId);
       return { content: [{ type: "text", text: deleted ? "Template deleted." : "Template not found." }] };
     } catch (e) {
       return { content: [{ type: "text", text: formatError(e) }], isError: true };
     }
   });
 }
+if (shouldRegisterTool("update_template")) {
+  server.tool("update_template", "Update a task template's name, title pattern, description, priority, tags, or other fields.", {
+    id: exports_external.string(),
+    name: exports_external.string().optional(),
+    title_pattern: exports_external.string().optional(),
+    description: exports_external.string().optional(),
+    priority: exports_external.enum(["low", "medium", "high", "critical"]).optional(),
+    tags: exports_external.array(exports_external.string()).optional(),
+    project_id: exports_external.string().optional(),
+    plan_id: exports_external.string().optional()
+  }, async ({ id, ...updates }) => {
+    try {
+      const { updateTemplate: updateTemplate2 } = await Promise.resolve().then(() => (init_templates(), exports_templates));
+      const resolvedId = resolveId(id, "task_templates");
+      const t = updateTemplate2(resolvedId, updates);
+      if (!t)
+        return { content: [{ type: "text", text: `Template not found: ${id}` }], isError: true };
+      return { content: [{ type: "text", text: `Template updated: ${t.id.slice(0, 8)} | ${t.name} | "${t.title_pattern}" | ${t.priority}` }] };
+    } catch (e) {
+      return { content: [{ type: "text", text: formatError(e) }], isError: true };
+    }
+  });
+}
 if (shouldRegisterTool("approve_task")) {
   server.tool("approve_task", "Approve a task with requires_approval=true.", {
     id: exports_external.string(),
@@ -22365,6 +23860,7 @@ if (shouldRegisterTool("search_tools")) {
       "list_templates",
       "create_task_from_template",
       "delete_template",
+      "update_template",
       "bulk_update_tasks",
       "bulk_create_tasks",
       "get_task_stats",
@@ -22601,6 +24097,9 @@ if (shouldRegisterTool("describe_tools")) {
       delete_template: `Delete a task template.
   Params: id(string, req)
   Example: {id: 'a1b2c3d4'}`,
+      update_template: `Update a task template's name, title pattern, or other fields.
+  Params: id(string, req), name(string), title_pattern(string), description(string), priority(low|medium|high|critical), tags(string[]), project_id(string), plan_id(string)
+  Example: {id: 'a1b2c3d4', name: 'Renamed Template', priority: 'critical'}`,
       get_active_work: `See all in-progress tasks and who is working on them.
   Params: project_id(string, optional), task_list_id(string, optional)
   Example: {project_id: 'a1b2c3d4'}`,
@@ -23411,6 +24910,49 @@ server.resource("task-lists", "todos://task-lists", { description: "All task lis
   const lists = listTaskLists();
   return { contents: [{ uri: "todos://task-lists", text: JSON.stringify(lists, null, 2), mimeType: "application/json" }] };
 });
+if (shouldRegisterTool("migrate_pg")) {
+  server.tool("migrate_pg", "Apply PostgreSQL schema migrations to the configured RDS instance", {
+    connection_string: exports_external.string().optional().describe("PostgreSQL connection string (overrides cloud config)")
+  }, async ({ connection_string }) => {
+    try {
+      let connStr;
+      if (connection_string) {
+        connStr = connection_string;
+      } else {
+        const { getConnectionString: getConnectionString2 } = await Promise.resolve().then(() => (init_dist(), exports_dist));
+        connStr = getConnectionString2("todos");
+      }
+      const { applyPgMigrations: applyPgMigrations2 } = await Promise.resolve().then(() => (init_pg_migrate(), exports_pg_migrate));
+      const result = await applyPgMigrations2(connStr);
+      const lines = [];
+      if (result.applied.length > 0) {
+        lines.push(`Applied ${result.applied.length} migration(s): ${result.applied.join(", ")}`);
+      }
+      if (result.alreadyApplied.length > 0) {
+        lines.push(`Already applied: ${result.alreadyApplied.length} migration(s)`);
+      }
+      if (result.errors.length > 0) {
+        lines.push(`Errors:
+${result.errors.join(`
+`)}`);
+      }
+      if (result.applied.length === 0 && result.errors.length === 0) {
+        lines.push("Schema is up to date.");
+      }
+      lines.push(`Total migrations: ${result.totalMigrations}`);
+      return {
+        content: [{ type: "text", text: lines.join(`
+`) }],
+        isError: result.errors.length > 0
+      };
+    } catch (e) {
+      return {
+        content: [{ type: "text", text: `Migration failed: ${e?.message ?? String(e)}` }],
+        isError: true
+      };
+    }
+  });
+}
 registerCloudTools(server, "todos");
 async function main() {
   const transport = new StdioServerTransport;