plasalid 0.3.5 → 0.5.0

package/dist/ai/tools/review.js

@@ -0,0 +1,359 @@
+import { deleteAccount, findSimilarAccounts, findUnusedAccounts, mergeAccounts, renameAccount, } from "../../db/queries/account_balance.js";
+import { deleteTransaction, findCorrelatedTransactions, findDuplicateTransactions, updateTransaction, updatePosting, } from "../../db/queries/transactions.js";
+import { findRecurrenceCandidates, linkTransactionToRecurrence, recordRecurrence, } from "../../db/queries/recurrences.js";
+import { formatAmount } from "../../currency.js";
+import { sanitizeForPrompt } from "../sanitize.js";
+const DEFS = [
+    {
+        name: "update_transaction",
+        description: "Header-only update: date, description, or source_page. To change amounts, delete the transaction and record a new one.",
+        input_schema: {
+            type: "object",
+            properties: {
+                transaction_id: { type: "string" },
+                date: { type: "string" },
+                description: { type: "string" },
+                source_page: { type: "number" },
+            },
+            required: ["transaction_id"],
+        },
+    },
+    {
+        name: "update_posting",
+        description: "Safe single-posting edit: re-categorize (account_id) or update memo. Refuses changes to debit/credit/currency — delete and re-record the transaction for those.",
+        input_schema: {
+            type: "object",
+            properties: {
+                posting_id: { type: "string" },
+                account_id: { type: "string" },
+                memo: { type: "string" },
+            },
+            required: ["posting_id"],
+        },
+    },
+    {
+        name: "delete_transaction",
+        description: "Delete a transaction and (via cascade) all its postings. The primitive for removing duplicates.",
+        input_schema: {
+            type: "object",
+            properties: { transaction_id: { type: "string" } },
+            required: ["transaction_id"],
+        },
+    },
+    {
+        name: "rename_account",
+        description: "Rename an account. Leaves postings and metadata untouched.",
+        input_schema: {
+            type: "object",
+            properties: { account_id: { type: "string" }, name: { type: "string" } },
+            required: ["account_id", "name"],
+        },
+    },
+    {
+        name: "merge_accounts",
+        description: "Move every posting on `from_id` over to `to_id`, then delete the source account. Use to collapse duplicate accounts. Refuses if the source still has child accounts.",
+        input_schema: {
+            type: "object",
+            properties: { from_id: { type: "string" }, to_id: { type: "string" } },
+            required: ["from_id", "to_id"],
+        },
+    },
+    {
+        name: "delete_account",
+        description: "Delete an account that has no postings and no children. Refuses if any posting or child still references it — merge first.",
+        input_schema: {
+            type: "object",
+            properties: { account_id: { type: "string" } },
+            required: ["account_id"],
+        },
+    },
+    {
+        name: "find_duplicate_transactions",
+        description: "Heuristic: groups transactions by total amount and a configurable date tolerance. Returns groups with two or more candidate dupes.",
+        input_schema: {
+            type: "object",
+            properties: {
+                tolerance_days: { type: "number", default: 2 },
+                account_id: { type: "string" },
+                min_amount: { type: "number" },
+            },
+            required: [],
+        },
+    },
+    {
+        name: "find_similar_accounts",
+        description: "Pairwise Levenshtein similarity on account names. Returns pairs above the threshold, sorted highest first.",
+        input_schema: {
+            type: "object",
+            properties: { threshold: { type: "number", default: 0.85 } },
+            required: [],
+        },
+    },
+    {
+        name: "find_unused_accounts",
+        description: "Accounts with zero postings and no children (excludes the five top-level type roots).",
+        input_schema: { type: "object", properties: {}, required: [] },
+    },
+    {
+        name: "find_correlated_transactions",
+        description: "Surface pairs of transactions that look like the same money movement recorded against different accounts (a transfer recorded once on each statement). Pairs are filtered: same amount + currency, within `tolerance_days` of each other, and the two transactions share no account_ids (overlap → duplicate, not correlation).",
+        input_schema: {
+            type: "object",
+            properties: {
+                from: { type: "string", description: "ISO date inclusive lower bound (YYYY-MM-DD)." },
+                to: { type: "string", description: "ISO date inclusive upper bound (YYYY-MM-DD)." },
+                tolerance_days: { type: "number", default: 3, description: "Max day gap between paired transactions." },
+                min_amount: { type: "number", default: 0 },
+            },
+            required: [],
+        },
+    },
+    {
+        name: "find_recurrences",
+        description: "Detect candidate recurring transactions by grouping unlinked transactions on the same account + amount + side (debit/credit), then classifying cadence (weekly/biweekly/monthly/annually/irregular) from the median gap between consecutive dates. Skips transactions already linked to a recurrence.",
+        input_schema: {
+            type: "object",
+            properties: {
+                account_id: { type: "string", description: "Limit to one account; omit for all." },
+                min_occurrences: { type: "number", default: 3, description: "Minimum sightings to qualify." },
+            },
+            required: [],
+        },
+    },
+    {
+        name: "record_recurrence",
+        description: "Create a recurrences row and link every supplied transaction to it. Computes first_seen_date, last_seen_date, and next_expected_date from the member transactions. Use this after the user confirms a recurrence candidate.",
+        input_schema: {
+            type: "object",
+            properties: {
+                account_id: { type: "string", description: "The account this recurs on." },
+                description: { type: "string", description: "Human label, e.g. 'Spotify subscription', 'Salary', 'Rent'." },
+                frequency: { type: "string", enum: ["weekly", "biweekly", "monthly", "annually"] },
+                amount_typical: { type: "number", description: "Representative amount (typically the matching amount of the member transactions)." },
+                currency: { type: "string", default: "THB" },
+                transaction_ids: { type: "array", items: { type: "string" }, description: "Transaction ids to link to this recurrence." },
+                notes: { type: "string", description: "Optional context the chat agent can read later." },
+            },
+            required: ["account_id", "description", "frequency", "transaction_ids"],
+        },
+    },
+    {
+        name: "link_transaction_to_recurrence",
+        description: "Attach a single newly-seen transaction to an existing recurrence. Recomputes last_seen_date and next_expected_date on the recurrence.",
+        input_schema: {
+            type: "object",
+            properties: {
+                transaction_id: { type: "string" },
+                recurrence_id: { type: "string" },
+            },
+            required: ["transaction_id", "recurrence_id"],
+        },
+    },
+    {
+        name: "mark_review_done",
+        description: "Call when the review pass is complete. The summary is shown to the user.",
+        input_schema: {
+            type: "object",
+            properties: { summary: { type: "string" } },
+            required: ["summary"],
+        },
+    },
+];
+const LABELS = {
+    update_transaction: "Updating transaction",
+    update_posting: "Updating posting",
+    delete_transaction: "Deleting transaction",
+    rename_account: "Renaming account",
+    merge_accounts: "Merging accounts",
+    delete_account: "Deleting account",
+    find_duplicate_transactions: "Finding duplicate transactions",
+    find_similar_accounts: "Finding similar accounts",
+    find_unused_accounts: "Finding unused accounts",
+    find_correlated_transactions: "Finding correlated transactions",
+    find_recurrences: "Finding recurrences",
+    record_recurrence: "Recording recurrence",
+    link_transaction_to_recurrence: "Linking transaction to recurrence",
+    mark_review_done: "Finalizing review",
+};
+async function execute(db, name, input, ctx) {
+    switch (name) {
+        case "update_transaction": {
+            if (ctx?.dryRun)
+                return `Would update transaction ${input.transaction_id}: ${JSON.stringify(input)}`;
+            const changed = updateTransaction(db, input.transaction_id, {
+                date: input.date,
+                description: input.description,
+                source_page: input.source_page,
+            });
+            return changed === 0
+                ? `Transaction ${input.transaction_id} not found or no fields to update.`
+                : `Updated transaction ${input.transaction_id}.`;
+        }
+        case "update_posting": {
+            if (ctx?.dryRun)
+                return `Would update posting ${input.posting_id}: ${JSON.stringify(input)}`;
+            const changed = updatePosting(db, input.posting_id, {
+                account_id: input.account_id,
+                memo: input.memo,
+            });
+            return changed === 0
+                ? `Posting ${input.posting_id} not found or no fields to update.`
+                : `Updated posting ${input.posting_id}.`;
+        }
+        case "delete_transaction": {
+            if (ctx?.dryRun)
+                return `Would delete transaction ${input.transaction_id} (and its postings).`;
+            const changed = deleteTransaction(db, input.transaction_id);
+            return changed === 0
+                ? `Transaction ${input.transaction_id} not found.`
+                : `Deleted transaction ${input.transaction_id} and its postings.`;
+        }
+        case "rename_account": {
+            if (ctx?.dryRun)
+                return `Would rename ${input.account_id} → "${input.name}".`;
+            const changed = renameAccount(db, input.account_id, input.name);
+            return changed === 0
+                ? `Account ${input.account_id} not found.`
+                : `Renamed ${input.account_id} → "${sanitizeForPrompt(input.name)}".`;
+        }
+        case "merge_accounts": {
+            if (ctx?.dryRun)
+                return `Would merge ${input.from_id} → ${input.to_id}.`;
+            try {
+                const moved = mergeAccounts(db, input.from_id, input.to_id);
+                return `Merged ${input.from_id} → ${input.to_id}; moved ${moved} posting(s).`;
+            }
+            catch (err) {
+                return `Could not merge: ${err.message}`;
+            }
+        }
+        case "delete_account": {
+            if (ctx?.dryRun)
+                return `Would delete account ${input.account_id}.`;
+            try {
+                deleteAccount(db, input.account_id);
+                return `Deleted account ${input.account_id}.`;
+            }
+            catch (err) {
+                return `Could not delete: ${err.message}`;
+            }
+        }
+        case "find_duplicate_transactions": {
+            const groups = findDuplicateTransactions(db, {
+                toleranceDays: input.tolerance_days,
+                accountId: input.account_id,
+                minAmount: input.min_amount,
+            });
+            if (groups.length === 0)
+                return "No candidate duplicate groups found.";
+            return groups
+                .map((g, i) => {
+                const header = `Group ${i + 1} — ${formatAmount(g[0].amount)}`;
+                const lines = g.map((e, j) => {
+                    const accounts = e.account_names.length > 0
+                        ? e.account_names.map(n => sanitizeForPrompt(n)).join(", ")
+                        : "(no postings)";
+                    return `  ${j + 1}. ${e.date} "${sanitizeForPrompt(e.description)}" — ${accounts}    [${e.id}]`;
+                });
+                return `${header}\n${lines.join("\n")}`;
+            })
+                .join("\n\n");
+        }
+        case "find_similar_accounts": {
+            const pairs = findSimilarAccounts(db, input.threshold);
+            if (pairs.length === 0)
+                return "No similar account pairs above threshold.";
+            return pairs
+                .map(p => `${p.similarity}: ${p.a.id} (${sanitizeForPrompt(p.a.name)}) <-> ${p.b.id} (${sanitizeForPrompt(p.b.name)})`)
+                .join("\n");
+        }
+        case "find_unused_accounts": {
+            const rows = findUnusedAccounts(db);
+            if (rows.length === 0)
+                return "No unused accounts.";
+            return rows.map(a => `${a.id} | ${sanitizeForPrompt(a.name)} | ${a.type}`).join("\n");
+        }
+        case "find_correlated_transactions": {
+            const pairs = findCorrelatedTransactions(db, {
+                from: input.from,
+                to: input.to,
+                toleranceDays: input.tolerance_days,
+                minAmount: input.min_amount,
+            });
+            if (pairs.length === 0)
+                return "No correlated transaction pairs found.";
+            return pairs
+                .map((p, i) => {
+                const accountsA = p.a.account_names.length > 0
+                    ? p.a.account_names.map(n => sanitizeForPrompt(n)).join(", ")
+                    : "(no postings)";
+                const accountsB = p.b.account_names.length > 0
+                    ? p.b.account_names.map(n => sanitizeForPrompt(n)).join(", ")
+                    : "(no postings)";
+                return [
+                    `Pair ${i + 1} — ${formatAmount(p.amount)} ${p.currency} (gap ${p.day_gap} day${p.day_gap === 1 ? "" : "s"})`,
+                    `  A: ${p.a.date} "${sanitizeForPrompt(p.a.description)}" — ${accountsA}    [${p.a.id}]`,
+                    `  B: ${p.b.date} "${sanitizeForPrompt(p.b.description)}" — ${accountsB}    [${p.b.id}]`,
+                ].join("\n");
+            })
+                .join("\n\n");
+        }
+        case "find_recurrences": {
+            const candidates = findRecurrenceCandidates(db, {
+                accountId: input.account_id,
+                minOccurrences: input.min_occurrences,
+            });
+            if (candidates.length === 0)
+                return "No recurrence candidates found.";
+            return candidates
+                .map((c, i) => {
+                const dates = c.transactions.map(e => e.date).join(", ");
+                const ids = c.transactions.map(e => e.id).join(", ");
+                return [
+                    `Candidate ${i + 1} — ${formatAmount(c.amount)} ${c.currency} on ${sanitizeForPrompt(c.account_name)} (${c.side})`,
+                    `  Sightings (${c.transactions.length}): ${dates}`,
+                    `  Median gap: ${c.median_days_between} day(s) → implied ${c.implied_frequency}`,
+                    `  Transaction ids: ${ids}`,
+                ].join("\n");
+            })
+                .join("\n\n");
+        }
+        case "record_recurrence": {
+            if (ctx?.dryRun)
+                return `Would record ${input.frequency} recurrence "${input.description}" linking ${(input.transaction_ids || []).length} transactions on ${input.account_id}.`;
+            try {
+                const id = recordRecurrence(db, {
+                    account_id: input.account_id,
+                    description: input.description,
+                    frequency: input.frequency,
+                    amount_typical: input.amount_typical ?? null,
+                    currency: input.currency,
+                    transaction_ids: input.transaction_ids || [],
+                    notes: input.notes ?? null,
+                });
+                return `Recorded recurrence ${id} ("${sanitizeForPrompt(input.description)}", ${input.frequency}); linked ${(input.transaction_ids || []).length} transaction(s).`;
+            }
+            catch (err) {
+                return `Could not record recurrence: ${err.message}`;
+            }
+        }
+        case "link_transaction_to_recurrence": {
+            if (ctx?.dryRun)
+                return `Would link transaction ${input.transaction_id} → recurrence ${input.recurrence_id}.`;
+            try {
+                linkTransactionToRecurrence(db, input.transaction_id, input.recurrence_id);
+                return `Linked transaction ${input.transaction_id} → recurrence ${input.recurrence_id}.`;
+            }
+            catch (err) {
+                return `Could not link: ${err.message}`;
+            }
+        }
+        case "mark_review_done": {
+            ctx?.onComplete?.(input.summary || "");
+            return `Review complete. Summary: ${sanitizeForPrompt(input.summary || "")}`;
+        }
+        default:
+            return undefined;
+    }
+}
+export const reviewTools = { DEFS, LABELS, execute };

