merge: categorizer refactor — :MCI: merchant recovery + real-merchant rules

src/features/accounting/CategorizeReview.tsx

@@ -4,11 +4,13 @@ import { useEffect, useMemo, useState } from "react";
 import { useRouter } from "next/navigation";
 import { useCategories, useTransactions, todayLocalDate } from "@/api/hooks/reads";
 import { useCategorize } from "@/api/hooks/mutations";
-import type { Txn } from "@/api/schemas";
+import type { Category, Txn } from "@/api/schemas";
 import { Card, EmptyState, IconChip, MercuryButton } from "@/ds";
 import { categoryStyle } from "@/ds/categoryStyle";
 import { Icon } from "@/ds/icons";
 import { MASKED, tugrikRaw } from "@/ds/money";
+import { CategorizeSheet } from "./CategorizeSheet";
+import { suggestCategory, extractMerchant, looksLikeCardNumber } from "./suggestCategory";
 import { accountingStrings as s } from "./strings";
 import { useHiddenAmounts } from "./useHiddenAmounts";
 
@@ -26,6 +28,17 @@ function threeMonthsAgo(base: Date = new Date()): Date {
   return new Date(base.getFullYear(), base.getMonth() - 3, base.getDate());
 }
 
+/** Spending transactions worth reviewing: excludes auto-detected salary
+ * deposits, any income, and inter-account transfers — those aren't expenses
+ * to categorize. Shared by the uncategorized queue and the coverage
+ * denominator so both count the same population. */
+function isReviewableSpend(t: Txn): boolean {
+  if (t.salary === true) return false;
+  if (t.direction === "income") return false;
+  if (t.transfer === true) return false;
+  return Boolean(t.matchKey || t.title);
+}
+
 /** Groups uncategorized transactions by matchKey, biggest total spend first —
  * a handful of taps then covers most of the uncategorized money instead of
  * burning through many trivial merchants. Ports the grouping in
@@ -34,6 +47,7 @@ function buildQueue(txns: Txn[]): ReviewItem[] {
   const groups = new Map<string, ReviewItem>();
   for (const t of txns) {
     if (t.category) continue; // defensive — the fetch already scopes to Uncategorized
+    if (!isReviewableSpend(t)) continue;
     const key = t.matchKey || t.title;
     if (!key) continue;
     const amount = parseFloat(t.amount) || 0;
@@ -54,11 +68,166 @@ function buildQueue(txns: Txn[]): ReviewItem[] {
   return Array.from(groups.values()).sort((a, b) => b.total - a.total);
 }
 
+// Masked card strings like "554835******6886:13-08-2026 09:41:22" carry a
+// trailing timestamp and no real merchant name — collapse them to a short
+// "card ending in ####" label instead of dumping the raw string on the row.
+const CARD_LIKE = /^(\d{3,})\*{2,}(\d{2,})/;
+
+function prettyMerchant(raw: string): string {
+  const name = extractMerchant(raw); // recovers "ANTHROPIC"/"TAOBAO" from card strings
+  if (name && !looksLikeCardNumber(name)) return name;
+  const head = (raw.split(":")[0] ?? raw).trim();
+  const m = head.match(CARD_LIKE);
+  return m ? `Карт •••• ${m[2]}` : head || raw;
+}
+
+interface Row extends ReviewItem {
+  displayName: string;
+  suggestion: string | null;
+}
+
+function toRows(queue: ReviewItem[], categories: Category[]): Row[] {
+  return queue.map((item) => ({
+    ...item,
+    displayName: prettyMerchant(item.merchant),
+    suggestion: suggestCategory(item.merchant, categories),
+  }));
+}
+
+const checkSvg = (
+  <svg viewBox="0 0 24 24" width={18} height={18} fill="none" stroke="currentColor" strokeWidth={2.5} strokeLinecap="round" strokeLinejoin="round">
+    <path d="M5 12.5l4.5 4.5L19 7" />
+  </svg>
+);
+
+function ProgressBar({ percent }: { percent: number }) {
+  return (
+    <div
+      style={{
+        height: 6,
+        borderRadius: 999,
+        background: "var(--seed-color-bg-neutral-subtle, #eef0f2)",
+        overflow: "hidden",
+      }}
+    >
+      <div
+        style={{
+          height: "100%",
+          width: `${Math.max(0, Math.min(100, percent))}%`,
+          borderRadius: 999,
+          background: "var(--mercury-success, #1e9e6b)",
+          transition: "width 300ms ease",
+        }}
+      />
+    </div>
+  );
+}
+
+function ReviewRow({
+  row,
+  hidden,
+  busy,
+  removing,
+  onConfirm,
+  onPick,
+}: {
+  row: Row;
+  hidden: boolean;
+  busy: boolean;
+  removing: boolean;
+  onConfirm: (row: Row) => void;
+  onPick: (row: Row) => void;
+}) {
+  const chip = row.suggestion ? categoryStyle(row.suggestion, false) : null;
+
+  return (
+    <div
+      style={{
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "space-between",
+        gap: 12,
+        padding: "10px 0",
+        opacity: removing ? 0 : 1,
+        transform: removing ? "translateX(6px)" : "translateX(0)",
+        transition: "opacity 220ms ease, transform 220ms ease",
+      }}
+    >
+      <div style={{ display: "flex", alignItems: "center", gap: 12, minWidth: 0 }}>
+        <IconChip
+          icon={chip?.icon ?? "receipt"}
+          tint={chip?.tint ?? "var(--seed-color-bg-neutral-subtle, #eef0f2)"}
+          fg={chip?.fg ?? "var(--seed-color-fg-neutral-muted, #8b8b8b)"}
+        />
+        <div style={{ display: "flex", flexDirection: "column", gap: 2, minWidth: 0 }}>
+          <span style={{ fontSize: 15, fontWeight: 700, overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" }}>
+            {row.displayName}
+          </span>
+          <span style={{ fontSize: 12, color: "var(--seed-color-fg-neutral-muted, #8b8b8b)" }}>
+            ×{row.count} · {hidden ? MASKED : tugrikRaw(row.total)}
+          </span>
+        </div>
+      </div>
+
+      <div style={{ display: "flex", alignItems: "center", gap: 8, flexShrink: 0 }}>
+        <button
+          type="button"
+          onClick={() => onPick(row)}
+          disabled={busy}
+          style={{
+            all: "unset",
+            cursor: busy ? "default" : "pointer",
+            display: "flex",
+            alignItems: "center",
+            gap: 6,
+            padding: "8px 12px",
+            borderRadius: 999,
+            fontSize: 13,
+            fontWeight: 600,
+            opacity: busy ? 0.6 : 1,
+            background: chip?.tint ?? "var(--seed-color-bg-neutral-subtle, #eef0f2)",
+            color: chip?.fg ?? "var(--seed-color-fg-neutral-muted, #8b8b8b)",
+          }}
+        >
+          <Icon name={chip?.icon ?? "list"} size={14} />
+          {chip ? chip.name : s.review.pickCategory}
+        </button>
+        {row.suggestion ? (
+          <button
+            type="button"
+            aria-label={s.review.confirm}
+            onClick={() => onConfirm(row)}
+            disabled={busy}
+            style={{
+              all: "unset",
+              cursor: busy ? "default" : "pointer",
+              display: "grid",
+              placeItems: "center",
+              width: 32,
+              height: 32,
+              borderRadius: "50%",
+              opacity: busy ? 0.6 : 1,
+              background: "var(--mercury-success, #1e9e6b)",
+              color: "#fff",
+            }}
+          >
+            {checkSvg}
+          </button>
+        ) : null}
+      </div>
+    </div>
+  );
+}
+
 /**
- * Full-screen categorize-review flow at `/accounting/review` (ports
+ * Batch categorize-review screen at `/accounting/review`: every uncategorized
- * `CategorizeReviewView.swift`): groups the last three months' uncategorized
+ * merchant from the last three months, biggest spend first, in one scannable
- * transactions by merchant, biggest spend first, and asks the user to assign
+ * list with an auto-suggested category per row. Confirming a suggestion (or
- * or skip a category one merchant at a time.
+ * picking a different category) posts a retroactive rule via `useCategorize`
+ * that categorizes all matching past + future transactions server-side — the
+ * row then animates out. "Бүгдийг санал болгосноор ангилах" applies every
+ * confident suggestion in one pass. Replaces the old one-merchant-at-a-time
+ * `CategorizeReviewView.swift` port.
  */
 export function CategorizeReview() {
   const router = useRouter();
@@ -67,40 +236,84 @@ export function CategorizeReview() {
     return { from: todayLocalDate(threeMonthsAgo(now)), to: todayLocalDate(now) };
   }, []);
   const { data, isLoading } = useTransactions({ from, to, category: "Uncategorized", limit: 500 });
