paisa-mcp 0.0.21 → 0.0.22

package/dist/index.js

@@ -38157,6 +38157,21 @@ axios.default = axios;
 var axios_default = axios;
 
 // src/api-client.ts
+class ApiError extends Error {
+  status;
+  body;
+  method;
+  path;
+  constructor(message, status, body, method, path) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.method = method;
+    this.path = path;
+    this.name = "ApiError";
+  }
+}
+
 class PaisaApiClient {
   http;
   constructor(baseUrl, token) {
@@ -38169,12 +38184,12 @@ class PaisaApiClient {
       }
     });
     this.http.interceptors.response.use((res) => res, (err) => {
-      const status = err.response?.status ?? "?";
+      const status = err.response?.status;
       const body = err.response?.data;
       const detail = typeof body === "string" ? body : JSON.stringify(body ?? "");
       const method = err.config?.method?.toUpperCase() ?? "?";
       const url2 = err.config?.url ?? "?";
-      throw new Error(`API ${method} ${url2} failed (${status}): ${detail}`);
+      throw new ApiError(`API ${method} ${url2} failed (${status ?? "?"}): ${detail}`, status, body, method, url2);
     });
   }
   async get(path, params) {
@@ -38298,6 +38313,58 @@ async function encryptTransactionFields(items, key) {
     await encryptObjectFields(item, ENCRYPTED_TXN_FIELDS, key);
   }
 }
