plasalid 0.5.7 → 0.6.0

package/dist/ai/tools/read.js

@@ -1,6 +1,6 @@
-import { findAccountById, getAccountBalances, getNetWorth, getPeriodTotals, } from "../../db/queries/account_balance.js";
+import { findAccountById, getAccountBalances, getNetWorth, getPeriodTotals, } from "../../db/queries/account-balance.js";
 import { listPostings } from "../../db/queries/transactions.js";
-import { listOpenConcerns } from "../../db/queries/concerns.js";
+import { listOpenUnknowns } from "../../db/queries/unknowns.js";
 import { searchPostings } from "../../db/queries/search.js";
 import { formatAmount } from "../../currency.js";
 import { sanitizeForPrompt, sanitizeForPromptCell } from "../sanitize.js";
@@ -28,7 +28,10 @@ const DEFS = [
                 account_id: { type: "string" },
                 from: { type: "string", description: "Start date YYYY-MM-DD" },
                 to: { type: "string", description: "End date YYYY-MM-DD" },
-                q: { type: "string", description: "Free-text contains-match on description, memo, or merchant" },
+                q: {
+                    type: "string",
+                    description: "Free-text contains-match on description, memo, or merchant",
+                },
                 limit: { type: "number", description: "Max results (default 50)" },
             },
             required: [],
