plasalid 0.5.7 → 0.6.0

package/dist/cli/commands/scan.js

@@ -59,20 +59,10 @@ async function buildInkEvents(parallel) {
             fileName: e.fileName,
             status: e.status,
             transactions: e.transactions,
-            concerns: e.concerns,
+            unknowns: e.unknowns,
             error: e.error,
         }),
-        correlating: (pairs) => {
-            if (inkInstance) {
-                inkInstance.unmount();
-                inkInstance = null;
-            }
-            if (mountedFiles > 0 && pairs > 0) {
-                console.log(chalk.dim(`Correlating across files... ${pairs} pair(s) flagged.`));
-            }
-        },
         committing: () => {
-            // In case correlating fired with 0 pairs, ink may still be mounted; unmount now.
             if (inkInstance) {
                 inkInstance.unmount();
                 inkInstance = null;
@@ -80,6 +70,11 @@ async function buildInkEvents(parallel) {
             if (mountedFiles > 0)
                 console.log(chalk.dim("Committing..."));
         },
+        inspecting: (result) => {
+            if (mountedFiles > 0 && result.total > 0) {
+                console.log(chalk.dim(`Inspectors flagged ${result.total} unknown(s).`));
+            }
+        },
     };
 }
 /** Plain-text progress (non-TTY or fallback) */
@@ -112,19 +107,20 @@ function buildPlainTextEvents() {
         scanEnd: (e) => {
             lastStepByFile.delete(e.fileName);
             if (e.status === "scanned") {
-                console.log(`${chalk.green("✓")} ${e.fileName} ${chalk.dim(`(${e.transactions} transactions, ${e.concerns} concerns)`)}`);
+                console.log(`${chalk.green("✓")} ${e.fileName} ${chalk.dim(`(${e.transactions} transactions, ${e.unknowns} unknowns)`)}`);
             }
             else {
                 console.log(`${chalk.red("✗")} ${e.fileName} ${chalk.dim(`— ${e.error ?? "failed"}`)}`);
             }
         },
-        correlating: (pairs) => {
-            if (pairs > 0)
-                console.log(chalk.dim(`Correlating across files... ${pairs} pair(s) flagged.`));
-        },
         committing: () => {
             console.log(chalk.dim("Committing..."));
         },
+        inspecting: (result) => {
+            if (result.total > 0) {
+                console.log(chalk.dim(`Inspectors flagged ${result.total} unknown(s).`));
+            }
+        },
     };
 }
 /** Terse summary */
