paisa-mcp 0.0.19 → 0.0.21

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");
@@ -42554,18 +42554,28 @@ function registerDebtTools(server, client) {
       dueDate: exports_external.string().optional().describe("YYYY-MM-DD"),
       notes: exports_external.string().optional()
     }
-  }, async (body) => {
-    const data = await client.post("/api/debts", body);
+  }, async ({ name, amount, type, dueDate, notes }) => {
+    const notesWithDue = dueDate ? [notes, `Due: ${dueDate}`].filter(Boolean).join(" — ") : notes;
+    const data = await client.post("/api/debts", {
+      name,
+      direction: type,
+      type: "other",
+      outstandingBalance: amount,
+      ...notesWithDue ? { notes: notesWithDue } : {}
+    });
     return { content: [{ type: "text", text: JSON.stringify(data) }] };
   });
   server.registerTool("settle_debt", {
-    description: "Mark a debt as settled.",
+    description: "Mark a debt as settled (soft-deactivates it; zeroes the balance).",
     inputSchema: {
       id: exports_external.string(),
       settledAmount: exports_external.string().optional().describe("Actual settled amount if different")
     }
-  }, async ({ id, ...body }) => {
-    const data = await client.patch(`/api/debts/${id}`, { ...body, isSettled: true });
+  }, async ({ id, settledAmount }) => {
+    const data = await client.patch(`/api/debts/${id}`, {
+      isActive: false,
+      outstandingBalance: settledAmount ?? "0"
+    });
     return { content: [{ type: "text", text: JSON.stringify(data) }] };
   });
 }
@@ -42763,7 +42773,7 @@ function registerHeatmapTools(server, client) {
   });
 }
 
-// src/tools/household-learning.ts
+// src/lib/learning-bag.ts
 var EMPTY_BAG = {
   merchantAliases: [],
   personAliases: [],
@@ -42777,12 +42787,11 @@ async function loadBag(client) {
   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.",
@@ -43016,309 +43025,630 @@ function registerInvestmentTools(server, client) {
   });
 }
 
-// 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);
-    }
+// ../../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;
   }
