paisa-mcp 0.0.20 → 0.0.22

package/dist/index.js

@@ -28092,7 +28092,7 @@ function finalize(ctx, schema) {
     result.$schema = "http://json-schema.org/draft-07/schema#";
   } else if (ctx.target === "draft-04") {
     result.$schema = "http://json-schema.org/draft-04/schema#";
-  } else if (ctx.target === "openapi-3.0") {} else {}
+  } else if (ctx.target === "openapi-3.0") {}
   if (ctx.external?.uri) {
     const id = ctx.external.registry.get(schema)?.id;
     if (!id)
@@ -28340,7 +28340,7 @@ var literalProcessor = (schema, ctx, json, _params) => {
     if (val === undefined) {
       if (ctx.unrepresentable === "throw") {
         throw new Error("Literal `undefined` cannot be represented in JSON Schema");
-      } else {}
+      }
     } else if (typeof val === "bigint") {
       if (ctx.unrepresentable === "throw") {
         throw new Error("BigInt literals cannot be represented in JSON Schema");
@@ -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
@@ -42773,7 +42846,7 @@ function registerHeatmapTools(server, client) {
   });
 }
 
-// src/tools/household-learning.ts
+// src/lib/learning-bag.ts
 var EMPTY_BAG = {
   merchantAliases: [],
   personAliases: [],
@@ -42784,15 +42857,17 @@ 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) {
-  const res = await client.put("/api/household-learning", {
-    bag,
-    expectedVersion
-  });
+  const res = await client.put("/api/household-learning", { bag, expectedVersion });
   return { version: res.data.version };
 }
+
+// src/tools/household-learning.ts
 function registerHouseholdLearningTools(server, client, _crypto) {
   server.registerTool("list_learning", {
     description: "List a slice of what the user has taught the categorizer for this household: " + "merchant->category rules, person->category rules, merchant aliases, or person aliases.",
@@ -42887,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) }] };
   });
 }
@@ -42900,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"),
@@ -42926,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)"),
@@ -42939,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,
@@ -42964,7 +43057,7 @@ function registerInvestmentTools(server, client) {
     }
     if (type === "sip") {
       const {
-        id,
+        id: id2,
         name,
         amount: amount2,
         startDate: startDate2,
@@ -42973,362 +43066,705 @@ 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
-    });
-    return { content: [{ type: "text", text: JSON.stringify(data) }] };
-  });
-}
-
-// 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);
+    };
+    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("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.",
+  server.registerTool("delete_investment", {
+    description: "Delete a SIP or fixed deposit by id. PERMANENT (FDs are soft-deleted) — confirm with the user first.",
     inputSchema: {
-      rawId: exports_external.string().optional().describe("Raw identifier to look up a single merchant; omit to list all")
-    }
-  }, 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((m) => String(m.rawId ?? "").toLowerCase() === needle || String(m.cleanName ?? "").toLowerCase().includes(needle));
-      return {
-        content: [{ type: "text", text: JSON.stringify({ ...data2, data: merchants }) }]
-      };
+      type: exports_external.enum(["sip", "fixed_deposit"]),
+      id: exports_external.string().describe("SIP or FD UUID")
     }
-    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);
+  }, 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("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}`);
+  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) }] };
   });
 }
 
