@hasna/invoices 0.1.0 → 0.1.1

package/dist/mcp/index.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env bun
 // @bun
 var __defProp = Object.defineProperty;
 var __returnValue = (v) => v;
@@ -16,6 +16,9 @@ var __export = (target, all) => {
 };
 
 // src/mcp/index.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname3, join as join7 } from "path";
+import { fileURLToPath } from "url";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
@@ -3992,6 +3995,10 @@ var coerce = {
   date: (arg) => ZodDate.create({ ...arg, coerce: true })
 };
 var NEVER = INVALID;
+// 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";
@@ -4009,6 +4016,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";
@@ -5352,7 +5360,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"];
@@ -5365,7 +5373,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,
@@ -5401,20 +5409,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;
@@ -5577,11 +5585,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;
@@ -7432,7 +7440,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.");
@@ -7648,7 +7656,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);
@@ -8926,6 +8934,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) {
@@ -9113,6 +9133,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();
 });
@@ -13375,7 +13452,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 {
@@ -13508,6 +14072,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();
@@ -13518,847 +14118,801 @@ 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";
+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/migrations.ts
+// 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 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 migrations (
+  id TEXT PRIMARY KEY,
+  applied_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 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 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 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 invoice_counter (
-        id INTEGER PRIMARY KEY CHECK (id = 1),
-        prefix TEXT NOT NULL DEFAULT 'INV',
-        next_number INTEGER NOT NULL DEFAULT 1
-      );
+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'))
+);
 
-      INSERT OR IGNORE INTO invoice_counter (id, prefix, next_number) VALUES (1, 'INV', 1);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_invoice_lines_invoice_position
+ON invoice_lines(invoice_id, position);
 
-      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 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 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 VIRTUAL TABLE IF NOT EXISTS invoices_fts USING fts5(
+  invoice_id UNINDEXED,
+  number,
+  issuer_name,
+  customer_name,
+  notes
+);
 
-      -- 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_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 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';
+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 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");
-}
-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));
+// 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 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 applied;
+}
+function migrateDatabase(options = {}) {
+  const db = openInvoiceDatabase(options);
+  try {
+    return applyMigrations(db);
+  } finally {
+    db.close();
   }
-  return _db;
 }
 
-// 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;
-}
-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);
-}
-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);
-}
-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 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 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 ");
-  }
-  sql += " ORDER BY created_at DESC";
-  if (options.limit) {
-    sql += " LIMIT ?";
-    params.push(options.limit);
-  }
-  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);
-}
-function deleteInvoice(id) {
-  const db = getDatabase();
-  return db.prepare("DELETE FROM invoices WHERE id = ?").run(id).changes > 0;
-}
-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 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;
+// src/db/cloud.ts
+function defaultConnectionString() {
+  return process.env.INVOICES_DATABASE_URL ?? getConnectionString("invoices");
 }
-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 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 parseTablesArg(tables) {
+  if (!tables)
+    return [];
+  return tables.split(",").map((table) => table.trim()).filter(Boolean);
 }
-
-// src/db/clients.ts
-function rowToClient(row) {
-  return { ...row, metadata: JSON.parse(row.metadata || "{}") };
-}
-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 getClient(id) {
-  const db = getDatabase();
-  const row = db.prepare("SELECT * FROM clients WHERE id = ?").get(id);
-  return row ? rowToClient(row) : null;
-}
-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 updateClient(id, input) {
-  const db = getDatabase();
-  const existing = getClient(id);
-  if (!existing)
-    return null;
-  const sets = [];
-  const params = [];
-  for (const [key, value] of Object.entries(input)) {
-    if (value !== undefined) {
-      sets.push(`${key} = ?`);
-      params.push(value);
-    }
+function resolveTables(local, tablesCsv) {
+  const configured = parseTablesArg(tablesCsv);
+  return configured.length > 0 ? configured : listSqliteTables(local);
+}
+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();
   }
-  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;
+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();
+  }
+}
+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 };
 }
 