-  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.`);
+  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;
       }
-      payload.categoryId = categoryId;
-    }
-    const data = id ? await client.patch(`/api/merchants/${id}`, payload) : await client.post("/api/merchants", payload);
-    return { content: [{ type: "text", text: JSON.stringify(data) }] };
-  });
-  server.registerTool("list_merchants", {
-    description: "List merchants in the dictionary with their categories and transaction counts. Pass `rawId` to look up a single merchant by its raw ID (UPI ID or normalised name) instead of listing all.",
-    inputSchema: {
-      rawId: exports_external.string().optional().describe("Raw identifier to look up a single merchant; omit to list all")
+      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 ({ 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 }) }]
-      };
+  }
+  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);
     }
-    const data = rawId ? await client.get("/api/merchants", {
-      search: rawId
-    }) : await client.get("/api/merchants");
-    if (crypto3 && data.data)
-      await decryptMerchantFields(data.data, crypto3.key);
-    return { content: [{ type: "text", text: JSON.stringify(data) }] };
-  });
-  server.registerTool("delete_merchant", {
-    description: "Delete merchant(s) from the dictionary. Provide `id` for a single merchant or `ids` for several. Transactions referencing a deleted merchant have their merchantId cleared. PERMANENT.",
-    inputSchema: {
-      id: exports_external.string().optional().describe("Single merchant UUID"),
-      ids: exports_external.array(exports_external.string()).min(1).optional().describe("Multiple merchant UUIDs (bulk delete)")
+  }
+  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 });
     }
-  }, async ({ id, ids }) => {
-    if (!id && (!ids || ids.length === 0)) {
-      throw new Error("Provide either id or ids");
+  }
+};
+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;
     }
-    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) }] };
-  });
-}
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+};
 
-// 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()
-    }
-  }, 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
-      });
+// 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 });
     }
-    return { content: [{ type: "text", text: JSON.stringify(data) }] };
-  });
+  }
+  return { bySlug, byId, parents };
+}
+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/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) }] };
-  });
-}
-
-// src/tools/push.ts
-function registerPushTools(server, client) {
-  server.registerTool("list_push_subscriptions", {
-    description: "List the household's registered web-push subscriptions (browser/device endpoints that receive alert notifications).",
-    inputSchema: {}
-  }, async () => {
-    const data = await client.get("/api/push/subscriptions");
-    return { content: [{ type: "text", text: JSON.stringify(data) }] };
-  });
-  server.registerTool("send_test_push", {
-    description: "Send a test web-push notification to all of the household's subscriptions. Use to verify push delivery is working.",
-    inputSchema: {}
-  }, async () => {
-    const data = await client.post("/api/push/test");
-    return { content: [{ type: "text", text: JSON.stringify(data) }] };
-  });
-}
-
-// src/tools/recurring.ts
-function registerRecurringTools(server, client) {
-  server.registerTool("list_recurring", {
-    description: "List all recurring transactions (subscriptions, rent, salaries).",
-    inputSchema: {}
-  }, async () => {
-    const data = await client.get("/api/recurring");
-    return { content: [{ type: "text", text: JSON.stringify(data) }] };
-  });
-  server.registerTool("add_recurring", {
-    description: "Add a recurring transaction to track subscriptions or regular income.",
-    inputSchema: {
-      name: exports_external.string(),
-      amount: exports_external.string(),
-      type: exports_external.enum(["debit", "credit"]),
-      frequency: exports_external.enum(["daily", "weekly", "monthly", "yearly"]),
-      dayOfMonth: exports_external.number().optional().describe("For monthly — day of month (1-31)"),
-      categorySlug: exports_external.string().optional(),
-      owner: exports_external.string(),
-      startDate: exports_external.string().optional().describe("YYYY-MM-DD"),
-      notes: exports_external.string().optional()
-    }
-  }, async (body) => {
-    const data = await client.post("/api/recurring", body);
-    return { content: [{ type: "text", text: JSON.stringify(data) }] };
-  });
-}
-
-// src/tools/reports.ts
-function registerReportTools(server, client) {
-  server.registerTool("generate_monthly_report", {
-    description: "Generate a detailed monthly financial report. Computes income, expenses, savings rate, top categories, and insights. Persists to DB.",
-    inputSchema: {
-      month: exports_external.number().min(1).max(12),
-      year: exports_external.number().min(2020).max(2100)
-    }
-  }, async (body) => {
-    const data = await client.post("/api/reports", body);
-    return { content: [{ type: "text", text: JSON.stringify(data) }] };
-  });
-  server.registerTool("get_reports", {
-    description: "Monthly financial reports for the last N months — income, expenses, savings rate, net worth.",
-    inputSchema: {
-      months: exports_external.number().optional().describe("Number of months (default: 6)")
-    }
-  }, async (params) => {
-    const data = await client.get("/api/reports", params.months ? { months: params.months } : undefined);
-    return { content: [{ type: "text", text: JSON.stringify(data) }] };
-  });
-}
-
-// src/tools/transactions.ts
-import { readFile } from "node:fs/promises";
-
 // ../reconciliation/src/aliases.ts
 var MERCHANT_ALIASES = [
   ["Swiggy", ["swiggy", "bundl technologies", "swiggy bundl"]],
@@ -43510,9 +43840,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;
@@ -43530,11 +43860,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;
@@ -43682,11 +44012,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;
@@ -44273,8 +44603,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;
 };
@@ -44644,15 +44974,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;
   }
@@ -44857,7 +45187,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;
@@ -44872,11 +45202,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);
@@ -44906,7 +45236,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);
@@ -44921,7 +45251,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) {
@@ -44957,7 +45287,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);
@@ -44976,7 +45306,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);
@@ -45062,11 +45392,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;
@@ -45151,7 +45481,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;
@@ -45395,82 +45725,820 @@ 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"
-];
-var CORPORATE_REGEX = new RegExp(`\\b(${CORPORATE_TOKENS.join("|")})\\b`);
-function classifyEntity({ paymentMethod, extractedName }) {
-  if (paymentMethod === "atm")
-    return "merchant";
-  if (paymentMethod === "pos")
-    return "merchant";
-  const upper = (extractedName ?? "").toUpperCase();
-  if (upper && CORPORATE_REGEX.test(upper))
-    return "merchant";
-  if (paymentMethod === "imps")
-    return "person";
-  if (paymentMethod === "upi")
-    return "person";
-  if (paymentMethod === "neft" || paymentMethod === "rtgs")
-    return "merchant";
-  if (paymentMethod === "ach")
-    return "merchant";
-  return "unknown";
+// 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;
 }
-// ../parsers/src/hdfc/narration.ts
-function parseHdfcNarration(narration) {
-  const trimmed = narration.trim();
-  if (trimmed.startsWith("UPI-")) {
-    return parseUpi(trimmed);
+async function postLinks(client, links) {
+  for (const batch of chunkLinks(links)) {
+    await client.post("/api/transactions/bulk-link-entity", { links: batch });
   }
-  if (trimmed.startsWith("NEFT CR-") || trimmed.startsWith("NEFT DR-")) {
-    return parseNeft(trimmed);
+}
+
+// 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) {
+  const out = [];
+  let cursor;
+  for (let page = 0;page < maxPages; page++) {
+    const q2 = { ...params, limit: 200, view: "match" };
+    if (cursor)
+      q2.cursor = cursor;
+    const res = await client.get("/api/transactions", q2);
+    const batch = res.data ?? [];
+    if (crypto3)
+      await decryptTransactionFields(batch, crypto3.key);
+    out.push(...batch.map(toTxnRow));
+    if (!res.hasMore || !res.nextCursor || batch.length === 0 || res.nextCursor === cursor)
+      break;
+    cursor = res.nextCursor;
   }
-  if (trimmed.startsWith("ACH D-") || trimmed.startsWith("ACH C-")) {
-    return parseAch(trimmed);
+  return out;
+}
+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/categorize-groups.ts
+var NOISE = new Set([
+  "upi",
+  "pos",
+  "imps",
+  "neft",
+  "rtgs",
+  "ach",
+  "nach",
+  "ecs",
+  "txn",
+  "transaction",
+  "payment",
+  "paid",
+  "pay",
+  "to",
+  "from",
+  "ref",
+  "refno",
+  "debit",
+  "credit",
+  "card",
+  "mob",
+  "mobile",
+  "bank",
+  "transfer",
+  "trf",
+  "by",
+  "for",
+  "the",
+  "via",
+  "ecom",
+  "purchase",
+  "online",
+  "inr",
+  "rs",
+  "towards",
+  "ibl",
+  "ybl",
+  "oksbi",
+  "okhdfcbank",
+  "okicici",
+  "okaxis",
+  "axl",
+  "apl",
+  "paytm",
+  "icici",
+  "hdfc",
+  "sbi",
+  "axis",
+  "utib",
+  "sbin",
+  "ifsc",
+  "vpa",
+  "bill",
+  "cas",
+  "dr",
+  "cr"
+]);
+var GOOD_TOKEN = /^[a-z][a-z&']{2,}$/;
+var MAX_RUN = 3;
+function descriptionPattern(description) {
+  const tokens = normaliseName(description).split(" ").filter(Boolean);
+  const run = [];
+  for (const tok of tokens) {
+    const good = GOOD_TOKEN.test(tok) && !NOISE.has(tok);
+    if (!good) {
+      if (run.length)
+        break;
+      continue;
+    }
+    if (run.includes(tok))
+      break;
+    run.push(tok);
+    if (run.length === MAX_RUN)
+      break;
   }
-  if (trimmed.startsWith("FT-") || trimmed.startsWith("FT -")) {
-    return parseFt(trimmed);
+  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 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 (trimmed.startsWith("IMPS-") || trimmed.startsWith("IMPS/")) {
-    return parseImps(trimmed);
+  if (opts.dryRun) {
+    result.applied = plan.map((p2) => ({
+      pattern: p2.group.pattern,
+      type: p2.group.type,
+      rows: p2.group.rows.length,
+      category: p2.slug
+    }));
+    return result;
   }
-  if (trimmed.startsWith("ATW-") || trimmed.startsWith("ATM-") || trimmed.startsWith("ATM/")) {
-    return {
-      paymentMethod: "atm",
-      name: "ATM Withdrawal",
-      upiId: null,
-      referenceNumber: null,
-      description: trimmed
-    };
+  if (plan.length === 0)
+    return result;
+  const learnable = plan.filter((p2) => p2.learn && p2.group.pattern !== UNPARSED);
+  const merchantByRawId = new Map;
+  if (learnable.length > 0) {
+    const ms = await client.get("/api/merchants");
+    for (const m2 of ms.data ?? [])
+      if (m2.rawId && m2.householdId)
+        merchantByRawId.set(m2.rawId, m2.id);
+  }
+  const { bag, version: version2 } = await loadBag(client);
+  const now = new Date().toISOString();
+  const links = [];
+  const direct = [];
+  for (const { group, categoryId, slug, learn } of plan) {
+    result.applied.push({
+      pattern: group.pattern,
+      type: group.type,
+      rows: group.rows.length,
+      category: slug
+    });
+    if (!learn || group.pattern === UNPARSED) {
+      if (learn)
+        result.unlearnable.push(UNPARSED);
+      direct.push({ ids: group.rows.map((r2) => r2.id), categoryId });
+      continue;
+    }
+    const rawId = `pattern:${group.pattern}`;
+    let merchantId = merchantByRawId.get(rawId);
+    if (!merchantId) {
+      const created = await client.post("/api/merchants", {
+        rawId,
+        cleanName: titleCase(group.pattern),
+        categoryId
+      });
+      merchantId = created.data.id;
+      merchantByRawId.set(rawId, merchantId);
+    }
+    if (!bag.merchantAliases.some((al) => al.pattern === group.pattern)) {
+      bag.merchantAliases.push({ pattern: group.pattern, merchantId, createdAt: now });
+    }
+    bag.merchantRules[merchantId] = { categoryId, lastUserCategoryAt: now };
+    result.rulesSaved += 1;
+    const withPerson = group.rows.filter((r2) => r2.personId);
+    if (withPerson.length)
+      direct.push({ ids: withPerson.map((r2) => r2.id), categoryId });
+    for (const r2 of group.rows) {
+      if (!r2.personId)
+        links.push({ transactionId: r2.id, merchantId, categoryId });
+    }
+  }
+  if (result.rulesSaved > 0)
+    await saveBag(client, bag, version2);
+  await postLinks(client, links);
+  for (const { ids, categoryId } of direct) {
+    const categoryType = [...catIndex.byId.entries()].find(([id]) => id === categoryId)?.[1].type;
+    for (let i2 = 0;i2 < ids.length; i2 += 200) {
+      await client.patch("/api/transactions/bulk", {
+        ids: ids.slice(i2, i2 + 200),
+        categoryId,
+        ...categoryType ? { categoryType } : {}
+      });
+    }
   }
-  if (trimmed.startsWith("POS ")) {
-    return parsePos(trimmed);
+  return result;
+}
+
+// src/lib/jev-categorize.ts
+var JEV_MODEL = "jev-1.13.0";
+var DEFAULT_MIN_CONFIDENCE = 0.95;
+var TIMEOUT_MS = 8000;
+var CONCURRENCY = 8;
+var MIN_LEARN_PATTERN_LEN = 5;
+function assertPrivateModeAllowed(crypto3, env2 = process.env) {
+  if (crypto3 && env2.JEV_ALLOW_PRIVATE_MODE !== "1") {
+    throw new Error("Jev categorization is disabled in private mode: it would send transaction text to a third party. " + "To opt in for your own account, set JEV_ALLOW_PRIVATE_MODE=1 in the MCP's environment. " + "Otherwise use get_uncategorized_groups + categorize_groups.");
   }
-  return parseFallback(trimmed);
 }
-function parseUpi(narration) {
-  const rest = narration.slice(4);
-  const parts = rest.split("-");
-  if (parts.length < 4) {
-    return {
-      paymentMethod: "upi",
-      name: rest,
-      upiId: null,
-      referenceNumber: null,
-      description: null
-    };
+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 sanitizeNarration(s2) {
+  return s2.replace(/\d{3,}/g, " ").replace(/\s+/g, " ").trim();
+}
+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 mapLimit(items, limit, fn2) {
+  const out = new Array(items.length);
+  let next = 0;
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, async () => {
+    while (next < items.length) {
+      const i2 = next++;
+      out[i2] = await fn2(items[i2]);
+    }
+  }));
+  return out;
+}
+async function jevCategorize(client, crypto3, classify, opts = {}) {
+  assertPrivateModeAllowed(crypto3, opts.env);
+  const min = opts.minConfidence ?? DEFAULT_MIN_CONFIDENCE;
+  const index = await loadCategoryIndex(client);
+  const rows = await fetchUncategorized(client, crypto3, opts);
+  const groups = groupRows(rows);
+  const unparsed = groups.filter((g3) => g3.pattern === UNPARSED).length;
+  const candidates = groups.filter((g3) => g3.pattern !== UNPARSED);
+  let errors4 = 0;
+  const suggestions = await mapLimit(candidates, CONCURRENCY, async (g3) => {
+    try {
+      const options = optionsFor(g3.type, index);
+      const sample = g3.rows[0].description;
+      const text = crypto3 ? sanitizeNarration(sample) : sample;
+      const r2 = await classify(groupState(g3.type, text), options);
+      return r2.choice in options ? { g: g3, ...r2 } : null;
+    } catch {
+      errors4 += 1;
+      return null;
+    }
+  });
+  const accepted = [];
+  const review = [];
+  for (const s2 of suggestions) {
+    if (!s2)
+      continue;
+    const isTransfer = index.bySlug.get(s2.choice)?.type === "transfer";
+    if (s2.choice !== UNSURE && !isTransfer && s2.confidence >= min) {
+      accepted.push({
+        pattern: s2.g.pattern,
+        type: s2.g.type,
+        categorySlug: s2.choice,
+        learn: s2.g.pattern.length >= MIN_LEARN_PATTERN_LEN,
+        confidence: s2.confidence
+      });
+    } else {
+      review.push({
+        pattern: s2.g.pattern,
+        type: s2.g.type === "credit" ? "cr" : "dr",
+        best: s2.choice,
+        confidence: Math.round(s2.confidence * 100) / 100,
+        total: Math.round(s2.g.total)
+      });
+    }
+  }
+  review.sort((a2, b2) => b2.total - a2.total);
+  const applied = await applyGroupAssignments(client, crypto3, accepted.map(({ confidence: _c, ...a2 }) => a2), { dryRun: opts.dryRun, startDate: opts.startDate, endDate: opts.endDate });
+  const conf = new Map(accepted.map((a2) => [`${a2.pattern}|${a2.type}`, a2.confidence]));
+  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 0.85) are categorized and a reusable rule is saved; " + "the rest come back in `review` (top 30 by ₹) for you to decide with `categorize_groups`. Use dryRun to preview.",
+    inputSchema: {
+      startDate: exports_external.string().optional().describe("YYYY-MM-DD"),
+      endDate: exports_external.string().optional().describe("YYYY-MM-DD"),
+      minConfidence: exports_external.number().min(0.5).max(1).optional().describe(`Apply at/above this confidence (default ${DEFAULT_MIN_CONFIDENCE})`),
+      dryRun: exports_external.boolean().optional()
+    }
+  }, async ({ startDate, endDate, minConfidence, dryRun }) => {
+    const key = assertJevAllowed(crypto3);
+    const result = await jevCategorize(client, crypto3, makeJevClassifier(key), {
+      startDate,
+      endDate,
+      minConfidence,
+      dryRun
+    });
+    return { content: [{ type: "text", text: JSON.stringify(result) }] };
+  });
+}
+
+// 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.",
+    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((m2) => String(m2.rawId ?? "").toLowerCase() === needle || String(m2.cleanName ?? "").toLowerCase().includes(needle));
+      return {
+        content: [{ type: "text", text: JSON.stringify({ ...data2, data: merchants }) }]
+      };
+    }
+    const data = rawId ? await client.get("/api/merchants", {
+      search: rawId
+    }) : await client.get("/api/merchants");
+    if (crypto3 && data.data)
+      await decryptMerchantFields(data.data, crypto3.key);
+    return { content: [{ type: "text", text: JSON.stringify(data) }] };
+  });
+  server.registerTool("delete_merchant", {
+    description: "Delete merchant(s) from the dictionary. Provide `id` for a single merchant or `ids` for several. Transactions referencing a deleted merchant have their merchantId cleared. PERMANENT.",
+    inputSchema: {
+      id: exports_external.string().optional().describe("Single merchant UUID"),
+      ids: exports_external.array(exports_external.string()).min(1).optional().describe("Multiple merchant UUIDs (bulk delete)")
+    }
+  }, 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 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()
+    }
+  }, 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
+      });
+    }
+    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) }] };
+  });
+}
+
+// src/tools/push.ts
+function registerPushTools(server, client) {
+  server.registerTool("list_push_subscriptions", {
+    description: "List the household's registered web-push subscriptions (browser/device endpoints that receive alert notifications).",
+    inputSchema: {}
+  }, async () => {
+    const data = await client.get("/api/push/subscriptions");
+    return { content: [{ type: "text", text: JSON.stringify(data) }] };
+  });
+  server.registerTool("send_test_push", {
+    description: "Send a test web-push notification to all of the household's subscriptions. Use to verify push delivery is working.",
+    inputSchema: {}
+  }, async () => {
+    const data = await client.post("/api/push/test");
+    return { content: [{ type: "text", text: JSON.stringify(data) }] };
+  });
+}
+
+// src/tools/recurring.ts
+function registerRecurringTools(server, client) {
+  server.registerTool("list_recurring", {
+    description: "List all recurring transactions (subscriptions, rent, salaries).",
+    inputSchema: {}
+  }, async () => {
+    const data = await client.get("/api/recurring");
+    return { content: [{ type: "text", text: JSON.stringify(data) }] };
+  });
+  server.registerTool("add_recurring", {
+    description: "Add a recurring transaction to track subscriptions or regular income.",
+    inputSchema: {
+      name: exports_external.string(),
+      amount: exports_external.string(),
+      type: exports_external.enum(["debit", "credit"]),
+      frequency: exports_external.enum(["daily", "weekly", "monthly", "yearly"]),
+      dayOfMonth: exports_external.number().optional().describe("For monthly — day of month (1-31)"),
+      categorySlug: exports_external.string().optional(),
+      owner: exports_external.string(),
+      startDate: exports_external.string().optional().describe("YYYY-MM-DD"),
+      notes: exports_external.string().optional()
+    }
+  }, async (body) => {
+    const data = await client.post("/api/recurring", body);
+    return { content: [{ type: "text", text: JSON.stringify(data) }] };
+  });
+}
+
+// src/tools/reports.ts
+function registerReportTools(server, client) {
+  server.registerTool("generate_monthly_report", {
+    description: "Generate a detailed monthly financial report. Computes income, expenses, savings rate, top categories, and insights. Persists to DB.",
+    inputSchema: {
+      month: exports_external.number().min(1).max(12),
+      year: exports_external.number().min(2020).max(2100)
+    }
+  }, async (body) => {
+    const data = await client.post("/api/reports", body);
+    return { content: [{ type: "text", text: JSON.stringify(data) }] };
+  });
+  server.registerTool("get_reports", {
+    description: "Monthly financial reports for the last N months — income, expenses, savings rate, net worth.",
+    inputSchema: {
+      months: exports_external.number().optional().describe("Number of months (default: 6)")
+    }
+  }, async (params) => {
+    const data = await client.get("/api/reports", params.months ? { months: params.months } : undefined);
+    return { content: [{ type: "text", text: JSON.stringify(data) }] };
+  });
+}
+
+// src/tools/transactions.ts
+import { readFile } from "node:fs/promises";
+// ../parsers/src/classify.ts
+var CORPORATE_TOKENS = [
+  "PVT",
+  "PRIVATE",
+  "LIMITED",
+  "LTD",
+  "LLP",
+  "INC",
+  "CORP",
+  "ENTERPRISES",
+  "TECHNOLOGIES",
+  "SOLUTIONS",
+  "SERVICES"
+];
+var CORPORATE_REGEX = new RegExp(`\\b(${CORPORATE_TOKENS.join("|")})\\b`);
+function classifyEntity({ paymentMethod, extractedName }) {
+  if (paymentMethod === "atm")
+    return "merchant";
+  if (paymentMethod === "pos")
+    return "merchant";
+  const upper = (extractedName ?? "").toUpperCase();
+  if (upper && CORPORATE_REGEX.test(upper))
+    return "merchant";
+  if (paymentMethod === "imps")
+    return "person";
+  if (paymentMethod === "upi")
+    return "person";
+  if (paymentMethod === "neft" || paymentMethod === "rtgs")
+    return "merchant";
+  if (paymentMethod === "ach")
+    return "merchant";
+  return "unknown";
+}
+// ../parsers/src/hdfc/narration.ts
+function parseHdfcNarration(narration) {
+  const trimmed = narration.trim();
+  if (trimmed.startsWith("UPI-")) {
+    return parseUpi(trimmed);
+  }
+  if (trimmed.startsWith("NEFT CR-") || trimmed.startsWith("NEFT DR-")) {
+    return parseNeft(trimmed);
+  }
+  if (trimmed.startsWith("ACH D-") || trimmed.startsWith("ACH C-")) {
+    return parseAch(trimmed);
+  }
+  if (trimmed.startsWith("FT-") || trimmed.startsWith("FT -")) {
+    return parseFt(trimmed);
+  }
+  if (trimmed.startsWith("IMPS-") || trimmed.startsWith("IMPS/")) {
+    return parseImps(trimmed);
+  }
+  if (trimmed.startsWith("ATW-") || trimmed.startsWith("ATM-") || trimmed.startsWith("ATM/")) {
+    return {
+      paymentMethod: "atm",
+      name: "ATM Withdrawal",
+      upiId: null,
+      referenceNumber: null,
+      description: trimmed
+    };
+  }
+  if (trimmed.startsWith("POS ")) {
+    return parsePos(trimmed);
+  }
+  return parseFallback(trimmed);
+}
+function parseUpi(narration) {
+  const rest = narration.slice(4);
+  const parts = rest.split("-");
+  if (parts.length < 4) {
+    return {
+      paymentMethod: "upi",
+      name: rest,
+      upiId: null,
+      referenceNumber: null,
+      description: null
+    };
   }
   const name = parts[0].trim();
   const upiId = parts[1]?.trim() || null;
@@ -45698,33 +46766,33 @@ async function backfillPersons(client, crypto3, opts = {}) {
     const norm = normalizePersonName(name);
     if (!norm)
       continue;
-    const g2 = groups.get(norm) ?? {
+    const g3 = 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);
+      g3.upiHandles.add(upiId);
+    g3.txnIds.push(t2.id);
+    groups.set(norm, g3);
   }
   const plan = [];
   const newGroups = [];
   let reused = 0;
-  for (const [norm, g2] of groups) {
-    const upiHandles = [...g2.upiHandles];
+  for (const [norm, g3] of groups) {
+    const upiHandles = [...g3.upiHandles];
     const isReuse = personIdByNorm.has(norm);
     plan.push({
-      name: g2.displayName,
+      name: g3.displayName,
       normalized: norm,
-      txnCount: g2.txnIds.length,
+      txnCount: g3.txnIds.length,
       upiHandles,
       action: isReuse ? "reuse" : "create"
     });
     if (isReuse)
       reused++;
     else
-      newGroups.push({ norm, displayName: g2.displayName, upiHandles });
+      newGroups.push({ norm, displayName: g3.displayName, upiHandles });
   }
   if (!opts.dryRun && newGroups.length > 0) {
     const bodies = await Promise.all(newGroups.map(async ({ displayName, upiHandles }) => {
@@ -45747,11 +46815,11 @@ async function backfillPersons(client, crypto3, opts = {}) {
   const created = newGroups.length;
   const links = [];
   if (!opts.dryRun) {
-    for (const [norm, g2] of groups) {
+    for (const [norm, g3] of groups) {
       const personId = personIdByNorm.get(norm);
       if (!personId)
         continue;
-      for (const txnId of g2.txnIds)
+      for (const txnId of g3.txnIds)
         links.push({ transactionId: txnId, personId });
     }
   }
@@ -45778,31 +46846,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;
@@ -45830,16 +46890,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 ?? [];
@@ -45849,23 +46902,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,
@@ -45876,25 +46914,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)"),
@@ -45909,64 +46945,106 @@ function registerTransactionTools(server, client, crypto3) {
       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.",
@@ -45995,13 +47073,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);
@@ -46040,8 +47114,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", {
@@ -46070,7 +47144,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(),
@@ -46109,7 +47183,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)}`);
     }
@@ -46138,9 +47217,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) ?? [];
@@ -46191,11 +47274,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) }] };
   });
@@ -46278,6 +47368,7 @@ async function main() {
     version: "0.0.1"
   });
   registerTransactionTools(server, client, crypto3);
+  registerJevTools(server, client, crypto3);
   registerMerchantTools(server, client, crypto3);
   registerPersonTools(server, client, crypto3);
   registerCategoryTools(server, client);
@@ -46311,5 +47402,5 @@ main().catch((err) => {
   process.exit(1);
 });
 
-//# debugId=0561A150F92599BE64756E2164756E21
+//# debugId=81E220C7BA0CDE2464756E2164756E21
 //# sourceMappingURL=index.js.map