-// 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()
+// ../../node_modules/.bun/@typesafe-ai+sdk@0.6.0/node_modules/@typesafe-ai/sdk/dist/index.mjs
+var requestIdFrom = (headers) => headers.get("x-typesafe-request-id") ?? undefined;
+var APIPromise = class APIPromise2 extends Promise {
+  #responsePromise;
+  #parseResponse;
+  #parsed;
+  constructor(responsePromise, parseResponse) {
+    super((resolve) => resolve(undefined));
+    this.#responsePromise = responsePromise;
+    this.#parseResponse = parseResponse;
+  }
+  asResponse() {
+    return this.#responsePromise;
+  }
+  async withResponse() {
+    const [data, response] = await Promise.all([this.#parse(), this.#responsePromise]);
+    return {
+      data,
+      response,
+      requestId: requestIdFrom(response.headers)
+    };
+  }
+  map(fn) {
+    return new APIPromise2(this.#responsePromise, () => this.#parse().then(fn));
+  }
+  #parse() {
+    this.#parsed ??= this.#responsePromise.then(this.#parseResponse);
+    return this.#parsed;
+  }
+  then(onfulfilled, onrejected) {
+    return this.#parse().then(onfulfilled, onrejected);
+  }
+  catch(onrejected) {
+    return this.#parse().catch(onrejected);
+  }
+  finally(onfinally) {
+    return this.#parse().finally(onfinally);
+  }
+};
+var ENV = {
+  apiKey: "TYPESAFE_API_KEY",
+  baseURL: "TYPESAFE_BASE_URL",
+  defaultModel: "TYPESAFE_DEFAULT_MODEL",
+  logLevel: "TYPESAFE_LOG_LEVEL"
+};
+var readEnv = (name) => {
+  if (typeof process === "undefined" || !process.env)
+    return;
+  return process.env[name]?.trim() || undefined;
+};
+var fromCodeOrEnv = (fromCode, envVar) => fromCode ?? readEnv(envVar);
+var range = (from, to) => Array.from({ length: to - from }, (_, i) => from + i);
+var DEFAULT_RETRY_POLICY = {
+  maxRetries: 2,
+  backoffInitialMs: 500,
+  backoffMaxMs: 5000,
+  backoffJitter: 0.25,
+  httpStatuses: /* @__PURE__ */ new Set([
+    408,
+    429,
+    ...range(500, 600)
+  ]),
+  respectRetryAfter: true,
+  maxRetryAfterMs: 60000,
+  apiConnectionError: true,
+  apiTimeoutError: true
+};
+DEFAULT_RETRY_POLICY.maxRetries;
+var isRetryableStatus = (status, policy = DEFAULT_RETRY_POLICY) => policy.httpStatuses.has(status);
+var parseRetryAfter = (headers, now = Date.now()) => {
+  const ms = Number(headers.get("retry-after-ms"));
+  if (headers.has("retry-after-ms") && Number.isFinite(ms) && ms >= 0)
+    return ms;
+  const raw = headers.get("retry-after");
+  if (raw === null)
+    return;
+  const seconds = Number(raw);
+  if (Number.isFinite(seconds))
+    return seconds >= 0 ? seconds * 1000 : undefined;
+  const date4 = Date.parse(raw);
+  if (!Number.isNaN(date4))
+    return Math.max(0, date4 - now);
+};
+var retryDelayMs = (attempt, headers, policy = DEFAULT_RETRY_POLICY, random = Math.random) => {
+  if (policy.respectRetryAfter && headers !== undefined) {
+    const retryAfter = parseRetryAfter(headers);
+    if (retryAfter !== undefined && retryAfter <= policy.maxRetryAfterMs)
+      return retryAfter;
+  }
+  const exponential = Math.min(policy.backoffInitialMs * 2 ** attempt, policy.backoffMaxMs);
+  return Math.round(exponential * (1 - random() * policy.backoffJitter));
+};
+var sleep = (ms, signal) => new Promise((resolve, reject) => {
+  if (signal?.aborted)
+    return reject(signal.reason);
+  const onAbort = () => {
+    clearTimeout(timer);
+    reject(signal?.reason);
+  };
+  const timer = setTimeout(() => {
+    signal?.removeEventListener("abort", onAbort);
+    resolve();
+  }, ms);
+  signal?.addEventListener("abort", onAbort, { once: true });
+});
+var TypeSafeError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = new.target.name;
+  }
+};
+var isRecord = (value) => typeof value === "object" && value !== null;
+var extractMessage = (body) => {
+  if (typeof body === "string")
+    return body || undefined;
+  if (!isRecord(body))
+    return;
+  const { error: error2, message, detail } = body;
+  if (typeof error2 === "string")
+    return error2;
+  if (isRecord(error2) && typeof error2.message === "string")
+    return error2.message;
+  if (typeof message === "string")
+    return message;
+  if (typeof detail === "string")
+    return detail;
+  if (isRecord(detail) && typeof detail.message === "string")
+    return detail.message;
+  if (Array.isArray(detail))
+    return describeValidationErrors(detail);
+};
+var describeValidationErrors = (errors4) => {
+  const parts = errors4.flatMap((e) => {
+    if (!isRecord(e) || typeof e.msg !== "string")
+      return [];
+    const loc = Array.isArray(e.loc) ? e.loc.filter((x) => x !== "body").join(".") : "";
+    return [loc ? `${loc}: ${e.msg}` : e.msg];
+  });
+  return parts.length > 0 ? parts.join("; ") : undefined;
+};
+var MAX_RAW_BODY_IN_MESSAGE = 200;
+var APIError = class APIError2 extends TypeSafeError {
+  status;
+  headers;
+  body;
+  requestId;
+  constructor(status, body, headers, message) {
+    super(message ?? APIError2.describe(status, body));
+    this.status = status;
+    this.body = body;
+    this.headers = headers;
+    this.requestId = requestIdFrom(headers);
+  }
+  static describe(status, body) {
+    const detail = extractMessage(body);
+    if (detail)
+      return `${status} ${detail}`;
+    if (body === undefined)
+      return `${status} status code (no body)`;
+    const raw = typeof body === "string" ? body : JSON.stringify(body);
+    return `${status} ${raw.length > MAX_RAW_BODY_IN_MESSAGE ? `${raw.slice(0, MAX_RAW_BODY_IN_MESSAGE)}…` : raw}`;
+  }
+  static fromResponse(status, body, headers) {
+    if (status === 400)
+      return new BadRequestError(status, body, headers);
+    if (status === 401)
+      return new AuthenticationError(status, body, headers);
+    if (status === 403)
+      return new PermissionDeniedError(status, body, headers);
+    if (status === 404)
+      return new NotFoundError(status, body, headers);
+    if (status === 422)
+      return new UnprocessableEntityError(status, body, headers);
+    if (status === 429)
+      return new RateLimitError(status, body, headers);
+    if (status >= 500)
+      return new InternalServerError(status, body, headers);
+    return new APIError2(status, body, headers);
+  }
+};
+var BadRequestError = class extends APIError {
+};
+var AuthenticationError = class extends APIError {
+};
+var PermissionDeniedError = class extends APIError {
+};
+var NotFoundError = class extends APIError {
+};
+var UnprocessableEntityError = class extends APIError {
+};
+var RateLimitError = class extends APIError {
+  retryAfterMs = parseRetryAfter(this.headers);
+};
+var InternalServerError = class extends APIError {
+};
+var APIConnectionError = class extends TypeSafeError {
+  constructor(message = "Connection error.", options) {
+    super(message, options);
+  }
+};
+var APITimeoutError = class extends APIConnectionError {
+  timeoutMs;
+  constructor(timeoutMs, options) {
+    super(`Request timed out after ${timeoutMs}ms.`, options);
+    this.timeoutMs = timeoutMs;
+  }
+};
+var APIUserAbortError = class extends TypeSafeError {
+  constructor(message = "Request was aborted.", options) {
+    super(message, options);
+  }
+};
+var LOG_LEVELS = [
+  "debug",
+  "info",
+  "warn",
+  "error",
+  "off"
+];
+var DEFAULT_LOG_LEVEL = "warn";
+var isLogLevel = (value) => LOG_LEVELS.includes(value);
+var parseLogLevel = (value, source) => {
+  if (isLogLevel(value))
+    return value;
+  throw new TypeSafeError(`Invalid log level "${value}" from ${source}. Expected one of: ${LOG_LEVELS.join(", ")}.`);
+};
+var PREFIX = "[typesafe-sdk]";
+var consoleLogger = {
+  debug: (message, ...args) => console.debug(`${PREFIX} ${message}`, ...args),
+  info: (message, ...args) => console.info(`${PREFIX} ${message}`, ...args),
+  warn: (message, ...args) => console.warn(`${PREFIX} ${message}`, ...args),
+  error: (message, ...args) => console.error(`${PREFIX} ${message}`, ...args)
+};
+var RANK = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  off: 4
+};
+var drop = () => {};
+var withLevel = (sink, level) => {
+  const enabled = (at) => RANK[at] >= RANK[level];
+  return {
+    debug: enabled("debug") ? (message, ...args) => sink.debug(message, ...args) : drop,
+    info: enabled("info") ? (message, ...args) => sink.info(message, ...args) : drop,
+    warn: enabled("warn") ? (message, ...args) => sink.warn(message, ...args) : drop,
+    error: enabled("error") ? (message, ...args) => sink.error(message, ...args) : drop
+  };
+};
+var KEY_HEADERS = /* @__PURE__ */ new Set([
+  "authorization",
+  "proxy-authorization",
+  "x-api-key"
+]);
+var OPAQUE_HEADERS = /* @__PURE__ */ new Set(["cookie", "set-cookie"]);
+var redactKey = (value) => {
+  const [scheme, secret] = value.includes(" ") ? value.split(/\s+/, 2) : [undefined, value];
+  const tail = secret && secret.length > 8 ? secret.slice(-4) : "";
+  return `${scheme ? `${scheme} ` : ""}***${tail}`;
+};
+var redact = (name, value) => {
+  const lower = name.toLowerCase();
+  if (KEY_HEADERS.has(lower))
+    return redactKey(value);
+  if (OPAQUE_HEADERS.has(lower))
+    return "***";
+  return value;
+};
+var redactHeaders = (headers) => Object.fromEntries(Object.entries(headers).map(([name, value]) => [name, redact(name, value)]));
+var choice = (instructions, criteria) => {
+  if (Array.isArray(criteria))
+    throw new TypeSafeError("Choice criteria must be a map of labels to descriptions, not a list.");
+  return {
+    type: "choice",
+    instructions,
+    criteria
+  };
+};
+var validateQuestions = (questions) => {
+  if (Object.keys(questions).length === 0)
+    throw new TypeSafeError("At least one question is required.");
+  for (const [name, question] of Object.entries(questions)) {
+    if (question.type !== "score")
+      continue;
+    if (!Array.isArray(question.criteria))
+      throw new TypeSafeError(`Score question "${name}" has criteria that are not a list; score criteria must be a list of descriptions indexed by score from zero.`);
+    if (question.criteria.length < 2)
+      throw new TypeSafeError(`Score question "${name}" has ${question.criteria.length} criteria; at least two scores are required.`);
+  }
+};
+var Models = class {
+  #transport;
+  constructor(transport) {
+    this.#transport = transport;
+  }
+  list(options = {}) {
+    return this.#transport.request("GET", "/v1/models", options).map(unwrapModels);
+  }
+};
+var unwrapModels = (wire) => {
+  if (Array.isArray(wire?.models))
+    return wire.models;
+  throw new TypeSafeError("Unexpected response shape from GET /v1/models; expected { models: [...] }.");
+};
+var g = globalThis;
+var isBrowser = () => typeof g.window !== "undefined" && typeof g.window.document !== "undefined" && typeof g.navigator !== "undefined";
+var describeRuntime = () => {
+  const platform = g.process?.platform && g.process?.arch ? ` (${g.process.platform}; ${g.process.arch})` : "";
+  if (g.Bun?.version)
+    return `bun/${g.Bun.version}${platform}`;
+  if (g.Deno?.version?.deno)
+    return `deno/${g.Deno.version.deno}${platform}`;
+  if (g.EdgeRuntime !== undefined)
+    return "vercel-edge";
+  if (g.navigator?.userAgent === "Cloudflare-Workers")
+    return "cloudflare-workers";
+  if (g.process?.versions?.node)
+    return `node/${g.process.versions.node}${platform}`;
+  if (isBrowser())
+    return "browser";
+  return "unknown";
+};
+var VERSION2 = "0.6.0";
+var missingApiKey = () => {
+  throw new TypeSafeError(`No API key was provided. Pass \`apiKey\` to the TypeSafeClient constructor or set the ${ENV.apiKey} environment variable.`);
+};
+var missingFetch = () => {
+  throw new TypeSafeError("No global `fetch` is available in this runtime. Pass a `fetch` implementation to the TypeSafeClient constructor.");
+};
+var refuseBrowser = () => {
+  throw new TypeSafeError("TypeSafeClient is running in a browser, which would expose your API key to anyone using the page. Call the API from a server instead, or pass `dangerouslyAllowBrowser: true` if you understand the risk.");
+};
+var defaultFetch = (input, init) => globalThis.fetch(input, init);
+var assertNonNegativeInteger = (name, value) => {
+  if (!Number.isInteger(value) || value < 0)
+    throw new TypeSafeError(`\`${name}\` must be a non-negative integer, got ${String(value)}.`);
+  return value;
+};
+var assertPositiveMs = (name, value) => {
+  if (!Number.isFinite(value) || value <= 0)
+    throw new TypeSafeError(`\`${name}\` must be a positive number of milliseconds, got ${String(value)}.`);
+  return value;
+};
+var assertNonNegativeMs = (name, value) => {
+  if (!Number.isFinite(value) || value < 0)
+    throw new TypeSafeError(`\`${name}\` must be a non-negative number of milliseconds, got ${String(value)}.`);
+  return value;
+};
+var assertFraction = (name, value) => {
+  if (!Number.isFinite(value) || value < 0 || value > 1)
+    throw new TypeSafeError(`\`${name}\` must be between 0 and 1, got ${String(value)}.`);
+  return value;
+};
+var assertStatusSet = (name, statuses) => {
+  for (const status of statuses)
+    if (!Number.isInteger(status) || status < 100 || status > 999)
+      throw new TypeSafeError(`\`${name}\` must contain HTTP status codes, got ${String(status)}.`);
+  return statuses;
+};
+var resolveRetryPolicy = (base, overrides) => {
+  const o = overrides ?? {};
+  return {
+    maxRetries: o.maxRetries === undefined ? base.maxRetries : assertNonNegativeInteger("retry.maxRetries", o.maxRetries),
+    backoffInitialMs: o.backoffInitialMs === undefined ? base.backoffInitialMs : assertNonNegativeMs("retry.backoffInitialMs", o.backoffInitialMs),
+    backoffMaxMs: o.backoffMaxMs === undefined ? base.backoffMaxMs : assertNonNegativeMs("retry.backoffMaxMs", o.backoffMaxMs),
+    backoffJitter: o.backoffJitter === undefined ? base.backoffJitter : assertFraction("retry.backoffJitter", o.backoffJitter),
+    httpStatuses: new Set(o.httpStatuses === undefined ? base.httpStatuses : assertStatusSet("retry.httpStatuses", o.httpStatuses)),
+    respectRetryAfter: o.respectRetryAfter ?? base.respectRetryAfter,
+    maxRetryAfterMs: o.maxRetryAfterMs === undefined ? base.maxRetryAfterMs : assertNonNegativeMs("retry.maxRetryAfterMs", o.maxRetryAfterMs),
+    apiConnectionError: o.apiConnectionError ?? base.apiConnectionError,
+    apiTimeoutError: o.apiTimeoutError ?? base.apiTimeoutError
+  };
+};
+var isRetryableError = (err, policy) => {
+  if (err instanceof APITimeoutError)
+    return policy.apiTimeoutError;
+  if (err instanceof APIConnectionError)
+    return policy.apiConnectionError;
+  return false;
+};
+var resolveLogLevel = (fromCode) => {
+  if (fromCode !== undefined)
+    return parseLogLevel(fromCode, "the `logLevel` option");
+  const fromEnv = readEnv(ENV.logLevel);
+  if (fromEnv !== undefined)
+    return parseLogLevel(fromEnv, ENV.logLevel);
+  return DEFAULT_LOG_LEVEL;
+};
+var stripTrailingSlashes = (url2) => url2.replace(/\/+$/, "");
+var mergeHeaders = (...sources) => {
+  const entries = /* @__PURE__ */ new Map;
+  for (const source of sources)
+    for (const [name, value] of Object.entries(source))
+      if (value === undefined)
+        entries.delete(name.toLowerCase());
+      else
+        entries.set(name.toLowerCase(), [name, value]);
+  return Object.fromEntries(entries.values());
+};
+var bufferResponse = async (response, signal) => {
+  const reader = response.clone().body?.getReader();
+  if (!reader)
+    return;
+  const cancel = () => {
+    reader.cancel(signal.reason).catch(() => {});
+    response.body?.cancel(signal.reason).catch(() => {});
+  };
+  signal.addEventListener("abort", cancel, { once: true });
+  try {
+    if (signal.aborted)
+      cancel();
+    signal.throwIfAborted();
+    while (!(await reader.read()).done)
+      signal.throwIfAborted();
+    signal.throwIfAborted();
+  } finally {
+    signal.removeEventListener("abort", cancel);
+    reader.releaseLock();
+  }
+};
+var RUNTIME = describeRuntime();
+var TypeSafeClient = class {
+  #apiKey;
+  baseURL;
+  defaultModel;
+  logLevel;
+  logger;
+  retry;
+  timeout;
+  defaultHeaders;
+  fetch;
+  models;
+  #requestCount = 0;
+  constructor(config2 = {}) {
+    if (isBrowser() && !config2.dangerouslyAllowBrowser)
+      refuseBrowser();
+    this.#apiKey = fromCodeOrEnv(config2.apiKey, ENV.apiKey) ?? missingApiKey();
+    this.baseURL = stripTrailingSlashes(fromCodeOrEnv(config2.baseURL, ENV.baseURL) ?? "https://api.typesafe.ai");
+    this.defaultModel = fromCodeOrEnv(config2.defaultModel, ENV.defaultModel) ?? "jev-latest";
+    this.logLevel = resolveLogLevel(config2.logLevel);
+    this.logger = withLevel(config2.logger ?? consoleLogger, this.logLevel);
+    this.retry = resolveRetryPolicy(DEFAULT_RETRY_POLICY, config2.retry);
+    this.timeout = assertPositiveMs("timeout", config2.timeout ?? 1e4);
+    this.defaultHeaders = { ...config2.defaultHeaders };
+    if (config2.fetch === undefined && typeof globalThis.fetch !== "function")
+      missingFetch();
+    this.fetch = config2.fetch ?? defaultFetch;
+    const transport = {
+      request: (method, path, options) => this.#request(method, path, options),
+      defaultModel: this.defaultModel
+    };
+    this.models = new Models(transport);
+  }
+  systemOne(request, options = {}) {
+    validateQuestions(request.questions);
+    const body = {
+      ...request,
+      model: request.model ?? this.defaultModel
+    };
+    return this.#request("POST", "/v1/systemone", {
+      ...options,
+      body
+    });
+  }
+  #request(method, path, options = {}) {
+    const resolved = {
+      method,
+      path,
+      body: options.body,
+      headers: mergeHeaders(this.defaultHeaders, options.headers ?? {}),
+      signal: options.signal,
+      timeout: options.timeout === undefined ? this.timeout : assertPositiveMs("timeout", options.timeout),
+      retry: resolveRetryPolicy(this.retry, options.retry)
+    };
+    const tag = `#${++this.#requestCount} ${method} ${path}`;
+    return new APIPromise(this.fetchWithRetries(tag, resolved), async (res) => {
+      const parsed = await parseBody(res);
+      this.logger.debug(`${tag} <- body`, parsed);
+      return parsed;
+    });
+  }
+  async fetchWithRetries(tag, req) {
+    const url2 = `${this.baseURL}${req.path}`;
+    const headers = mergeHeaders(req.headers, {
+      Authorization: `Bearer ${this.#apiKey}`,
+      Accept: "application/json",
+      "User-Agent": `typesafe-sdk/${VERSION2}`,
+      "X-TypeSafe-SDK": `typesafe-sdk/${VERSION2}`,
+      "X-TypeSafe-Runtime": RUNTIME,
+      "Content-Type": req.body === undefined ? undefined : "application/json",
+      "X-TypeSafe-Retry-Count": undefined
+    });
+    const body = req.body === undefined ? undefined : JSON.stringify(req.body);
+    for (let attempt = 0;; attempt++) {
+      const retriesLeft = req.retry.maxRetries - attempt;
+      const attemptHeaders = attempt === 0 ? headers : {
+        ...headers,
+        "X-TypeSafe-Retry-Count": String(attempt)
+      };
+      this.logger.debug(`${tag} -> ${url2}`, {
+        headers: redactHeaders(attemptHeaders),
+        body: req.body
+      });
+      const started = Date.now();
+      let res;
+      try {
+        res = await this.attempt(tag, url2, {
+          method: req.method,
+          headers: attemptHeaders,
+          body
+        }, req);
+      } catch (err) {
+        if (err instanceof APIUserAbortError || retriesLeft <= 0)
+          throw err;
+        if (!isRetryableError(err, req.retry))
+          throw err;
+        await this.backOff(tag, attempt, retriesLeft, err.message, undefined, req);
+        continue;
+      }
+      const requestId = requestIdFrom(res.headers);
+      this.logger.info(`${tag} <- ${res.status} in ${Date.now() - started}ms${requestId ? ` (request ${requestId})` : ""}`);
+      if (res.ok)
+        return res;
+      const errorBody = await parseBody(res);
+      this.logger.debug(`${tag} <- error body`, errorBody);
+      const error2 = APIError.fromResponse(res.status, errorBody, res.headers);
+      if (retriesLeft <= 0 || !isRetryableStatus(res.status, req.retry))
+        throw error2;
+      await this.backOff(tag, attempt, retriesLeft, `${res.status}`, res.headers, req);
     }
-  }, 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,
-        emergencyFund: body.emergencyFund ?? "0",
-        totalNetWorth
+  }
+  async attempt(tag, url2, init, { signal, timeout }) {
+    const controller = new AbortController;
+    const abortFromCaller = () => controller.abort(signal?.reason);
+    if (signal?.aborted)
+      abortFromCaller();
+    signal?.addEventListener("abort", abortFromCaller, { once: true });
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+    }, timeout);
+    const started = Date.now();
+    const elapsed = () => `${Date.now() - started}ms`;
+    try {
+      const response = await this.fetch(url2, {
+        ...init,
+        signal: controller.signal
       });
+      await bufferResponse(response, controller.signal);
+      return response;
+    } catch (err) {
+      if (signal?.aborted) {
+        this.logger.info(`${tag} aborted by caller after ${elapsed()}`);
+        throw new APIUserAbortError(undefined, { cause: err });
+      }
+      if (timedOut) {
+        this.logger.info(`${tag} timed out after ${elapsed()}`);
+        throw new APITimeoutError(timeout, { cause: err });
+      }
+      this.logger.info(`${tag} connection error after ${elapsed()}`, err);
+      throw new APIConnectionError(err instanceof Error ? `Connection error: ${err.message}` : undefined, { cause: err });
+    } finally {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", abortFromCaller);
     }
