@hasna/todos 0.11.6 → 0.11.8

package/dist/cli/index.js

@@ -3730,6 +3730,7 @@ var init_webhooks = __esm(() => {
 // src/db/templates.ts
 var exports_templates = {};
 __export(exports_templates, {
+  updateTemplate: () => updateTemplate,
   taskFromTemplate: () => taskFromTemplate,
   listTemplates: () => listTemplates,
   getTemplate: () => getTemplate,
@@ -3744,6 +3745,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();
@@ -3764,7 +3768,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) {
@@ -3773,7 +3780,55 @@ 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 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);
@@ -10524,6 +10579,64 @@ var init_zod = __esm(() => {
 });
 
 // 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: () => getDbPath2,
+  getDataDir: () => getDataDir,
+  getConnectionString: () => getConnectionString,
+  getConflict: () => getConflict,
+  getConfigPath: () => getConfigPath2,
+  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 as Database2 } from "bun:sqlite";
 import { existsSync as existsSync22, mkdirSync as mkdirSync22, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "fs";
@@ -10538,6 +10651,12 @@ import {
 import { homedir as homedir3 } from "os";
 import { join as join9, relative as relative2 } from "path";
 import { hostname } from "os";
+import { existsSync as existsSync32, readFileSync as readFileSync22 } from "fs";
+import { homedir as homedir32 } from "os";
+import { join as join32 } from "path";
+import { existsSync as existsSync42, readdirSync as readdirSync22 } from "fs";
+import { join as join42 } from "path";
+import { join as join52, dirname as dirname2 } from "path";
 function __accessProp2(key) {
   return this[key];
 }
@@ -10578,6 +10697,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;
@@ -10605,6 +10735,9 @@ class SqliteAdapter {
   exec(sql) {
     this.db.exec(sql);
   }
+  query(sql) {
+    return this.db.query(sql);
+  }
   prepare(sql) {
     const stmt = this.db.prepare(sql);
     return {
@@ -10762,6 +10895,62 @@ class PgAdapter {
     return this.pool;
   }
 }
+
+class PgAdapterAsync {
+  pool;
+  constructor(arg) {
+    if (typeof arg === "string") {
+      this.pool = new esm_default.Pool({ connectionString: arg });
+    } else {
+      this.pool = arg;
+    }
+  }
+  async run(sql, ...params) {
+    const pgSql = translateSql(sql, "pg");
+    const pgParams = translateParams(params);
+    const res = await this.pool.query(pgSql, pgParams);
+    return {
+      changes: res.rowCount ?? 0,
+      lastInsertRowid: res.rows?.[0]?.id ?? 0
+    };
+  }
+  async get(sql, ...params) {
+    const pgSql = translateSql(sql, "pg");
+    const pgParams = translateParams(params);
+    const res = await this.pool.query(pgSql, pgParams);
+    return res.rows[0] ?? null;
+  }
+  async all(sql, ...params) {
+    const pgSql = translateSql(sql, "pg");
+    const pgParams = translateParams(params);
+    const res = await this.pool.query(pgSql, pgParams);
+    return res.rows;
+  }
+  async exec(sql) {
+    const pgSql = translateSql(sql, "pg");
+    await this.pool.query(pgSql);
+  }
+  async close() {
+    await this.pool.end();
+  }
+  async transaction(fn) {
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      const result = await fn(client);
+      await client.query("COMMIT");
+      return result;
+    } catch (err) {
+      await client.query("ROLLBACK");
+      throw err;
+    } finally {
+      client.release();
+    }
+  }
+  get raw() {
+    return this.pool;
+  }
+}
 function setErrorMap2(map) {
   overrideErrorMap2 = map;
 }
@@ -11342,6 +11531,45 @@ function getDbPath2(serviceName) {
   const dir = getDataDir(serviceName);
   return join9(dir, `${serviceName}.db`);
 }
+function migrateDotfile(serviceName) {
+  const legacyDir = join9(homedir3(), `.${serviceName}`);
+  const newDir = join9(HASNA_DIR, serviceName);
+  if (!existsSync8(legacyDir))
+    return [];
+  if (existsSync8(newDir))
+    return [];
+  mkdirSync5(newDir, { recursive: true });
+  const migrated = [];
+  copyDirRecursive(legacyDir, newDir, legacyDir, migrated);
+  return migrated;
+}
+function copyDirRecursive(src, dest, root, migrated) {
+  const entries = readdirSync4(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = join9(src, entry.name);
+    const destPath = join9(dest, entry.name);
+    if (entry.isDirectory()) {
+      mkdirSync5(destPath, { recursive: true });
+      copyDirRecursive(srcPath, destPath, root, migrated);
+    } else {
+      copyFileSync(srcPath, destPath);
+      migrated.push(relative2(root, srcPath));
+    }
+  }
+}
+function hasLegacyDotfile(serviceName) {
+  return existsSync8(join9(homedir3(), `.${serviceName}`));
+}
+function getHasnaDir() {
+  mkdirSync5(HASNA_DIR, { recursive: true });
+  return HASNA_DIR;
+}
+function getConfigDir() {
+  return CONFIG_DIR2;
+}
+function getConfigPath2() {
+  return CONFIG_PATH2;
+}
 function getCloudConfig() {
   if (!existsSync22(CONFIG_PATH2)) {
     return CloudConfigSchema.parse({});
@@ -11353,6 +11581,11 @@ function getCloudConfig() {
     return CloudConfigSchema.parse({});
   }
 }
+function saveCloudConfig(config) {
+  mkdirSync22(CONFIG_DIR2, { recursive: true });
+  writeFileSync5(CONFIG_PATH2, JSON.stringify(config, null, 2) + `
+`, "utf-8");
+}
 function getConnectionString(dbName) {
   const config = getCloudConfig();
   const { host, port, username, password_env, ssl } = config.rds;
@@ -11373,126 +11606,367 @@ function createDatabase(options) {
   const dbPath = options.sqlitePath ?? getDbPath2(options.service);
   return new SqliteAdapter(dbPath);
 }
-function syncPush(local, cloud, options) {
-  return syncTransfer(local, cloud, options, "push");
+async function syncPush(local, remote, options) {
+  const orderedTables = await getTableOrder(remote, options.tables);
+  return syncTransfer(local, remote, { ...options, tables: orderedTables }, "push");
+}
+async function syncPull(remote, local, options) {
+  const orderedTables = await getTableOrder(remote, options.tables);
+  return syncTransfer(remote, local, { ...options, tables: orderedTables }, "pull");
+}
+async function getTableOrder(remote, tables) {
+  if (tables.length <= 1)
+    return tables;
+  try {
+    const fks = await remote.all(`
+      SELECT DISTINCT
+        tc.table_name AS source_table,
+        ccu.table_name AS referenced_table
+      FROM information_schema.table_constraints tc
+      JOIN information_schema.constraint_column_usage ccu
+        ON tc.constraint_name = ccu.constraint_name
+        AND tc.table_schema = ccu.table_schema
+      WHERE tc.constraint_type = 'FOREIGN KEY'
+        AND tc.table_schema = 'public'
+    `);
+    if (fks.length > 0) {
+      return topoSort(tables, fks);
+    }
+  } catch {}
+  return heuristicOrder(tables);
+}
+function topoSort(tables, fks) {
+  const tableSet = new Set(tables);
+  const deps = new Map;
+  for (const t of tables) {
+    deps.set(t, new Set);
+  }
+  for (const fk of fks) {
+    if (tableSet.has(fk.source_table) && tableSet.has(fk.referenced_table)) {
+      deps.get(fk.source_table).add(fk.referenced_table);
+    }
+  }
+  const sorted = [];
+  const visited = new Set;
+  const visiting = new Set;
+  function visit(table) {
+    if (visited.has(table))
+      return;
+    if (visiting.has(table)) {
+      sorted.push(table);
+      visited.add(table);
+      return;
+    }
+    visiting.add(table);
+    const tableDeps = deps.get(table) ?? new Set;
+    for (const dep of tableDeps) {
+      visit(dep);
+    }
+    visiting.delete(table);
+    visited.add(table);
+    sorted.push(table);
+  }
+  for (const t of tables) {
+    visit(t);
+  }
+  return sorted;
+}
+function heuristicOrder(tables) {
+  const sorted = [...tables].sort((a, b) => {
+    const aIsChild = a.includes("_") && tables.some((t) => a.startsWith(t + "_") || a.endsWith("_" + t));
+    const bIsChild = b.includes("_") && tables.some((t) => b.startsWith(t + "_") || b.endsWith("_" + t));
+    if (aIsChild && !bIsChild)
+      return 1;
+    if (!aIsChild && bIsChild)
+      return -1;
+    return a.localeCompare(b);
+  });
+  return sorted;
+}
+function getSqlitePrimaryKeys(adapter, table) {
+  try {
+    const cols = adapter.all(`PRAGMA table_info("${table}")`);
+    const pkCols = cols.filter((c) => c.pk > 0).sort((a, b) => a.pk - b.pk).map((c) => c.name);
+    return pkCols;
+  } catch {
+    return [];
+  }
+}
+async function getPgPrimaryKeys(adapter, table) {
+  try {
+    const rows = await adapter.all(`
+        SELECT kcu.column_name, kcu.ordinal_position
+        FROM information_schema.table_constraints tc
+        JOIN information_schema.key_column_usage kcu
+          ON tc.constraint_name = kcu.constraint_name
+          AND tc.table_schema = kcu.table_schema
+        WHERE tc.constraint_type = 'PRIMARY KEY'
+          AND tc.table_schema = 'public'
+          AND tc.table_name = '${table}'
+        ORDER BY kcu.ordinal_position
+      `);
+    return rows.map((r) => r.column_name);
+  } catch {
+    return [];
+  }
+}
+async function detectPrimaryKeys(adapter, table) {
+  if (isAsyncAdapter(adapter)) {
+    return getPgPrimaryKeys(adapter, table);
+  }
+  return getSqlitePrimaryKeys(adapter, table);
 }
-function syncPull(local, cloud, options) {
-  return syncTransfer(cloud, local, options, "pull");
+async function resolvePrimaryKeys(source, target, table, pkOption) {
+  if (pkOption) {
+    return Array.isArray(pkOption) ? pkOption : [pkOption];
+  }
+  let pks = await detectPrimaryKeys(source, table);
+  if (pks.length === 0) {
+    pks = await detectPrimaryKeys(target, table);
+  }
+  return pks;
 }
-function syncTransfer(source, target, options, _direction) {
+async function syncTransfer(source, target, options, _direction) {
   const {
     tables,
     onProgress,
-    batchSize = 500,
+    batchSize = 100,
     conflictColumn = "updated_at",
-    primaryKey = "id"
+    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 = source.all(`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 columns = Object.keys(rows[0]);
-      const hasConflictCol = columns.includes(conflictColumn);
-      const hasPrimaryKey = columns.includes(primaryKey);
-      if (!hasPrimaryKey) {
-        result.errors.push(`Table "${table}" has no "${primaryKey}" column \u2014 skipping`);
-        results.push(result);
-        continue;
-      }
-      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);
-        for (const row of batch) {
+        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 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) {
-                  result.rowsSkipped++;
-                  continue;
-                }
+            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);
               }
-              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);
+              result.rowsWritten += batch.length;
+            } catch (err) {
+              result.errors.push(`Batch at offset ${offset}: ${err?.message ?? String(err)}`);
             }
-            result.rowsWritten++;
-          } catch (err) {
-            result.errors.push(`Row ${row[primaryKey]}: ${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",
           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);
+            }
+            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)}`);
       }
-      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)}`);
+      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);
+          }
+        }
+      } catch {}
     }
-    results.push(result);
   }
   return results;
 }
+async function batchUpsertPg(target, table, columns, updateCols, primaryKeys, batch) {
+  if (batch.length === 0)
+    return;
+  const colList = columns.map((c) => `"${c}"`).join(", ");
+  const valuePlaceholders = batch.map((_, rowIdx) => {
+    const offset = rowIdx * columns.length;
+    return `(${columns.map((_2, colIdx) => `$${offset + colIdx + 1}`).join(", ")})`;
+  }).join(", ");
+  const pkList = primaryKeys.map((c) => `"${c}"`).join(", ");
+  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));
+  await target.run(sql, ...params);
+}
+function batchUpsertSqlite(target, table, columns, updateCols, primaryKeys, batch) {
+  if (batch.length === 0)
+    return;
+  const colList = columns.map((c) => `"${c}"`).join(", ");
+  const valuePlaceholders = batch.map(() => `(${columns.map(() => "?").join(", ")})`).join(", ");
+  const pkList = primaryKeys.map((c) => `"${c}"`).join(", ");
+  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) => coerceForSqlite(row[c])));
+  target.run(sql, ...params);
+}
+async function batchInsertPg(target, table, columns, batch) {
+  if (batch.length === 0)
+    return;
+  const colList = columns.map((c) => `"${c}"`).join(", ");
+  const valuePlaceholders = batch.map((_, rowIdx) => {
+    const offset = rowIdx * columns.length;
+    return `(${columns.map((_2, colIdx) => `$${offset + colIdx + 1}`).join(", ")})`;
+  }).join(", ");
+  const sql = `INSERT INTO "${table}" (${colList}) VALUES ${valuePlaceholders}`;
+  const params = batch.flatMap((row) => columns.map((c) => row[c] ?? null));
+  await target.run(sql, ...params);
+}
+function batchInsertSqlite(target, table, columns, batch) {
+  if (batch.length === 0)
+    return;
+  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) => 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";
+}
+async function readAll(adapter, sql) {
+  const result = adapter.all(sql);
+  return result instanceof Promise ? await result : result;
+}
 function listSqliteTables(db) {
   const rows = db.all(`SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name`);
   return rows.map((r) => r.name);
 }
