@hasna/invoices 0.1.0 → 0.1.1

package/dist/index.js

@@ -1,4 +1,10 @@
 // @bun
+// src/lib/version.ts
+var VERSION = "0.0.1";
+// src/db/database.ts
+import { mkdirSync as mkdirSync3 } from "fs";
+import { dirname as dirname2, join as join5 } from "path";
+
 // node_modules/@hasna/cloud/dist/index.js
 import { createRequire } from "module";
 import { Database } from "bun:sqlite";
@@ -16,6 +22,7 @@ import { join as join2 } from "path";
 import { readdirSync as readdirSync2, existsSync as existsSync3 } from "fs";
 import { join as join3 } from "path";
 import { homedir as homedir3 } from "os";
+import { hostname } from "os";
 import { homedir as homedir4 } from "os";
 import { join as join4 } from "path";
 import { join as join6, dirname } from "path";
@@ -1359,7 +1366,7 @@ var require_cert_signatures = __commonJS((exports, module) => {
   module.exports = { signatureAlgorithmHashFromCertificate };
 });
 var require_sasl = __commonJS((exports, module) => {
-  var crypto2 = require_utils2();
+  var crypto = require_utils2();
   var { signatureAlgorithmHashFromCertificate } = require_cert_signatures();
   function startSession(mechanisms, stream) {
     const candidates = ["SCRAM-SHA-256"];
@@ -1372,7 +1379,7 @@ var require_sasl = __commonJS((exports, module) => {
     if (mechanism === "SCRAM-SHA-256-PLUS" && typeof stream.getPeerCertificate !== "function") {
       throw new Error("SASL: Mechanism SCRAM-SHA-256-PLUS requires a certificate");
     }
-    const clientNonce = crypto2.randomBytes(18).toString("base64");
+    const clientNonce = crypto.randomBytes(18).toString("base64");
     const gs2Header = mechanism === "SCRAM-SHA-256-PLUS" ? "p=tls-server-end-point" : stream ? "y" : "n";
     return {
       mechanism,
@@ -1408,20 +1415,20 @@ var require_sasl = __commonJS((exports, module) => {
       let hashName = signatureAlgorithmHashFromCertificate(peerCert);
       if (hashName === "MD5" || hashName === "SHA-1")
         hashName = "SHA-256";
-      const certHash = await crypto2.hashByName(hashName, peerCert);
+      const certHash = await crypto.hashByName(hashName, peerCert);
       const bindingData = Buffer.concat([Buffer.from("p=tls-server-end-point,,"), Buffer.from(certHash)]);
       channelBinding = bindingData.toString("base64");
     }
     const clientFinalMessageWithoutProof = "c=" + channelBinding + ",r=" + sv.nonce;
     const authMessage = clientFirstMessageBare + "," + serverFirstMessage + "," + clientFinalMessageWithoutProof;
     const saltBytes = Buffer.from(sv.salt, "base64");
-    const saltedPassword = await crypto2.deriveKey(password, saltBytes, sv.iteration);
-    const clientKey = await crypto2.hmacSha256(saltedPassword, "Client Key");
-    const storedKey = await crypto2.sha256(clientKey);
-    const clientSignature = await crypto2.hmacSha256(storedKey, authMessage);
+    const saltedPassword = await crypto.deriveKey(password, saltBytes, sv.iteration);
+    const clientKey = await crypto.hmacSha256(saltedPassword, "Client Key");
+    const storedKey = await crypto.sha256(clientKey);
+    const clientSignature = await crypto.hmacSha256(storedKey, authMessage);
     const clientProof = xorBuffers(Buffer.from(clientKey), Buffer.from(clientSignature)).toString("base64");
-    const serverKey = await crypto2.hmacSha256(saltedPassword, "Server Key");
-    const serverSignatureBytes = await crypto2.hmacSha256(serverKey, authMessage);
+    const serverKey = await crypto.hmacSha256(saltedPassword, "Server Key");
+    const serverSignatureBytes = await crypto.hmacSha256(serverKey, authMessage);
     session.message = "SASLResponse";
     session.serverSignature = Buffer.from(serverSignatureBytes).toString("base64");
     session.response = clientFinalMessageWithoutProof + ",p=" + clientProof;
@@ -1584,11 +1591,11 @@ var require_pg_connection_string = __commonJS((exports, module) => {
       config.client_encoding = result.searchParams.get("encoding");
       return config;
     }
-    const hostname = dummyHost ? "" : result.hostname;
+    const hostname2 = dummyHost ? "" : result.hostname;
     if (!config.host) {
-      config.host = decodeURIComponent(hostname);
-    } else if (hostname && /^%2f/i.test(hostname)) {
-      result.pathname = hostname + result.pathname;
+      config.host = decodeURIComponent(hostname2);
+    } else if (hostname2 && /^%2f/i.test(hostname2)) {
+      result.pathname = hostname2 + result.pathname;
     }
     if (!config.port) {
       config.port = result.port;
@@ -3439,7 +3446,7 @@ var require_client = __commonJS((exports, module) => {
   var Query = require_query();
   var defaults = require_defaults();
   var Connection = require_connection();
-  var crypto2 = require_utils2();
+  var crypto = require_utils2();
   var activeQueryDeprecationNotice = nodeUtils.deprecate(() => {}, "Client.activeQuery is deprecated and will be removed in pg@9.0");
   var queryQueueDeprecationNotice = nodeUtils.deprecate(() => {}, "Client.queryQueue is deprecated and will be removed in pg@9.0.");
   var pgPassDeprecationNotice = nodeUtils.deprecate(() => {}, "pgpass support is deprecated and will be removed in pg@9.0. " + "You can provide an async function as the password property to the Client/Pool constructor that returns a password instead. Within this function you can call the pgpass module in your own code.");
@@ -3655,7 +3662,7 @@ var require_client = __commonJS((exports, module) => {
     _handleAuthMD5Password(msg) {
       this._getPassword(async () => {
         try {
-          const hashedPassword = await crypto2.postgresMd5PasswordHash(this.user, this.password, msg.salt);
+          const hashedPassword = await crypto.postgresMd5PasswordHash(this.user, this.password, msg.salt);
           this.connection.password(hashedPassword);
         } catch (e) {
           this.emit("error", e);
@@ -4933,6 +4940,18 @@ 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;
   constructor(path) {
@@ -5120,6 +5139,63 @@ class PgAdapter {
     return this.pool;
   }
 }
+
+class PgAdapterAsync {
+  pool;
+  constructor(arg) {
+    if (typeof arg === "string") {
+      const sslConfig = arg.includes("sslmode=require") || arg.includes("ssl=true") ? { rejectUnauthorized: false } : undefined;
+      this.pool = new esm_default.Pool({ connectionString: arg, ssl: sslConfig });
+    } 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;
+  }
+}
 var init_adapter = __esm(() => {
   init_esm();
 });
@@ -9382,7 +9458,494 @@ var init_discover = __esm(() => {
 });
 init_adapter();
 init_config();
+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);
+}
+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 pgTypeToSqlite(pgType) {
+  const t = pgType.toLowerCase();
+  if (t.includes("int") || t === "bigint" || t === "smallint" || t === "serial" || t === "bigserial")
+    return "INTEGER";
+  if (t.includes("bool"))
+    return "INTEGER";
+  if (t.includes("float") || t.includes("double") || t === "real" || t === "numeric" || t === "decimal")
+    return "REAL";
+  if (t === "bytea")
+    return "BLOB";
+  return "TEXT";
+}
+async function ensureTableInSqliteFromPg(target, source, table) {
+  const existing = target.all(`SELECT name FROM sqlite_master WHERE type='table' AND name=?`, table);
+  if (existing.length > 0)
+    return false;
+  const cols = await source.all(`SELECT column_name, data_type, is_nullable, column_default
+     FROM information_schema.columns
+     WHERE table_schema = 'public' AND table_name = '${table}'
+     ORDER BY ordinal_position`);
+  if (cols.length === 0)
+    return false;
+  const pkCols = await source.all(`SELECT kcu.column_name
+     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`);
+  const pkSet = new Set(pkCols.map((c) => c.column_name));
+  const skipTypes = new Set(["tsvector", "tsquery", "user-defined"]);
+  const filteredCols = cols.filter((c) => !skipTypes.has(c.data_type));
+  const colDefs = filteredCols.map((c) => {
+    const sqliteType = pgTypeToSqlite(c.data_type);
+    const notNull = c.is_nullable === "NO" && !pkSet.has(c.column_name) ? " NOT NULL" : "";
+    return `"${c.column_name}" ${sqliteType}${notNull}`;
+  });
+  if (pkSet.size > 0) {
+    const pkList = [...pkSet].map((c) => `"${c}"`).join(", ");
+    colDefs.push(`PRIMARY KEY (${pkList})`);
+  }
+  const sql = `CREATE TABLE IF NOT EXISTS "${table}" (${colDefs.join(", ")})`;
+  target.exec(sql);
+  process.stderr.write(`  [sync] ${table}: auto-created in SQLite from PG schema
+`);
+  return true;
+}
+async function ensureTablesExist(source, target, tables) {
+  for (const table of tables) {
+    if (!isAsyncAdapter(target) && isAsyncAdapter(source)) {
+      await ensureTableInSqliteFromPg(target, source, table);
+    }
+  }
+}
+async function filterColumnsForTarget(target, table, sourceColumns) {
+  try {
+    if (!isAsyncAdapter(target)) {
+      const colInfo = target.all(`PRAGMA table_info("${table}")`);
+      if (Array.isArray(colInfo) && colInfo.length > 0) {
+        const targetCols = new Set(colInfo.map((c) => c.name));
+        const filtered = sourceColumns.filter((c) => targetCols.has(c));
+        if (filtered.length < sourceColumns.length) {
+          const dropped = sourceColumns.filter((c) => !targetCols.has(c));
+          process.stderr.write(`  [sync] ${table}: dropping ${dropped.length} columns not in target: ${dropped.join(", ")}
+`);
+        }
+        return filtered;
+      }
+    } else {
+      const colInfo = await target.all(`SELECT column_name FROM information_schema.columns WHERE table_schema = 'public' AND table_name = '${table}'`);
+      if (colInfo.length > 0) {
+        const targetCols = new Set(colInfo.map((c) => c.column_name));
+        return sourceColumns.filter((c) => targetCols.has(c));
+      }
+    }
+  } catch {}
+  return sourceColumns;
+}
+async function syncTransfer(source, target, options, _direction) {
+  const {
+    tables,
+    onProgress,
+    batchSize = 100,
+    conflictColumn = "updated_at",
+    primaryKey: pkOption
+  } = options;
+  const results = [];
+  const sqliteTarget = !isAsyncAdapter(target) ? target : null;
+  await ensureTablesExist(source, target, tables);
+  if (sqliteTarget) {
+    try {
+      sqliteTarget.exec("PRAGMA foreign_keys = OFF");
+    } catch {}
+  }
+  try {
+    for (let i = 0;i < tables.length; i++) {
+      const table = tables[i];
+      const result = {
+        table,
+        rowsRead: 0,
+        rowsWritten: 0,
+        rowsSkipped: 0,
+        errors: []
+      };
+      try {
+        onProgress?.({
+          table,
+          phase: "reading",
+          rowsRead: 0,
+          rowsWritten: 0,
+          totalTables: tables.length,
+          currentTableIndex: i
+        });
+        const rows = await readAll(source, `SELECT * FROM "${table}"`);
+        result.rowsRead = rows.length;
+        if (rows.length === 0) {
+          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]);
+        const columns = await filterColumnsForTarget(target, table, sourceColumns);
+        if (pkColumns.length === 0) {
+          result.errors.push(`Table "${table}" has no primary key \u2014 inserting without conflict handling`);
+          onProgress?.({
+            table,
+            phase: "writing",
+            rowsRead: result.rowsRead,
+            rowsWritten: 0,
+            totalTables: tables.length,
+            currentTableIndex: i
+          });
+          for (let offset = 0;offset < rows.length; offset += batchSize) {
+            const batch = rows.slice(offset, offset + batchSize);
+            try {
+              if (isAsyncAdapter(target)) {
+                await batchInsertPg(target, table, columns, batch);
+              } else {
+                batchInsertSqlite(target, table, columns, batch);
+              }
+              result.rowsWritten += batch.length;
+            } catch (err) {
+              result.errors.push(`Batch at offset ${offset}: ${err?.message ?? String(err)}`);
+            }
+          }
+          onProgress?.({
+            table,
+            phase: "done",
+            rowsRead: result.rowsRead,
+            rowsWritten: result.rowsWritten,
+            totalTables: tables.length,
+            currentTableIndex: i
+          });
+          results.push(result);
+          continue;
+        }
+        const missingPks = pkColumns.filter((pk) => !columns.includes(pk));
+        if (missingPks.length > 0) {
+          result.errors.push(`Table "${table}" missing PK columns in data: ${missingPks.join(", ")} \u2014 skipping`);
+          results.push(result);
+          continue;
+        }
+        onProgress?.({
+          table,
+          phase: "writing",
+          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, columns.includes(conflictColumn) ? conflictColumn : undefined);
+            } else {
+              batchUpsertSqlite(target, table, columns, updateCols, pkColumns, batch, columns.includes(conflictColumn) ? conflictColumn : undefined);
+            }
+            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)}`);
+      }
+      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 {}
+    }
+  }
+  return results;
+}
+async function batchUpsertPg(target, table, columns, updateCols, primaryKeys, batch, conflictColumn) {
+  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 whereClause = conflictColumn && updateCols.includes(conflictColumn) ? ` WHERE "${table}"."${conflictColumn}" IS NULL OR EXCLUDED."${conflictColumn}" >= "${table}"."${conflictColumn}"` : "";
+  const sql = `INSERT INTO "${table}" (${colList}) VALUES ${valuePlaceholders}
+    ON CONFLICT (${pkList}) DO UPDATE SET ${setClause}${whereClause}`;
+  const params = batch.flatMap((row) => columns.map((c) => row[c] ?? null));
+  await target.run(sql, ...params);
+}
+function batchUpsertSqlite(target, table, columns, updateCols, primaryKeys, batch, conflictColumn) {
+  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 whereClause = conflictColumn && updateCols.includes(conflictColumn) ? ` WHERE "${table}"."${conflictColumn}" IS NULL OR EXCLUDED."${conflictColumn}" >= "${table}"."${conflictColumn}"` : "";
+  const sql = `INSERT INTO "${table}" (${colList}) VALUES ${valuePlaceholders}
+    ON CONFLICT (${pkList}) DO UPDATE SET ${setClause}${whereClause}`;
+  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);
+}
 init_config();
+var FEEDBACK_TABLE_SQL = `
+CREATE TABLE IF NOT EXISTS feedback (
+  id TEXT PRIMARY KEY,
+  service TEXT NOT NULL,
+  version TEXT DEFAULT '',
+  message TEXT NOT NULL,
+  email TEXT DEFAULT '',
+  machine_id TEXT DEFAULT '',
+  created_at TEXT DEFAULT (datetime('now'))
+)`;
+function ensureFeedbackTable(db) {
+  db.exec(FEEDBACK_TABLE_SQL);
+}
+function saveFeedback(db, feedback) {
+  ensureFeedbackTable(db);
+  const id = feedback.id ?? Math.random().toString(36).slice(2) + Date.now().toString(36);
+  const now = new Date().toISOString();
+  const machineId = feedback.machine_id ?? hostname();
+  db.run(`INSERT INTO feedback (id, service, version, message, email, machine_id, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`, id, feedback.service, feedback.version ?? "", feedback.message, feedback.email ?? "", machineId, feedback.created_at ?? now);
+  return id;
+}
+async function sendFeedback(feedback, db) {
+  const config = getCloudConfig();
+  const id = feedback.id ?? Math.random().toString(36).slice(2) + Date.now().toString(36);
+  const machineId = feedback.machine_id ?? hostname();
+  const now = new Date().toISOString();
+  const payload = {
+    id,
+    service: feedback.service,
+    version: feedback.version ?? "",
+    message: feedback.message,
+    email: feedback.email ?? "",
+    machine_id: machineId,
+    created_at: feedback.created_at ?? now
+  };
+  try {
+    const res = await fetch(config.feedback_endpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!res.ok) {
+      throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+    }
+    if (db) {
+      try {
+        saveFeedback(db, { ...feedback, id });
+      } catch {}
+    }
+    return { sent: true, id };
+  } catch (err) {
+    const errorMsg = err?.message ?? String(err);
+    if (db) {
+      try {
+        saveFeedback(db, { ...feedback, id });
+      } catch {}
+    }
+    return { sent: false, id, error: errorMsg };
+  }
+}
 init_dotfile();
 
 class SyncProgressTracker {
@@ -9515,6 +10078,42 @@ init_config();
 var CONFIG_DIR2 = join6(homedir5(), ".hasna", "cloud");
 init_adapter();
 init_config();
+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;
+}
 init_discover();
 init_zod();
 init_config();
@@ -9525,563 +10124,515 @@ init_dotfile();
 init_adapter();
 
 // src/db/database.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync3 } from "fs";
-import { dirname as dirname2, join as join5 } from "path";
-
-// src/db/migrations.ts
+function defaultDatabasePath() {
+  const baseDir = join5(process.env.HOME ?? ".", ".hasna", "invoices");
+  mkdirSync3(baseDir, { recursive: true });
+  return join5(baseDir, "invoices.db");
+}
+function openInvoiceDatabase(options = {}) {
+  const dbPath = options.dbPath ?? defaultDatabasePath();
+  mkdirSync3(dirname2(dbPath), { recursive: true });
+  const db = new SqliteAdapter(dbPath);
+  db.exec("PRAGMA journal_mode = WAL;");
+  db.exec("PRAGMA foreign_keys = ON;");
+  db.exec("PRAGMA busy_timeout = 5000;");
+  return db;
+}
+// src/db/schema.ts
 var MIGRATIONS = [
   {
-    id: 1,
-    name: "initial_schema",
+    id: "0001_init",
     sql: `
-      CREATE TABLE IF NOT EXISTS clients (
-        id TEXT PRIMARY KEY,
-        name TEXT NOT NULL,
-        email TEXT,
-        phone TEXT,
-        address TEXT,
-        tax_id TEXT,
-        notes TEXT,
-        metadata TEXT NOT NULL DEFAULT '{}',
-        created_at TEXT NOT NULL DEFAULT (datetime('now')),
-        updated_at TEXT NOT NULL DEFAULT (datetime('now'))
-      );
+CREATE TABLE IF NOT EXISTS migrations (
+  id TEXT PRIMARY KEY,
+  applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
 
-      CREATE TABLE IF NOT EXISTS invoices (
-        id TEXT PRIMARY KEY,
-        invoice_number TEXT NOT NULL UNIQUE,
-        client_id TEXT REFERENCES clients(id) ON DELETE SET NULL,
-        status TEXT NOT NULL DEFAULT 'draft' CHECK(status IN ('draft', 'sent', 'paid', 'overdue', 'cancelled', 'refunded')),
-        issue_date TEXT NOT NULL DEFAULT (date('now')),
-        due_date TEXT,
-        currency TEXT NOT NULL DEFAULT 'USD',
-        subtotal REAL NOT NULL DEFAULT 0,
-        tax_rate REAL NOT NULL DEFAULT 0,
-        tax_amount REAL NOT NULL DEFAULT 0,
-        discount REAL NOT NULL DEFAULT 0,
-        total REAL NOT NULL DEFAULT 0,
-        notes TEXT,
-        metadata TEXT NOT NULL DEFAULT '{}',
-        created_at TEXT NOT NULL DEFAULT (datetime('now')),
-        updated_at TEXT NOT NULL DEFAULT (datetime('now')),
-        paid_at TEXT
-      );
+CREATE TABLE IF NOT EXISTS parties (
+  id TEXT PRIMARY KEY,
+  kind TEXT NOT NULL CHECK(kind IN ('issuer', 'customer')),
+  legal_name TEXT NOT NULL,
+  email TEXT,
+  tax_id TEXT,
+  country TEXT,
+  address TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
 
-      CREATE TABLE IF NOT EXISTS line_items (
-        id TEXT PRIMARY KEY,
-        invoice_id TEXT NOT NULL REFERENCES invoices(id) ON DELETE CASCADE,
-        description TEXT NOT NULL,
-        quantity REAL NOT NULL DEFAULT 1,
-        unit_price REAL NOT NULL DEFAULT 0,
-        amount REAL NOT NULL DEFAULT 0,
-        sort_order INTEGER NOT NULL DEFAULT 0,
-        created_at TEXT NOT NULL DEFAULT (datetime('now'))
-      );
+CREATE TABLE IF NOT EXISTS invoices (
+  id TEXT PRIMARY KEY,
+  number TEXT NOT NULL UNIQUE,
+  issuer_id TEXT NOT NULL REFERENCES parties(id),
+  customer_id TEXT NOT NULL REFERENCES parties(id),
+  status TEXT NOT NULL CHECK(status IN ('draft', 'sent', 'partially_paid', 'paid', 'void', 'overdue')),
+  currency TEXT NOT NULL,
+  notes TEXT,
+  issued_at TEXT NOT NULL,
+  due_at TEXT,
+  subtotal_cents INTEGER NOT NULL DEFAULT 0,
+  tax_cents INTEGER NOT NULL DEFAULT 0,
+  total_cents INTEGER NOT NULL DEFAULT 0,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
 
-      CREATE TABLE IF NOT EXISTS payments (
-        id TEXT PRIMARY KEY,
-        invoice_id TEXT NOT NULL REFERENCES invoices(id) ON DELETE CASCADE,
-        amount REAL NOT NULL,
-        method TEXT,
-        reference TEXT,
-        notes TEXT,
-        paid_at TEXT NOT NULL DEFAULT (datetime('now')),
-        created_at TEXT NOT NULL DEFAULT (datetime('now'))
-      );
+CREATE TABLE IF NOT EXISTS invoice_lines (
+  id TEXT PRIMARY KEY,
+  invoice_id TEXT NOT NULL REFERENCES invoices(id) ON DELETE CASCADE,
+  position INTEGER NOT NULL,
+  description TEXT NOT NULL,
+  quantity REAL NOT NULL DEFAULT 1,
+  unit_price_cents INTEGER NOT NULL DEFAULT 0,
+  tax_rate_basis_points INTEGER NOT NULL DEFAULT 0,
+  line_total_cents INTEGER NOT NULL DEFAULT 0,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
 
-      CREATE TABLE IF NOT EXISTS invoice_counter (
-        id INTEGER PRIMARY KEY CHECK (id = 1),
-        prefix TEXT NOT NULL DEFAULT 'INV',
-        next_number INTEGER NOT NULL DEFAULT 1
-      );
+CREATE UNIQUE INDEX IF NOT EXISTS idx_invoice_lines_invoice_position
+ON invoice_lines(invoice_id, position);
 
-      INSERT OR IGNORE INTO invoice_counter (id, prefix, next_number) VALUES (1, 'INV', 1);
+CREATE INDEX IF NOT EXISTS idx_invoices_number ON invoices(number);
+CREATE INDEX IF NOT EXISTS idx_invoices_status ON invoices(status);
+CREATE INDEX IF NOT EXISTS idx_invoices_issued_at ON invoices(issued_at);
+CREATE INDEX IF NOT EXISTS idx_invoices_due_at ON invoices(due_at);
 
-      CREATE INDEX IF NOT EXISTS idx_invoices_client ON invoices(client_id);
-      CREATE INDEX IF NOT EXISTS idx_invoices_status ON invoices(status);
-      CREATE INDEX IF NOT EXISTS idx_invoices_number ON invoices(invoice_number);
-      CREATE INDEX IF NOT EXISTS idx_invoices_due ON invoices(due_date);
-      CREATE INDEX IF NOT EXISTS idx_line_items_invoice ON line_items(invoice_id);
-      CREATE INDEX IF NOT EXISTS idx_payments_invoice ON payments(invoice_id);
-      CREATE INDEX IF NOT EXISTS idx_clients_name ON clients(name);
-      CREATE INDEX IF NOT EXISTS idx_clients_email ON clients(email);
-    `
-  },
-  {
-    id: 2,
-    name: "multi_country_support",
-    sql: `
-      CREATE TABLE IF NOT EXISTS business_profiles (
-        id TEXT PRIMARY KEY,
-        name TEXT NOT NULL,
-        address_line1 TEXT,
-        address_line2 TEXT,
-        city TEXT,
-        state TEXT,
-        postal_code TEXT,
-        country TEXT NOT NULL DEFAULT 'US',
-        tax_id TEXT,
-        vat_number TEXT,
-        registration_number TEXT,
-        email TEXT,
-        phone TEXT,
-        website TEXT,
-        bank_name TEXT,
-        bank_iban TEXT,
-        bank_swift TEXT,
-        bank_account TEXT,
-        logo_url TEXT,
-        is_default INTEGER NOT NULL DEFAULT 0,
-        metadata TEXT NOT NULL DEFAULT '{}',
-        created_at TEXT NOT NULL DEFAULT (datetime('now')),
-        updated_at TEXT NOT NULL DEFAULT (datetime('now'))
-      );
+CREATE VIRTUAL TABLE IF NOT EXISTS invoices_fts USING fts5(
+  invoice_id UNINDEXED,
+  number,
+  issuer_name,
+  customer_name,
+  notes
+);
 
-      CREATE TABLE IF NOT EXISTS tax_rules (
-        id TEXT PRIMARY KEY,
-        country TEXT NOT NULL,
-        region TEXT,
-        tax_name TEXT NOT NULL,
-        rate REAL NOT NULL,
-        type TEXT NOT NULL DEFAULT 'vat' CHECK(type IN ('vat', 'sales_tax', 'gst', 'other')),
-        is_default INTEGER NOT NULL DEFAULT 0,
-        reverse_charge INTEGER NOT NULL DEFAULT 0,
-        description TEXT,
-        created_at TEXT NOT NULL DEFAULT (datetime('now'))
-      );
+CREATE TRIGGER IF NOT EXISTS invoices_ai_fts
+AFTER INSERT ON invoices
+BEGIN
+  INSERT INTO invoices_fts(invoice_id, number, issuer_name, customer_name, notes)
+  VALUES (
+    NEW.id,
+    NEW.number,
+    COALESCE((SELECT legal_name FROM parties WHERE id = NEW.issuer_id), ''),
+    COALESCE((SELECT legal_name FROM parties WHERE id = NEW.customer_id), ''),
+    COALESCE(NEW.notes, '')
+  );
+END;
 
-      -- Add new columns to invoices
-      ALTER TABLE invoices ADD COLUMN business_profile_id TEXT REFERENCES business_profiles(id) ON DELETE SET NULL;
-      ALTER TABLE invoices ADD COLUMN tax_name TEXT DEFAULT 'Tax';
-      ALTER TABLE invoices ADD COLUMN reverse_charge INTEGER NOT NULL DEFAULT 0;
-      ALTER TABLE invoices ADD COLUMN language TEXT NOT NULL DEFAULT 'en';
-      ALTER TABLE invoices ADD COLUMN footer_text TEXT;
+CREATE TRIGGER IF NOT EXISTS invoices_au_fts
+AFTER UPDATE ON invoices
+BEGIN
+  DELETE FROM invoices_fts WHERE invoice_id = OLD.id;
+  INSERT INTO invoices_fts(invoice_id, number, issuer_name, customer_name, notes)
+  VALUES (
+    NEW.id,
+    NEW.number,
+    COALESCE((SELECT legal_name FROM parties WHERE id = NEW.issuer_id), ''),
+    COALESCE((SELECT legal_name FROM parties WHERE id = NEW.customer_id), ''),
+    COALESCE(NEW.notes, '')
+  );
+END;
 
-      -- Add new columns to clients
-      ALTER TABLE clients ADD COLUMN address_line1 TEXT;
-      ALTER TABLE clients ADD COLUMN address_line2 TEXT;
-      ALTER TABLE clients ADD COLUMN city TEXT;
-      ALTER TABLE clients ADD COLUMN state TEXT;
-      ALTER TABLE clients ADD COLUMN postal_code TEXT;
-      ALTER TABLE clients ADD COLUMN country TEXT DEFAULT 'US';
-      ALTER TABLE clients ADD COLUMN vat_number TEXT;
-      ALTER TABLE clients ADD COLUMN language TEXT DEFAULT 'en';
-
-      -- Add per-line-item tax support
-      ALTER TABLE line_items ADD COLUMN tax_rate REAL;
-      ALTER TABLE line_items ADD COLUMN tax_amount REAL DEFAULT 0;
+CREATE TRIGGER IF NOT EXISTS invoices_ad_fts
+AFTER DELETE ON invoices
+BEGIN
+  DELETE FROM invoices_fts WHERE invoice_id = OLD.id;
+END;
+`
+  },
+  {
+    id: "0002_party_fts_sync",
+    sql: `
+CREATE TRIGGER IF NOT EXISTS parties_au_invoice_fts
+AFTER UPDATE ON parties
+BEGIN
+  DELETE FROM invoices_fts
+  WHERE invoice_id IN (
+    SELECT id FROM invoices WHERE issuer_id = NEW.id OR customer_id = NEW.id
+  );
 
-      -- Seed default tax rules
-      INSERT INTO tax_rules (id, country, tax_name, rate, type, is_default, description) VALUES
-        ('tax-ro-vat-19', 'RO', 'TVA', 19, 'vat', 1, 'Romania standard VAT 19%'),
-        ('tax-ro-vat-9', 'RO', 'TVA', 9, 'vat', 0, 'Romania reduced VAT 9% (food, hotels)'),
-        ('tax-ro-vat-5', 'RO', 'TVA', 5, 'vat', 0, 'Romania reduced VAT 5% (housing)'),
-        ('tax-us-none', 'US', 'Sales Tax', 0, 'sales_tax', 1, 'US federal (no federal sales tax)'),
-        ('tax-us-ca', 'US', 'Sales Tax', 7.25, 'sales_tax', 0, 'California base sales tax'),
-        ('tax-us-ny', 'US', 'Sales Tax', 8, 'sales_tax', 0, 'New York sales tax'),
-        ('tax-us-tx', 'US', 'Sales Tax', 6.25, 'sales_tax', 0, 'Texas sales tax'),
-        ('tax-uk-vat-20', 'GB', 'VAT', 20, 'vat', 1, 'UK standard VAT 20%'),
-        ('tax-uk-vat-5', 'GB', 'VAT', 5, 'vat', 0, 'UK reduced VAT 5%'),
-        ('tax-uk-vat-0', 'GB', 'VAT', 0, 'vat', 0, 'UK zero-rated VAT'),
-        ('tax-de-vat-19', 'DE', 'MwSt', 19, 'vat', 1, 'Germany standard VAT 19%'),
-        ('tax-de-vat-7', 'DE', 'MwSt', 7, 'vat', 0, 'Germany reduced VAT 7%'),
-        ('tax-fr-vat-20', 'FR', 'TVA', 20, 'vat', 1, 'France standard VAT 20%'),
-        ('tax-fr-vat-10', 'FR', 'TVA', 10, 'vat', 0, 'France reduced VAT 10%'),
-        ('tax-fr-vat-55', 'FR', 'TVA', 5.5, 'vat', 0, 'France reduced VAT 5.5%'),
-        ('tax-nl-vat-21', 'NL', 'BTW', 21, 'vat', 1, 'Netherlands standard VAT 21%'),
-        ('tax-it-vat-22', 'IT', 'IVA', 22, 'vat', 1, 'Italy standard VAT 22%'),
-        ('tax-es-vat-21', 'ES', 'IVA', 21, 'vat', 1, 'Spain standard VAT 21%'),
-        ('tax-at-vat-20', 'AT', 'USt', 20, 'vat', 1, 'Austria standard VAT 20%'),
-        ('tax-be-vat-21', 'BE', 'BTW', 21, 'vat', 1, 'Belgium standard VAT 21%'),
-        ('tax-pl-vat-23', 'PL', 'VAT', 23, 'vat', 1, 'Poland standard VAT 23%'),
-        ('tax-ie-vat-23', 'IE', 'VAT', 23, 'vat', 1, 'Ireland standard VAT 23%'),
-        ('tax-se-vat-25', 'SE', 'Moms', 25, 'vat', 1, 'Sweden standard VAT 25%'),
-        ('tax-dk-vat-25', 'DK', 'Moms', 25, 'vat', 1, 'Denmark standard VAT 25%'),
-        ('tax-hu-vat-27', 'HU', 'AFA', 27, 'vat', 1, 'Hungary standard VAT 27%'),
-        ('tax-bg-vat-20', 'BG', 'DDC', 20, 'vat', 1, 'Bulgaria standard VAT 20%'),
-        ('tax-eu-rc', 'EU', 'Reverse Charge', 0, 'vat', 0, 'EU B2B reverse charge mechanism');
+  INSERT INTO invoices_fts(invoice_id, number, issuer_name, customer_name, notes)
+  SELECT
+    i.id,
+    i.number,
+    COALESCE((SELECT legal_name FROM parties p WHERE p.id = i.issuer_id), ''),
+    COALESCE((SELECT legal_name FROM parties p WHERE p.id = i.customer_id), ''),
+    COALESCE(i.notes, '')
+  FROM invoices i
+  WHERE i.issuer_id = NEW.id OR i.customer_id = NEW.id;
+END;
 
-      CREATE INDEX IF NOT EXISTS idx_business_profiles_default ON business_profiles(is_default);
-      CREATE INDEX IF NOT EXISTS idx_tax_rules_country ON tax_rules(country);
-      CREATE INDEX IF NOT EXISTS idx_invoices_business ON invoices(business_profile_id);
-    `
+INSERT INTO invoices_fts(invoice_id, number, issuer_name, customer_name, notes)
+SELECT
+  i.id,
+  i.number,
+  COALESCE((SELECT legal_name FROM parties p WHERE p.id = i.issuer_id), ''),
+  COALESCE((SELECT legal_name FROM parties p WHERE p.id = i.customer_id), ''),
+  COALESCE(i.notes, '')
+FROM invoices i
+WHERE i.id NOT IN (SELECT invoice_id FROM invoices_fts);
+`
+  },
+  {
+    id: "0003_agents",
+    sql: `
+CREATE TABLE IF NOT EXISTS agents (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL UNIQUE,
+  description TEXT,
+  focus TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  last_seen_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+`
   }
 ];
 
-// src/db/database.ts
-var _db = null;
-function getDbPath2() {
-  const explicit = process.env["HASNA_INVOICES_DIR"] ?? process.env["INVOICES_DIR"];
-  if (explicit) {
-    return join5(explicit, "invoices.db");
-  }
-  const home = process.env["HOME"] ?? process.env["USERPROFILE"] ?? "~";
-  return join5(home, ".hasna", "invoices", "invoices.db");
+// src/db/migrate.ts
+function ensureMigrationsTable(db) {
+  db.exec(`
+CREATE TABLE IF NOT EXISTS migrations (
+  id TEXT PRIMARY KEY,
+  applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+`);
 }
-function getDatabase() {
-  if (_db)
-    return _db;
-  const dbPath = getDbPath2();
-  const dir = dirname2(dbPath);
-  if (!existsSync4(dir)) {
-    mkdirSync3(dir, { recursive: true });
-  }
-  const adapter = new SqliteAdapter(dbPath);
-  _db = adapter.raw;
-  _db.exec(`
-    CREATE TABLE IF NOT EXISTS _migrations (
-      id INTEGER PRIMARY KEY,
-      name TEXT NOT NULL,
-      applied_at TEXT NOT NULL DEFAULT (datetime('now'))
-    )
-  `);
-  const applied = _db.query("SELECT id FROM _migrations ORDER BY id").all();
-  const appliedIds = new Set(applied.map((r) => r.id));
+function applyMigrations(db) {
+  ensureMigrationsTable(db);
+  const getMigration = db.query("SELECT id FROM migrations WHERE id = ?1");
+  const markMigration = db.query("INSERT INTO migrations (id) VALUES (?1)");
+  const applied = [];
   for (const migration of MIGRATIONS) {
-    if (appliedIds.has(migration.id))
+    const row = getMigration.get(migration.id);
+    if (row) {
       continue;
-    _db.exec("BEGIN");
-    try {
-      _db.exec(migration.sql);
-      _db.prepare("INSERT INTO _migrations (id, name) VALUES (?, ?)").run(migration.id, migration.name);
-      _db.exec("COMMIT");
-    } catch (error) {
-      _db.exec("ROLLBACK");
-      throw new Error(`Migration ${migration.id} (${migration.name}) failed: ${error instanceof Error ? error.message : String(error)}`);
     }
+    db.transaction(() => {
+      db.exec(migration.sql);
+      markMigration.run(migration.id);
+    });
+    applied.push(migration.id);
   }
-  return _db;
+  return applied;
 }
-function closeDatabase() {
-  if (_db) {
-    _db.close();
-    _db = null;
+function migrateDatabase(options = {}) {
+  const db = openInvoiceDatabase(options);
+  try {
+    return applyMigrations(db);
+  } finally {
+    db.close();
   }
 }
-
-// src/db/invoices.ts
-function rowToInvoice(row) {
-  return {
-    ...row,
-    reverse_charge: row.reverse_charge === 1,
-    tax_name: row["tax_name"] || "Tax",
-    language: row["language"] || "en",
-    footer_text: row["footer_text"] ?? null,
-    business_profile_id: row["business_profile_id"] ?? null,
-    metadata: JSON.parse(row.metadata || "{}")
-  };
-}
-function nextInvoiceNumber() {
-  const db = getDatabase();
-  const counter = db.prepare("SELECT prefix, next_number FROM invoice_counter WHERE id = 1").get();
-  const number = `${counter.prefix}-${String(counter.next_number).padStart(5, "0")}`;
-  db.prepare("UPDATE invoice_counter SET next_number = next_number + 1 WHERE id = 1").run();
-  return number;
+// src/db/pg.ts
+function defaultPgConnectionString() {
+  return process.env.INVOICES_DATABASE_URL ?? getConnectionString("invoices");
 }
-function recalculateInvoice(invoiceId) {
-  const db = getDatabase();
-  const row = db.prepare("SELECT COALESCE(SUM(amount), 0) as subtotal FROM line_items WHERE invoice_id = ?").get(invoiceId);
-  const invoice = db.prepare("SELECT tax_rate, discount FROM invoices WHERE id = ?").get(invoiceId);
-  const subtotal = row.subtotal;
-  const discounted = subtotal - (invoice.discount || 0);
-  const taxAmount = discounted * ((invoice.tax_rate || 0) / 100);
-  const total = discounted + taxAmount;
-  db.prepare("UPDATE invoices SET subtotal = ?, tax_amount = ?, total = ?, updated_at = datetime('now') WHERE id = ?").run(subtotal, taxAmount, total, invoiceId);
+async function migratePgDatabase(connectionString = defaultPgConnectionString()) {
+  const pgMigrations = MIGRATIONS.map((migration) => translateDdl(migration.sql, "pg"));
+  return applyPgMigrations(connectionString, pgMigrations, "invoices");
 }
-function createInvoice(input = {}) {
-  const db = getDatabase();
-  const id = crypto.randomUUID();
-  const invoiceNumber = input.invoice_number || nextInvoiceNumber();
-  db.prepare(`INSERT INTO invoices (id, invoice_number, client_id, business_profile_id, issue_date, due_date, currency, tax_rate, tax_name, discount, reverse_charge, language, notes, footer_text)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, invoiceNumber, input.client_id || null, input.business_profile_id || null, input.issue_date ?? new Date().toISOString().split("T")[0], input.due_date ?? null, input.currency || "USD", input.tax_rate || 0, input.tax_name || "Tax", input.discount || 0, input.reverse_charge ? 1 : 0, input.language || "en", input.notes || null, input.footer_text || null);
-  return getInvoice(id);
+// src/db/cloud.ts
+function defaultConnectionString() {
+  return process.env.INVOICES_DATABASE_URL ?? getConnectionString("invoices");
 }
-function getInvoice(id) {
-  const db = getDatabase();
-  const row = db.prepare("SELECT * FROM invoices WHERE id = ? OR invoice_number = ?").get(id, id);
-  return row ? rowToInvoice(row) : null;
+function parseTablesArg(tables) {
+  if (!tables)
+    return [];
+  return tables.split(",").map((table) => table.trim()).filter(Boolean);
 }
-function getInvoiceWithItems(id) {
-  const invoice = getInvoice(id);
-  if (!invoice)
-    return null;
-  const db = getDatabase();
-  const line_items = db.prepare("SELECT * FROM line_items WHERE invoice_id = ? ORDER BY sort_order").all(invoice.id);
-  const payments = db.prepare("SELECT * FROM payments WHERE invoice_id = ? ORDER BY paid_at").all(invoice.id);
-  return { ...invoice, line_items, payments };
+function resolveTables(local, tablesCsv) {
+  const configured = parseTablesArg(tablesCsv);
+  return configured.length > 0 ? configured : listSqliteTables(local);
 }
-function listInvoices(options = {}) {
-  const db = getDatabase();
-  const conditions = [];
-  const params = [];
-  if (options.status) {
-    conditions.push("status = ?");
-    params.push(options.status);
-  }
-  if (options.client_id) {
-    conditions.push("client_id = ?");
-    params.push(options.client_id);
-  }
-  if (options.from_date) {
-    conditions.push("issue_date >= ?");
-    params.push(options.from_date);
-  }
-  if (options.to_date) {
-    conditions.push("issue_date <= ?");
-    params.push(options.to_date);
-  }
-  let sql = "SELECT * FROM invoices";
-  if (conditions.length > 0) {
-    sql += " WHERE " + conditions.join(" AND ");
+async function cloudPush(local, tablesCsv, connectionString = defaultConnectionString()) {
+  const remote = new PgAdapterAsync(connectionString);
+  try {
+    const tables = resolveTables(local, tablesCsv);
+    const result = await syncPush(local, remote, { tables });
+    return { direction: "push", tables, result };
+  } finally {
+    await remote.close();
   }
-  sql += " ORDER BY created_at DESC";
-  if (options.limit) {
-    sql += " LIMIT ?";
-    params.push(options.limit);
+}
+async function cloudPull(local, tablesCsv, connectionString = defaultConnectionString()) {
+  const remote = new PgAdapterAsync(connectionString);
+  try {
+    const tables = resolveTables(local, tablesCsv);
+    const result = await syncPull(remote, local, { tables });
+    return { direction: "pull", tables, result };
+  } finally {
+    await remote.close();
   }
-  const rows = db.prepare(sql).all(...params);
-  return rows.map(rowToInvoice);
 }
-function updateInvoiceStatus(id, status) {
-  const db = getDatabase();
-  const paidAt = status === "paid" ? "datetime('now')" : "NULL";
-  db.prepare(`UPDATE invoices SET status = ?, paid_at = ${paidAt}, updated_at = datetime('now') WHERE id = ?`).run(status, id);
-  return getInvoice(id);
+async function submitFeedback(local, feedback) {
+  const payload = {
+    service: "invoices",
+    version: feedback.version,
+    message: feedback.message,
+    email: feedback.email,
+    machine_id: feedback.machine_id
+  };
+  const delivery = await sendFeedback(payload, local);
+  if (!delivery.sent) {
+    const id = saveFeedback(local, payload);
+    return { ...delivery, id, stored_locally: true };
+  }
+  return { ...delivery, stored_locally: false };
 }
-function deleteInvoice(id) {
-  const db = getDatabase();
-  return db.prepare("DELETE FROM invoices WHERE id = ?").run(id).changes > 0;
+// src/db/invoices.ts
+import { randomUUID } from "crypto";
+function toLineTotalCents(line) {
+  const subtotal = Math.round(line.quantity * line.unitPriceCents);
+  const taxRate = line.taxRateBasisPoints ?? 0;
+  const tax = Math.round(subtotal * taxRate / 1e4);
+  return { lineTotalCents: subtotal, lineTaxCents: tax };
 }
-function addLineItem(input) {
-  const db = getDatabase();
-  const id = crypto.randomUUID();
-  const quantity = input.quantity || 1;
-  const amount = quantity * input.unit_price;
-  const maxOrder = db.prepare("SELECT COALESCE(MAX(sort_order), -1) as max_order FROM line_items WHERE invoice_id = ?").get(input.invoice_id);
-  db.prepare(`INSERT INTO line_items (id, invoice_id, description, quantity, unit_price, amount, sort_order)
-     VALUES (?, ?, ?, ?, ?, ?, ?)`).run(id, input.invoice_id, input.description, quantity, input.unit_price, amount, maxOrder.max_order + 1);
-  recalculateInvoice(input.invoice_id);
-  return db.prepare("SELECT * FROM line_items WHERE id = ?").get(id);
+function mapPartyRow(row) {
+  return {
+    id: row.id,
+    kind: row.kind,
+    legalName: row.legal_name,
+    email: row.email ?? undefined,
+    taxId: row.tax_id ?? undefined,
+    country: row.country ?? undefined,
+    address: row.address ?? undefined,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
 }
-function removeLineItem(id) {
-  const db = getDatabase();
-  const item = db.prepare("SELECT invoice_id FROM line_items WHERE id = ?").get(id);
-  if (!item)
-    return false;
-  db.prepare("DELETE FROM line_items WHERE id = ?").run(id);
-  recalculateInvoice(item.invoice_id);
-  return true;
+function mapInvoiceRow(row) {
+  return {
+    id: row.id,
+    number: row.number,
+    issuerId: row.issuer_id,
+    customerId: row.customer_id,
+    status: row.status,
+    currency: row.currency,
+    notes: row.notes ?? undefined,
+    issuedAt: row.issued_at,
+    dueAt: row.due_at ?? undefined,
+    subtotalCents: row.subtotal_cents,
+    taxCents: row.tax_cents,
+    totalCents: row.total_cents,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
 }
-function recordPayment(input) {
-  const db = getDatabase();
-  const id = crypto.randomUUID();
-  db.prepare(`INSERT INTO payments (id, invoice_id, amount, method, reference, notes)
-     VALUES (?, ?, ?, ?, ?, ?)`).run(id, input.invoice_id, input.amount, input.method || null, input.reference || null, input.notes || null);
-  const invoice = getInvoice(input.invoice_id);
-  if (invoice) {
-    const totalPaid = db.prepare("SELECT COALESCE(SUM(amount), 0) as total FROM payments WHERE invoice_id = ?").get(input.invoice_id);
-    if (totalPaid.total >= invoice.total) {
-      updateInvoiceStatus(input.invoice_id, "paid");
-    }
-  }
-  return db.prepare("SELECT * FROM payments WHERE id = ?").get(id);
+function mapInvoiceLineRow(row) {
+  return {
+    id: row.id,
+    invoiceId: row.invoice_id,
+    position: row.position,
+    description: row.description,
+    quantity: row.quantity,
+    unitPriceCents: row.unit_price_cents,
+    taxRateBasisPoints: row.tax_rate_basis_points,
+    lineTotalCents: row.line_total_cents,
+    createdAt: row.created_at
+  };
 }
-function getInvoiceSummary() {
-  const db = getDatabase();
-  const counts = db.prepare(`SELECT
-        COUNT(*) as total_invoices,
-        SUM(CASE WHEN status = 'draft' THEN 1 ELSE 0 END) as draft,
-        SUM(CASE WHEN status = 'sent' THEN 1 ELSE 0 END) as sent,
-        SUM(CASE WHEN status = 'paid' THEN 1 ELSE 0 END) as paid,
-        SUM(CASE WHEN status = 'overdue' THEN 1 ELSE 0 END) as overdue,
-        COALESCE(SUM(CASE WHEN status IN ('sent', 'overdue') THEN total ELSE 0 END), 0) as total_outstanding,
-        COALESCE(SUM(CASE WHEN status = 'paid' THEN total ELSE 0 END), 0) as total_paid
-      FROM invoices`).get();
-  return counts;
+function createParty(db, input) {
+  const id = input.id ?? randomUUID();
+  db.query(`
+INSERT INTO parties (id, kind, legal_name, email, tax_id, country, address)
+VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)
+`).run(id, input.kind, input.legalName, input.email ?? null, input.taxId ?? null, input.country ?? null, input.address ?? null);
+  return getPartyById(db, id);
 }
-// src/db/clients.ts
-function rowToClient(row) {
-  return { ...row, metadata: JSON.parse(row.metadata || "{}") };
+function updateParty(db, id, updates) {
+  db.query(`
+UPDATE parties
+SET legal_name = COALESCE(?2, legal_name),
+    email = COALESCE(?3, email),
+    tax_id = COALESCE(?4, tax_id),
+    country = COALESCE(?5, country),
+    address = COALESCE(?6, address),
+    updated_at = datetime('now')
+WHERE id = ?1
+`).run(id, updates.legalName ?? null, updates.email ?? null, updates.taxId ?? null, updates.country ?? null, updates.address ?? null);
+  return getPartyById(db, id);
 }
-function createClient(input) {
-  const db = getDatabase();
-  const id = crypto.randomUUID();
-  db.prepare(`INSERT INTO clients (id, name, email, phone, address, address_line1, address_line2, city, state, postal_code, country, tax_id, vat_number, language, notes)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, input.name, input.email || null, input.phone || null, input.address || null, input.address_line1 || null, input.address_line2 || null, input.city || null, input.state || null, input.postal_code || null, input.country || null, input.tax_id || null, input.vat_number || null, input.language || null, input.notes || null);
-  return getClient(id);
+function getPartyById(db, id) {
+  const row = db.query("SELECT * FROM parties WHERE id = ?1").get(id);
+  return row ? mapPartyRow(row) : null;
 }
-function getClient(id) {
-  const db = getDatabase();
-  const row = db.prepare("SELECT * FROM clients WHERE id = ?").get(id);
-  return row ? rowToClient(row) : null;
+function listParties(db, kind) {
+  if (kind) {
+    return db.query("SELECT * FROM parties WHERE kind = ?1 ORDER BY legal_name ASC").all(kind).map(mapPartyRow);
+  }
+  return db.query("SELECT * FROM parties ORDER BY legal_name ASC").all().map(mapPartyRow);
 }
-function listClients(search) {
-  const db = getDatabase();
-  if (search) {
-    const q = `%${search}%`;
-    const rows = db.prepare("SELECT * FROM clients WHERE name LIKE ? OR email LIKE ? ORDER BY name").all(q, q);
-    return rows.map(rowToClient);
-  }
-  return db.prepare("SELECT * FROM clients ORDER BY name").all().map(rowToClient);
+function createInvoice(db, input) {
+  const invoiceId = input.id ?? randomUUID();
+  const preparedLines = input.lines.map((line, index) => {
+    const { lineTotalCents, lineTaxCents } = toLineTotalCents(line);
+    return {
+      id: line.id ?? randomUUID(),
+      position: index,
+      description: line.description,
+      quantity: line.quantity,
+      unitPriceCents: line.unitPriceCents,
+      taxRateBasisPoints: line.taxRateBasisPoints ?? 0,
+      lineTotalCents,
+      lineTaxCents
+    };
+  });
+  const subtotalCents = preparedLines.reduce((sum, line) => sum + line.lineTotalCents, 0);
+  const taxCents = preparedLines.reduce((sum, line) => sum + line.lineTaxCents, 0);
+  const totalCents = subtotalCents + taxCents;
+  db.transaction(() => {
+    db.query(`
+INSERT INTO invoices (
+  id, number, issuer_id, customer_id, status, currency, notes, issued_at, due_at, subtotal_cents, tax_cents, total_cents
+)
+VALUES (?1, ?2, ?3, ?4, 'draft', ?5, ?6, ?7, ?8, ?9, ?10, ?11)
+`).run(invoiceId, input.number, input.issuerId, input.customerId, input.currency, input.notes ?? null, input.issuedAt, input.dueAt ?? null, subtotalCents, taxCents, totalCents);
+    const insertLine = db.query(`
+INSERT INTO invoice_lines (
+  id, invoice_id, position, description, quantity, unit_price_cents, tax_rate_basis_points, line_total_cents
+)
+VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8)
+`);
+    for (const line of preparedLines) {
+      insertLine.run(line.id, invoiceId, line.position, line.description, line.quantity, line.unitPriceCents, line.taxRateBasisPoints, line.lineTotalCents);
+    }
+  });
+  return getInvoiceById(db, invoiceId);
 }
-function updateClient(id, input) {
-  const db = getDatabase();
-  const existing = getClient(id);
-  if (!existing)
+function getInvoiceById(db, id) {
+  const invoiceRow = db.query("SELECT * FROM invoices WHERE id = ?1").get(id);
+  if (!invoiceRow) {
     return null;
-  const sets = [];
-  const params = [];
-  for (const [key, value] of Object.entries(input)) {
-    if (value !== undefined) {
-      sets.push(`${key} = ?`);
-      params.push(value);
-    }
-  }
-  if (sets.length === 0)
-    return existing;
-  sets.push("updated_at = datetime('now')");
-  params.push(id);
-  db.prepare(`UPDATE clients SET ${sets.join(", ")} WHERE id = ?`).run(...params);
-  return getClient(id);
-}
-function deleteClient(id) {
-  const db = getDatabase();
-  return db.prepare("DELETE FROM clients WHERE id = ?").run(id).changes > 0;
-}
-// src/db/business.ts
-function rowToBusiness(row) {
+  }
+  const lines = db.query("SELECT * FROM invoice_lines WHERE invoice_id = ?1 ORDER BY position ASC").all(id).map(mapInvoiceLineRow);
   return {
-    ...row,
-    is_default: row.is_default === 1,
-    metadata: JSON.parse(row.metadata || "{}")
+    ...mapInvoiceRow(invoiceRow),
+    lines
   };
 }
-function createBusinessProfile(input) {
-  const db = getDatabase();
-  const id = crypto.randomUUID();
-  if (input.is_default) {
-    db.prepare("UPDATE business_profiles SET is_default = 0").run();
-  }
-  db.prepare(`INSERT INTO business_profiles (id, name, address_line1, address_line2, city, state, postal_code, country, tax_id, vat_number, registration_number, email, phone, website, bank_name, bank_iban, bank_swift, bank_account, logo_url, is_default)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, input.name, input.address_line1 || null, input.address_line2 || null, input.city || null, input.state || null, input.postal_code || null, input.country || "US", input.tax_id || null, input.vat_number || null, input.registration_number || null, input.email || null, input.phone || null, input.website || null, input.bank_name || null, input.bank_iban || null, input.bank_swift || null, input.bank_account || null, input.logo_url || null, input.is_default ? 1 : 0);
-  return getBusinessProfile(id);
-}
-function getBusinessProfile(id) {
-  const db = getDatabase();
-  const row = db.prepare("SELECT * FROM business_profiles WHERE id = ?").get(id);
-  return row ? rowToBusiness(row) : null;
-}
-function getDefaultBusinessProfile() {
-  const db = getDatabase();
-  const row = db.prepare("SELECT * FROM business_profiles WHERE is_default = 1").get();
-  return row ? rowToBusiness(row) : null;
+function listInvoices(db, options = {}) {
+  const limit = options.limit ?? 50;
+  const offset = options.offset ?? 0;
+  if (options.status) {
+    return db.query("SELECT * FROM invoices WHERE status = ?1 ORDER BY issued_at DESC, created_at DESC LIMIT ?2 OFFSET ?3").all(options.status, limit, offset).map(mapInvoiceRow);
+  }
+  return db.query("SELECT * FROM invoices ORDER BY issued_at DESC, created_at DESC LIMIT ?1 OFFSET ?2").all(limit, offset).map(mapInvoiceRow);
 }
-function listBusinessProfiles() {
-  const db = getDatabase();
-  return db.prepare("SELECT * FROM business_profiles ORDER BY is_default DESC, name").all().map(rowToBusiness);
+function updateInvoiceStatus(db, id, status) {
+  db.query("UPDATE invoices SET status = ?2, updated_at = datetime('now') WHERE id = ?1").run(id, status);
+  const row = db.query("SELECT * FROM invoices WHERE id = ?1").get(id);
+  return row ? mapInvoiceRow(row) : null;
 }
-function updateBusinessProfile(id, input) {
-  const db = getDatabase();
-  if (!getBusinessProfile(id))
-    return null;
-  const sets = [];
-  const params = [];
-  for (const [key, value] of Object.entries(input)) {
-    if (value === undefined)
-      continue;
-    if (key === "is_default") {
-      if (value)
-        db.prepare("UPDATE business_profiles SET is_default = 0").run();
-      sets.push("is_default = ?");
-      params.push(value ? 1 : 0);
-    } else {
-      sets.push(`${key} = ?`);
-      params.push(value);
-    }
-  }
-  if (sets.length === 0)
-    return getBusinessProfile(id);
-  sets.push("updated_at = datetime('now')");
-  params.push(id);
-  db.prepare(`UPDATE business_profiles SET ${sets.join(", ")} WHERE id = ?`).run(...params);
-  return getBusinessProfile(id);
+function deleteInvoice(db, id) {
+  const result = db.query("DELETE FROM invoices WHERE id = ?1").run(id);
+  return result.changes > 0;
 }
-function deleteBusinessProfile(id) {
-  return getDatabase().prepare("DELETE FROM business_profiles WHERE id = ?").run(id).changes > 0;
+function rebuildInvoiceSearchIndex(db) {
+  db.exec("DELETE FROM invoices_fts;");
+  db.exec(`
+INSERT INTO invoices_fts(invoice_id, number, issuer_name, customer_name, notes)
+SELECT
+  i.id,
+  i.number,
+  COALESCE((SELECT legal_name FROM parties p WHERE p.id = i.issuer_id), ''),
+  COALESCE((SELECT legal_name FROM parties p WHERE p.id = i.customer_id), ''),
+  COALESCE(i.notes, '')
+FROM invoices i;
+`);
 }
-function rowToTaxRule(row) {
-  return { ...row, is_default: row.is_default === 1, reverse_charge: row.reverse_charge === 1 };
+function searchInvoices(db, query, options = {}) {
+  const limit = options.limit ?? 20;
+  const offset = options.offset ?? 0;
+  const escapedPhrase = `"${query.replace(/"/g, '""')}"`;
+  if (options.status) {
+    return db.query(`
+SELECT i.*
+FROM invoices_fts f
+JOIN invoices i ON i.id = f.invoice_id
+WHERE invoices_fts MATCH ?1
+  AND i.status = ?2
+ORDER BY bm25(invoices_fts)
+LIMIT ?3
+OFFSET ?4
+`).all(escapedPhrase, options.status, limit, offset).map(mapInvoiceRow);
+  }
+  return db.query(`
+SELECT i.*
+FROM invoices_fts f
+JOIN invoices i ON i.id = f.invoice_id
+WHERE invoices_fts MATCH ?1
+ORDER BY bm25(invoices_fts)
+LIMIT ?2
+OFFSET ?3
+`).all(escapedPhrase, limit, offset).map(mapInvoiceRow);
 }
-function getTaxRulesForCountry(country) {
-  const db = getDatabase();
-  return db.prepare("SELECT * FROM tax_rules WHERE country = ? ORDER BY is_default DESC, rate DESC").all(country).map(rowToTaxRule);
+// src/db/agents.ts
+import { randomUUID as randomUUID2 } from "crypto";
+function mapAgent(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    description: row.description ?? undefined,
+    focus: row.focus ?? undefined,
+    createdAt: row.created_at,
+    lastSeenAt: row.last_seen_at
+  };
 }
-function getDefaultTaxRule(country) {
-  const db = getDatabase();
-  const row = db.prepare("SELECT * FROM tax_rules WHERE country = ? AND is_default = 1").get(country);
-  return row ? rowToTaxRule(row) : null;
+function registerAgent(db, input) {
+  const existing = db.query("SELECT * FROM agents WHERE name = ?1").get(input.name);
+  if (existing) {
+    db.query("UPDATE agents SET description = COALESCE(?2, description), last_seen_at = datetime('now') WHERE name = ?1").run(input.name, input.description ?? null);
+    return getAgentByName(db, input.name);
+  }
+  const id = randomUUID2();
+  db.query("INSERT INTO agents (id, name, description) VALUES (?1, ?2, ?3)").run(id, input.name, input.description ?? null);
+  return getAgentById(db, id);
 }
-function getTaxRule(id) {
-  const db = getDatabase();
-  const row = db.prepare("SELECT * FROM tax_rules WHERE id = ?").get(id);
-  return row ? rowToTaxRule(row) : null;
+function getAgentById(db, id) {
+  const row = db.query("SELECT * FROM agents WHERE id = ?1").get(id);
+  return row ? mapAgent(row) : null;
 }
-function listAllTaxRules() {
-  const db = getDatabase();
-  return db.prepare("SELECT * FROM tax_rules ORDER BY country, is_default DESC, rate DESC").all().map(rowToTaxRule);
+function getAgentByName(db, name) {
+  const row = db.query("SELECT * FROM agents WHERE name = ?1").get(name);
+  return row ? mapAgent(row) : null;
 }
-function createTaxRule(input) {
-  const db = getDatabase();
-  const id = crypto.randomUUID();
-  db.prepare(`INSERT INTO tax_rules (id, country, region, tax_name, rate, type, is_default, reverse_charge, description)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, input.country, input.region || null, input.tax_name, input.rate, input.type || "vat", input.is_default ? 1 : 0, input.reverse_charge ? 1 : 0, input.description || null);
-  return getTaxRule(id);
+function heartbeatAgent(db, agentId) {
+  db.query("UPDATE agents SET last_seen_at = datetime('now') WHERE id = ?1").run(agentId);
+  return getAgentById(db, agentId);
 }
-function deleteTaxRule(id) {
-  return getDatabase().prepare("DELETE FROM tax_rules WHERE id = ?").run(id).changes > 0;
+function setAgentFocus(db, agentId, focus) {
+  db.query("UPDATE agents SET focus = ?2, last_seen_at = datetime('now') WHERE id = ?1").run(agentId, focus ?? null);
+  return getAgentById(db, agentId);
 }
-function determineTax(issuerCountry, clientCountry, clientVatNumber) {
-  const EU_COUNTRIES = ["AT", "BE", "BG", "HR", "CY", "CZ", "DK", "EE", "FI", "FR", "DE", "GR", "HU", "IE", "IT", "LV", "LT", "LU", "MT", "NL", "PL", "PT", "RO", "SK", "SI", "ES", "SE"];
-  const issuerInEU = EU_COUNTRIES.includes(issuerCountry);
-  const clientInEU = EU_COUNTRIES.includes(clientCountry);
-  if (issuerInEU && clientInEU && issuerCountry !== clientCountry && clientVatNumber) {
-    return { tax_rate: 0, tax_name: "Reverse Charge", reverse_charge: true };
-  }
-  const defaultRule = getDefaultTaxRule(issuerCountry);
-  if (defaultRule) {
-    return { tax_rate: defaultRule.rate, tax_name: defaultRule.tax_name, reverse_charge: false };
-  }
-  return { tax_rate: 0, tax_name: "Tax", reverse_charge: false };
+function listAgents(db) {
+  return db.query("SELECT * FROM agents ORDER BY last_seen_at DESC").all().map(mapAgent);
 }
 export {
+  updateParty,
   updateInvoiceStatus,
-  updateClient,
-  updateBusinessProfile,
-  removeLineItem,
-  recordPayment,
+  submitFeedback,
+  setAgentFocus,
+  searchInvoices,
+  registerAgent,
+  rebuildInvoiceSearchIndex,
+  openInvoiceDatabase,
+  migratePgDatabase,
+  migrateDatabase,
+  listParties,
   listInvoices,
-  listClients,
-  listBusinessProfiles,
-  listAllTaxRules,
-  getTaxRulesForCountry,
-  getTaxRule,
-  getInvoiceWithItems,
-  getInvoiceSummary,
-  getInvoice,
-  getDefaultTaxRule,
-  getDefaultBusinessProfile,
-  getDatabase,
-  getClient,
-  getBusinessProfile,
-  determineTax,
-  deleteTaxRule,
+  listAgents,
+  heartbeatAgent,
+  getPartyById,
+  getInvoiceById,
+  getAgentByName,
+  getAgentById,
   deleteInvoice,
-  deleteClient,
-  deleteBusinessProfile,
-  createTaxRule,
+  defaultPgConnectionString,
+  defaultDatabasePath,
+  defaultConnectionString,
+  createParty,
   createInvoice,
-  createClient,
-  createBusinessProfile,
-  closeDatabase,
-  addLineItem
+  cloudPush,
+  cloudPull,
+  applyMigrations,
+  VERSION
 };