-    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 {}
-        }
-      }
+  }
+  async backOff(tag, attempt, retriesLeft, reason, headers, { retry, signal }) {
+    const delay = retryDelayMs(attempt, headers, retry);
+    const nth = attempt + 1;
+    const total = attempt + retriesLeft;
+    this.logger.info(`${tag} retrying in ${delay}ms (retry ${nth}/${total}) after ${reason}`);
+    try {
+      await sleep(delay, signal);
+    } catch (err) {
+      this.logger.info(`${tag} aborted by caller while waiting to retry`);
+      throw new APIUserAbortError(undefined, { cause: err });
     }
-    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")
+  }
+};
+var parseBody = async (res) => {
+  const text = await res.text();
+  if (text.length === 0)
+    return;
+  if ((res.headers.get("content-type") ?? "").includes("application/json"))
+    try {
+      return JSON.parse(text);
+    } catch {
+      return text;
     }
-  }, 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) }] };
-  });
-}
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+};
 
-// 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()
+// src/lib/categories.ts
+async function loadCategoryIndex(client) {
+  const res = await client.get("/api/categories");
+  const bySlug = new Map;
+  const byId = new Map;
+  const parents = new Set;
+  for (const root of res.data ?? []) {
+    if (root.slug && (root.children?.length ?? 0) > 0)
+      parents.add(root.slug);
+    for (const c of [root, ...root.children ?? []]) {
+      if (!c.slug)
+        continue;
+      bySlug.set(c.slug, { id: c.id, type: c.type });
+      byId.set(c.id, { slug: c.slug, type: c.type });
     }
-  }, async (body) => {
-    const data = await client.post("/api/recurring", body);
-    return { content: [{ type: "text", text: JSON.stringify(data) }] };
-  });
+  }
+  return { bySlug, byId, parents };
 }