-// src/db/business.ts
-function rowToBusiness(row) {
+// src/db/pg.ts
+function defaultPgConnectionString() {
+  return process.env.INVOICES_DATABASE_URL ?? getConnectionString("invoices");
+}
+async function migratePgDatabase(connectionString = defaultPgConnectionString()) {
+  const pgMigrations = MIGRATIONS.map((migration) => translateDdl(migration.sql, "pg"));
+  return applyPgMigrations(connectionString, pgMigrations, "invoices");
+}
+
+// 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 mapPartyRow(row) {
   return {
-    ...row,
-    is_default: row.is_default === 1,
-    metadata: JSON.parse(row.metadata || "{}")
-  };
-}
-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 listBusinessProfiles() {
-  const db = getDatabase();
-  return db.prepare("SELECT * FROM business_profiles ORDER BY is_default DESC, name").all().map(rowToBusiness);
-}
-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);
+    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 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 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 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);
+}
+function getPartyById(db, id) {
+  const row = db.query("SELECT * FROM parties WHERE id = ?1").get(id);
+  return row ? mapPartyRow(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 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 getInvoiceById(db, id) {
+  const invoiceRow = db.query("SELECT * FROM invoices WHERE id = ?1").get(id);
+  if (!invoiceRow) {
+    return null;
+  }
+  const lines = db.query("SELECT * FROM invoice_lines WHERE invoice_id = ?1 ORDER BY position ASC").all(id).map(mapInvoiceLineRow);
+  return {
+    ...mapInvoiceRow(invoiceRow),
+    lines
+  };
+}
+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);
   }
-  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);
+  return db.query("SELECT * FROM invoices ORDER BY issued_at DESC, created_at DESC LIMIT ?1 OFFSET ?2").all(limit, offset).map(mapInvoiceRow);
 }
-function deleteBusinessProfile(id) {
-  return getDatabase().prepare("DELETE FROM business_profiles WHERE id = ?").run(id).changes > 0;
+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 rowToTaxRule(row) {
-  return { ...row, is_default: row.is_default === 1, reverse_charge: row.reverse_charge === 1 };
+function deleteInvoice(db, id) {
+  const result = db.query("DELETE FROM invoices WHERE id = ?1").run(id);
+  return result.changes > 0;
 }
-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);
+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);
+}
+
+// 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);
 }
 
 // src/mcp/index.ts
