@hasna/conversations 0.2.24 → 0.2.26

package/bin/mcp.js

@@ -6537,6 +6537,75 @@ var require_dist = __commonJS((exports, module) => {
 });
 
 // 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,
+  migrateService: () => migrateService,
+  migrateDotfile: () => migrateDotfile,
+  migrateAllServices: () => migrateAllServices,
+  listSqliteTables: () => listSqliteTables,
+  listPgTables: () => listPgTables,
+  listFeedback: () => listFeedback,
+  listConflicts: () => listConflicts,
+  isSyncExcludedTable: () => isSyncExcludedTable,
+  incrementalSyncPush: () => incrementalSyncPush,
+  incrementalSyncPull: () => incrementalSyncPull,
+  hasLegacyDotfile: () => hasLegacyDotfile,
+  getWinningData: () => getWinningData,
+  getSyncScheduleStatus: () => getSyncScheduleStatus,
+  getSyncMetaForTable: () => getSyncMetaForTable,
+  getSyncMetaAll: () => getSyncMetaAll,
+  getServiceDbPath: () => getServiceDbPath,
+  getHasnaDir: () => getHasnaDir,
+  getDbPath: () => getDbPath,
+  getDataDir: () => getDataDir,
+  getConnectionString: () => getConnectionString,
+  getConflict: () => getConflict,
+  getConfigPath: () => getConfigPath,
+  getConfigDir: () => getConfigDir,
+  getCloudConfig: () => getCloudConfig,
+  getAutoSyncConfig: () => getAutoSyncConfig,
+  ensureSyncMetaTable: () => ensureSyncMetaTable,
+  ensurePgDatabase: () => ensurePgDatabase,
+  ensureFeedbackTable: () => ensureFeedbackTable,
+  ensureConflictsTable: () => ensureConflictsTable,
+  ensureAllPgDatabases: () => ensureAllPgDatabases,
+  enableAutoSync: () => enableAutoSync,
+  discoverSyncableServicesV2: () => discoverSyncableServices,
+  discoverSyncableServices: () => discoverSyncableServices2,
+  discoverServices: () => discoverServices,
+  detectConflicts: () => detectConflicts,
+  createDatabase: () => createDatabase,
+  applyPgMigrations: () => applyPgMigrations,
+  SyncProgressTracker: () => SyncProgressTracker,
+  SqliteAdapter: () => SqliteAdapter,
+  SYNC_EXCLUDED_TABLE_PATTERNS: () => SYNC_EXCLUDED_TABLE_PATTERNS,
+  PgAdapterAsync: () => PgAdapterAsync,
+  PgAdapter: () => PgAdapter,
+  KNOWN_PG_SERVICES: () => KNOWN_PG_SERVICES,
+  CloudConfigSchema: () => CloudConfigSchema
+});
 import { createRequire } from "module";
 import { Database } from "bun:sqlite";
 import {
@@ -6554,9 +6623,13 @@ import { readdirSync as readdirSync2, existsSync as existsSync3 } from "fs";
 import { join as join3 } from "path";
 import { homedir as homedir3 } from "os";
 import { hostname as hostname3 } from "os";
+import { existsSync as existsSync4, readFileSync as readFileSync2 } from "fs";
 import { homedir as homedir4 } from "os";
 import { join as join4 } from "path";
+import { existsSync as existsSync5, readdirSync as readdirSync3 } from "fs";
+import { join as join5 } from "path";
 import { join as join6, dirname } from "path";
+import { existsSync as existsSync6, writeFileSync as writeFileSync2, unlinkSync, mkdirSync as mkdirSync3 } from "fs";
 import { homedir as homedir5, platform } from "os";
 function __accessProp2(key) {
   return this[key];
@@ -6611,6 +6684,17 @@ function sqliteToPostgres(sql) {
   }
   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;
@@ -7436,6 +7520,39 @@ function getDbPath(serviceName) {
   const dir = getDataDir(serviceName);
   return join(dir, `${serviceName}.db`);
 }
+function migrateDotfile(serviceName) {
+  const legacyDir = join(homedir(), `.${serviceName}`);
+  const newDir = join(HASNA_DIR, serviceName);
+  if (!existsSync(legacyDir))
+    return [];
+  if (existsSync(newDir))
+    return [];
+  mkdirSync(newDir, { recursive: true });
+  const migrated = [];
+  copyDirRecursive(legacyDir, newDir, legacyDir, migrated);
+  return migrated;
+}
+function copyDirRecursive(src, dest, root, migrated) {
+  const entries = readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = join(src, entry.name);
+    const destPath = join(dest, entry.name);
+    if (entry.isDirectory()) {
+      mkdirSync(destPath, { recursive: true });
+      copyDirRecursive(srcPath, destPath, root, migrated);
+    } else {
+      copyFileSync(srcPath, destPath);
+      migrated.push(relative(root, srcPath));
+    }
+  }
+}
+function hasLegacyDotfile(serviceName) {
+  return existsSync(join(homedir(), `.${serviceName}`));
+}
+function getHasnaDir() {
+  mkdirSync(HASNA_DIR, { recursive: true });
+  return HASNA_DIR;
+}
 function getConfigDir() {
   return CONFIG_DIR;
 }
@@ -8008,6 +8125,10 @@ async function sendFeedback(feedback, db) {
     return { sent: false, id, error: errorMsg };
   }
 }
+function listFeedback(db) {
+  ensureFeedbackTable(db);
+  return db.all(`SELECT id, service, version, message, email, machine_id, created_at FROM feedback ORDER BY created_at DESC`);
+}
 
 class SyncProgressTracker {
   db;
@@ -8128,6 +8249,847 @@ class SyncProgressTracker {
     }
   }
 }