-
-// 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) }] };
-  });
+function requireCategory(index, slug) {
+  const hit = index.bySlug.get(slug);
+  if (!hit) {
+    throw new Error(`Unknown categorySlug "${slug}". Valid: ${[...index.bySlug.keys()].sort().join(", ")}`);
+  }
+  return { ...hit, slug };
 }
 
-// src/tools/transactions.ts
-import { readFile } from "node:fs/promises";
-
 // ../reconciliation/src/aliases.ts
 var MERCHANT_ALIASES = [
   ["Swiggy", ["swiggy", "bundl technologies", "swiggy bundl"]],
@@ -43469,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 : {};
@@ -43520,9 +43963,9 @@ var i = function() {
       return _has(u, e3);
     };
   }, SequenceMatcher.prototype.findLongestMatch = function(e2, t2, r2, n2) {
-    var o2, a2, i2, s, c, u, l, f, p, h, v, _, d, y, g, m, b, k, j, $, w;
+    var o2, a2, i2, s, c, u, l, f, p, h, v, _, d, y, g2, m, b, k, j, $, w;
     for (o2 = (m = [this.a, this.b, this.b2j, this.isbjunk])[0], a2 = m[1], i2 = m[2], f = m[3], s = (b = [e2, r2, 0])[0], c = b[1], u = b[2], h = {}, l = d = e2;e2 <= t2 ? d < t2 : d > t2; l = e2 <= t2 ? ++d : --d) {
-      for (_ = {}, y = 0, g = (k = _has(i2, o2[l]) ? i2[o2[l]] : []).length;y < g; y++)
+      for (_ = {}, y = 0, g2 = (k = _has(i2, o2[l]) ? i2[o2[l]] : []).length;y < g2; y++)
         if (!((p = k[y]) < r2)) {
           if (p >= n2)
             break;
@@ -43540,11 +43983,11 @@ var i = function() {
       u++;
     return [s, c, u];
   }, SequenceMatcher.prototype.getMatchingBlocks = function() {
-    var e2, t2, r2, n2, o2, a2, i2, s, c, u, l, f, p, h, v, _, d, y, g, m, b, k, j, $, w, O;
+    var e2, t2, r2, n2, o2, a2, i2, s, c, u, l, f, p, h, v, _, d, y, g2, m, b, k, j, $, w, O;
     if (this.matchingBlocks)
       return this.matchingBlocks;
     for (y = [[0, h = (k = [this.a.length, this.b.length])[0], 0, v = k[1]]], _ = [];y.length; )
-      t2 = (j = y.pop())[0], e2 = j[1], n2 = j[2], r2 = j[3], o2 = ($ = g = this.findLongestMatch(t2, e2, n2, r2))[0], s = $[1], (l = $[2]) && (_.push(g), t2 < o2 && n2 < s && y.push([t2, o2, n2, s]), o2 + l < e2 && s + l < r2 && y.push([o2 + l, e2, s + l, r2]));
+      t2 = (j = y.pop())[0], e2 = j[1], n2 = j[2], r2 = j[3], o2 = ($ = g2 = this.findLongestMatch(t2, e2, n2, r2))[0], s = $[1], (l = $[2]) && (_.push(g2), t2 < o2 && n2 < s && y.push([t2, o2, n2, s]), o2 + l < e2 && s + l < r2 && y.push([o2 + l, e2, s + l, r2]));
     for (_.sort(_arrayCmp), a2 = c = f = 0, d = [], m = 0, b = _.length;m < b; m++)
       i2 = (w = _[m])[0], u = w[1], p = w[2], a2 + f === i2 && c + f === u ? f += p : (f && d.push([a2, c, f]), a2 = (O = [i2, u, p])[0], c = O[1], f = O[2]);
     return f && d.push([a2, c, f]), d.push([h, v, 0]), this.matchingBlocks = d;
@@ -43692,11 +44135,11 @@ var v = p || h || Function("return this")();
 var _ = v.Symbol;
 var d = _;
 var y = Object.prototype;
-var g = y.hasOwnProperty;
+var g2 = y.hasOwnProperty;
 var m = y.toString;
 var b = d ? d.toStringTag : undefined;
 var k = function getRawTag$1(e2) {
-  var t2 = g.call(e2, b), r2 = e2[b];
+  var t2 = g2.call(e2, b), r2 = e2[b];
   try {
     e2[b] = undefined;
     var n2 = true;
@@ -44283,8 +44726,8 @@ var Xr = function equalObjects$1(e2, t2, r2, n2, o2, a2) {
     v2 || (v2 = l2 == "constructor");
   }
   if (h2 && !v2) {
-    var g2 = e2.constructor, m2 = t2.constructor;
-    g2 == m2 || !("constructor" in e2) || !("constructor" in t2) || typeof g2 == "function" && g2 instanceof g2 && typeof m2 == "function" && m2 instanceof m2 || (h2 = false);
+    var g3 = e2.constructor, m2 = t2.constructor;
+    g3 == m2 || !("constructor" in e2) || !("constructor" in t2) || typeof g3 == "function" && g3 instanceof g3 && typeof m2 == "function" && m2 instanceof m2 || (h2 = false);
   }
   return a2.delete(e2), a2.delete(t2), h2;
 };
@@ -44654,15 +45097,15 @@ var qo = function leven2(e2, t2, r2, n2) {
         return 0;
     } else
       f2 = (l2 = r2.wildcards[0].toLowerCase()).charCodeAt(0);
-    for (var y2 = 0, g2 = 0;y2 < c2; )
+    for (var y2 = 0, g3 = 0;y2 < c2; )
       a2[y2] = e2.charCodeAt(y2), o2[y2] = ++y2;
     if (i2)
-      for (;g2 < u2; )
-        for (p2 = t2.charCodeAt(g2), v2 = g2++, h2 = g2, y2 = 0;y2 < c2; y2++)
+      for (;g3 < u2; )
+        for (p2 = t2.charCodeAt(g3), v2 = g3++, h2 = g3, y2 = 0;y2 < c2; y2++)
           _2 = Io.compare(String.fromCharCode(p2), String.fromCharCode(a2[y2])) === 0 || p2 === f2 || a2[y2] === f2 ? v2 : v2 + s2, v2 = o2[y2], h2 = o2[y2] = v2 > h2 ? _2 > h2 ? h2 + 1 : _2 : _2 > v2 ? v2 + 1 : _2;
     else
-      for (;g2 < u2; )
-        for (p2 = t2.charCodeAt(g2), v2 = g2++, h2 = g2, y2 = 0;y2 < c2; y2++)
+      for (;g3 < u2; )
+        for (p2 = t2.charCodeAt(g3), v2 = g3++, h2 = g3, y2 = 0;y2 < c2; y2++)
           _2 = p2 === a2[y2] || p2 === f2 || a2[y2] === f2 ? v2 : v2 + s2, v2 = o2[y2], h2 = o2[y2] = v2 > h2 ? _2 > h2 ? h2 + 1 : _2 : _2 > v2 ? v2 + 1 : _2;
     return h2;
   }
@@ -44867,7 +45310,7 @@ var Lo = { exports: {} };
     }, n3.isCustomFunc = function(e4) {
       return typeof e4 != "function" || e4.name !== "token_set_ratio" && e4.name !== "partial_token_set_ratio" && e4.name !== "token_sort_ratio" && e4.name !== "partial_token_sort_ratio" && e4.name !== "QRatio" && e4.name !== "WRatio" && e4.name !== "distance" && e4.name !== "partial_ratio";
     }, n3;
-  }(Mo._uniq, Mo._uniqWith, l2), y2 = d2.validate, g2 = d2.process_and_sort, m2 = d2.tokenize, b2 = d2.full_process, k2 = d2.clone_and_set_option_defaults, j2 = d2.isCustomFunc, $2 = Lo.exports(k2, p2, QRatio, extract).dedupe;
+  }(Mo._uniq, Mo._uniqWith, l2), y2 = d2.validate, g3 = d2.process_and_sort, m2 = d2.tokenize, b2 = d2.full_process, k2 = d2.clone_and_set_option_defaults, j2 = d2.isCustomFunc, $2 = Lo.exports(k2, p2, QRatio, extract).dedupe;
   function QRatio(e3, t3, r2) {
     var n3 = k2(r2);
     return e3 = n3.normalize ? e3.normalize() : e3, t3 = n3.normalize ? t3.normalize() : t3, e3 = n3.full_process ? b2(e3, n3) : e3, t3 = n3.full_process ? b2(t3, n3) : t3, y2(e3) && y2(t3) ? _ratio(e3, t3, n3) : 0;
@@ -44882,11 +45325,11 @@ var Lo = { exports: {} };
   }
   function token_sort_ratio(e3, t3, r2) {
     var n3 = k2(r2);
-    return e3 = n3.normalize ? e3.normalize() : e3, t3 = n3.normalize ? t3.normalize() : t3, e3 = n3.full_process ? b2(e3, n3) : e3, t3 = n3.full_process ? b2(t3, n3) : t3, y2(e3) && y2(t3) ? (n3.proc_sorted || (e3 = g2(e3), t3 = g2(t3)), _ratio(e3, t3, n3)) : 0;
+    return e3 = n3.normalize ? e3.normalize() : e3, t3 = n3.normalize ? t3.normalize() : t3, e3 = n3.full_process ? b2(e3, n3) : e3, t3 = n3.full_process ? b2(t3, n3) : t3, y2(e3) && y2(t3) ? (n3.proc_sorted || (e3 = g3(e3), t3 = g3(t3)), _ratio(e3, t3, n3)) : 0;
   }
   function partial_token_sort_ratio(e3, t3, r2) {
     var n3 = k2(r2);
-    return e3 = n3.normalize ? e3.normalize() : e3, t3 = n3.normalize ? t3.normalize() : t3, e3 = n3.full_process ? b2(e3, n3) : e3, t3 = n3.full_process ? b2(t3, n3) : t3, y2(e3) && y2(t3) ? (n3.partial = true, n3.proc_sorted || (e3 = g2(e3), t3 = g2(t3)), _partial_ratio(e3, t3, n3)) : 0;
+    return e3 = n3.normalize ? e3.normalize() : e3, t3 = n3.normalize ? t3.normalize() : t3, e3 = n3.full_process ? b2(e3, n3) : e3, t3 = n3.full_process ? b2(t3, n3) : t3, y2(e3) && y2(t3) ? (n3.partial = true, n3.proc_sorted || (e3 = g3(e3), t3 = g3(t3)), _partial_ratio(e3, t3, n3)) : 0;
   }
   function extract(e3, r2, n3) {
     var o3, a3 = k2(n3);
@@ -44916,7 +45359,7 @@ var Lo = { exports: {} };
     i2 || (a3.astral && a3.normalize && (a3.normalize = false, String.prototype.normalize ? (s3 = true, e3 = e3.normalize()) : typeof console !== undefined && console.warn("Normalization not supported in your environment")), e3 = pre_processor(e3, a3), a3.full_process = false, e3.length === 0 && typeof console !== undefined && console.warn("Processed query is empty string"));
     var c2, u3, l3, h3, v3 = [], _3 = false, d3 = false, y3 = false;
     if (a3.scorer.name === "token_sort_ratio" || a3.scorer.name === "partial_token_sort_ratio") {
-      var $3 = g2(e3);
+      var $3 = g3(e3);
       d3 = true;
     } else if (a3.scorer.name === "token_set_ratio" || a3.scorer.name === "partial_token_set_ratio") {
       var w3 = m2(e3, a3);
@@ -44931,7 +45374,7 @@ var Lo = { exports: {} };
     }, h3 = function(e4, t3) {
       return t3[1] - e4[1];
     }), f2(r2, function(t3, r3) {
-      a3.tokens = undefined, a3.proc_sorted = false, d3 ? (a3.proc_sorted = true, t3 && t3.proc_sorted ? u3 = t3.proc_sorted : (u3 = pre_processor(s3 ? a3.processor(t3).normalize() : a3.processor(t3), a3), u3 = g2(u3)), c2 = a3.scorer($3, u3, a3)) : y3 ? (u3 = "x", t3 && t3.tokens ? (a3.tokens = [w3, t3.tokens], a3.trySimple && (u3 = pre_processor(a3.processor(t3), a3))) : (u3 = pre_processor(s3 ? a3.processor(t3).normalize() : a3.processor(t3), a3), a3.tokens = [w3, m2(u3, a3)]), c2 = a3.scorer(e3, u3, a3)) : i2 ? (u3 = a3.processor(t3), c2 = a3.scorer(e3, u3, a3)) : (typeof (u3 = pre_processor(s3 ? a3.processor(t3).normalize() : a3.processor(t3), a3)) == "string" && u3.length !== 0 || (_3 = true), c2 = a3.scorer(e3, u3, a3)), c2 > a3.cutoff && (a3.returnObjects ? v3.push({ choice: t3, score: c2, key: r3 }) : v3.push([t3, c2, r3]));
+      a3.tokens = undefined, a3.proc_sorted = false, d3 ? (a3.proc_sorted = true, t3 && t3.proc_sorted ? u3 = t3.proc_sorted : (u3 = pre_processor(s3 ? a3.processor(t3).normalize() : a3.processor(t3), a3), u3 = g3(u3)), c2 = a3.scorer($3, u3, a3)) : y3 ? (u3 = "x", t3 && t3.tokens ? (a3.tokens = [w3, t3.tokens], a3.trySimple && (u3 = pre_processor(a3.processor(t3), a3))) : (u3 = pre_processor(s3 ? a3.processor(t3).normalize() : a3.processor(t3), a3), a3.tokens = [w3, m2(u3, a3)]), c2 = a3.scorer(e3, u3, a3)) : i2 ? (u3 = a3.processor(t3), c2 = a3.scorer(e3, u3, a3)) : (typeof (u3 = pre_processor(s3 ? a3.processor(t3).normalize() : a3.processor(t3), a3)) == "string" && u3.length !== 0 || (_3 = true), c2 = a3.scorer(e3, u3, a3)), c2 > a3.cutoff && (a3.returnObjects ? v3.push({ choice: t3, score: c2, key: r3 }) : v3.push([t3, c2, r3]));
     }), _3 && typeof console !== undefined && console.log("One or more choices were empty. (post-processing if applied)"), a3.limit && typeof a3.limit == "number" && a3.limit > 0 && a3.limit < o3 && !a3.unsorted ? v3 = t2.nlargest(v3, a3.limit, l3) : a3.unsorted || (v3 = v3.sort(h3)), v3;
   }
   function extractAsync(e3, r2, n3, o3) {
@@ -44967,7 +45410,7 @@ var Lo = { exports: {} };
       f3 || (s3.astral && s3.normalize && (s3.normalize = false, String.prototype.normalize ? (h3 = true, e3 = e3.normalize()) : typeof console !== undefined && console.warn("Normalization not supported in your environment")), e3 = pre_processor(e3, s3), s3.full_process = false, e3.length === 0 && typeof console !== undefined && console.warn("Processed query is empty string"));
       var v3, _3, d3, y3, $3, w3 = [], O3 = false, S3 = false, C2 = false;
       if (s3.scorer.name === "token_sort_ratio" || s3.scorer.name === "partial_token_sort_ratio") {
-        var z2 = g2(e3);
+        var z2 = g3(e3);
         S3 = true;
       } else if (s3.scorer.name === "token_set_ratio" || s3.scorer.name === "partial_token_set_ratio") {
         var A2 = m2(e3, s3);
@@ -44986,7 +45429,7 @@ var Lo = { exports: {} };
       l3 ? searchLoop(0) : searchLoop(x2[0], 0);
     }
     function searchLoop(n4, p3) {
-      (l3 || r2.hasOwnProperty(n4)) && (s3.tokens = undefined, s3.proc_sorted = false, S3 ? (s3.proc_sorted = true, r2[n4] && r2[n4].proc_sorted ? _3 = r2[n4].proc_sorted : (_3 = pre_processor(h3 ? s3.processor(r2[n4]).normalize() : s3.processor(r2[n4]), s3), _3 = g2(_3)), d3 = s3.scorer(z2, _3, s3)) : C2 ? (_3 = "x", r2[n4] && r2[n4].tokens ? (s3.tokens = [A2, r2[n4].tokens], s3.trySimple && (_3 = pre_processor(s3.processor(r2[n4]), s3))) : (_3 = pre_processor(h3 ? s3.processor(r2[n4]).normalize() : s3.processor(r2[n4]), s3), s3.tokens = [A2, m2(_3, s3)]), d3 = s3.scorer(e3, _3, s3)) : f3 ? (_3 = s3.processor(r2[n4]), d3 = s3.scorer(e3, _3, s3)) : (typeof (_3 = pre_processor(h3 ? s3.processor(r2[n4]).normalize() : s3.processor(r2[n4]), s3)) == "string" && _3.length !== 0 || (O3 = true), d3 = s3.scorer(e3, _3, s3)), v3 = l3 ? parseInt(n4) : n4, d3 > s3.cutoff && (s3.returnObjects ? w3.push({ choice: r2[n4], score: d3, key: v3 }) : w3.push([r2[n4], d3, v3]))), a3 && a3.signal.aborted === true ? o3(new Error("aborted")) : i2 && i2.canceled === true ? o3(new Error("canceled")) : l3 && n4 < r2.length - 1 ? n4 % c2 == 0 ? setImmediate(function() {
+      (l3 || r2.hasOwnProperty(n4)) && (s3.tokens = undefined, s3.proc_sorted = false, S3 ? (s3.proc_sorted = true, r2[n4] && r2[n4].proc_sorted ? _3 = r2[n4].proc_sorted : (_3 = pre_processor(h3 ? s3.processor(r2[n4]).normalize() : s3.processor(r2[n4]), s3), _3 = g3(_3)), d3 = s3.scorer(z2, _3, s3)) : C2 ? (_3 = "x", r2[n4] && r2[n4].tokens ? (s3.tokens = [A2, r2[n4].tokens], s3.trySimple && (_3 = pre_processor(s3.processor(r2[n4]), s3))) : (_3 = pre_processor(h3 ? s3.processor(r2[n4]).normalize() : s3.processor(r2[n4]), s3), s3.tokens = [A2, m2(_3, s3)]), d3 = s3.scorer(e3, _3, s3)) : f3 ? (_3 = s3.processor(r2[n4]), d3 = s3.scorer(e3, _3, s3)) : (typeof (_3 = pre_processor(h3 ? s3.processor(r2[n4]).normalize() : s3.processor(r2[n4]), s3)) == "string" && _3.length !== 0 || (O3 = true), d3 = s3.scorer(e3, _3, s3)), v3 = l3 ? parseInt(n4) : n4, d3 > s3.cutoff && (s3.returnObjects ? w3.push({ choice: r2[n4], score: d3, key: v3 }) : w3.push([r2[n4], d3, v3]))), a3 && a3.signal.aborted === true ? o3(new Error("aborted")) : i2 && i2.canceled === true ? o3(new Error("canceled")) : l3 && n4 < r2.length - 1 ? n4 % c2 == 0 ? setImmediate(function() {
         searchLoop(n4 + 1);
       }) : searchLoop(n4 + 1) : p3 < x2.length - 1 ? p3 % c2 == 0 ? setImmediate(function() {
         searchLoop(x2[p3 + 1], p3 + 1);
@@ -45072,11 +45515,11 @@ var Lo = { exports: {} };
       }, f3 = a2(n3, i2, wildCompare), p3 = u2(n3, i2, wildCompare), h3 = u2(i2, n3, wildCompare);
     else
       f3 = o2(n3, i2), p3 = s2(n3, i2), h3 = s2(i2, n3);
-    var d3 = f3.sort().join(" "), y3 = p3.sort(), g3 = h3.sort();
+    var d3 = f3.sort().join(" "), y3 = p3.sort(), g4 = h3.sort();
     if (r2.sortBySimilarity)
-      var b3 = _order_token_lists(e3, y3, t3, g3), k3 = b3[0], j3 = b3[1], $3 = k3.join(" "), w3 = _token_similarity_sort(k3, j3, r2).join(" ");
+      var b3 = _order_token_lists(e3, y3, t3, g4), k3 = b3[0], j3 = b3[1], $3 = k3.join(" "), w3 = _token_similarity_sort(k3, j3, r2).join(" ");
     else
-      $3 = y3.join(" "), w3 = g3.join(" ");
+      $3 = y3.join(" "), w3 = g4.join(" ");
     var O3 = d3 + " " + $3, S3 = d3 + " " + w3;
     d3 = d3.trim(), O3 = O3.trim(), S3 = S3.trim();
     var C2 = _ratio;
@@ -45161,7 +45604,7 @@ var Lo = { exports: {} };
     }
     var p3 = token_sort_ratio(e3, t3, n3) * a3, h3 = token_set_ratio(e3, t3, n3) * a3;
     return Math.round(Math.max(s3, p3, h3));
-  }, full_process: b2, extract, extractAsync, extractAsPromised: O2, process_and_sort: g2, unique_tokens: m2, dedupe: $2 };
+  }, full_process: b2, extract, extractAsync, extractAsPromised: O2, process_and_sort: g3, unique_tokens: m2, dedupe: $2 };
   r.exports = S2;
 }();
 var Ro = r.exports;