+function getMcpVersion() {
+  try {
+    const __dir = dirname3(fileURLToPath(import.meta.url));
+    const pkgPath = join7(__dir, "..", "..", "package.json");
+    return JSON.parse(readFileSync2(pkgPath, "utf-8")).version || "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
 var server = new McpServer({
   name: "invoices",
-  version: "0.1.0"
+  version: getMcpVersion()
+});
+var statusSchema = exports_external.enum(["draft", "sent", "partially_paid", "paid", "void", "overdue"]);
+server.registerTool("health", {
+  title: "Health",
+  description: "Health check and current SQLite database path.",
+  inputSchema: {}
+}, async () => {
+  const db = openInvoiceDatabase();
+  const path = db.filename;
+  db.close();
+  return { content: [{ type: "text", text: JSON.stringify({ ok: true, dbPath: path }) }] };
+});
+server.registerTool("migrate_database", {
+  title: "Migrate Database",
+  description: "Apply pending SQLite schema migrations.",
+  inputSchema: {}
+}, async () => {
+  const applied = migrateDatabase();
+  return { content: [{ type: "text", text: JSON.stringify({ applied }) }] };
+});
+server.registerTool("create_party", {
+  title: "Create Party",
+  description: "Create invoice issuer/customer party.",
+  inputSchema: {
+    kind: exports_external.enum(["issuer", "customer"]),
+    legal_name: exports_external.string().min(1),
+    email: exports_external.string().email().optional(),
+    tax_id: exports_external.string().optional(),
+    country: exports_external.string().optional(),
+    address: exports_external.string().optional()
+  }
+}, async (input) => {
+  const db = openInvoiceDatabase();
+  try {
+    const party = createParty(db, {
+      kind: input.kind,
+      legalName: input.legal_name,
+      email: input.email,
+      taxId: input.tax_id,
+      country: input.country,
+      address: input.address
+    });
+    return { content: [{ type: "text", text: JSON.stringify(party) }] };
+  } finally {
+    db.close();
+  }
+});
+server.registerTool("list_parties", {
+  title: "List Parties",
+  description: "List registered invoice parties.",
+  inputSchema: {
+    kind: exports_external.enum(["issuer", "customer"]).optional()
+  }
+}, async (input) => {
+  const db = openInvoiceDatabase();
+  try {
+    const parties = listParties(db, input.kind);
+    return { content: [{ type: "text", text: JSON.stringify(parties) }] };
+  } finally {
+    db.close();
+  }
 });
 server.registerTool("create_invoice", {
   title: "Create Invoice",
-  description: "Create a new invoice. Auto-generates an invoice number (INV-00001, etc.).",
+  description: "Create invoice with lines and calculated totals.",
   inputSchema: {
-    client_id: exports_external.string().optional(),
-    business_profile_id: exports_external.string().optional(),
-    due_date: exports_external.string().optional(),
-    currency: exports_external.string().optional(),
-    tax_rate: exports_external.number().optional(),
-    tax_name: exports_external.string().optional(),
-    discount: exports_external.number().optional(),
-    reverse_charge: exports_external.boolean().optional(),
-    language: exports_external.string().optional(),
+    number: exports_external.string().min(1),
+    issuer_id: exports_external.string().min(1),
+    customer_id: exports_external.string().min(1),
+    currency: exports_external.string().min(3),
     notes: exports_external.string().optional(),
-    footer_text: exports_external.string().optional()
+    issued_at: exports_external.string().min(1),
+    due_at: exports_external.string().optional(),
+    lines: exports_external.array(exports_external.object({
+      description: exports_external.string().min(1),
+      quantity: exports_external.number().positive(),
+      unit_price_cents: exports_external.number().int().nonnegative(),
+      tax_rate_basis_points: exports_external.number().int().nonnegative().optional()
+    }))
+  }
+}, async (input) => {
+  const db = openInvoiceDatabase();
+  try {
+    const invoice = createInvoice(db, {
+      number: input.number,
+      issuerId: input.issuer_id,
+      customerId: input.customer_id,
+      currency: input.currency,
+      notes: input.notes,
+      issuedAt: input.issued_at,
+      dueAt: input.due_at,
+      lines: input.lines.map((line) => ({
+        description: line.description,
+        quantity: line.quantity,
+        unitPriceCents: line.unit_price_cents,
+        taxRateBasisPoints: line.tax_rate_basis_points
+      }))
+    });
+    return { content: [{ type: "text", text: JSON.stringify(invoice) }] };
+  } finally {
+    db.close();
   }
-}, async (params) => {
-  const invoice = createInvoice(params);
-  return { content: [{ type: "text", text: JSON.stringify(invoice, null, 2) }] };
 });
 server.registerTool("get_invoice", {
   title: "Get Invoice",
-  description: "Get an invoice with line items and payments by ID or invoice number.",
-  inputSchema: { id: exports_external.string() }
-}, async ({ id }) => {
-  const invoice = getInvoiceWithItems(id);
-  if (!invoice) {
-    return { content: [{ type: "text", text: `Invoice '${id}' not found.` }], isError: true };
-  }
-  return { content: [{ type: "text", text: JSON.stringify(invoice, null, 2) }] };
+  description: "Fetch invoice details including lines.",
+  inputSchema: {
+    id: exports_external.string().min(1)
+  }
+}, async (input) => {
+  const db = openInvoiceDatabase();
+  try {
+    const invoice = getInvoiceById(db, input.id);
+    return { content: [{ type: "text", text: JSON.stringify(invoice) }] };
+  } finally {
+    db.close();
+  }
 });
 server.registerTool("list_invoices", {
   title: "List Invoices",
-  description: "List invoices with optional filters.",
+  description: "List invoices with optional status filter.",
   inputSchema: {
-    status: exports_external.string().optional(),
-    client_id: exports_external.string().optional(),
-    from_date: exports_external.string().optional(),
-    to_date: exports_external.string().optional(),
-    limit: exports_external.number().optional()
-  }
-}, async (params) => {
-  const invoices = listInvoices(params);
-  return {
-    content: [{ type: "text", text: JSON.stringify({ invoices, count: invoices.length }, null, 2) }]
-  };
+    status: statusSchema.optional(),
+    limit: exports_external.number().int().positive().max(200).optional(),
+    offset: exports_external.number().int().nonnegative().optional()
+  }
+}, async (input) => {
+  const db = openInvoiceDatabase();
+  try {
+    const invoices = listInvoices(db, {
+      status: input.status,
+      limit: input.limit,
+      offset: input.offset
+    });
+    return { content: [{ type: "text", text: JSON.stringify(invoices) }] };
+  } finally {
+    db.close();
+  }
+});
+server.registerTool("search_invoices", {
+  title: "Search Invoices",
+  description: "Full-text search over invoice number, issuer/customer names, and notes.",
+  inputSchema: {
+    query: exports_external.string().min(1),
+    status: statusSchema.optional(),
+    limit: exports_external.number().int().positive().max(200).optional(),
+    offset: exports_external.number().int().nonnegative().optional()
+  }
+}, async (input) => {
+  const db = openInvoiceDatabase();
+  try {
+    const invoices = searchInvoices(db, input.query, {
+      status: input.status,
+      limit: input.limit,
+      offset: input.offset
+    });
+    return { content: [{ type: "text", text: JSON.stringify(invoices) }] };
+  } finally {
+    db.close();
+  }
 });
 server.registerTool("update_invoice_status", {
   title: "Update Invoice Status",
-  description: "Change invoice status: draft, sent, paid, overdue, cancelled, refunded.",
+  description: "Update invoice lifecycle status.",
   inputSchema: {
-    id: exports_external.string(),
-    status: exports_external.enum(["draft", "sent", "paid", "overdue", "cancelled", "refunded"])
+    id: exports_external.string().min(1),
+    status: statusSchema
   }
-}, async ({ id, status }) => {
-  const invoice = updateInvoiceStatus(id, status);
-  if (!invoice) {
-    return { content: [{ type: "text", text: `Invoice '${id}' not found.` }], isError: true };
+}, async (input) => {
+  const db = openInvoiceDatabase();
+  try {
+    const invoice = updateInvoiceStatus(db, input.id, input.status);
+    return { content: [{ type: "text", text: JSON.stringify(invoice) }] };
+  } finally {
+    db.close();
   }
-  return { content: [{ type: "text", text: JSON.stringify(invoice, null, 2) }] };
 });
 server.registerTool("delete_invoice", {
   title: "Delete Invoice",
-  description: "Delete an invoice.",
-  inputSchema: { id: exports_external.string() }
-}, async ({ id }) => {
-  const deleted = deleteInvoice(id);
-  return { content: [{ type: "text", text: JSON.stringify({ id, deleted }) }] };
-});
-server.registerTool("add_line_item", {
-  title: "Add Line Item",
-  description: "Add a line item to an invoice. Automatically recalculates subtotal, tax, and total.",
+  description: "Delete invoice and lines by id.",
   inputSchema: {
-    invoice_id: exports_external.string(),
-    description: exports_external.string(),
-    unit_price: exports_external.number(),
-    quantity: exports_external.number().optional()
-  }
-}, async (params) => {
-  const item = addLineItem(params);
-  return { content: [{ type: "text", text: JSON.stringify(item, null, 2) }] };
-});
-server.registerTool("remove_line_item", {
-  title: "Remove Line Item",
-  description: "Remove a line item from an invoice. Recalculates totals.",
-  inputSchema: { id: exports_external.string() }
-}, async ({ id }) => {
-  const removed = removeLineItem(id);
-  return { content: [{ type: "text", text: JSON.stringify({ id, removed }) }] };
-});
-server.registerTool("record_payment", {
-  title: "Record Payment",
-  description: "Record a payment against an invoice. Auto-marks invoice as paid when fully covered.",
-  inputSchema: {
-    invoice_id: exports_external.string(),
-    amount: exports_external.number(),
-    method: exports_external.string().optional(),
-    reference: exports_external.string().optional(),
-    notes: exports_external.string().optional()
-  }
-}, async (params) => {
-  const payment = recordPayment(params);
-  return { content: [{ type: "text", text: JSON.stringify(payment, null, 2) }] };
-});
-server.registerTool("invoice_summary", {
-  title: "Invoice Summary",
-  description: "Get summary statistics: total invoices by status, outstanding and collected amounts.",
-  inputSchema: {}
-}, async () => {
-  const summary = getInvoiceSummary();
-  return { content: [{ type: "text", text: JSON.stringify(summary, null, 2) }] };
+    id: exports_external.string().min(1)
+  }
+}, async (input) => {
+  const db = openInvoiceDatabase();
+  try {
+    const deleted = deleteInvoice(db, input.id);
+    return { content: [{ type: "text", text: JSON.stringify({ deleted }) }] };
+  } finally {
+    db.close();
+  }
 });
-server.registerTool("create_client", {
-  title: "Create Client",
-  description: "Create a new client for invoicing.",
+server.registerTool("register_agent", {
+  title: "Register Agent",
+  description: "Register or refresh an agent identity.",
   inputSchema: {
-    name: exports_external.string(),
-    email: exports_external.string().optional(),
-    phone: exports_external.string().optional(),
-    address: exports_external.string().optional(),
-    address_line1: exports_external.string().optional(),
-    city: exports_external.string().optional(),
-    state: exports_external.string().optional(),
-    postal_code: exports_external.string().optional(),
-    country: exports_external.string().optional(),
-    tax_id: exports_external.string().optional(),
-    vat_number: exports_external.string().optional(),
-    language: exports_external.string().optional(),
-    notes: exports_external.string().optional()
+    name: exports_external.string().min(1),
+    description: exports_external.string().optional()
+  }
+}, async (input) => {
+  const db = openInvoiceDatabase();
+  try {
+    const agent = registerAgent(db, {
+      name: input.name,
+      description: input.description
+    });
+    return { content: [{ type: "text", text: JSON.stringify(agent) }] };
+  } finally {
+    db.close();
   }
-}, async (params) => {
-  const client = createClient(params);
-  return { content: [{ type: "text", text: JSON.stringify(client, null, 2) }] };
-});
-server.registerTool("list_clients", {
-  title: "List Clients",
-  description: "List all clients. Optionally search by name or email.",
-  inputSchema: { search: exports_external.string().optional() }
-}, async ({ search }) => {
-  const clients = listClients(search);
-  return {
-    content: [{ type: "text", text: JSON.stringify({ clients, count: clients.length }, null, 2) }]
-  };
 });
-server.registerTool("update_client", {
-  title: "Update Client",
-  description: "Update client details.",
+server.registerTool("heartbeat", {
+  title: "Heartbeat",
+  description: "Update agent last_seen_at.",
   inputSchema: {
-    id: exports_external.string(),
-    name: exports_external.string().optional(),
-    email: exports_external.string().optional(),
-    phone: exports_external.string().optional(),
-    country: exports_external.string().optional(),
-    vat_number: exports_external.string().optional(),
-    notes: exports_external.string().optional()
+    agent_id: exports_external.string().min(1)
   }
-}, async ({ id, ...input }) => {
-  const client = updateClient(id, input);
-  if (!client) {
-    return { content: [{ type: "text", text: `Client '${id}' not found.` }], isError: true };
+}, async (input) => {
+  const db = openInvoiceDatabase();
+  try {
+    const agent = heartbeatAgent(db, input.agent_id);
+    return { content: [{ type: "text", text: JSON.stringify(agent) }] };
+  } finally {
+    db.close();
   }
-  return { content: [{ type: "text", text: JSON.stringify(client, null, 2) }] };
-});
-server.registerTool("delete_client", {
-  title: "Delete Client",
-  description: "Delete a client.",
-  inputSchema: { id: exports_external.string() }
-}, async ({ id }) => {
-  const deleted = deleteClient(id);
-  return { content: [{ type: "text", text: JSON.stringify({ id, deleted }) }] };
 });
-server.registerTool("create_business_profile", {
-  title: "Create Business Profile",
-  description: "Create a business profile (issuer details for invoices).",
+server.registerTool("set_focus", {
+  title: "Set Focus",
+  description: "Set or clear current agent focus.",
   inputSchema: {
-    name: exports_external.string(),
-    country: exports_external.string().optional(),
-    address_line1: exports_external.string().optional(),
-    city: exports_external.string().optional(),
-    state: exports_external.string().optional(),
-    postal_code: exports_external.string().optional(),
-    tax_id: exports_external.string().optional(),
-    vat_number: exports_external.string().optional(),
-    registration_number: exports_external.string().optional(),
-    email: exports_external.string().optional(),
-    phone: exports_external.string().optional(),
-    website: exports_external.string().optional(),
-    bank_name: exports_external.string().optional(),
-    bank_iban: exports_external.string().optional(),
-    bank_swift: exports_external.string().optional(),
-    bank_account: exports_external.string().optional(),
-    logo_url: exports_external.string().optional(),
-    is_default: exports_external.boolean().optional()
-  }
-}, async (params) => {
-  const biz = createBusinessProfile(params);
-  return { content: [{ type: "text", text: JSON.stringify(biz, null, 2) }] };
-});
-server.registerTool("get_business_profile", {
-  title: "Get Business Profile",
-  description: "Get a business profile by ID.",
-  inputSchema: { id: exports_external.string() }
-}, async ({ id }) => {
-  const biz = getBusinessProfile(id);
-  if (!biz) {
-    return { content: [{ type: "text", text: `Business profile '${id}' not found.` }], isError: true };
-  }
-  return { content: [{ type: "text", text: JSON.stringify(biz, null, 2) }] };
+    agent_id: exports_external.string().min(1),
+    focus: exports_external.string().optional()
+  }
+}, async (input) => {
+  const db = openInvoiceDatabase();
+  try {
+    const agent = setAgentFocus(db, input.agent_id, input.focus);
+    return { content: [{ type: "text", text: JSON.stringify(agent) }] };
+  } finally {
+    db.close();
+  }
 });
-server.registerTool("get_default_business_profile", {
-  title: "Get Default Business Profile",
-  description: "Get the default business profile.",
+server.registerTool("list_agents", {
+  title: "List Agents",
+  description: "List registered agents and their metadata.",
   inputSchema: {}
 }, async () => {
-  const biz = getDefaultBusinessProfile();
-  return { content: [{ type: "text", text: JSON.stringify(biz, null, 2) }] };
+  const db = openInvoiceDatabase();
+  try {
+    const agents = listAgents(db);
+    return { content: [{ type: "text", text: JSON.stringify(agents) }] };
+  } finally {
+    db.close();
+  }
 });
-server.registerTool("list_business_profiles", {
-  title: "List Business Profiles",
-  description: "List all business profiles.",
-  inputSchema: {}
-}, async () => {
-  const profiles = listBusinessProfiles();
-  return { content: [{ type: "text", text: JSON.stringify({ profiles, count: profiles.length }, null, 2) }] };
+server.registerTool("migrate_postgres", {
+  title: "Migrate PostgreSQL",
+  description: "Apply pending PostgreSQL migrations translated from local schema.",
+  inputSchema: {
+    connection_string: exports_external.string().optional()
+  }
+}, async (input) => {
+  const result = await migratePgDatabase(input.connection_string);
+  return { content: [{ type: "text", text: JSON.stringify(result) }] };
 });
-server.registerTool("update_business_profile", {
-  title: "Update Business Profile",
-  description: "Update a business profile.",
+server.registerTool("cloud_push", {
+  title: "Cloud Push",
+  description: "Push local SQLite tables to cloud PostgreSQL.",
   inputSchema: {
-    id: exports_external.string(),
-    name: exports_external.string().optional(),
-    country: exports_external.string().optional(),
-    email: exports_external.string().optional(),
-    phone: exports_external.string().optional(),
-    bank_iban: exports_external.string().optional(),
-    is_default: exports_external.boolean().optional()
+    tables: exports_external.string().optional(),
+    connection_string: exports_external.string().optional()
   }
-}, async ({ id, ...input }) => {
-  const biz = updateBusinessProfile(id, input);
-  if (!biz) {
-    return { content: [{ type: "text", text: `Business profile '${id}' not found.` }], isError: true };
+}, async (input) => {
+  const db = openInvoiceDatabase();
+  try {
+    const result = await cloudPush(db, input.tables, input.connection_string);
+    return { content: [{ type: "text", text: JSON.stringify(result) }] };
+  } finally {
+    db.close();
   }
-  return { content: [{ type: "text", text: JSON.stringify(biz, null, 2) }] };
-});
-server.registerTool("delete_business_profile", {
-  title: "Delete Business Profile",
-  description: "Delete a business profile.",
-  inputSchema: { id: exports_external.string() }
-}, async ({ id }) => {
-  const deleted = deleteBusinessProfile(id);
-  return { content: [{ type: "text", text: JSON.stringify({ id, deleted }) }] };
-});
-server.registerTool("list_tax_rules", {
-  title: "List Tax Rules",
-  description: "List tax rules. Optionally filter by country code.",
-  inputSchema: { country: exports_external.string().optional() }
-}, async ({ country }) => {
-  const rules = country ? getTaxRulesForCountry(country) : listAllTaxRules();
-  return { content: [{ type: "text", text: JSON.stringify({ rules, count: rules.length }, null, 2) }] };
 });
-server.registerTool("get_default_tax_rule", {
-  title: "Get Default Tax Rule",
-  description: "Get the default tax rule for a country.",
-  inputSchema: { country: exports_external.string() }
-}, async ({ country }) => {
-  const rule = getDefaultTaxRule(country);
-  return { content: [{ type: "text", text: JSON.stringify(rule, null, 2) }] };
-});
-server.registerTool("create_tax_rule", {
-  title: "Create Tax Rule",
-  description: "Create a custom tax rule for a country or region.",
+server.registerTool("cloud_pull", {
+  title: "Cloud Pull",
+  description: "Pull cloud PostgreSQL tables into local SQLite.",
   inputSchema: {
-    country: exports_external.string(),
-    region: exports_external.string().optional(),
-    tax_name: exports_external.string(),
-    rate: exports_external.number(),
-    type: exports_external.enum(["vat", "sales_tax", "gst", "other"]).optional(),
-    is_default: exports_external.boolean().optional(),
-    reverse_charge: exports_external.boolean().optional(),
-    description: exports_external.string().optional()
+    tables: exports_external.string().optional(),
+    connection_string: exports_external.string().optional()
+  }
+}, async (input) => {
+  const db = openInvoiceDatabase();
+  try {
+    const result = await cloudPull(db, input.tables, input.connection_string);
+    return { content: [{ type: "text", text: JSON.stringify(result) }] };
+  } finally {
+    db.close();
   }
-}, async (params) => {
-  const rule = createTaxRule(params);
-  return { content: [{ type: "text", text: JSON.stringify(rule, null, 2) }] };
-});
-server.registerTool("delete_tax_rule", {
-  title: "Delete Tax Rule",
-  description: "Delete a tax rule.",
-  inputSchema: { id: exports_external.string() }
-}, async ({ id }) => {
-  const deleted = deleteTaxRule(id);
-  return { content: [{ type: "text", text: JSON.stringify({ id, deleted }) }] };
 });
-server.registerTool("determine_tax", {
-  title: "Determine Tax",
-  description: "Determine the applicable tax rate for a transaction between issuer and client countries. Handles EU reverse charge automatically.",
+server.registerTool("send_feedback", {
+  title: "Send Feedback",
+  description: "Send feedback to remote endpoint with local persistence fallback.",
   inputSchema: {
-    issuer_country: exports_external.string(),
-    client_country: exports_external.string(),
-    client_vat_number: exports_external.string().optional()
+    message: exports_external.string().min(1),
+    email: exports_external.string().email().optional(),
+    version: exports_external.string().optional(),
+    machine_id: exports_external.string().optional()
+  }
+}, async (input) => {
+  const db = openInvoiceDatabase();
+  try {
+    const result = await submitFeedback(db, {
+      service: "invoices",
+      message: input.message,
+      email: input.email,
+      version: input.version,
+      machine_id: input.machine_id
+    });
+    return { content: [{ type: "text", text: JSON.stringify(result) }] };
+  } finally {
+    db.close();
   }
-}, async ({ issuer_country, client_country, client_vat_number }) => {
-  const result = determineTax(issuer_country, client_country, client_vat_number);
-  return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
-});
-async function main() {
-  const transport = new StdioServerTransport;
-  await server.connect(transport);
-  console.error("invoices MCP server running on stdio");
-}
-main().catch((error) => {
-  console.error("Fatal error:", error);
-  process.exit(1);
 });
+var transport = new StdioServerTransport;
+await server.connect(transport);