-  const { data: categories = [] } = useCategories();
+  // Same 3-month window, unfiltered — only used as the coverage bar's fixed
+  // denominator (total reviewable spend transactions), not re-rendered as a list.
+  const { data: allData } = useTransactions({ from, to, limit: 500 });
+  const { data: categoriesData } = useCategories();
+  const categories = categoriesData ?? [];
   const categorize = useCategorize();
   const hidden = useHiddenAmounts();
 
-  // The queue is seeded once from the fetch, then mutated locally (skip
+  // The queue is seeded once from the fetch, then mutated locally (assign
-  // removes, assign removes on success) — re-deriving it from `data` on every
+  // removes on success) — re-deriving it from `data` on every background
-  // background refetch (categorize invalidates the transactions cache) would
+  // refetch (categorize invalidates the transactions cache) would otherwise
-  // otherwise re-insert items the user already handled in this session.
+  // re-insert items the user already handled in this session.
   const [queue, setQueue] = useState<ReviewItem[] | null>(null);
   useEffect(() => {
     if (data && queue === null) setQueue(buildQueue(data));
   }, [data, queue]);
 
+  const [removingKeys, setRemovingKeys] = useState<Set<string>>(new Set());
+  const [pickerFor, setPickerFor] = useState<ReviewItem | null>(null);
+  const [bulkRunning, setBulkRunning] = useState(false);
+  const [bulkProgress, setBulkProgress] = useState({ done: 0, total: 0 });
+
+  const rows = useMemo(() => (queue ? toRows(queue, categories) : []), [queue, categories]);
   const mainCategories = useMemo(() => categories.filter((c) => c.depth === 1), [categories]);
 