@@ -45185,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;
@@ -45329,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,
@@ -45405,20 +46019,344 @@ function settlementEnrichedData(description, type, source) {
     out.settlementCardLast4 = last4;
   return out;
 }
-// ../parsers/src/classify.ts
-var CORPORATE_TOKENS = [
-  "PVT",
-  "PRIVATE",
-  "LIMITED",
-  "LTD",
-  "LLP",
-  "INC",
-  "CORP",
-  "ENTERPRISES",
-  "TECHNOLOGIES",
-  "SOLUTIONS",
-  "SERVICES"
-];
+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;
+function chunkLinks(links) {
+  const batches = [];
+  let cur = [];
+  let targets = new Set;
+  for (const l2 of links) {
+    const key = `${l2.merchantId ?? ""}|${l2.personId ?? ""}|${l2.categoryId ?? ""}`;
+    if (cur.length >= MAX_LINKS || !targets.has(key) && targets.size >= MAX_TARGETS) {
+      batches.push(cur);
+      cur = [];
+      targets = new Set;
+    }
+    cur.push(l2);
+    targets.add(key);
+  }
+  if (cur.length)
+    batches.push(cur);
+  return batches;
+}
+async function postLinks(client, links) {
+  for (const batch of chunkLinks(links)) {
+    await client.post("/api/transactions/bulk-link-entity", { links: batch });
+  }
+}
+
+// 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;
+}
+// ../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 result;
+}
+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);
+    }
+  }
+  return [...buckets.values()].map((row) => row.sort((a2, b2) => a2.x - b2.x).map((c2) => c2.str).join(" "));
+}
+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;
+    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 transactions;
+}
+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 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")}`;
+}
+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);
+}
+// ../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")
@@ -45438,6 +46376,17 @@ function classifyEntity({ paymentMethod, extractedName }) {
     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();
@@ -45626,6 +46575,796 @@ function parseSbiNarration(narration) {
   }
   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
+      });
+    }
+  }
+  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;
+      }
+    }
+    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)
+      });
+    }
+  }
+  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));
+      }
+    }
+  }
+  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;
+      }
+    }
+    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));
+}
+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
+      });
+    }
+  }
+  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 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(" "));
+}
+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 });
+    }
+  }
+  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 (bestKey) {
+      const bucket = buckets.get(bestKey);
+      if (bucket)
+        bucket.narrationParts.push(item.str);
+    }
+  }
+  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;
+      }
+    }
+    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));
+}
+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 {
+    date: date4,
+    description: narration,
+    amount,
+    type,
+    referenceNumber,
+    valueDate,
+    closingBalance,
+    paymentMethod: parsed.paymentMethod,
+    extractedName: parsed.name,
+    upiId: parsed.upiId,
+    sourceCategory: 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 parseAmount4(raw) {
+  if (!raw)
+    return 0;
+  const cleaned = raw.replace(/,/g, "").trim();
+  const num = parseFloat(cleaned);
+  return Number.isNaN(num) ? 0 : Math.abs(num);
+}
+// 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
+  };
+}
+async function fetchAllRows(client, crypto3, params = {}, maxPages = 100) {
+  return (await fetchAllRowsPaged(client, crypto3, params, maxPages)).rows;
+}
+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 {
+    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 } : {}
+  };
+}
+
 // src/lib/person-backfill.ts
 function normalizePersonName(name) {
   return name.toLowerCase().trim().replace(/\s+/g, " ");
@@ -45640,141 +47379,792 @@ async function loadDecryptedPersons(client, crypto3) {
         name = (await decryptPersonCipher(p2.cipher, crypto3.key)).name;
       } catch {}
     }