+var VERIFIER_PLAINTEXT = "paisa-verify-v1";
+async function checkVerifier(key, encryptedVerifier) {
+  try {
+    const decrypted = await decryptField(encryptedVerifier, key);
+    return decrypted === VERIFIER_PLAINTEXT;
+  } catch {
+    return false;
+  }
+}
+
+// src/lib/crypto-init.ts
+async function initCrypto(client, pin, userId) {
+  if (pin && !userId)
+    throw new Error("PAISA_USER_ID is required when PAISA_PIN is set.");
+  let meta2;
+  try {
+    meta2 = await client.get("/api/auth-crypto");
+  } catch (err) {
+    throw new Error(`Could not load encryption settings from /api/auth-crypto, refusing to start: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  const mode = meta2.encryptionMode ?? "standard";
+  if (mode === "private" && !pin) {
+    throw new Error("This account is in private (encrypted) mode but PAISA_PIN is not set. " + "Set PAISA_PIN and PAISA_USER_ID; refusing to write plaintext.");
+  }
+  if (mode !== "private") {
+    if (pin) {
+      throw new Error("PAISA_PIN is set but this account is not in private mode. " + "Unset PAISA_PIN and PAISA_USER_ID; refusing to write ciphertext into a plaintext account.");
+    }
+    return;
+  }
+  const pinValue = pin;
+  if ((meta2.kdfVersion ?? 1) >= 2) {
+    if (!meta2.kdfSalt || !meta2.wrappedDek) {
+      throw new Error("Server reports kdfVersion 2 but is missing kdfSalt/wrappedDek.");
+    }
+    try {
+      const kek = await deriveKEK(pinValue, meta2.kdfSalt);
+      return { key: await unwrapDEK(meta2.wrappedDek, kek) };
+    } catch {
+      throw new Error("Incorrect PAISA_PIN.");
+    }
+  }
+  const uid = userId;
+  const key = await deriveKey(uid, pinValue, uid);
+  if (!meta2.encryptedVerifier) {
+    throw new Error("Server has no PIN verifier stored for this private-mode account; re-run PIN setup in the web app.");
+  }
+  if (!await checkVerifier(key, meta2.encryptedVerifier)) {
+    throw new Error("Incorrect PAISA_PIN (or PAISA_USER_ID).");
+  }
+  return { key };
+}
 
 // ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/external.js
 var exports_external = {};
@@ -42311,13 +42378,17 @@ function registerAlertRuleTools(server, client) {
     return { content: [{ type: "text", text: JSON.stringify(data) }] };
   });
   server.registerTool("set_alert_rule", {
-    description: "Create or update an alert rule.",
+    description: "Update an existing alert rule's enabled flag and/or threshold.",
     inputSchema: {
       type: exports_external.string().describe("Rule type (e.g. budget_threshold, spending_spike)"),
-      config: exports_external.record(exports_external.unknown()).describe("Rule-specific config")
+      enabled: exports_external.boolean().optional().describe("Turn the rule on or off"),
+      threshold: exports_external.string().regex(/^\d{1,4}(\.\d{1,2})?$/).optional().nullable().describe('Threshold as a decimal string, e.g. "80" or "80.50"')
     }
-  }, async ({ type, config: config2 }) => {
-    const data = await client.post(`/api/alerts/rules/${type}`, config2);
+  }, async ({ type, enabled, threshold }) => {
+    const data = await client.patch(`/api/alerts/rules/${type}`, {
+      ...enabled !== undefined ? { enabled } : {},
+      ...threshold !== undefined ? { threshold } : {}
+    });
     return { content: [{ type: "text", text: JSON.stringify(data) }] };
   });
 }
@@ -42352,7 +42423,7 @@ function registerAlertTools(server, client) {
     description: "Dismiss a specific alert.",
     inputSchema: { id: exports_external.string().describe("Alert UUID") }
   }, async ({ id }) => {
-    const data = await client.post(`/api/alerts/${id}/dismiss`);
+    const data = await client.patch(`/api/alerts/${id}/dismiss`);
     return { content: [{ type: "text", text: JSON.stringify(data) }] };
   });
 }
@@ -42392,17 +42463,9 @@ async function decryptAnalytics(data, key) {
 }
 function registerAnalyticsTools(server, client, crypto3) {
   server.registerTool("get_analytics", {
-    description: "Analytics reports. Select one via `report`:\n" + "- monthly_summary: Income, expenses, and investments for a specific month, broken down by category type. Includes budget vs actual. Requires `month` and `year`; optional `owner`.\n" + "- spending_trends: Monthly spending trends by category type over the last N months. Optional `months` (default: 6) and `owner`.\n" + "- category_analytics: Detailed spending breakdown for a specific category over time. Requires `slug`; optional `months`.\n" + "- merchant_analytics: Transaction history and spend total for a specific merchant. Requires `id`; optional `months`.",
+    description: "Analytics reports. Select one via `report`:\n" + "- spending_trends: Monthly spending trends by category type over the last N months (per-month rows), plus category breakdown and budget vs actual. Optional `months` (default: 6). For a specific month, read that month's row.\n" + "- category_analytics: Detailed spending breakdown for a specific category over time. Requires `slug`; optional `months`.\n" + "- merchant_analytics: Transaction history and spend total for a specific merchant. Requires `id`; optional `months`.",
     inputSchema: {
-      report: exports_external.enum([
-        "monthly_summary",
-        "spending_trends",
-        "category_analytics",
-        "merchant_analytics"
-      ]),
-      month: exports_external.number().min(1).max(12).optional().describe("monthly_summary: target month (1-12)"),
-      year: exports_external.number().optional().describe("monthly_summary: target year"),
-      owner: exports_external.string().optional().describe("monthly_summary/spending_trends: filter by owner slug, or omit for all"),
+      report: exports_external.enum(["spending_trends", "category_analytics", "merchant_analytics"]),
       months: exports_external.number().optional().describe("spending_trends/category_analytics/merchant_analytics: months to look back (spending_trends default: 6)"),
       slug: exports_external.string().optional().describe("category_analytics: category slug"),
       id: exports_external.string().optional().describe("merchant_analytics: merchant UUID")
@@ -42410,18 +42473,8 @@ function registerAnalyticsTools(server, client, crypto3) {
   }, async (params) => {
     let data;
     switch (params.report) {
-      case "monthly_summary":
-        data = await client.get("/api/analytics", {
-          month: params.month,
-          year: params.year,
-          ...params.owner ? { owner: params.owner } : {}
-        });
-        break;
       case "spending_trends":
-        data = await client.get("/api/analytics", {
-          ...params.months ? { months: params.months } : {},
-          ...params.owner ? { owner: params.owner } : {}
-        });
+        data = await client.get("/api/analytics", params.months ? { months: params.months } : undefined);
         break;
       case "category_analytics":
         data = await client.get(`/api/analytics/categories/${params.slug}`, params.months ? { months: params.months } : undefined);
@@ -42606,29 +42659,40 @@ function registerExportTools(server, client, crypto3) {
 // src/tools/goals.ts
 function registerGoalTools(server, client) {
   server.registerTool("list_savings", {
-    description: "List savings vehicles. type='goals' → savings goals with progress; type='emis' → active EMIs (loans being repaid monthly); type='sinking_funds' → sinking funds (saving toward a future expense).",
+    description: "List savings vehicles. type='goals' → savings goals with progress; 'emis' → EMIs (loans repaid monthly); 'sinking_funds' → funds for a future expense; 'insurance' → insurance policies; 'contributions' → contribution history of one goal (pass id).",
     inputSchema: {
-      type: exports_external.enum(["goals", "emis", "sinking_funds"])
+      type: exports_external.enum(["goals", "emis", "sinking_funds", "insurance", "contributions"]),
+      id: exports_external.string().optional().describe("Goal UUID — required for type='contributions'")
     }
-  }, async ({ type }) => {
-    const endpoint = type === "goals" ? "/api/goals" : type === "emis" ? "/api/goals/emis" : "/api/goals/sinking-funds";
-    const data = await client.get(endpoint);
-    return { content: [{ type: "text", text: JSON.stringify(data) }] };
+  }, async ({ type, id }) => {
+    if (type === "contributions") {
+      if (!id)
+        throw new Error("list_savings type='contributions' requires id (goal UUID)");
+      const data = await client.get(`/api/goals/${id}/contributions`);
+      return { content: [{ type: "text", text: JSON.stringify(data) }] };
+    }
+    const all2 = await client.get("/api/goals");
+    const key = type === "sinking_funds" ? "sinkingFunds" : type;
+    return {
+      content: [
+        { type: "text", text: JSON.stringify({ success: true, data: all2[key] ?? [] }) }
+      ]
+    };
   });
   server.registerTool("upsert_savings", {
     description: `Create (or update) a savings vehicle. Field requirements depend on type:
 ` + `- type='goal': create/update a savings goal. Omit id to create (name + targetAmount required); pass id to update an existing goal (all other fields optional).
-` + `- type='emi': add an EMI/loan repayment. Requires name, totalAmount, emiAmount, startDate, endDate, totalMonths, owner (interestRate, paidMonths optional).
-` + "- type='sinking_fund': create a sinking fund for a future expense. Requires name, targetAmount, targetDate (monthlyContribution, currentAmount optional).",
+` + `- type='emi': add an EMI/loan repayment (pass id to update; then all fields optional). Requires name, totalAmount, emiAmount, startDate, endDate, totalMonths, owner (interestRate, paidMonths optional).
+` + "- type='sinking_fund': create a sinking fund for a future expense (pass id to update; then all fields optional). Requires name, targetAmount, targetDate, monthlyContribution (currentAmount optional).",
     inputSchema: {
       type: exports_external.enum(["goal", "emi", "sinking_fund"]),
-      id: exports_external.string().optional().describe("[goal] Goal UUID — omit to create, pass to update"),
+      id: exports_external.string().optional().describe("[goal, emi, sinking_fund] UUID — omit to create, pass to update"),
       goalType: exports_external.enum(["emergency_fund", "travel", "car", "house", "education", "retirement", "custom"]).optional().describe("[goal] Goal category — required when creating"),
       name: exports_external.string().optional().describe("[goal, emi, sinking_fund] Name"),
       targetAmount: exports_external.string().optional().describe("[goal, sinking_fund] Target amount"),
-      targetDate: exports_external.string().optional().describe("[goal, sinking_fund] YYYY-MM-DD"),
+      targetDate: exports_external.string().optional().describe("[goal, sinking_fund] YYYY-MM-DD (fund: due date)"),
       currentAmount: exports_external.string().optional().describe("[goal, sinking_fund] Already saved"),
-      monthlyContribution: exports_external.string().optional().describe("[goal] Monthly contribution"),
+      monthlyContribution: exports_external.string().optional().describe("[goal, sinking_fund] Monthly contribution / set-aside"),
       owner: exports_external.string().optional().describe("[goal, emi] Owner"),
       icon: exports_external.string().optional().describe("[goal] Icon"),
       color: exports_external.string().optional().describe("[goal] Color"),
@@ -42650,7 +42714,7 @@ function registerGoalTools(server, client) {
     };
     if (type === "goal") {
       const {
-        id,
+        id: id2,
         goalType,
         name: name2,
         targetAmount: targetAmount2,
@@ -42674,50 +42738,49 @@ function registerGoalTools(server, client) {
         color,
         notes
       };
-      if (!id)
+      if (!id2)
         require2(["name", "targetAmount", "goalType"]);
-      const data2 = id ? await client.patch(`/api/goals/${id}`, body2) : await client.post("/api/goals", body2);
+      const data2 = id2 ? await client.patch(`/api/goals/${id2}`, body2) : await client.post("/api/goals", body2);
       return { content: [{ type: "text", text: JSON.stringify(data2) }] };
     }
     if (type === "emi") {
-      require2([
-        "name",
-        "totalAmount",
-        "emiAmount",
-        "startDate",
-        "endDate",
-        "totalMonths",
-        "owner"
-      ]);
-      const {
-        name: name2,
-        totalAmount,
-        emiAmount,
-        interestRate,
-        startDate,
-        endDate,
-        totalMonths,
-        paidMonths,
-        owner
-      } = fields;
+      const { id: id2, name: name2, totalAmount, emiAmount, startDate, endDate, totalMonths, paidMonths } = fields;
+      const { owner } = fields;
+      if (!id2) {
+        require2([
+          "name",
+          "totalAmount",
+          "emiAmount",
+          "startDate",
+          "endDate",
+          "totalMonths",
+          "owner"
+        ]);
+      }
       const body2 = {
         name: name2,
         totalAmount,
         emiAmount,
-        interestRate,
         startDate,
         endDate,
         totalMonths,
         paidMonths,
         owner
       };
-      const data2 = await client.post("/api/goals/emis", body2);
+      const data2 = id2 ? await client.patch(`/api/goals/emis/${id2}`, body2) : await client.post("/api/goals/emis", body2);
       return { content: [{ type: "text", text: JSON.stringify(data2) }] };
     }
-    require2(["name", "targetAmount", "targetDate"]);
-    const { name, targetAmount, targetDate, monthlyContribution, currentAmount } = fields;
-    const body = { name, targetAmount, targetDate, monthlyContribution, currentAmount };
-    const data = await client.post("/api/goals/sinking-funds", body);
+    const { id, name, targetAmount, targetDate, monthlyContribution, currentAmount } = fields;
+    if (!id)
+      require2(["name", "targetAmount", "targetDate", "monthlyContribution"]);
+    const body = {
+      name,
+      targetAmount,
+      dueDate: targetDate,
+      monthlySetAside: monthlyContribution,
+      currentAmount
+    };
+    const data = id ? await client.patch(`/api/goals/sinking-funds/${id}`, body) : await client.post("/api/goals/sinking-funds", body);
     return { content: [{ type: "text", text: JSON.stringify(data) }] };
   });
   server.registerTool("upsert_insurance", {
@@ -42754,6 +42817,16 @@ function registerGoalTools(server, client) {
     const data = await client.post(`/api/goals/${id}/contribute`, body);
     return { content: [{ type: "text", text: JSON.stringify(data) }] };
   });
+  server.registerTool("delete_savings", {
+    description: "Delete a savings goal, EMI, insurance policy or sinking fund by id. PERMANENT — confirm with the user first.",
+    inputSchema: {
+      type: exports_external.enum(["goal", "emi", "insurance", "sinking_fund"]),
+      id: exports_external.string().describe("UUID of the item to delete")
+    }
+  }, async ({ type, id }) => {
+    const data = type === "goal" ? await client.delete(`/api/goals/${id}`) : type === "emi" ? await client.delete(`/api/goals/emis/${id}`) : type === "insurance" ? await client.delete(`/api/goals/insurance/${id}`) : await client.delete(`/api/goals/sinking-funds/${id}`);
+    return { content: [{ type: "text", text: JSON.stringify(data) }] };
+  });
 }
 
 // src/tools/heatmap.ts
@@ -42784,6 +42857,9 @@ async function loadBag(client) {
   const res = await client.get("/api/household-learning");
   if (!res.data)
     return { bag: structuredClone(EMPTY_BAG), version: 0 };
+  if (res.data.readable === false) {
+    throw new Error("Household learning bag is unreadable (decrypt/parse failed); refusing to modify it. Check ENCRYPTION_KEY / the stored blob before retrying.");
+  }
   return { bag: res.data.bag, version: res.data.version };
 }
 async function saveBag(client, bag, expectedVersion) {
@@ -42886,12 +42962,24 @@ function registerHouseholdTools(server, client) {
     return { content: [{ type: "text", text: JSON.stringify(data) }] };
   });
   server.registerTool("create_invite", {
-    description: "Create an invite link to add a new member to the household.",
-    inputSchema: {
-      expiresInHours: exports_external.number().optional().describe("Invite expiry in hours (default: 72)")
-    }
-  }, async (body) => {
-    const data = await client.post("/api/households/invites", body);
+    description: "Invite someone (by email) to the household. Returns the invite URL; the invite expires in 72h.",
+    inputSchema: { email: exports_external.string().email().describe("Email address of the invitee") }
+  }, async ({ email: email2 }) => {
+    const data = await client.post("/api/households/invites", { email: email2 });
+    return { content: [{ type: "text", text: JSON.stringify(data) }] };
+  });
+  server.registerTool("list_invites", {
+    description: "List pending household invites (use to find an invite id to revoke).",
+    inputSchema: {}
+  }, async () => {
+    const data = await client.get("/api/households/invites");
+    return { content: [{ type: "text", text: JSON.stringify(data) }] };
+  });
+  server.registerTool("revoke_invite", {
+    description: "Revoke a pending household invite so its link stops working.",
+    inputSchema: { id: exports_external.string().describe("Invite UUID from list_invites") }
+  }, async ({ id }) => {
+    const data = await client.delete(`/api/households/invites/${id}`);
     return { content: [{ type: "text", text: JSON.stringify(data) }] };
   });
 }
@@ -42899,20 +42987,26 @@ function registerHouseholdTools(server, client) {
 // src/tools/investments.ts
 function registerInvestmentTools(server, client) {
   server.registerTool("list_investments", {
-    description: "List investments by type. holdings = mutual funds, stocks, etc. with current values; sips = Systematic Investment Plans; fixed_deposits = fixed deposits.",
+    description: "List investments by type. holdings = mutual funds, stocks, etc. with current values; sips = Systematic Investment Plans; fixed_deposits = fixed deposits; transactions = buy/sell/dividend history of one holding (pass id).",
     inputSchema: {
-      type: exports_external.enum(["holdings", "sips", "fixed_deposits"]).describe("Which investments to list")
+      type: exports_external.enum(["holdings", "sips", "fixed_deposits", "transactions"]).describe("Which investments to list"),
+      id: exports_external.string().optional().describe("Investment UUID — required for type='transactions'")
     }
-  }, async ({ type }) => {
-    const endpoint = type === "sips" ? "/api/investments/sips" : type === "fixed_deposits" ? "/api/investments/fds" : "/api/investments";
-    const data = await client.get(endpoint);
+  }, async ({ type, id }) => {
+    if (type === "transactions") {
+      if (!id)
+        throw new Error("list_investments type='transactions' requires id");
+      const data2 = await client.get(`/api/investments/${id}/transactions`);
+      return { content: [{ type: "text", text: JSON.stringify(data2) }] };
+    }
+    const data = type === "sips" ? await client.get("/api/investments/sips") : type === "fixed_deposits" ? await client.get("/api/investments/fds") : await client.get("/api/investments");
     return { content: [{ type: "text", text: JSON.stringify(data) }] };
   });
   server.registerTool("upsert_investment", {
-    description: "Create or update an investment. " + "type=sip: omit id to add a new SIP (name, amount, startDate, sipDay, owner required); pass id to update an existing SIP, including pausing/stopping it via status. " + "type=fixed_deposit: create-only (bankName, amount, interestRate, startDate, maturityDate, owner required). " + "type=holding: create/update a manual stock/MF holding not pulled by a sync, e.g. a Groww position (name, holdingType, owner, investedAmount, currentValue required; re-upserting the same name+platform updates it).",
+    description: "Create or update an investment. " + "type=sip: omit id to add a new SIP (name, amount, startDate, sipDay, owner required); pass id to update an existing SIP, including pausing/stopping it via status. " + "type=fixed_deposit: omit id to create (bankName, amount, interestRate, startDate, maturityDate, owner required); pass id to update an FD (fields optional). " + "type=holding: create/update a manual stock/MF holding not pulled by a sync, e.g. a Groww position (name, holdingType, owner, investedAmount, currentValue required; re-upserting the same name+platform updates it).",
     inputSchema: {
       type: exports_external.enum(["sip", "fixed_deposit", "holding"]).describe("Investment type"),
-      id: exports_external.string().optional().describe("sip: SIP UUID — omit to add, pass to update"),
+      id: exports_external.string().optional().describe("sip & fixed_deposit: UUID — omit to add, pass to update"),
       name: exports_external.string().optional().describe('sip: fund name (e.g. "Parag Parikh Flexi Cap")'),
       startDate: exports_external.string().optional().describe("sip & fixed_deposit: YYYY-MM-DD"),
       sipDay: exports_external.number().optional().describe("sip: day of month the SIP debits"),
@@ -42925,7 +43019,7 @@ function registerInvestmentTools(server, client) {
       maturityDate: exports_external.string().optional().describe("fixed_deposit: YYYY-MM-DD"),
       notes: exports_external.string().optional().describe("fixed_deposit: notes"),
       holdingType: exports_external.enum(["mutual_fund", "stock", "gold", "ppf", "nps", "other"]).optional().describe("holding: asset type"),
-      platform: exports_external.string().optional().describe("holding: broker/platform (e.g. groww); defaults to 'manual'"),
+      platform: exports_external.string().optional().describe("sip & holding: broker/platform (e.g. groww); defaults to 'manual'"),
       symbol: exports_external.string().optional().describe("holding: ticker symbol (optional)"),
       isin: exports_external.string().optional().describe("holding: ISIN (optional)"),
       units: exports_external.string().optional().describe("holding: units held (optional)"),
@@ -42938,15 +43032,15 @@ function registerInvestmentTools(server, client) {
     if (type === "holding") {
       const { name, holdingType, owner: owner2, platform, symbol, isin, units, investedAmount } = fields;
       const { currentValue } = fields;
-      const missing2 = [
+      const missing = [
         ["name", name],
         ["holdingType", holdingType],
         ["owner", owner2],
         ["investedAmount", investedAmount],
         ["currentValue", currentValue]
       ].filter(([, v]) => v === undefined).map(([k]) => k);
-      if (missing2.length > 0) {
-        throw new Error(`Missing required fields for holding: ${missing2.join(", ")}`);
+      if (missing.length > 0) {
+        throw new Error(`Missing required fields for holding: ${missing.join(", ")}`);
       }
       const data2 = await client.post("/api/investments/holdings", {
         name,
@@ -42963,7 +43057,7 @@ function registerInvestmentTools(server, client) {
     }
     if (type === "sip") {
       const {
-        id,
+        id: id2,
         name,
         amount: amount2,
         startDate: startDate2,
@@ -42972,55 +43066,77 @@ function registerInvestmentTools(server, client) {
         folioNumber,
         category,
         status,
-        endDate
+        endDate,
+        platform
       } = fields;
-      if (!id) {
-        const missing2 = [
+      if (!id2) {
+        const missing = [
           ["name", name],
           ["amount", amount2],
           ["startDate", startDate2],
           ["sipDay", sipDay],
           ["owner", owner2]
         ].filter(([, v]) => v === undefined).map(([k]) => k);
-        if (missing2.length > 0) {
-          throw new Error(`Missing required fields for new SIP: ${missing2.join(", ")}`);
+        if (missing.length > 0) {
+          throw new Error(`Missing required fields for new SIP: ${missing.join(", ")}`);
         }
       }
       const sipFields = {
         name,
         amount: amount2,
         startDate: startDate2,
-        sipDay,
+        sipDate: sipDay,
         owner: owner2,
         folioNumber,
         category,
         status,
-        endDate
+        endDate,
+        platform: id2 ? platform : platform ?? "manual"
       };
-      const data2 = id ? await client.patch(`/api/investments/sips/${id}`, sipFields) : await client.post("/api/investments/sips", sipFields);
+      const data2 = id2 ? await client.patch(`/api/investments/sips/${id2}`, sipFields) : await client.post("/api/investments/sips", sipFields);
       return { content: [{ type: "text", text: JSON.stringify(data2) }] };
     }
-    const { bankName, amount, interestRate, startDate, maturityDate, owner, notes } = fields;
-    const missing = [
-      ["bankName", bankName],
-      ["amount", amount],
-      ["interestRate", interestRate],
-      ["startDate", startDate],
-      ["maturityDate", maturityDate],
-      ["owner", owner]
-    ].filter(([, v]) => v === undefined).map(([k]) => k);
-    if (missing.length > 0) {
-      throw new Error(`Missing required fields for fixed deposit: ${missing.join(", ")}`);
-    }
-    const data = await client.post("/api/investments/fds", {
-      bankName,
-      amount,
+    const { id, bankName, amount, interestRate, startDate, maturityDate, owner, notes } = fields;
+    if (!id) {
+      const missing = [
+        ["bankName", bankName],
+        ["amount", amount],
+        ["interestRate", interestRate],
+        ["startDate", startDate],
+        ["maturityDate", maturityDate],
+        ["owner", owner]
+      ].filter(([, v]) => v === undefined).map(([k]) => k);
+      if (missing.length > 0) {
+        throw new Error(`Missing required fields for fixed deposit: ${missing.join(", ")}`);
+      }
+    }
+    const fdBody = {
+      bank: bankName,
+      principal: amount,
       interestRate,
       startDate,
       maturityDate,
       owner,
       notes
-    });
+    };
+    const data = id ? await client.patch(`/api/investments/fds/${id}`, fdBody) : await client.post("/api/investments/fds", fdBody);
+    return { content: [{ type: "text", text: JSON.stringify(data) }] };
+  });
+  server.registerTool("delete_investment", {
+    description: "Delete a SIP or fixed deposit by id. PERMANENT (FDs are soft-deleted) — confirm with the user first.",
+    inputSchema: {
+      type: exports_external.enum(["sip", "fixed_deposit"]),
+      id: exports_external.string().describe("SIP or FD UUID")
+    }
+  }, async ({ type, id }) => {
+    const data = type === "sip" ? await client.delete(`/api/investments/sips/${id}`) : await client.delete(`/api/investments/fds/${id}`);
+    return { content: [{ type: "text", text: JSON.stringify(data) }] };
+  });
+  server.registerTool("sync_zerodha", {
+    description: "Zerodha broker link. action='token_health' → check whether the access token is still valid (expired tokens need re-login in the web app); action='sync' → pull latest stocks, mutual funds and SIPs.",
+    inputSchema: { action: exports_external.enum(["token_health", "sync"]) }
+  }, async ({ action }) => {
+    const data = action === "sync" ? await client.post("/api/investments/zerodha/sync") : await client.get("/api/investments/zerodha/token-health");
     return { content: [{ type: "text", text: JSON.stringify(data) }] };
   });
 }
@@ -43789,6 +43905,13 @@ function resolveAlias(name) {
   }
   return null;
 }
+function aliasesMatch(a, b) {
+  const resolvedA = resolveAlias(a);
+  const resolvedB = resolveAlias(b);
+  if (resolvedA === null || resolvedB === null)
+    return false;
+  return resolvedA === resolvedB;
+}
 // ../../node_modules/.bun/fuzzball@2.2.3/node_modules/fuzzball/dist/esm/fuzzball.esm.min.js
 var e;
 var t = typeof globalThis != "undefined" ? globalThis : typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : {};
@@ -45505,9 +45628,35 @@ var ta = Ro.dedupe;
 
 // ../reconciliation/src/normalise.ts
 var CORPORATE_SUFFIXES = /\b(PRIVATE|PVT\.?|LIMITED|LTD\.?)\s*\w*/gi;
+var TOKEN_SET_THRESHOLD = 80;
 function normaliseName(name) {
   return name.replace(CORPORATE_SUFFIXES, "").replace(/[^\w\s]/g, " ").replace(/\s+/g, " ").trim().toLowerCase();
 }
+function getMatchName(extractedName, description) {
+  if (extractedName && extractedName.trim().length > 0) {
+    return normaliseName(extractedName);
+  }
+  return normaliseName(description);
+}
+function isSameMerchant(a2, b2) {
+  const normA = normaliseName(a2);
+  const normB = normaliseName(b2);
+  if (normA.length === 0 || normB.length === 0)
+    return false;
+  if (normA === normB)
+    return true;
+  if (aliasesMatch(normA, normB))
+    return true;
+  const shorter = Math.min(normA.length, normB.length);
+  const longer = Math.max(normA.length, normB.length);
+  if (shorter < 4 || shorter / longer < 0.4)
+    return false;
+  if (Fo(normA, normB) >= TOKEN_SET_THRESHOLD)
+    return true;
+  if (Bo(normA, normB) >= 90)
+    return true;
+  return false;
+}
 
 // ../reconciliation/src/entity.ts
 var FUZZBALL_THRESHOLD = 92;
@@ -45649,6 +45798,151 @@ function entityRule(e2, bag) {
     return bag.merchantRules[e2.merchantId] ?? null;
   return bag.personRules[e2.personId] ?? null;
 }
+// ../reconciliation/src/match.ts
+var DEFAULT_DATE_TOLERANCE = 2;
+var DEFAULT_AMOUNT_TOLERANCE = 0.02;
+function toDays(dateStr) {
+  const [y2, m2, d2] = dateStr.split("-").map(Number);
+  return Math.round(Date.UTC(y2, m2 - 1, d2) / 86400000);
+}
+function amountsClose(a2, b2, tolerance) {
+  if (a2 === 0 || b2 === 0)
+    return false;
+  return Math.abs(a2 - b2) / Math.max(a2, b2) <= tolerance;
+}
+function namesSimilar(inc, ex) {
+  if (inc.upiId && ex.upiId && inc.upiId === ex.upiId)
+    return true;
+  const incName = getMatchName(inc.extractedName, inc.description);
+  const exName = getMatchName(ex.extractedName ?? ex.merchantName, ex.description);
+  return isSameMerchant(incName, exName);
+}
+function matchTransactions(existing, incoming, config2) {
+  const dateTolerance = config2?.dateTolerance ?? DEFAULT_DATE_TOLERANCE;
+  const amountTolerance = config2?.amountTolerance ?? DEFAULT_AMOUNT_TOLERANCE;
+  const claimedExisting = new Set;
+  const claimedIncoming = new Set;
+  const matched = [];
+  const conflicts = [];
+  const eligible = existing.filter((t2) => !t2.isDuplicate && !t2.isIgnored);
+  for (let i2 = 0;i2 < incoming.length; i2++) {
+    if (claimedIncoming.has(i2))
+      continue;
+    const inc = incoming[i2];
+    for (const ex of eligible) {
+      if (claimedExisting.has(ex.id))
+        continue;
+      if (inc.description === ex.description && inc.amount === ex.amount && inc.type === ex.type && inc.date === ex.date) {
+        matched.push({
+          existing: ex,
+          incoming: inc,
+          incomingIndex: i2,
+          confidence: "exact",
+          reason: "Same row: identical description, amount, type, and date"
+        });
+        claimedExisting.add(ex.id);
+        claimedIncoming.add(i2);
+        break;
+      }
+    }
+  }
+  for (let i2 = 0;i2 < incoming.length; i2++) {
+    if (claimedIncoming.has(i2))
+      continue;
+    const inc = incoming[i2];
+    if (!inc.referenceNumber)
+      continue;
+    for (const ex of eligible) {
+      if (claimedExisting.has(ex.id))
+        continue;
+      if (ex.referenceNumber === inc.referenceNumber && inc.type === ex.type && inc.amount === ex.amount) {
+        matched.push({
+          existing: ex,
+          incoming: inc,
+          incomingIndex: i2,
+          confidence: "exact",
+          reason: `Reference number match: ${inc.referenceNumber}`
+        });
+        claimedExisting.add(ex.id);
+        claimedIncoming.add(i2);
+        break;
+      }
+    }
+  }
+  for (let i2 = 0;i2 < incoming.length; i2++) {
+    if (claimedIncoming.has(i2))
+      continue;
+    const inc = incoming[i2];
+    for (const ex of eligible) {
+      if (claimedExisting.has(ex.id))
+        continue;
+      if (inc.amount === ex.amount && inc.type === ex.type && inc.date === ex.date && namesSimilar(inc, ex)) {
+        matched.push({
+          existing: ex,
+          incoming: inc,
+          incomingIndex: i2,
+          confidence: "exact",
+          reason: `Exact match: ${inc.amount} on ${inc.date}`
+        });
+        claimedExisting.add(ex.id);
+        claimedIncoming.add(i2);
+        break;
+      }
+    }
+  }
+  for (let i2 = 0;i2 < incoming.length; i2++) {
+    if (claimedIncoming.has(i2))
+      continue;
+    const inc = incoming[i2];
+    const incDays = toDays(inc.date);
+    for (const ex of eligible) {
+      if (claimedExisting.has(ex.id))
+        continue;
+      const daysDiff = Math.abs(incDays - toDays(ex.date));
+      if (daysDiff > 0 && daysDiff <= dateTolerance && inc.amount === ex.amount && inc.type === ex.type && namesSimilar(inc, ex)) {
+        matched.push({
+          existing: ex,
+          incoming: inc,
+          incomingIndex: i2,
+          confidence: "date_tolerance",
+          reason: `Amount + name match, ${daysDiff} day${daysDiff > 1 ? "s" : ""} apart`
+        });
+        claimedExisting.add(ex.id);
+        claimedIncoming.add(i2);
+        break;
+      }
+    }
+  }
+  for (let i2 = 0;i2 < incoming.length; i2++) {
+    if (claimedIncoming.has(i2))
+      continue;
+    const inc = incoming[i2];
+    const incDays = toDays(inc.date);
+    for (const ex of eligible) {
+      if (claimedExisting.has(ex.id))
+        continue;
+      const daysDiff = Math.abs(incDays - toDays(ex.date));
+      if (daysDiff <= dateTolerance && inc.type === ex.type && inc.amount !== ex.amount && amountsClose(inc.amount, ex.amount, amountTolerance) && namesSimilar(inc, ex)) {
+        const pctDiff = (Math.abs(inc.amount - ex.amount) / Math.max(inc.amount, ex.amount) * 100).toFixed(1);
+        conflicts.push({
+          existing: ex,
+          incoming: inc,
+          incomingIndex: i2,
+          reason: `Amount differs by ${pctDiff}% (${ex.amount} vs ${inc.amount})`
+        });
+        claimedExisting.add(ex.id);
+        claimedIncoming.add(i2);
+        break;
+      }
+    }
+  }
+  const unmatchedIndices = [];
+  for (let i2 = 0;i2 < incoming.length; i2++) {
+    if (!claimedIncoming.has(i2))
+      unmatchedIndices.push(i2);
+  }
+  return { matched, conflicts, unmatchedIndices };
+}
 // ../reconciliation/src/settlement.ts
 var SETTLEMENT_PATTERNS = [
   /\bCRED\b.*\bPAYMENT\b/i,
@@ -45725,6 +46019,61 @@ function settlementEnrichedData(description, type, source) {
     out.settlementCardLast4 = last4;
   return out;
 }
+function detectSettlements(transactions, accountLinks) {
+  const settlements = [];
+  const debits = transactions.filter((t2) => t2.type === "debit" && !t2.isDuplicate && !t2.isIgnored && !t2.isTransfer);
+  for (const debit of debits) {
+    const patternMatch = isSettlementDescription(debit.description);
+    if (!patternMatch)
+      continue;
+    const linkedAccount = findLinkedCreditCard(debit, accountLinks);
+    const { brand, last4 } = extractSettlementCardInfo(debit.description);
+    settlements.push({
+      bankDebit: debit,
+      creditAccountId: linkedAccount?.creditAccountId ?? "unknown",
+      statementTotal: null,
+      reason: linkedAccount ? `Settlement for ${linkedAccount.creditAccountId} (keyword: ${linkedAccount.settlementKeyword})` : `Likely CC settlement (pattern: ${patternMatch})`,
+      cardBrand: brand,
+      cardLast4: last4
+    });
+  }
+  return settlements;
+}
+function findLinkedCreditCard(debit, accountLinks) {
+  if (!debit.accountId)
+    return null;
+  for (const link of accountLinks) {
+    if (link.debitAccountId !== debit.accountId)
+      continue;
+    if (link.settlementKeyword) {
+      const normDesc = normaliseName(debit.description);
+      if (normDesc.includes(normaliseName(link.settlementKeyword))) {
+        return link;
+      }
+    } else {
+      return link;
+    }
+  }
+  return null;
+}
+
+// ../reconciliation/src/reconcile.ts
+function reconcile(existing, incoming, config2) {
+  const accountLinks = config2?.accountLinks ?? [];
+  const settlements = detectSettlements(existing, accountLinks);
+  const { matched, conflicts, unmatchedIndices } = matchTransactions(existing, incoming.transactions, {
+    dateTolerance: config2?.dateTolerance,
+    amountTolerance: config2?.amountTolerance
+  });
+  const unmatched = unmatchedIndices.map((i2) => incoming.transactions[i2]);
+  return {
+    matched,
+    settlements,
+    conflicts,
+    unmatched,
+    unmatchedIndices
+  };
+}
 // src/lib/link-batches.ts
 var MAX_LINKS = 500;
 var MAX_TARGETS = 25;
@@ -45752,1087 +46101,2070 @@ async function postLinks(client, links) {
   }
 }
 
-// src/lib/txn-rows.ts
-function toTxnRow(r2) {
-  return {
-    id: String(r2.id),
-    date: String(r2.date),
-    amount: Number(r2.amount),
-    type: r2.type === "credit" ? "credit" : "debit",
-    description: String(r2.description ?? ""),
-    merchantId: r2.merchantId ?? null,
-    personId: r2.personId ?? null,
-    categoryId: r2.categoryId ?? null,
-    isTransfer: !!r2.isTransfer,
-    isIgnored: !!r2.isIgnored,
-    isDuplicate: !!r2.isDuplicate
-  };
+// src/lib/map-limit.ts
+async function mapLimit(items, limit, fn2) {
+  const out = new Array(items.length);
+  let next = 0;
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, async () => {
+    while (next < items.length) {
+      const i2 = next++;
+      out[i2] = await fn2(items[i2]);
+    }
+  }));
+  return out;
 }
-async function fetchAllRows(client, crypto3, params = {}, maxPages = 100) {
-  const out = [];
-  let cursor;
-  for (let page = 0;page < maxPages; page++) {
-    const q2 = { ...params, limit: 200, view: "match" };
-    if (cursor)
-      q2.cursor = cursor;
-    const res = await client.get("/api/transactions", q2);
-    const batch = res.data ?? [];
-    if (crypto3)
-      await decryptTransactionFields(batch, crypto3.key);
-    out.push(...batch.map(toTxnRow));
-    if (!res.hasMore || !res.nextCursor || batch.length === 0 || res.nextCursor === cursor)
-      break;
-    cursor = res.nextCursor;
+// ../parsers/src/amex/credit-card-pdf.ts
+var _pdfjs = null;
+async function getPdfjs() {
+  if (!_pdfjs) {
+    _pdfjs = await import("pdfjs-dist/legacy/build/pdf.mjs");
+    _pdfjs.GlobalWorkerOptions.workerSrc = import.meta.resolve("pdfjs-dist/legacy/build/pdf.worker.mjs");
+  }
+  return _pdfjs;
+}
+var X_DATE_MAX = 20;
+var X_DESC_MIN = 80;
+var X_DESC_MAX = 340;
+var X_AMOUNT_MIN = 465;
+var Y_DATA_MIN = 260;
+var ROW_TOLERANCE = 12;
+async function parseAmexCreditCardPdf(data, password) {
+  const pdfjs = await getPdfjs();
+  const loadOptions = {
+    data: new Uint8Array(data),
+    useWorkerFetch: false,
+    isEvalSupported: false,
+    useSystemFonts: true
+  };
+  if (password)
+    loadOptions.password = password;
+  const pdf = await pdfjs.getDocument(loadOptions).promise;
+  const items = await extractTextItems(pdf);
+  const metadata = extractMetadata(items);
+  const transactions = parseTransactions(items, metadata);
+  return {
+    bank: "amex",
+    accountType: "credit_card",
+    accountNumber: metadata.accountLast4,
+    periodStart: metadata.periodStart,
+    periodEnd: metadata.periodEnd,
+    transactions
+  };
+}
+async function extractTextItems(pdf) {
+  const result = [];
+  for (let p2 = 1;p2 <= pdf.numPages; p2++) {
+    const page = await pdf.getPage(p2);
+    const content = await page.getTextContent();
+    for (const item of content.items) {
+      const ti = item;
+      if (typeof ti.str !== "string" || !ti.str.trim())
+        continue;
+      result.push({
+        page: p2,
+        x: Math.round(ti.transform[4]),
+        y: Math.round(ti.transform[5]),
+        str: ti.str
+      });
+    }
   }
-  return out;
+  return result;
 }
-var MAX_DESC = 70;
-function toLeanRow(r2, personNames) {
-  const merchant = r2.merchant;
-  const category = r2.category;
-  const merchantName = r2.merchantName ?? merchant?.cleanName;
-  const categorySlug = typeof category === "string" ? category : category?.slug;
-  const personId = r2.personId;
-  const person = personId ? personNames.get(personId) ?? null : null;
-  let flags = r2.flags;
-  if (!flags) {
-    flags = [];
-    if (r2.isTransfer)
-      flags.push("transfer");
-    if (r2.isIgnored)
-      flags.push("ignored");
-    if (r2.isDuplicate)
-      flags.push("duplicate");
+function extractMetadata(items) {
+  const page1Items = items.filter((i2) => i2.page === 1);
+  const rowStrings = groupIntoRowStrings(page1Items);
+  const fullText = rowStrings.join(" ");
+  let accountLast4 = null;
+  let periodStart = null;
+  let periodEnd = null;
+  let periodEndYear = new Date().getFullYear();
+  let periodEndMonth = 1;
+  const accountMatch = fullText.match(/XXXX-XXXXXX-(\d+)/);
+  if (accountMatch) {
+    accountLast4 = accountMatch[1].slice(-4);
+  }
+  const periodMatch = fullText.match(/From\s+(\w+\s+\d+)\s+to\s+(\w+\s+\d+,?\s*\d{4})/i);
+  if (periodMatch) {
+    const endParsed = parseMonthDayYear(periodMatch[2]);
+    if (endParsed) {
+      periodEnd = endParsed.iso;
+      periodEndYear = endParsed.year;
+      periodEndMonth = endParsed.month;
+      const startParsed = parseMonthDay(periodMatch[1]);
+      if (startParsed) {
+        const startYear = startParsed.month > periodEndMonth ? periodEndYear - 1 : periodEndYear;
+        periodStart = `${startYear}-${String(startParsed.month).padStart(2, "0")}-${String(startParsed.day).padStart(2, "0")}`;
+      }
+    }
+  }
+  return { accountLast4, periodStart, periodEnd, periodEndYear, periodEndMonth };
+}
+function groupIntoRowStrings(items) {
+  const buckets = new Map;
+  for (const item of items) {
+    const pagePrefix = `${item.page}:`;
+    let bucketKey = null;
+    for (const key of buckets.keys()) {
+      if (!key.startsWith(pagePrefix))
+        continue;
+      if (Math.abs(item.y - parseInt(key.slice(pagePrefix.length), 10)) <= ROW_TOLERANCE) {
+        bucketKey = key;
+        break;
+      }
+    }
+    if (bucketKey === null) {
+      bucketKey = `${item.page}:${item.y}`;
+      buckets.set(bucketKey, [item]);
+    } else {
+      const existing = buckets.get(bucketKey);
+      if (existing)
+        existing.push(item);
+    }
   }
-  const desc = String(r2.description ?? "");
-  return {
-    id: r2.id,
-    date: r2.date,
-    amt: Number(r2.amount),
-    t: r2.type === "credit" ? "cr" : "dr",
-    desc: desc.length > MAX_DESC ? `${desc.slice(0, MAX_DESC)}…` : desc,
-    ...categorySlug ? { cat: categorySlug } : {},
-    ...merchantName ? { merchant: merchantName } : {},
-    ...person ? { person } : {},
-    ...flags.length ? { flags } : {}
-  };
+  return [...buckets.values()].map((row) => row.sort((a2, b2) => a2.x - b2.x).map((c2) => c2.str).join(" "));
 }
-
-// src/lib/categorize-groups.ts
-var NOISE = new Set([
-  "upi",
-  "pos",
-  "imps",
-  "neft",
-  "rtgs",
-  "ach",
-  "nach",
-  "ecs",
-  "txn",
-  "transaction",
-  "payment",
-  "paid",
-  "pay",
-  "to",
-  "from",
-  "ref",
-  "refno",
-  "debit",
-  "credit",
-  "card",
-  "mob",
-  "mobile",
-  "bank",
-  "transfer",
-  "trf",
-  "by",
-  "for",
-  "the",
-  "via",
-  "ecom",
-  "purchase",
-  "online",
-  "inr",
-  "rs",
-  "towards",
-  "ibl",
-  "ybl",
-  "oksbi",
-  "okhdfcbank",
-  "okicici",
-  "okaxis",
-  "axl",
-  "apl",
-  "paytm",
-  "icici",
-  "hdfc",
-  "sbi",
-  "axis",
-  "utib",
-  "sbin",
-  "ifsc",
-  "vpa",
-  "bill",
-  "cas",
-  "dr",
-  "cr"
-]);
-var GOOD_TOKEN = /^[a-z][a-z&']{2,}$/;
-var MAX_RUN = 3;
-function descriptionPattern(description) {
-  const tokens = normaliseName(description).split(" ").filter(Boolean);
-  const run = [];
-  for (const tok of tokens) {
-    const good = GOOD_TOKEN.test(tok) && !NOISE.has(tok);
-    if (!good) {
-      if (run.length)
-        break;
+function parseTransactions(items, metadata) {
+  const dataItems = items.filter((i2) => i2.y > Y_DATA_MIN);
+  const rows = buildRows(dataItems);
+  const transactions = [];
+  for (const row of rows) {
+    const dateCell = row.find((c2) => c2.x <= X_DATE_MAX);
+    if (!dateCell)
       continue;
-    }
-    if (run.includes(tok))
-      break;
-    run.push(tok);
-    if (run.length === MAX_RUN)
-      break;
+    const date4 = parseAmexPdfDate(dateCell.str.trim(), metadata);
+    if (!date4)
+      continue;
+    const descCells = row.filter((c2) => c2.x >= X_DESC_MIN && c2.x < X_DESC_MAX);
+    if (descCells.length === 0)
+      continue;
+    const description = descCells.sort((a2, b2) => a2.x - b2.x).map((c2) => c2.str).join(" ").replace(/\s{2,}/g, " ").trim();
+    if (!description)
+      continue;
+    const amountCells = row.filter((c2) => c2.x >= X_AMOUNT_MIN);
+    const isCredit = amountCells.some((c2) => c2.str.trim() === "CR");
+    const amountCell = amountCells.find((c2) => c2.str.trim() !== "CR");
+    if (!amountCell)
+      continue;
+    const amount = parseAmount(amountCell.str);
+    if (amount === 0)
+      continue;
+    const type = isCredit ? "credit" : "debit";
+    transactions.push({
+      date: date4,
+      description,
+      amount,
+      type,
+      referenceNumber: null,
+      valueDate: null,
+      closingBalance: null,
+      paymentMethod: null,
+      extractedName: description,
+      upiId: null,
+      sourceCategory: null
+    });
   }
-  return run.join(" ");
+  return transactions;
 }
-var UNPARSED = "(unparsed)";
-function groupRows(rows) {
-  const map2 = new Map;
-  for (const r2 of rows) {
-    const pattern = descriptionPattern(r2.description) || UNPARSED;
-    const key = `${pattern}|${r2.type}`;
-    const g3 = map2.get(key) ?? { pattern, type: r2.type, rows: [], total: 0 };
-    g3.rows.push(r2);
-    g3.total += r2.amount;
-    map2.set(key, g3);
-  }
-  return [...map2.values()].sort((a2, b2) => b2.total - a2.total);
+function buildRows(items) {
+  const buckets = new Map;
+  for (const item of items) {
+    const pagePrefix = `${item.page}:`;
+    let bucketKey = null;
+    for (const key of buckets.keys()) {
+      if (!key.startsWith(pagePrefix))
+        continue;
+      const bucketY = parseInt(key.slice(pagePrefix.length), 10);
+      if (Math.abs(item.y - bucketY) <= ROW_TOLERANCE) {
+        bucketKey = key;
+        break;
+      }
+    }
+    if (bucketKey === null) {
+      bucketKey = `${item.page}:${item.y}`;
+      buckets.set(bucketKey, [item]);
+    } else {
+      const existing = buckets.get(bucketKey);
+      if (existing)
+        existing.push(item);
+    }
+  }
+  return [...buckets.entries()].sort((a2, b2) => {
+    const [pa, ya] = a2[0].split(":").map(Number);
+    const [pb, yb] = b2[0].split(":").map(Number);
+    return pa !== pb ? pa - pb : yb - ya;
+  }).map(([, row]) => row.sort((r1, r2) => r1.x - r2.x));
+}
+var MONTH_MAP = {
+  january: 1,
+  february: 2,
+  march: 3,
+  april: 4,
+  may: 5,
+  june: 6,
+  july: 7,
+  august: 8,
+  september: 9,
+  october: 10,
+  november: 11,
+  december: 12
+};
+function parseMonthDayYear(raw) {
+  const match = raw.trim().match(/^(\w+)\s+(\d{1,2}),?\s+(\d{4})$/);
+  if (!match)
+    return null;
+  const month = MONTH_MAP[match[1].toLowerCase()];
+  if (!month)
+    return null;
+  const day = parseInt(match[2], 10);
+  const year = parseInt(match[3], 10);
+  const iso = `${year}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
+  return { month, day, year, iso };
+}
+function parseMonthDay(raw) {
+  const match = raw.trim().match(/^(\w+)\s+(\d{1,2})$/);
+  if (!match)
+    return null;
+  const month = MONTH_MAP[match[1].toLowerCase()];
+  if (!month)
+    return null;
+  return { month, day: parseInt(match[2], 10) };
 }
-function isCategorizable(r2) {
-  return !r2.categoryId && !r2.isTransfer && !r2.isIgnored && !r2.isDuplicate;
+function parseAmexPdfDate(raw, meta2) {
+  const parsed = parseMonthDay(raw);
+  if (!parsed)
+    return null;
+  const year = parsed.month > meta2.periodEndMonth ? meta2.periodEndYear - 1 : meta2.periodEndYear;
+  return `${year}-${String(parsed.month).padStart(2, "0")}-${String(parsed.day).padStart(2, "0")}`;
 }
-async function fetchUncategorized(client, crypto3, range2 = {}) {
-  const params = { uncategorized: "true" };
-  if (range2.startDate)
-    params.startDate = range2.startDate;
-  if (range2.endDate)
-    params.endDate = range2.endDate;
-  return (await fetchAllRows(client, crypto3, params)).filter(isCategorizable);
+function parseAmount(raw) {
+  if (!raw)
+    return 0;
+  const cleaned = raw.replace(/,/g, "").trim();
+  const num = parseFloat(cleaned);
+  return Number.isNaN(num) ? 0 : Math.abs(num);
 }
-var titleCase = (s2) => s2.replace(/\b[a-z]/g, (c2) => c2.toUpperCase());
-async function applyGroupAssignments(client, crypto3, assignments, opts = {}) {
-  const catIndex = await loadCategoryIndex(client);
-  const resolved = assignments.map((a2) => ({ a: a2, cat: requireCategory(catIndex, a2.categorySlug) }));
-  const groups = groupRows(await fetchUncategorized(client, crypto3, opts));
-  const result = { applied: [], notFound: [], rulesSaved: 0, unlearnable: [] };
-  const plan = [];
-  const claimed = new Set;
-  for (const { a: a2, cat } of resolved) {
-    const hits = groups.filter((g3) => g3.pattern === a2.pattern && (!a2.type || g3.type === a2.type) && !claimed.has(g3));
-    if (hits.length === 0) {
-      result.notFound.push(a2.pattern);
-      continue;
-    }
-    for (const g3 of hits) {
-      claimed.add(g3);
-      plan.push({ group: g3, categoryId: cat.id, slug: cat.slug, learn: a2.learn !== false });
-    }
+// ../parsers/src/classify.ts
+var CORPORATE_TOKENS = [
+  "PVT",
+  "PRIVATE",
+  "LIMITED",
+  "LTD",
+  "LLP",
+  "INC",
+  "CORP",
+  "ENTERPRISES",
+  "TECHNOLOGIES",
+  "SOLUTIONS",
+  "SERVICES"
+];
+var CORPORATE_REGEX = new RegExp(`\\b(${CORPORATE_TOKENS.join("|")})\\b`);
+function classifyEntity({ paymentMethod, extractedName }) {
+  if (paymentMethod === "atm")
+    return "merchant";
+  if (paymentMethod === "pos")
+    return "merchant";
+  const upper = (extractedName ?? "").toUpperCase();
+  if (upper && CORPORATE_REGEX.test(upper))
+    return "merchant";
+  if (paymentMethod === "imps")
+    return "person";
+  if (paymentMethod === "upi")
+    return "person";
+  if (paymentMethod === "neft" || paymentMethod === "rtgs")
+    return "merchant";
+  if (paymentMethod === "ach")
+    return "merchant";
+  return "unknown";
+}
+// ../parsers/src/lib/parse-helpers.ts
+function parseAmount2(cell) {
+  if (cell === null || cell === undefined || cell === "")
+    return 0;
+  if (typeof cell === "number")
+    return Math.abs(cell);
+  const cleaned = String(cell).replace(/,/g, "").trim();
+  const num = parseFloat(cleaned);
+  return Number.isNaN(num) ? 0 : Math.abs(num);
+}
+
+// ../parsers/src/hdfc/narration.ts
+function parseHdfcNarration(narration) {
+  const trimmed = narration.trim();
+  if (trimmed.startsWith("UPI-")) {
+    return parseUpi(trimmed);
   }
-  if (opts.dryRun) {
-    result.applied = plan.map((p2) => ({
-      pattern: p2.group.pattern,
-      type: p2.group.type,
-      rows: p2.group.rows.length,
-      category: p2.slug
-    }));
-    return result;
+  if (trimmed.startsWith("NEFT CR-") || trimmed.startsWith("NEFT DR-")) {
+    return parseNeft(trimmed);
   }
-  if (plan.length === 0)
-    return result;
-  const learnable = plan.filter((p2) => p2.learn && p2.group.pattern !== UNPARSED);
-  const merchantByRawId = new Map;
-  if (learnable.length > 0) {
-    const ms = await client.get("/api/merchants");
-    for (const m2 of ms.data ?? [])
-      if (m2.rawId && m2.householdId)
-        merchantByRawId.set(m2.rawId, m2.id);
+  if (trimmed.startsWith("ACH D-") || trimmed.startsWith("ACH C-")) {
+    return parseAch(trimmed);
   }
-  const { bag, version: version2 } = await loadBag(client);
-  const now = new Date().toISOString();
-  const links = [];
-  const direct = [];
-  for (const { group, categoryId, slug, learn } of plan) {
-    result.applied.push({
-      pattern: group.pattern,
-      type: group.type,
-      rows: group.rows.length,
-      category: slug
-    });
-    if (!learn || group.pattern === UNPARSED) {
-      if (learn)
-        result.unlearnable.push(UNPARSED);
-      direct.push({ ids: group.rows.map((r2) => r2.id), categoryId });
-      continue;
-    }
-    const rawId = `pattern:${group.pattern}`;
-    let merchantId = merchantByRawId.get(rawId);
-    if (!merchantId) {
-      const created = await client.post("/api/merchants", {
-        rawId,
-        cleanName: titleCase(group.pattern),
-        categoryId
-      });
-      merchantId = created.data.id;
-      merchantByRawId.set(rawId, merchantId);
-    }
-    if (!bag.merchantAliases.some((al) => al.pattern === group.pattern)) {
-      bag.merchantAliases.push({ pattern: group.pattern, merchantId, createdAt: now });
-    }
-    bag.merchantRules[merchantId] = { categoryId, lastUserCategoryAt: now };
-    result.rulesSaved += 1;
-    const withPerson = group.rows.filter((r2) => r2.personId);
-    if (withPerson.length)
-      direct.push({ ids: withPerson.map((r2) => r2.id), categoryId });
-    for (const r2 of group.rows) {
-      if (!r2.personId)
-        links.push({ transactionId: r2.id, merchantId, categoryId });
-    }
+  if (trimmed.startsWith("FT-") || trimmed.startsWith("FT -")) {
+    return parseFt(trimmed);
   }
-  if (result.rulesSaved > 0)
-    await saveBag(client, bag, version2);
-  await postLinks(client, links);
-  for (const { ids, categoryId } of direct) {
-    const categoryType = [...catIndex.byId.entries()].find(([id]) => id === categoryId)?.[1].type;
-    for (let i2 = 0;i2 < ids.length; i2 += 200) {
-      await client.patch("/api/transactions/bulk", {
-        ids: ids.slice(i2, i2 + 200),
-        categoryId,
-        ...categoryType ? { categoryType } : {}
-      });
-    }
+  if (trimmed.startsWith("IMPS-") || trimmed.startsWith("IMPS/")) {
+    return parseImps(trimmed);
   }
-  return result;
-}
-
-// src/lib/jev-categorize.ts
-var JEV_MODEL = "jev-1.13.0";
-var DEFAULT_MIN_CONFIDENCE = 0.95;
-var TIMEOUT_MS = 8000;
-var CONCURRENCY = 8;
-var MIN_LEARN_PATTERN_LEN = 5;
-function assertPrivateModeAllowed(crypto3, env2 = process.env) {
-  if (crypto3 && env2.JEV_ALLOW_PRIVATE_MODE !== "1") {
-    throw new Error("Jev categorization is disabled in private mode: it would send transaction text to a third party. " + "To opt in for your own account, set JEV_ALLOW_PRIVATE_MODE=1 in the MCP's environment. " + "Otherwise use get_uncategorized_groups + categorize_groups.");
+  if (trimmed.startsWith("ATW-") || trimmed.startsWith("ATM-") || trimmed.startsWith("ATM/")) {
+    return {
+      paymentMethod: "atm",
+      name: "ATM Withdrawal",
+      upiId: null,
+      referenceNumber: null,
+      description: trimmed
+    };
+  }
+  if (trimmed.startsWith("POS ")) {
+    return parsePos(trimmed);
   }
+  return parseFallback(trimmed);
 }
-function assertJevAllowed(crypto3, env2 = process.env) {
-  assertPrivateModeAllowed(crypto3, env2);
-  const key = env2.JEV_API_KEY;
-  if (!key)
-    throw new Error("JEV_API_KEY is not set — Jev categorization is off.");
-  return key;
+function parseUpi(narration) {
+  const rest = narration.slice(4);
+  const parts = rest.split("-");
+  if (parts.length < 4) {
+    return {
+      paymentMethod: "upi",
+      name: rest,
+      upiId: null,
+      referenceNumber: null,
+      description: null
+    };
+  }
+  const name = parts[0].trim();
+  const upiId = parts[1]?.trim() || null;
+  const referenceNumber = parts[3]?.trim() || null;
+  const description = parts.length > 4 ? parts.slice(4).join("-").trim() : null;
+  return {
+    paymentMethod: "upi",
+    name: cleanName(name),
+    upiId,
+    referenceNumber,
+    description: description || null
+  };
 }
-function makeJevClassifier(apiKey) {
-  const client = new TypeSafeClient({ apiKey, timeout: TIMEOUT_MS });
-  return async (state, options) => {
-    const { answers } = await client.systemOne({
-      model: JEV_MODEL,
-      state,
-      questions: {
-        category: choice("Which spending category best fits this bank transaction?", options)
-      }
-    });
-    return { choice: answers.category.choice, confidence: answers.category.confidence };
+function parseNeft(narration) {
+  const isCredit = narration.startsWith("NEFT CR-");
+  const rest = narration.slice(isCredit ? 8 : 8);
+  const parts = rest.split("-");
+  if (parts.length < 2) {
+    return {
+      paymentMethod: "neft",
+      name: rest,
+      upiId: null,
+      referenceNumber: null,
+      description: null
+    };
+  }
+  const companyName = parts[1]?.trim() || parts[0]?.trim() || rest;
+  const referenceNumber = parts[parts.length - 1]?.trim() || null;
+  return {
+    paymentMethod: "neft",
+    name: cleanName(companyName),
+    upiId: null,
+    referenceNumber,
+    description: null
   };
 }
-var UNSURE = "unsure";
-function sanitizeNarration(s2) {
-  return s2.replace(/\d{3,}/g, " ").replace(/\s+/g, " ").trim();
+function parseAch(narration) {
+  const rest = narration.slice(7).trim();
+  const parts = rest.split("-");
+  const name = parts[0]?.trim() || rest;
+  const referenceNumber = parts.length > 1 ? parts[parts.length - 1]?.trim() : null;
+  return {
+    paymentMethod: "ach",
+    name: cleanName(name),
+    upiId: null,
+    referenceNumber,
+    description: null
+  };
 }
-function optionsFor(type, index) {
-  const allowed = type === "credit" ? new Set(["income", "transfer"]) : new Set(["needs", "wants", "investments", "transfer"]);
-  const out = {};
-  for (const [slug, c2] of index.bySlug) {
-    if (index.parents.has(slug) || !allowed.has(c2.type))
-      continue;
-    out[slug] = `${c2.type}: ${slug.replace(/_/g, " ")}`;
+function parseFt(narration) {
+  const rest = narration.replace(/^FT[\s-]+/, "").trim();
+  const spaceDashParts = rest.split(" - ");
+  if (spaceDashParts.length >= 2) {
+    const namePart = spaceDashParts.find((p2, i2) => i2 > 0 && p2.trim().length > 0);
+    return {
+      paymentMethod: "fund_transfer",
+      name: cleanName(namePart?.trim() || rest),
+      upiId: null,
+      referenceNumber: spaceDashParts[0]?.split("-")[0]?.trim() || null,
+      description: null
+    };
   }
-  out[UNSURE] = "unclear, or a payment to an individual person";
-  return out;
+  return {
+    paymentMethod: "fund_transfer",
+    name: cleanName(rest),
+    upiId: null,
+    referenceNumber: null,
+    description: null
+  };
 }
-function groupState(type, sample) {
-  const dir = type === "credit" ? "Money received" : "Money paid out";
-  return `${dir}. Bank narration: "${sample.slice(0, 80)}"`;
+function parseImps(narration) {
+  const rest = narration.replace(/^IMPS[-/]/, "").trim();
+  const parts = rest.split("-");
+  const referenceNumber = parts[0]?.trim() || null;
+  const name = parts.length > 1 ? parts[1]?.trim() : rest;
+  return {
+    paymentMethod: "imps",
+    name: cleanName(name || rest),
+    upiId: null,
+    referenceNumber,
+    description: null
+  };
 }
-async function mapLimit(items, limit, fn2) {
-  const out = new Array(items.length);
-  let next = 0;
-  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, async () => {
-    while (next < items.length) {
-      const i2 = next++;
-      out[i2] = await fn2(items[i2]);
-    }
-  }));
-  return out;
+function parsePos(narration) {
+  const rest = narration.slice(4).trim();
+  const cleaned = rest.replace(/^[0-9X]{4,}\s*/, "").trim();
+  return {
+    paymentMethod: "pos",
+    name: cleanName(cleaned || rest),
+    upiId: null,
+    referenceNumber: null,
+    description: null
+  };
 }
-async function jevCategorize(client, crypto3, classify, opts = {}) {
-  assertPrivateModeAllowed(crypto3, opts.env);
-  const min = opts.minConfidence ?? DEFAULT_MIN_CONFIDENCE;
-  const index = await loadCategoryIndex(client);
-  const rows = await fetchUncategorized(client, crypto3, opts);
-  const groups = groupRows(rows);
-  const unparsed = groups.filter((g3) => g3.pattern === UNPARSED).length;
-  const candidates = groups.filter((g3) => g3.pattern !== UNPARSED);
-  let errors4 = 0;
-  const suggestions = await mapLimit(candidates, CONCURRENCY, async (g3) => {
-    try {
-      const options = optionsFor(g3.type, index);
-      const sample = g3.rows[0].description;
-      const text = crypto3 ? sanitizeNarration(sample) : sample;
-      const r2 = await classify(groupState(g3.type, text), options);
-      return r2.choice in options ? { g: g3, ...r2 } : null;
-    } catch {
-      errors4 += 1;
-      return null;
-    }
-  });
-  const accepted = [];
-  const review = [];
-  for (const s2 of suggestions) {
-    if (!s2)
-      continue;
-    const isTransfer = index.bySlug.get(s2.choice)?.type === "transfer";
-    if (s2.choice !== UNSURE && !isTransfer && s2.confidence >= min) {
-      accepted.push({
-        pattern: s2.g.pattern,
-        type: s2.g.type,
-        categorySlug: s2.choice,
-        learn: s2.g.pattern.length >= MIN_LEARN_PATTERN_LEN,
-        confidence: s2.confidence
-      });
-    } else {
-      review.push({
-        pattern: s2.g.pattern,
-        type: s2.g.type === "credit" ? "cr" : "dr",
-        best: s2.choice,
-        confidence: Math.round(s2.confidence * 100) / 100,
-        total: Math.round(s2.g.total)
-      });
-    }
-  }
-  review.sort((a2, b2) => b2.total - a2.total);
-  const applied = await applyGroupAssignments(client, crypto3, accepted.map(({ confidence: _c, ...a2 }) => a2), { dryRun: opts.dryRun, startDate: opts.startDate, endDate: opts.endDate });
-  const conf = new Map(accepted.map((a2) => [`${a2.pattern}|${a2.type}`, a2.confidence]));
+function parseFallback(narration) {
   return {
-    dryRun: !!opts.dryRun,
-    applied: applied.applied.map((a2) => ({
-      pattern: a2.pattern,
-      category: a2.category,
-      confidence: Math.round((conf.get(`${a2.pattern}|${a2.type}`) ?? 0) * 100) / 100,
-      rows: a2.rows
-    })),
-    review: review.slice(0, 30),
-    skipped: { unparsed, errors: errors4 },
-    rulesSaved: applied.rulesSaved
+    paymentMethod: "other",
+    name: cleanName(narration),
+    upiId: null,
+    referenceNumber: null,
+    description: null
   };
 }
-
-// src/tools/jev.ts
-function registerJevTools(server, client, crypto3) {
-  server.registerTool("auto_categorize_jev", {
-    description: "Auto-categorize uncategorized transactions with Jev (TypeSafe's classifier) — zero LLM tokens, ~ms per group. " + "OPT-IN: needs JEV_API_KEY. Refuses in private mode (it would send transaction text to a third party) unless the owner sets JEV_ALLOW_PRIVATE_MODE=1; in private mode only the sanitized merchant pattern is sent. " + "Groups by merchant pattern; groups at/above `minConfidence` (default 0.85) are categorized and a reusable rule is saved; " + "the rest come back in `review` (top 30 by ₹) for you to decide with `categorize_groups`. Use dryRun to preview.",
-    inputSchema: {
-      startDate: exports_external.string().optional().describe("YYYY-MM-DD"),
-      endDate: exports_external.string().optional().describe("YYYY-MM-DD"),
-      minConfidence: exports_external.number().min(0.5).max(1).optional().describe(`Apply at/above this confidence (default ${DEFAULT_MIN_CONFIDENCE})`),
-      dryRun: exports_external.boolean().optional()
-    }
-  }, async ({ startDate, endDate, minConfidence, dryRun }) => {
-    const key = assertJevAllowed(crypto3);
-    const result = await jevCategorize(client, crypto3, makeJevClassifier(key), {
-      startDate,
-      endDate,
-      minConfidence,
-      dryRun
-    });
-    return { content: [{ type: "text", text: JSON.stringify(result) }] };
-  });
+function cleanName(raw) {
+  return raw.replace(/\s+(PRIVATE|PVT\.?)\s*\w*/gi, "").replace(/\s+(LIMITED|LTD\.?)(\s|$)/gi, " ").replace(/[\s.-]+$/, "").replace(/\s{2,}/g, " ").trim();
 }
 
-// src/tools/merchants.ts
-async function categorySlugToId(client) {
-  const res = await client.get("/api/categories");
-  const map2 = new Map;
-  for (const root of res.data ?? []) {
-    if (root.slug)
-      map2.set(root.slug, root.id);
-    for (const child of root.children ?? []) {
-      if (child.slug)
-        map2.set(child.slug, child.id);
-    }
+// ../parsers/src/sbi/savings.ts
+function parseSbiNarration(narration) {
+  const upper = narration.toUpperCase();
+  const upiMatch = narration.match(/UPI\/(?:DR|CR)\/(\d+)\/([^/]+)\/([A-Z]{2,6})\/([^/\s]+)/i);
+  if (upiMatch) {
+    const name = upiMatch[2].trim();
+    const upiId = upiMatch[4].trim();
+    return {
+      paymentMethod: "upi",
+      name: name || null,
+      upiId: upiId || null
+    };
   }
-  return map2;
-}
-function registerMerchantTools(server, client, crypto3) {
-  server.registerTool("upsert_merchant", {
-    description: "Create or update a merchant in the dictionary. Omit `id` to add a new merchant (future transactions from it are auto-categorised); pass `id` to update an existing merchant's name, category, or flags.",
-    inputSchema: {
-      id: exports_external.string().optional().describe("Merchant UUID — pass to update, omit to create"),
-      rawId: exports_external.string().optional().describe("Raw identifier — UPI ID or normalised name (required when creating)"),
-      cleanName: exports_external.string().optional().describe('Human-friendly name (e.g. "DMart")'),
-      categorySlug: exports_external.string().optional().describe("Category slug, e.g. 'food_delivery'"),
-      isPerson: exports_external.boolean().optional(),
-      isRecurring: exports_external.boolean().optional(),
-      notes: exports_external.string().optional()
+  if (upper.includes("NEFT")) {
+    const neftMatch = narration.match(/NEFT[-/][\w]+[-/]([\w\s]+?)(?:[-/]|$)/i);
+    return {
+      paymentMethod: "neft",
+      name: neftMatch ? neftMatch[1].trim() : null,
+      upiId: null
+    };
+  }
+  if (upper.includes("RTGS")) {
+    return { paymentMethod: "rtgs", name: null, upiId: null };
+  }
+  if (upper.includes("IMPS")) {
+    return { paymentMethod: "imps", name: null, upiId: null };
+  }
+  if (upper.includes("ATM") || upper.includes("WDL ATM")) {
+    return { paymentMethod: "atm", name: null, upiId: null };
+  }
+  if (upper.includes("POS") || upper.includes("PURCHASE")) {
+    return { paymentMethod: "pos", name: null, upiId: null };
+  }
+  if (upper.includes("INT.COLL") || upper.includes("INTEREST")) {
+    return { paymentMethod: "other", name: "Interest", upiId: null };
+  }
+  return { paymentMethod: null, name: null, upiId: null };
+}
+// ../parsers/src/hdfc/cc-pdf.ts
+var _pdfjs2 = null;
+async function getPdfjs2() {
+  if (!_pdfjs2) {
+    _pdfjs2 = await import("pdfjs-dist/legacy/build/pdf.mjs");
+    _pdfjs2.GlobalWorkerOptions.workerSrc = import.meta.resolve("pdfjs-dist/legacy/build/pdf.worker.mjs");
+  }
+  return _pdfjs2;
+}
+var NOISE = /^(C|l|EMI|PI)$/;
+var NEUCOIN = /^[+-]\s*[\d,]/;
+var DATE_CELL = /^\d{2}\/\d{2}\/\d{4}/;
+var AMOUNT_CELL = /^[\d,]+\.\d{2}$/;
+var CREDIT_CELL = /^\+$/;
+var ROW_TOLERANCE2 = 4;
+async function parseHdfcCreditCardPdf(data, password) {
+  const pdfjs = await getPdfjs2();
+  const loadOptions = {
+    data: new Uint8Array(data),
+    useWorkerFetch: false,
+    isEvalSupported: false,
+    useSystemFonts: true
+  };
+  if (password)
+    loadOptions.password = password;
+  const pdf = await pdfjs.getDocument(loadOptions).promise;
+  const items = await extractTextItems2(pdf);
+  const metadata = extractMetadata2(items);
+  const transactions = parseTransactions2(items);
+  return {
+    bank: "hdfc",
+    accountType: "credit_card",
+    accountNumber: metadata.accountLast4,
+    periodStart: metadata.periodStart,
+    periodEnd: metadata.periodEnd,
+    transactions
+  };
+}
+async function extractTextItems2(pdf) {
+  const result = [];
+  for (let p2 = 1;p2 <= pdf.numPages; p2++) {
+    const page = await pdf.getPage(p2);
+    const content = await page.getTextContent();
+    for (const item of content.items) {
+      const ti = item;
+      if (typeof ti.str !== "string" || !ti.str.trim())
+        continue;
+      result.push({
+        page: p2,
+        x: Math.round(ti.transform[4]),
+        y: Math.round(ti.transform[5]),
+        str: ti.str
+      });
     }
-  }, async ({ id, categorySlug, ...rest }) => {
-    const payload = { ...rest };
-    if (categorySlug) {
-      const slugMap = await categorySlugToId(client);
-      const categoryId = slugMap.get(categorySlug);
-      if (!categoryId) {
-        throw new Error(`Unknown categorySlug "${categorySlug}". Use list_categories to see valid slugs.`);
+  }
+  return result;
+}
+function extractMetadata2(items) {
+  const fullText = items.map((i2) => i2.str).join(" ");
+  const cardMatch = fullText.match(/(\d{6}X{6}\d{4})/);
+  const accountLast4 = cardMatch ? cardMatch[1].slice(-4) : null;
+  const DATE_PART = /\d{1,2}\s+\w+,?\s+\d{4}/;
+  const periodMatch = fullText.match(new RegExp(`(${DATE_PART.source})\\s*[-–]\\s*(${DATE_PART.source})`));
+  let periodStart = null;
+  let periodEnd = null;
+  if (periodMatch) {
+    periodStart = parseMonthNameDate(periodMatch[1]);
+    periodEnd = parseMonthNameDate(periodMatch[2]);
+  }
+  return { accountLast4, periodStart, periodEnd };
+}
+function parseTransactions2(items) {
+  const rows = buildRows2(items);
+  const transactions = [];
+  for (const row of rows) {
+    const dateItem = row.find((c2) => DATE_CELL.test(c2.str.trim()));
+    if (!dateItem)
+      continue;
+    const date4 = parseDdMmYyyy(dateItem.str);
+    if (!date4)
+      continue;
+    const useful = row.filter((c2) => !NOISE.test(c2.str.trim()) && !NEUCOIN.test(c2.str.trim()));
+    const amountItem = [...useful].reverse().find((c2) => AMOUNT_CELL.test(c2.str.trim()));
+    if (!amountItem)
+      continue;
+    const amount = parseAmount2(amountItem.str);
+    if (amount === 0)
+      continue;
+    const isCredit = useful.some((c2) => CREDIT_CELL.test(c2.str.trim()));
+    const description = useful.filter((c2) => c2 !== dateItem && c2 !== amountItem && !CREDIT_CELL.test(c2.str.trim()) && c2.x < amountItem.x).sort((a2, b2) => a2.x - b2.x).map((c2) => c2.str).join(" ").replace(/([a-z])([A-Z][a-z])/g, "$1 $2").replace(/\s{2,}/g, " ").trim();
+    if (!description)
+      continue;
+    transactions.push({
+      date: date4,
+      description,
+      amount,
+      type: isCredit ? "credit" : "debit",
+      referenceNumber: null,
+      valueDate: null,
+      closingBalance: null,
+      paymentMethod: null,
+      extractedName: description,
+      upiId: null,
+      sourceCategory: null
+    });
+  }
+  return transactions;
+}
+function buildRows2(items) {
+  const buckets = new Map;
+  for (const item of items) {
+    const pagePrefix = `${item.page}:`;
+    let bucketKey = null;
+    for (const key of buckets.keys()) {
+      if (!key.startsWith(pagePrefix))
+        continue;
+      const bucketY = parseInt(key.slice(pagePrefix.length), 10);
+      if (Math.abs(item.y - bucketY) <= ROW_TOLERANCE2) {
+        bucketKey = key;
+        break;
       }
-      payload.categoryId = categoryId;
     }
-    const data = id ? await client.patch(`/api/merchants/${id}`, payload) : await client.post("/api/merchants", payload);
-    return { content: [{ type: "text", text: JSON.stringify(data) }] };
-  });
-  server.registerTool("list_merchants", {
-    description: "List merchants in the dictionary with their categories and transaction counts. Pass `rawId` to look up a single merchant by its raw ID (UPI ID or normalised name) instead of listing all.",
-    inputSchema: {
-      rawId: exports_external.string().optional().describe("Raw identifier to look up a single merchant; omit to list all")
+    if (bucketKey === null) {
+      bucketKey = `${item.page}:${item.y}`;
+      buckets.set(bucketKey, [item]);
+    } else {
+      const existing = buckets.get(bucketKey);
+      if (existing)
+        existing.push(item);
+    }
+  }
+  return [...buckets.entries()].sort((a2, b2) => {
+    const [pa, ya] = a2[0].split(":").map(Number);
+    const [pb, yb] = b2[0].split(":").map(Number);
+    return pa !== pb ? pa - pb : yb - ya;
+  }).map(([, row]) => row.sort((a2, b2) => a2.x - b2.x));
+}
+var MONTH_NAMES = {
+  jan: "01",
+  feb: "02",
+  mar: "03",
+  apr: "04",
+  may: "05",
+  jun: "06",
+  jul: "07",
+  aug: "08",
+  sep: "09",
+  oct: "10",
+  nov: "11",
+  dec: "12"
+};
+function parseMonthNameDate(raw) {
+  const match = raw.trim().match(/^(\d{1,2})\s+(\w{3})\w*,?\s+(\d{4})$/);
+  if (!match)
+    return null;
+  const month = MONTH_NAMES[match[2].toLowerCase().slice(0, 3)];
+  if (!month)
+    return null;
+  return `${match[3]}-${month}-${match[1].padStart(2, "0")}`;
+}
+function parseDdMmYyyy(raw) {
+  const match = raw.trim().match(/^(\d{2})\/(\d{2})\/(\d{4})/);
+  if (!match)
+    return null;
+  return `${match[3]}-${match[2]}-${match[1]}`;
+}
+// ../parsers/src/hdfc/savings-pdf.ts
+var _pdfjs3 = null;
+async function getPdfjs3() {
+  if (!_pdfjs3) {
+    _pdfjs3 = await import("pdfjs-dist/legacy/build/pdf.mjs");
+    _pdfjs3.GlobalWorkerOptions.workerSrc = import.meta.resolve("pdfjs-dist/legacy/build/pdf.worker.mjs");
+  }
+  return _pdfjs3;
+}
+var X_DATE_MAX2 = 56;
+var X_NARRATION_MIN = 60;
+var X_NARRATION_MAX = 280;
+var X_REF_MIN = 280;
+var X_VALUEDT_MIN = 355;
+var X_WITHDRAWAL_MIN = 402;
+var X_WITHDRAWAL_MAX = 490;
+var X_DEPOSIT_MIN = 490;
+var X_DEPOSIT_MAX = 560;
+var X_BALANCE_MIN = 560;
+var Y_DATA_MAX = 618;
+var Y_DATA_MIN2 = 55;
+var ROW_TOLERANCE3 = 4;
+async function parseHdfcSavingsPdf(data, password) {
+  const pdfjs = await getPdfjs3();
+  const loadOptions = {
+    data: new Uint8Array(data),
+    useWorkerFetch: false,
+    isEvalSupported: false,
+    useSystemFonts: true
+  };
+  if (password)
+    loadOptions.password = password;
+  const pdf = await pdfjs.getDocument(loadOptions).promise;
+  const items = await extractTextItems3(pdf);
+  const metadata = extractMetadata3(items);
+  const transactions = parseHdfcSavingsItems(items);
+  return {
+    bank: "hdfc",
+    accountType: metadata.accountType,
+    accountNumber: metadata.accountLast4,
+    periodStart: metadata.periodStart,
+    periodEnd: metadata.periodEnd,
+    transactions
+  };
+}
+async function extractTextItems3(pdf) {
+  const result = [];
+  for (let p2 = 1;p2 <= pdf.numPages; p2++) {
+    const page = await pdf.getPage(p2);
+    const content = await page.getTextContent();
+    for (const item of content.items) {
+      const ti = item;
+      if (typeof ti.str !== "string" || !ti.str.trim())
+        continue;
+      result.push({
+        page: p2,
+        x: Math.round(ti.transform[4]),
+        y: Math.round(ti.transform[5]),
+        str: ti.str,
+        w: Math.round(ti.width ?? 0)
+      });
     }
-  }, async ({ rawId }) => {
-    if (crypto3 && rawId) {
-      const data2 = await client.get("/api/merchants");
-      if (data2.data)
-        await decryptMerchantFields(data2.data, crypto3.key);
-      const needle = rawId.toLowerCase();
-      const merchants = (data2.data ?? []).filter((m2) => String(m2.rawId ?? "").toLowerCase() === needle || String(m2.cleanName ?? "").toLowerCase().includes(needle));
-      return {
-        content: [{ type: "text", text: JSON.stringify({ ...data2, data: merchants }) }]
+  }
+  return result;
+}
+function extractMetadata3(items) {
+  const headerItems = items.filter((i2) => i2.y > Y_DATA_MAX);
+  const rowStrings = groupIntoRowStrings2(headerItems);
+  const fullText = rowStrings.join(" ");
+  let accountType = "savings";
+  let accountLast4 = null;
+  let periodStart = null;
+  let periodEnd = null;
+  const accountMatch = fullText.match(/Account No\s*:?\s*(\d{10,18})/);
+  if (accountMatch) {
+    accountLast4 = accountMatch[1].slice(-4);
+  }
+  if (/current/i.test(fullText) && /account.*type/i.test(fullText)) {
+    accountType = "current";
+  }
+  const periodMatch = fullText.match(/(?:Statement\s+)?From\s*:\s*(\d{2}\/\d{2}\/\d{4})\s+To\s*:\s*(\d{2}\/\d{2}\/\d{4})/i);
+  if (periodMatch) {
+    periodStart = parseHdfcDate(periodMatch[1]);
+    periodEnd = parseHdfcDate(periodMatch[2]);
+  }
+  return { accountType, accountLast4, periodStart, periodEnd };
+}
+function groupIntoRowStrings2(items) {
+  const buckets = new Map;
+  for (const item of items) {
+    const pagePrefix = `${item.page}:`;
+    let bucketKey = null;
+    for (const key of buckets.keys()) {
+      if (!key.startsWith(pagePrefix))
+        continue;
+      if (Math.abs(item.y - parseInt(key.slice(pagePrefix.length), 10)) <= ROW_TOLERANCE3) {
+        bucketKey = key;
+        break;
+      }
+    }
+    if (bucketKey === null) {
+      bucketKey = `${item.page}:${item.y}`;
+      buckets.set(bucketKey, [item]);
+    } else {
+      const existing = buckets.get(bucketKey);
+      if (existing)
+        existing.push(item);
+    }
+  }
+  return [...buckets.values()].map((row) => row.sort((a2, b2) => a2.x - b2.x).map((c2) => c2.str).join(" "));
+}
+var COMPACT_DATE_MAX_X = 90;
+var COMPACT_NARRATION_MIN_X = 90;
+var COMPACT_NUMERIC_MIN_X = 300;
+var COMPACT_WITHDRAWAL_MAX_RIGHT = 400;
+var COMPACT_DEPOSIT_MAX_RIGHT = 500;
+var AMOUNT_RE = /^[\d,]+\.\d{2}$/;
+function detectLayout(items) {
+  const hdr = items.find((i2) => /^Narration$/i.test(i2.str.trim()));
+  if (!hdr)
+    return "classic";
+  const headerRow = items.filter((i2) => i2.page === hdr.page && Math.abs(i2.y - hdr.y) <= ROW_TOLERANCE3);
+  const isClassic = headerRow.some((i2) => /chq|ref\.?\s*no|value\s*dt/i.test(i2.str));
+  return isClassic ? "classic" : "compact";
+}
+function classifyRow(row, layout) {
+  if (layout === "compact") {
+    const amounts = row.filter((c2) => c2.x >= COMPACT_NUMERIC_MIN_X && AMOUNT_RE.test(c2.str.trim()));
+    const right = (c2) => c2.x + c2.w;
+    return {
+      dateCell: row.find((c2) => c2.x <= COMPACT_DATE_MAX_X),
+      narrationCells: row.filter((c2) => c2.x > COMPACT_NARRATION_MIN_X && c2.x < COMPACT_NUMERIC_MIN_X),
+      withdrawalCell: amounts.find((c2) => right(c2) < COMPACT_WITHDRAWAL_MAX_RIGHT),
+      depositCell: amounts.find((c2) => right(c2) >= COMPACT_WITHDRAWAL_MAX_RIGHT && right(c2) < COMPACT_DEPOSIT_MAX_RIGHT),
+      balanceCell: amounts.find((c2) => right(c2) >= COMPACT_DEPOSIT_MAX_RIGHT)
+    };
+  }
+  return {
+    dateCell: row.find((c2) => c2.x <= X_DATE_MAX2),
+    narrationCells: row.filter((c2) => c2.x >= X_NARRATION_MIN && c2.x < X_NARRATION_MAX),
+    refCell: row.find((c2) => c2.x >= X_REF_MIN && c2.x < X_VALUEDT_MIN),
+    valueDtCell: row.find((c2) => c2.x >= X_VALUEDT_MIN && c2.x < X_WITHDRAWAL_MIN),
+    withdrawalCell: row.find((c2) => c2.x >= X_WITHDRAWAL_MIN && c2.x < X_WITHDRAWAL_MAX),
+    depositCell: row.find((c2) => c2.x >= X_DEPOSIT_MIN && c2.x < X_DEPOSIT_MAX),
+    balanceCell: row.find((c2) => c2.x >= X_BALANCE_MIN)
+  };
+}
+function parseHdfcSavingsItems(items) {
+  const transactions = parseTransactions3(items, detectLayout(items));
+  assertBalanceContinuity(transactions);
+  return transactions;
+}
+function assertBalanceContinuity(txns) {
+  let checked = 0;
+  let bad = 0;
+  for (let i2 = 1;i2 < txns.length; i2++) {
+    const prev = txns[i2 - 1].closingBalance;
+    const cur = txns[i2].closingBalance;
+    if (prev == null || cur == null)
+      continue;
+    checked++;
+    const expected = prev + (txns[i2].type === "credit" ? txns[i2].amount : -txns[i2].amount);
+    if (Math.abs(expected - cur) > 0.02)
+      bad++;
+  }
+  if (checked >= 5 && bad / checked > 0.25) {
+    throw new Error(`HDFC savings PDF: column layout not recognised — ${bad}/${checked} rows fail the running-balance check. Refusing to return misread amounts.`);
+  }
+}
+function parseTransactions3(items, layout) {
+  const dataItems = items.filter((i2) => i2.y > Y_DATA_MIN2 && i2.y <= Y_DATA_MAX);
+  const rows = buildRows3(dataItems);
+  const transactions = [];
+  let pending = null;
+  for (const row of rows) {
+    const {
+      dateCell,
+      narrationCells,
+      refCell,
+      valueDtCell,
+      withdrawalCell,
+      depositCell,
+      balanceCell
+    } = classifyRow(row, layout);
+    const dateStr = dateCell?.str.trim() ?? "";
+    const isDateRow = /^\d{2}\/\d{2}\/\d{2,4}$/.test(dateStr);
+    const isColumnHeader = narrationCells.some((c2) => c2.str === "Narration" || c2.str === "Date");
+    if (isColumnHeader)
+      continue;
+    if (isDateRow) {
+      if (pending) {
+        const txn = buildTransaction(pending);
+        if (txn)
+          transactions.push(txn);
+      }
+      pending = {
+        dateStr,
+        narrationParts: narrationCells.map((c2) => c2.str),
+        refNo: refCell?.str.trim() ?? null,
+        valueDateStr: valueDtCell?.str.trim() ?? null,
+        withdrawalStr: withdrawalCell?.str.trim() ?? null,
+        depositStr: depositCell?.str.trim() ?? null,
+        balanceStr: balanceCell?.str.trim() ?? null
       };
+    } else if (narrationCells.length > 0 && !refCell && !withdrawalCell && !depositCell) {
+      const continuationText = narrationCells.map((c2) => c2.str).join(" ");
+      if (/STATEMENT SUMMARY/i.test(continuationText))
+        break;
+      if (pending) {
+        pending.narrationParts.push(...narrationCells.map((c2) => c2.str));
+      }
     }
-    const data = rawId ? await client.get("/api/merchants", {
-      search: rawId
-    }) : await client.get("/api/merchants");
-    if (crypto3 && data.data)
-      await decryptMerchantFields(data.data, crypto3.key);
-    return { content: [{ type: "text", text: JSON.stringify(data) }] };
-  });
-  server.registerTool("delete_merchant", {
-    description: "Delete merchant(s) from the dictionary. Provide `id` for a single merchant or `ids` for several. Transactions referencing a deleted merchant have their merchantId cleared. PERMANENT.",
-    inputSchema: {
-      id: exports_external.string().optional().describe("Single merchant UUID"),
-      ids: exports_external.array(exports_external.string()).min(1).optional().describe("Multiple merchant UUIDs (bulk delete)")
+  }
+  if (pending) {
+    const txn = buildTransaction(pending);
+    if (txn)
+      transactions.push(txn);
+  }
+  return transactions;
+}
+function buildRows3(items) {
+  const buckets = new Map;
+  for (const item of items) {
+    const pagePrefix = `${item.page}:`;
+    let bucketKey = null;
+    for (const key of buckets.keys()) {
+      if (!key.startsWith(pagePrefix))
+        continue;
+      const bucketY = parseInt(key.slice(pagePrefix.length), 10);
+      if (Math.abs(item.y - bucketY) <= ROW_TOLERANCE3) {
+        bucketKey = key;
+        break;
+      }
     }
-  }, async ({ id, ids }) => {
-    if (!id && (!ids || ids.length === 0)) {
-      throw new Error("Provide either id or ids");
+    if (bucketKey === null) {
+      bucketKey = `${item.page}:${item.y}`;
+      buckets.set(bucketKey, [item]);
+    } else {
+      const existing = buckets.get(bucketKey);
+      if (existing)
+        existing.push(item);
     }
-    const data = ids ? await client.post("/api/merchants/bulk-delete", { ids }) : await client.delete(`/api/merchants/${id}`);
-    return { content: [{ type: "text", text: JSON.stringify(data) }] };
-  });
+  }
+  return [...buckets.entries()].sort((a2, b2) => {
+    const [pa, ya] = a2[0].split(":").map(Number);
+    const [pb, yb] = b2[0].split(":").map(Number);
+    return pa !== pb ? pa - pb : yb - ya;
+  }).map(([, row]) => row.sort((r1, r2) => r1.x - r2.x));
 }
-
-// src/tools/net-worth.ts
-function registerNetWorthTools(server, client) {
-  server.registerTool("get_net_worth", {
-    description: "Current net worth snapshot and history (up to 12 months). Includes liquid cash, investments, emergency fund, liabilities.",
-    inputSchema: {}
-  }, async () => {
-    const data = await client.get("/api/net-worth");
-    return { content: [{ type: "text", text: JSON.stringify(data) }] };
-  });
-  server.registerTool("update_net_worth", {
-    description: "Log a net worth snapshot for a specific month. Upserts — safe to call multiple times for the same month. mode=manual (default) records the provided liquidCash/investments/emergencyFund/liabilities/breakdown values. mode=auto ignores those and auto-calculates net worth from DB (investments + FDs + accounts) — use it when the data is already in the system.",
-    inputSchema: {
-      mode: exports_external.enum(["manual", "auto"]).default("manual"),
-      month: exports_external.number().min(1).max(12),
-      year: exports_external.number().min(2020).max(2100),
-      liquidCash: exports_external.string().optional(),
-      investments: exports_external.string().optional(),
-      emergencyFund: exports_external.string().optional(),
-      liabilities: exports_external.string().optional(),
-      breakdown: exports_external.record(exports_external.string(), exports_external.string()).optional()
+function buildTransaction(row) {
+  const date4 = parseHdfcDate(row.dateStr);
+  if (!date4)
+    return null;
+  let narration = row.narrationParts.join(" ").replace(/\s{2,}/g, " ").trim();
+  let embeddedValueDate = null;
+  const vd = narration.match(/\s*Value\s*Dt\s*(\d{2}\/\d{2}\/\d{2,4})/i);
+  if (vd) {
+    embeddedValueDate = parseHdfcDate(vd[1]);
+    narration = narration.replace(vd[0], "").replace(/\s{2,}/g, " ").trim();
+  }
+  if (!narration)
+    return null;
+  const withdrawal = parseAmount3(row.withdrawalStr);
+  const deposit = parseAmount3(row.depositStr);
+  if (withdrawal === 0 && deposit === 0)
+    return null;
+  const amount = withdrawal > 0 ? withdrawal : deposit;
+  const type = withdrawal > 0 ? "debit" : "credit";
+  const valueDate = row.valueDateStr ? parseHdfcDate(row.valueDateStr) : embeddedValueDate;
+  const closingBalance = parseAmount3(row.balanceStr) || null;
+  const parsed = parseHdfcNarration(narration);
+  return {
+    date: date4,
+    description: narration,
+    amount,
+    type,
+    referenceNumber: row.refNo || null,
+    valueDate,
+    closingBalance,
+    paymentMethod: parsed.paymentMethod,
+    extractedName: parsed.name,
+    upiId: parsed.upiId,
+    sourceCategory: null
+  };
+}
+function parseHdfcDate(raw) {
+  const match = raw.trim().match(/^(\d{2})\/(\d{2})\/(\d{2,4})$/);
+  if (!match)
+    return null;
+  const day = match[1];
+  const month = match[2];
+  let year = match[3];
+  if (year.length === 2) {
+    const num = parseInt(year, 10);
+    year = num > 50 ? `19${year}` : `20${year}`;
+  }
+  return `${year}-${month}-${day}`;
+}
+function parseAmount3(raw) {
+  if (!raw)
+    return 0;
+  const cleaned = raw.replace(/,/g, "").trim();
+  const num = parseFloat(cleaned);
+  return Number.isNaN(num) ? 0 : Math.abs(num);
+}
+// ../parsers/src/sbi/savings-pdf.ts
+var _pdfjs4 = null;
+async function getPdfjs4() {
+  if (!_pdfjs4) {
+    _pdfjs4 = await import("pdfjs-dist/legacy/build/pdf.mjs");
+    _pdfjs4.GlobalWorkerOptions.workerSrc = import.meta.resolve("pdfjs-dist/legacy/build/pdf.worker.mjs");
+  }
+  return _pdfjs4;
+}
+var X_DATE_MAX3 = 60;
+var X_VALUEDT_MIN2 = 61;
+var X_VALUEDT_MAX = 120;
+var X_NARRATION_MIN2 = 120;
+var X_NARRATION_MAX2 = 285;
+var X_DEBIT_MIN = 310;
+var X_DEBIT_MAX = 395;
+var X_CREDIT_MIN = 395;
+var X_CREDIT_MAX = 465;
+var X_BALANCE_MIN2 = 465;
+var Y_FOOTER_MIN = 80;
+var ROW_TOLERANCE4 = 4;
+var NARRATION_ABOVE_TOLERANCE = 12;
+async function parseSbiSavingsPdf(data, password) {
+  const pdfjs = await getPdfjs4();
+  const loadOptions = {
+    data: new Uint8Array(data),
+    useWorkerFetch: false,
+    isEvalSupported: false,
+    useSystemFonts: true
+  };
+  if (password)
+    loadOptions.password = password;
+  const pdf = await pdfjs.getDocument(loadOptions).promise;
+  const items = await extractTextItems4(pdf);
+  const metadata = extractMetadata4(items);
+  const transactions = parseTransactions4(items);
+  return {
+    bank: "sbi",
+    accountType: metadata.accountType,
+    accountNumber: metadata.accountLast4,
+    periodStart: metadata.periodStart,
+    periodEnd: metadata.periodEnd,
+    transactions
+  };
+}
+async function extractTextItems4(pdf) {
+  const result = [];
+  for (let p2 = 1;p2 <= pdf.numPages; p2++) {
+    const page = await pdf.getPage(p2);
+    const content = await page.getTextContent();
+    for (const item of content.items) {
+      const ti = item;
+      if (typeof ti.str !== "string" || !ti.str.trim())
+        continue;
+      result.push({
+        page: p2,
+        x: Math.round(ti.transform[4]),
+        y: Math.round(ti.transform[5]),
+        str: ti.str
+      });
     }
-  }, async ({ mode, ...body }) => {
-    let data;
-    if (mode === "auto") {
-      data = await client.post("/api/net-worth/auto", { month: body.month, year: body.year });
+  }
+  return result;
+}
+function extractMetadata4(items) {
+  const page1Items = items.filter((i2) => i2.page === 1);
+  const rowStrings = groupIntoRowStrings3(page1Items);
+  const fullText = rowStrings.join(" ");
+  let accountType = "savings";
+  let accountLast4 = null;
+  let periodStart = null;
+  let periodEnd = null;
+  const accountMatch = fullText.match(/Account Number\s*:\s*(\d{8,18})/);
+  if (accountMatch) {
+    accountLast4 = accountMatch[1].slice(-4);
+  }
+  if (/current.*account/i.test(fullText)) {
+    accountType = "current";
+  }
+  const periodMatch = fullText.match(/Statement From\s*:\s*(\d{2}-\d{2}-\d{4})\s+to\s+(\d{2}-\d{2}-\d{4})/i);
+  if (periodMatch) {
+    periodStart = parseSbiDate(periodMatch[1]);
+    periodEnd = parseSbiDate(periodMatch[2]);
+  }
+  return { accountType, accountLast4, periodStart, periodEnd };
+}
+function groupIntoRowStrings3(items) {
+  const buckets = new Map;
+  for (const item of items) {
+    const pagePrefix = `${item.page}:`;
+    let bucketKey = null;
+    for (const key of buckets.keys()) {
+      if (!key.startsWith(pagePrefix))
+        continue;
+      if (Math.abs(item.y - parseInt(key.slice(pagePrefix.length), 10)) <= ROW_TOLERANCE4) {
+        bucketKey = key;
+        break;
+      }
+    }
+    if (bucketKey === null) {
+      bucketKey = `${item.page}:${item.y}`;
+      buckets.set(bucketKey, [item]);
     } else {
-      const liquidCash = parseFloat(body.liquidCash ?? "0");
-      const investments = parseFloat(body.investments ?? "0");
-      const emergencyFund = parseFloat(body.emergencyFund ?? "0");
-      const liabilities = parseFloat(body.liabilities ?? "0");
-      const totalNetWorth = (liquidCash + investments + emergencyFund - liabilities).toFixed(2);
-      data = await client.post("/api/net-worth", {
-        ...body,
-        emergencyFund: body.emergencyFund ?? "0",
-        totalNetWorth
-      });
+      const existing = buckets.get(bucketKey);
+      if (existing)
+        existing.push(item);
     }
-    return { content: [{ type: "text", text: JSON.stringify(data) }] };
-  });
+  }
+  return [...buckets.values()].map((row) => row.sort((a2, b2) => a2.x - b2.x).map((c2) => c2.str).join(" "));
 }
-
-// src/tools/persons.ts
-function registerPersonTools(server, client, crypto3) {
-  server.registerTool("upsert_person", {
-    description: "Create or update a person (UPI counterparty / individual) in this household's encrypted directory. Omit `id` to add a new person; pass `id` to update any combination of an existing person's fields.",
-    inputSchema: {
-      id: exports_external.string().optional().describe("Person UUID — pass to update, omit to create"),
-      name: exports_external.string().optional().describe('Display name (e.g. "Priya") — required when creating'),
-      upiHandles: exports_external.array(exports_external.string()).optional().describe("UPI ids the person uses"),
-      phoneNumbers: exports_external.array(exports_external.string()).optional(),
-      relationship: exports_external.string().optional().describe('e.g. "sister", "friend", "landlord"'),
-      notes: exports_external.string().optional()
+function parseTransactions4(items) {
+  const dataItems = items.filter((i2) => i2.y > Y_FOOTER_MIN);
+  const rows = buildRows4(dataItems);
+  const dateRows = [];
+  for (const row of rows) {
+    const dateCell = row.find((c2) => c2.x <= X_DATE_MAX3 && /^\d{2}\/\d{2}\/\d{4}$/.test(c2.str.trim()));
+    if (dateCell) {
+      dateRows.push({ page: dateCell.page, y: dateCell.y, row });
     }
-  }, async ({ id, ...updates }) => {
-    if (crypto3) {
-      if (id) {
-        const existing = await client.get(`/api/persons/${id}`);
-        const personData = existing.data;
-        let current;
-        if (personData.cipher) {
-          current = await decryptPersonCipher(personData.cipher, crypto3.key);
-        } else {
-          current = {
-            name: personData.name,
-            upiHandles: personData.upiHandles,
-            phoneNumbers: personData.phoneNumbers,
-            relationship: personData.relationship,
-            notes: personData.notes
-          };
-        }
-        const merged = {
-          name: updates.name ?? current.name,
-          upiHandles: updates.upiHandles ?? current.upiHandles,
-          phoneNumbers: updates.phoneNumbers ?? current.phoneNumbers,
-          relationship: updates.relationship ?? current.relationship ?? null,
-          notes: updates.notes ?? current.notes ?? null
-        };
-        const payload2 = await encryptPersonCipher(merged, crypto3.key);
-        const data3 = await client.patch(`/api/persons/${id}`, payload2);
-        return { content: [{ type: "text", text: JSON.stringify(data3) }] };
+  }
+  const buckets = new Map;
+  for (const { page, y: y2, row } of dateRows) {
+    const key = `${page}:${y2}`;
+    const dateCell = row.find((c2) => c2.x <= X_DATE_MAX3);
+    if (!dateCell)
+      continue;
+    const valueDtCell = row.find((c2) => c2.x >= X_VALUEDT_MIN2 && c2.x < X_VALUEDT_MAX);
+    const debitCell = row.find((c2) => c2.x >= X_DEBIT_MIN && c2.x < X_DEBIT_MAX && c2.str.trim() !== "-");
+    const creditCell = row.find((c2) => c2.x >= X_CREDIT_MIN && c2.x < X_CREDIT_MAX && c2.str.trim() !== "-");
+    const balanceCell = row.find((c2) => c2.x >= X_BALANCE_MIN2);
+    buckets.set(key, {
+      page,
+      dateY: y2,
+      dateStr: dateCell.str.trim(),
+      valueDateStr: valueDtCell?.str.trim() ?? null,
+      debitStr: debitCell?.str.trim() ?? null,
+      creditStr: creditCell?.str.trim() ?? null,
+      balanceStr: balanceCell?.str.trim() ?? null,
+      narrationParts: []
+    });
+  }
+  const narrationItems = dataItems.filter((i2) => i2.x >= X_NARRATION_MIN2 && i2.x < X_NARRATION_MAX2);
+  for (const item of narrationItems) {
+    const yMin = item.y - NARRATION_ABOVE_TOLERANCE;
+    let bestKey = null;
+    let bestY = Number.MAX_SAFE_INTEGER;
+    for (const { page, y: y2 } of dateRows) {
+      if (page !== item.page)
+        continue;
+      if (y2 >= yMin && y2 < bestY) {
+        bestY = y2;
+        bestKey = `${page}:${y2}`;
       }
-      if (!updates.name)
-        throw new Error("name is required when creating a person");
-      const fields = {
-        name: updates.name,
-        upiHandles: updates.upiHandles ?? [],
-        phoneNumbers: updates.phoneNumbers ?? [],
-        relationship: updates.relationship ?? null,
-        notes: updates.notes ?? null
-      };
-      const payload = await encryptPersonCipher(fields, crypto3.key);
-      const data2 = await client.post("/api/persons", payload);
-      return { content: [{ type: "text", text: JSON.stringify(data2) }] };
     }
-    const data = id ? await client.patch(`/api/persons/${id}`, updates) : await client.post("/api/persons", updates);
-    return { content: [{ type: "text", text: JSON.stringify(data) }] };
-  });
-  server.registerTool("list_persons", {
-    description: "List all persons in the current household. Pass `id` to get a single person by id instead of listing all.",
-    inputSchema: {
-      id: exports_external.string().optional().describe("Person UUID to fetch a single person; omit to list all")
+    if (bestKey) {
+      const bucket = buckets.get(bestKey);
+      if (bucket)
+        bucket.narrationParts.push(item.str);
     }
-  }, async ({ id }) => {
-    if (id) {
-      const data2 = await client.get(`/api/persons/${id}`);
-      if (crypto3 && data2.data.cipher) {
-        const fields = await decryptPersonCipher(data2.data.cipher, crypto3.key);
-        Object.assign(data2.data, fields, { cipher: null });
+  }
+  const sortedBuckets = [...buckets.values()].sort((a2, b2) => a2.page !== b2.page ? a2.page - b2.page : b2.dateY - a2.dateY);
+  const transactions = [];
+  for (const bucket of sortedBuckets) {
+    const txn = buildTransaction2(bucket);
+    if (txn)
+      transactions.push(txn);
+  }
+  return transactions;
+}
+function buildRows4(items) {
+  const buckets = new Map;
+  for (const item of items) {
+    const pagePrefix = `${item.page}:`;
+    let bucketKey = null;
+    for (const key of buckets.keys()) {
+      if (!key.startsWith(pagePrefix))
+        continue;
+      const bucketY = parseInt(key.slice(pagePrefix.length), 10);
+      if (Math.abs(item.y - bucketY) <= ROW_TOLERANCE4) {
+        bucketKey = key;
+        break;
       }
-      return { content: [{ type: "text", text: JSON.stringify(data2) }] };
     }
-    const data = await client.get("/api/persons");
-    if (crypto3 && data.data) {
-      for (const person of data.data) {
-        const cipher = person.cipher;
-        if (cipher) {
-          try {
-            const fields = await decryptPersonCipher(cipher, crypto3.key);
-            Object.assign(person, fields, { cipher: null });
-          } catch {}
-        }
-      }
+    if (bucketKey === null) {
+      bucketKey = `${item.page}:${item.y}`;
+      buckets.set(bucketKey, [item]);
+    } else {
+      const existing = buckets.get(bucketKey);
+      if (existing)
+        existing.push(item);
     }
-    return { content: [{ type: "text", text: JSON.stringify(data) }] };
-  });
-  server.registerTool("delete_person", {
-    description: "Delete a person. Returns 409 if any transactions still reference this person.",
-    inputSchema: { id: exports_external.string().describe("Person UUID") }
-  }, async ({ id }) => {
-    const data = await client.delete(`/api/persons/${id}`);
-    return { content: [{ type: "text", text: JSON.stringify(data) }] };
-  });
-}
-
-// src/tools/profile.ts
-function registerProfileTools(server, client) {
-  server.registerTool("get_profile", {
-    description: "Get the current user's profile (name, email, owner).",
-    inputSchema: {}
-  }, async () => {
-    const data = await client.get("/api/profile");
-    return { content: [{ type: "text", text: JSON.stringify(data) }] };
-  });
-  server.registerTool("update_profile", {
-    description: "Update your display name.",
-    inputSchema: {
-      name: exports_external.string().min(1).describe("Display name")
-    }
-  }, async (body) => {
-    const data = await client.patch("/api/profile", body);
-    return { content: [{ type: "text", text: JSON.stringify(data) }] };
-  });
-}
-
-// src/tools/push.ts
-function registerPushTools(server, client) {
-  server.registerTool("list_push_subscriptions", {
-    description: "List the household's registered web-push subscriptions (browser/device endpoints that receive alert notifications).",
-    inputSchema: {}
-  }, async () => {
-    const data = await client.get("/api/push/subscriptions");
-    return { content: [{ type: "text", text: JSON.stringify(data) }] };
-  });
-  server.registerTool("send_test_push", {
-    description: "Send a test web-push notification to all of the household's subscriptions. Use to verify push delivery is working.",
-    inputSchema: {}
-  }, async () => {
-    const data = await client.post("/api/push/test");
-    return { content: [{ type: "text", text: JSON.stringify(data) }] };
-  });
-}
-
-// src/tools/recurring.ts
-function registerRecurringTools(server, client) {
-  server.registerTool("list_recurring", {
-    description: "List all recurring transactions (subscriptions, rent, salaries).",
-    inputSchema: {}
-  }, async () => {
-    const data = await client.get("/api/recurring");
-    return { content: [{ type: "text", text: JSON.stringify(data) }] };
-  });
-  server.registerTool("add_recurring", {
-    description: "Add a recurring transaction to track subscriptions or regular income.",
-    inputSchema: {
-      name: exports_external.string(),
-      amount: exports_external.string(),
-      type: exports_external.enum(["debit", "credit"]),
-      frequency: exports_external.enum(["daily", "weekly", "monthly", "yearly"]),
-      dayOfMonth: exports_external.number().optional().describe("For monthly — day of month (1-31)"),
-      categorySlug: exports_external.string().optional(),
-      owner: exports_external.string(),
-      startDate: exports_external.string().optional().describe("YYYY-MM-DD"),
-      notes: exports_external.string().optional()
-    }
-  }, async (body) => {
-    const data = await client.post("/api/recurring", body);
-    return { content: [{ type: "text", text: JSON.stringify(data) }] };
-  });
-}
-
-// src/tools/reports.ts
-function registerReportTools(server, client) {
-  server.registerTool("generate_monthly_report", {
-    description: "Generate a detailed monthly financial report. Computes income, expenses, savings rate, top categories, and insights. Persists to DB.",
-    inputSchema: {
-      month: exports_external.number().min(1).max(12),
-      year: exports_external.number().min(2020).max(2100)
-    }
-  }, async (body) => {
-    const data = await client.post("/api/reports", body);
-    return { content: [{ type: "text", text: JSON.stringify(data) }] };
-  });
-  server.registerTool("get_reports", {
-    description: "Monthly financial reports for the last N months — income, expenses, savings rate, net worth.",
-    inputSchema: {
-      months: exports_external.number().optional().describe("Number of months (default: 6)")
-    }
-  }, async (params) => {
-    const data = await client.get("/api/reports", params.months ? { months: params.months } : undefined);
-    return { content: [{ type: "text", text: JSON.stringify(data) }] };
-  });
-}
-
-// src/tools/transactions.ts
-import { readFile } from "node:fs/promises";
-// ../parsers/src/classify.ts
-var CORPORATE_TOKENS = [
-  "PVT",
-  "PRIVATE",
-  "LIMITED",
-  "LTD",
-  "LLP",
-  "INC",
-  "CORP",
-  "ENTERPRISES",
-  "TECHNOLOGIES",
-  "SOLUTIONS",
-  "SERVICES"
-];
-var CORPORATE_REGEX = new RegExp(`\\b(${CORPORATE_TOKENS.join("|")})\\b`);
-function classifyEntity({ paymentMethod, extractedName }) {
-  if (paymentMethod === "atm")
-    return "merchant";
-  if (paymentMethod === "pos")
-    return "merchant";
-  const upper = (extractedName ?? "").toUpperCase();
-  if (upper && CORPORATE_REGEX.test(upper))
-    return "merchant";
-  if (paymentMethod === "imps")
-    return "person";
-  if (paymentMethod === "upi")
-    return "person";
-  if (paymentMethod === "neft" || paymentMethod === "rtgs")
-    return "merchant";
-  if (paymentMethod === "ach")
-    return "merchant";
-  return "unknown";
-}
-// ../parsers/src/hdfc/narration.ts
-function parseHdfcNarration(narration) {
-  const trimmed = narration.trim();
-  if (trimmed.startsWith("UPI-")) {
-    return parseUpi(trimmed);
-  }
-  if (trimmed.startsWith("NEFT CR-") || trimmed.startsWith("NEFT DR-")) {
-    return parseNeft(trimmed);
   }
-  if (trimmed.startsWith("ACH D-") || trimmed.startsWith("ACH C-")) {
-    return parseAch(trimmed);
-  }
-  if (trimmed.startsWith("FT-") || trimmed.startsWith("FT -")) {
-    return parseFt(trimmed);
-  }
-  if (trimmed.startsWith("IMPS-") || trimmed.startsWith("IMPS/")) {
-    return parseImps(trimmed);
-  }
-  if (trimmed.startsWith("ATW-") || trimmed.startsWith("ATM-") || trimmed.startsWith("ATM/")) {
-    return {
-      paymentMethod: "atm",
-      name: "ATM Withdrawal",
-      upiId: null,
-      referenceNumber: null,
-      description: trimmed
-    };
-  }
-  if (trimmed.startsWith("POS ")) {
-    return parsePos(trimmed);
-  }
-  return parseFallback(trimmed);
+  return [...buckets.entries()].sort((a2, b2) => {
+    const [pa, ya] = a2[0].split(":").map(Number);
+    const [pb, yb] = b2[0].split(":").map(Number);
+    return pa !== pb ? pa - pb : yb - ya;
+  }).map(([, row]) => row.sort((r1, r2) => r1.x - r2.x));
 }
-function parseUpi(narration) {
-  const rest = narration.slice(4);
-  const parts = rest.split("-");
-  if (parts.length < 4) {
-    return {
-      paymentMethod: "upi",
-      name: rest,
-      upiId: null,
-      referenceNumber: null,
-      description: null
-    };
-  }
-  const name = parts[0].trim();
-  const upiId = parts[1]?.trim() || null;
-  const referenceNumber = parts[3]?.trim() || null;
-  const description = parts.length > 4 ? parts.slice(4).join("-").trim() : null;
+function buildTransaction2(bucket) {
+  const date4 = parseSbiDate(bucket.dateStr);
+  if (!date4)
+    return null;
+  const terminalIdx = bucket.narrationParts.findIndex((p2) => /^\d+\s+AT\s+\d+/.test(p2.trim()));
+  const parts = terminalIdx >= 0 ? bucket.narrationParts.slice(0, terminalIdx + 1) : bucket.narrationParts;
+  const narration = parts.join(" ").replace(/\s{2,}/g, " ").trim();
+  if (!narration)
+    return null;
+  const debit = parseAmount4(bucket.debitStr);
+  const credit = parseAmount4(bucket.creditStr);
+  if (debit === 0 && credit === 0)
+    return null;
+  const amount = debit > 0 ? debit : credit;
+  const type = debit > 0 ? "debit" : "credit";
+  const valueDate = bucket.valueDateStr ? parseSbiDate(bucket.valueDateStr) : null;
+  const closingBalance = parseAmount4(bucket.balanceStr) || null;
+  const parsed = parseSbiNarration(narration);
+  const upiRefMatch = narration.match(/UPI\/(?:DR|CR)\/(\d+)\//i);
+  const referenceNumber = upiRefMatch ? upiRefMatch[1] : null;
   return {
-    paymentMethod: "upi",
-    name: cleanName(name),
-    upiId,
+    date: date4,
+    description: narration,
+    amount,
+    type,
     referenceNumber,
-    description: description || null
+    valueDate,
+    closingBalance,
+    paymentMethod: parsed.paymentMethod,
+    extractedName: parsed.name,
+    upiId: parsed.upiId,
+    sourceCategory: null
   };
 }
-function parseNeft(narration) {
-  const isCredit = narration.startsWith("NEFT CR-");
-  const rest = narration.slice(isCredit ? 8 : 8);
-  const parts = rest.split("-");
-  if (parts.length < 2) {
-    return {
-      paymentMethod: "neft",
-      name: rest,
-      upiId: null,
-      referenceNumber: null,
-      description: null
-    };
-  }
-  const companyName = parts[1]?.trim() || parts[0]?.trim() || rest;
-  const referenceNumber = parts[parts.length - 1]?.trim() || null;
-  return {
-    paymentMethod: "neft",
-    name: cleanName(companyName),
-    upiId: null,
-    referenceNumber,
-    description: null
-  };
+function parseSbiDate(raw) {
+  if (!raw)
+    return null;
+  const match = raw.trim().match(/^(\d{2})[/-](\d{2})[/-](\d{4})$/);
+  if (!match)
+    return null;
+  return `${match[3]}-${match[2]}-${match[1]}`;
 }
-function parseAch(narration) {
-  const rest = narration.slice(7).trim();
-  const parts = rest.split("-");
-  const name = parts[0]?.trim() || rest;
-  const referenceNumber = parts.length > 1 ? parts[parts.length - 1]?.trim() : null;
-  return {
-    paymentMethod: "ach",
-    name: cleanName(name),
-    upiId: null,
-    referenceNumber,
-    description: null
-  };
+function parseAmount4(raw) {
+  if (!raw)
+    return 0;
+  const cleaned = raw.replace(/,/g, "").trim();
+  const num = parseFloat(cleaned);
+  return Number.isNaN(num) ? 0 : Math.abs(num);
 }
-function parseFt(narration) {
-  const rest = narration.replace(/^FT[\s-]+/, "").trim();
-  const spaceDashParts = rest.split(" - ");
-  if (spaceDashParts.length >= 2) {
-    const namePart = spaceDashParts.find((p2, i2) => i2 > 0 && p2.trim().length > 0);
-    return {
-      paymentMethod: "fund_transfer",
-      name: cleanName(namePart?.trim() || rest),
-      upiId: null,
-      referenceNumber: spaceDashParts[0]?.split("-")[0]?.trim() || null,
-      description: null
-    };
-  }
+// src/lib/txn-rows.ts
+function toTxnRow(r2) {
   return {
-    paymentMethod: "fund_transfer",
-    name: cleanName(rest),
-    upiId: null,
-    referenceNumber: null,
-    description: null
+    id: String(r2.id),
+    date: String(r2.date),
+    amount: Number(r2.amount),
+    type: r2.type === "credit" ? "credit" : "debit",
+    description: String(r2.description ?? ""),
+    merchantId: r2.merchantId ?? null,
+    personId: r2.personId ?? null,
+    categoryId: r2.categoryId ?? null,
+    isTransfer: !!r2.isTransfer,
+    isIgnored: !!r2.isIgnored,
+    isDuplicate: !!r2.isDuplicate
   };
 }
-function parseImps(narration) {
-  const rest = narration.replace(/^IMPS[-/]/, "").trim();
-  const parts = rest.split("-");
-  const referenceNumber = parts[0]?.trim() || null;
-  const name = parts.length > 1 ? parts[1]?.trim() : rest;
-  return {
-    paymentMethod: "imps",
-    name: cleanName(name || rest),
-    upiId: null,
-    referenceNumber,
-    description: null
-  };
+async function fetchAllRows(client, crypto3, params = {}, maxPages = 100) {
+  return (await fetchAllRowsPaged(client, crypto3, params, maxPages)).rows;
 }
-function parsePos(narration) {
-  const rest = narration.slice(4).trim();
-  const cleaned = rest.replace(/^[0-9X]{4,}\s*/, "").trim();
+async function fetchAllRowsPaged(client, crypto3, params = {}, maxPages = 100) {
+  const out = [];
+  let cursor;
+  let truncated = false;
+  for (let page = 0;page < maxPages; page++) {
+    const q2 = { ...params, limit: 200, view: "match" };
+    if (cursor)
+      q2.cursor = cursor;
+    const res = await client.get("/api/transactions", q2);
+    const batch = res.data ?? [];
+    if (crypto3)
+      await decryptTransactionFields(batch, crypto3.key);
+    out.push(...batch.map(toTxnRow));
+    if (!res.hasMore || !res.nextCursor || batch.length === 0 || res.nextCursor === cursor)
+      break;
+    cursor = res.nextCursor;
+    if (page === maxPages - 1)
+      truncated = true;
+  }
+  return { rows: out, truncated };
+}
+var MAX_DESC = 70;
+function toLeanRow(r2, personNames) {
+  const merchant = r2.merchant;
+  const category = r2.category;
+  const merchantName = r2.merchantName ?? merchant?.cleanName;
+  const categorySlug = typeof category === "string" ? category : category?.slug;
+  const personId = r2.personId;
+  const person = personId ? personNames.get(personId) ?? null : null;
+  let flags = r2.flags;
+  if (!flags) {
+    flags = [];
+    if (r2.isTransfer)
+      flags.push("transfer");
+    if (r2.isIgnored)
+      flags.push("ignored");
+    if (r2.isDuplicate)
+      flags.push("duplicate");
+  }
+  const desc = String(r2.description ?? "");
   return {
-    paymentMethod: "pos",
-    name: cleanName(cleaned || rest),
-    upiId: null,
-    referenceNumber: null,
-    description: null
+    id: r2.id,
+    date: r2.date,
+    amt: Number(r2.amount),
+    t: r2.type === "credit" ? "cr" : "dr",
+    desc: desc.length > MAX_DESC ? `${desc.slice(0, MAX_DESC)}…` : desc,
+    ...categorySlug ? { cat: categorySlug } : {},
+    ...merchantName ? { merchant: merchantName } : {},
+    ...person ? { person } : {},
+    ...flags.length ? { flags } : {}
   };
 }
-function parseFallback(narration) {
+
+// src/lib/person-backfill.ts
+function normalizePersonName(name) {
+  return name.toLowerCase().trim().replace(/\s+/g, " ");
+}
+async function loadDecryptedPersons(client, crypto3) {
+  const res = await client.get("/api/persons");
+  const persons = [];
+  for (const p2 of res.data ?? []) {
+    let name = p2.name ?? "";
+    if (crypto3 && p2.cipher) {
+      try {
+        name = (await decryptPersonCipher(p2.cipher, crypto3.key)).name;
+      } catch {}
+    }
+    if (name)
+      persons.push({ id: p2.id, name });
+  }
+  return persons;
+}
+function resolvePersonByName(persons, query) {
+  const q2 = normalizePersonName(query);
+  if (!q2)
+    return null;
+  const exact = persons.filter((p2) => normalizePersonName(p2.name) === q2);
+  if (exact.length === 1)
+    return { personId: exact[0].id };
+  if (exact.length > 1)
+    return { candidates: exact.map((p2) => p2.name) };
+  const partial2 = persons.filter((p2) => normalizePersonName(p2.name).includes(q2));
+  if (partial2.length === 1)
+    return { personId: partial2[0].id };
+  if (partial2.length > 1)
+    return { candidates: partial2.map((p2) => p2.name) };
+  return null;
+}
+function parseNarration(description) {
+  const hdfc = parseHdfcNarration(description);
+  if (hdfc.name && hdfc.paymentMethod)
+    return { name: hdfc.name, upiId: hdfc.upiId, paymentMethod: hdfc.paymentMethod };
+  const sbi = parseSbiNarration(description);
+  if (sbi.name && sbi.paymentMethod)
+    return { name: sbi.name, upiId: sbi.upiId, paymentMethod: sbi.paymentMethod };
   return {
-    paymentMethod: "other",
-    name: cleanName(narration),
-    upiId: null,
-    referenceNumber: null,
-    description: null
+    name: hdfc.name || sbi.name,
+    upiId: hdfc.upiId ?? sbi.upiId,
+    paymentMethod: hdfc.paymentMethod ?? sbi.paymentMethod
   };
 }
-function cleanName(raw) {
-  return raw.replace(/\s+(PRIVATE|PVT\.?)\s*\w*/gi, "").replace(/\s+(LIMITED|LTD\.?)(\s|$)/gi, " ").replace(/[\s.-]+$/, "").replace(/\s{2,}/g, " ").trim();
+function isPersonLikeNarration(description) {
+  const { name, paymentMethod } = parseNarration(description);
+  return classifyEntity({ paymentMethod, extractedName: name }) !== "merchant";
 }
-
-// ../parsers/src/sbi/savings.ts
-function parseSbiNarration(narration) {
-  const upper = narration.toUpperCase();
-  const upiMatch = narration.match(/UPI\/(?:DR|CR)\/(\d+)\/([^/]+)\/([A-Z]{2,6})\/([^/\s]+)/i);
-  if (upiMatch) {
-    const name = upiMatch[2].trim();
-    const upiId = upiMatch[4].trim();
-    return {
-      paymentMethod: "upi",
-      name: name || null,
-      upiId: upiId || null
-    };
-  }
-  if (upper.includes("NEFT")) {
-    const neftMatch = narration.match(/NEFT[-/][\w]+[-/]([\w\s]+?)(?:[-/]|$)/i);
-    return {
-      paymentMethod: "neft",
-      name: neftMatch ? neftMatch[1].trim() : null,
-      upiId: null
+async function backfillPersons(client, crypto3, opts = {}) {
+  const existing = await loadDecryptedPersons(client, crypto3);
+  const personIdByNorm = new Map;
+  for (const p2 of existing)
+    personIdByNorm.set(normalizePersonName(p2.name), p2.id);
+  const { rows, truncated } = await fetchAllRowsPaged(client, crypto3, { unresolved: "true" });
+  const candidates = rows.filter((r2) => !r2.merchantId && !r2.personId && !r2.isTransfer && !r2.isIgnored);
+  const groups = new Map;
+  for (const t2 of candidates) {
+    const { name, upiId, paymentMethod } = parseNarration(t2.description);
+    if (!name)
+      continue;
+    if (classifyEntity({ paymentMethod, extractedName: name }) !== "person")
+      continue;
+    const norm = normalizePersonName(name);
+    if (!norm)
+      continue;
+    const g3 = groups.get(norm) ?? {
+      displayName: name.trim(),
+      upiHandles: new Set,
+      txnIds: []
     };
+    if (upiId)
+      g3.upiHandles.add(upiId);
+    g3.txnIds.push(t2.id);
+    groups.set(norm, g3);
   }
-  if (upper.includes("RTGS")) {
-    return { paymentMethod: "rtgs", name: null, upiId: null };
-  }
-  if (upper.includes("IMPS")) {
-    return { paymentMethod: "imps", name: null, upiId: null };
+  const plan = [];
+  const newGroups = [];
+  let reused = 0;
+  for (const [norm, g3] of groups) {
+    const upiHandles = [...g3.upiHandles];
+    const isReuse = personIdByNorm.has(norm);
+    plan.push({
+      name: g3.displayName,
+      normalized: norm,
+      txnCount: g3.txnIds.length,
+      upiHandles,
+      action: isReuse ? "reuse" : "create"
+    });
+    if (isReuse)
+      reused++;
+    else
+      newGroups.push({ norm, displayName: g3.displayName, upiHandles });
   }
-  if (upper.includes("ATM") || upper.includes("WDL ATM")) {
-    return { paymentMethod: "atm", name: null, upiId: null };
+  if (!opts.dryRun && newGroups.length > 0) {
+    const bodies = await Promise.all(newGroups.map(async ({ displayName, upiHandles }) => {
+      const fields = {
+        name: displayName,
+        upiHandles,
+        phoneNumbers: [],
+        relationship: null,
+        notes: null
+      };
+      return crypto3 ? await encryptPersonCipher(fields, crypto3.key) : { name: displayName, upiHandles, phoneNumbers: [], relationship: null, notes: null };
+    }));
+    const res = await client.post("/api/persons/bulk", {
+      persons: bodies
+    });
+    res.data.forEach((p2, i2) => {
+      personIdByNorm.set(newGroups[i2].norm, p2.id);
+    });
   }
-  if (upper.includes("POS") || upper.includes("PURCHASE")) {
-    return { paymentMethod: "pos", name: null, upiId: null };
+  const created = opts.dryRun ? 0 : newGroups.length;
+  const links = [];
+  if (!opts.dryRun) {
+    for (const [norm, g3] of groups) {
+      const personId = personIdByNorm.get(norm);
+      if (!personId)
+        continue;
+      for (const txnId of g3.txnIds)
+        links.push({ transactionId: txnId, personId });
+    }
   }
-  if (upper.includes("INT.COLL") || upper.includes("INTEREST")) {
-    return { paymentMethod: "other", name: "Interest", upiId: null };
+  if (!opts.dryRun && links.length > 0) {
+    const CHUNK = 25;
+    for (let i2 = 0;i2 < links.length; i2 += CHUNK) {
+      await client.post("/api/transactions/bulk-link-entity", { links: links.slice(i2, i2 + CHUNK) });
+    }
   }
-  return { paymentMethod: null, name: null, upiId: null };
+  return {
+    dryRun: !!opts.dryRun,
+    truncated,
+    candidatesScanned: candidates.length,
+    created,
+    reused,
+    linked: links.length,
+    plan
+  };
 }
-// src/lib/person-backfill.ts
-function normalizePersonName(name) {
-  return name.toLowerCase().trim().replace(/\s+/g, " ");
+
+// src/lib/categorize-groups.ts
+var NOISE2 = new Set([
+  "upi",
+  "pos",
+  "imps",
+  "neft",
+  "rtgs",
+  "ach",
+  "nach",
+  "ecs",
+  "txn",
+  "transaction",
+  "payment",
+  "paid",
+  "pay",
+  "to",
+  "from",
+  "ref",
+  "refno",
+  "debit",
+  "credit",
+  "card",
+  "mob",
+  "mobile",
+  "bank",
+  "transfer",
+  "trf",
+  "by",
+  "for",
+  "the",
+  "via",
+  "ecom",
+  "purchase",
+  "online",
+  "inr",
+  "rs",
+  "towards",
+  "ibl",
+  "ybl",
+  "oksbi",
+  "okhdfcbank",
+  "okicici",
+  "okaxis",
+  "axl",
+  "apl",
+  "paytm",
+  "icici",
+  "hdfc",
+  "sbi",
+  "axis",
+  "utib",
+  "sbin",
+  "ifsc",
+  "vpa",
+  "bill",
+  "cas",
+  "dr",
+  "cr"
+]);
+var GOOD_TOKEN = /^[a-z][a-z&']{2,}$/;
+var MAX_RUN = 3;
+function descriptionPattern(description) {
+  const tokens = normaliseName(description).split(" ").filter(Boolean);
+  const run = [];
+  for (const tok of tokens) {
+    const good = GOOD_TOKEN.test(tok) && !NOISE2.has(tok);
+    if (!good) {
+      if (run.length)
+        break;
+      continue;
+    }
+    if (run.includes(tok))
+      break;
+    run.push(tok);
+    if (run.length === MAX_RUN)
+      break;
+  }
+  return run.join(" ");
+}
+var UNPARSED = "(unparsed)";
+function groupRows(rows) {
+  const map2 = new Map;
+  for (const r2 of rows) {
+    const pattern = descriptionPattern(r2.description) || UNPARSED;
+    const key = `${pattern}|${r2.type}`;
+    const g3 = map2.get(key) ?? { pattern, type: r2.type, rows: [], total: 0 };
+    g3.rows.push(r2);
+    g3.total += r2.amount;
+    map2.set(key, g3);
+  }
+  return [...map2.values()].sort((a2, b2) => b2.total - a2.total);
+}
+function isCategorizable(r2) {
+  return !r2.categoryId && !r2.isTransfer && !r2.isIgnored && !r2.isDuplicate;
+}
+async function fetchUncategorized(client, crypto3, range2 = {}) {
+  const params = { uncategorized: "true" };
+  if (range2.startDate)
+    params.startDate = range2.startDate;
+  if (range2.endDate)
+    params.endDate = range2.endDate;
+  return (await fetchAllRows(client, crypto3, params)).filter(isCategorizable);
+}
+var MERCHANT_CREATE_CONCURRENCY = 5;
+var titleCase = (s2) => s2.replace(/\b[a-z]/g, (c2) => c2.toUpperCase());
+async function applyGroupAssignments(client, crypto3, assignments, opts = {}) {
+  const catIndex = await loadCategoryIndex(client);
+  const resolved = assignments.map((a2) => ({ a: a2, cat: requireCategory(catIndex, a2.categorySlug) }));
+  const groups = groupRows(await fetchUncategorized(client, crypto3, opts));
+  const result = { applied: [], notFound: [], rulesSaved: 0, unlearnable: [] };
+  const plan = [];
+  const claimed = new Set;
+  for (const { a: a2, cat } of resolved) {
+    const hits = groups.filter((g3) => g3.pattern === a2.pattern && (!a2.type || g3.type === a2.type) && !claimed.has(g3));
+    if (hits.length === 0) {
+      result.notFound.push(a2.pattern);
+      continue;
+    }
+    for (const g3 of hits) {
+      claimed.add(g3);
+      plan.push({ group: g3, categoryId: cat.id, slug: cat.slug, learn: a2.learn !== false });
+    }
+  }
+  if (opts.dryRun) {
+    result.applied = plan.map((p2) => ({
+      pattern: p2.group.pattern,
+      type: p2.group.type,
+      rows: p2.group.rows.length,
+      category: p2.slug
+    }));
+    return result;
+  }
+  if (plan.length === 0)
+    return result;
+  const learnable = plan.filter((p2) => p2.learn && p2.group.pattern !== UNPARSED);
+  const merchantByRawId = new Map;
+  if (learnable.length > 0) {
+    const ms = await client.get("/api/merchants");
+    for (const m2 of ms.data ?? [])
+      if (m2.rawId && m2.householdId)
+        merchantByRawId.set(m2.rawId, m2.id);
+  }
+  const { bag, version: version2 } = await loadBag(client);
+  const now = new Date().toISOString();
+  const links = [];
+  const direct = [];
+  const taught = new Map;
+  const learnPlans = [];
+  const directPlans = [];
+  for (const p2 of plan) {
+    const { group, learn } = p2;
+    if (!learn || group.pattern === UNPARSED) {
+      directPlans.push({ p: p2, reason: learn ? UNPARSED : undefined });
+    } else if (crypto3 && group.rows.some((r2) => isPersonLikeNarration(r2.description))) {
+      directPlans.push({ p: p2, reason: `${group.pattern} (private mode: person-like)` });
+    } else if (taught.has(group.pattern) && taught.get(group.pattern) !== p2.categoryId) {
+      directPlans.push({ p: p2, reason: `${group.pattern} (conflicting category for same pattern)` });
+    } else {
+      taught.set(group.pattern, p2.categoryId);
+      learnPlans.push(p2);
+    }
+  }
+  for (const { p: p2, reason } of directPlans) {
+    if (reason)
+      result.unlearnable.push(reason);
+    direct.push({ ids: p2.group.rows.map((r2) => r2.id), categoryId: p2.categoryId });
+    result.applied.push({
+      pattern: p2.group.pattern,
+      type: p2.group.type,
+      rows: p2.group.rows.length,
+      category: p2.slug
+    });
+  }
+  const toCreate = new Map;
+  for (const p2 of learnPlans) {
+    const rawId = `pattern:${p2.group.pattern}`;
+    if (!merchantByRawId.has(rawId) && !toCreate.has(rawId))
+      toCreate.set(rawId, p2);
+  }
+  await mapLimit([...toCreate], MERCHANT_CREATE_CONCURRENCY, async ([rawId, p2]) => {
+    const created = await client.post("/api/merchants", {
+      rawId,
+      cleanName: titleCase(p2.group.pattern),
+      categoryId: p2.categoryId
+    });
+    merchantByRawId.set(rawId, created.data.id);
+  });
+  for (const { group, categoryId, slug } of learnPlans) {
+    result.applied.push({
+      pattern: group.pattern,
+      type: group.type,
+      rows: group.rows.length,
+      category: slug
+    });
+    const merchantId = merchantByRawId.get(`pattern:${group.pattern}`);
+    if (!bag.merchantAliases.some((al) => al.pattern === group.pattern)) {
+      bag.merchantAliases.push({ pattern: group.pattern, merchantId, createdAt: now });
+    }
+    bag.merchantRules[merchantId] = { categoryId, lastUserCategoryAt: now };
+    result.rulesSaved += 1;
+    const withPerson = group.rows.filter((r2) => r2.personId);
+    if (withPerson.length)
+      direct.push({ ids: withPerson.map((r2) => r2.id), categoryId });
+    for (const r2 of group.rows) {
+      if (!r2.personId)
+        links.push({ transactionId: r2.id, merchantId, categoryId });
+    }
+  }
+  if (result.rulesSaved > 0)
+    await saveBag(client, bag, version2);
+  await postLinks(client, links);
+  for (const { ids, categoryId } of direct) {
+    const categoryType = catIndex.byId.get(categoryId)?.type;
+    for (let i2 = 0;i2 < ids.length; i2 += 200) {
+      await client.patch("/api/transactions/bulk", {
+        ids: ids.slice(i2, i2 + 200),
+        categoryId,
+        ...categoryType ? { categoryType } : {}
+      });
+    }
+  }
+  return result;
+}
+
+// src/lib/jev-categorize.ts
+var JEV_MODEL = "jev-1.13.0";
+var DEFAULT_MIN_CONFIDENCE = 0.95;
+var TIMEOUT_MS = 8000;
+var CONCURRENCY = 8;
+var MIN_LEARN_PATTERN_LEN = 5;
+function assertPrivateModeAllowed(crypto3, env2 = process.env) {
+  if (crypto3 && env2.JEV_ALLOW_PRIVATE_MODE !== "1") {
+    throw new Error("Jev categorization is disabled in private mode: it would send transaction text to a third party. " + "To opt in for your own account, set JEV_ALLOW_PRIVATE_MODE=1 in the MCP's environment. " + "Otherwise use get_uncategorized_groups + categorize_groups.");
+  }
+}
+function assertJevAllowed(crypto3, env2 = process.env) {
+  assertPrivateModeAllowed(crypto3, env2);
+  const key = env2.JEV_API_KEY;
+  if (!key)
+    throw new Error("JEV_API_KEY is not set — Jev categorization is off.");
+  return key;
+}
+function makeJevClassifier(apiKey) {
+  const client = new TypeSafeClient({ apiKey, timeout: TIMEOUT_MS });
+  return async (state, options) => {
+    const { answers } = await client.systemOne({
+      model: JEV_MODEL,
+      state,
+      questions: {
+        category: choice("Which spending category best fits this bank transaction?", options)
+      }
+    });
+    return { choice: answers.category.choice, confidence: answers.category.confidence };
+  };
+}
+var UNSURE = "unsure";
+function optionsFor(type, index) {
+  const allowed = type === "credit" ? new Set(["income", "transfer"]) : new Set(["needs", "wants", "investments", "transfer"]);
+  const out = {};
+  for (const [slug, c2] of index.bySlug) {
+    if (index.parents.has(slug) || !allowed.has(c2.type))
+      continue;
+    out[slug] = `${c2.type}: ${slug.replace(/_/g, " ")}`;
+  }
+  out[UNSURE] = "unclear, or a payment to an individual person";
+  return out;
+}
+function groupState(type, sample) {
+  const dir = type === "credit" ? "Money received" : "Money paid out";
+  return `${dir}. Bank narration: "${sample.slice(0, 80)}"`;
+}
+async function jevCategorize(client, crypto3, classify, opts = {}) {
+  assertPrivateModeAllowed(crypto3, opts.env);
+  const min = opts.minConfidence ?? DEFAULT_MIN_CONFIDENCE;
+  const index = await loadCategoryIndex(client);
+  const rows = await fetchUncategorized(client, crypto3, opts);
+  const groups = groupRows(rows);
+  const unparsed = groups.filter((g3) => g3.pattern === UNPARSED).length;
+  const candidates = groups.filter((g3) => g3.pattern !== UNPARSED);
+  let errors4 = 0;
+  const suggestions = await mapLimit(candidates, CONCURRENCY, async (g3) => {
+    try {
+      const options = optionsFor(g3.type, index);
+      const sample = g3.rows[0].description;
+      const text = crypto3 ? g3.pattern : sample;
+      const r2 = await classify(groupState(g3.type, text), options);
+      return r2.choice in options ? { g: g3, ...r2 } : null;
+    } catch {
+      errors4 += 1;
+      return null;
+    }
+  });
+  const accepted = [];
+  const review = [];
+  for (const s2 of suggestions) {
+    if (!s2)
+      continue;
+    const isTransfer = index.bySlug.get(s2.choice)?.type === "transfer";
+    if (s2.choice !== UNSURE && !isTransfer && s2.confidence >= min) {
+      accepted.push({
+        pattern: s2.g.pattern,
+        type: s2.g.type,
+        categorySlug: s2.choice,
+        learn: s2.g.pattern.length >= MIN_LEARN_PATTERN_LEN,
+        confidence: s2.confidence
+      });
+    } else {
+      review.push({
+        pattern: s2.g.pattern,
+        type: s2.g.type === "credit" ? "cr" : "dr",
+        best: s2.choice,
+        confidence: Math.round(s2.confidence * 100) / 100,
+        total: Math.round(s2.g.total)
+      });
+    }
+  }
+  review.sort((a2, b2) => b2.total - a2.total);
+  const applied = await applyGroupAssignments(client, crypto3, accepted.map(({ confidence: _c, ...a2 }) => a2), { dryRun: opts.dryRun, startDate: opts.startDate, endDate: opts.endDate });
+  const conf = new Map(accepted.map((a2) => [`${a2.pattern}|${a2.type}`, a2.confidence]));
+  return {
+    dryRun: !!opts.dryRun,
+    applied: applied.applied.map((a2) => ({
+      pattern: a2.pattern,
+      category: a2.category,
+      confidence: Math.round((conf.get(`${a2.pattern}|${a2.type}`) ?? 0) * 100) / 100,
+      rows: a2.rows
+    })),
+    review: review.slice(0, 30),
+    skipped: { unparsed, errors: errors4 },
+    rulesSaved: applied.rulesSaved
+  };
+}
+
+// src/tools/jev.ts
+function registerJevTools(server, client, crypto3) {
+  server.registerTool("auto_categorize_jev", {
+    description: "Auto-categorize uncategorized transactions with Jev (TypeSafe's classifier) — zero LLM tokens, ~ms per group. " + "OPT-IN: needs JEV_API_KEY. Refuses in private mode (it would send transaction text to a third party) unless the owner sets JEV_ALLOW_PRIVATE_MODE=1; in private mode only the sanitized merchant pattern is sent. " + `Groups by merchant pattern; groups at/above \`minConfidence\` (default ${DEFAULT_MIN_CONFIDENCE}) are categorized and a reusable rule is saved; ` + "the rest come back in `review` (top 30 by ₹) for you to decide with `categorize_groups`. Use dryRun to preview.",
+    inputSchema: {
+      startDate: exports_external.string().optional().describe("YYYY-MM-DD"),
+      endDate: exports_external.string().optional().describe("YYYY-MM-DD"),
+      minConfidence: exports_external.number().min(0.5).max(1).optional().describe(`Apply at/above this confidence (default ${DEFAULT_MIN_CONFIDENCE})`),
+      dryRun: exports_external.boolean().optional()
+    }
+  }, async ({ startDate, endDate, minConfidence, dryRun }) => {
+    const key = assertJevAllowed(crypto3);
+    const result = await jevCategorize(client, crypto3, makeJevClassifier(key), {
+      startDate,
+      endDate,
+      minConfidence,
+      dryRun
+    });
+    return { content: [{ type: "text", text: JSON.stringify(result) }] };
+  });
+}
+
+// src/tools/merchants.ts
+async function categorySlugToId(client) {
+  const res = await client.get("/api/categories");
+  const map2 = new Map;
+  for (const root of res.data ?? []) {
+    if (root.slug)
+      map2.set(root.slug, root.id);
+    for (const child of root.children ?? []) {
+      if (child.slug)
+        map2.set(child.slug, child.id);
+    }
+  }
+  return map2;
+}
+function registerMerchantTools(server, client, crypto3) {
+  server.registerTool("upsert_merchant", {
+    description: "Create or update a merchant in the dictionary. Omit `id` to add a new merchant (future transactions from it are auto-categorised); pass `id` to update an existing merchant's name, category, or flags.",
+    inputSchema: {
+      id: exports_external.string().optional().describe("Merchant UUID — pass to update, omit to create"),
+      rawId: exports_external.string().optional().describe("Raw identifier — UPI ID or normalised name (required when creating)"),
+      cleanName: exports_external.string().optional().describe('Human-friendly name (e.g. "DMart")'),
+      categorySlug: exports_external.string().optional().describe("Category slug, e.g. 'food_delivery'"),
+      isPerson: exports_external.boolean().optional(),
+      isRecurring: exports_external.boolean().optional(),
+      notes: exports_external.string().optional()
+    }
+  }, async ({ id, categorySlug, ...rest }) => {
+    const payload = { ...rest };
+    if (categorySlug) {
+      const slugMap = await categorySlugToId(client);
+      const categoryId = slugMap.get(categorySlug);
+      if (!categoryId) {
+        throw new Error(`Unknown categorySlug "${categorySlug}". Use list_categories to see valid slugs.`);
+      }
+      payload.categoryId = categoryId;
+    }
+    const data = id ? await client.patch(`/api/merchants/${id}`, payload) : await client.post("/api/merchants", payload);
+    return { content: [{ type: "text", text: JSON.stringify(data) }] };
+  });
+  server.registerTool("list_merchants", {
+    description: "List merchants in the dictionary with their categories and transaction counts. Pass `rawId` to look up a single merchant by its raw ID (UPI ID or normalised name) instead of listing all (matched client-side).",
+    inputSchema: {
+      rawId: exports_external.string().optional().describe("Raw identifier to look up a single merchant; omit to list all")
+    }
+  }, async ({ rawId }) => {
+    const data = await client.get("/api/merchants");
+    if (crypto3 && data.data)
+      await decryptMerchantFields(data.data, crypto3.key);
+    if (!rawId)
+      return { content: [{ type: "text", text: JSON.stringify(data) }] };
+    const needle = rawId.toLowerCase();
+    const merchants = (data.data ?? []).filter((m2) => String(m2.rawId ?? "").toLowerCase() === needle || String(m2.cleanName ?? "").toLowerCase().includes(needle));
+    return {
+      content: [{ type: "text", text: JSON.stringify({ ...data, data: merchants }) }]
+    };
+  });
+  server.registerTool("merge_merchants", {
+    description: "Merge duplicate merchants into one primary merchant. Transactions of the duplicates are re-pointed to the primary (unlike delete_merchant, which unlinks them). Duplicates are removed.",
+    inputSchema: {
+      primaryId: exports_external.string().describe("UUID of the merchant to keep"),
+      duplicateIds: exports_external.array(exports_external.string()).min(1).describe("UUIDs of duplicates to fold into it")
+    }
+  }, async (body) => {
+    const data = await client.post("/api/merchants/merge", body);
+    return { content: [{ type: "text", text: JSON.stringify(data) }] };
+  });
+  server.registerTool("delete_merchant", {
+    description: "Delete merchant(s) from the dictionary. Provide `id` for a single merchant or `ids` for several. Transactions referencing a deleted merchant have their merchantId cleared. PERMANENT.",
+    inputSchema: {
+      id: exports_external.string().optional().describe("Single merchant UUID"),
+      ids: exports_external.array(exports_external.string()).min(1).optional().describe("Multiple merchant UUIDs (bulk delete)")
+    }
+  }, async ({ id, ids }) => {
+    if (!id && (!ids || ids.length === 0)) {
+      throw new Error("Provide either id or ids");
+    }
+    const data = ids ? await client.post("/api/merchants/bulk-delete", { ids }) : await client.delete(`/api/merchants/${id}`);
+    return { content: [{ type: "text", text: JSON.stringify(data) }] };
+  });
+}
+
+// src/tools/net-worth.ts
+function registerNetWorthTools(server, client) {
+  server.registerTool("get_net_worth", {
+    description: "Current net worth snapshot and history (up to 12 months). Includes liquid cash, investments, emergency fund, liabilities.",
+    inputSchema: {}
+  }, async () => {
+    const data = await client.get("/api/net-worth");
+    return { content: [{ type: "text", text: JSON.stringify(data) }] };
+  });
+  server.registerTool("update_net_worth", {
+    description: "Log a net worth snapshot for a specific month. Upserts — safe to call multiple times for the same month. mode=manual (default) records the provided (omitted ones default to 0) liquidCash/investments/emergencyFund/liabilities/breakdown values. mode=auto ignores those and auto-calculates net worth from DB (investments + FDs + accounts) — use it when the data is already in the system.",
+    inputSchema: {
+      mode: exports_external.enum(["manual", "auto"]).default("manual"),
+      month: exports_external.number().min(1).max(12),
+      year: exports_external.number().min(2020).max(2100),
+      liquidCash: exports_external.string().optional().describe('manual mode: defaults to "0"'),
+      investments: exports_external.string().optional().describe('manual mode: defaults to "0"'),
+      emergencyFund: exports_external.string().optional().describe('manual mode: defaults to "0"'),
+      liabilities: exports_external.string().optional(),
+      breakdown: exports_external.record(exports_external.string(), exports_external.string()).optional()
+    }
+  }, async ({ mode, ...body }) => {
+    let data;
+    if (mode === "auto") {
+      data = await client.post("/api/net-worth/auto", { month: body.month, year: body.year });
+    } else {
+      const liquidCash = parseFloat(body.liquidCash ?? "0");
+      const investments = parseFloat(body.investments ?? "0");
+      const emergencyFund = parseFloat(body.emergencyFund ?? "0");
+      const liabilities = parseFloat(body.liabilities ?? "0");
+      const totalNetWorth = (liquidCash + investments + emergencyFund - liabilities).toFixed(2);
+      data = await client.post("/api/net-worth", {
+        ...body,
+        liquidCash: body.liquidCash ?? "0",
+        investments: body.investments ?? "0",
+        emergencyFund: body.emergencyFund ?? "0",
+        totalNetWorth
+      });
+    }
+    return { content: [{ type: "text", text: JSON.stringify(data) }] };
+  });
+}
+
+// src/tools/persons.ts
+function registerPersonTools(server, client, crypto3) {
+  server.registerTool("upsert_person", {
+    description: "Create or update a person (UPI counterparty / individual) in this household's encrypted directory. Omit `id` to add a new person; pass `id` to update any combination of an existing person's fields.",
+    inputSchema: {
+      id: exports_external.string().optional().describe("Person UUID — pass to update, omit to create"),
+      name: exports_external.string().optional().describe('Display name (e.g. "Priya") — required when creating'),
+      upiHandles: exports_external.array(exports_external.string()).optional().describe("UPI ids the person uses"),
+      phoneNumbers: exports_external.array(exports_external.string()).optional(),
+      relationship: exports_external.string().optional().describe('e.g. "sister", "friend", "landlord"'),
+      notes: exports_external.string().optional()
+    }
+  }, async ({ id, ...updates }) => {
+    if (crypto3) {
+      if (id) {
+        const existing = await client.get(`/api/persons/${id}`);
+        const personData = existing.data;
+        let current;
+        if (personData.cipher) {
+          current = await decryptPersonCipher(personData.cipher, crypto3.key);
+        } else {
+          current = {
+            name: personData.name,
+            upiHandles: personData.upiHandles,
+            phoneNumbers: personData.phoneNumbers,
+            relationship: personData.relationship,
+            notes: personData.notes
+          };
+        }
+        const merged = {
+          name: updates.name ?? current.name,
+          upiHandles: updates.upiHandles ?? current.upiHandles,
+          phoneNumbers: updates.phoneNumbers ?? current.phoneNumbers,
+          relationship: updates.relationship ?? current.relationship ?? null,
+          notes: updates.notes ?? current.notes ?? null
+        };
+        const payload2 = await encryptPersonCipher(merged, crypto3.key);
+        const data3 = await client.patch(`/api/persons/${id}`, payload2);
+        return { content: [{ type: "text", text: JSON.stringify(data3) }] };
+      }
+      if (!updates.name)
+        throw new Error("name is required when creating a person");
+      const fields = {
+        name: updates.name,
+        upiHandles: updates.upiHandles ?? [],
+        phoneNumbers: updates.phoneNumbers ?? [],
+        relationship: updates.relationship ?? null,
+        notes: updates.notes ?? null
+      };
+      const payload = await encryptPersonCipher(fields, crypto3.key);
+      const data2 = await client.post("/api/persons", payload);
+      return { content: [{ type: "text", text: JSON.stringify(data2) }] };
+    }
+    const data = id ? await client.patch(`/api/persons/${id}`, updates) : await client.post("/api/persons", updates);
+    return { content: [{ type: "text", text: JSON.stringify(data) }] };
+  });
+  server.registerTool("list_persons", {
+    description: "List all persons in the current household. Pass `id` to get a single person by id instead of listing all.",
+    inputSchema: {
+      id: exports_external.string().optional().describe("Person UUID to fetch a single person; omit to list all")
+    }
+  }, async ({ id }) => {
+    if (id) {
+      const data2 = await client.get(`/api/persons/${id}`);
+      if (crypto3 && data2.data.cipher) {
+        const fields = await decryptPersonCipher(data2.data.cipher, crypto3.key);
+        Object.assign(data2.data, fields, { cipher: null });
+      }
+      return { content: [{ type: "text", text: JSON.stringify(data2) }] };
+    }
+    const data = await client.get("/api/persons");
+    if (crypto3 && data.data) {
+      for (const person of data.data) {
+        const cipher = person.cipher;
+        if (cipher) {
+          try {
+            const fields = await decryptPersonCipher(cipher, crypto3.key);
+            Object.assign(person, fields, { cipher: null });
+          } catch {}
+        }
+      }
+    }
+    return { content: [{ type: "text", text: JSON.stringify(data) }] };
+  });
+  server.registerTool("delete_person", {
+    description: "Delete a person. Returns 409 if any transactions still reference this person.",
+    inputSchema: { id: exports_external.string().describe("Person UUID") }
+  }, async ({ id }) => {
+    const data = await client.delete(`/api/persons/${id}`);
+    return { content: [{ type: "text", text: JSON.stringify(data) }] };
+  });
 }
-async function loadDecryptedPersons(client, crypto3) {
-  const res = await client.get("/api/persons");
-  const persons = [];
-  for (const p2 of res.data ?? []) {
-    let name = p2.name ?? "";
-    if (crypto3 && p2.cipher) {
-      try {
-        name = (await decryptPersonCipher(p2.cipher, crypto3.key)).name;
-      } catch {}
+
+// src/tools/profile.ts
+function registerProfileTools(server, client) {
+  server.registerTool("get_profile", {
+    description: "Get the current user's profile (name, email, owner).",
+    inputSchema: {}
+  }, async () => {
+    const data = await client.get("/api/profile");
+    return { content: [{ type: "text", text: JSON.stringify(data) }] };
+  });
+  server.registerTool("update_profile", {
+    description: "Update your display name.",
+    inputSchema: {
+      name: exports_external.string().min(1).describe("Display name")
     }
-    if (name)
-      persons.push({ id: p2.id, name });
-  }
-  return persons;
+  }, async (body) => {
+    const data = await client.patch("/api/profile", body);
+    return { content: [{ type: "text", text: JSON.stringify(data) }] };
+  });
 }
-function resolvePersonByName(persons, query) {
-  const q2 = normalizePersonName(query);
-  if (!q2)
-    return null;
-  const exact = persons.filter((p2) => normalizePersonName(p2.name) === q2);
-  if (exact.length === 1)
-    return { personId: exact[0].id };
-  if (exact.length > 1)
-    return { candidates: exact.map((p2) => p2.name) };
-  const partial2 = persons.filter((p2) => normalizePersonName(p2.name).includes(q2));
-  if (partial2.length === 1)
-    return { personId: partial2[0].id };
-  if (partial2.length > 1)
-    return { candidates: partial2.map((p2) => p2.name) };
-  return null;
+
+// src/tools/push.ts
+function registerPushTools(server, client) {
+  server.registerTool("list_push_subscriptions", {
+    description: "List the household's registered web-push subscriptions (browser/device endpoints that receive alert notifications).",
+    inputSchema: {}
+  }, async () => {
+    const data = await client.get("/api/push/subscriptions");
+    return { content: [{ type: "text", text: JSON.stringify(data) }] };
+  });
+  server.registerTool("send_test_push", {
+    description: "Send a test web-push notification to all of the household's subscriptions. Use to verify push delivery is working.",
+    inputSchema: {}
+  }, async () => {
+    const data = await client.post("/api/push/test");
+    return { content: [{ type: "text", text: JSON.stringify(data) }] };
+  });
 }
-function parseNarration(description) {
-  const hdfc = parseHdfcNarration(description);
-  if (hdfc.name && hdfc.paymentMethod)
-    return { name: hdfc.name, upiId: hdfc.upiId, paymentMethod: hdfc.paymentMethod };
-  const sbi = parseSbiNarration(description);
-  if (sbi.name && sbi.paymentMethod)
-    return { name: sbi.name, upiId: sbi.upiId, paymentMethod: sbi.paymentMethod };
-  return {
-    name: hdfc.name || sbi.name,
-    upiId: hdfc.upiId ?? sbi.upiId,
-    paymentMethod: hdfc.paymentMethod ?? sbi.paymentMethod
-  };
+
+// src/tools/recurring.ts
+function registerRecurringTools(server, client) {
+  server.registerTool("list_recurring", {
+    description: "List recurring transactions (subscriptions, rent, salaries). These are auto-detected from transaction history; they cannot be added manually.",
+    inputSchema: {}
+  }, async () => {
+    const data = await client.get("/api/recurring");
+    return { content: [{ type: "text", text: JSON.stringify(data) }] };
+  });
+  server.registerTool("sync_recurring", {
+    description: "Auto-flag detected recurring merchants (isRecurring) from transaction history. Run after importing statements.",
+    inputSchema: {}
+  }, async () => {
+    const data = await client.post("/api/recurring/sync");
+    return { content: [{ type: "text", text: JSON.stringify(data) }] };
+  });
 }
-async function backfillPersons(client, crypto3, opts = {}) {
-  const existing = await loadDecryptedPersons(client, crypto3);
-  const personIdByNorm = new Map;
-  for (const p2 of existing)
-    personIdByNorm.set(normalizePersonName(p2.name), p2.id);
-  const candidates = [];
-  let cursor;
-  const MAX_PAGES = 100;
-  for (let page = 0;page < MAX_PAGES; page++) {
-    const params = { limit: 200 };
-    if (cursor)
-      params.cursor = cursor;
-    const res = await client.get("/api/transactions", params);
-    const rows = res.data ?? [];
-    if (crypto3)
-      await decryptTransactionFields(rows, crypto3.key);
-    for (const r2 of rows) {
-      if (!r2.merchantId && !r2.personId && !r2.isTransfer && !r2.isIgnored)
-        candidates.push(r2);
-    }
-    if (!res.hasMore || !res.nextCursor || rows.length === 0)
-      break;
-    cursor = res.nextCursor;
-  }
-  const groups = new Map;
-  for (const t2 of candidates) {
-    const { name, upiId, paymentMethod } = parseNarration(t2.description);
-    if (!name)
-      continue;
-    if (classifyEntity({ paymentMethod, extractedName: name }) !== "person")
-      continue;
-    const norm = normalizePersonName(name);
-    if (!norm)
-      continue;
-    const g3 = groups.get(norm) ?? {
-      displayName: name.trim(),
-      upiHandles: new Set,
-      txnIds: []
-    };
-    if (upiId)
-      g3.upiHandles.add(upiId);
-    g3.txnIds.push(t2.id);
-    groups.set(norm, g3);
-  }
-  const plan = [];
-  const newGroups = [];
-  let reused = 0;
-  for (const [norm, g3] of groups) {
-    const upiHandles = [...g3.upiHandles];
-    const isReuse = personIdByNorm.has(norm);
-    plan.push({
-      name: g3.displayName,
-      normalized: norm,
-      txnCount: g3.txnIds.length,
-      upiHandles,
-      action: isReuse ? "reuse" : "create"
-    });
-    if (isReuse)
-      reused++;
-    else
-      newGroups.push({ norm, displayName: g3.displayName, upiHandles });
-  }
-  if (!opts.dryRun && newGroups.length > 0) {
-    const bodies = await Promise.all(newGroups.map(async ({ displayName, upiHandles }) => {
-      const fields = {
-        name: displayName,
-        upiHandles,
-        phoneNumbers: [],
-        relationship: null,
-        notes: null
-      };
-      return crypto3 ? await encryptPersonCipher(fields, crypto3.key) : { name: displayName, upiHandles, phoneNumbers: [], relationship: null, notes: null };
-    }));
-    const res = await client.post("/api/persons/bulk", {
-      persons: bodies
-    });
-    res.data.forEach((p2, i2) => {
-      personIdByNorm.set(newGroups[i2].norm, p2.id);
-    });
-  }
-  const created = newGroups.length;
-  const links = [];
-  if (!opts.dryRun) {
-    for (const [norm, g3] of groups) {
-      const personId = personIdByNorm.get(norm);
-      if (!personId)
-        continue;
-      for (const txnId of g3.txnIds)
-        links.push({ transactionId: txnId, personId });
+
+// src/tools/reports.ts
+function registerReportTools(server, client) {
+  server.registerTool("generate_monthly_report", {
+    description: "Generate a detailed monthly financial report. Computes income, expenses, savings rate, top categories, and insights. Persists to DB.",
+    inputSchema: {
+      month: exports_external.number().min(1).max(12),
+      year: exports_external.number().min(2020).max(2100)
     }
-  }
-  if (!opts.dryRun && links.length > 0) {
-    const CHUNK = 25;
-    for (let i2 = 0;i2 < links.length; i2 += CHUNK) {
-      await client.post("/api/transactions/bulk-link-entity", { links: links.slice(i2, i2 + CHUNK) });
+  }, async (body) => {
+    const data = await client.post("/api/reports/generate", body);
+    return { content: [{ type: "text", text: JSON.stringify(data) }] };
+  });
+  server.registerTool("get_reports", {
+    description: "Monthly financial reports for the last N months — income, expenses, savings rate, net worth.",
+    inputSchema: {
+      months: exports_external.number().optional().describe("Number of months (default: 6)")
     }
-  }
-  return { candidatesScanned: candidates.length, created, reused, linked: links.length, plan };
+  }, async (params) => {
+    const data = await client.get("/api/reports", params.months ? { months: params.months } : undefined);
+    return { content: [{ type: "text", text: JSON.stringify(data) }] };
+  });
 }
 
+// src/lib/statement-import.ts
+import { readFile as readFile2 } from "node:fs/promises";
+import { basename } from "node:path";
+
 // src/tools/transactions.ts
+import { readFile } from "node:fs/promises";
 function dedupeKey(date4, description, amount, type) {
   return `${date4}|${description}|${amount.toFixed(2)}|${type}`;
 }
@@ -46940,8 +48272,23 @@ function registerTransactionTools(server, client, crypto3) {
       owner: exports_external.string().optional(),
       categorySlug: exports_external.string().optional(),
       categoryType: exports_external.enum(["needs", "wants", "investments", "income", "transfer"]).optional(),
-      source: exports_external.string().optional(),
       type: exports_external.enum(["debit", "credit"]).optional(),
+      source: exports_external.enum([
+        "bank_statement",
+        "cc_statement",
+        "zomato",
+        "swiggy",
+        "blinkit",
+        "amazon",
+        "zerodha_kite",
+        "zerodha_coin",
+        "groww",
+        "cas_statement",
+        "manual",
+        "telegram",
+        "wisprflow",
+        "ai_import"
+      ]).optional().describe("Filter by ingestion source"),
       amountMin: exports_external.number().optional(),
       amountMax: exports_external.number().optional(),
       uncategorized: exports_external.boolean().optional().describe("Only transactions with no category (server-side filter)"),
@@ -47105,6 +48452,12 @@ function registerTransactionTools(server, client, crypto3) {
       resolution: exports_external.enum(["keep", "ignore"]).optional().describe("[resolve] 'ignore' excludes the duplicates, 'keep' unflags them")
     }
   }, async ({ action, transactionId, ids, resolution }) => {
+    if (action === "flag" && !transactionId) {
+      throw new Error("transactionId is required for action 'flag'");
+    }
+    if (action === "resolve" && (!ids || ids.length === 0 || !resolution)) {
+      throw new Error("ids and resolution are required for action 'resolve'");
+    }
     if (action === "flag") {
       const data2 = await client.patch(`/api/transactions/${transactionId}`, {
         isDuplicate: true,
@@ -47309,16 +48662,152 @@ function registerTransactionTools(server, client, crypto3) {
   });
 }
 
+// src/lib/statement-import.ts
+var realParsers = {
+  "hdfc-savings": parseHdfcSavingsPdf,
+  "hdfc-card": parseHdfcCreditCardPdf,
+  amex: parseAmexCreditCardPdf,
+  "sbi-savings": parseSbiSavingsPdf
+};
+async function readFileAsArrayBuffer(path) {
+  const b2 = await readFile2(path);
+  return b2.buffer.slice(b2.byteOffset, b2.byteOffset + b2.byteLength);
+}
+function resolveAccount(accounts, query) {
+  const q2 = query.trim().toLowerCase();
+  const byId = accounts.find((a2) => a2.id === query);
+  if (byId)
+    return byId;
+  let hits = accounts.filter((a2) => a2.name.toLowerCase() === q2);
+  if (hits.length === 0) {
+    hits = accounts.filter((a2) => a2.name.toLowerCase().includes(q2) || a2.last4 !== null && a2.last4 === q2);
+  }
+  if (hits.length === 1)
+    return hits[0];
+  const names = (hits.length ? hits : accounts).map((a2) => a2.name).join(", ");
+  throw new Error(hits.length === 0 ? `No account matches "${query}". Accounts: ${names || "(none yet)"}. ` + "To add it, call upsert_bank_account (name, bankName, type: savings|current|credit_card|wallet, last4, owner), then retry." : `"${query}" matches several accounts: ${names}. Use the exact name or id.`);
+}
+function pickFormat(account, override) {
+  if (override)
+    return override;
+  const bank = `${account.bankName ?? ""} ${account.name}`.toLowerCase();
+  const card = account.type === "credit_card";
+  if (bank.includes("amex") || bank.includes("american express"))
+    return "amex";
+  if (bank.includes("hdfc"))
+    return card ? "hdfc-card" : "hdfc-savings";
+  if (bank.includes("sbi") && !card)
+    return "sbi-savings";
+  throw new Error(`No PDF parser for "${account.name}" (${account.bankName ?? "unknown bank"}, ${account.type}) yet. ` + "Supported: HDFC savings + cards, Amex, SBI savings.");
+}
+var isPasswordError = (e2) => e2 instanceof Error && /password/i.test(`${e2.name} ${e2.message}`);
+var sum = (rows) => Math.round(rows.reduce((n2, r2) => n2 + r2.amount, 0));
+async function runStatementImport(deps, args) {
+  const { client, crypto: crypto3 } = deps;
+  const accounts = (await client.get("/api/accounts")).data ?? [];
+  const account = resolveAccount(accounts, args.account);
+  const format = pickFormat(account, args.format);
+  let statement;
+  try {
+    statement = await deps.parsers[format](await deps.readFile(args.filePath), args.password);
+  } catch (e2) {
+    if (isPasswordError(e2)) {
+      throw new Error(`${basename(args.filePath)} is password-protected and the password was ${args.password ? "wrong" : "not given"}.`);
+    }
+    throw e2;
+  }
+  const txns = statement.transactions.filter((t2) => t2.amount > 0);
+  if (txns.length === 0) {
+    throw new Error(`${basename(args.filePath)} parsed to 0 transactions (format ${format}). If it is a statement with real activity, the layout may not be supported.`);
+  }
+  const dates = txns.map((t2) => t2.date).sort();
+  const ctx = await client.get("/api/transactions/reconciliation-context", { accountId: account.id, startDate: dates[0], endDate: dates[dates.length - 1] });
+  const existing = ctx.data ?? [];
+  if (crypto3)
+    await decryptTransactionFields(existing, crypto3.key);
+  const present = existing.map((r2) => ({ ...r2, isDuplicate: false, isIgnored: false }));
+  const result = reconcile(present, { ...statement, transactions: txns });
+  const fresh = result.unmatched;
+  const debits = fresh.filter((t2) => t2.type === "debit");
+  const credits = fresh.filter((t2) => t2.type === "credit");
+  const summary = {
+    account: account.name,
+    file: basename(args.filePath),
+    format,
+    period: { from: dates[0], to: dates[dates.length - 1] },
+    parsed: txns.length,
+    alreadyInPaisa: result.matched.length,
+    conflicts: result.conflicts.slice(0, 5).map((c2) => ({
+      date: c2.incoming.date,
+      amount: c2.incoming.amount,
+      reason: c2.reason
+    })),
+    conflictCount: result.conflicts.length,
+    new: {
+      n: fresh.length,
+      debits: { n: debits.length, total: sum(debits) },
+      credits: { n: credits.length, total: sum(credits) }
+    }
+  };
+  if (!args.confirm) {
+    return {
+      ...summary,
+      dryRun: true,
+      sample: fresh.slice(0, 8).map((t2) => ({
+        date: t2.date,
+        amt: t2.amount,
+        t: t2.type === "credit" ? "cr" : "dr",
+        desc: t2.description.slice(0, 50)
+      })),
+      next: fresh.length === 0 ? "Nothing new — this statement is already fully in Paisa." : `Call again with confirm:true to import the ${fresh.length} new rows${result.conflicts.length ? " (conflicts are skipped)" : ""}.`
+    };
+  }
+  if (fresh.length === 0)
+    return { ...summary, dryRun: false, imported: 0 };
+  const savings = account.type !== "credit_card";
+  const imported = await importTransactions(client, crypto3, {
+    accountId: account.id,
+    source: savings ? "bank_statement" : "cc_statement",
+    granularity: savings ? 1 : 2,
+    txns: fresh.map((t2) => ({
+      date: t2.date,
+      amount: t2.amount,
+      type: t2.type,
+      description: t2.description,
+      referenceNumber: t2.referenceNumber ?? undefined
+    }))
+  });
+  const rescan = await runRescan(client, crypto3);
+  return { ...summary, dryRun: false, ...imported, rescan };
+}
+
+// src/tools/statement-import.ts
+function registerStatementImportTools(server, client, crypto3) {
+  server.registerTool("import_statement_pdf", {
+    description: "Import a bank/credit-card statement PDF from a local file. TWO-PHASE: without `confirm` it only parses and reconciles against what Paisa already has and returns a summary " + "(rows already in Paisa, conflicts, NEW rows with totals) — nothing is written. Call again with confirm:true to import just the new rows, then run the categorize rescan. " + "Rows already in Paisa are never re-imported; conflicting rows (same date/name, different amount) are reported, never auto-imported. " + "Supported: HDFC savings + credit cards, Amex, SBI savings. Encrypted in private mode; reads the file locally.",
+    inputSchema: {
+      filePath: exports_external.string().describe("Absolute path to the statement PDF"),
+      account: exports_external.string().describe("Paisa account name (e.g. 'HDFC Swiggy'), last4, or id — see list_bank_accounts. If the account doesn't exist yet, create it first with upsert_bank_account"),
+      password: exports_external.string().optional().describe("PDF password, if the file is protected"),
+      format: exports_external.enum(["hdfc-savings", "hdfc-card", "amex", "sbi-savings"]).optional().describe("Override the parser (default: chosen from the account's bank and type)"),
+      confirm: exports_external.boolean().optional().describe("false/omitted = dry run (nothing written); true = import the new rows")
+    }
+  }, async (args) => {
+    const result = await runStatementImport({ client, crypto: crypto3, readFile: readFileAsArrayBuffer, parsers: realParsers }, args);
+    return { content: [{ type: "text", text: JSON.stringify(result) }] };
+  });
+}
+
 // src/tools/upcoming.ts
 function registerUpcomingTools(server, client) {
   server.registerTool("get_upcoming", {
     description: "Get upcoming payments (EMIs, SIPs, insurance renewals, CC billing) due in the next N days.",
     inputSchema: {
-      days: exports_external.number().optional().describe("Look-ahead window in days (default: 60)")
+      days: exports_external.number().int().min(1).max(365).optional().describe("Look-ahead window in days (1-365, default 60)")
     }
-  }, async (params) => {
-    const data = await client.get("/api/upcoming", params.days ? { days: params.days } : undefined);
-    return { content: [{ type: "text", text: JSON.stringify(data) }] };
+  }, async ({ days }) => {
+    const res = await client.get("/api/upcoming", { days });
+    return { content: [{ type: "text", text: JSON.stringify(res) }] };
   });
 }
 
@@ -47333,6 +48822,79 @@ function registerWaitlistTools(server, client) {
   });
 }
 
+// src/registrations.ts
+var REGISTRATIONS = [
+  { title: "Transactions", register: registerTransactionTools },
+  { title: "Statement import", register: registerStatementImportTools },
+  { title: "Jev auto-categorize", register: registerJevTools },
+  { title: "Merchants", register: registerMerchantTools },
+  { title: "Persons", register: registerPersonTools },
+  { title: "Categories", register: registerCategoryTools },
+  { title: "Analytics", register: registerAnalyticsTools },
+  { title: "Bank accounts", register: registerAccountTools },
+  { title: "Goals & EMIs", register: registerGoalTools },
+  { title: "Budgets", register: registerBudgetTools },
+  { title: "Upcoming", register: registerUpcomingTools },
+  { title: "Dashboard", register: registerDashboardTools },
+  { title: "Recurring & subscriptions", register: registerRecurringTools },
+  { title: "Alerts", register: registerAlertTools },
+  { title: "Alert rules", register: registerAlertRuleTools },
+  { title: "Debts", register: registerDebtTools },
+  { title: "Reports", register: registerReportTools },
+  { title: "Export", register: registerExportTools },
+  { title: "Heatmap", register: registerHeatmapTools },
+  { title: "Household", register: registerHouseholdTools },
+  { title: "Household learning", register: registerHouseholdLearningTools },
+  { title: "Net worth", register: registerNetWorthTools },
+  { title: "Investments", register: registerInvestmentTools },
+  { title: "Profile", register: registerProfileTools },
+  { title: "Encryption & privacy", register: registerAuthCryptoTools },
+  { title: "Waitlist", register: registerWaitlistTools },
+  { title: "Push notifications", register: registerPushTools }
+];
+// package.json
+var package_default = {
+  name: "paisa-mcp",
+  version: "0.0.22",
+  description: "Paisa MCP server — personal finance tools for AI assistants",
+  bin: {
+    "paisa-mcp": "dist/index.js"
+  },
+  type: "module",
+  files: [
+    "dist"
+  ],
+  scripts: {
+    build: 'bun build src/index.ts --outdir dist --target node --format esm --sourcemap --external pdfjs-dist --external "pdfjs-dist/*"',
+    "gen:tools-doc": "bun src/tools-doc.ts",
+    start: "node dist/index.js",
+    test: "bun test",
+    typecheck: "tsc --noEmit"
+  },
+  dependencies: {
+    "pdfjs-dist": "^5.6.205"
+  },
+  devDependencies: {
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "@paisa/parsers": "workspace:*",
+    "@paisa/reconciliation": "workspace:*",
+    "@paisa/types": "workspace:*",
+    "@scure/bip39": "^2.2.0",
+    "@types/bun": "^1.3.14",
+    "@typesafe-ai/sdk": "^0.6.0",
+    axios: "^1.16.1",
+    "hash-wasm": "^4.12.0",
+    typescript: "^5.8.3",
+    zod: "^3.25.17"
+  },
+  engines: {
+    node: ">=20.0.0"
+  }
+};
+
+// src/version.ts
+var VERSION3 = package_default.version;
+
 // src/index.ts
 async function main() {
   const apiUrl = process.env.PAISA_API_URL;
@@ -47343,56 +48905,16 @@ async function main() {
     process.exit(1);
   }
   const client = new PaisaApiClient(apiUrl, apiToken);
-  let cryptoCtx;
-  const pin = process.env.PAISA_PIN;
-  const userId = process.env.PAISA_USER_ID;
-  if (pin) {
-    if (!userId) {
-      console.error("Error: PAISA_USER_ID is required when PAISA_PIN is set.");
-      process.exit(1);
-    }
-    const cryptoMeta = await client.get("/api/auth-crypto").catch(() => null);
-    if (cryptoMeta && (cryptoMeta.kdfVersion ?? 1) >= 2 && cryptoMeta.kdfSalt && cryptoMeta.wrappedDek) {
-      const kek = await deriveKEK(pin, cryptoMeta.kdfSalt);
-      const dek = await unwrapDEK(cryptoMeta.wrappedDek, kek);
-      cryptoCtx = { key: dek };
-    } else {
-      const key = await deriveKey(userId, pin, userId);
-      cryptoCtx = { key };
-    }
+  const cryptoCtx = await initCrypto(client, process.env.PAISA_PIN, process.env.PAISA_USER_ID);
+  if (cryptoCtx)
     console.error("Paisa MCP: private mode — encryption active");
-  }
   const crypto3 = cryptoCtx;
   const server = new McpServer({
     name: "paisa",
-    version: "0.0.1"
-  });
-  registerTransactionTools(server, client, crypto3);
-  registerJevTools(server, client, crypto3);
-  registerMerchantTools(server, client, crypto3);
-  registerPersonTools(server, client, crypto3);
-  registerCategoryTools(server, client);
-  registerAnalyticsTools(server, client, crypto3);
-  registerAccountTools(server, client);
-  registerGoalTools(server, client);
-  registerBudgetTools(server, client);
-  registerUpcomingTools(server, client);
-  registerDashboardTools(server, client, crypto3);
-  registerRecurringTools(server, client);
-  registerAlertTools(server, client);
-  registerAlertRuleTools(server, client);
-  registerDebtTools(server, client);
-  registerReportTools(server, client);
-  registerExportTools(server, client, crypto3);
-  registerHeatmapTools(server, client);
-  registerHouseholdTools(server, client);
-  registerHouseholdLearningTools(server, client, crypto3);
-  registerNetWorthTools(server, client);
-  registerInvestmentTools(server, client);
-  registerProfileTools(server, client);
-  registerAuthCryptoTools(server, client);
-  registerWaitlistTools(server, client);
-  registerPushTools(server, client);
+    version: VERSION3
+  });
+  for (const { register } of REGISTRATIONS)
+    register(server, client, crypto3);
   const transport = new StdioServerTransport;
   await server.connect(transport);
   console.error("Paisa MCP server running on stdio");
@@ -47402,5 +48924,5 @@ main().catch((err) => {
   process.exit(1);
 });
 
-//# debugId=81E220C7BA0CDE2464756E2164756E21
+//# debugId=BC4AFE8852AA4C8E64756E2164756E21
 //# sourceMappingURL=index.js.map