+  const totalSpend = useMemo(
+    () => (allData ? allData.filter(isReviewableSpend).length : null),
+    [allData],
+  );
+  const remainingCount = useMemo(() => rows.reduce((sum, r) => sum + r.count, 0), [rows]);
+  const percent =
+    totalSpend && totalSpend > 0 ? Math.round(((totalSpend - remainingCount) / totalSpend) * 100) : null;
+
   function close() {
     router.push("/accounting");
   }
 
-  function skip(item: ReviewItem) {
+  function removeItem(matchKey: string) {
-    setQueue((q) => (q ? q.filter((i) => i.matchKey !== item.matchKey) : q));
+    setRemovingKeys((r) => new Set(r).add(matchKey));
+    setTimeout(() => {
+      setQueue((q) => (q ? q.filter((i) => i.matchKey !== matchKey) : q));
+      setRemovingKeys((r) => {
+        const next = new Set(r);
+        next.delete(matchKey);
+        return next;
+      });
+    }, 220);
   }
 
   function assign(item: ReviewItem, category: string) {
     categorize.mutate(
       { matchKey: item.matchKey, category, kind: item.direction },
-      { onSuccess: () => setQueue((q) => (q ? q.filter((i) => i.matchKey !== item.matchKey) : q)) },
+      { onSuccess: () => removeItem(item.matchKey) },
     );
   }
 
-  const current = queue?.[0];
+  async function runBulk() {
+    const targets = rows.filter((r) => r.suggestion);
+    if (targets.length === 0) return;
+    setBulkRunning(true);
+    setBulkProgress({ done: 0, total: targets.length });
+    for (const row of targets) {
+      try {
+        await categorize.mutateAsync({ matchKey: row.matchKey, category: row.suggestion!, kind: row.direction });
+        removeItem(row.matchKey);
+      } catch {
+        // Leave it in the queue on failure so the user can retry it manually.
+      }
+      setBulkProgress((p) => ({ ...p, done: p.done + 1 }));
+    }
+    setBulkRunning(false);
+  }
+
+  const confidentCount = rows.filter((r) => r.suggestion).length;
+  const busy = categorize.isPending || bulkRunning;
 
   return (
-    <div style={{ display: "flex", flexDirection: "column", gap: 20 }}>
+    <div style={{ display: "flex", flexDirection: "column", gap: 16 }}>
       <div style={{ display: "flex", alignItems: "center", justifyContent: "space-between" }}>
         <h1 style={{ fontSize: 18, fontWeight: 700, margin: 0 }}>{s.review.title}</h1>
         <button
@@ -113,64 +326,60 @@ export function CategorizeReview() {
       </div>
 
       {isLoading && queue === null ? (
-        <Card style={{ minHeight: 320 }} />
+        <Card style={{ minHeight: 200 }} />
-      ) : current ? (
+      ) : rows.length > 0 ? (
         <>
-          <p style={{ margin: 0, fontSize: 13, color: "var(--seed-color-fg-neutral-muted, #8b8b8b)" }}>
+          <Card style={{ display: "flex", flexDirection: "column", gap: 8 }}>
-            {s.review.remaining(queue!.length)}
+            <div style={{ display: "flex", alignItems: "baseline", justifyContent: "space-between" }}>
-          </p>
+              <span style={{ fontSize: 14, fontWeight: 700 }}>{s.review.remaining(remainingCount)}</span>
-
+              {percent !== null ? (
-          <Card style={{ display: "flex", flexDirection: "column", alignItems: "center", gap: 8, padding: "24px 16px" }}>
+                <span style={{ fontSize: 13, color: "var(--seed-color-fg-neutral-muted, #8b8b8b)" }}>
-            <IconChip icon="cart" tint="var(--seed-color-bg-neutral-subtle, #eef0f2)" fg="var(--seed-color-fg-neutral)" size={56} />
+                  {s.review.coverage(percent)}
-            <span style={{ fontSize: 16, fontWeight: 700, textAlign: "center" }}>{current.merchant}</span>
-            <span style={{ fontSize: 12, color: "var(--seed-color-fg-neutral-muted, #8b8b8b)" }}>
-              {s.review.transactionCount(current.count)} · {hidden ? MASKED : tugrikRaw(current.total)}
                 </span>
+              ) : null}
+            </div>
+            {percent !== null ? <ProgressBar percent={percent} /> : null}
           </Card>
 
-          <p style={{ margin: 0, fontSize: 14, fontWeight: 700 }}>{s.review.question}</p>
+          <MercuryButton variant="primary" onClick={runBulk} disabled={busy || confidentCount === 0}>
-
+            {bulkRunning ? s.review.bulkProgress(bulkProgress.done, bulkProgress.total) : s.review.bulkApply}
-          <div style={{ display: "flex", flexWrap: "wrap", gap: 10 }}>
-            {mainCategories.map((cat) => {
-              const style = categoryStyle(cat.name, cat.kind === "income");
-              return (
-                <button
-                  key={cat.name}
-                  type="button"
-                  onClick={() => assign(current, cat.name)}
-                  disabled={categorize.isPending}
-                  style={{
-                    all: "unset",
-                    cursor: categorize.isPending ? "default" : "pointer",
-                    display: "flex",
-                    alignItems: "center",
-                    gap: 6,
-                    padding: "10px 14px",
-                    borderRadius: 999,
-                    fontSize: 14,
-                    opacity: categorize.isPending ? 0.6 : 1,
-                    background: "var(--seed-color-bg-neutral-subtle, #eef0f2)",
-                  }}
-                >
-                  <Icon name={style.icon} size={16} />
-                  {style.name}
-                </button>
-              );
-            })}
-          </div>
-
-          <MercuryButton variant="secondary" onClick={() => skip(current)}>
-            {s.review.skip}
           </MercuryButton>
+
+          <Card style={{ display: "flex", flexDirection: "column" }}>
+            {rows.map((row) => (
+              <ReviewRow
+                key={row.matchKey}
+                row={row}
+                hidden={hidden}
+                busy={busy}
+                removing={removingKeys.has(row.matchKey)}
+                onConfirm={(r) => assign(r, r.suggestion!)}
+                onPick={(r) => setPickerFor(r)}
+              />
+            ))}
+          </Card>
         </>
       ) : (
         <>
-          <EmptyState icon="calendar-check" title={s.review.done} />
+          <EmptyState icon="calendar-check" title={s.review.done} hint={s.review.doneHint} />
           <MercuryButton variant="primary" onClick={close}>
             {s.review.close}
           </MercuryButton>
         </>
       )}
+
+      <CategorizeSheet
+        open={pickerFor !== null}
+        onOpenChange={(open) => {
+          if (!open) setPickerFor(null);
+        }}
+        categories={mainCategories}
+        selected={pickerFor ? (suggestCategory(pickerFor.merchant, categories) ?? undefined) : undefined}
+        onSelect={(cat) => {
+          if (pickerFor) assign(pickerFor, cat.name);
+          setPickerFor(null);
+        }}
+      />
     </div>
   );
 }

src/features/accounting/TransactionList.tsx

@@ -163,7 +163,15 @@ export function TransactionList() {
   const categoryOptions = useMemo(() => categoriesIn(all), [all]);
 
   const hasUncategorized = useMemo(
-    () => all.some((txn) => !txn.category && (txn.matchKey || txn.title)),
+    () =>
+      all.some(
+        (txn) =>
+          !txn.category &&
+          txn.salary !== true &&
+          txn.transfer !== true &&
+          txn.direction !== "income" &&
+          (txn.matchKey || txn.title),
+      ),
     [all],
   );
 

src/features/accounting/strings.ts

@@ -20,12 +20,16 @@ export const accountingStrings = {
   review: {
     title: "Ангилалжуулах",
     later: "Дараа нь",
-    remaining: (n: number) => `${n} ангилалгүй худалдагч үлдлээ`,
+    remaining: (n: number) => `${n} ангилаагүй үлдлээ`,
-    question: "Аль ангилалд хамаарах вэ?",
+    coverage: (pct: number) => `${pct}% ангилагдсан`,
-    skip: "Алгасах",
-    done: "Бүгд ангилагдлаа",
-    close: "Хаах",
     transactionCount: (n: number) => `${n} гүйлгээ`,
+    bulkApply: "Бүгдийг санал болгосноор ангилах",
+    bulkProgress: (done: number, total: number) => `${done}/${total} ангилж байна…`,
+    confirm: "Баталгаажуулах",
+    pickCategory: "Ангилал сонгох",
+    done: "Бүгд ангилагдлаа",
+    doneHint: "Шинэ гүйлгээ ирвэл дүрмийн дагуу автоматаар ангилагдана.",
+    close: "Хаах",
   },
   detail: {
     total: "Нийт",

src/features/accounting/suggestCategory.test.ts

@@ -0,0 +1,159 @@
+import { describe, it, expect } from "vitest";
+import { suggestCategory, extractMerchant, looksLikeCardNumber } from "./suggestCategory";
+import type { Category } from "@/api/schemas";
+
+function cat(name: string, kind: "income" | "expense" = "expense", depth = 1): Category {
+  return { name, kind, depth };
+}
+
+const CATEGORIES: Category[] = [
+  cat("Food & Drink"),
+  cat("Coffee"),
+  cat("Transport"),
+  cat("Shopping"),
+  cat("Bills & Services"),
+  cat("Entertainment"),
+  cat("Groceries"),
+  cat("Insurance"),
+  cat("Electronics"),
+];
+
+describe("extractMerchant", () => {
+  it("pulls the real merchant out of a card string's :MCI: segment", () => {
+    expect(extractMerchant("554835******6886:30-07-2026 11:02:10:MCI:ANTHROPIC 1")).toBe("ANTHROPIC");
+    expect(extractMerchant("554835******6886:13-08-2026 12:13:52:MCI:WWW HOSTI 5")).toBe("WWW HOSTI");
+    expect(extractMerchant("554835******6886:11-08-2026 10:07:35:MCI:TAOBAO CO 4")).toBe("TAOBAO CO");
+  });
+
+  it("falls back to the head before the first colon when there's no :MCI: segment", () => {
+    expect(extractMerchant("ЛИЗИНГ ХХК")).toBe("ЛИЗИНГ ХХК");
+    expect(extractMerchant("1234******5678")).toBe("1234******5678");
+  });
+});
+
+describe("suggestCategory — real card charges (:MCI: merchant extraction)", () => {
+  it("suggests Bills & Services for ANTHROPIC (no Software/Subscriptions category present)", () => {
+    expect(suggestCategory("554835******6886:30-07-2026 11:02:10:MCI:ANTHROPIC 1", CATEGORIES)).toBe(
+      "Bills & Services",
+    );
+  });
+
+  it("prefers Software over Bills & Services when the category exists", () => {
+    const withSoftware = [...CATEGORIES, cat("Software")];
+    expect(suggestCategory("554835******6886:30-07-2026 11:02:10:MCI:ANTHROPIC 1", withSoftware)).toBe("Software");
+  });
+
+  it("suggests Bills & Services for a hosting merchant (WWW HOSTI)", () => {
+    expect(suggestCategory("554835******6886:13-08-2026 12:13:52:MCI:WWW HOSTI 5", CATEGORIES)).toBe(
+      "Bills & Services",
+    );
+  });
+
+  it("suggests Shopping for TAOBAO", () => {
+    expect(suggestCategory("554835******6886:11-08-2026 10:07:35:MCI:TAOBAO CO 4", CATEGORIES)).toBe("Shopping");
+  });
+});
+
+describe("suggestCategory — local merchants", () => {
+  it("matches ТОКИ (non-bank lender) to Loan", () => {
+    const withLoan = [...CATEGORIES, cat("Loan")];
+    expect(suggestCategory("ТОКИ ББСБ ХХК", withLoan)).toBe("Loan");
+  });
+
+  it("falls back to Bills & Services when Loan doesn't exist", () => {
+    expect(suggestCategory("ЛИЗИНГ ХХК", CATEGORIES)).toBe("Bills & Services");
+  });
+
+  it("matches the Cyrillic ЗЭЭЛ keyword (word-boundary-free, Cyrillic-safe)", () => {
+    const withLoan = [...CATEGORIES, cat("Loan")];
+    expect(suggestCategory("ХААН ЗЭЭЛ ТӨЛБӨР", withLoan)).toBe("Loan");
+  });
+
+  it("matches TUSHIG to Groceries", () => {
+    expect(suggestCategory("TUSHIG SUPERMARKET", CATEGORIES)).toBe("Groceries");
+  });
+
+  it("matches other grocery keywords", () => {
+    expect(suggestCategory("NOMIN SUPERMARKET", CATEGORIES)).toBe("Groceries");
+    expect(suggestCategory("CU-24 CONVENIENCE", CATEGORIES)).toBe("Groceries");
+    expect(suggestCategory("ХҮНСНИЙ ДЭЛГҮҮР", CATEGORIES)).toBe("Groceries");
+  });
+
+  it("matches insurance keywords", () => {
+    expect(suggestCategory("MONGOL ДААТГАЛ LLC", CATEGORIES)).toBe("Insurance");
+    expect(suggestCategory("SOME INSURANCE CO", CATEGORIES)).toBe("Insurance");
+  });
+
+  it("matches electronics retailers", () => {
+    expect(suggestCategory("MAGIC TECH STORE", CATEGORIES)).toBe("Electronics");
+    expect(suggestCategory("ITOPIA MALL", CATEGORIES)).toBe("Electronics");
+  });
+
+  it("matches mobile carriers to Bills & Services", () => {
+    expect(suggestCategory("MOBICOM PAYMENT", CATEGORIES)).toBe("Bills & Services");
+    expect(suggestCategory("UNITEL TOP UP", CATEGORIES)).toBe("Bills & Services");
+  });
+
+  it("matches apparel/shopping brands", () => {
+    expect(suggestCategory("CONVERSE STORE", CATEGORIES)).toBe("Shopping");
+    expect(suggestCategory("SANT ASAR TRADE", CATEGORIES)).toBe("Shopping");
+  });
+
+  it("matches gaming merchants to Entertainment", () => {
+    expect(suggestCategory("STEAM GAMES", CATEGORIES)).toBe("Entertainment");
+    expect(suggestCategory("PGAMING WALLET", CATEGORIES)).toBe("Entertainment");
+  });
+
+  it("matches CAFE/КАФЕ to Coffee, not Food & Drink", () => {
+    expect(suggestCategory("КАФЕ МОДЕРН", CATEGORIES)).toBe("Coffee");
+    expect(suggestCategory("TOM CAFE LLC", CATEGORIES)).toBe("Coffee");
+    expect(suggestCategory("КОФЕ ЦЭГ", CATEGORIES)).toBe("Coffee");
+    expect(suggestCategory("STARBUCKS COFFEE", CATEGORIES)).toBe("Coffee");
+  });
+
+  it("matches restaurant/food keywords (no CAFE overlap) to Food & Drink", () => {
+    expect(suggestCategory("KFC ULAANBAATAR", CATEGORIES)).toBe("Food & Drink");
+    expect(suggestCategory("ХООЛНЫ ГАЗАР", CATEGORIES)).toBe("Food & Drink");
+    expect(suggestCategory("BURGER KING", CATEGORIES)).toBe("Food & Drink");
+  });
+
+  it("matches transport/fuel keywords", () => {
+    expect(suggestCategory("UBCAB TRIP", CATEGORIES)).toBe("Transport");
+    expect(suggestCategory("ШАТАХУУНЫ СТАНЦ", CATEGORIES)).toBe("Transport");
+  });
+});
+
+describe("suggestCategory — no signal", () => {
+  it("returns null for a masked card number with no :MCI: merchant segment", () => {
+    expect(suggestCategory("554835******6886:13-08-2026 09:41:22", CATEGORIES)).toBeNull();
+    expect(suggestCategory("1234******5678", CATEGORIES)).toBeNull();
+  });
+
+  it("returns null when nothing matches", () => {
+    expect(suggestCategory("TLJ CENTR", CATEGORIES)).toBeNull();
+    expect(suggestCategory("TSENGELDE", CATEGORIES)).toBeNull();
+  });
+
+  it("returns null when every matching rule's candidates are all absent", () => {
+    // The phone-carrier rule has a single candidate ("Bills & Services") with
+    // no fallback, unlike Loan/Insurance/Groceries/Electronics which fall
+    // back to a broader category — removing it leaves nothing to suggest.
+    const noBills = CATEGORIES.filter((c) => c.name !== "Bills & Services");
+    expect(suggestCategory("MOBICOM PAYMENT", noBills)).toBeNull();
+  });
+
+  it("returns null for empty input", () => {
+    expect(suggestCategory("", CATEGORIES)).toBeNull();
+  });
+});
+
+describe("looksLikeCardNumber", () => {
+  it("recognizes a masked card head as a card number", () => {
+    expect(looksLikeCardNumber("554835******6886")).toBe(true);
+  });
+
+  it("does not flag a normal merchant name", () => {
+    expect(looksLikeCardNumber("ANTHROPIC")).toBe(false);
+    expect(looksLikeCardNumber("ТОКИ ББСБ ХХК")).toBe(false);
+  });
+});

src/features/accounting/suggestCategory.ts

@@ -0,0 +1,79 @@
+import type { Category } from "@/api/schemas";
+
+/** Card/online charges arrive as a masked-card string with the real merchant
+ * buried after the last `:MCI:` segment, e.g.
+ * `"554835******6886:30-07-2026 11:02:10:MCI:ANTHROPIC 1"` → `"ANTHROPIC"`.
+ * Returns the cleaned merchant name (trailing sequence number stripped), or the
+ * head before the first colon for normal names. */
+export function extractMerchant(raw: string): string {
+  const s = (raw ?? "").trim();
+  const mci = s.split(/:MCI:/i);
+  if (mci.length > 1) {
+    const m = mci[mci.length - 1].replace(/\s+\d+$/, "").trim();
+    if (m) return m;
+  }
+  return (s.split(":")[0] ?? s).trim();
+}
+
+/** True when the string is (still) mostly a masked card number with no merchant
+ * signal — e.g. a card charge with no `:MCI:` merchant segment. */
+export function looksLikeCardNumber(s: string): boolean {
+  const head = (s.split(":")[0] ?? s).trim();
+  if (/^\d{4,}\*{2,}/.test(head)) return true;
+  const digits = (s.match(/\d/g) ?? []).length;
+  const stars = (s.match(/\*/g) ?? []).length;
+  return stars >= 2 && digits / Math.max(s.length, 1) > 0.4;
+}
+
+interface Rule {
+  pattern: RegExp;
+  candidates: string[];
+}
+
+// Ordered — earlier rules win when a merchant matches more than one. Keyed to
+// the REAL uncategorized merchants in the data (incl. the merchant extracted
+// from card strings). Each rule's candidates are tried in order; the first that
+// exists in the user's category list is used, so a specific child (Groceries,
+// Loan, Electronics) falls back to its depth-1 parent when absent. Add new
+// merchants here rather than growing suggestCategory()'s logic.
+const RULES: Rule[] = [
+  { pattern: /ANTHROPIC|OPENAI|CLAUDE|GITHUB|VERCEL|\bAWS\b|HOSTI|\bWWW\b|GOOGLE|NETLIFY/i, candidates: ["Software", "Subscriptions", "Bills & Services"] },
+  { pattern: /TAOBAO|ALIEXPRESS|ALIPAY|AMAZON|WISH/i, candidates: ["Shopping"] },
+  // Note: no `\b` word-boundary around the Cyrillic keywords — JS's `\b` is
+  // defined in terms of `\w` ([A-Za-z0-9_]), which doesn't include Cyrillic
+  // letters, so `\bЗЭЭЛ\b` would never match any Cyrillic text at all.
+  { pattern: /ЛИЗИНГ|ТОКИ|АВДАР|ББСБ|ЗЭЭЛ|LOAN|LEASING/i, candidates: ["Loan", "Bills & Services"] },
+  { pattern: /ДААТГАЛ|INSURANCE/i, candidates: ["Insurance", "Bills & Services"] },
+  { pattern: /MOBICOM|UNITEL|SKYTEL|GMOBILE|ONDO/i, candidates: ["Bills & Services"] },
+  { pattern: /TUSHIG|CARREFOUR|NOMIN|MART|МАРКЕТ|CU-|GS25|MINII|ХҮНС|GROCER/i, candidates: ["Groceries", "Food & Drink"] },
+  { pattern: /MAGIC TEC|ELECTRONI|ITOPIA|TOPAZ|ELECTRO/i, candidates: ["Electronics", "Shopping"] },
+  { pattern: /PGAMING|GAMING|STEAM|PLAYSTATION|XBOX/i, candidates: ["Entertainment"] },
+  // CAFE/КАФЕ live here (not in the Food & Drink rule below) per the latest
+  // keyword grounding — a bare "cafe" name reads as a coffee spot first.
+  { pattern: /КОФЕ|COFFEE|TOM N TOMS|CAFE|КАФЕ/i, candidates: ["Coffee", "Food & Drink"] },
+  { pattern: /ХООЛ|RESTAURANT|KFC|PIZZA|BURGER/i, candidates: ["Food & Drink"] },
+  { pattern: /TAXI|UBCAB|ТЭЭВЭР|PETROL|ШАТАХУУН|BENZIN/i, candidates: ["Transport"] },
+  { pattern: /CONVERSE|WARRIOR|PASTEL|OLYMPIC|НЭКСУС|SANT ASAR|STORE|SHOP|ДЭЛГҮҮР/i, candidates: ["Shopping"] },
+];
+
+/**
+ * Suggests one of the user's existing categories for an uncategorized merchant,
+ * from a keyword heuristic keyed to the real merchants seen in the data. The
+ * merchant name is first extracted from any card string (`:MCI:ANTHROPIC`).
+ * Returns `null` (user picks) when nothing matches, when the matching rule's
+ * candidates are all absent, or when the string is a card number with no
+ * recoverable merchant.
+ */
+export function suggestCategory(merchant: string, categories: Category[]): string | null {
+  const text = extractMerchant(merchant);
+  if (!text || looksLikeCardNumber(text)) return null;
+
+  const names = new Set(categories.map((c) => c.name));
+  for (const rule of RULES) {
+    if (!rule.pattern.test(text)) continue;
+    for (const candidate of rule.candidates) {
+      if (names.has(candidate)) return candidate;
+    }
+  }
+  return null;
+}