-    if (name)
-      persons.push({ id: p2.id, name });
-  }
-  return persons;
+    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 {
+    name: hdfc.name || sbi.name,
+    upiId: hdfc.upiId ?? sbi.upiId,
+    paymentMethod: hdfc.paymentMethod ?? sbi.paymentMethod
+  };
+}
+function isPersonLikeNarration(description) {
+  const { name, paymentMethod } = parseNarration(description);
+  return classifyEntity({ paymentMethod, extractedName: name }) !== "merchant";
+}
+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);
+  }
+  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 = 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 (!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 {
+    dryRun: !!opts.dryRun,
+    truncated,
+    candidatesScanned: candidates.length,
+    created,
+    reused,
+    linked: links.length,
+    plan
+  };
+}
+
+// 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) }] };
+  });
+}
+
+// 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) }] };
+  });
 }
-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 g2 = groups.get(norm) ?? {
-      displayName: name.trim(),
-      upiHandles: new Set,
-      txnIds: []
-    };
-    if (upiId)
-      g2.upiHandles.add(upiId);
-    g2.txnIds.push(t2.id);
-    groups.set(norm, g2);
-  }
-  const plan = [];
-  const newGroups = [];
-  let reused = 0;
-  for (const [norm, g2] of groups) {
-    const upiHandles = [...g2.upiHandles];
-    const isReuse = personIdByNorm.has(norm);
-    plan.push({
-      name: g2.displayName,
-      normalized: norm,
-      txnCount: g2.txnIds.length,
-      upiHandles,
-      action: isReuse ? "reuse" : "create"
-    });
-    if (isReuse)
-      reused++;
-    else
-      newGroups.push({ norm, displayName: g2.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, g2] of groups) {
-      const personId = personIdByNorm.get(norm);
-      if (!personId)
-        continue;
-      for (const txnId of g2.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}`;
 }
@@ -45788,31 +48178,23 @@ function flagBatchDuplicates(txns) {
     return false;
   });
 }
+var fileRowsSchema = exports_external.array(exports_external.object({
+  date: exports_external.string().regex(/^\d{4}-\d{2}-\d{2}$/, "must be YYYY-MM-DD"),
+  amount: exports_external.number().positive(),
+  type: exports_external.enum(["debit", "credit"]),
+  description: exports_external.string(),
+  referenceNumber: exports_external.string().optional()
+}));
 async function importTransactions(client, crypto3, opts) {
   let txns = opts.txns;
   let duplicatesSkipped = 0;
   if (txns.length > 0) {
     const dates = txns.map((t2) => t2.date).sort();
-    const existing = [];
-    let cursor;
-    for (let page = 0;page < 100; page++) {
-      const params = {
-        limit: 200,
-        startDate: dates[0],
-        endDate: dates[dates.length - 1]
-      };
-      if (cursor)
-        params.cursor = cursor;
-      const res = await client.get("/api/transactions", params);
-      const batch = res.data ?? [];
-      if (crypto3)
-        await decryptTransactionFields(batch, crypto3.key);
-      existing.push(...batch);
-      if (!res.hasMore || !res.nextCursor || batch.length === 0)
-        break;
-      cursor = res.nextCursor;
-    }
-    const seen = new Set(existing.map((r2) => dedupeKey(String(r2.date), String(r2.description ?? ""), Number(r2.amount), String(r2.type))));
+    const existing = await fetchAllRows(client, crypto3, {
+      startDate: dates[0],
+      endDate: dates[dates.length - 1]
+    });
+    const seen = new Set(existing.map((r2) => dedupeKey(r2.date, r2.description, r2.amount, r2.type)));
     const before = txns.length;
     txns = txns.filter((t2) => !seen.has(dedupeKey(t2.date, t2.description ?? "", t2.amount, t2.type)));
     duplicatesSkipped = before - txns.length;
@@ -45840,16 +48222,9 @@ async function importTransactions(client, crypto3, opts) {
   return { imported, duplicatesSkipped, duplicatesFlagged };
 }
 async function runRescan(client, crypto3) {
-  const EMPTY_BAG2 = {
-    merchantAliases: [],
-    personAliases: [],
-    merchantRules: {},
-    personRules: {}
-  };
-  let bag = EMPTY_BAG2;
+  let bag = structuredClone(EMPTY_BAG);
   try {
-    const learningRes = await client.get("/api/household-learning");
-    bag = learningRes.data?.bag ?? EMPTY_BAG2;
+    bag = (await loadBag(client)).bag;
   } catch {}
   const merchantsRes = await client.get("/api/merchants");
   const allMerchants = merchantsRes.data ?? [];
@@ -45859,23 +48234,8 @@ async function runRescan(client, crypto3) {
   const localMerchants = allMerchants.filter((m2) => m2.householdId && m2.cleanName).map((m2) => ({ id: m2.id, name: m2.cleanName }));
   const merchantCategoryById = new Map(allMerchants.filter((m2) => m2.categoryId).map((m2) => [m2.id, m2.categoryId]));
   const persons = await loadDecryptedPersons(client, crypto3);
-  const allRows = [];
-  const limit = 200;
-  let cursor;
-  const MAX_PAGES = 100;
-  for (let page = 0;page < MAX_PAGES; page++) {
-    const params = { limit };
-    if (cursor)
-      params.cursor = cursor;
-    const res = await client.get("/api/transactions", params);
-    const rows = res.data ?? [];
-    if (crypto3)
-      await decryptTransactionFields(rows, crypto3.key);
-    allRows.push(...rows);
-    if (!res.hasMore || !res.nextCursor || rows.length === 0)
-      break;
-    cursor = res.nextCursor;
-  }
+  const allRows = await fetchAllRows(client, crypto3, { unresolved: "true" });
+  const categoryByTxn = new Map(allRows.map((r2) => [r2.id, r2.categoryId]));
   const plan = autoCategorizeFromDescriptions({
     rows: allRows,
     bag,
@@ -45886,25 +48246,23 @@ async function runRescan(client, crypto3) {
   let categorized = 0;
   const links = plan.suggestions.flatMap((s2) => {
     const categoryId = s2.categoryId ?? (s2.entity.type === "merchant" ? merchantCategoryById.get(s2.entity.merchantId) ?? null : null);
-    if (categoryId)
-      categorized += s2.transactionIds.length;
-    return s2.transactionIds.map((txId) => ({
-      transactionId: txId,
-      ...s2.entity.type === "merchant" ? { merchantId: s2.entity.merchantId } : { personId: s2.entity.personId },
-      ...categoryId ? { categoryId } : {}
-    }));
+    return s2.transactionIds.map((txId) => {
+      const applyCategory = categoryId && !categoryByTxn.get(txId);
+      if (applyCategory)
+        categorized += 1;
+      return {
+        transactionId: txId,
+        ...s2.entity.type === "merchant" ? { merchantId: s2.entity.merchantId } : { personId: s2.entity.personId },
+        ...applyCategory ? { categoryId } : {}
+      };
+    });
   });
-  if (links.length > 0) {
-    const CHUNK = 500;
-    for (let i2 = 0;i2 < links.length; i2 += CHUNK) {
-      await client.post("/api/transactions/bulk-link-entity", { links: links.slice(i2, i2 + CHUNK) });
-    }
-  }
+  await postLinks(client, links);
   return { linked: links.length, categorized, unresolved: plan.unresolvedCount };
 }
 function registerTransactionTools(server, client, crypto3) {
   server.registerTool("get_transactions", {
-    description: "Search and filter transactions. Returns paginated results with merchant and category details. To find everything paid to a specific counterparty, pass `personName` (resolved to a person via the household's persons list) or `personId` directly — this is an indexed lookup, not a description scan. Note: free-text `search` only matches plaintext merchant names, not encrypted descriptions.",
+    description: "Search/filter transactions. Returns COMPACT rows {id,date,amt,t:'dr'|'cr',desc,cat,merchant,person,flags} " + "(default 25, max 100) plus `more`/`cursor` for the next page and, on page 1, `spent`/`income` totals over the whole filter. " + "To find everything paid to a counterparty pass `personName` or `personId` (indexed). " + "Free-text `search` only matches plaintext merchant names, not encrypted descriptions. " + "Pass `full: true` for the raw joined rows (much larger — avoid unless needed).",
     inputSchema: {
       search: exports_external.string().optional().describe("Search merchant name (NOT encrypted descriptions)"),
       personId: exports_external.string().optional().describe("Filter to one person (exact, indexed)"),
@@ -45914,69 +48272,126 @@ 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)"),
-      limit: exports_external.number().optional().describe("Max results (default 50, max 200)"),
-      cursor: exports_external.string().optional().describe("Opaque cursor from a prior page's nextCursor")
+      limit: exports_external.number().optional().describe("Max results (default 25, max 100)"),
+      cursor: exports_external.string().optional().describe("Opaque cursor from a prior page's `cursor`"),
+      full: exports_external.boolean().optional().describe("Return raw joined rows instead of compact rows")
     }
   }, async (params) => {
-    const { personName, categorySlug, ...rest } = params;
+    const { personName, categorySlug, full, limit, ...rest } = params;
     const apiParams = { ...rest };
     if (apiParams.uncategorized !== true)
       delete apiParams.uncategorized;
     if (categorySlug) {
-      const cats = await client.get("/api/categories");
-      const all2 = cats.data.flatMap((c2) => [c2, ...c2.children ?? []]);
-      const match = all2.find((c2) => c2.slug === categorySlug);
-      if (match)
-        apiParams.categoryId = match.id;
+      apiParams.categoryId = requireCategory(await loadCategoryIndex(client), categorySlug).id;
     }
     if (personName && !apiParams.personId) {
       const persons = await loadDecryptedPersons(client, crypto3);
       const match = resolvePersonByName(persons, personName);
+      const err = (error2) => ({
+        content: [{ type: "text", text: JSON.stringify({ error: error2 }) }]
+      });
       if (!match) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({
-                error: `No person matches "${personName}". Use list_persons to see known counterparties, or run backfill_persons if persons haven't been extracted yet.`
-              })
-            }
-          ]
-        };
+        return err(`No person matches "${personName}". Use list_persons to see known counterparties, or run backfill_persons if persons haven't been extracted yet.`);
       }
       if ("candidates" in match) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({
-                error: `Ambiguous person "${personName}". Candidates: ${match.candidates.join(", ")}. Re-run with an exact name or personId.`
-              })
-            }
-          ]
-        };
+        return err(`Ambiguous person "${personName}". Candidates: ${match.candidates.join(", ")}. Re-run with an exact name or personId.`);
       }
       apiParams.personId = match.personId;
     }