+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 resolved;
+  });
+}
+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)`;
+    }
+  }
+  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, meta3) {
+  ensureSyncMetaTable(db);
+  const existing = db.get(`SELECT table_name FROM _sync_meta WHERE table_name = ?`, meta3.table_name);
+  if (existing) {
+    db.run(`UPDATE _sync_meta SET last_synced_at = ?, last_synced_row_count = ?, direction = ? WHERE table_name = ?`, meta3.last_synced_at, meta3.last_synced_row_count, meta3.direction, meta3.table_name);
+  } else {
+    db.run(`INSERT INTO _sync_meta (table_name, last_synced_at, last_synced_row_count, direction) VALUES (?, ?, ?, ?)`, meta3.table_name, meta3.last_synced_at, meta3.last_synced_row_count, meta3.direction);
+  }
+}
+function transferRows(source, target, table, rows, options) {
+  const { primaryKey = "id", conflictColumn = "updated_at" } = options;
+  let written = 0;
+  let skipped = 0;
+  const errors22 = [];
+  if (rows.length === 0)
+    return { written, skipped, errors: errors22 };
+  const columns = Object.keys(rows[0]);
+  const hasConflictCol = columns.includes(conflictColumn);
+  const hasPrimaryKey = columns.includes(primaryKey);
+  if (!hasPrimaryKey) {
+    errors22.push(`Table "${table}" has no "${primaryKey}" column -- skipping`);
+    return { written, skipped, errors: errors22 };
+  }
+  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) {
+      errors22.push(`Row ${row[primaryKey]}: ${err?.message ?? String(err)}`);
+    }
+  }
+  return { written, skipped, errors: errors22 };
+}
+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 meta3 = getSyncMeta(local, table);
+      let rows;
+      if (meta3?.last_synced_at) {
+        try {
+          rows = local.all(`SELECT * FROM "${table}" WHERE "${conflictColumn}" > ?`, meta3.last_synced_at);
+        } catch {
+          rows = local.all(`SELECT * FROM "${table}"`);
+          stat.first_sync = true;
+        }
+      } else {
+        rows = local.all(`SELECT * FROM "${table}"`);
+        stat.first_sync = true;
+      }
+      for (let offset = 0;offset < rows.length; offset += batchSize) {
+        const batch = rows.slice(offset, offset + batchSize);
+        const result = transferRows(local, remote, table, batch, options);
+        stat.synced_rows += result.written;
+        stat.skipped_rows += result.skipped;
+        stat.errors.push(...result.errors);
+      }
+      if (rows.length === 0) {
+        stat.skipped_rows = stat.total_rows;
+      }
+      const now = new Date().toISOString();
+      upsertSyncMeta(local, {
+        table_name: table,
+        last_synced_at: now,
+        last_synced_row_count: stat.synced_rows,
+        direction: "push"
+      });
+    } catch (err) {
+      stat.errors.push(`Table "${table}": ${err?.message ?? String(err)}`);
+    }
+    results.push(stat);
+  }
+  return results;
+}
+function incrementalSyncPull(remote, local, tables, options = {}) {
+  const { conflictColumn = "updated_at", batchSize = 500 } = options;
+  const results = [];
+  ensureSyncMetaTable(local);
+  for (const table of tables) {
+    const stat = {
+      table,
+      total_rows: 0,
+      synced_rows: 0,
+      skipped_rows: 0,
+      errors: [],
+      first_sync: false
+    };
+    try {
+      const countResult = remote.get(`SELECT COUNT(*) as cnt FROM "${table}"`);
+      stat.total_rows = countResult?.cnt ?? 0;
+      const meta3 = getSyncMeta(local, table);
+      let rows;
+      if (meta3?.last_synced_at) {
+        try {
+          rows = remote.all(`SELECT * FROM "${table}" WHERE "${conflictColumn}" > ?`, meta3.last_synced_at);
+        } catch {
+          rows = remote.all(`SELECT * FROM "${table}"`);
+          stat.first_sync = true;
+        }
+      } else {
+        rows = remote.all(`SELECT * FROM "${table}"`);
+        stat.first_sync = true;
+      }
+      for (let offset = 0;offset < rows.length; offset += batchSize) {
+        const batch = rows.slice(offset, offset + batchSize);
+        const result = transferRows(remote, local, table, batch, options);
+        stat.synced_rows += result.written;
+        stat.skipped_rows += result.skipped;
+        stat.errors.push(...result.errors);
+      }
+      if (rows.length === 0) {
+        stat.skipped_rows = stat.total_rows;
+      }
+      const now = new Date().toISOString();
+      upsertSyncMeta(local, {
+        table_name: table,
+        last_synced_at: now,
+        last_synced_row_count: stat.synced_rows,
+        direction: "pull"
+      });
+    } catch (err) {
+      stat.errors.push(`Table "${table}": ${err?.message ?? String(err)}`);
+    }
+    results.push(stat);
+  }
+  return results;
+}
+function getSyncMetaAll(db) {
+  ensureSyncMetaTable(db);
+  return db.all(`SELECT table_name, last_synced_at, last_synced_row_count, direction FROM _sync_meta ORDER BY table_name`);
+}
+function getSyncMetaForTable(db, table) {
+  return getSyncMeta(db, table);
+}
+function resetSyncMeta(db, table) {
+  ensureSyncMetaTable(db);
+  db.run(`DELETE FROM _sync_meta WHERE table_name = ?`, table);
+}
+function resetAllSyncMeta(db) {
+  ensureSyncMetaTable(db);
+  db.run(`DELETE FROM _sync_meta`);
+}
+function getAutoSyncConfig() {
+  try {
+    if (!existsSync4(AUTO_SYNC_CONFIG_PATH)) {
+      return { ...DEFAULT_AUTO_SYNC_CONFIG };
+    }
+    const raw = JSON.parse(readFileSync2(AUTO_SYNC_CONFIG_PATH, "utf-8"));
+    return {
+      auto_sync_on_start: typeof raw.auto_sync_on_start === "boolean" ? raw.auto_sync_on_start : DEFAULT_AUTO_SYNC_CONFIG.auto_sync_on_start,
+      auto_sync_on_stop: typeof raw.auto_sync_on_stop === "boolean" ? raw.auto_sync_on_stop : DEFAULT_AUTO_SYNC_CONFIG.auto_sync_on_stop
+    };
+  } catch {
+    return { ...DEFAULT_AUTO_SYNC_CONFIG };
+  }
+}
+async function executeAutoSync(event, serviceName, local, tables) {
+  const direction = event === "start" ? "pull" : "push";
+  const result = {
+    event,
+    direction,
+    success: false,
+    tables_synced: 0,
+    total_rows_synced: 0,
+    errors: []
+  };
+  let remote = null;
+  try {
+    const connStr = getConnectionString(serviceName);
+    remote = new PgAdapterAsync(connStr);
+    const syncTables = tables.length > 0 ? tables.filter((t) => !isSyncExcludedTable(t)) : direction === "push" ? listSqliteTables(local).filter((t) => !isSyncExcludedTable(t)) : (await listPgTables(remote)).filter((t) => !isSyncExcludedTable(t));
+    if (syncTables.length === 0) {
+      result.success = true;
+      return result;
+    }
+    const results = direction === "pull" ? await syncPull(remote, local, { tables: syncTables }) : await syncPush(local, remote, { tables: syncTables });
+    for (const r of results) {
+      if (r.errors.length === 0)
+        result.tables_synced++;
+      result.total_rows_synced += r.rowsWritten;
+      result.errors.push(...r.errors);
+    }
+    result.success = result.errors.length === 0;
+  } catch (err) {
+    result.errors.push(err?.message ?? String(err));
+  } finally {
+    if (remote) {
+      try {
+        await remote.close();
+      } catch {}
+    }
+  }
+  return result;
+}
+function installSignalHandlers() {
+  if (signalHandlersInstalled)
+    return;
+  signalHandlersInstalled = true;
+  const handleExit = async () => {
+    for (const fn of cleanupHandlers) {
+      try {
+        await fn();
+      } catch {}
+    }
+  };
+  process.on("SIGTERM", async () => {
+    await handleExit();
+    process.exit(0);
+  });
+  process.on("SIGINT", async () => {
+    await handleExit();
+    process.exit(0);
+  });
+  process.on("beforeExit", async () => {
+    await handleExit();
+  });
+}
+function setupAutoSync(serviceName, server, local, remote, tables) {
+  const config2 = getAutoSyncConfig();
+  const cloudConfig = getCloudConfig();
+  const isSyncEnabled = cloudConfig.mode === "hybrid" || cloudConfig.mode === "cloud";
+  const syncOnStart = async () => {
+    if (!config2.auto_sync_on_start || !isSyncEnabled)
+      return null;
+    return executeAutoSync("start", serviceName, local, tables);
+  };
+  const syncOnStop = async () => {
+    if (!config2.auto_sync_on_stop || !isSyncEnabled)
+      return null;
+    return executeAutoSync("stop", serviceName, local, tables);
+  };
+  if (server && typeof server.onconnect === "function") {
+    const origOnConnect = server.onconnect;
+    server.onconnect = async (...args) => {
+      await 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 = async (...args) => {
+      await syncOnStop();
+      return origOnDisconnect.apply(server, args);
+    };
+  } else if (server && typeof server.on === "function") {
+    server.on("disconnect", () => syncOnStop());
+  }
+  installSignalHandlers();
+  cleanupHandlers.push(async () => {
+    await syncOnStop();
+  });
+  return { syncOnStart, syncOnStop, config: config2 };
+}
+function enableAutoSync(serviceName, mcpServer, local, remote, tables) {
+  setupAutoSync(serviceName, mcpServer, local, remote, tables);
+}
+function discoverSyncableServices2() {
+  const hasnaDir = getHasnaDir();
+  const services = [];
+  try {
+    const entries = readdirSync3(hasnaDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory())
+        continue;
+      const dbPath = join5(hasnaDir, entry.name, `${entry.name}.db`);
+      if (existsSync5(dbPath)) {
+        services.push(entry.name);
+      }
+    }
+  } catch {}
+  return services;
+}
+async function runScheduledSync() {
+  const config2 = getCloudConfig();
+  if (config2.mode === "local")
+    return [];
+  const services = discoverSyncableServices2();
+  const results = [];
+  let remote = null;
+  for (const service of services) {
+    const result = {
+      service,
+      tables_synced: 0,
+      total_rows_synced: 0,
+      errors: []
+    };
+    try {
+      const dbPath = join5(getDataDir(service), `${service}.db`);
+      if (!existsSync5(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 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} * * * *`;
+}
+function getWorkerPath() {
+  const dir = typeof import.meta.dir === "string" ? import.meta.dir : dirname(import.meta.url.replace("file://", ""));
+  const tsPath = join6(dir, "scheduled-sync.ts");
+  const jsPath = join6(dir, "scheduled-sync.js");
+  try {
+    if (existsSync6(tsPath))
+      return tsPath;
+  } catch {}
+  return jsPath;
+}
+function getBunPath() {
+  const candidates = [
+    join6(homedir5(), ".bun", "bin", "bun"),
+    "/usr/local/bin/bun",
+    "/usr/bin/bun"
+  ];
+  for (const p of candidates) {
+    if (existsSync6(p))
+      return p;
+  }
+  return "bun";
+}
+function getLaunchdPlistPath() {
+  return join6(homedir5(), "Library", "LaunchAgents", `com.hasna.cloud-sync.plist`);
+}
+function createLaunchdPlist(intervalMinutes) {
+  const workerPath = getWorkerPath();
+  const bunPath = getBunPath();
+  const logPath = join6(CONFIG_DIR2, "sync.log");
+  const errorLogPath = join6(CONFIG_DIR2, "sync-error.log");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>com.hasna.cloud-sync</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${bunPath}</string>
+    <string>run</string>
+    <string>${workerPath}</string>
+  </array>
+  <key>StartInterval</key>
+  <integer>${intervalMinutes * 60}</integer>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${logPath}</string>
+  <key>StandardErrorPath</key>
+  <string>${errorLogPath}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>${process.env.PATH || "/usr/local/bin:/usr/bin:/bin"}</string>
+    <key>HOME</key>
+    <string>${homedir5()}</string>
+  </dict>
+</dict>
+</plist>`;
+}
+async function registerLaunchd(intervalMinutes) {
+  const plistPath = getLaunchdPlistPath();
+  const plistDir = dirname(plistPath);
+  mkdirSync3(plistDir, { recursive: true });
+  try {
+    await Bun.spawn(["launchctl", "unload", plistPath]).exited;
+  } catch {}
+  writeFileSync2(plistPath, createLaunchdPlist(intervalMinutes));
+  await Bun.spawn(["launchctl", "load", plistPath]).exited;
+}
+async function removeLaunchd() {
+  const plistPath = getLaunchdPlistPath();
+  try {
+    await Bun.spawn(["launchctl", "unload", plistPath]).exited;
+  } catch {}
+  try {
+    unlinkSync(plistPath);
+  } catch {}
+}
+function getSystemdDir() {
+  return join6(homedir5(), ".config", "systemd", "user");
+}
+function createSystemdService() {
+  const workerPath = getWorkerPath();
+  const bunPath = getBunPath();
+  return `[Unit]
+Description=Hasna Cloud Sync
+After=network.target
+
+[Service]
+Type=oneshot
+ExecStart=${bunPath} run ${workerPath}
+Environment=HOME=${homedir5()}
+Environment=PATH=${process.env.PATH || "/usr/local/bin:/usr/bin:/bin"}
+
+[Install]
+WantedBy=default.target
+`;
+}
+function createSystemdTimer(intervalMinutes) {
+  return `[Unit]
+Description=Hasna Cloud Sync Timer
+
+[Timer]
+OnBootSec=${intervalMinutes}min
+OnUnitActiveSec=${intervalMinutes}min
+Persistent=true
+
+[Install]
+WantedBy=timers.target
+`;
+}
+async function registerSystemd(intervalMinutes) {
+  const dir = getSystemdDir();
+  mkdirSync3(dir, { recursive: true });
+  writeFileSync2(join6(dir, `${SERVICE_NAME}.service`), createSystemdService());
+  writeFileSync2(join6(dir, `${SERVICE_NAME}.timer`), createSystemdTimer(intervalMinutes));
+  await Bun.spawn(["systemctl", "--user", "daemon-reload"]).exited;
+  await Bun.spawn(["systemctl", "--user", "enable", "--now", `${SERVICE_NAME}.timer`]).exited;
+}
+async function removeSystemd() {
+  try {
+    await Bun.spawn(["systemctl", "--user", "disable", "--now", `${SERVICE_NAME}.timer`]).exited;
+  } catch {}
+  const dir = getSystemdDir();
+  try {
+    unlinkSync(join6(dir, `${SERVICE_NAME}.service`));
+  } catch {}
+  try {
+    unlinkSync(join6(dir, `${SERVICE_NAME}.timer`));
+  } catch {}
+  try {
+    await Bun.spawn(["systemctl", "--user", "daemon-reload"]).exited;
+  } catch {}
+}
+async function registerSyncSchedule(intervalMinutes) {
+  if (intervalMinutes <= 0) {
+    throw new Error("Interval must be a positive number of minutes.");
+  }
+  mkdirSync3(CONFIG_DIR2, { recursive: true });
+  if (platform() === "darwin") {
+    await registerLaunchd(intervalMinutes);
+  } else {
+    await registerSystemd(intervalMinutes);
+  }
+  const config2 = getCloudConfig();
+  config2.sync.schedule_minutes = intervalMinutes;
+  saveCloudConfig(config2);
+}
+async function removeSyncSchedule() {
+  if (platform() === "darwin") {
+    await removeLaunchd();
+  } else {
+    await removeSystemd();
+  }
+  const config2 = getCloudConfig();
+  config2.sync.schedule_minutes = 0;
+  saveCloudConfig(config2);
+}
+function getSyncScheduleStatus() {
+  const config2 = getCloudConfig();
+  const minutes = config2.sync.schedule_minutes;
+  const registered = minutes > 0;
+  let mechanism = "none";
+  if (registered) {
+    if (platform() === "darwin") {
+      mechanism = existsSync6(getLaunchdPlistPath()) ? "launchd" : "none";
+    } else {
+      mechanism = existsSync6(join6(getSystemdDir(), `${SERVICE_NAME}.timer`)) ? "systemd" : "none";
+    }
+  }
+  return {
+    registered,
+    schedule_minutes: minutes,
+    cron_expression: registered ? minutesToCron(minutes) : null,
+    mechanism
+  };
+}
+async function applyPgMigrations(connectionString, migrations, service = "unknown") {
+  const pg2 = new PgAdapterAsync(connectionString);
+  const result = {
+    service,
+    applied: [],
+    alreadyApplied: [],
+    errors: [],
+    totalMigrations: migrations.length
+  };
+  try {
+    await pg2.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 pg2.all("SELECT version FROM _pg_migrations ORDER BY version");
+    const appliedSet = new Set(applied.map((r) => r.version));
+    for (let i = 0;i < migrations.length; i++) {
+      if (appliedSet.has(i)) {
+        result.alreadyApplied.push(i);
+        continue;
+      }
+      try {
+        await pg2.exec(migrations[i]);
+        await pg2.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 pg2.close();
+  }
+  return result;
+}
+function getServicePackage(service) {
+  return `@hasna/${service}`;
+}
+async function loadServiceMigrations(service) {
+  const pkg = getServicePackage(service);
+  const paths = [
+    `${pkg}/pg-migrations`,
+    `${pkg}/dist/db/pg-migrations.js`,
+    `${pkg}/dist/db/pg-migrations`
+  ];
+  for (const path of paths) {
+    try {
+      const mod = await import(path);
+      if (Array.isArray(mod.PG_MIGRATIONS)) {
+        return mod.PG_MIGRATIONS;
+      }
+      if (mod.default && Array.isArray(mod.default.PG_MIGRATIONS)) {
+        return mod.default.PG_MIGRATIONS;
+      }
+    } catch {}
+  }
+  return null;
+}
+async function migrateService(service, connectionString) {
+  const connStr = connectionString ?? getConnectionString(service);
+  const migrations = await loadServiceMigrations(service);
+  if (!migrations) {
+    return {
+      service,
+      applied: [],
+      alreadyApplied: [],
+      errors: [`No PG migrations found for service "${service}"`],
+      totalMigrations: 0
+    };
+  }
+  return applyPgMigrations(connStr, migrations, service);
+}
+async function migrateAllServices() {
+  const { discoverServices: discoverServices2 } = await Promise.resolve().then(() => (init_discover(), exports_discover));
+  const services = discoverServices2();
+  const results = [];
+  for (const service of services) {
+    try {
+      const result = await migrateService(service);
+      results.push(result);
+    } catch (err) {
+      results.push({
+        service,
+        applied: [],
+        alreadyApplied: [],
+        errors: [err?.message ?? String(err)],
+        totalMigrations: 0
+      });
+    }
+  }
+  return results;
+}
+async function ensurePgDatabase(service) {
+  const config2 = (await Promise.resolve().then(() => (init_config(), exports_config))).getCloudConfig();
+  const { host, port, username, password_env, ssl } = config2.rds;
+  if (!host || !username)
+    return false;
+  const password = process.env[password_env] ?? "";
+  const sslParam = ssl ? "?sslmode=require" : "";
+  const adminConnStr = `postgres://${username}:${encodeURIComponent(password)}@${host}:${port}/postgres${sslParam}`;
+  const pg2 = new PgAdapterAsync(adminConnStr);
+  try {
+    const existing = await pg2.all(`SELECT 1 FROM pg_database WHERE datname = $1`, service);
+    if (existing.length === 0) {
+      await pg2.exec(`CREATE DATABASE "${service}"`);
+      return true;
+    }
+    return false;
+  } finally {
+    await pg2.close();
+  }
+}
+async function ensureAllPgDatabases() {
+  const { discoverServices: discoverServices2 } = await Promise.resolve().then(() => (init_discover(), exports_discover));
+  const services = discoverServices2();
+  const results = [];
+  for (const service of services) {
+    try {
+      const created = await ensurePgDatabase(service);
+      results.push({ service, created });
+    } catch (err) {
+      results.push({ service, created: false, error: err?.message ?? String(err) });
+    }
+  }
+  return results;
+}
 function registerCloudTools(server, serviceName) {
   server.tool(`${serviceName}_cloud_status`, "Show cloud configuration and connection health", {}, async () => {
     const config2 = getCloudConfig();
@@ -8228,6 +9190,85 @@ function registerCloudTools(server, serviceName) {
     };
   });
 }