@@ -59,13 +62,16 @@ const DEFS = [
         },
     },
     {
-        name: "list_open_concerns",
-        description: "List clarification requests recorded by the scanner that have not been resolved yet. Each row carries the prompt, optional candidate answers, and the file/transaction/account it was attached to. The reviewer uses this to drive the step-by-step clarification loop.",
+        name: "list_open_unknowns",
+        description: "List clarification requests recorded by the scanner that have not been resolved yet. Each row carries the prompt, optional candidate answers, and the file/transaction/account it was attached to. The resolver uses this to drive the step-by-step clarification loop.",
         input_schema: {
             type: "object",
             properties: {
                 limit: { type: "number", default: 50 },
-                kind: { type: "string", description: "Optional filter by concern kind (e.g. 'uncategorized_expense')." },
+                kind: {
+                    type: "string",
+                    description: "Optional filter by unknown kind (e.g. 'uncategorized_expense').",
+                },
             },
             required: [],
         },
@@ -77,7 +83,7 @@ const LABELS = {
     list_postings: "Listing postings",
     search_transactions: "Searching transactions",
     get_period_totals: "Summing period totals",
-    list_open_concerns: "Listing open concerns",
+    list_open_unknowns: "Listing open unknowns",
 };
 async function execute(db, name, input, _ctx) {
     switch (name) {
@@ -86,7 +92,7 @@ async function execute(db, name, input, _ctx) {
             if (!acct)
                 return `Account "${input.account_id}" not found.`;
             const balances = getAccountBalances(db);
-            const bal = balances.find(b => b.id === acct.id)?.balance ?? 0;
+            const bal = balances.find((b) => b.id === acct.id)?.balance ?? 0;
             return `${sanitizeForPrompt(acct.name)} (${acct.type}): ${formatAmount(bal)}`;
         }
         case "get_net_worth": {
@@ -104,10 +110,12 @@ async function execute(db, name, input, _ctx) {
             if (rows.length === 0)
                 return "No matching postings.";
             return rows
-                .map(r => {
+                .map((r) => {
                 const dr = r.debit > 0 ? `DR ${formatAmount(r.debit)}` : "";
                 const cr = r.credit > 0 ? `CR ${formatAmount(r.credit)}` : "";
-                const merchant = r.merchant_name ? ` (${sanitizeForPromptCell(r.merchant_name)})` : "";
+                const merchant = r.merchant_name
+                    ? ` (${sanitizeForPromptCell(r.merchant_name)})`
+                    : "";
                 return `${r.transaction_date} | ${sanitizeForPromptCell(r.transaction_description || "")}${merchant} | ${sanitizeForPromptCell(r.account_name || "")} | ${dr}${cr} | ${sanitizeForPromptCell(r.memo || "")}`;
             })
                 .join("\n");
@@ -117,10 +125,12 @@ async function execute(db, name, input, _ctx) {
             if (rows.length === 0)
                 return `No matches for "${sanitizeForPrompt(input.query)}".`;
             return rows
-                .map(r => {
+                .map((r) => {
                 const dr = r.debit > 0 ? `DR ${formatAmount(r.debit)}` : "";
                 const cr = r.credit > 0 ? `CR ${formatAmount(r.credit)}` : "";
-                const merchant = r.merchant_name ? ` (${sanitizeForPromptCell(r.merchant_name)})` : "";
+                const merchant = r.merchant_name
+                    ? ` (${sanitizeForPromptCell(r.merchant_name)})`
+                    : "";
                 return `${r.transaction_date} | ${sanitizeForPromptCell(r.transaction_description || "")}${merchant} | ${sanitizeForPromptCell(r.account_name || "")} | ${dr}${cr}`;
             })
                 .join("\n");
@@ -129,21 +139,27 @@ async function execute(db, name, input, _ctx) {
             const totals = getPeriodTotals(db, input.from, input.to);
             return `Income ${formatAmount(totals.income)} · Expenses ${formatAmount(totals.expenses)} · Net ${formatAmount(totals.income - totals.expenses)}`;
         }
-        case "list_open_concerns": {
-            const rows = listOpenConcerns(db, input.limit ?? 50);
-            const filtered = input.kind ? rows.filter(r => r.kind === input.kind) : rows;
+        case "list_open_unknowns": {
+            const rows = listOpenUnknowns(db, input.limit ?? 50);
+            const filtered = input.kind
+                ? rows.filter((r) => r.kind === input.kind)
+                : rows;
             if (filtered.length === 0)
-                return "No open concerns. The picture is clear.";
+                return "No open unknowns. The picture is clear.";
             return filtered
-                .map(r => {
+                .map((r) => {
                 const targets = [
                     r.transaction_id ? `transaction=${r.transaction_id}` : null,
                     r.account_id ? `account=${r.account_id}` : null,
-                    !r.transaction_id && !r.account_id && r.file_id ? `file=${r.file_id}` : null,
+                    !r.transaction_id && !r.account_id && r.file_id
+                        ? `file=${r.file_id}`
+                        : null,
                     r.kind ? `kind=${r.kind}` : null,
-                ].filter(Boolean).join(" ");
+                ]
+                    .filter(Boolean)
+                    .join(" ");
                 const options = r.options_json
-                    ? ` [options: ${JSON.parse(r.options_json).map(o => sanitizeForPrompt(o)).join(" | ")}]`
+                    ? ` [options: ${JSON.parse(r.options_json).map((o) => sanitizeForPrompt(o)).join(" | ")}]`
                     : "";
                 return `${r.id} ${targets} — ${sanitizeForPrompt(r.prompt)}${options}`;
             })

package/dist/ai/tools/record.js

@@ -1,6 +1,6 @@
-import { findAccountById, findAccountsByFuzzyName, getAccountBalances, ensureStructuralAccount, } from "../../db/queries/account_balance.js";
+import { findAccountById, findAccountsByFuzzyName, getAccountBalances, ensureStructuralAccount, renameAccount, deleteAccount, } from "../../db/queries/account-balance.js";
 import { validateTransaction, insertTransactionRows, } from "../../db/queries/transactions.js";
-import { appendAction } from "../../db/queries/action_log.js";
+import { appendAction } from "../../db/queries/action-log.js";
 import { formatAmount } from "../../currency.js";
 import { sanitizeForPrompt } from "../sanitize.js";
 const EQUITY_ADJUST_ID = "equity:adjustments";
@@ -10,10 +10,10 @@ function todayIso() {
 /**
  * Record-only tool definitions
  *
- * `find_similar_accounts` and `clarify` are reads / prompts; only
- * `adjust_account_balance` mutates the DB. It writes its own action_log row
- * with `action_type='adjust_balance'` rather than going through the shared
- * `record_transaction` path.
+ * `find_similar_accounts` and `clarify` are reads / prompts; `adjust_account_balance`,
+ * `rename_account`, and `delete_account` mutate the DB. Of those, only
+ * `adjust_account_balance` writes an action_log row (with `action_type='adjust_balance'`);
+ * rename and delete are simple shape changes without an audit entry.
  */
 const DEFS = [
     {
@@ -22,8 +22,15 @@ const DEFS = [
         input_schema: {
             type: "object",
             properties: {
-                query: { type: "string", description: "Free-text name to match against the chart of accounts." },
-                threshold: { type: "number", description: "Minimum similarity (0-1). Default 0.5.", default: 0.5 },
+                query: {
+                    type: "string",
+                    description: "Free-text name to match against the chart of accounts.",
+                },
+                threshold: {
+                    type: "number",
+                    description: "Minimum similarity (0-1). Default 0.5.",
+                    default: 0.5,
+                },
             },
             required: ["query"],
         },
@@ -35,20 +42,53 @@ const DEFS = [
             type: "object",
             properties: {
                 account_id: { type: "string" },
-                target_balance: { type: "number", description: "The new desired balance in the account's currency, in natural sign (positive)." },
-                reason: { type: "string", description: "Short description, e.g. 'Set DIEM portfolio to current market value (user-asserted).'." },
-                date: { type: "string", description: "ISO YYYY-MM-DD. Defaults to today." },
+                target_balance: {
+                    type: "number",
+                    description: "The new desired balance in the account's currency, in natural sign (positive).",
+                },
+                reason: {
+                    type: "string",
+                    description: "Short description, e.g. 'Set DIEM portfolio to current market value (user-asserted).'.",
+                },
+                date: {
+                    type: "string",
+                    description: "ISO YYYY-MM-DD. Defaults to today.",
+                },
             },
             required: ["account_id", "target_balance", "reason"],
         },
     },
+    {
+        name: "rename_account",
+        description: "Rename an existing account. Postings and metadata are untouched. Use for utterances like 'rename SCB to Bangkok Bank' once the user-named account is resolved via find_similar_accounts.",
+        input_schema: {
+            type: "object",
+            properties: {
+                account_id: { type: "string" },
+                name: { type: "string" },
+            },
+            required: ["account_id", "name"],
+        },
+    },
+    {
+        name: "delete_account",
+        description: "Delete an account that has no postings and no children. Use for utterances like 'delete my old empty cash account'. Refuses if the account still has postings (merge into another account first) or child accounts (delete or re-parent the children first).",
+        input_schema: {
+            type: "object",
+            properties: { account_id: { type: "string" } },
+            required: ["account_id"],
+        },
+    },
     {
         name: "clarify",
-        description: "Ask the user a clarifying question and return their answer as a string. Use when the utterance is ambiguous (multiple matching accounts, missing amount, unclear date, can't tell expense vs transfer, plan confirmation before a multi-step action). Unlike review's ask_user, this does NOT write to the concerns table — record-time questions are transient.",
+        description: "Ask the user a clarifying question and return their answer as a string. Use when the utterance is ambiguous (multiple matching accounts, missing amount, unclear date, can't tell expense vs transfer, plan confirmation before a multi-step action). Unlike resolve's ask_user, this does NOT write to the unknowns table — record-time questions are transient.",
         input_schema: {
             type: "object",
             properties: {
-                prompt: { type: "string", description: "The question to ask in plain language." },
+                prompt: {
+                    type: "string",
+                    description: "The question to ask in plain language.",
+                },
                 options: {
                     type: "array",
                     items: { type: "string" },
@@ -72,6 +112,8 @@ const DEFS = [
 const LABELS = {
     find_similar_accounts: "Searching similar accounts",
     adjust_account_balance: "Adjusting balance",
+    rename_account: "Renaming account",
+    delete_account: "Deleting account",
     clarify: "Asking for clarification",
 };
 async function execute(db, name, input, ctx) {
@@ -82,11 +124,26 @@ async function execute(db, name, input, ctx) {
                 return `No accounts matched "${sanitizeForPrompt(input.query ?? "")}".`;
             return matches
                 .slice(0, 8)
-                .map(m => `${m.account.id} | ${sanitizeForPrompt(m.account.name)} | ${m.account.type}${m.account.subtype ? `/${m.account.subtype}` : ""} | similarity ${m.similarity}`)
+                .map((m) => `${m.account.id} | ${sanitizeForPrompt(m.account.name)} | ${m.account.type}${m.account.subtype ? `/${m.account.subtype}` : ""} | similarity ${m.similarity}`)
                 .join("\n");
         }
         case "adjust_account_balance":
             return adjustAccountBalance(db, input, ctx);
+        case "rename_account": {
+            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 "delete_account": {
+            try {
+                deleteAccount(db, input.account_id);
+                return `Deleted account ${input.account_id}.`;
+            }
+            catch (err) {
+                return `Could not delete: ${err.message}`;
+            }
+        }
         case "clarify": {
             if (!ctx)
                 return "clarify is only available inside an agent session.";
@@ -103,8 +160,6 @@ async function execute(db, name, input, ctx) {
 async function adjustAccountBalance(db, input, ctx) {
     if (!ctx)
         return "adjust_account_balance is only available inside an agent session.";
-    if (ctx.dryRun)
-        return `Would adjust ${input.account_id} balance to ${input.target_balance}.`;
     const account = findAccountById(db, input.account_id);
     if (!account)
         return `Account "${input.account_id}" not found.`;
@@ -112,7 +167,7 @@ async function adjustAccountBalance(db, input, ctx) {
     if (!Number.isFinite(target))
         return `target_balance must be a number, got ${JSON.stringify(input.target_balance)}.`;
     const balances = getAccountBalances(db);
-    const current = balances.find(b => b.id === account.id)?.balance ?? 0;
+    const current = balances.find((b) => b.id === account.id)?.balance ?? 0;
     const delta = round2(target - current);
     if (delta === 0) {
         return `${sanitizeForPrompt(account.name)} is already at ${formatAmount(target)}; no transaction posted.`;
@@ -123,7 +178,9 @@ async function adjustAccountBalance(db, input, ctx) {
         ? account.id
         : EQUITY_ADJUST_ID;
     const creditAccountId = debitAccountId === account.id ? EQUITY_ADJUST_ID : account.id;
-    const date = input.date && /^\d{4}-\d{2}-\d{2}$/.test(input.date) ? input.date : todayIso();
+    const date = input.date && /^\d{4}-\d{2}-\d{2}$/.test(input.date)
+        ? input.date
+        : todayIso();
     const reason = String(input.reason || "Balance adjustment").trim();
     const currency = account.currency || "THB";
     const txInput = {
@@ -169,7 +226,10 @@ async function adjustAccountBalance(db, input, ctx) {
                         account_id: account.id,
                         before_balance: current,
                         after_balance: target,
-                        transaction: { date: validated.date, description: validated.description },
+                        transaction: {
+                            date: validated.date,
+                            description: validated.description,
+                        },
                         postings: validated.postings,
                     },
                 });

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

@@ -0,0 +1,2 @@
+import type { ToolModule } from "./types.js";
+export declare const resolveTools: ToolModule;

package/dist/ai/tools/resolve.js

@@ -0,0 +1,195 @@
+import { deleteTransaction, updateTransaction, updatePosting, } from "../../db/queries/transactions.js";
+import { mergeAccounts } from "../../db/queries/account-balance.js";
+import { linkTransactionToRecurrence, recordRecurrence, } from "../../db/queries/recurrences.js";
+import { sanitizeForPrompt } from "../sanitize.js";
+/**
+ * Resolve-mode tools: the mutation primitives an agent calls to APPLY the
+ * answer to an open unknown. Inspection has already happened (scanner inspectors
+ * wrote the unknowns); discovery tools (find_duplicate_transactions,
+ * find_recurrences, etc.) don't live here — the resolver iterates unknowns
+ * and asks the user, it doesn't search.
+ */
+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: "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 unknown.",
+        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: "merge_accounts",
+        description: "Move every posting on `from_id` over to `to_id`, then delete the source account. Use to apply a similar_accounts unknown's 'Merge A into B' resolution. 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: "mark_resolve_done",
+        description: "Call once the current unknown's resolution has been applied. The summary is shown to the user. The pipeline will then mark the unknown resolved and move to the next one.",
+        input_schema: {
+            type: "object",
+            properties: { summary: { type: "string" } },
+            required: ["summary"],
+        },
+    },
+];
+const LABELS = {
+    update_transaction: "Updating transaction",
+    update_posting: "Updating posting",
+    delete_transaction: "Deleting transaction",
+    record_recurrence: "Recording recurrence",
+    link_transaction_to_recurrence: "Linking transaction to recurrence",
+    merge_accounts: "Merging accounts",
+    mark_resolve_done: "Finalizing unknown",
+};
+async function execute(db, name, input, ctx) {
+    switch (name) {
+        case "update_transaction": {
+            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": {
+            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": {
+            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 "record_recurrence": {
+            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": {
+            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 "merge_accounts": {
+            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 "mark_resolve_done": {
+            ctx?.onComplete?.(input.summary || "");
+            return `Unknown done. Summary: ${sanitizeForPrompt(input.summary || "")}`;
+        }
+        default:
+            return undefined;
+    }
+}
+export const resolveTools = { DEFS, LABELS, execute };

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

@@ -1,9 +1,9 @@
 import type Database from "libsql";
 import type { ToolDefinition } from "../provider.js";
 import type { BufferedWriteContext } from "../../scanner/buffer.js";
-export type ToolProfile = "scan" | "chat" | "review" | "record";
+export type ToolProfile = "scan" | "chat" | "resolve" | "record";
 /**
- * Structured highlights the review agent can pass to ask_user. The prompter
+ * Structured highlights the resolve 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.
@@ -19,23 +19,21 @@ export interface AgentExecutionContext {
     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[], facts?: PromptUserFacts) => Promise<string>;
-    /** Called when the model declares the session is done (scan or review). */
+    /** Called when the model declares the session is done (scan or resolve). */
     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";
+    command?: "scan" | "resolve" | "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
+     * Scan-only: when set, transactions and unknowns 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.

package/dist/cli/commands/accounts.js

@@ -1,6 +1,6 @@
 import chalk from "chalk";
 import { getDb } from "../../db/connection.js";
-import { getAccountBalances } from "../../db/queries/account_balance.js";
+import { getAccountBalances } from "../../db/queries/account-balance.js";
 import { visibleLength } from "../format.js";
 import { formatSignedAmount } from "../../currency.js";
 const TYPE_TAG = {
@@ -42,7 +42,7 @@ export function showAccounts() {
         console.log(chalk.yellow("No accounts yet. Drop your bank/credit card statements into ~/.plasalid/data/ and run `plasalid scan`."));
         return;
     }
-    const byId = new Map(raw.map(a => [a.id, a]));
+    const byId = new Map(raw.map((a) => [a.id, a]));
     const depthCache = new Map();
     const depthOf = (id) => {
         if (depthCache.has(id))

package/dist/cli/commands/record.js

@@ -3,7 +3,7 @@ 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 { listActions } from "../../db/queries/action-log.js";
 import { formatAmount } from "../../currency.js";
 export async function runRecordCommand(opts) {
     const utterance = opts.utterance.trim();
@@ -73,7 +73,9 @@ function describeAction(a) {
             const date = payload?.transaction?.date ?? "";
             const desc = payload?.transaction?.description ?? "";
             const total = totalDebit(payload?.postings);
-            const amount = total != null ? ` ${formatTotal(total, currencyOf(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": {

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

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

package/dist/cli/commands/resolve.js

@@ -0,0 +1,13 @@
+import chalk from "chalk";
+import { runResolve } from "../../resolver/pipeline.js";
+export async function runResolveCommand(opts) {
+    try {
+        const summary = await runResolve(opts);
+        console.log("");
+        console.log(chalk.bold(summary));
+    }
+    catch (err) {
+        console.error(chalk.red(`Resolve failed: ${err.message}`));
+        process.exitCode = 1;
+    }
+}