+    apiParams.limit = Math.min(Math.max(limit ?? 25, 1), full ? 200 : 100);
+    if (!full)
+      apiParams.view = "lean";
     const data = await client.get("/api/transactions", Object.fromEntries(Object.entries(apiParams).filter(([, v2]) => v2 !== undefined).map(([k2, v2]) => [k2, String(v2)])));
-    if (crypto3 && data.data) {
-      await decryptTransactionFields(data.data, crypto3.key);
-      if (data.data.some((r2) => r2.personId)) {
-        const persons = await loadDecryptedPersons(client, crypto3);
-        const nameById = new Map(persons.map((p2) => [p2.id, p2.name]));
-        for (const r2 of data.data) {
-          const person = r2.person;
-          if (person && nameById.has(person.id))
-            person.name = nameById.get(person.id);
-        }
-      }
-    }
-    return { content: [{ type: "text", text: JSON.stringify(data) }] };
+    const rows = data.data ?? [];
+    if (crypto3)
+      await decryptTransactionFields(rows, crypto3.key);
+    const personNames = new Map;
+    if (rows.some((r2) => r2.personId)) {
+      for (const p2 of await loadDecryptedPersons(client, crypto3))
+        personNames.set(p2.id, p2.name);
+    }
+    if (full) {
+      for (const r2 of rows) {
+        const person = r2.person;
+        if (person && personNames.has(person.id))
+          person.name = personNames.get(person.id) ?? "";
+      }
+      return { content: [{ type: "text", text: JSON.stringify(data) }] };
+    }
+    const out = {
+      rows: rows.map((r2) => toLeanRow(r2, personNames)),
+      ...data.hasMore ? { more: true, cursor: data.nextCursor } : {},
+      ...data.summary ? { spent: data.summary.spent, income: data.summary.income } : {}
+    };
+    return { content: [{ type: "text", text: JSON.stringify(out) }] };
+  });
+  server.registerTool("get_uncategorized_groups", {
+    description: "Token-cheap way to categorize: groups still-uncategorized transactions by merchant-like pattern " + "(descriptions are decrypted locally in private mode) and returns only " + "{pattern,t:'dr'|'cr',n,total,sample} per group, biggest ₹ first — never individual rows. " + "Then call `categorize_groups` with a category per pattern. Skip tiny groups via `minTotal`.",
+    inputSchema: {
+      startDate: exports_external.string().optional().describe("YYYY-MM-DD"),
+      endDate: exports_external.string().optional().describe("YYYY-MM-DD"),
+      minTotal: exports_external.number().optional().describe("Hide groups whose total ₹ is below this"),
+      limit: exports_external.number().optional().describe("Max groups (default 40, max 100)")
+    }
+  }, async ({ startDate, endDate, minTotal, limit }) => {
+    const rows = await fetchUncategorized(client, crypto3, { startDate, endDate });
+    const all2 = groupRows(rows);
+    const shown = all2.filter((g3) => g3.total >= (minTotal ?? 0)).slice(0, Math.min(Math.max(limit ?? 40, 1), 100));
+    const shownRows = shown.reduce((n2, g3) => n2 + g3.rows.length, 0);
+    const out = {
+      groups: shown.map((g3) => ({
+        pattern: g3.pattern,
+        t: g3.type === "credit" ? "cr" : "dr",
+        n: g3.rows.length,
+        total: Math.round(g3.total),
+        sample: g3.rows[0].description.slice(0, 50)
+      })),
+      rows: rows.length,
+      groupsTotal: all2.length,
+      rowsCovered: shownRows
+    };
+    return { content: [{ type: "text", text: JSON.stringify(out) }] };
+  });
+  server.registerTool("categorize_groups", {
+    description: "Assign a category to whole groups from `get_uncategorized_groups` in ONE call. " + "For each pattern it categorizes every matching uncategorized transaction and saves a learning rule " + "(merchant + alias + category) so future imports auto-categorize it. " + "Unknown categorySlug fails before any write. Use dryRun to preview.",
+    inputSchema: {
+      assignments: exports_external.array(exports_external.object({
+        pattern: exports_external.string().describe("Group pattern exactly as returned"),
+        type: exports_external.enum(["debit", "credit"]).optional().describe("Limit to debits or credits"),
+        categorySlug: exports_external.string().describe("Category slug (see list_categories)"),
+        learn: exports_external.boolean().optional().describe("false = don't save a reusable rule (use for short/generic patterns)")
+      })).min(1).max(100),
+      startDate: exports_external.string().optional().describe("Same range used when listing groups"),
+      endDate: exports_external.string().optional(),
+      dryRun: exports_external.boolean().optional()
+    }
+  }, async ({ assignments, startDate, endDate, dryRun }) => {
+    const result = await applyGroupAssignments(client, crypto3, assignments, {
+      dryRun,
+      startDate,
+      endDate
+    });
+    return { content: [{ type: "text", text: JSON.stringify(result) }] };
   });
   server.registerTool("backfill_persons", {
     description: "Extract UPI/IMPS counterparties from unlinked transactions, create person records for them (deduped by name), and link transactions via personId — so you can later filter all payments to a person. Idempotent: re-running reuses existing persons and skips already-linked rows. Pass dryRun to preview without writing.",
@@ -46005,13 +48420,9 @@ function registerTransactionTools(server, client, crypto3) {
     if (crypto3 && body.notes)
       body.notes = await encryptField(body.notes, crypto3.key);
     if (body.categorySlug) {
-      const cats = await client.get("/api/categories");
-      const allCats = cats.data.flatMap((c2) => [c2, ...c2.children ?? []]);
-      const cat = allCats.find((c2) => c2.slug === body.categorySlug);
-      if (cat) {
-        body.categoryId = cat.id;
-        body.categoryType = cat.type;
-      }
+      const cat = requireCategory(await loadCategoryIndex(client), body.categorySlug);
+      body.categoryId = cat.id;
+      body.categoryType = cat.type;
       delete body.categorySlug;
     }
     const data = await client.patch(`/api/transactions/${id}`, body);
@@ -46041,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,
@@ -46050,8 +48467,8 @@ function registerTransactionTools(server, client, crypto3) {
     }
     if (action === "list") {
       const data2 = await client.get("/api/transactions/duplicates");
-      if (crypto3 && data2.duplicates)
-        await decryptTransactionFields(data2.duplicates, crypto3.key);
+      if (crypto3 && data2.data)
+        await decryptTransactionFields(data2.data, crypto3.key);
       return { content: [{ type: "text", text: JSON.stringify(data2) }] };
     }
     const data = await client.post("/api/transactions/duplicates/resolve", {
@@ -46080,7 +48497,7 @@ function registerTransactionTools(server, client, crypto3) {
       source: exports_external.enum(["bank_statement", "cc_statement", "manual", "telegram", "wisprflow", "ai_import"]).describe("Origin of the statement"),
       granularity: exports_external.number().int().min(1).max(5).describe("Source trust level: 1=bank statement, 2=CC statement, 3=manual, 4=app export, 5=telegram/AI"),
       transactions: exports_external.array(exports_external.object({
-        date: exports_external.string().describe("YYYY-MM-DD"),
+        date: exports_external.string().regex(/^\d{4}-\d{2}-\d{2}$/, "date must be YYYY-MM-DD"),
         amount: exports_external.number().positive(),
         type: exports_external.enum(["debit", "credit"]),
         description: exports_external.string(),
@@ -46119,7 +48536,12 @@ function registerTransactionTools(server, client, crypto3) {
       const parsed = JSON.parse(raw);
       if (!Array.isArray(parsed))
         throw new Error("File must contain a JSON array");
-      txns = parsed;
+      const result = fileRowsSchema.safeParse(parsed);
+      if (!result.success) {
+        const i2 = result.error.issues[0];
+        throw new Error(`row ${String(i2.path[0])}: ${i2.path.slice(1).join(".")} ${i2.message}`);
+      }
+      txns = result.data;
     } catch (e2) {
       throw new Error(`Failed to read/parse ${filePath}: ${e2 instanceof Error ? e2.message : String(e2)}`);
     }
@@ -46148,9 +48570,13 @@ function registerTransactionTools(server, client, crypto3) {
       })).min(1).max(500)
     }
   }, async ({ links }) => {
-    const catsRes = await client.get("/api/categories");
-    const allCats = catsRes.data.flatMap((c2) => [c2, ...c2.children ?? []]);
-    const typeById = new Map(allCats.map((c2) => [c2.id, c2.type]));
+    const catIndex = await loadCategoryIndex(client);
+    const typeById = new Map([...catIndex.byId].map(([id, c2]) => [id, c2.type]));
+    const unknown3 = [
+      ...new Set(links.map((l2) => l2.categoryId))
+    ].filter((id) => !typeById.has(id));
+    if (unknown3.length)
+      throw new Error(`Unknown categoryId(s): ${unknown3.join(", ")}`);
     const groups = new Map;
     for (const { transactionId, categoryId } of links) {
       const arr = groups.get(categoryId) ?? [];
@@ -46201,11 +48627,18 @@ function registerTransactionTools(server, client, crypto3) {
       }).optional().describe("Filter params — deletes all matching transactions (provide one of id / ids / filters)")
     }
   }, async ({ id, ids, filters }) => {
+    const given = [id, ids, filters].filter((v2) => v2 !== undefined).length;
+    if (given !== 1) {
+      throw new Error("Provide exactly one of id, ids, or filters");
+    }
+    if (filters && Object.values(filters).every((v2) => v2 === undefined)) {
+      throw new Error("filters is empty — refusing to delete every transaction");
+    }
     if (id) {
       const data2 = await client.delete(`/api/transactions/${id}`);
       return { content: [{ type: "text", text: JSON.stringify(data2) }] };
     }
-    const body = ids ? { ids } : { filters: filters ?? {} };
+    const body = ids ? { ids } : { filters };
     const data = await client.delete("/api/transactions/bulk", body);
     return { content: [{ type: "text", text: JSON.stringify(data) }] };
   });
@@ -46229,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) }] };
   });
 }
 
@@ -46253,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;
@@ -46263,55 +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);
-  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");
@@ -46321,5 +48924,5 @@ main().catch((err) => {
   process.exit(1);
 });
 
-//# debugId=1EEBC94B29D2067F64756E2164756E21
+//# debugId=BC4AFE8852AA4C8E64756E2164756E21
 //# sourceMappingURL=index.js.map