+function registerCloudCommands(program, serviceName) {
+  const cloudCmd = program.command("cloud").description("Cloud sync and feedback commands");
+  cloudCmd.command("status").description("Show cloud config and connection health").action(async () => {
+    const config2 = getCloudConfig();
+    console.log("Mode:", config2.mode);
+    console.log("RDS Host:", config2.rds.host || "(not configured)");
+    console.log("Service:", serviceName);
+    if (config2.rds.host && config2.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 config2 = getCloudConfig();
+    if (config2.mode === "local") {
+      console.error("Error: mode is 'local'. Run `cloud setup` first.");
+      process.exit(1);
+    }
+    const local = new SqliteAdapter(getDbPath(serviceName));
+    const cloud = new PgAdapterAsync(getConnectionString(serviceName));
+    const tables = opts.tables ? opts.tables.split(",").map((t) => t.trim()) : listSqliteTables(local);
+    const results = await syncPush(local, cloud, {
+      tables,
+      onProgress: (p) => {
+        if (p.phase === "done") {
+          console.log(`  ${p.table}: ${p.rowsWritten} rows pushed`);
+        }
+      }
+    });
+    local.close();
+    await cloud.close();
+    const total = results.reduce((s, r) => s + r.rowsWritten, 0);
+    console.log(`Done. ${total} rows pushed.`);
+  });
+  cloudCmd.command("pull").description("Pull cloud data to local").option("--tables <tables>", "Comma-separated table names").action(async (opts) => {
+    const config2 = getCloudConfig();
+    if (config2.mode === "local") {
+      console.error("Error: mode is 'local'. Run `cloud setup` first.");
+      process.exit(1);
+    }
+    const local = new SqliteAdapter(getDbPath(serviceName));
+    const cloud = new PgAdapterAsync(getConnectionString(serviceName));
+    let tables;
+    if (opts.tables) {
+      tables = opts.tables.split(",").map((t) => t.trim());
+    } else {
+      tables = await listPgTables(cloud);
+    }
+    const results = await syncPull(cloud, local, {
+      tables,
+      onProgress: (p) => {
+        if (p.phase === "done") {
+          console.log(`  ${p.table}: ${p.rowsWritten} rows pulled`);
+        }
+      }
+    });
+    local.close();
+    await cloud.close();
+    const total = results.reduce((s, r) => s + r.rowsWritten, 0);
+    console.log(`Done. ${total} rows pulled.`);
+  });
+  cloudCmd.command("feedback").description("Send feedback").requiredOption("--message <msg>", "Feedback message").option("--email <email>", "Contact email").action(async (opts) => {
+    const db = createDatabase({ service: "cloud" });
+    const result = await sendFeedback({ service: serviceName, message: opts.message, email: opts.email }, db);
+    db.close();
+    if (result.sent) {
+      console.log(`Feedback sent (id: ${result.id})`);
+    } else {
+      console.log(`Feedback saved locally (id: ${result.id}): ${result.error}`);
+    }
+  });
+}
 var __create2, __getProtoOf2, __defProp2, __getOwnPropNames2, __hasOwnProp2, __toESMCache_node2, __toESMCache_esm2, __toESM2 = (mod, isNodeMode, target) => {
   var canCache = mod != null && typeof mod === "object";
   if (canCache) {
@@ -8480,7 +9521,13 @@ CREATE TABLE IF NOT EXISTS feedback (
   email TEXT DEFAULT '',
   machine_id TEXT DEFAULT '',
   created_at TEXT DEFAULT (datetime('now'))
-)`, AUTO_SYNC_CONFIG_PATH, CONFIG_DIR2;
+)`, 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, SERVICE_NAME = "hasna-cloud-sync", CONFIG_DIR2;
 var init_dist = __esm(() => {
   __create2 = Object.create;
   __getProtoOf2 = Object.getPrototypeOf;
@@ -16548,6 +17595,11 @@ See https://www.postgresql.org/docs/current/libpq-ssl.html for libpq SSL mode de
   init_config();
   init_discover();
   AUTO_SYNC_CONFIG_PATH = join4(homedir4(), ".hasna", "cloud", "config.json");
+  DEFAULT_AUTO_SYNC_CONFIG = {
+    auto_sync_on_start: true,
+    auto_sync_on_stop: true
+  };
+  cleanupHandlers = [];
   init_config();
   init_adapter();
   init_dotfile();
@@ -16573,23 +17625,23 @@ __export(exports_db, {
   getDataDir: () => getDataDir2,
   closeDb: () => closeDb
 });
-import { copyFileSync as copyFileSync2, existsSync as existsSync4, mkdirSync as mkdirSync3, readdirSync as readdirSync3, statSync } from "fs";
-import { join as join5, dirname as dirname2 } from "path";
+import { copyFileSync as copyFileSync2, existsSync as existsSync7, mkdirSync as mkdirSync4, readdirSync as readdirSync4, statSync } from "fs";
+import { join as join7, dirname as dirname2 } from "path";
 import { homedir as homedir6 } from "os";
 function getDataDir2() {
   const home = process.env["HOME"] || process.env["USERPROFILE"] || homedir6();
-  const newDir = join5(home, ".hasna", "conversations");
-  const oldDir = join5(home, ".conversations");
-  if (existsSync4(oldDir) && !existsSync4(newDir)) {
-    mkdirSync3(newDir, { recursive: true });
-    for (const file2 of readdirSync3(oldDir)) {
-      const oldPath = join5(oldDir, file2);
+  const newDir = join7(home, ".hasna", "conversations");
+  const oldDir = join7(home, ".conversations");
+  if (existsSync7(oldDir) && !existsSync7(newDir)) {
+    mkdirSync4(newDir, { recursive: true });
+    for (const file2 of readdirSync4(oldDir)) {
+      const oldPath = join7(oldDir, file2);
       if (statSync(oldPath).isFile()) {
-        copyFileSync2(oldPath, join5(newDir, file2));
+        copyFileSync2(oldPath, join7(newDir, file2));
       }
     }
   }
-  mkdirSync3(newDir, { recursive: true });
+  mkdirSync4(newDir, { recursive: true });
   return newDir;
 }
 function getDbPath2() {
@@ -16597,19 +17649,20 @@ function getDbPath2() {
     return process.env.HASNA_CONVERSATIONS_DB_PATH;
   if (process.env.CONVERSATIONS_DB_PATH)
     return process.env.CONVERSATIONS_DB_PATH;
-  return join5(getDataDir2(), "messages.db");
+  return join7(getDataDir2(), "messages.db");
 }
 function getDb() {
   if (db)
     return db;
   const dbPath = getDbPath2();
-  mkdirSync3(dirname2(dbPath), { recursive: true });
+  mkdirSync4(dirname2(dbPath), { recursive: true });
   db = new SqliteAdapter(dbPath);
   db.exec("PRAGMA journal_mode = WAL");
   db.exec("PRAGMA busy_timeout = 5000");
   db.exec(`
     CREATE TABLE IF NOT EXISTS messages (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
+      uuid TEXT NOT NULL DEFAULT (lower(hex(randomblob(16)))),
       session_id TEXT NOT NULL,
       from_agent TEXT NOT NULL,
       to_agent TEXT NOT NULL,
@@ -16629,6 +17682,7 @@ function getDb() {
   db.exec("CREATE INDEX IF NOT EXISTS idx_messages_to ON messages(to_agent)");
   db.exec("CREATE INDEX IF NOT EXISTS idx_messages_created ON messages(created_at)");
   db.exec("CREATE INDEX IF NOT EXISTS idx_messages_space ON messages(space)");
+  db.exec("CREATE UNIQUE INDEX IF NOT EXISTS idx_messages_uuid ON messages(uuid)");
   db.exec(`
     CREATE TABLE IF NOT EXISTS projects (
       id TEXT PRIMARY KEY,
@@ -16776,6 +17830,11 @@ function getDb() {
     db.exec("ALTER TABLE messages ADD COLUMN project_id TEXT");
     db.exec("CREATE INDEX IF NOT EXISTS idx_messages_project ON messages(project_id)");
   }
+  if (!colNames2.includes("uuid")) {
+    db.exec("ALTER TABLE messages ADD COLUMN uuid TEXT");
+    db.exec("UPDATE messages SET uuid = lower(hex(randomblob(16))) WHERE uuid IS NULL");
+    db.exec("CREATE UNIQUE INDEX IF NOT EXISTS idx_messages_uuid ON messages(uuid)");
+  }
   const presenceCols = db.prepare("PRAGMA table_info(agent_presence)").all();
   const presenceColNames = presenceCols.map((c) => c.name);
   if (!presenceColNames.includes("id")) {
@@ -16880,6 +17939,187 @@ var init_db = __esm(() => {
   init_dist();
 });
 
+// src/lib/pg-migrations.ts
+var exports_pg_migrations = {};
+__export(exports_pg_migrations, {
+  PG_MIGRATIONS: () => PG_MIGRATIONS
+});
+var PG_MIGRATIONS;
+var init_pg_migrations = __esm(() => {
+  PG_MIGRATIONS = [
+    `
+  CREATE TABLE IF NOT EXISTS projects (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL UNIQUE,
+    description TEXT,
+    path TEXT,
+    created_by TEXT NOT NULL,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    metadata TEXT,
+    tags TEXT,
+    status TEXT NOT NULL DEFAULT 'active',
+    repository TEXT,
+    settings TEXT
+  );
+  CREATE INDEX IF NOT EXISTS idx_projects_name ON projects(name);
+  CREATE INDEX IF NOT EXISTS idx_projects_status ON projects(status);
+
+  CREATE TABLE IF NOT EXISTS spaces (
+    name TEXT PRIMARY KEY,
+    description TEXT,
+    parent_id TEXT REFERENCES spaces(name),
+    project_id TEXT REFERENCES projects(id),
+    created_by TEXT NOT NULL,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    archived_at TEXT,
+    topic TEXT
+  );
+  CREATE INDEX IF NOT EXISTS idx_spaces_parent ON spaces(parent_id);
+  CREATE INDEX IF NOT EXISTS idx_spaces_project ON spaces(project_id);
+
+  CREATE TABLE IF NOT EXISTS space_members (
+    space TEXT NOT NULL REFERENCES spaces(name),
+    agent TEXT NOT NULL,
+    joined_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    PRIMARY KEY (space, agent)
+  );
+
+  CREATE TABLE IF NOT EXISTS messages (
+    id BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+    uuid TEXT NOT NULL DEFAULT gen_random_uuid()::text UNIQUE,
+    session_id TEXT NOT NULL,
+    from_agent TEXT NOT NULL,
+    to_agent TEXT NOT NULL,
+    space TEXT,
+    project_id TEXT,
+    content TEXT NOT NULL,
+    priority TEXT NOT NULL DEFAULT 'normal',
+    working_dir TEXT,
+    repository TEXT,
+    branch TEXT,
+    metadata TEXT,
+    edited_at TEXT,
+    pinned_at TEXT,
+    blocking BOOLEAN NOT NULL DEFAULT FALSE,
+    attachments TEXT,
+    reply_to BIGINT,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    read_at TEXT
+  );
+  CREATE INDEX IF NOT EXISTS idx_messages_session ON messages(session_id);
+  CREATE INDEX IF NOT EXISTS idx_messages_to ON messages(to_agent);
+  CREATE INDEX IF NOT EXISTS idx_messages_created ON messages(created_at);
+  CREATE INDEX IF NOT EXISTS idx_messages_space ON messages(space);
+  CREATE INDEX IF NOT EXISTS idx_messages_pinned ON messages(pinned_at);
+  CREATE INDEX IF NOT EXISTS idx_messages_blocking ON messages(blocking);
+  CREATE INDEX IF NOT EXISTS idx_messages_reply_to ON messages(reply_to);
+  CREATE INDEX IF NOT EXISTS idx_messages_project ON messages(project_id);
+
+  CREATE TABLE IF NOT EXISTS agent_presence (
+    id TEXT NOT NULL DEFAULT '',
+    agent TEXT PRIMARY KEY,
+    session_id TEXT,
+    role TEXT NOT NULL DEFAULT 'agent',
+    project_id TEXT,
+    status TEXT NOT NULL DEFAULT 'online',
+    last_seen_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    metadata TEXT
+  );
+
+  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 DEFAULT NOW(),
+    expires_at TIMESTAMPTZ NOT NULL,
+    UNIQUE(resource_type, resource_id, lock_type)
+  );
+  CREATE INDEX IF NOT EXISTS idx_locks_resource ON resource_locks(resource_type, resource_id);
+  CREATE INDEX IF NOT EXISTS idx_locks_agent ON resource_locks(agent_id);
+  CREATE INDEX IF NOT EXISTS idx_locks_expires ON resource_locks(expires_at);
+
+  CREATE TABLE IF NOT EXISTS reactions (
+    id BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+    message_id BIGINT NOT NULL REFERENCES messages(id) ON DELETE CASCADE,
+    agent TEXT NOT NULL,
+    emoji TEXT NOT NULL,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    UNIQUE(message_id, agent, emoji)
+  );
+  CREATE INDEX IF NOT EXISTS idx_reactions_message ON reactions(message_id);
+
+  CREATE TABLE IF NOT EXISTS message_read_receipts (
+    message_id BIGINT NOT NULL REFERENCES messages(id) ON DELETE CASCADE,
+    agent TEXT NOT NULL,
+    read_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    PRIMARY KEY (message_id, agent)
+  );
+  CREATE INDEX IF NOT EXISTS idx_read_receipts_message ON message_read_receipts(message_id);
+  CREATE INDEX IF NOT EXISTS idx_read_receipts_agent ON message_read_receipts(agent);
+
+  CREATE TABLE IF NOT EXISTS message_mentions (
+    id BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+    message_id BIGINT NOT NULL REFERENCES messages(id) ON DELETE CASCADE,
+    mentioned_agent TEXT NOT NULL,
+    from_agent TEXT NOT NULL,
+    space TEXT,
+    notified_at TEXT,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+  CREATE INDEX IF NOT EXISTS idx_mentions_agent ON message_mentions(mentioned_agent);
+  CREATE INDEX IF NOT EXISTS idx_mentions_message ON message_mentions(message_id);
+  CREATE INDEX IF NOT EXISTS idx_mentions_notified ON message_mentions(notified_at);
+
+  -- Full-text search using PostgreSQL tsvector
+  ALTER TABLE messages ADD COLUMN IF NOT EXISTS search_vector tsvector;
+  CREATE INDEX IF NOT EXISTS idx_messages_search ON messages USING GIN(search_vector);
+
+  CREATE OR REPLACE FUNCTION messages_search_vector_update() RETURNS trigger AS $$
+  BEGIN
+    NEW.search_vector :=
+      setweight(to_tsvector('english', COALESCE(NEW.content, '')), 'A') ||
+      setweight(to_tsvector('english', COALESCE(NEW.from_agent, '')), 'B') ||
+      setweight(to_tsvector('english', COALESCE(NEW.to_agent, '')), 'B') ||
+      setweight(to_tsvector('english', COALESCE(NEW.space, '')), 'C');
+    RETURN NEW;
+  END;
+  $$ LANGUAGE plpgsql;
+
+  DROP TRIGGER IF EXISTS messages_search_vector_trigger ON messages;
+  CREATE TRIGGER messages_search_vector_trigger
+    BEFORE INSERT OR UPDATE OF content, from_agent, to_agent, space ON messages
+    FOR EACH ROW EXECUTE FUNCTION messages_search_vector_update();
+
+  -- Backfill existing rows
+  UPDATE messages SET search_vector =
+    setweight(to_tsvector('english', COALESCE(content, '')), 'A') ||
+    setweight(to_tsvector('english', COALESCE(from_agent, '')), 'B') ||
+    setweight(to_tsvector('english', COALESCE(to_agent, '')), 'B') ||
+    setweight(to_tsvector('english', COALESCE(space, '')), 'C')
+  WHERE search_vector IS NULL;
+
+  -- Feedback table
+  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()
+  );
+
+  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;
+  `
+  ];
+});
+
 // node_modules/zod/v3/helpers/util.js
 var util;
 (function(util2) {
@@ -38697,9 +39937,6 @@ class StdioServerTransport {
   }
 }
 
-// src/mcp/index.ts
-init_dist();
-
 // src/lib/presence.ts
 init_db();
 var ONLINE_THRESHOLD_SECONDS = 60;
@@ -38832,25 +40069,25 @@ function renameAgent(oldName, newName) {
 // src/lib/messages.ts
 init_db();
 import { randomUUID } from "crypto";
-import { mkdirSync as mkdirSync5, copyFileSync as copyFileSync3, statSync as statSync2 } from "fs";
-import { join as join8 } from "path";
+import { mkdirSync as mkdirSync6, copyFileSync as copyFileSync3, statSync as statSync2 } from "fs";
+import { join as join10 } from "path";
 
 // src/lib/webhooks.ts
 init_db();
-import { readFileSync as readFileSync2 } from "fs";
-import { join as join7 } from "path";
+import { readFileSync as readFileSync3 } from "fs";
+import { join as join9 } from "path";
 var cachedConfig = null;
 var configLoadedAt = 0;
 var CONFIG_CACHE_MS = 1e4;
 function getConfigPath2() {
-  return process.env.CONVERSATIONS_CONFIG_PATH || join7(getDataDir2(), "config.json");
+  return process.env.CONVERSATIONS_CONFIG_PATH || join9(getDataDir2(), "config.json");
 }
 function loadConfig() {
   const now = Date.now();
   if (cachedConfig && now - configLoadedAt < CONFIG_CACHE_MS)
     return cachedConfig;
   try {
-    const raw = readFileSync2(getConfigPath2(), "utf-8");
+    const raw = readFileSync3(getConfigPath2(), "utf-8");
     cachedConfig = JSON.parse(raw);
     configLoadedAt = now;
     return cachedConfig;
@@ -38938,7 +40175,7 @@ function parseMessage(row) {
 function getAttachmentsDir() {
   if (process.env.CONVERSATIONS_ATTACHMENTS_DIR)
     return process.env.CONVERSATIONS_ATTACHMENTS_DIR;
-  return join8(getDataDir2(), "attachments");
+  return join10(getDataDir2(), "attachments");
 }
 function guessMimeType(name) {
   const ext = name.split(".").pop()?.toLowerCase();
@@ -38967,7 +40204,30 @@ function guessMimeType(name) {
   };
   return mimeMap[ext || ""] || "application/octet-stream";
 }
+var MAX_MESSAGE_BYTES = 65536;
+var RATE_LIMIT_MAX = 60;
+var RATE_LIMIT_WINDOW_MS = 60000;
+var _rateLimitCounters = new Map;
+function checkRateLimit(agentId) {
+  const dbPath = process.env.CONVERSATIONS_DB_PATH ?? process.env.HASNA_CONVERSATIONS_DB_PATH ?? "";
+  if (dbPath === ":memory:" || dbPath.includes("test") || dbPath.includes("tmp"))
+    return;
+  const now = Date.now();
+  const entry = _rateLimitCounters.get(agentId);
+  if (!entry || now - entry.windowStart > RATE_LIMIT_WINDOW_MS) {
+    _rateLimitCounters.set(agentId, { count: 1, windowStart: now });
+    return;
+  }
+  entry.count++;
+  if (entry.count > RATE_LIMIT_MAX) {
+    throw new Error(`Rate limit exceeded: ${agentId} may send at most ${RATE_LIMIT_MAX} messages per minute.`);
+  }
+}
 function sendMessage(opts) {
+  if (Buffer.byteLength(opts.content, "utf8") > MAX_MESSAGE_BYTES) {
+    throw new Error(`Message content exceeds maximum size of ${MAX_MESSAGE_BYTES} bytes (64 KB).`);
+  }
+  checkRateLimit(opts.from);
   const db2 = getDb();
   const explicitSession = opts.session_id && opts.session_id.trim().length > 0 ? opts.session_id : undefined;
   const sessionId = explicitSession ?? (opts.space ? `space:${opts.space}` : `${[opts.from, opts.to].sort().join("-")}-${randomUUID().slice(0, 8)}`);
@@ -38983,11 +40243,11 @@ function sendMessage(opts) {
   const row = stmt.get(sessionId, opts.from, opts.to, opts.space || null, opts.project_id || null, opts.content, normalizedPriority, opts.working_dir || null, opts.repository || null, opts.branch || null, metadata, blocking, replyTo);
   const message = parseMessage(row);
   if (opts.attachments && opts.attachments.length > 0) {
-    const attachmentsDir = join8(getAttachmentsDir(), String(message.id));
-    mkdirSync5(attachmentsDir, { recursive: true });
+    const attachmentsDir = join10(getAttachmentsDir(), String(message.id));
+    mkdirSync6(attachmentsDir, { recursive: true });
     const attachmentInfos = [];
     for (const att of opts.attachments) {
-      const destPath = join8(attachmentsDir, att.name);
+      const destPath = join10(attachmentsDir, att.name);
       copyFileSync3(att.source_path, destPath);
       const stat = statSync2(destPath);
       attachmentInfos.push({
@@ -39548,8 +40808,8 @@ function getSessionActivity(sessionId) {
 }
 
 // src/lib/identity.ts
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync6 } from "fs";
-import { join as join9, dirname as dirname3 } from "path";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, mkdirSync as mkdirSync7 } from "fs";
+import { join as join11, dirname as dirname3 } from "path";
 
 // src/lib/names.ts
 var AGENT_NAMES = [
@@ -39902,7 +41162,7 @@ var AGENT_NAMES = [
 
 // src/lib/identity.ts
 init_db();
-var AGENT_ID_FILE = join9(getDataDir2(), "agent-id");
+var AGENT_ID_FILE = join11(getDataDir2(), "agent-id");
 var cachedAutoName = null;
 function isNameTaken(name) {
   try {
@@ -39918,7 +41178,7 @@ function getAutoName() {
   if (cachedAutoName)
     return cachedAutoName;
   try {
-    const name2 = readFileSync3(AGENT_ID_FILE, "utf-8").trim();
+    const name2 = readFileSync5(AGENT_ID_FILE, "utf-8").trim();
     if (name2) {
       cachedAutoName = name2;
       return name2;
@@ -39934,8 +41194,8 @@ function getAutoName() {
   }
   cachedAutoName = name;
   try {
-    mkdirSync6(dirname3(AGENT_ID_FILE), { recursive: true });
-    writeFileSync2(AGENT_ID_FILE, name + `
+    mkdirSync7(dirname3(AGENT_ID_FILE), { recursive: true });
+    writeFileSync3(AGENT_ID_FILE, name + `
 `, "utf-8");
   } catch {}
   return name;
@@ -39952,8 +41212,8 @@ function resolveIdentity(explicit) {
 function updateCachedAutoName(newName) {
   cachedAutoName = newName;
   try {
-    mkdirSync6(dirname3(AGENT_ID_FILE), { recursive: true });
-    writeFileSync2(AGENT_ID_FILE, newName + `
+    mkdirSync7(dirname3(AGENT_ID_FILE), { recursive: true });
+    writeFileSync3(AGENT_ID_FILE, newName + `
 `, "utf-8");
   } catch {}
 }
@@ -42504,10 +43764,295 @@ function registerAdvancedTools(server, pkgVersion) {
     }
   });
 }
+
+// src/mcp/tools/cloud.ts
+var SYNC_EXCLUDED = new Set([
+  "messages",
+  "reactions",
+  "message_read_receipts",
+  "message_mentions",
+  "messages_fts",
+  "_sync_conflicts",
+  "_migrations"
+]);
+var CONFLICT_TABLES = new Set(["spaces", "projects", "agent_presence"]);
+async function detectAndLogConflicts(local, cloud, table) {
+  if (!CONFLICT_TABLES.has(table))
+    return 0;
+  try {
+    const { detectConflicts: detectConflicts2, storeConflicts: storeConflicts2 } = await Promise.resolve().then(() => (init_dist(), exports_dist));
+    const pk = table === "messages" ? "id" : table === "spaces" ? "name" : table === "space_members" ? "space" : "id";
+    const tsCol = "created_at";
+    const localRows = local.all(`SELECT * FROM "${table}"`);
+    const remoteRows = await cloud.all(`SELECT * FROM "${table}"`);
+    if (localRows.length === 0 || remoteRows.length === 0)
+      return 0;
+    const conflicts = detectConflicts2(localRows, remoteRows, table, pk, tsCol);
+    if (conflicts.length > 0) {
+      storeConflicts2(local, conflicts);
+    }
+    return conflicts.length;
+  } catch {
+    return 0;
+  }
+}
+function registerCloudSyncTools(server) {
+  server.tool("conversations_cloud_status", "Show cloud configuration, connection health, and sync status", {}, async () => {
+    try {
+      const {
+        getCloudConfig: getCloudConfig2,
+        getConnectionString: getConnectionString2,
+        PgAdapterAsync: PgAdapterAsync2,
+        listConflicts: listConflicts2,
+        ensureConflictsTable: ensureConflictsTable2,
+        SqliteAdapter: SqliteAdapter2,
+        getDbPath: cloudGetDbPath
+      } = await Promise.resolve().then(() => (init_dist(), exports_dist));
+      const config2 = getCloudConfig2();
+      const lines = [
+        `Mode: ${config2.mode}`,
+        `Service: conversations`,
+        `RDS Host: ${config2.rds.host || "(not configured)"}`
+      ];
+      if (config2.rds.host && config2.rds.username) {
+        try {
+          const pg = new PgAdapterAsync2(getConnectionString2("postgres"));
+          await pg.get("SELECT 1 as ok");
+          lines.push("PostgreSQL: connected");
+          await pg.close();
+        } catch (err) {
+          lines.push(`PostgreSQL: failed \u2014 ${err?.message}`);
+        }
+      }
+      try {
+        const local = new SqliteAdapter2(cloudGetDbPath("conversations"));
+        ensureConflictsTable2(local);
+        const unresolved = listConflicts2(local, { resolved: false });
+        const resolved = listConflicts2(local, { resolved: true });
+        lines.push(`Sync conflicts: ${unresolved.length} unresolved, ${resolved.length} resolved`);
+        local.close();
+      } catch {}
+      return { content: [{ type: "text", text: lines.join(`
+`) }] };
+    } catch (e) {
+      return { content: [{ type: "text", text: formatError2(e) }], isError: true };
+    }
+  });
+  server.tool("conversations_cloud_push", "Push local conversations data to cloud PostgreSQL. Detects conflicts and syncs all tables.", {
+    tables: exports_external.string().optional().describe("Comma-separated table names (default: all)")
+  }, async ({ tables: tablesStr }) => {
+    try {
+      const {
+        getCloudConfig: getCloudConfig2,
+        getConnectionString: getConnectionString2,
+        syncPush: syncPush2,
+        listSqliteTables: listSqliteTables2,
+        SqliteAdapter: SqliteAdapter2,
+        PgAdapterAsync: PgAdapterAsync2,
+        getDbPath: cloudGetDbPath
+      } = await Promise.resolve().then(() => (init_dist(), exports_dist));
+      const config2 = getCloudConfig2();
+      if (config2.mode === "local") {
+        return { content: [{ type: "text", text: "Error: cloud mode not configured." }], isError: true };
+      }
+      const localPath = cloudGetDbPath("conversations");
+      const local = new SqliteAdapter2(localPath);
+      const cloud = new PgAdapterAsync2(getConnectionString2("conversations"));
+      const tableList = tablesStr ? tablesStr.split(",").map((t) => t.trim()) : listSqliteTables2(local).filter((t) => !SYNC_EXCLUDED.has(t));
+      let totalConflicts = 0;
+      for (const table of tableList) {
+        totalConflicts += await detectAndLogConflicts(local, cloud, table);
+      }
+      const results = await syncPush2(local, cloud, { tables: tableList });
+      local.close();
+      await cloud.close();
+      const total = results.reduce((s, r) => s + r.rowsWritten, 0);
+      const errors3 = results.flatMap((r) => r.errors);
+      const lines = [`Pushed ${total} rows across ${tableList.length} table(s).`];
+      if (totalConflicts > 0)
+        lines.push(`Conflicts detected: ${totalConflicts} (logged to _sync_conflicts)`);
+      if (errors3.length > 0)
+        lines.push(`Errors: ${errors3.join("; ")}`);
+      return { content: [{ type: "text", text: lines.join(`
+`) }] };
+    } catch (e) {
+      return { content: [{ type: "text", text: formatError2(e) }], isError: true };
+    }
+  });
+  server.tool("conversations_cloud_pull", "Pull cloud PostgreSQL data to local. Detects conflicts and merges by primary key with UPSERT.", {
+    tables: exports_external.string().optional().describe("Comma-separated table names (default: all)")
+  }, async ({ tables: tablesStr }) => {
+    try {
+      const {
+        getCloudConfig: getCloudConfig2,
+        getConnectionString: getConnectionString2,
+        syncPull: syncPull2,
+        listPgTables: listPgTables2,
+        SqliteAdapter: SqliteAdapter2,
+        PgAdapterAsync: PgAdapterAsync2,
+        getDbPath: cloudGetDbPath
+      } = await Promise.resolve().then(() => (init_dist(), exports_dist));
+      const config2 = getCloudConfig2();
+      if (config2.mode === "local") {
+        return { content: [{ type: "text", text: "Error: cloud mode not configured." }], isError: true };
+      }
+      const local = new SqliteAdapter2(cloudGetDbPath("conversations"));
+      const cloud = new PgAdapterAsync2(getConnectionString2("conversations"));
+      let tableList;
+      if (tablesStr) {
+        tableList = tablesStr.split(",").map((t) => t.trim());
+      } else {
+        try {
+          tableList = (await listPgTables2(cloud)).filter((t) => !SYNC_EXCLUDED.has(t));
+        } catch {
+          local.close();
+          await cloud.close();
+          return { content: [{ type: "text", text: "Error: failed to list cloud tables." }], isError: true };
+        }
+      }
+      let totalConflicts = 0;
+      for (const table of tableList) {
+        totalConflicts += await detectAndLogConflicts(local, cloud, table);
+      }
+      const results = await syncPull2(cloud, local, { tables: tableList });
+      local.close();
+      await cloud.close();
+      const total = results.reduce((s, r) => s + r.rowsWritten, 0);
+      const errors3 = results.flatMap((r) => r.errors);
+      const lines = [`Pulled ${total} rows across ${tableList.length} table(s).`];
+      if (totalConflicts > 0)
+        lines.push(`Conflicts detected: ${totalConflicts} (logged to _sync_conflicts)`);
+      if (errors3.length > 0)
+        lines.push(`Errors: ${errors3.join("; ")}`);
+      return { content: [{ type: "text", text: lines.join(`
+`) }] };
+    } catch (e) {
+      return { content: [{ type: "text", text: formatError2(e) }], isError: true };
+    }
+  });
+  server.tool("conversations_cloud_sync", "Bidirectional cloud sync \u2014 pull remote changes then push local changes. Detects and logs conflicts.", {
+    tables: exports_external.string().optional().describe("Comma-separated table names (default: all syncable tables)")
+  }, async ({ tables: tablesStr }) => {
+    try {
+      const {
+        getCloudConfig: getCloudConfig2,
+        getConnectionString: getConnectionString2,
+        syncPush: syncPush2,
+        syncPull: syncPull2,
+        listSqliteTables: listSqliteTables2,
+        listPgTables: listPgTables2,
+        SqliteAdapter: SqliteAdapter2,
+        PgAdapterAsync: PgAdapterAsync2,
+        getDbPath: cloudGetDbPath
+      } = await Promise.resolve().then(() => (init_dist(), exports_dist));
+      const config2 = getCloudConfig2();
+      if (config2.mode === "local") {
+        return { content: [{ type: "text", text: "Error: cloud mode not configured." }], isError: true };
+      }
+      const local = new SqliteAdapter2(cloudGetDbPath("conversations"));
+      const cloud = new PgAdapterAsync2(getConnectionString2("conversations"));
+      let tableList;
+      if (tablesStr) {
+        tableList = tablesStr.split(",").map((t) => t.trim());
+      } else {
+        const localTables = new Set(listSqliteTables2(local).filter((t) => !SYNC_EXCLUDED.has(t)));
+        let remoteTables;
+        try {
+          remoteTables = new Set((await listPgTables2(cloud)).filter((t) => !SYNC_EXCLUDED.has(t)));
+        } catch {
+          local.close();
+          await cloud.close();
+          return { content: [{ type: "text", text: "Error: failed to list cloud tables." }], isError: true };
+        }
+        tableList = [...new Set([...localTables, ...remoteTables])];
+      }
+      let totalConflicts = 0;
+      for (const table of tableList) {
+        totalConflicts += await detectAndLogConflicts(local, cloud, table);
+      }
+      const pullResults = await syncPull2(cloud, local, { tables: tableList });
+      const pullTotal = pullResults.reduce((s, r) => s + r.rowsWritten, 0);
+      const pushResults = await syncPush2(local, cloud, { tables: tableList });
+      const pushTotal = pushResults.reduce((s, r) => s + r.rowsWritten, 0);
+      local.close();
+      await cloud.close();
+      const allErrors = [
+        ...pullResults.flatMap((r) => r.errors.map((e) => `pull: ${e}`)),
+        ...pushResults.flatMap((r) => r.errors.map((e) => `push: ${e}`))
+      ];
+      const lines = [
+        `Sync complete: pulled ${pullTotal} rows, pushed ${pushTotal} rows across ${tableList.length} table(s).`
+      ];
+      if (totalConflicts > 0)
+        lines.push(`Conflicts detected: ${totalConflicts} (logged to _sync_conflicts)`);
+      if (allErrors.length > 0)
+        lines.push(`Errors: ${allErrors.join("; ")}`);
+      return { content: [{ type: "text", text: lines.join(`
+`) }] };
+    } catch (e) {
+      return { content: [{ type: "text", text: formatError2(e) }], isError: true };
+    }
+  });
+  server.tool("conversations_cloud_migrate", "Run PostgreSQL migrations against the configured RDS instance to initialize the cloud schema", {
+    dry_run: exports_external.boolean().optional().describe("Print SQL without executing")
+  }, async ({ dry_run }) => {
+    try {
+      const { getCloudConfig: getCloudConfig2, getConnectionString: getConnectionString2, PgAdapterAsync: PgAdapterAsync2 } = await Promise.resolve().then(() => (init_dist(), exports_dist));
+      const { PG_MIGRATIONS: PG_MIGRATIONS2 } = await Promise.resolve().then(() => (init_pg_migrations(), exports_pg_migrations));
+      const config2 = getCloudConfig2();
+      if (config2.mode === "local") {
+        return { content: [{ type: "text", text: "Error: cloud mode not configured." }], isError: true };
+      }
+      if (dry_run) {
+        return { content: [{ type: "text", text: PG_MIGRATIONS2.join(`
+
+---
+
+`) }] };
+      }
+      const pg = new PgAdapterAsync2(getConnectionString2("conversations"));
+      const lines = [];
+      for (let i = 0;i < PG_MIGRATIONS2.length; i++) {
+        await pg.run(PG_MIGRATIONS2[i]);
+        lines.push(`Migration ${i + 1}/${PG_MIGRATIONS2.length}: applied`);
+      }
+      await pg.close();
+      lines.push("All migrations applied successfully.");
+      return { content: [{ type: "text", text: lines.join(`
+`) }] };
+    } catch (e) {
+      return { content: [{ type: "text", text: formatError2(e) }], isError: true };
+    }
+  });
+  server.tool("conversations_cloud_feedback", "Send feedback for the conversations service", {
+    message: exports_external.string().describe("Feedback message"),
+    email: exports_external.string().optional().describe("Contact email")
+  }, async ({ message, email: email3 }) => {
+    try {
+      const { sendFeedback: sendFeedback2, createDatabase: createDatabase2 } = await Promise.resolve().then(() => (init_dist(), exports_dist));
+      const db2 = createDatabase2({ service: "cloud" });
+      const result = await sendFeedback2({ service: "conversations", message, email: email3 }, db2);
+      db2.close();
+      return {
+        content: [{
+          type: "text",
+          text: result.sent ? `Feedback sent (id: ${result.id})` : `Saved locally (id: ${result.id}): ${result.error}`
+        }]
+      };
+    } catch (e) {
+      return { content: [{ type: "text", text: formatError2(e) }], isError: true };
+    }
+  });
+}
+function formatError2(e) {
+  if (e instanceof Error)
+    return e.message;
+  return String(e);
+}
 // package.json
 var package_default = {
   name: "@hasna/conversations",
-  version: "0.2.24",
+  version: "0.2.26",
   description: "Real-time CLI messaging for AI agents",
   type: "module",
   bin: {
@@ -42536,7 +44081,7 @@ var package_default = {
     test: "bun test",
     dev: "bun run ./src/cli/index.tsx",
     typecheck: "tsc --noEmit",
-    prepublishOnly: "bun run build",
+    prepublishOnly: "bun run build:dashboard && bun run build",
     postinstall: "mkdir -p $HOME/.hasna/conversations $HOME/.hasna/conversations/training 2>/dev/null || true"
   },
   keywords: [
@@ -42611,7 +44156,7 @@ registerAgentTools(server, agentFocus, getAgentFocus);
 registerAdvancedTools(server, package_default.version);
 async function startMcpServer() {
   const transport = new StdioServerTransport;
-  registerCloudTools(server, "conversations");
+  registerCloudSyncTools(server);
   await server.connect(transport);
 }
 var isDirectRun = import.meta.url === `file://${process.argv[1]}` || process.argv[1]?.endsWith("mcp.js") || process.argv[1]?.endsWith("mcp.ts");