paisa-mcp 0.4.1 → 0.4.3

package/dist/index.js

@@ -38033,17 +38033,6 @@ var inputRequired = Object.assign(buildInputRequired, {
     return { method: "roots/list" };
   }
 });
-function acceptedContent(responses, key, schema) {
-  const view = inputResponse(responses, key);
-  if (view.kind !== "elicit" || view.action !== "accept" || view.content === undefined)
-    return;
-  if (schema === undefined)
-    return view.content;
-  const outcome = schema["~standard"].validate(view.content);
-  if (outcome instanceof Promise)
-    throw new TypeError("acceptedContent(responses, key, schema) requires a synchronously-validating schema");
-  return outcome.issues === undefined ? outcome.value : undefined;
-}
 function inputResponse(responses, key) {
   if (responses === undefined || typeof responses !== "object" || responses === null)
     return { kind: "missing" };
@@ -53267,25 +53256,8 @@ async function decryptFields(input2, paths, { decrypt, isCiphertext }) {
   return { data, undecrypted };
 }
 
-// src/crypto.ts
+// ../crypto/src/index.ts
 var import_hash_wasm = __toESM(require_index_umd(), 1);
-var ENCRYPTED_TXN_FIELDS = ["description", "referenceNumber", "notes"];
-var ENCRYPTED_MERCHANT_FIELDS = ["cleanName", "rawId", "notes"];
-async function hmacWithKey(value, key) {
-  const rawKey = await crypto.subtle.exportKey("raw", key);
-  const hmacKey = await crypto.subtle.importKey("raw", rawKey, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
-  const sig = await crypto.subtle.sign("HMAC", hmacKey, new TextEncoder().encode(value));
-  return btoa(String.fromCharCode(...new Uint8Array(sig)));
-}
-async function encryptPersonCipher(fields, key) {
-  const cipher = await encryptField(JSON.stringify(fields), key);
-  const searchHash = await hmacWithKey(fields.name.toLowerCase().trim().replace(/\s+/g, " "), key);
-  return { cipher, searchHash };
-}
-async function decryptPersonCipher(cipher, key) {
-  const json2 = await decryptField(cipher, key);
-  return JSON.parse(json2);
-}
 async function deriveKey(userId, pin, salt) {
   const enc = new TextEncoder;
   const baseKey = await crypto.subtle.importKey("raw", enc.encode(userId + pin), "PBKDF2", false, [
@@ -53329,6 +53301,34 @@ async function decryptField(encrypted, key) {
   const plaintext = await crypto.subtle.decrypt({ name: "AES-GCM", iv }, key, ciphertext);
   return new TextDecoder().decode(plaintext);
 }
+var VERIFIER_PLAINTEXT = "paisa-verify-v1";
+async function checkVerifier(key, encryptedVerifier) {
+  try {
+    const decrypted = await decryptField(encryptedVerifier, key);
+    return decrypted === VERIFIER_PLAINTEXT;
+  } catch {
+    return false;
+  }
+}
+
+// src/crypto.ts
+var ENCRYPTED_TXN_FIELDS = ["description", "referenceNumber", "notes"];
+var ENCRYPTED_MERCHANT_FIELDS = ["cleanName", "rawId", "notes"];
+async function hmacWithKey(value, key) {
+  const rawKey = await crypto.subtle.exportKey("raw", key);
+  const hmacKey = await crypto.subtle.importKey("raw", rawKey, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+  const sig = await crypto.subtle.sign("HMAC", hmacKey, new TextEncoder().encode(value));
+  return btoa(String.fromCharCode(...new Uint8Array(sig)));
+}
+async function encryptPersonCipher(fields, key) {
+  const cipher = await encryptField(JSON.stringify(fields), key);
+  const searchHash = await hmacWithKey(fields.name.toLowerCase().trim().replace(/\s+/g, " "), key);
+  return { cipher, searchHash };
+}
+async function decryptPersonCipher(cipher, key) {
+  const json2 = await decryptField(cipher, key);
+  return JSON.parse(json2);
+}
 async function encryptObjectFields(obj, fields, key) {
   for (const field of fields) {
     const val = obj[field];
@@ -53386,15 +53386,6 @@ async function decryptPersonCiphers(input2, key) {
     merge3(data);
   return { data, undecrypted };
 }
-var VERIFIER_PLAINTEXT = "paisa-verify-v1";
-async function checkVerifier(key, encryptedVerifier) {
-  try {
-    const decrypted = await decryptField(encryptedVerifier, key);
-    return decrypted === VERIFIER_PLAINTEXT;
-  } catch {
-    return false;
-  }
-}
 
 // src/lib/crypto-init.ts
 async function initCrypto(client, pin, userId) {
@@ -53439,10 +53430,153 @@ async function initCrypto(client, pin, userId) {
   return { key };
 }
 
+// src/server.ts
+import { randomBytes } from "node:crypto";
+
 // ../../node_modules/.bun/@modelcontextprotocol+server@2.1.0/node_modules/@modelcontextprotocol/server/dist/index.mjs
 var DEFAULT_MAX_REQUEST_BODY_SIZE = 4 * 1024 * 1024;
+var PREFIX = "v1.";
+function bytesToBase64Url(bytes) {
+  let bin = "";
+  for (const b of bytes)
+    bin += String.fromCodePoint(b);
+  return btoa(bin).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+}
+function constantTimeTagEqual(a, b) {
+  if (a.length !== b.length)
+    return false;
+  let r = 0;
+  for (let i = 0;i < a.length; i++)
+    r |= a.codePointAt(i) ^ b.codePointAt(i);
+  return r === 0;
+}
+function base64UrlToBytes(s) {
+  const b64 = s.replaceAll("-", "+").replaceAll("_", "/");
+  const bin = atob(b64);
+  const bytes = new Uint8Array(bin.length);
+  for (let i = 0;i < bin.length; i++)
+    bytes[i] = bin.codePointAt(i);
+  return bytes;
+}
+function createRequestStateCodec(options) {
+  const subtle = globalThis.crypto?.subtle;
+  if (subtle === undefined)
+    throw new TypeError("createRequestStateCodec requires the Web Crypto API (globalThis.crypto.subtle); see https://ts.sdk.modelcontextprotocol.io/v2/troubleshooting for the Node.js polyfill instructions");
+  const keyBytes = typeof options.key === "string" ? new TextEncoder().encode(options.key) : Uint8Array.from(options.key);
+  if (keyBytes.byteLength < 32)
+    throw new RangeError(`createRequestStateCodec: key must be at least 32 bytes (got ${keyBytes.byteLength})`);
+  const ttlSeconds = options.ttlSeconds ?? 600;
+  if (!Number.isFinite(ttlSeconds))
+    throw new RangeError("createRequestStateCodec: ttlSeconds must be a finite number");
+  const bind2 = options.bind;
+  let cryptoKey;
+  const importedKey = () => cryptoKey ??= subtle.importKey("raw", keyBytes, {
+    name: "HMAC",
+    hash: "SHA-256"
+  }, false, ["sign", "verify"]);
+  const utf8 = new TextEncoder;
+  const BIND_LABEL = "mcp.requestState.bind:";
+  const bindTag = async (value) => {
+    return bytesToBase64Url(new Uint8Array(await subtle.sign("HMAC", await importedKey(), utf8.encode(BIND_LABEL + value))).slice(0, 16));
+  };
+  return {
+    async mint(payload, ctx) {
+      const envelope = {
+        p: payload,
+        exp: Math.floor(Date.now() / 1000) + ttlSeconds
+      };
+      if (bind2 !== undefined) {
+        if (ctx === undefined)
+          throw new TypeError("createRequestStateCodec: mint() requires ctx when a bind callback is configured");
+        envelope.b = await bindTag(bind2(ctx));
+      }
+      const body = bytesToBase64Url(utf8.encode(JSON.stringify(envelope)));
+      return `${PREFIX}${body}.${bytesToBase64Url(new Uint8Array(await subtle.sign("HMAC", await importedKey(), utf8.encode(PREFIX + body))))}`;
+    },
+    async verify(state, ctx) {
+      const dot = state.lastIndexOf(".");
+      if (!state.startsWith(PREFIX) || dot <= 3)
+        throw new Error("malformed");
+      const body = state.slice(3, dot);
+      let macBytes;
+      try {
+        macBytes = base64UrlToBytes(state.slice(dot + 1));
+      } catch {
+        throw new Error("malformed");
+      }
+      if (!await subtle.verify("HMAC", await importedKey(), macBytes, utf8.encode(PREFIX + body)))
+        throw new Error("mac");
+      let envelope;
+      try {
+        envelope = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(base64UrlToBytes(body)));
+      } catch {
+        throw new Error("malformed");
+      }
+      if (typeof envelope.exp !== "number" || envelope.exp < Math.floor(Date.now() / 1000))
+        throw new Error("expired");
+      if (bind2 !== undefined) {
+        const expected = await bindTag(bind2(ctx));
+        if (envelope.b === undefined || !constantTimeTagEqual(envelope.b, expected))
+          throw new Error("bind");
+      } else if (envelope.b !== undefined)
+        throw new Error("bind");
+      return envelope.p;
+    }
+  };
+}
 
-// ../../node_modules/.bun/@nimit9+signet-server@0.2.6+e803b2305afdb064/node_modules/@nimit9/signet-server/dist/mcp/interaction.js
+// ../../node_modules/.bun/@nimit9+signet-server@0.2.7+e803b2305afdb064/node_modules/@nimit9/signet-server/dist/mcp/interaction.js
+var CONFIRM_KEY = "signet_confirm";
+function canonicalize(value) {
+  if (Array.isArray(value))
+    return value.map(canonicalize);
+  if (value !== null && typeof value === "object") {
+    const obj = value;
+    return Object.fromEntries(Object.keys(obj).sort().map((k) => [k, canonicalize(obj[k])]));
+  }
+  return value;
+}
+async function fingerprint(args) {
+  const bytes = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(JSON.stringify(canonicalize(args ?? null))));
+  return [...new Uint8Array(bytes)].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function confirm(ctx, { message, detail, args, key }) {
+  const id = key ?? `${CONFIRM_KEY}:${ctx.tool}`;
+  const view = inputResponse(ctx.mcp.mcpReq.inputResponses, id);
+  if (view.kind === "missing") {
+    if (!ctx.confirmSupport.getClientCapabilities()?.elicitation)
+      return "unsupported";
+    const payload = { tool: ctx.tool, id, fp: await fingerprint(args) };
+    const requestState = await ctx.confirmSupport.mint?.(payload);
+    return inputRequired({
+      inputRequests: {
+        [id]: inputRequired.elicit({
+          message: detail ? `${message}
+
+${detail}` : message,
+          requestedSchema: {
+            type: "object",
+            properties: { confirm: { type: "boolean", title: "Confirm" } },
+            required: ["confirm"]
+          }
+        })
+      },
+      ...requestState ? { requestState } : {}
+    });
+  }
+  if (view.kind !== "elicit" || view.action !== "accept" || view.content?.confirm !== true) {
+    return "declined";
+  }
+  if (ctx.confirmSupport.mint) {
+    const state = ctx.mcp.mcpReq.requestState();
+    if (!state || state.tool !== ctx.tool || state.id !== id || state.fp !== await fingerprint(args))
+      return "declined";
+  }
+  return "confirmed";
+}
+function isConfirmPending(value) {
+  return isInputRequiredResult(value);
+}
 async function progress(ctx, done, total, message) {
   const token = ctx.mcp.mcpReq._meta?.progressToken;
   if (token === undefined)
@@ -53459,7 +53593,7 @@ async function progress(ctx, done, total, message) {
     });
   } catch {}
 }
-// ../../node_modules/.bun/@nimit9+signet-server@0.2.6+e803b2305afdb064/node_modules/@nimit9/signet-server/dist/http/status-codes.js
+// ../../node_modules/.bun/@nimit9+signet-server@0.2.7+e803b2305afdb064/node_modules/@nimit9/signet-server/dist/http/status-codes.js
 var STATUS_CODES = {
   400: "BAD_REQUEST",
   401: "UNAUTHORIZED",
@@ -53473,7 +53607,7 @@ var STATUS_CODES = {
   429: "RATE_LIMITED"
 };
 
-// ../../node_modules/.bun/@nimit9+signet-server@0.2.6+e803b2305afdb064/node_modules/@nimit9/signet-server/dist/mcp/errors.js
+// ../../node_modules/.bun/@nimit9+signet-server@0.2.7+e803b2305afdb064/node_modules/@nimit9/signet-server/dist/mcp/errors.js
 function isZodError(err) {
   return err instanceof Error && err.name === "ZodError" && Array.isArray(err.issues);
 }
@@ -53537,7 +53671,7 @@ function report(opts, err, meta3, c) {
   } catch {}
 }
 
-// ../../node_modules/.bun/@nimit9+signet-server@0.2.6+e803b2305afdb064/node_modules/@nimit9/signet-server/dist/mcp/primitives.js
+// ../../node_modules/.bun/@nimit9+signet-server@0.2.7+e803b2305afdb064/node_modules/@nimit9/signet-server/dist/mcp/primitives.js
 var RAW = Symbol.for("signet.mcp.rawResult");
 function protocolError(err, deps, meta3) {
   if (ProtocolError.isInstance(err))
@@ -53570,8 +53704,14 @@ function checkScopes(scopes, token) {
   });
 }
 function baseContext(mcp, deps) {
-  const { c, token } = deps.context;
-  return { signal: mcp.mcpReq.signal, mcp, ...c ? { c } : {}, ...token ? { token } : {} };
+  const { c, token, confirmSupport } = deps.context;
+  return {
+    signal: mcp.mcpReq.signal,
+    mcp,
+    confirmSupport,
+    ...c ? { c } : {},
+    ...token ? { token } : {}
+  };
 }
 function toContents(uri, value, mimeType) {
   if (value !== null && typeof value === "object" && RAW in value)
@@ -53681,7 +53821,7 @@ function registerPrompts(server, prompts, deps) {
   }
 }
 
-// ../../node_modules/.bun/@nimit9+signet-server@0.2.6+e803b2305afdb064/node_modules/@nimit9/signet-server/dist/mcp/server.js
+// ../../node_modules/.bun/@nimit9+signet-server@0.2.7+e803b2305afdb064/node_modules/@nimit9/signet-server/dist/mcp/server.js
 var RAW2 = Symbol.for("signet.mcp.rawResult");
 function toolResult(result) {
   return Object.defineProperty({ ...result }, RAW2, { value: true, enumerable: false });
@@ -53709,9 +53849,14 @@ function createMcpServer(options) {
     ...options.resources?.length ? { resources: { listChanged: false } } : {},
     ...options.prompts?.length ? { prompts: { listChanged: false } } : {}
   };
+  const confirmCodec = options.confirm ? createRequestStateCodec({
+    key: options.confirm.key,
+    ...options.confirm.ttlSeconds !== undefined ? { ttlSeconds: options.confirm.ttlSeconds } : {}
+  }) : undefined;
   const server = new McpServer({ name: options.name, version: options.version }, {
     ...unlisted.size ? {} : { capabilities: toolsCapability },
-    ...options.instructions ? { instructions: options.instructions } : {}
+    ...options.instructions ? { instructions: options.instructions } : {},
+    ...confirmCodec ? { requestState: { verify: confirmCodec.verify } } : {}
   });
   let restore;
   if (unlisted.size) {
@@ -53726,6 +53871,10 @@ function createMcpServer(options) {
         tool: tool.name,
         signal: mcp.mcpReq.signal,
         mcp,
+        confirmSupport: {
+          getClientCapabilities: () => server.server.getClientCapabilities(),
+          ...confirmCodec ? { mint: (payload) => confirmCodec.mint(payload, mcp) } : {}
+        },
         ...c ? { c } : {},
         ...token ? { token } : {}
       };
@@ -53764,7 +53913,14 @@ function createMcpServer(options) {
     restore?.();
     restore = undefined;
   }
-  const deps = { options, context: { ...c ? { c } : {}, ...token ? { token } : {} } };
+  const confirmSupport = {
+    getClientCapabilities: () => server.server.getClientCapabilities(),
+    ...confirmCodec ? { mint: (payload) => confirmCodec.mint(payload) } : {}
+  };
+  const deps = {
+    options,
+    context: { confirmSupport, ...c ? { c } : {}, ...token ? { token } : {} }
+  };
   if (options.resources?.length)
     registerResources(server, options.resources, deps);
   if (options.prompts?.length)
@@ -53867,84 +54023,34 @@ function applyAnnotations(tools) {
 }
 
 // src/lib/confirm.ts
-import { createHash, createHmac, randomBytes, timingSafeEqual } from "node:crypto";
-var ANSWER_KEY = "confirm";
-function clientCanConfirm(mcp, initializeCapabilities) {
-  const envelope = mcp.mcpReq.envelope;
-  const caps = envelope?.[CLIENT_CAPABILITIES_META_KEY] ?? initializeCapabilities();
-  return Boolean(caps?.elicitation);
-}
-function planFingerprint(plan) {
-  const canonical = (v) => Array.isArray(v) ? v.map(canonical) : v && typeof v === "object" ? Object.fromEntries(Object.entries(v).filter(([, x]) => x !== undefined).sort(([a], [b]) => a.localeCompare(b)).map(([k, x]) => [k, canonical(x)])) : v;
-  return createHash("sha256").update(JSON.stringify(canonical(plan))).digest("hex");
-}
-var STATE_KEY = randomBytes(32);
-function sign(nonce, fingerprint) {
-  return createHmac("sha256", STATE_KEY).update(`${nonce}.${fingerprint}`).digest("hex");
-}
-function mintState(fingerprint) {
-  const nonce = randomBytes(16).toString("hex");
-  return `${nonce}.${sign(nonce, fingerprint)}`;
-}
-function verifyState(state, fingerprint) {
-  if (typeof state !== "string")
-    return false;
-  const [nonce, mac3, ...rest] = state.split(".");
-  if (!nonce || !mac3 || rest.length)
-    return false;
-  const expected = Buffer.from(sign(nonce, fingerprint), "hex");
-  const given = Buffer.from(mac3, "hex");
-  return given.length === expected.length && timingSafeEqual(given, expected);
+var CANCELLED = { cancelled: true, message: "Cancelled by the user. Nothing was changed." };
+var PLAN_CHANGED = {
+  planChanged: true,
+  message: "The request changed after you confirmed, so nothing was changed. Run it again to see the new plan."
+};
+function acceptedDifferentPlan(ctx) {
+  const view = inputResponse(ctx.mcp.mcpReq.inputResponses, `signet_confirm:${ctx.tool}`);
+  return view.kind === "elicit" && view.action === "accept" && view.content?.confirm === true;
 }
-function confirmPlan(mcp, message, plan, initializeCapabilities = () => {
-  return;
-}) {
-  if (!clientCanConfirm(mcp, initializeCapabilities))
-    return { kind: "unsupported" };
-  const fingerprint = planFingerprint(plan);
-  const responses = mcp.mcpReq.inputResponses;
-  const answered = responses !== undefined && ANSWER_KEY in responses;
-  const echoed = mcp.mcpReq.requestState?.();
-  if (answered && verifyState(echoed, fingerprint)) {
-    const content = acceptedContent(responses, ANSWER_KEY);
-    if (content?.confirm === true)
-      return { kind: "confirmed" };
-    return {
-      kind: "declined",
-      result: { cancelled: true, message: "Cancelled by the user. Nothing was changed." }
-    };
-  }
-  return {
-    kind: "ask",
-    result: inputRequired({
-      inputRequests: {
-        [ANSWER_KEY]: inputRequired.elicit({
-          message,
-          requestedSchema: {
-            type: "object",
-            properties: {
-              confirm: { type: "boolean", title: "Confirm", description: "This can't be undone." }
-            },
-            required: ["confirm"]
-          }
-        })
-      },
-      requestState: mintState(fingerprint)
-    })
-  };
+async function askThenRun(ctx, message, plan, run, fallback = run) {
+  const answer = await confirm(ctx, { message, args: plan });
+  if (isConfirmPending(answer))
+    return answer;
+  if (answer === "confirmed")
+    return run();
+  if (answer === "unsupported")
+    return fallback();
+  return acceptedDifferentPlan(ctx) ? PLAN_CHANGED : CANCELLED;
 }
-function withConfirmation(tool, describe3, initializeCapabilities) {
+function withConfirmation(tool, describe3) {
   const run = tool.handler;
   return {
     ...tool,
-    handler: (args, ctx) => {
+    handler: async (args, ctx) => {
       const message = describe3(args);
       if (message === null || !ctx?.mcp)
         return run(args, ctx);
-      const outcome = confirmPlan(ctx.mcp, message, { tool: tool.name, args }, initializeCapabilities);
-      if (outcome.kind === "confirmed" || outcome.kind === "unsupported")
-        return run(args, ctx);
-      return outcome.result;
+      return askThenRun(ctx, message, { tool: tool.name, args }, () => run(args, ctx));
     }
   };
 }
@@ -54021,11 +54127,7 @@ var BULK_CONFIRMED_TOOLS = {
   }),
   bulk_link_entity: async (args) => ({ n: Array.isArray(args.links) ? args.links.length : 0 })
 };
-var PLAN_CHANGED = {
-  planChanged: true,
-  message: "The transactions changed after they were counted, so nothing was written. Run it again to see the new count."
-};
-function withBulkConfirmation(tool, count, initializeCapabilities) {
+function withBulkConfirmation(tool, count) {
   const run = tool.handler;
   const runPlanned = async (args, ctx, hash2) => {
     const result = await run(hash2 === undefined ? args : { ...args, expectedPlanHash: hash2 }, ctx);
@@ -54034,18 +54136,13 @@ function withBulkConfirmation(tool, count, initializeCapabilities) {
   return {
     ...tool,
     handler: async (args, ctx) => {
-      if (args.dryRun === true || !ctx?.mcp || !clientCanConfirm(ctx.mcp, initializeCapabilities))
+      const canAsk = Boolean(ctx?.confirmSupport?.getClientCapabilities()?.elicitation);
+      if (args.dryRun === true || !ctx?.mcp || !canAsk)
         return run(args, ctx);
       const { n, planHash: hash2 } = await count(args, async (a) => run(a, ctx));
       if (n <= BULK_CONFIRM_THRESHOLD)
         return runPlanned(args, ctx, hash2);
-      const message = `Update ${plural2(n, "transaction")} in one go?`;
-      const outcome = confirmPlan(ctx.mcp, message, { tool: tool.name, args, n, planHash: hash2 }, initializeCapabilities);
-      if (outcome.kind === "confirmed")
-        return runPlanned(args, ctx, hash2);
-      if (outcome.kind === "unsupported")
-        return run(args, ctx);
-      return outcome.result;
+      return askThenRun(ctx, `Update ${plural2(n, "transaction")} in one go?`, { tool: tool.name, args, n, planHash: hash2 }, () => runPlanned(args, ctx, hash2), () => run(args, ctx));
     }
   };
 }
@@ -54478,7 +54575,7 @@ async function decryptAnalytics(data, key) {
   ], key);
   return undecrypted.length ? { ...decrypted, undecrypted } : decrypted;
 }
-function analyticsTools(client, crypto3) {
+function analyticsTools(client, crypto4) {
   return [
     defineTool({
       name: "get_analytics",
@@ -54503,8 +54600,8 @@ function analyticsTools(client, crypto3) {
             data = await client.get(`/api/analytics/merchants/${params.id}`, params.months ? { months: params.months } : undefined);
             break;
         }
-        if (crypto3)
-          data = await decryptAnalytics(data, crypto3.key);
+        if (crypto4)
+          data = await decryptAnalytics(data, crypto4.key);
         return data;
       }
     })
@@ -54562,7 +54659,7 @@ function budgetTools(client) {
 }
 
 // src/tools/dashboard.ts
-function dashboardTools(client, crypto3) {
+function dashboardTools(client, crypto4) {
   return [
     defineTool({
       name: "get_dashboard",
@@ -54571,8 +54668,8 @@ function dashboardTools(client, crypto3) {
       output: dashboardOutputSchema,
       handler: async (params) => {
         const data = await client.get("/api/dashboard", params.months ? { months: params.months } : undefined);
-        if (crypto3 && Array.isArray(data?.recentTransactions)) {
-          const { data: decrypted, undecrypted } = await decryptTransactionFields(data.recentTransactions, crypto3.key);
+        if (crypto4 && Array.isArray(data?.recentTransactions)) {
+          const { data: decrypted, undecrypted } = await decryptTransactionFields(data.recentTransactions, crypto4.key);
           data.recentTransactions = decrypted;
           if (undecrypted.length)
             return { ...data, undecrypted };
@@ -54718,7 +54815,7 @@ function goalTools(client) {
   return [
     defineTool({
       name: "upsert_savings",
-      description: "Create (omit id) or update (pass id; all fields optional) a savings goal, EMI or sinking fund. Amounts are ₹ decimal strings, dates YYYY-MM-DD. Required on create — " + "goal: goalType, name, targetAmount. emi: name, totalAmount, emiAmount (monthly), startDate, endDate (last payment), totalMonths, owner. " + "sinking_fund: name, targetAmount, targetDate (due), monthlyContribution.",
+      description: "Create (omit id) or update (pass id; all fields optional) a savings goal, EMI or sinking fund. Amounts are ₹ decimal strings, dates YYYY-MM-DD. Required on create — " + "goal: goalType, name, targetAmount. emi: name, totalAmount, emiAmount (monthly), startDate, endDate (last payment), totalMonths, owner. " + "sinking_fund: name, targetAmount, targetDate (due), monthlyContribution. " + "status — goal: active|paused|completed|cancelled; emi: active|completed|foreclosed; sinking funds have none.",
       input: exports_external.object({
         type: exports_external.enum(["goal", "emi", "sinking_fund"]),
         id: exports_external.string().optional(),
@@ -54739,7 +54836,8 @@ function goalTools(client) {
         startDate: exports_external.string().optional(),
         endDate: exports_external.string().optional(),
         totalMonths: exports_external.number().optional(),
-        paidMonths: exports_external.number().optional()
+        paidMonths: exports_external.number().optional(),
+        status: exports_external.enum(["active", "paused", "completed", "cancelled", "foreclosed"]).optional().describe("goal: active|paused|completed|cancelled; emi: active|completed|foreclosed")
       }),
       handler: async ({ type, ...fields }) => {
         const require2 = (keys) => {
@@ -54748,6 +54846,14 @@ function goalTools(client) {
             throw new Error(`upsert_savings type='${type}' requires: ${missing.join(", ")}`);
           }
         };
+        const allowedStatus = {
+          goal: ["active", "paused", "completed", "cancelled"],
+          emi: ["active", "completed", "foreclosed"],
+          sinking_fund: []
+        };
+        if (fields.status !== undefined && !allowedStatus[type].includes(fields.status)) {
+          throw new Error(type === "sinking_fund" ? "upsert_savings type='sinking_fund' has no status" : `upsert_savings type='${type}' status must be one of: ${allowedStatus[type].join(", ")}`);
+        }
         if (type === "goal") {
           const {
             id: id2,
@@ -54760,7 +54866,8 @@ function goalTools(client) {
             owner,
             icon,
             color,
-            notes
+            notes,
+            status
           } = fields;
           const body2 = {
             type: goalType,
@@ -54772,7 +54879,8 @@ function goalTools(client) {
             owner,
             icon,
             color,
-            notes
+            notes,
+            status
           };
           if (!id2)
             require2(["name", "targetAmount", "goalType"]);
@@ -54790,7 +54898,8 @@ function goalTools(client) {
             totalMonths,
             paidMonths,
             interestRate,
-            outstandingPrincipal
+            outstandingPrincipal,
+            status
           } = fields;
           const { owner } = fields;
           if (!id2) {
@@ -54814,7 +54923,8 @@ function goalTools(client) {
             paidMonths,
             interestRate,
             outstandingPrincipal,
-            owner
+            owner,
+            status
           };
           const data2 = id2 ? await client.patch(`/api/goals/emis/${id2}`, body2) : await client.post("/api/goals/emis", body2);
           return data2;
@@ -55123,13 +55233,13 @@ async function categorySlugToId(client) {
   }
   return map2;
 }
-function merchantVariants(client, crypto3) {
+function merchantVariants(client, crypto4) {
   return {
     list: variant(exports_external.object({ rawId: exports_external.string().optional().describe("merchants: find one by UPI ID or name") }), async ({ rawId }) => {
       const data = await client.get("/api/merchants");
       let undecrypted = [];
-      if (crypto3 && data.data) {
-        const dec = await decryptMerchantFields(data.data, crypto3.key);
+      if (crypto4 && data.data) {
+        const dec = await decryptMerchantFields(data.data, crypto4.key);
         data.data = dec.data;
         undecrypted = dec.undecrypted;
       }
@@ -55187,7 +55297,7 @@ function merchantTools(client) {
 }
 
 // src/tools/persons.ts
-function personVariants(client, crypto3) {
+function personVariants(client, crypto4) {
   return {
     upsert: variant(exports_external.object({
       id: exports_external.string().optional().describe("Person UUID — pass to update, omit to create"),
@@ -55197,13 +55307,13 @@ function personVariants(client, crypto3) {
       relationship: exports_external.string().optional(),
       notes: exports_external.string().optional()
     }), async ({ id, ...updates }) => {
-      if (crypto3) {
+      if (crypto4) {
         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);
+            current = await decryptPersonCipher(personData.cipher, crypto4.key);
           } else {
             current = {
               name: personData.name,
@@ -55220,7 +55330,7 @@ function personVariants(client, crypto3) {
             relationship: updates.relationship ?? current.relationship ?? null,
             notes: updates.notes ?? current.notes ?? null
           };
-          const payload2 = await encryptPersonCipher(merged, crypto3.key);
+          const payload2 = await encryptPersonCipher(merged, crypto4.key);
           const data3 = await client.patch(`/api/persons/${id}`, payload2);
           return data3;
         }
@@ -55233,7 +55343,7 @@ function personVariants(client, crypto3) {
           relationship: updates.relationship ?? null,
           notes: updates.notes ?? null
         };
-        const payload = await encryptPersonCipher(fields, crypto3.key);
+        const payload = await encryptPersonCipher(fields, crypto4.key);
         const data2 = await client.post("/api/persons", payload);
         return data2;
       }
@@ -55245,8 +55355,8 @@ function personVariants(client, crypto3) {
     }), async ({ id }) => {
       if (id) {
         const data2 = await client.get(`/api/persons/${id}`);
-        if (crypto3 && data2.data.cipher) {
-          const { data: decrypted, undecrypted } = await decryptPersonCiphers(data2.data, crypto3.key);
+        if (crypto4 && data2.data.cipher) {
+          const { data: decrypted, undecrypted } = await decryptPersonCiphers(data2.data, crypto4.key);
           data2.data = decrypted;
           if (undecrypted.length)
             return { ...data2, undecrypted };
@@ -55254,8 +55364,8 @@ function personVariants(client, crypto3) {
         return data2;
       }
       const data = await client.get("/api/persons");
-      if (crypto3 && data.data) {
-        const { data: decrypted, undecrypted } = await decryptPersonCiphers(data.data, crypto3.key);
+      if (crypto4 && data.data) {
+        const { data: decrypted, undecrypted } = await decryptPersonCiphers(data.data, crypto4.key);
         data.data = decrypted;
         if (undecrypted.length)
           return { ...data, undecrypted };
@@ -55393,11 +55503,11 @@ function reportTools(client) {
 }
 
 // src/tools/entities.ts
-function entityTools(client, crypto3) {
+function entityTools(client, crypto4) {
   const category = categoryVariants(client);
   const account = accountVariants(client);
-  const person = personVariants(client, crypto3);
-  const merchant = merchantVariants(client, crypto3);
+  const person = personVariants(client, crypto4);
+  const merchant = merchantVariants(client, crypto4);
   const debt = debtVariants(client);
   const household = householdVariants(client);
   const goal = goalVariants(client);
@@ -59025,9 +59135,9 @@ function parseAmount4(raw) {
   return Number.isNaN(num) ? 0 : Math.abs(num);
 }
 // src/lib/plan-hash.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash } from "node:crypto";
 function planHash(ids) {
-  return createHash2("sha256").update([...ids].sort().join(",")).digest("hex");
+  return createHash("sha256").update([...ids].sort().join(",")).digest("hex");
 }
 
 // src/lib/txn-rows.ts
@@ -59046,10 +59156,10 @@ function toTxnRow(r2) {
     isDuplicate: !!r2.isDuplicate
   };
 }
-async function fetchAllRows(client, crypto3, params = {}, maxPages = 100) {
-  return (await fetchAllRowsPaged(client, crypto3, params, maxPages)).rows;
+async function fetchAllRows(client, crypto4, params = {}, maxPages = 100) {
+  return (await fetchAllRowsPaged(client, crypto4, params, maxPages)).rows;
 }
-async function fetchAllRowsPaged(client, crypto3, params = {}, maxPages = 100) {
+async function fetchAllRowsPaged(client, crypto4, params = {}, maxPages = 100) {
   const out = [];
   let cursor;
   let truncated = false;
@@ -59059,7 +59169,7 @@ async function fetchAllRowsPaged(client, crypto3, params = {}, maxPages = 100) {
       q2.cursor = cursor;
     const res = await client.get("/api/transactions", q2);
     const batch0 = res.data ?? [];
-    const batch = crypto3 ? (await decryptTransactionFields(batch0, crypto3.key)).data : batch0;
+    const batch = crypto4 ? (await decryptTransactionFields(batch0, crypto4.key)).data : batch0;
     out.push(...batch.map(toTxnRow));
     if (!res.hasMore || !res.nextCursor || batch.length === 0 || res.nextCursor === cursor)
       break;
@@ -59105,18 +59215,21 @@ function toLeanRow(r2, personNames) {
 function normalizePersonName(name) {
   return name.toLowerCase().trim().replace(/\s+/g, " ");
 }
-async function loadDecryptedPersons(client, crypto3) {
+function normalizeUpiHandle(handle) {
+  return handle.toLowerCase().trim().split("@")[0];
+}
+async function loadDecryptedPersons(client, crypto4) {
   const res = await client.get("/api/persons");
   const persons = [];
   for (const p2 of res.data ?? []) {
     let name = p2.name ?? "";
-    if (crypto3 && p2.cipher) {
+    if (crypto4 && p2.cipher) {
       try {
-        name = (await decryptPersonCipher(p2.cipher, crypto3.key)).name;
+        name = (await decryptPersonCipher(p2.cipher, crypto4.key)).name;
       } catch {}
     }
     if (name)
-      persons.push({ id: p2.id, name });
+      persons.push({ id: p2.id, name, upiHandles: p2.upiHandles ?? [] });
   }
   return persons;
 }
@@ -59153,13 +59266,18 @@ function isPersonLikeNarration(description) {
   const { name, paymentMethod } = parseNarration(description);
   return classifyEntity({ paymentMethod, extractedName: name }) !== "merchant";
 }
-async function backfillPersons(client, crypto3, opts = {}) {
-  const existing = await loadDecryptedPersons(client, crypto3);
+async function backfillPersons(client, crypto4, opts = {}) {
+  const existing = await loadDecryptedPersons(client, crypto4);
   const personIdByNorm = new Map;
-  for (const p2 of existing)
+  const personIdByHandle = new Map;
+  for (const p2 of existing) {
     personIdByNorm.set(normalizePersonName(p2.name), p2.id);
-  const { rows, truncated } = await fetchAllRowsPaged(client, crypto3, { unresolved: "true" });
+    for (const h2 of p2.upiHandles)
+      personIdByHandle.set(normalizeUpiHandle(h2), p2.id);
+  }
+  const { rows, truncated } = await fetchAllRowsPaged(client, crypto4, { unresolved: "true" });
   const candidates = rows.filter((r2) => !r2.merchantId && !r2.personId && !r2.isTransfer && !r2.isIgnored);
+  const directLinks = [];
   const groups = new Map;
   for (const t2 of candidates) {
     const { name, upiId, paymentMethod } = parseNarration(t2.description);
@@ -59167,6 +59285,11 @@ async function backfillPersons(client, crypto3, opts = {}) {
       continue;
     if (classifyEntity({ paymentMethod, extractedName: name }) !== "person")
       continue;
+    const handlePersonId = upiId ? personIdByHandle.get(normalizeUpiHandle(upiId)) : undefined;
+    if (handlePersonId) {
+      directLinks.push({ transactionId: t2.id, personId: handlePersonId, upiHandle: upiId });
+      continue;
+    }
     const norm = normalizePersonName(name);
     if (!norm)
       continue;
@@ -59182,7 +59305,7 @@ async function backfillPersons(client, crypto3, opts = {}) {
   }
   const plan = [];
   const newGroups = [];
-  let reused = 0;
+  const reusedPersonIds = new Set;
   for (const [norm, g2] of groups) {
     const upiHandles = [...g2.upiHandles];
     const isReuse = personIdByNorm.has(norm);
@@ -59194,11 +59317,34 @@ async function backfillPersons(client, crypto3, opts = {}) {
       action: isReuse ? "reuse" : "create"
     });
     if (isReuse)
-      reused++;
+      reusedPersonIds.add(personIdByNorm.get(norm));
     else
       newGroups.push({ norm, displayName: g2.displayName, upiHandles });
   }
-  const hash2 = planHash([...groups.values()].flatMap((g2) => g2.txnIds));
+  const directByPerson = new Map;
+  for (const d2 of directLinks) {
+    const e2 = directByPerson.get(d2.personId) ?? { txnIds: [], handles: new Set };
+    e2.txnIds.push(d2.transactionId);
+    if (d2.upiHandle)
+      e2.handles.add(d2.upiHandle);
+    directByPerson.set(d2.personId, e2);
+  }
+  for (const [personId, e2] of directByPerson) {
+    const person = existing.find((p2) => p2.id === personId);
+    plan.push({
+      name: person?.name ?? personId,
+      normalized: person ? normalizePersonName(person.name) : personId,
+      txnCount: e2.txnIds.length,
+      upiHandles: [...e2.handles],
+      action: "reuse"
+    });
+    reusedPersonIds.add(personId);
+  }
+  const reused = reusedPersonIds.size;
+  const hash2 = planHash([
+    ...[...groups.values()].flatMap((g2) => g2.txnIds),
+    ...directLinks.map((d2) => d2.transactionId)
+  ]);
   if (!opts.dryRun && opts.expectedPlanHash !== undefined && opts.expectedPlanHash !== hash2) {
     return {
       dryRun: false,
@@ -59221,7 +59367,7 @@ async function backfillPersons(client, crypto3, opts = {}) {
         relationship: null,
         notes: null
       };
-      return crypto3 ? await encryptPersonCipher(fields, crypto3.key) : { name: displayName, upiHandles, phoneNumbers: [], relationship: null, notes: null };
+      return crypto4 ? await encryptPersonCipher(fields, crypto4.key) : { name: displayName, upiHandles, phoneNumbers: [], relationship: null, notes: null };
     }));
     const res = await client.post("/api/persons/bulk", {
       persons: bodies
@@ -59240,6 +59386,7 @@ async function backfillPersons(client, crypto3, opts = {}) {
       for (const txnId of g2.txnIds)
         links.push({ transactionId: txnId, personId });
     }
+    links.push(...directLinks);
   }
   if (!opts.dryRun && links.length > 0) {
     const CHUNK = 25;
@@ -59355,20 +59502,20 @@ function groupRows(rows) {
 function isCategorizable(r2) {
   return !r2.categoryId && !r2.isTransfer && !r2.isIgnored && !r2.isDuplicate;
 }
-async function fetchUncategorized(client, crypto3, range = {}) {
+async function fetchUncategorized(client, crypto4, range = {}) {
   const params = { uncategorized: "true" };
   if (range.startDate)
     params.startDate = range.startDate;
   if (range.endDate)
     params.endDate = range.endDate;
-  return (await fetchAllRows(client, crypto3, params)).filter(isCategorizable);
+  return (await fetchAllRows(client, crypto4, params)).filter(isCategorizable);
 }
 var MERCHANT_CREATE_CONCURRENCY = 5;
 var titleCase = (s2) => s2.replace(/\b[a-z]/g, (c2) => c2.toUpperCase());
-async function applyGroupAssignments(client, crypto3, assignments, opts = {}) {
+async function applyGroupAssignments(client, crypto4, 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 groups = groupRows(await fetchUncategorized(client, crypto4, opts));
   const result = { applied: [], notFound: [], rulesSaved: 0, unlearnable: [] };
   const plan = [];
   const claimed = new Set;
@@ -59380,7 +59527,13 @@ async function applyGroupAssignments(client, crypto3, assignments, opts = {}) {
     }
     for (const g2 of hits) {
       claimed.add(g2);
-      plan.push({ group: g2, categoryId: cat.id, slug: cat.slug, learn: a2.learn !== false });
+      plan.push({
+        group: g2,
+        categoryId: cat.id,
+        slug: cat.slug,
+        learn: a2.learn !== false,
+        confirmMerchant: !!a2.confirmMerchant
+      });
     }
   }
   result.planHash = planHash(plan.flatMap((p2) => p2.group.rows.map((r2) => r2.id)));
@@ -59414,10 +59567,10 @@ async function applyGroupAssignments(client, crypto3, assignments, opts = {}) {
   const learnPlans = [];
   const directPlans = [];
   for (const p2 of plan) {
-    const { group, learn } = p2;
+    const { group, learn, confirmMerchant } = p2;
     if (!learn || group.pattern === UNPARSED) {
       directPlans.push({ p: p2, reason: learn ? UNPARSED : undefined });
-    } else if (crypto3 && group.rows.some((r2) => isPersonLikeNarration(r2.description))) {
+    } else if (crypto4 && !confirmMerchant && group.rows.some((r2) => isPersonLikeNarration(r2.description))) {
       directPlans.push({ p: p2, reason: `${group.pattern} (private mode: person-like)` });
     } else if (taught.has(group.pattern) && taught.get(group.pattern) !== p2.categoryId) {
       directPlans.push({ p: p2, reason: `${group.pattern} (conflicting category for same pattern)` });
@@ -59515,12 +59668,12 @@ function flagBatchDuplicates(txns) {
     return false;
   });
 }
-async function importTransactions(client, crypto3, opts) {
+async function importTransactions(client, crypto4, opts) {
   let txns = opts.txns;
   let duplicatesSkipped = 0;
   if (txns.length > 0) {
     const dates = txns.map((t2) => t2.date).sort();
-    const existing = await fetchAllRows(client, crypto3, {
+    const existing = await fetchAllRows(client, crypto4, {
       startDate: dates[0],
       endDate: dates[dates.length - 1]
     });
@@ -59536,8 +59689,8 @@ async function importTransactions(client, crypto3, opts) {
     const base = { ...t2, isDuplicate: dupFlags[i2] };
     return enrichedData ? { ...base, enrichedData } : base;
   });
-  if (crypto3)
-    await encryptTransactionFields(rows, crypto3.key);
+  if (crypto4)
+    await encryptTransactionFields(rows, crypto4.key);
   const CHUNK = 200;
   let imported = 0;
   for (let i2 = 0;i2 < rows.length; i2 += CHUNK) {
@@ -59552,19 +59705,19 @@ async function importTransactions(client, crypto3, opts) {
   }
   return { imported, duplicatesSkipped, duplicatesFlagged };
 }
-async function runRescan(client, crypto3) {
+async function runRescan(client, crypto4) {
   let bag = structuredClone(EMPTY_BAG);
   try {
     bag = (await loadBag(client)).bag;
   } catch {}
   const merchantsRes = await client.get("/api/merchants");
   const allMerchants0 = merchantsRes.data ?? [];
-  const allMerchants = crypto3 ? (await decryptMerchantFields(allMerchants0, crypto3.key)).data : allMerchants0;
+  const allMerchants = crypto4 ? (await decryptMerchantFields(allMerchants0, crypto4.key)).data : allMerchants0;
   const globalMerchants = allMerchants.filter((m2) => !m2.householdId && m2.cleanName).map((m2) => ({ id: m2.id, name: m2.cleanName }));
   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 = await fetchAllRows(client, crypto3, { unresolved: "true" });
+  const persons = await loadDecryptedPersons(client, crypto4);
+  const allRows = await fetchAllRows(client, crypto4, { unresolved: "true" });
   const categoryByTxn = new Map(allRows.map((r2) => [r2.id, r2.categoryId]));
   const plan = autoCategorizeFromDescriptions({
     rows: allRows,
@@ -59573,8 +59726,17 @@ async function runRescan(client, crypto3) {
     localMerchants,
     persons
   });
+  const knownMerchants = new Set([
+    ...allMerchants.map((m2) => m2.id),
+    ...allRows.flatMap((r2) => r2.merchantId ? [r2.merchantId] : [])
+  ]);
+  const knownPersons = new Set([
+    ...persons.map((p2) => p2.id),
+    ...allRows.flatMap((r2) => r2.personId ? [r2.personId] : [])
+  ]);
+  const live = plan.suggestions.filter((s2) => s2.entity.type === "merchant" ? knownMerchants.has(s2.entity.merchantId) : knownPersons.has(s2.entity.personId));
   let categorized = 0;
-  const links = plan.suggestions.flatMap((s2) => {
+  const links = live.flatMap((s2) => {
     const categoryId = s2.categoryId ?? (s2.entity.type === "merchant" ? merchantCategoryById.get(s2.entity.merchantId) ?? null : null);
     return s2.transactionIds.map((txId) => {
       const applyCategory = categoryId && !categoryByTxn.get(txId);
@@ -59594,7 +59756,7 @@ var TRUNCATED_WARNING = "TRUNCATED: the API capped this result, so it is INCOMPL
 function withTruncationWarning(data) {
   return data.truncated ? { warning: TRUNCATED_WARNING, ...data } : data;
 }
-function transactionTools(client, crypto3) {
+function transactionTools(client, crypto4) {
   return [
     defineTool({
       name: "get_transactions",
@@ -59641,7 +59803,7 @@ function transactionTools(client, crypto3) {
           apiParams.categoryId = requireCategory(await loadCategoryIndex(client), categorySlug).id;
         }
         if (personName && !apiParams.personId) {
-          const persons = await loadDecryptedPersons(client, crypto3);
+          const persons = await loadDecryptedPersons(client, crypto4);
           const match = resolvePersonByName(persons, personName);
           const err = (error62) => ({ error: error62 });
           if (!match) {
@@ -59658,14 +59820,14 @@ function transactionTools(client, crypto3) {
         const data = await client.get("/api/transactions", Object.fromEntries(Object.entries(apiParams).filter(([, v2]) => v2 !== undefined).map(([k2, v2]) => [k2, String(v2)])));
         let rows = data.data ?? [];
         let undecrypted = [];
-        if (crypto3) {
-          const dec = await decryptTransactionFields(rows, crypto3.key);
+        if (crypto4) {
+          const dec = await decryptTransactionFields(rows, crypto4.key);
           rows = dec.data;
           undecrypted = dec.undecrypted;
         }
         const personNames = new Map;
         if (rows.some((r2) => r2.personId)) {
-          for (const p2 of await loadDecryptedPersons(client, crypto3))
+          for (const p2 of await loadDecryptedPersons(client, crypto4))
             personNames.set(p2.id, p2.name);
         }
         if (full) {
@@ -59696,7 +59858,7 @@ function transactionTools(client, crypto3) {
         limit: exports_external.number().optional().describe("Max groups (default 40, max 100)")
       }),
       handler: async ({ startDate, endDate, minTotal, limit }) => {
-        const rows = await fetchUncategorized(client, crypto3, { startDate, endDate });
+        const rows = await fetchUncategorized(client, crypto4, { startDate, endDate });
         const all2 = groupRows(rows);
         const shown = all2.filter((g2) => g2.total >= (minTotal ?? 0)).slice(0, Math.min(Math.max(limit ?? 40, 1), 100));
         const shownRows = shown.reduce((n2, g2) => n2 + g2.rows.length, 0);
@@ -59723,7 +59885,8 @@ function transactionTools(client, crypto3) {
           pattern: exports_external.string().describe("Exactly as returned"),
           type: exports_external.enum(["debit", "credit"]).optional(),
           categorySlug: exports_external.string(),
-          learn: exports_external.boolean().optional().describe("false = no rule (short/generic patterns)")
+          learn: exports_external.boolean().optional().describe("false = no rule (short/generic patterns)"),
+          confirmMerchant: exports_external.boolean().optional().describe("true = you've confirmed this pattern is a real business (brand lookup, web search, etc), not a person — skips the private-mode person-like block that would otherwise refuse to save a merchant rule")
         })).min(1).max(100),
         startDate: exports_external.string().optional().describe("Same range as the listing"),
         endDate: exports_external.string().optional(),
@@ -59732,7 +59895,7 @@ function transactionTools(client, crypto3) {
       handler: (args, ctx) => {
         const { assignments, startDate, endDate, dryRun } = args;
         const { expectedPlanHash } = args;
-        return applyGroupAssignments(client, crypto3, assignments, {
+        return applyGroupAssignments(client, crypto4, assignments, {
           dryRun,
           startDate,
           endDate,
@@ -59745,7 +59908,7 @@ function transactionTools(client, crypto3) {
       name: "backfill_persons",
       description: "Create persons from UPI/IMPS counterparties in unlinked transactions (deduped by name) and link those transactions to them. Idempotent. dryRun previews.",
       input: exports_external.object({ dryRun: exports_external.boolean().optional() }),
-      handler: (args, ctx) => backfillPersons(client, crypto3, {
+      handler: (args, ctx) => backfillPersons(client, crypto4, {
         onProgress: progressFor(ctx),
         dryRun: args.dryRun,
         expectedPlanHash: args.expectedPlanHash
@@ -59767,8 +59930,8 @@ function transactionTools(client, crypto3) {
       }),
       handler: async ({ id, ...updates }) => {
         const body = { ...updates };
-        if (crypto3 && body.notes)
-          body.notes = await encryptField(body.notes, crypto3.key);
+        if (crypto4 && body.notes)
+          body.notes = await encryptField(body.notes, crypto4.key);
         if (body.categorySlug) {
           const cat = requireCategory(await loadCategoryIndex(client), body.categorySlug);
           body.categoryId = cat.id;
@@ -59817,8 +59980,8 @@ function transactionTools(client, crypto3) {
         }
         if (action === "list") {
           const data2 = await client.get("/api/transactions/duplicates");
-          if (crypto3 && data2.data) {
-            const { data: decrypted, undecrypted } = await decryptTransactionFields(data2.data, crypto3.key);
+          if (crypto4 && data2.data) {
+            const { data: decrypted, undecrypted } = await decryptTransactionFields(data2.data, crypto4.key);
             data2.data = decrypted;
             return withTruncationWarning(undecrypted.length ? { ...data2, undecrypted } : data2);
           }
@@ -59841,8 +60004,8 @@ function transactionTools(client, crypto3) {
       }),
       handler: async ({ accountId, startDate, endDate }) => {
         const data = await client.get("/api/transactions/reconciliation-context", { accountId, startDate, endDate });
-        if (crypto3 && data.data) {
-          const { data: decrypted, undecrypted } = await decryptTransactionFields(data.data, crypto3.key);
+        if (crypto4 && data.data) {
+          const { data: decrypted, undecrypted } = await decryptTransactionFields(data.data, crypto4.key);
           data.data = decrypted;
           return withTruncationWarning(undecrypted.length ? { ...data, undecrypted } : data);
         }
@@ -59929,7 +60092,7 @@ function transactionTools(client, crypto3) {
       name: "rescan_transactions",
       description: "Apply saved learning rules (merchant aliases, category rules) to uncategorized transactions, like the web app's auto-categorize.",
       input: exports_external.object({}),
-      handler: () => runRescan(client, crypto3)
+      handler: () => runRescan(client, crypto4)
     }),
     defineTool({
       name: "get_settlement_candidates",
@@ -59937,8 +60100,8 @@ function transactionTools(client, crypto3) {
       input: exports_external.object({ ccAccountId: exports_external.string().uuid() }),
       handler: async ({ ccAccountId }) => {
         const data = await client.get("/api/transactions/settlement-candidates", { ccAccountId });
-        if (crypto3 && data.data) {
-          const { data: decrypted, undecrypted } = await decryptTransactionFields(data.data, crypto3.key);
+        if (crypto4 && data.data) {
+          const { data: decrypted, undecrypted } = await decryptTransactionFields(data.data, crypto4.key);
           data.data = decrypted;
           return withTruncationWarning(undecrypted.length ? { ...data, undecrypted } : data);
         }
@@ -59955,8 +60118,8 @@ function transactionTools(client, crypto3) {
         if (!row)
           return res;
         let undecrypted = [];
-        if (crypto3) {
-          const dec = await decryptTransactionFields([row], crypto3.key);
+        if (crypto4) {
+          const dec = await decryptTransactionFields([row], crypto4.key);
           row = dec.data[0];
           undecrypted = dec.undecrypted;
         }
@@ -59982,7 +60145,7 @@ function transactionTools(client, crypto3) {
 }
 
 // src/tools/export.ts
-function exportTools(client, crypto3) {
+function exportTools(client, crypto4) {
   return [
     defineTool({
       name: "export_transactions",
@@ -59999,8 +60162,8 @@ function exportTools(client, crypto3) {
           ...Object.fromEntries(Object.entries(params).filter(([, v2]) => v2 !== undefined)),
           format: "json"
         });
-        if (crypto3 && Array.isArray(data?.transactions)) {
-          const { data: decrypted, undecrypted } = await decryptTransactionFields(data.transactions, crypto3.key);
+        if (crypto4 && Array.isArray(data?.transactions)) {
+          const { data: decrypted, undecrypted } = await decryptTransactionFields(data.transactions, crypto4.key);
           data.transactions = decrypted;
           return withTruncationWarning(undecrypted.length ? { ...data, undecrypted } : data);
         }
@@ -60242,28 +60405,28 @@ 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") {
+function assertPrivateModeAllowed(crypto4, env2 = process.env) {
+  if (crypto4 && env2.JEV_ALLOW_PRIVATE_MODE !== "1") {
     throw new Error("Jev categorization is disabled in private mode: it would send transaction text to a third party. " + "To opt in for your own account, set JEV_ALLOW_PRIVATE_MODE=1 in the MCP's environment. " + "Otherwise use get_uncategorized_groups + categorize_groups.");
   }
 }
-function assertJevAllowed(crypto3, env2 = process.env) {
-  assertPrivateModeAllowed(crypto3, env2);
+function assertJevAllowed(crypto4, env2 = process.env) {
+  assertPrivateModeAllowed(crypto4, 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 jevAllowSensitive(crypto3, env2) {
-  return crypto3 === undefined || env2.JEV_ALLOW_PRIVATE_MODE === "1";
+function jevAllowSensitive(crypto4, env2) {
+  return crypto4 === undefined || env2.JEV_ALLOW_PRIVATE_MODE === "1";
 }
-function makeJev(apiKey, crypto3, env2 = process.env, fetchImpl) {
+function makeJev(apiKey, crypto4, env2 = process.env, fetchImpl) {
   return createJev({
     apiKey,
     model: JEV_MODEL,
     minConfidence: DEFAULT_MIN_CONFIDENCE,
     timeoutMs: TIMEOUT_MS,
-    allowSensitive: jevAllowSensitive(crypto3, env2),
+    allowSensitive: jevAllowSensitive(crypto4, env2),
     ...fetchImpl ? { fetch: fetchImpl } : {}
   });
 }
@@ -60283,10 +60446,10 @@ function groupState(type, sample) {
   const dir = type === "credit" ? "Money received" : "Money paid out";
   return `${dir}. Bank narration: "${sample.slice(0, 80)}"`;
 }
-async function jevCategorize(client, crypto3, jev, opts = {}) {
-  assertPrivateModeAllowed(crypto3, opts.env);
+async function jevCategorize(client, crypto4, jev, opts = {}) {
+  assertPrivateModeAllowed(crypto4, opts.env);
   const index = await loadCategoryIndex(client);
-  const rows = await fetchUncategorized(client, crypto3, opts);
+  const rows = await fetchUncategorized(client, crypto4, opts);
   const groups = groupRows(rows);
   const unparsed = groups.filter((g2) => g2.pattern === UNPARSED).length;
   const candidates = groups.filter((g2) => g2.pattern !== UNPARSED);
@@ -60294,7 +60457,7 @@ async function jevCategorize(client, crypto3, jev, opts = {}) {
   const suggestions = await mapLimit(candidates, CONCURRENCY, async (g2) => {
     const options = optionsFor(g2.type, index);
     const sample = g2.rows[0].description;
-    const text = crypto3 ? g2.pattern : sample;
+    const text = crypto4 ? g2.pattern : sample;
     const d2 = await jev.choice({
       question: "Which spending category best fits this bank transaction?",
       options,
@@ -60336,7 +60499,7 @@ async function jevCategorize(client, crypto3, jev, opts = {}) {
     }
   }
   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 applied = await applyGroupAssignments(client, crypto4, 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,
@@ -60353,7 +60516,7 @@ async function jevCategorize(client, crypto3, jev, opts = {}) {
 }
 
 // src/tools/jev.ts
-function jevTools(client, crypto3) {
+function jevTools(client, crypto4) {
   return [
     defineTool({
       name: "auto_categorize_jev",
@@ -60365,9 +60528,9 @@ function jevTools(client, crypto3) {
         dryRun: exports_external.boolean().optional()
       }),
       handler: async ({ startDate, endDate, minConfidence, dryRun }) => {
-        const key = assertJevAllowed(crypto3);
-        const jev = makeJev(key, crypto3);
-        const result = await jevCategorize(client, crypto3, jev, {
+        const key = assertJevAllowed(crypto4);
+        const jev = makeJev(key, crypto4);
+        const result = await jevCategorize(client, crypto4, jev, {
           startDate,
           endDate,
           minConfidence,
@@ -60391,12 +60554,12 @@ function profileVariants(client) {
 function settingsTools(client) {
   const profile = profileVariants(client);
   const household = householdVariants(client);
-  const crypto3 = authCryptoVariants(client);
+  const crypto4 = authCryptoVariants(client);
   const get = unionTool({
     name: "get_settings",
     description: "Read settings. profile: your name, email, owner. household: name, currency, locale, owner labels, members. encryption: mode (standard/private) and whether a PIN verifier / recovery key is set.",
     key: "section",
-    variants: { profile: profile.get, household: household.get, encryption: crypto3.status }
+    variants: { profile: profile.get, household: household.get, encryption: crypto4.status }
   });
   const update = unionTool({
     name: "update_settings",
@@ -60478,7 +60641,7 @@ async function fetchReconciliationContext(client, accountId, start, end, budget
 }
 var sum2 = (rows) => Math.round(rows.reduce((n2, r2) => n2 + r2.amount, 0));
 async function runStatementImport(deps, args) {
-  const { client, crypto: crypto3 } = deps;
+  const { client, crypto: crypto4 } = deps;
   const accounts = (await client.get("/api/accounts")).data ?? [];
   const account = resolveAccount(accounts, args.account);
   const format = pickFormat(account, args.format);
@@ -60497,7 +60660,7 @@ async function runStatementImport(deps, args) {
   }
   const dates = txns.map((t2) => t2.date).sort();
   const existing0 = await fetchReconciliationContext(client, account.id, dates[0], dates[dates.length - 1]);
-  const existing = crypto3 ? (await decryptTransactionFields(existing0, crypto3.key)).data : existing0;
+  const existing = crypto4 ? (await decryptTransactionFields(existing0, crypto4.key)).data : existing0;
   const present = existing.map((r2) => ({ ...r2, isDuplicate: false, isIgnored: false }));
   const result = reconcile(present, { ...statement, transactions: txns });
   const fresh = result.unmatched;
@@ -60538,7 +60701,7 @@ async function runStatementImport(deps, args) {
   if (fresh.length === 0)
     return { ...summary, dryRun: false, imported: 0 };
   const savings = account.type !== "credit_card";
-  const imported = await importTransactions(client, crypto3, {
+  const imported = await importTransactions(client, crypto4, {
     onProgress: deps.onProgress,
     accountId: account.id,
     source: savings ? "bank_statement" : "cc_statement",
@@ -60551,7 +60714,7 @@ async function runStatementImport(deps, args) {
       referenceNumber: t2.referenceNumber ?? undefined
     }))
   });
-  const rescan = await runRescan(client, crypto3);
+  const rescan = await runRescan(client, crypto4);
   return { ...summary, dryRun: false, ...imported, rescan };
 }
 
@@ -60587,16 +60750,16 @@ var statementSource = exports_external.enum([
   "ai_import"
 ]);
 var granularity = exports_external.number().int().min(1).max(5).describe("1=bank, 2=CC, 3=manual, 4=app export, 5=telegram/AI");
-function statementImportTools(client, crypto3) {
+function statementImportTools(client, crypto4) {
   const pdf = (confirm2) => variant(pdfInput, (args, ctx) => runStatementImport({
     client,
-    crypto: crypto3,
+    crypto: crypto4,
     readFile: readFileAsArrayBuffer,
     parsers: realParsers,
     onProgress: progressFor(ctx)
   }, confirm2 ? { ...args, confirm: true } : args));
   const csvParse = variant(exports_external.object({ filePath: exports_external.string() }), async ({ filePath }) => {
-    if (crypto3)
+    if (crypto4)
       return CSV_PRIVATE_MODE_ERROR;
     const buf = await readFile2(filePath);
     const form = new FormData;
@@ -60631,7 +60794,7 @@ function statementImportTools(client, crypto3) {
         skipDuplicates: exports_external.boolean().optional(),
         force: exports_external.boolean().optional()
       }), async ({ filePath, mapping, accountId, owner, skipDuplicates, force }) => {
-        if (crypto3)
+        if (crypto4)
           return CSV_PRIVATE_MODE_ERROR;
         const csvText = await readFile2(filePath, "utf8");
         const data = await client.post("/api/transactions/import/confirm", {
@@ -60656,14 +60819,14 @@ function statementImportTools(client, crypto3) {
           referenceNumber: exports_external.string().optional()
         }))
       }), async ({ accountId, source, granularity: granularity2, transactions: txns }, ctx) => {
-        const data = await importTransactions(client, crypto3, {
+        const data = await importTransactions(client, crypto4, {
           onProgress: progressFor(ctx),
           accountId,
           source,
           granularity: granularity2,
           txns
         });
-        const rescan = await runRescan(client, crypto3);
+        const rescan = await runRescan(client, crypto4);
         return { import: data, rescan };
       }),
       json_file: variant(exports_external.object({
@@ -60687,14 +60850,14 @@ function statementImportTools(client, crypto3) {
         } catch (e2) {
           throw new Error(`Failed to read/parse ${filePath}: ${e2 instanceof Error ? e2.message : String(e2)}`);
         }
-        const data = await importTransactions(client, crypto3, {
+        const data = await importTransactions(client, crypto4, {
           onProgress: progressFor(ctx),
           accountId,
           source,
           granularity: granularity2,
           txns
         });
-        const rescan = await runRescan(client, crypto3);
+        const rescan = await runRescan(client, crypto4);
         return { import: data, count: txns.length, rescan };
       })
     }
@@ -60809,7 +60972,14 @@ function scrubCiphertext(value) {
 }
 async function runTool(tool, args, mcp) {
   const input2 = tool.input ? await tool.input.parseAsync(args) : args;
-  const ctx = { tool: tool.name, signal: mcp.mcpReq.signal, mcp };
+  const ctx = {
+    tool: tool.name,
+    signal: mcp.mcpReq.signal,
+    mcp,
+    confirmSupport: { getClientCapabilities: () => {
+      return;
+    } }
+  };
   return tool.handler(input2, ctx);
 }
 function jsonContents(uri, value) {
@@ -60844,7 +61014,7 @@ function registerResources2(server2, tools) {
 // package.json
 var package_default = {
   name: "paisa-mcp",
-  version: "0.4.1",
+  version: "0.4.3",
   repository: {
     type: "git",
     url: "git+https://github.com/nimit9/paisa.git",
@@ -60873,14 +61043,13 @@ var package_default = {
     "@modelcontextprotocol/server": "^2.1.0",
     "@nimit9/signet-ai": "^0.1.11",
     "@nimit9/signet-lib": "^0.1.15",
-    "@nimit9/signet-server": "^0.2.6",
+    "@nimit9/signet-server": "^0.2.7",
+    "@paisa/crypto": "workspace:*",
     "@paisa/parsers": "workspace:*",
     "@paisa/reconciliation": "workspace:*",
     "@paisa/types": "workspace:*",
-    "@scure/bip39": "^2.2.0",
     "@types/bun": "^1.3.14",
     axios: "^1.16.1",
-    "hash-wasm": "^4.12.0",
     typescript: "^7.0.2",
     zod: "^4.6.5"
   },
@@ -60899,17 +61068,14 @@ function paisaErrorResult(err) {
     content: [{ type: "text", text: err instanceof Error ? err.message : String(err) }]
   });
 }
-function buildServer(client, crypto3) {
-  let initializeCapabilities = () => {
-    return;
-  };
-  const tools = applyAnnotations(REGISTRATIONS.flatMap((group) => group.tools(client, crypto3)).map((t2) => {
-    const caps = () => initializeCapabilities();
+var CONFIRM_KEY2 = randomBytes(32);
+function buildServer(client, crypto4) {
+  const tools = applyAnnotations(REGISTRATIONS.flatMap((group) => group.tools(client, crypto4)).map((t2) => {
     const describe3 = CONFIRMED_TOOLS[t2.name];
     if (describe3)
-      return withConfirmation(t2, describe3, caps);
+      return withConfirmation(t2, describe3);
     const count = BULK_CONFIRMED_TOOLS[t2.name];
-    return count ? withBulkConfirmation(t2, count, caps) : t2;
+    return count ? withBulkConfirmation(t2, count) : t2;
   }));
   for (const t2 of tools)
     if (t2.input)
@@ -60918,9 +61084,9 @@ function buildServer(client, crypto3) {
     name: "paisa",
     version: VERSION2,
     tools,
-    errorResult: paisaErrorResult
+    errorResult: paisaErrorResult,
+    confirm: { key: CONFIRM_KEY2 }
   });
-  initializeCapabilities = () => server2.server.getClientCapabilities();
   registerResources2(server2, tools);
   registerPrompts2(server2);
   return server2;
@@ -60947,5 +61113,5 @@ main().catch((err) => {
   process.exit(1);
 });
 
-//# debugId=882108748FF621AF64756E2164756E21
+//# debugId=1892106D83105DD764756E2164756E21
 //# sourceMappingURL=index.js.map