@@ -133,19 +129,19 @@ function renderScanSummary(summary) {
     const headline = `Scanned ${summary.total} file(s) — ` +
         `${summary.scanned + summary.replaced} ok, ` +
         `${summary.failed} failed, ` +
-        `${summary.concerns} concern${summary.concerns === 1 ? "" : "s"} flagged`;
+        `${summary.unknowns} unknown${summary.unknowns === 1 ? "" : "s"} flagged`;
     console.log(chalk.bold(headline));
     console.log("");
     for (const d of summary.details) {
         const label = d.relPath;
         switch (d.status) {
             case "scanned": {
-                const tag = chalk.dim(`${d.transactions} transactions${d.concerns > 0 ? ` · ${d.concerns} concerns` : ""}`);
+                const tag = chalk.dim(`${d.transactions} transactions${d.unknowns > 0 ? ` · ${d.unknowns} unknowns` : ""}`);
                 console.log(`  ${chalk.green("✓")} ${label}  ${tag}`);
                 break;
             }
             case "replaced": {
-                const tag = chalk.dim(`${d.transactions} transactions${d.concerns > 0 ? ` · ${d.concerns} concerns` : ""} (replaces prior)`);
+                const tag = chalk.dim(`${d.transactions} transactions${d.unknowns > 0 ? ` · ${d.unknowns} unknowns` : ""} (replaces prior)`);
                 console.log(`  ${chalk.cyan("↻")} ${label}  ${tag}`);
                 break;
             }
@@ -162,8 +158,8 @@ function renderScanSummary(summary) {
     const newlyProcessed = summary.scanned + summary.replaced;
     if (newlyProcessed > 0) {
         console.log("");
-        console.log(`${chalk.dim("Next:")} ${chalk.cyan("plasalid review")}${chalk.dim(summary.concerns > 0
-            ? " — to clear the concerns and learn your recurring rhythms."
-            : " — to connect related transactions and learn your recurring rhythms.")}`);
+        console.log(`${chalk.dim("Next:")} ${chalk.cyan("plasalid resolve")}${chalk.dim(summary.unknowns > 0
+            ? " — to walk every open unknown and apply your decision."
+            : " — no unknowns surfaced this run; nothing to do.")}`);
     }
 }

package/dist/cli/commands/status.js

@@ -1,6 +1,6 @@
 import chalk from "chalk";
 import { getDb } from "../../db/connection.js";
-import { getNetWorth, getPeriodTotals } from "../../db/queries/account_balance.js";
+import { getNetWorth, getPeriodTotals, } from "../../db/queries/account-balance.js";
 import { formatAmount } from "../../currency.js";
 export function showStatus() {
     const db = getDb();
@@ -8,7 +8,9 @@ export function showStatus() {
     console.log(chalk.bold("Net worth: ") + formatAmount(nw.net_worth));
     console.log(chalk.dim(`Assets ${formatAmount(nw.assets)} − Liabilities ${formatAmount(nw.liabilities)}`));
     const now = new Date();
-    const monthStart = new Date(now.getFullYear(), now.getMonth(), 1).toISOString().slice(0, 10);
+    const monthStart = new Date(now.getFullYear(), now.getMonth(), 1)
+        .toISOString()
+        .slice(0, 10);
     const today = now.toISOString().slice(0, 10);
     const totals = getPeriodTotals(db, monthStart, today);
     console.log("");

package/dist/cli/index.js

@@ -115,20 +115,20 @@ program
     await runScanCommand({ regex: regexes[0], force: !!opts.force, parallel });
 });
 program
-    .command("review")
-    .description("See the whole picture — connect related transactions across statements, surface recurring patterns, and clear up anything that's still in question.")
-    .option("-a, --account <id>", "Limit review to a single account")
+    .command("resolve")
+    .description("Walk every open unknown from the last scan one at a time and apply your decision (categorize, merge duplicates, link recurrences, skip).")
+    .option("-a, --account <id>", "Limit to unknowns attached to a single account")
     .option("--from <date>", "Only consider entries on or after this date (YYYY-MM-DD)")
     .option("--to <date>", "Only consider entries on or before this date (YYYY-MM-DD)")
-    .option("-d, --dry-run", "Surface findings without applying any change")
+    .option("-k, --kind <kind>", "Filter by unknown kind (uncategorized_expense, duplicate, correlation, recurrence_candidate, similar_accounts)")
     .action(async (opts) => {
     ensureConfigured();
-    const { runReviewCommand } = await import("./commands/review.js");
-    await runReviewCommand({
+    const { runResolveCommand } = await import("./commands/resolve.js");
+    await runResolveCommand({
         accountId: opts.account,
         from: opts.from,
         to: opts.to,
-        dryRun: !!opts.dryRun,
+        kind: opts.kind,
     });
 });
 program
@@ -164,8 +164,8 @@ program.configureHelp({
             desc: "Scan new PDFs (optionally by regex; --force to re-scan)",
         },
         {
-            name: "review",
-            desc: "Cleanup uncategorized, connect duplicates, learn recurring patterns",
+            name: "resolve",
+            desc: "Walk open unknowns one at a time and apply your decision",
         },
         {
             name: "revert",

package/dist/cli/ink/hooks/useFooterText.js

@@ -12,7 +12,7 @@ const HINTS = [
     "try: list my subscriptions",
     "try: how much liquid cash do I have?",
     "try: net worth trend this year?",
-    "try: open concerns from last scan?",
+    "try: open unknowns from last scan?",
 ];
 export function useFooterText(db) {
     const [tick, setTick] = useState(0);

package/dist/cli/ink/hooks/useTextInput.js

@@ -13,9 +13,6 @@ const ENTER = 13;
 const BACKSPACE = 127;
 const BACKSPACE_ALT = 8;
 const ESC = 27;
-function cloneBuf(b) {
-    return { lines: [...b.lines], row: b.row, col: b.col };
-}
 function wordLeft(line, col) {
     let p = col;
     while (p > 0 && line[p - 1] === " ")
@@ -58,6 +55,22 @@ function insertText(buf, text) {
         col: last.length,
     };
 }
+function moveToBol(buf) {
+    return { ...buf, col: 0 };
+}
+function moveToEol(buf) {
+    return { ...buf, col: buf.lines[buf.row].length };
+}
+function killToEol(buf) {
+    const lines = [...buf.lines];
+    lines[buf.row] = lines[buf.row].slice(0, buf.col);
+    return { lines, row: buf.row, col: buf.col };
+}
+function killToBol(buf) {
+    const lines = [...buf.lines];
+    lines[buf.row] = lines[buf.row].slice(buf.col);
+    return { lines, row: buf.row, col: 0 };
+}
 function backspace(buf) {
     if (buf.col > 0) {
         const lines = [...buf.lines];
@@ -128,6 +141,43 @@ function moveWordRight(buf) {
 function toString(buf) {
     return buf.lines.join("\n");
 }
+/** Pure mutators dispatched by single keycode. Side-effecting keys (Ctrl+C, Ctrl+D,
+ *  Enter, ESC) stay inline in handleChunk because they call host callbacks or open
+ *  a sub-state-machine for escape sequences. */
+const CTRL_HANDLERS = {
+    [CTRL_A]: moveToBol,
+    [CTRL_E]: moveToEol,
+    [CTRL_K]: killToEol,
+    [CTRL_U]: killToBol,
+    [CTRL_W]: deleteWordLeft,
+    [BACKSPACE]: backspace,
+    [BACKSPACE_ALT]: backspace,
+};
+/** CSI sequences: ESC [ ... <final>. `wordMod` runs when the parameter is one of
+ *  the word-step modifiers (Option/Ctrl/Cmd) — `1;3`, `1;5`, `1;9`. */
+const CSI_HANDLERS = {
+    D: { plain: moveLeft, wordMod: moveWordLeft },
+    C: { plain: moveRight, wordMod: moveWordRight },
+    A: { plain: moveUp, wordMod: moveUp },
+    B: { plain: moveDown, wordMod: moveDown },
+    H: { plain: moveToBol, wordMod: moveToBol },
+    F: { plain: moveToEol, wordMod: moveToEol },
+};
+/** Kitty keyboard protocol: ESC [ codepoint ; modifier u */
+function handleKittyKey(seq, apply) {
+    const parts = seq.split(";");
+    const codepoint = parseInt(parts[0], 10);
+    const mod = parts.length > 1 ? parseInt(parts[1], 10) : 1;
+    const hasShift = ((mod - 1) & 1) !== 0;
+    const hasCtrl = ((mod - 1) & 4) !== 0;
+    const hasCmd = ((mod - 1) & 8) !== 0;
+    if (codepoint === 13 && hasShift) {
+        apply((b) => insertText(b, "\n"));
+    }
+    else if (codepoint === 127 && (hasCmd || hasCtrl)) {
+        apply(killToBol);
+    }
+}
 /**
  * Raw-stdin driven keystroke state machine that owns a multiline buffer and
  * exposes its current state plus reset/insert helpers. Purely stateful — Ink
@@ -221,42 +271,15 @@ export function useTextInput(opts) {
                     }
                     continue;
                 }
-                if (code === CTRL_A) {
-                    apply(b => ({ ...b, col: 0 }));
-                    continue;
-                }
-                if (code === CTRL_E) {
-                    apply(b => ({ ...b, col: b.lines[b.row].length }));
-                    continue;
-                }
-                if (code === CTRL_K) {
-                    apply(b => {
-                        const lines = [...b.lines];
-                        lines[b.row] = lines[b.row].slice(0, b.col);
-                        return { lines, row: b.row, col: b.col };
-                    });
-                    continue;
-                }
-                if (code === CTRL_U) {
-                    apply(b => {
-                        const lines = [...b.lines];
-                        lines[b.row] = lines[b.row].slice(b.col);
-                        return { lines, row: b.row, col: 0 };
-                    });
-                    continue;
-                }
-                if (code === CTRL_W) {
-                    apply(deleteWordLeft);
-                    continue;
-                }
                 if (code === ENTER) {
                     optsRef.current.onSubmit(toString(bufferRef.current));
                     setBuffer(EMPTY_BUFFER);
                     optsRef.current.onChange?.(EMPTY_BUFFER);
                     continue;
                 }
-                if (code === BACKSPACE || code === BACKSPACE_ALT) {
-                    apply(backspace);
+                const ctrlHandler = CTRL_HANDLERS[code];
+                if (ctrlHandler) {
+                    apply(ctrlHandler);
                     continue;
                 }
                 if (code === ESC) {
@@ -288,44 +311,12 @@ export function useTextInput(opts) {
                         if (i < chunk.length) {
                             const final = chunk[i];
                             const isWordMod = seq === "1;3" || seq === "1;5" || seq === "1;9";
-                            if (final === "D") {
-                                apply(isWordMod ? moveWordLeft : moveLeft);
-                            }
-                            else if (final === "C") {
-                                apply(isWordMod ? moveWordRight : moveRight);
-                            }
-                            else if (final === "A") {
-                                apply(moveUp);
-                            }
-                            else if (final === "B") {
-                                apply(moveDown);
-                            }
-                            else if (final === "H") {
-                                apply(b => ({ ...b, col: 0 }));
-                            }
-                            else if (final === "F") {
-                                apply(b => ({ ...b, col: b.lines[b.row].length }));
+                            const csi = CSI_HANDLERS[final];
+                            if (csi) {
+                                apply(isWordMod ? csi.wordMod : csi.plain);
                             }
                             else if (final === "u") {
-                                // Kitty keyboard protocol: ESC [ codepoint ; modifier u
-                                const parts = seq.split(";");
-                                const codepoint = parseInt(parts[0], 10);
-                                const mod = parts.length > 1 ? parseInt(parts[1], 10) : 1;
-                                const hasShift = ((mod - 1) & 1) !== 0;
-                                const hasCtrl = ((mod - 1) & 4) !== 0;
-                                const hasCmd = ((mod - 1) & 8) !== 0;
-                                if (codepoint === 13 && hasShift) {
-                                    // Shift+Enter → insert newline
-                                    apply(b => insertText(b, "\n"));
-                                }
-                                else if (codepoint === 127 && (hasCmd || hasCtrl)) {
-                                    // Cmd/Ctrl+Backspace → delete to line start
-                                    apply(b => {
-                                        const lines = [...b.lines];
-                                        lines[b.row] = lines[b.row].slice(b.col);
-                                        return { lines, row: b.row, col: 0 };
-                                    });
-                                }
+                                handleKittyKey(seq, apply);
                             }
                         }
                         continue;

package/dist/cli/ink/scan_dashboard.d.ts

@@ -10,7 +10,7 @@ export type ScanDashboardEvent = {
     fileName: string;
     status: "scanned" | "failed";
     transactions: number;
-    concerns: number;
+    unknowns: number;
     error?: string;
 };
 /**
@@ -31,7 +31,7 @@ interface Props {
 /**
  * Multi-row live dashboard for the scan phase. Rows appear when a file starts
  * scanning, update as steps flow, and freeze when the agent loop ends. Counts
- * shown are the in-buffer counts at scan-end; correlation may add concerns
+ * shown are the in-buffer counts at scan-end; correlation may add unknowns
  * later, which the terse summary reflects.
  */
 export declare function ScanDashboard({ controller, totalFiles, parallel }: Props): import("react/jsx-runtime").JSX.Element;

package/dist/cli/ink/scan_dashboard.js

@@ -23,7 +23,7 @@ export class ScanDashboardController {
 /**
  * Multi-row live dashboard for the scan phase. Rows appear when a file starts
  * scanning, update as steps flow, and freeze when the agent loop ends. Counts
- * shown are the in-buffer counts at scan-end; correlation may add concerns
+ * shown are the in-buffer counts at scan-end; correlation may add unknowns
  * later, which the terse summary reflects.
  */
 export function ScanDashboard({ controller, totalFiles, parallel }) {
@@ -41,7 +41,7 @@ export function ScanDashboard({ controller, totalFiles, parallel }) {
                         break;
                     case "scan-end":
                         next.set(event.fileName, event.status === "scanned"
-                            ? { kind: "done", transactions: event.transactions, concerns: event.concerns }
+                            ? { kind: "done", transactions: event.transactions, unknowns: event.unknowns }
                             : { kind: "failed", error: event.error ?? "failed" });
                         break;
                 }
@@ -56,7 +56,7 @@ function FileRow({ name, state }) {
         return (_jsxs(Text, { children: ["  ", _jsx(Text, { color: "yellow", children: _jsx(Spinner, { type: "dots" }) }), " ", name, " ", _jsxs(Text, { dimColor: true, children: ["\u00B7 ", state.step] })] }));
     }
     if (state.kind === "done") {
-        return (_jsxs(Text, { children: ["  ", _jsx(Text, { color: "green", children: "\u2713" }), " ", name, " ", _jsxs(Text, { dimColor: true, children: ["(", state.transactions, " transactions, ", state.concerns, " concerns)"] })] }));
+        return (_jsxs(Text, { children: ["  ", _jsx(Text, { color: "green", children: "\u2713" }), " ", name, " ", _jsxs(Text, { dimColor: true, children: ["(", state.transactions, " transactions, ", state.unknowns, " unknowns)"] })] }));
     }
     return (_jsxs(Text, { children: ["  ", _jsx(Text, { color: "red", children: "\u2717" }), " ", name, " ", _jsxs(Text, { dimColor: true, children: ["\u2014 ", state.error] })] }));
 }

package/dist/cli/setup.js

@@ -34,9 +34,12 @@ function printSummary(dataDir) {
     console.log(chalk.dim(`Data:   ${dataDir}`));
     console.log("");
     console.log("Next steps:");
-    console.log(`  1. Run ${chalk.cyan("plasalid data")} to drop your bank/credit card statments PDFs in.`);
-    console.log(`  2. Run ${chalk.cyan("plasalid scan")} to allow Plasalid to scan them.`);
-    console.log(`  3. Run ${chalk.cyan("plasalid")} to query your local ledger.`);
+    console.log(`  1. Run ${chalk.cyan("plasalid data")} to drop your bank / credit-card statement PDFs in.`);
+    console.log(`  2. Run ${chalk.cyan("plasalid scan")} to parse them.`);
+    console.log(`  3. Run ${chalk.cyan("plasalid resolve")} to work through anything the scanner flagged.`);
+    console.log(`  4. Run ${chalk.cyan("plasalid")} to chat with your money.`);
+    console.log("");
+    console.log(chalk.dim(`  Optional: ${chalk.cyan(`plasalid record "..."`)}${chalk.dim(" to record manual/undocumented transaction, balance, or account at any time.")}`));
 }
 /**
  * Wraps inquirer's list prompt with a blank line above and below, and inserts

package/dist/cli/ux.js

@@ -118,7 +118,7 @@ export function makeAgentOnProgress(spinner, subject) {
     };
 }
 /**
- * Render the structured facts the review agent attaches to ask_user as a
+ * Render the structured facts the resolve agent attaches to ask_user as a
  * single colored line above the inquirer prompt. Each category has a fixed
  * chalk color so the user's eye picks out the type without reading prose.
  * Returns null when there's nothing to render (so the caller can skip the

package/dist/db/queries/account-balance.d.ts

@@ -0,0 +1,140 @@
+import type Database from "libsql";
+export type AccountType = "asset" | "liability" | "income" | "expense" | "equity";
+export declare const TOP_LEVEL_TYPES: ReadonlyArray<AccountType>;
+export interface AccountRow {
+    id: string;
+    name: string;
+    type: AccountType;
+    parent_id: string | null;
+    subtype: string | null;
+    bank_name: string | null;
+    account_number_masked: string | null;
+    currency: string;
+    due_day: number | null;
+    statement_day: number | null;
+    points_balance: number | null;
+    metadata_json: string | null;
+    pii_flag: number;
+    has_unknown: number;
+    created_at: string;
+}
+export interface AccountBalance extends AccountRow {
+    balance: number;
+}
+/**
+ * Balance per account using the natural debit/credit convention:
+ *   asset / expense  → debit-normal  → balance = debits − credits
+ *   liability / income / equity → credit-normal → balance = credits − debits
+ */
+export declare function getAccountBalances(db: Database.Database, opts?: {
+    type?: AccountType;
+}): AccountBalance[];
+export interface NetWorth {
+    assets: number;
+    liabilities: number;
+    net_worth: number;
+}
+export declare function getNetWorth(db: Database.Database): NetWorth;
+export interface PeriodTotals {
+    income: number;
+    expenses: number;
+}
+export declare function getPeriodTotals(db: Database.Database, from: string, to: string): PeriodTotals;
+export declare function findAccountById(db: Database.Database, id: string): AccountRow | null;
+export declare function renameAccount(db: Database.Database, id: string, name: string): number;
+/**
+ * Idempotently insert one of the five top-level type roots (id = type name,
+ * parent_id = null). Called by `createAccount` when a child's declared parent
+ * is a missing top-level root.
+ */
+export declare function ensureTopLevelRoot(db: Database.Database, type: AccountType): void;
+/**
+ * Idempotently insert one of the structural accounts the system auto-creates:
+ *  - `expense:uncategorized`  (suspense for unclassifiable expense postings)
+ *  - `equity:adjustments`     (balancing side of `adjust_account_balance`)
+ *  - `equity:opening-balance` (starting state imports)
+ * The top-level root is bootstrapped first when missing.
+ */
+export declare function ensureStructuralAccount(db: Database.Database, id: "expense:uncategorized" | "equity:adjustments" | "equity:opening-balance"): void;
+export interface CreateAccountInput {
+    id: string;
+    name: string;
+    type: AccountType;
+    parent_id?: string | null;
+    subtype?: string | null;
+    bank_name?: string | null;
+    account_number_masked?: string | null;
+    currency?: string;
+    due_day?: number | null;
+    statement_day?: number | null;
+    metadata?: Record<string, unknown> | null;
+}
+/**
+ * Insert a new account row. Enforces the three hierarchy invariants:
+ *   1. Top-level roots: parent_id null, id == type, one of TOP_LEVEL_TYPES.
+ *   2. Children: parent_id non-null, parent must exist (the top-level root is
+ *      auto-bootstrapped if missing — intermediate categories must be created
+ *      explicitly), parent.type must equal input.type, input.id must start with
+ *      parent.id + ':'.
+ *   3. UNIQUE on id (surfaces as code: 'ACCOUNT_EXISTS').
+ */
+export declare function createAccount(db: Database.Database, input: CreateAccountInput): void;
+export interface UpdateAccountMetadataPatch {
+    due_day?: number | null;
+    statement_day?: number | null;
+    points_balance?: number | null;
+    account_number_masked?: string | null;
+    bank_name?: string | null;
+    metadata?: Record<string, unknown>;
+}
+export interface UpdateAccountMetadataResult {
+    before: Record<string, unknown>;
+    after: Record<string, unknown>;
+    changed: boolean;
+}
+/**
+ * Patch metadata fields on an account. Returns before/after snapshots of the
+ * touched fields so callers can persist a reversible audit record. `metadata`
+ * is shallow-merged into the existing metadata_json blob.
+ */
+export declare function updateAccountMetadata(db: Database.Database, id: string, patch: UpdateAccountMetadataPatch): UpdateAccountMetadataResult;
+/**
+ * Re-point every posting on `fromId` to `toId`, then delete the source account.
+ * Wrapped in a transaction. Refuses if the source still has children. Returns
+ * the number of postings moved.
+ */
+export declare function mergeAccounts(db: Database.Database, fromId: string, toId: string): number;
+/** Delete an account only if no postings reference it AND it has no children. */
+export declare function deleteAccount(db: Database.Database, id: string): void;
+/**
+ * Recursive CTE walk over `accounts.parent_id` returning the root and every
+ * descendant. Used by `getRollupBalance` and by hierarchical rendering paths.
+ */
+export declare function getAccountSubtree(db: Database.Database, rootId: string): AccountRow[];
+/**
+ * Sum the natural balance of every account in a subtree (root inclusive).
+ * Uses the same debit-normal / credit-normal convention as `getAccountBalances`.
+ */
+export declare function getRollupBalance(db: Database.Database, rootId: string): number;
+export interface SimilarAccountPair {
+    a: AccountRow;
+    b: AccountRow;
+    similarity: number;
+}
+/**
+ * Pairwise Levenshtein similarity over `accounts.name`. Returns pairs above the
+ * threshold (0–1, where 1 = identical), sorted highest first. Quadratic in the
+ * number of accounts — fine for the small N a personal chart of accounts holds.
+ */
+export declare function findSimilarAccounts(db: Database.Database, threshold?: number): SimilarAccountPair[];
+export interface FuzzyAccountMatch {
+    account: AccountRow;
+    similarity: number;
+}
+/**
+ * Rank the chart of accounts by name similarity to a free-text query. Returns
+ * matches at or above `threshold`, highest first. Bonus weight when the query
+ * is a substring of the name so "ttb saving" still finds "TTB Savings ••1234"
+ * even though pure Levenshtein on the full strings is mediocre.
+ */
+export declare function findAccountsByFuzzyName(db: Database.Database, query: string, threshold?: number): FuzzyAccountMatch[];