+async function listPgTables(db) {
+  const rows = await db.all(`SELECT tablename FROM pg_tables WHERE schemaname = 'public' ORDER BY tablename`);
+  return rows.map((r) => r.tablename);
+}
 function ensureFeedbackTable(db) {
   db.exec(FEEDBACK_TABLE_SQL);
 }
@@ -11545,74 +12019,762 @@ async function sendFeedback(feedback, db) {
     return { sent: false, id, error: errorMsg };
   }
 }
-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 PgAdapter(getConnectionString("postgres"));
-        pg2.get("SELECT 1 as ok");
-        lines.push("PostgreSQL: connected");
-        pg2.close();
-      } catch (err) {
-        lines.push(`PostgreSQL: failed \u2014 ${err?.message}`);
+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;
+  progress = new Map;
+  startTimes = new Map;
+  callback;
+  constructor(db, callback) {
+    this.db = db;
+    this.callback = callback;
+    this.ensureResumeTable();
+  }
+  ensureResumeTable() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS _sync_resume (
+        table_name TEXT PRIMARY KEY,
+        last_row_id TEXT,
+        direction TEXT,
+        started_at TEXT,
+        status TEXT DEFAULT 'in_progress'
+      )
+    `);
+  }
+  start(table, total, direction) {
+    const resumed = this.canResume(table);
+    const now2 = Date.now();
+    this.startTimes.set(table, now2);
+    const status = resumed ? "resumed" : "in_progress";
+    const info = {
+      table,
+      total,
+      done: 0,
+      percent: 0,
+      elapsed_ms: 0,
+      eta_ms: 0,
+      status
+    };
+    this.progress.set(table, info);
+    this.db.run(`INSERT INTO _sync_resume (table_name, last_row_id, direction, started_at, status)
+       VALUES (?, ?, ?, datetime('now'), ?)
+       ON CONFLICT (table_name) DO UPDATE SET
+         direction = excluded.direction,
+         started_at = datetime('now'),
+         status = excluded.status`, table, "", direction, status);
+    this.notify(table);
+  }
+  update(table, done, lastRowId) {
+    const info = this.progress.get(table);
+    if (!info)
+      return;
+    const startTime = this.startTimes.get(table) ?? Date.now();
+    const elapsed = Date.now() - startTime;
+    const rate = done > 0 ? elapsed / done : 0;
+    const remaining = info.total - done;
+    const eta = remaining > 0 ? Math.round(rate * remaining) : 0;
+    info.done = done;
+    info.percent = info.total > 0 ? Math.round(done / info.total * 100) : 0;
+    info.elapsed_ms = elapsed;
+    info.eta_ms = eta;
+    info.status = "in_progress";
+    this.db.run(`UPDATE _sync_resume SET last_row_id = ?, status = 'in_progress' WHERE table_name = ?`, lastRowId, table);
+    this.notify(table);
+  }
+  markComplete(table) {
+    const info = this.progress.get(table);
+    if (info) {
+      const startTime = this.startTimes.get(table) ?? Date.now();
+      info.elapsed_ms = Date.now() - startTime;
+      info.done = info.total;
+      info.percent = 100;
+      info.eta_ms = 0;
+      info.status = "completed";
+      this.notify(table);
+    }
+    this.db.run(`UPDATE _sync_resume SET status = 'completed' WHERE table_name = ?`, table);
+  }
+  markFailed(table, _error) {
+    const info = this.progress.get(table);
+    if (info) {
+      const startTime = this.startTimes.get(table) ?? Date.now();
+      info.elapsed_ms = Date.now() - startTime;
+      info.status = "failed";
+      this.notify(table);
+    }
+    this.db.run(`UPDATE _sync_resume SET status = 'failed' WHERE table_name = ?`, table);
+  }
+  canResume(table) {
+    const row = this.db.get(`SELECT status FROM _sync_resume WHERE table_name = ?`, table);
+    if (!row)
+      return false;
+    return row.status === "in_progress" || row.status === "resumed";
+  }
+  getResumePoint(table) {
+    const row = this.db.get(`SELECT table_name, last_row_id, direction, started_at, status FROM _sync_resume WHERE table_name = ?`, table);
+    if (!row)
+      return null;
+    if (row.status !== "in_progress" && row.status !== "resumed")
+      return null;
+    return row;
+  }
+  clearResume(table) {
+    this.db.run(`DELETE FROM _sync_resume WHERE table_name = ?`, table);
+    this.progress.delete(table);
+    this.startTimes.delete(table);
+  }
+  getProgress(table) {
+    return this.progress.get(table) ?? null;
+  }
+  getAllProgress() {
+    return Array.from(this.progress.values());
+  }
+  listResumeRecords() {
+    return this.db.all(`SELECT table_name, last_row_id, direction, started_at, status FROM _sync_resume ORDER BY started_at DESC`);
+  }
+  notify(table) {
+    const info = this.progress.get(table);
+    if (info && this.callback) {
+      this.callback({ ...info });
+    }
+  }
+}
+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 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;
       }
     }
-    return { content: [{ type: "text", text: lines.join(`
-`) }] };
+    return resolved;
   });
-  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
-      };
+}
+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 {
+      sql += ` AND (resolution IS NULL OR resolved_at IS NULL)`;
     }
-    const local = new SqliteAdapter(getDbPath2(serviceName));
-    const cloud = new PgAdapter(getConnectionString(serviceName));
-    const tableList = tablesStr ? tablesStr.split(",").map((t) => t.trim()) : listSqliteTables(local);
-    const results = syncPush(local, cloud, { tables: tableList });
-    local.close();
-    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
+  }
+  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)}`);
+    }
+  }
+  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
+    };
+    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 now2 = new Date().toISOString();
+      upsertSyncMeta(local, {
+        table_name: table,
+        last_synced_at: now2,
+        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 now2 = new Date().toISOString();
+      upsertSyncMeta(local, {
+        table_name: table,
+        last_synced_at: now2,
+        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 (!existsSync32(AUTO_SYNC_CONFIG_PATH)) {
+      return { ...DEFAULT_AUTO_SYNC_CONFIG };
+    }
+    const raw = JSON.parse(readFileSync22(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 = readdirSync22(hasnaDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory())
+        continue;
+      const dbPath = join42(hasnaDir, entry.name, `${entry.name}.db`);
+      if (existsSync42(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 = join42(getDataDir(service), `${service}.db`);
+      if (!existsSync42(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 : dirname2(import.meta.url.replace("file://", ""));
+  const tsPath = join52(dir, "scheduled-sync.ts");
+  const jsPath = join52(dir, "scheduled-sync.js");
+  try {
+    const { existsSync: existsSync52 } = __require2("fs");
+    if (existsSync52(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(getDbPath2(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(getDbPath2(serviceName));
-    const cloud = new PgAdapter(getConnectionString(serviceName));
+    const cloud = new PgAdapterAsync(getConnectionString(serviceName));
     let tableList;
     if (tablesStr) {
       tableList = tablesStr.split(",").map((t) => t.trim());
     } else {
       try {
-        const rows = cloud.all(`SELECT tablename FROM pg_tables WHERE schemaname = 'public'`);
-        tableList = rows.map((r) => r.tablename);
+        tableList = await listPgTables(cloud);
       } catch {
         local.close();
-        cloud.close();
+        await cloud.close();
         return {
           content: [
             { type: "text", text: "Error: failed to list cloud tables." }
@@ -11621,9 +12783,9 @@ function registerCloudTools(server, serviceName) {
         };
       }
     }
-    const results = syncPull(local, cloud, { tables: tableList });
+    const results = await syncPull(cloud, local, { tables: tableList });
     local.close();
-    cloud.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).` }]
@@ -11646,6 +12808,85 @@ function registerCloudTools(server, serviceName) {
     };
   });
 }
+function registerCloudCommands(program2, serviceName) {
+  const cloudCmd = program2.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(getDbPath2(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(getDbPath2(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 __create2, __getProtoOf2, __defProp2, __getOwnPropNames2, __hasOwnProp2, __toESMCache_node2, __toESMCache_esm2, __toESM2 = (mod, isNodeMode, target) => {
   var canCache = mod != null && typeof mod === "object";
   if (canCache) {
@@ -11898,7 +13139,13 @@ CREATE TABLE IF NOT EXISTS feedback (
   email TEXT DEFAULT '',
   machine_id TEXT DEFAULT '',
   created_at TEXT DEFAULT (datetime('now'))
-)`;
+)`, 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(() => {
   __create2 = Object.create;
   __getProtoOf2 = Object.getPrototypeOf;
@@ -19837,10 +21084,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_DIR2 = join22(homedir22(), ".hasna", "cloud");
   CONFIG_PATH2 = join22(CONFIG_DIR2, "config.json");
+  AUTO_SYNC_CONFIG_PATH = join32(homedir32(), ".hasna", "cloud", "config.json");
+  DEFAULT_AUTO_SYNC_CONFIG = {
+    auto_sync_on_start: true,
+    auto_sync_on_stop: true
+  };
+  cleanupHandlers = [];
 });
 
 // src/db/traces.ts
@@ -21046,106 +22302,691 @@ var init_patrol = __esm(() => {
   init_database();
 });
 
-// src/db/agent-metrics.ts
-var exports_agent_metrics = {};
-__export(exports_agent_metrics, {
-  scoreTask: () => scoreTask,
-  getLeaderboard: () => getLeaderboard,
-  getAgentMetrics: () => getAgentMetrics
+// src/db/agent-metrics.ts
+var exports_agent_metrics = {};
+__export(exports_agent_metrics, {
+  scoreTask: () => scoreTask,
+  getLeaderboard: () => getLeaderboard,
+  getAgentMetrics: () => getAgentMetrics
+});
+function getAgentMetrics(agentId, opts, db) {
+  const d = db || getDatabase();
+  const agent = d.query("SELECT id, name FROM agents WHERE id = ? OR LOWER(name) = LOWER(?)").get(agentId, agentId);
+  if (!agent)
+    return null;
+  let projectFilter = "";
+  const params = [agent.id, agent.id];
+  if (opts?.project_id) {
+    projectFilter = " AND project_id = ?";
+    params.push(opts.project_id);
+  }
+  const completed = d.query(`SELECT COUNT(*) as count FROM tasks WHERE (agent_id = ? OR assigned_to = ?) AND status = 'completed'${projectFilter}`).get(...params).count;
+  const failed = d.query(`SELECT COUNT(*) as count FROM tasks WHERE (agent_id = ? OR assigned_to = ?) AND status = 'failed'${projectFilter}`).get(...params).count;
+  const inProgress = d.query(`SELECT COUNT(*) as count FROM tasks WHERE (agent_id = ? OR assigned_to = ?) AND status = 'in_progress'${projectFilter}`).get(...params).count;
+  const total = completed + failed;
+  const completionRate = total > 0 ? completed / total : 0;
+  const avgTime = d.query(`SELECT AVG(
+       (julianday(completed_at) - julianday(created_at)) * 24 * 60
+     ) as avg_minutes
+     FROM tasks
+     WHERE (agent_id = ? OR assigned_to = ?) AND status = 'completed' AND completed_at IS NOT NULL${projectFilter}`).get(...params);
+  const avgConf = d.query(`SELECT AVG(confidence) as avg_confidence
+     FROM tasks
+     WHERE (agent_id = ? OR assigned_to = ?) AND status = 'completed' AND confidence IS NOT NULL${projectFilter}`).get(...params);
+  const reviewTasks = d.query(`SELECT metadata FROM tasks
+     WHERE (agent_id = ? OR assigned_to = ?) AND status = 'completed'${projectFilter}
+       AND metadata LIKE '%_review_score%'`).all(...params);
+  let reviewScoreAvg = null;
+  if (reviewTasks.length > 0) {
+    let total2 = 0;
+    let count = 0;
+    for (const row of reviewTasks) {
+      try {
+        const meta = JSON.parse(row.metadata);
+        if (typeof meta._review_score === "number") {
+          total2 += meta._review_score;
+          count++;
+        }
+      } catch {}
+    }
+    if (count > 0)
+      reviewScoreAvg = total2 / count;
+  }
+  const speedScore = avgTime?.avg_minutes != null ? Math.max(0, 1 - avgTime.avg_minutes / (60 * 24)) : 0.5;
+  const confidenceScore = avgConf?.avg_confidence ?? 0.5;
+  const volumeScore = Math.min(1, completed / 50);
+  const compositeScore = completionRate * 0.3 + speedScore * 0.2 + confidenceScore * 0.3 + volumeScore * 0.2;
+  return {
+    agent_id: agent.id,
+    agent_name: agent.name,
+    tasks_completed: completed,
+    tasks_failed: failed,
+    tasks_in_progress: inProgress,
+    completion_rate: Math.round(completionRate * 1000) / 1000,
+    avg_completion_minutes: avgTime?.avg_minutes != null ? Math.round(avgTime.avg_minutes * 10) / 10 : null,
+    avg_confidence: avgConf?.avg_confidence != null ? Math.round(avgConf.avg_confidence * 1000) / 1000 : null,
+    review_score_avg: reviewScoreAvg != null ? Math.round(reviewScoreAvg * 1000) / 1000 : null,
+    composite_score: Math.round(compositeScore * 1000) / 1000
+  };
+}
+function getLeaderboard(opts, db) {
+  const d = db || getDatabase();
+  const agents = d.query("SELECT id FROM agents ORDER BY name").all();
+  const entries = [];
+  for (const agent of agents) {
+    const metrics = getAgentMetrics(agent.id, { project_id: opts?.project_id }, d);
+    if (metrics && (metrics.tasks_completed > 0 || metrics.tasks_failed > 0 || metrics.tasks_in_progress > 0)) {
+      entries.push(metrics);
+    }
+  }
+  entries.sort((a, b) => b.composite_score - a.composite_score);
+  const limit = opts?.limit || 20;
+  return entries.slice(0, limit).map((entry, idx) => ({
+    ...entry,
+    rank: idx + 1
+  }));
+}
+function scoreTask(taskId, score, reviewerId, db) {
+  const d = db || getDatabase();
+  if (score < 0 || score > 1)
+    throw new Error("Score must be between 0 and 1");
+  const task = d.query("SELECT metadata FROM tasks WHERE id = ?").get(taskId);
+  if (!task)
+    throw new Error(`Task not found: ${taskId}`);
+  const metadata = JSON.parse(task.metadata || "{}");
+  metadata._review_score = score;
+  if (reviewerId)
+    metadata._reviewed_by = reviewerId;
+  metadata._reviewed_at = now();
+  d.run("UPDATE tasks SET metadata = ?, updated_at = ? WHERE id = ?", [JSON.stringify(metadata), now(), taskId]);
+}
+var init_agent_metrics = __esm(() => {
+  init_database();
+});
+
+// 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
 });
-function getAgentMetrics(agentId, opts, db) {
-  const d = db || getDatabase();
-  const agent = d.query("SELECT id, name FROM agents WHERE id = ? OR LOWER(name) = LOWER(?)").get(agentId, agentId);
-  if (!agent)
-    return null;
-  let projectFilter = "";
-  const params = [agent.id, agent.id];
-  if (opts?.project_id) {
-    projectFilter = " AND project_id = ?";
-    params.push(opts.project_id);
-  }
-  const completed = d.query(`SELECT COUNT(*) as count FROM tasks WHERE (agent_id = ? OR assigned_to = ?) AND status = 'completed'${projectFilter}`).get(...params).count;
-  const failed = d.query(`SELECT COUNT(*) as count FROM tasks WHERE (agent_id = ? OR assigned_to = ?) AND status = 'failed'${projectFilter}`).get(...params).count;
-  const inProgress = d.query(`SELECT COUNT(*) as count FROM tasks WHERE (agent_id = ? OR assigned_to = ?) AND status = 'in_progress'${projectFilter}`).get(...params).count;
-  const total = completed + failed;
-  const completionRate = total > 0 ? completed / total : 0;
-  const avgTime = d.query(`SELECT AVG(
-       (julianday(completed_at) - julianday(created_at)) * 24 * 60
-     ) as avg_minutes
-     FROM tasks
-     WHERE (agent_id = ? OR assigned_to = ?) AND status = 'completed' AND completed_at IS NOT NULL${projectFilter}`).get(...params);
-  const avgConf = d.query(`SELECT AVG(confidence) as avg_confidence
-     FROM tasks
-     WHERE (agent_id = ? OR assigned_to = ?) AND status = 'completed' AND confidence IS NOT NULL${projectFilter}`).get(...params);
-  const reviewTasks = d.query(`SELECT metadata FROM tasks
-     WHERE (agent_id = ? OR assigned_to = ?) AND status = 'completed'${projectFilter}
-       AND metadata LIKE '%_review_score%'`).all(...params);
-  let reviewScoreAvg = null;
-  if (reviewTasks.length > 0) {
-    let total2 = 0;
-    let count = 0;
-    for (const row of reviewTasks) {
-      try {
-        const meta = JSON.parse(row.metadata);
-        if (typeof meta._review_score === "number") {
-          total2 += meta._review_score;
-          count++;
-        }
-      } catch {}
-    }
-    if (count > 0)
-      reviewScoreAvg = total2 / count;
-  }
-  const speedScore = avgTime?.avg_minutes != null ? Math.max(0, 1 - avgTime.avg_minutes / (60 * 24)) : 0.5;
-  const confidenceScore = avgConf?.avg_confidence ?? 0.5;
-  const volumeScore = Math.min(1, completed / 50);
-  const compositeScore = completionRate * 0.3 + speedScore * 0.2 + confidenceScore * 0.3 + volumeScore * 0.2;
-  return {
-    agent_id: agent.id,
-    agent_name: agent.name,
-    tasks_completed: completed,
-    tasks_failed: failed,
-    tasks_in_progress: inProgress,
-    completion_rate: Math.round(completionRate * 1000) / 1000,
-    avg_completion_minutes: avgTime?.avg_minutes != null ? Math.round(avgTime.avg_minutes * 10) / 10 : null,
-    avg_confidence: avgConf?.avg_confidence != null ? Math.round(avgConf.avg_confidence * 1000) / 1000 : null,
-    review_score_avg: reviewScoreAvg != null ? Math.round(reviewScoreAvg * 1000) / 1000 : null,
-    composite_score: Math.round(compositeScore * 1000) / 1000
+async function applyPgMigrations(connectionString) {
+  const pg = new PgAdapterAsync(connectionString);
+  const result = {
+    applied: [],
+    alreadyApplied: [],
+    errors: [],
+    totalMigrations: PG_MIGRATIONS.length
   };
-}
-function getLeaderboard(opts, db) {
-  const d = db || getDatabase();
-  const agents = d.query("SELECT id FROM agents ORDER BY name").all();
-  const entries = [];
-  for (const agent of agents) {
-    const metrics = getAgentMetrics(agent.id, { project_id: opts?.project_id }, d);
-    if (metrics && (metrics.tasks_completed > 0 || metrics.tasks_failed > 0 || metrics.tasks_in_progress > 0)) {
-      entries.push(metrics);
+  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;
+      }
+      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;
+      }
     }
+  } finally {
+    await pg.close();
   }
-  entries.sort((a, b) => b.composite_score - a.composite_score);
-  const limit = opts?.limit || 20;
-  return entries.slice(0, limit).map((entry, idx) => ({
-    ...entry,
-    rank: idx + 1
-  }));
-}
-function scoreTask(taskId, score, reviewerId, db) {
-  const d = db || getDatabase();
-  if (score < 0 || score > 1)
-    throw new Error("Score must be between 0 and 1");
-  const task = d.query("SELECT metadata FROM tasks WHERE id = ?").get(taskId);
-  if (!task)
-    throw new Error(`Task not found: ${taskId}`);
-  const metadata = JSON.parse(task.metadata || "{}");
-  metadata._review_score = score;
-  if (reviewerId)
-    metadata._reviewed_by = reviewerId;
-  metadata._reviewed_at = now();
-  d.run("UPDATE tasks SET metadata = ?, updated_at = ? WHERE id = ?", [JSON.stringify(metadata), now(), taskId]);
+  return result;
 }
-var init_agent_metrics = __esm(() => {
-  init_database();
+var init_pg_migrate = __esm(() => {
+  init_dist();
+  init_pg_migrations();
 });
 
 // src/mcp/index.ts
@@ -21156,11 +22997,11 @@ __export(exports_mcp, {
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { readFileSync as readFileSync6 } from "fs";
-import { join as join10, dirname as dirname2 } from "path";
+import { join as join10, dirname as dirname3 } from "path";
 import { fileURLToPath } from "url";
 function getMcpVersion() {
   try {
-    const __dir = dirname2(fileURLToPath(import.meta.url));
+    const __dir = dirname3(fileURLToPath(import.meta.url));
     const pkgPath = join10(__dir, "..", "package.json");
     return JSON.parse(readFileSync6(pkgPath, "utf-8")).version || "0.0.0";
   } catch {
@@ -21357,6 +23198,7 @@ var init_mcp = __esm(() => {
     "list_templates",
     "create_task_from_template",
     "delete_template",
+    "update_template",
     "approve_task"
   ]);
   agentFocusMap = new Map;
@@ -23039,7 +24881,8 @@ ${text}` }] };
     }, 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,
@@ -23058,13 +24901,37 @@ ${task.id.slice(0, 8)} | ${task.priority} | ${task.title}` }] };
     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(),
@@ -24181,6 +26048,7 @@ ${stack_trace.slice(0, 1500)}
         "list_templates",
         "create_task_from_template",
         "delete_template",
+        "update_template",
         "bulk_update_tasks",
         "bulk_create_tasks",
         "get_task_stats",
@@ -24417,6 +26285,9 @@ ${stack_trace.slice(0, 1500)}
         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'}`,
@@ -25227,6 +27098,49 @@ ${taskLines.join(`
     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");
   main().catch((err) => {
     console.error("MCP server error:", err);
@@ -25305,17 +27219,17 @@ __export(exports_serve, {
   startServer: () => startServer
 });
 import { existsSync as existsSync9 } from "fs";
-import { join as join11, dirname as dirname3, extname, resolve as resolve3, sep } from "path";
+import { join as join11, dirname as dirname4, extname, resolve as resolve3, sep } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function resolveDashboardDir() {
   const candidates = [];
   try {
-    const scriptDir = dirname3(fileURLToPath2(import.meta.url));
+    const scriptDir = dirname4(fileURLToPath2(import.meta.url));
     candidates.push(join11(scriptDir, "..", "dashboard", "dist"));
     candidates.push(join11(scriptDir, "..", "..", "dashboard", "dist"));
   } catch {}
   if (process.argv[1]) {
-    const mainDir = dirname3(process.argv[1]);
+    const mainDir = dirname4(process.argv[1]);
     candidates.push(join11(mainDir, "..", "dashboard", "dist"));
     candidates.push(join11(mainDir, "..", "..", "dashboard", "dist"));
   }
@@ -27560,7 +29474,7 @@ init_config();
 import chalk2 from "chalk";
 import { execSync as execSync2 } from "child_process";
 import { existsSync as existsSync10, mkdirSync as mkdirSync6, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
-import { basename, dirname as dirname4, join as join12, resolve as resolve4 } from "path";
+import { basename, dirname as dirname5, join as join12, resolve as resolve4 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/cli/brains.ts
@@ -27883,7 +29797,7 @@ function makeBrainsCommand() {
 // src/cli/index.tsx
 function getPackageVersion() {
   try {
-    const pkgPath = join12(dirname4(fileURLToPath3(import.meta.url)), "..", "..", "package.json");
+    const pkgPath = join12(dirname5(fileURLToPath3(import.meta.url)), "..", "..", "package.json");
     return JSON.parse(readFileSync7(pkgPath, "utf-8")).version || "0.0.0";
   } catch {
     return "0.0.0";
@@ -28694,9 +30608,9 @@ program2.command("plans").description("List and manage plans").option("--add <na
     console.log(`${chalk2.dim(p.id.slice(0, 8))} ${chalk2.bold(p.name)} ${chalk2.cyan(`[${p.status}]`)}${desc}`);
   }
 });
-program2.command("templates").description("List and manage task templates").option("--add <name>", "Create a template").option("--title <pattern>", "Title pattern (with --add)").option("-d, --description <text>", "Default description").option("-p, --priority <level>", "Default priority").option("-t, --tags <tags>", "Default tags (comma-separated)").option("--delete <id>", "Delete a template").option("--use <id>", "Create a task from a template").action((opts) => {
+program2.command("templates").description("List and manage task templates").option("--add <name>", "Create a template").option("--title <pattern>", "Title pattern (with --add)").option("-d, --description <text>", "Default description").option("-p, --priority <level>", "Default priority").option("-t, --tags <tags>", "Default tags (comma-separated)").option("--delete <id>", "Delete a template").option("--update <id>", "Update a template").option("--use <id>", "Create a task from a template").action((opts) => {
   const globalOpts = program2.opts();
-  const { createTemplate: createTemplate2, listTemplates: listTemplates2, deleteTemplate: deleteTemplate2, taskFromTemplate: taskFromTemplate2 } = (init_templates(), __toCommonJS(exports_templates));
+  const { createTemplate: createTemplate2, listTemplates: listTemplates2, deleteTemplate: deleteTemplate2, updateTemplate: updateTemplate2, taskFromTemplate: taskFromTemplate2 } = (init_templates(), __toCommonJS(exports_templates));
   if (opts.add) {
     if (!opts.title) {
       console.error(chalk2.red("--title is required with --add"));
@@ -28730,6 +30644,30 @@ program2.command("templates").description("List and manage task templates").opti
     }
     return;
   }
+  if (opts.update) {
+    const updates = {};
+    if (opts.add)
+      updates.name = opts.add;
+    if (opts.title)
+      updates.title_pattern = opts.title;
+    if (opts.description)
+      updates.description = opts.description;
+    if (opts.priority)
+      updates.priority = opts.priority;
+    if (opts.tags)
+      updates.tags = opts.tags.split(",").map((t) => t.trim());
+    const updated = updateTemplate2(opts.update, updates);
+    if (!updated) {
+      console.error(chalk2.red("Template not found."));
+      process.exit(1);
+    }
+    if (globalOpts.json) {
+      output(updated, true);
+    } else {
+      console.log(chalk2.green(`Template updated: ${updated.id.slice(0, 8)} | ${updated.name} | "${updated.title_pattern}"`));
+    }
+    return;
+  }
   if (opts.use) {
     try {
       const input = taskFromTemplate2(opts.use, {
@@ -29111,7 +31049,7 @@ function readJsonFile2(path) {
   }
 }
 function writeJsonFile2(path, data) {
-  const dir = dirname4(path);
+  const dir = dirname5(path);
   if (!existsSync10(dir))
     mkdirSync6(dir, { recursive: true });
   writeFileSync6(path, JSON.stringify(data, null, 2) + `
@@ -29123,7 +31061,7 @@ function readTomlFile(path) {
   return readFileSync7(path, "utf-8");
 }
 function writeTomlFile(path, content) {
-  const dir = dirname4(path);
+  const dir = dirname5(path);
   if (!existsSync10(dir))
     mkdirSync6(dir, { recursive: true });
   writeFileSync6(path, content);
@@ -29740,7 +31678,7 @@ program2.command("config").description("View or update configuration").option("-
       obj = obj[keys[i]];
     }
     obj[keys[keys.length - 1]] = parsedValue;
-    const dir = dirname4(configPath);
+    const dir = dirname5(configPath);
     if (!existsSync10(dir))
       mkdirSync6(dir, { recursive: true });
     writeFileSync6(configPath, JSON.stringify(config2, null, 2));
@@ -31122,4 +33060,57 @@ program2.action(async () => {
   }
 });
 program2.addCommand(makeBrainsCommand());
+var dbCmd = program2.command("db").description("Database management commands");
+dbCmd.command("migrate-pg").description("Apply PostgreSQL migrations to the configured RDS instance").option("--connection-string <url>", "PostgreSQL connection string (overrides cloud config)").option("--json", "Output as JSON").action(async (opts) => {
+  const globalOpts = program2.opts();
+  const useJson = opts.json || globalOpts.json;
+  let connStr;
+  if (opts.connectionString) {
+    connStr = opts.connectionString;
+  } else {
+    try {
+      const { getConnectionString: getConnectionString2 } = await Promise.resolve().then(() => (init_dist(), exports_dist));
+      connStr = getConnectionString2("todos");
+    } catch (e) {
+      const msg = "Cloud RDS not configured. Use --connection-string or run `cloud setup`.";
+      if (useJson) {
+        console.log(JSON.stringify({ error: msg }));
+      } else {
+        console.error(chalk2.red(msg));
+      }
+      process.exit(1);
+    }
+  }
+  try {
+    const { applyPgMigrations: applyPgMigrations2 } = await Promise.resolve().then(() => (init_pg_migrate(), exports_pg_migrate));
+    const result = await applyPgMigrations2(connStr);
+    if (useJson) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    if (result.applied.length > 0) {
+      console.log(chalk2.green(`Applied ${result.applied.length} migration(s): ${result.applied.join(", ")}`));
+    }
+    if (result.alreadyApplied.length > 0) {
+      console.log(chalk2.dim(`Already applied: ${result.alreadyApplied.length} migration(s)`));
+    }
+    if (result.errors.length > 0) {
+      for (const err of result.errors) {
+        console.error(chalk2.red(`  Error: ${err}`));
+      }
+      process.exit(1);
+    }
+    if (result.applied.length === 0 && result.errors.length === 0) {
+      console.log(chalk2.dim("Schema is up to date."));
+    }
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    if (useJson) {
+      console.log(JSON.stringify({ error: msg }));
+    } else {
+      console.error(chalk2.red(`Migration failed: ${msg}`));
+    }
+    process.exit(1);
+  }
+});
 program2.parse();