package/dist/ai/tools/scan.js

@@ -2,7 +2,7 @@ import { sanitizeForPrompt } from "../sanitize.js";
 const DEFS = [
     {
         name: "mark_file_scanned",
-        description: "Call this once the file is fully processed and all journal entries are posted. Summary text is shown to the user.",
+        description: "Call this once the file is fully processed and all transactions are posted. Summary text is shown to the user.",
         input_schema: {
             type: "object",
             properties: {
@@ -18,7 +18,9 @@ const LABELS = {
 async function execute(_db, name, input, ctx) {
     if (name !== "mark_file_scanned")
         return undefined;
-    ctx?.onComplete?.(input.summary || "");
-    return `Marked file as scanned. Summary: ${sanitizeForPrompt(input.summary || "")}`;
+    const summary = input.summary || "";
+    ctx?.buffer?.markDone(summary);
+    ctx?.onComplete?.(summary);
+    return `Marked file as scanned. Summary: ${sanitizeForPrompt(summary)}`;
 }
 export const scanTools = { DEFS, LABELS, execute };

package/dist/ai/tools/types.d.ts

@@ -1,17 +1,46 @@
 import type Database from "libsql";
 import type { ToolDefinition } from "../provider.js";
-export type ToolProfile = "scan" | "chat" | "reconcile";
+import type { BufferedWriteContext } from "../../scanner/buffer.js";
+export type ToolProfile = "scan" | "chat" | "review" | "record";
+/**
+ * Structured highlights the review agent can pass to ask_user. The prompter
+ * renders them as a single colored header line above the question (each
+ * category gets its own chalk color), so the user can scan amount / date /
+ * merchant / accounts at a glance without parsing prose.
+ */
+export interface PromptUserFacts {
+    amount?: string;
+    date?: string;
+    merchant?: string;
+    accounts?: string[];
+}
 export interface AgentExecutionContext {
-    /** Set during scan so `record_journal_entry` can stamp `source_file_id`. */
+    /** Set during scan so `record_transaction` can stamp `source_file_id`. */
     fileId?: string;
     /** When false, ask_user returns a marker and the caller halts after the run. */
     interactive: boolean;
     /** When true, mutating tools become no-ops that return a "would do X" preview. */
     dryRun?: boolean;
     /** Synchronously prompt the user (only invoked when interactive === true). */
-    promptUser?: (prompt: string, options?: string[]) => Promise<string>;
-    /** Called when the model declares the session is done (scan or reconcile). */
+    promptUser?: (prompt: string, options?: string[], facts?: PromptUserFacts) => Promise<string>;
+    /** Called when the model declares the session is done (scan or review). */
     onComplete?: (summary: string) => void;
+    /**
+     * Which top-level command this agent serves. Mutating tools branch on this
+     * to decide whether to append an action_log row (currently only "record").
+     */
+    command?: "scan" | "review" | "record";
+    /** Per-invocation id grouping every action_log row from one CLI run. */
+    correlationId?: string;
+    /** The raw user utterance / file path that started this invocation. */
+    userInput?: string;
+    /**
+     * Scan-only: when set, transactions and concerns are queued here instead of
+     * being written directly to the DB. Account and merchant writes still hit
+     * the DB eagerly (serialized via their own mutexes) so concurrent scan
+     * agents share the same chart of accounts and merchant directory.
+     */
+    buffer?: BufferedWriteContext;
 }
 /**
  * A tool module owns a slice of tool definitions, the spinner labels that go

package/dist/cli/commands/accounts.js

@@ -1,19 +1,8 @@
 import chalk from "chalk";
 import { getDb } from "../../db/connection.js";
 import { getAccountBalances } from "../../db/queries/account_balance.js";
-import { formatCurrencyAmount } from "../../currency.js";
-function fmtSigned(n) {
-    const body = formatCurrencyAmount(n, {
-        minimumFractionDigits: 2,
-        maximumFractionDigits: 2,
-    });
-    return n < 0 ? `-${body}` : body;
-}
-// eslint-disable-next-line no-control-regex
-const ANSI_RE = /\x1b\[[0-9;]*m/g;
-function visibleLength(s) {
-    return s.replace(ANSI_RE, "").length;
-}
+import { visibleLength } from "../format.js";
+import { formatSignedAmount } from "../../currency.js";
 const TYPE_TAG = {
     asset: "asset",
     liability: "liab",
@@ -48,20 +37,39 @@ function compactMeta(a) {
 }
 export function showAccounts() {
     const db = getDb();
-    const accounts = [...getAccountBalances(db)].sort((a, b) => {
-        const t = TYPE_RANK[a.type] - TYPE_RANK[b.type];
-        return t !== 0 ? t : a.name.localeCompare(b.name);
-    });
-    if (accounts.length === 0) {
+    const raw = getAccountBalances(db);
+    if (raw.length === 0) {
         console.log(chalk.yellow("No accounts yet. Drop your bank/credit card statements into ~/.plasalid/data/ and run `plasalid scan`."));
         return;
     }
-    const balanceWidth = Math.max(...accounts.map((a) => fmtSigned(a.balance).length));
-    const nameWidth = Math.max(...accounts.map((a) => a.name.length));
+    const byId = new Map(raw.map(a => [a.id, a]));
+    const depthCache = new Map();
+    const depthOf = (id) => {
+        if (depthCache.has(id))
+            return depthCache.get(id);
+        const node = byId.get(id);
+        if (!node || !node.parent_id) {
+            depthCache.set(id, 0);
+            return 0;
+        }
+        const d = depthOf(node.parent_id) + 1;
+        depthCache.set(id, d);
+        return d;
+    };
+    const accounts = [...raw].sort((a, b) => {
+        const t = TYPE_RANK[a.type] - TYPE_RANK[b.type];
+        if (t !== 0)
+            return t;
+        return a.id.localeCompare(b.id);
+    });
+    const balanceWidth = Math.max(...accounts.map((a) => formatSignedAmount(a.balance).length));
+    const nameWidth = Math.max(...accounts.map((a) => a.name.length + depthOf(a.id) * 2));
     for (const a of accounts) {
         const tag = chalk.dim(TYPE_TAG[a.type].padEnd(TYPE_TAG_WIDTH));
-        const name = chalk.bold(a.name) + " ".repeat(nameWidth - a.name.length);
-        const rawBalance = fmtSigned(a.balance);
+        const indent = "  ".repeat(depthOf(a.id));
+        const displayName = indent + a.name;
+        const name = chalk.bold(displayName) + " ".repeat(nameWidth - displayName.length);
+        const rawBalance = formatSignedAmount(a.balance);
         const coloredBalance = a.balance < 0 ? chalk.red(rawBalance) : rawBalance;
         const paddedBalance = " ".repeat(balanceWidth - visibleLength(coloredBalance)) + coloredBalance;
         const meta = compactMeta(a);
@@ -78,9 +86,9 @@ export function showAccounts() {
     const netWorth = assets - liabilities;
     console.log("");
     console.log("  " +
-        chalk.dim(`Assets ${fmtSigned(assets)}`) +
+        chalk.dim(`Assets ${formatSignedAmount(assets)}`) +
         chalk.dim("   ·   ") +
-        chalk.dim(`Liabilities ${fmtSigned(liabilities)}`) +
+        chalk.dim(`Liabilities ${formatSignedAmount(liabilities)}`) +
         chalk.dim("   ·   ") +
-        chalk.bold(`Net worth ${fmtSigned(netWorth)}`));
+        chalk.bold(`Net worth ${formatSignedAmount(netWorth)}`));
 }

package/dist/cli/commands/record.d.ts

@@ -0,0 +1,4 @@
+export interface RecordCommandOptions {
+    utterance: string;
+}
+export declare function runRecordCommand(opts: RecordCommandOptions): Promise<void>;

package/dist/cli/commands/record.js

@@ -0,0 +1,119 @@
+import chalk from "chalk";
+import { randomUUID } from "crypto";
+import { getDb } from "../../db/connection.js";
+import { runRecordAgent } from "../../ai/agent.js";
+import { makePromptUser, makeAgentOnProgress, statusSpinner } from "../ux.js";
+import { listActions } from "../../db/queries/action_log.js";
+import { formatAmount } from "../../currency.js";
+export async function runRecordCommand(opts) {
+    const utterance = opts.utterance.trim();
+    if (!utterance) {
+        console.error(chalk.red(`Usage: plasalid record "<what happened>"`));
+        process.exitCode = 1;
+        return;
+    }
+    const db = getDb();
+    const spinner = statusSpinner("Thinking...");
+    const promptUser = makePromptUser(spinner);
+    const onProgress = makeAgentOnProgress(spinner);
+    const correlationId = `cr:${randomUUID()}`;
+    const initialMessages = [
+        { role: "user", content: utterance },
+    ];
+    try {
+        const text = await runRecordAgent({
+            db,
+            initialMessages,
+            prompt: { utterance },
+            agentCtx: {
+                command: "record",
+                correlationId,
+                userInput: utterance,
+                interactive: !!process.stdout.isTTY,
+                promptUser,
+            },
+            onProgress,
+        });
+        spinner.succeed("Done.");
+        if (text) {
+            console.log("");
+            console.log(text);
+        }
+        renderActionSummary(correlationId);
+    }
+    catch (err) {
+        spinner.fail(err?.message ?? "Record failed.");
+        process.exitCode = 1;
+    }
+}
+function renderActionSummary(correlationId) {
+    const actions = listActions(getDb(), { correlationId });
+    if (actions.length === 0)
+        return;
+    console.log("");
+    console.log(chalk.dim(`Logged ${actions.length} action${actions.length === 1 ? "" : "s"} (${correlationId}):`));
+    for (const a of actions) {
+        console.log(chalk.dim(`  · ${describeAction(a)}`));
+    }
+}
+function describeAction(a) {
+    const payload = safeJson(a.payload_json);
+    switch (a.action_type) {
+        case "create_account": {
+            const name = payload?.row?.name ? ` — ${payload.row.name}` : "";
+            return `create_account ${a.target_id}${name}`;
+        }
+        case "update_account_metadata": {
+            const fields = payload?.after && typeof payload.after === "object"
+                ? Object.keys(payload.after).join(", ")
+                : "";
+            return `update_account_metadata ${a.target_id}${fields ? ` — ${fields}` : ""}`;
+        }
+        case "record_transaction": {
+            const date = payload?.transaction?.date ?? "";
+            const desc = payload?.transaction?.description ?? "";
+            const total = totalDebit(payload?.postings);
+            const amount = total != null ? ` ${formatTotal(total, currencyOf(payload?.postings))}` : "";
+            return `record_transaction ${a.target_id} — ${[date, desc].filter(Boolean).join(" ")}${amount}`;
+        }
+        case "adjust_balance": {
+            const before = payload?.before_balance;
+            const after = payload?.after_balance;
+            const currency = currencyOf(payload?.postings);
+            if (typeof before === "number" && typeof after === "number") {
+                return `adjust_balance ${payload?.account_id ?? a.target_id} — ${formatTotal(before, currency)} → ${formatTotal(after, currency)}`;
+            }
+            return `adjust_balance ${a.target_id}`;
+        }
+        case "create_merchant": {
+            const name = payload?.canonical_name ?? "";
+            return `create_merchant ${a.target_id}${name ? ` — ${name}` : ""}`;
+        }
+        case "update_merchant_default": {
+            return `update_merchant_default ${a.target_id} — ${payload?.before ?? "(none)"} → ${payload?.after ?? "(none)"}`;
+        }
+        default:
+            return `${a.action_type} ${a.target_id}`;
+    }
+}
+function safeJson(s) {
+    try {
+        return JSON.parse(s);
+    }
+    catch {
+        return null;
+    }
+}
+function totalDebit(postings) {
+    if (!Array.isArray(postings))
+        return null;
+    return postings.reduce((sum, p) => sum + (Number(p?.debit) || 0), 0);
+}
+function currencyOf(postings) {
+    if (Array.isArray(postings) && postings[0]?.currency)
+        return String(postings[0].currency);
+    return "THB";
+}
+function formatTotal(amount, currency) {
+    return formatAmount(amount, currency);
+}

package/dist/cli/commands/revert.js

@@ -51,7 +51,7 @@ export async function runRevertCommand(regex) {
         console.log(chalk.dim("No scanned files match that regex."));
         return;
     }
-    console.log(chalk.bold(`revert will delete ${matches.length} file(s) and their journal entries:`));
+    console.log(chalk.bold(`revert will delete ${matches.length} file(s) and their transactions:`));
     for (const m of matches) {
         const when = m.scannedAt ? chalk.dim(` (scanned ${m.scannedAt})`) : "";
         console.log(`  • ${m.relPath}${when}`);

package/dist/cli/commands/review.d.ts

@@ -0,0 +1,2 @@
+import { type ReviewOptions } from "../../reviewer/pipeline.js";
+export declare function runReviewCommand(opts: ReviewOptions): Promise<void>;

package/dist/cli/commands/review.js

@@ -0,0 +1,15 @@
+import chalk from "chalk";
+import { runReview } from "../../reviewer/pipeline.js";
+export async function runReviewCommand(opts) {
+    try {
+        const result = await runReview(opts);
+        if (result.summary) {
+            console.log("");
+            console.log(chalk.bold(result.summary));
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(`Review failed: ${err.message}`));
+        process.exitCode = 1;
+    }
+}