plasalid 0.5.7 → 0.6.0

package/dist/ai/tools/ingest.js

@@ -1,18 +1,18 @@
-import { createAccount, updateAccountMetadata, findAccountById, } from "../../db/queries/account_balance.js";
+import { createAccount, updateAccountMetadata, findAccountById, } from "../../db/queries/account-balance.js";
 import { validateTransaction, insertTransactionRows, recordTransaction, } from "../../db/queries/transactions.js";
-import { appendAction } from "../../db/queries/action_log.js";
-import { getConcernTarget, recordConcern, resolveConcern, } from "../../db/queries/concerns.js";
-import { runExclusive as runAccountExclusive } from "../../scanner/account_mutex.js";
+import { appendAction } from "../../db/queries/action-log.js";
+import { getUnknownTarget, recordUnknown, resolveUnknown, } from "../../db/queries/unknowns.js";
+import { runExclusive as runAccountExclusive } from "../../scanner/account-mutex.js";
 import { sanitizeForPrompt } from "../sanitize.js";
 import { ACCOUNT_TYPE_DESCRIPTIONS } from "../../accounts/taxonomy.js";
 const ACCOUNT_TYPES = Object.keys(ACCOUNT_TYPE_DESCRIPTIONS);
 /**
  * Account + transaction write primitives
  *
- * Shared by scan, review, and record. Each tool branches once on
+ * Shared by scan, resolve, and record. Each tool branches once on
  * `ctx.correlationId`: when set (record path), the data write and the
  * action_log insert run inside a single transaction so the audit row is
- * atomic with the change. Without it (scan / review), the write goes through
+ * atomic with the change. Without it (scan / resolve), the write goes through
  * the existing path unchanged.
  */
 const ACCOUNT_DEFS = [
@@ -22,20 +22,52 @@ const ACCOUNT_DEFS = [
         input_schema: {
             type: "object",
             properties: {
-                id: { type: "string", description: "Stable colon-path identifier, lowercase. e.g. 'expense:food:groceries' or 'asset:kbank-savings-1234'." },
-                name: { type: "string", description: "Human-readable name. e.g. 'Groceries' or 'KBank Savings ••1234'." },
-                type: { type: "string", enum: ACCOUNT_TYPES, description: "Account type. Must match the parent's type." },
+                id: {
+                    type: "string",
+                    description: "Stable colon-path identifier, lowercase. e.g. 'expense:food:groceries' or 'asset:kbank-savings-1234'.",
+                },
+                name: {
+                    type: "string",
+                    description: "Human-readable name. e.g. 'Groceries' or 'KBank Savings ••1234'.",
+                },
+                type: {
+                    type: "string",
+                    enum: ACCOUNT_TYPES,
+                    description: "Account type. Must match the parent's type.",
+                },
                 parent_id: {
                     type: ["string", "null"],
                     description: "Parent account id (the prefix before the final ':' segment). Pass null only when creating one of the five top-level type roots — and then id must equal type. Examples: id='expense:food:groceries' → parent_id='expense:food'. id='expense:food' → parent_id='expense'. id='expense' → parent_id=null.",
                 },
-                subtype: { type: "string", description: "e.g. 'bank', 'credit_card', 'salary'." },
-                bank_name: { type: "string", description: "Thai institution code from the taxonomy (e.g. KBANK, SCB, KTC)." },
-                account_number_masked: { type: "string", description: "Last 4 digits only, e.g. '••1234'." },
-                currency: { type: "string", description: "ISO 4217 code. Defaults to 'THB'.", default: "THB" },
-                due_day: { type: "number", description: "Credit-card due day of month (liabilities only)." },
-                statement_day: { type: "number", description: "Statement-cut day of month." },
-                metadata: { type: "object", description: "Free-form extra fields (e.g. {points_program: 'KTC Forever'})." },
+                subtype: {
+                    type: "string",
+                    description: "e.g. 'bank', 'credit_card', 'salary'.",
+                },
+                bank_name: {
+                    type: "string",
+                    description: "Thai institution code from the taxonomy (e.g. KBANK, SCB, KTC).",
+                },
+                account_number_masked: {
+                    type: "string",
+                    description: "Last 4 digits only, e.g. '••1234'.",
+                },
+                currency: {
+                    type: "string",
+                    description: "ISO 4217 code. Defaults to 'THB'.",
+                    default: "THB",
+                },
+                due_day: {
+                    type: "number",
+                    description: "Credit-card due day of month (liabilities only).",
+                },
+                statement_day: {
+                    type: "number",
+                    description: "Statement-cut day of month.",
+                },
+                metadata: {
+                    type: "object",
+                    description: "Free-form extra fields (e.g. {points_program: 'KTC Forever'}).",
+                },
             },
             required: ["id", "name", "type", "parent_id"],
         },
@@ -52,7 +84,10 @@ const ACCOUNT_DEFS = [
                 points_balance: { type: "number" },
                 account_number_masked: { type: "string" },
                 bank_name: { type: "string" },
-                metadata: { type: "object", description: "Merged into existing metadata_json." },
+                metadata: {
+                    type: "object",
+                    description: "Merged into existing metadata_json.",
+                },
             },
             required: ["account_id"],
         },
@@ -63,9 +98,18 @@ const ACCOUNT_DEFS = [
         input_schema: {
             type: "object",
             properties: {
-                date: { type: "string", description: "ISO Gregorian date (YYYY-MM-DD)." },
-                description: { type: "string", description: "Short human-readable description." },
-                source_page: { type: "number", description: "Page number in the source PDF, if known." },
+                date: {
+                    type: "string",
+                    description: "ISO Gregorian date (YYYY-MM-DD).",
+                },
+                description: {
+                    type: "string",
+                    description: "Short human-readable description.",
+                },
+                source_page: {
+                    type: "number",
+                    description: "Page number in the source PDF, if known.",
+                },
                 raw_descriptor: {
                     type: "string",
                     description: "The exact statement line (the raw merchant descriptor) when posting from a PDF — preserved for alias matching and later review. Omit for manual entries and transfers.",
@@ -74,9 +118,18 @@ const ACCOUNT_DEFS = [
                     type: "object",
                     description: "Counter-party block. Omit for transfers between own accounts and pure metadata movements. When set during a scan, Plasalid upserts the merchant by canonical_name and (optionally) records the raw descriptor as an alias for future matches. Set default_account_id to teach the cache when categorization is confident.",
                     properties: {
-                        canonical_name: { type: "string", description: "Normalized merchant name, Title Case. e.g. 'Starbucks', 'Amazon', 'Spotify'." },
-                        alias: { type: "string", description: "The raw descriptor exactly as it appears on the statement. Plasalid normalizes and stores it so future statements skip the LLM." },
-                        default_account_id: { type: "string", description: "Optional learned cache: 'this merchant's expense category is X'. Set when categorization is confident." },
+                        canonical_name: {
+                            type: "string",
+                            description: "Normalized merchant name, Title Case. e.g. 'Starbucks', 'Amazon', 'Spotify'.",
+                        },
+                        alias: {
+                            type: "string",
+                            description: "The raw descriptor exactly as it appears on the statement. Plasalid normalizes and stores it so future statements skip the LLM.",
+                        },
+                        default_account_id: {
+                            type: "string",
+                            description: "Optional learned cache: 'this merchant's expense category is X'. Set when categorization is confident.",
+                        },
                     },
                     required: ["canonical_name"],
                 },
@@ -90,11 +143,27 @@ const ACCOUNT_DEFS = [
                     items: {
                         type: "object",
                         properties: {
-                            account_id: { type: "string", description: "Existing account id from list_accounts or create_account." },
-                            debit: { type: "number", description: "Debit amount in this posting's currency. Use 0 if this posting is a credit." },
-                            credit: { type: "number", description: "Credit amount in this posting's currency. Use 0 if this posting is a debit." },
-                            currency: { type: "string", description: "ISO 4217 currency code for this posting (e.g. THB, USD, EUR). Defaults to THB.", default: "THB" },
-                            memo: { type: "string", description: "Optional per-posting memo." },
+                            account_id: {
+                                type: "string",
+                                description: "Existing account id from list_accounts or create_account.",
+                            },
+                            debit: {
+                                type: "number",
+                                description: "Debit amount in this posting's currency. Use 0 if this posting is a credit.",
+                            },
+                            credit: {
+                                type: "number",
+                                description: "Credit amount in this posting's currency. Use 0 if this posting is a debit.",
+                            },
+                            currency: {
+                                type: "string",
+                                description: "ISO 4217 currency code for this posting (e.g. THB, USD, EUR). Defaults to THB.",
+                                default: "THB",
+                            },
+                            memo: {
+                                type: "string",
+                                description: "Optional per-posting memo.",
+                            },
                         },
                         required: ["account_id"],
                     },
@@ -112,8 +181,6 @@ const ACCOUNT_LABELS = {
 async function accountExecute(db, name, input, ctx) {
     switch (name) {
         case "create_account": {
-            if (ctx?.dryRun)
-                return `Would create account ${input.id}.`;
             if (!ACCOUNT_TYPES.includes(input.type)) {
                 return `Invalid type "${input.type}". Allowed: ${ACCOUNT_TYPES.join(", ")}.`;
             }
@@ -163,8 +230,6 @@ async function accountExecute(db, name, input, ctx) {
             });
         }
         case "update_account_metadata": {
-            if (ctx?.dryRun)
-                return `Would update metadata for ${input.account_id}: ${JSON.stringify(input)}`;
             return await runAccountExclusive(() => {
                 try {
                     let changed = false;
@@ -199,7 +264,9 @@ async function accountExecute(db, name, input, ctx) {
                     else {
                         apply();
                     }
-                    return changed ? `Updated ${input.account_id}.` : "Nothing to update.";
+                    return changed
+                        ? `Updated ${input.account_id}.`
+                        : "Nothing to update.";
                 }
                 catch (err) {
                     if (String(err.message).includes("not found")) {
@@ -212,8 +279,6 @@ async function accountExecute(db, name, input, ctx) {
         case "record_transaction": {
             if (!ctx)
                 return "record_transaction is only available inside an agent session.";
-            if (ctx.dryRun)
-                return `Would post transaction "${input.description}" on ${input.date}.`;
             const txInput = {
                 date: input.date,
                 description: input.description,
@@ -278,62 +343,67 @@ export const accountIngestTools = {
     execute: accountExecute,
 };
 /**
- * Scan-only concerns
+ * Scan-only unknowns
  *
- * `note_concern` records a clarification mid-scan without ever prompting the
+ * `note_unknown` records a clarification mid-scan without ever prompting the
  * user — only scan needs this. Record uses `clarify` (transient prompt, no
- * concerns-table residue); review uses `ask_user` (prompts and resolves).
+ * unknowns-table residue); resolve uses `ask_user` (prompts and resolves).
  */
-const CONCERN_DEFS = [
+const UNKNOWN_DEFS = [
     {
-        name: "note_concern",
-        description: "Record a clarification request without pausing the run. Use during scan when a row is ambiguous (post your best-guess transaction first, then call this with the transaction's id), when a row is unparseable (skip the transaction, call this with no transaction_id), or when you have a concern about an account itself (pass account_id). Use kind='uncategorized_expense' when posting an expense to expense:uncategorized so reviewer can group these. The reviewer picks these up later with the full picture.",
+        name: "note_unknown",
+        description: "Record a clarification request without pausing the run. Use during scan when a row is ambiguous (post your best-guess transaction first, then call this with the transaction's id), when a row is unparseable (skip the transaction, call this with no transaction_id), or when you have a unknown about an account itself (pass account_id). Use kind='uncategorized_expense' when posting an expense to expense:uncategorized so resolve can group these. The resolver picks these up later with the full picture.",
         input_schema: {
             type: "object",
             properties: {
                 prompt: {
                     type: "string",
-                    description: "The question or concern in a complete sentence, with date, ฿-formatted amount, and human account names. Never reference internal ids.",
+                    description: "The question or unknown in a complete sentence, with date, ฿-formatted amount, and human account names. Never reference internal ids.",
                 },
                 kind: {
                     type: "string",
-                    description: "Optional category for the concern. Use 'uncategorized_expense' when the posting landed in expense:uncategorized; reviewer batches these into one cleanup pass.",
+                    description: "Optional category for the unknown. Use 'uncategorized_expense' when the posting landed in expense:uncategorized; the resolver batches these into one cleanup pass.",
                 },
                 options: {
                     type: "array",
-                    description: "Optional list of candidate answers the reviewer can offer the user.",
+                    description: "Optional list of candidate answers the resolver can offer the user.",
                     items: { type: "string" },
                 },
                 transaction_id: {
                     type: "string",
-                    description: "Id of the transaction this concern relates to (returned by record_transaction). Omit for file-level concerns about an unparseable row.",
+                    description: "Id of the transaction this unknown relates to (returned by record_transaction). Omit for file-level unknowns about an unparseable row.",
                 },
                 account_id: {
                     type: "string",
-                    description: "Id of the account this concern relates to. Set when the statement's bank name, currency, statement_day, due_day, or other metadata disagrees with the stored account, or when you suspect a new account you're about to create duplicates an existing one. Can be combined with transaction_id.",
+                    description: "Id of the account this unknown relates to. Set when the statement's bank name, currency, statement_day, due_day, or other metadata disagrees with the stored account, or when you suspect a new account you're about to create duplicates an existing one. Can be combined with transaction_id.",
                 },
             },
             required: ["prompt"],
         },
     },
 ];
-const CONCERN_LABELS = {
-    note_concern: "Noting concern",
+const UNKNOWN_LABELS = {
+    note_unknown: "Noting unknown",
 };
-async function concernExecute(db, name, input, ctx) {
-    if (name !== "note_concern")
+async function unknownExecute(db, name, input, ctx) {
+    if (name !== "note_unknown")
         return undefined;
     if (!ctx)
-        return "note_concern is only available inside an agent session.";
+        return "note_unknown is only available inside an agent session.";
     const target = {
         transaction_id: input.transaction_id ?? null,
         account_id: input.account_id ?? null,
     };
     if (ctx.buffer) {
-        ctx.buffer.appendConcern({ ...target, kind: input.kind ?? null, prompt: input.prompt, options: input.options });
-        return `Concern noted (buffered). Continue with the next row.`;
+        ctx.buffer.appendUnknown({
+            ...target,
+            kind: input.kind ?? null,
+            prompt: input.prompt,
+            options: input.options,
+        });
+        return `Unknown noted (buffered). Continue with the next row.`;
     }
-    const id = recordConcern(db, {
+    const id = recordUnknown(db, {
         file_id: ctx.fileId ?? null,
         transaction_id: target.transaction_id,
         account_id: target.account_id,
@@ -341,28 +411,31 @@ async function concernExecute(db, name, input, ctx) {
         prompt: input.prompt,
         options: input.options,
     });
-    return `Concern noted (${id}). Continue with the next row.`;
+    return `Unknown noted (${id}). Continue with the next row.`;
 }
-export const scanConcernTools = {
-    DEFS: CONCERN_DEFS,
-    LABELS: CONCERN_LABELS,
-    execute: concernExecute,
+export const scanUnknownTools = {
+    DEFS: UNKNOWN_DEFS,
+    LABELS: UNKNOWN_LABELS,
+    execute: unknownExecute,
 };
 /**
- * Review-only tool definitions
+ * Resolve-only tool definitions
  *
  * `ask_user` is the only interactive primitive. Scan never reaches it (the
  * scan profile doesn't include this module), so we don't need a "scan, please
  * don't use this" guard.
  */
-const REVIEW_DEFS = [
+const RESOLVE_DEFS = [
     {
         name: "ask_user",
-        description: "Ask the user a clarifying question when you cannot confidently proceed. The pipeline pauses and prompts the user interactively. Available during `plasalid review`. Not exposed during `plasalid scan` — use `note_concern` instead. Pass `transaction_id` / `account_id` to attach the question to the same target as a scan-noted concern. Pass `concern_id` to resolve an existing open concern in place (recommended when re-posing a scan-noted concern to the user). Pass `related_concern_ids` to apply the user's single answer to a whole group of sibling concerns at once.",
+        description: "Ask the user a clarifying question when you cannot confidently proceed. The pipeline pauses and prompts the user interactively. Available during `plasalid resolve`. Not exposed during `plasalid scan` — use `note_unknown` instead. Pass `transaction_id` / `account_id` to attach the question to the same target as a scan-noted unknown. Pass `unknown_id` to resolve an existing open unknown in place (recommended when re-posing a scan-noted unknown to the user). Pass `related_unknown_ids` to apply the user's single answer to a whole group of sibling unknowns at once.",
         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",
                     description: "Optional list of candidate answers.",
@@ -370,28 +443,37 @@ const REVIEW_DEFS = [
                 },
                 transaction_id: {
                     type: "string",
-                    description: "Optional: transaction this question is about. Used to clear the transaction's has_concern flag once all its concerns close.",
+                    description: "Optional: transaction this question is about. Used to clear the transaction's has_unknown flag once all its unknowns close.",
                 },
                 account_id: {
                     type: "string",
-                    description: "Optional: account this question is about. Used to clear the account's has_concern flag once all its concerns close.",
+                    description: "Optional: account this question is about. Used to clear the account's has_unknown flag once all its unknowns close.",
                 },
-                concern_id: {
+                unknown_id: {
                     type: "string",
-                    description: "Optional: id of an existing open concern. If supplied, the user's answer resolves that row in place instead of creating a new one.",
+                    description: "Optional: id of an existing open unknown. If supplied, the user's answer resolves that row in place instead of creating a new one.",
                 },
-                related_concern_ids: {
+                related_unknown_ids: {
                     type: "array",
                     items: { type: "string" },
-                    description: "Optional: ids of additional open concerns that share the same answer as `concern_id`. The user is prompted once; every listed concern (plus the primary) is marked resolved with the same answer. Use this for grouping duplicate questions — e.g., 12 Lazada rows that all categorize the same way — so the user isn't asked the same thing twelve times.",
+                    description: "Optional: ids of additional open unknowns that share the same answer as `unknown_id`. The user is prompted once; every listed unknown (plus the primary) is marked resolved with the same answer. Use this for grouping duplicate questions — e.g., 12 Lazada rows that all categorize the same way — so the user isn't asked the same thing twelve times.",
                 },
                 facts: {
                     type: "object",
                     description: "Optional structured highlights rendered as a single colored header line above the question. Provide whichever fields apply; the prompter colorizes each by category (amount=yellow, date=cyan, merchant=green, accounts=magenta). Keep the `prompt` text short — the facts header carries the context.",
                     properties: {
-                        amount: { type: "string", description: "฿-formatted amount, e.g. '฿1,200.00'." },
-                        date: { type: "string", description: "ISO date or short range, e.g. '2026-04-15' or '2026-02-15 to 2026-05-15'." },
-                        merchant: { type: "string", description: "Counterparty / merchant name, e.g. 'LAZADA TH', 'Spotify'." },
+                        amount: {
+                            type: "string",
+                            description: "฿-formatted amount, e.g. '฿1,200.00'.",
+                        },
+                        date: {
+                            type: "string",
+                            description: "ISO date or short range, e.g. '2026-04-15' or '2026-02-15 to 2026-05-15'.",
+                        },
+                        merchant: {
+                            type: "string",
+                            description: "Counterparty / merchant name, e.g. 'LAZADA TH', 'Spotify'.",
+                        },
                         accounts: {
                             type: "array",
                             items: { type: "string" },
@@ -403,23 +485,42 @@ const REVIEW_DEFS = [
             required: ["prompt"],
         },
     },
+    {
+        name: "close_unknown",
+        description: "Close an open unknown by writing its answer to the row WITHOUT prompting the user. Use after applying a mutation that a memory rule, heuristic, or small-amount auto-skip already implied. Pass `related_unknown_ids` to close a sibling group in one call. The actual mutation (update_posting / record_recurrence / merge_accounts / etc.) must be done BEFORE this call — close_unknown only records the answer for audit.",
+        input_schema: {
+            type: "object",
+            properties: {
+                unknown_id: { type: "string" },
+                answer: {
+                    type: "string",
+                    description: "The implied answer to record.",
+                },
+                related_unknown_ids: { type: "array", items: { type: "string" } },
+            },
+            required: ["unknown_id", "answer"],
+        },
+    },
 ];
-const REVIEW_LABELS = {
+const RESOLVE_LABELS = {
     ask_user: "Asking for clarification",
+    close_unknown: "Closing unknown",
 };
-async function reviewExecute(db, name, input, ctx) {
+async function resolveExecute(db, name, input, ctx) {
+    if (name === "close_unknown")
+        return closeUnknown(db, input);
     if (name !== "ask_user")
         return undefined;
     if (!ctx)
         return "ask_user is only available inside an agent session.";
     let id;
-    if (input.concern_id) {
-        id = String(input.concern_id);
-        if (!getConcernTarget(db, id))
-            return `Concern ${id} not found.`;
+    if (input.unknown_id) {
+        id = String(input.unknown_id);
+        if (!getUnknownTarget(db, id))
+            return `Unknown ${id} not found.`;
     }
     else {
-        id = recordConcern(db, {
+        id = recordUnknown(db, {
             file_id: ctx.fileId ?? null,
             transaction_id: input.transaction_id ?? null,
             account_id: input.account_id ?? null,
@@ -429,22 +530,44 @@ async function reviewExecute(db, name, input, ctx) {
     }
     if (ctx.interactive && ctx.promptUser) {
         const answer = await ctx.promptUser(input.prompt, input.options, input.facts);
-        resolveConcern(db, id, answer);
-        const siblings = Array.isArray(input.related_concern_ids) ? input.related_concern_ids : [];
+        resolveUnknown(db, id, answer);
+        const siblings = Array.isArray(input.related_unknown_ids)
+            ? input.related_unknown_ids
+            : [];
         let propagated = 0;
         for (const sibId of siblings) {
             if (sibId === id)
                 continue;
-            if (resolveConcern(db, String(sibId), answer))
+            if (resolveUnknown(db, String(sibId), answer))
                 propagated++;
         }
         const totalResolved = 1 + propagated;
-        return `User answered: ${sanitizeForPrompt(answer)}${totalResolved > 1 ? ` (applied to ${totalResolved} concern${totalResolved === 1 ? "" : "s"})` : ""}`;
+        return `User answered: ${sanitizeForPrompt(answer)}${totalResolved > 1 ? ` (applied to ${totalResolved} unknown${totalResolved === 1 ? "" : "s"})` : ""}`;
     }
     return `Question recorded for later (${id}). Awaiting user input — do not act on assumptions about this answer.`;
 }
-export const reviewIngestTools = {
-    DEFS: REVIEW_DEFS,
-    LABELS: REVIEW_LABELS,
-    execute: reviewExecute,
+function closeUnknown(db, input) {
+    const primary = String(input.unknown_id ?? "");
+    const answer = String(input.answer ?? "");
+    if (!primary || !answer)
+        return "close_unknown requires unknown_id and answer.";
+    if (!getUnknownTarget(db, primary))
+        return `Unknown ${primary} not found.`;
+    resolveUnknown(db, primary, answer);
+    let count = 1;
+    const siblings = Array.isArray(input.related_unknown_ids)
+        ? input.related_unknown_ids
+        : [];
+    for (const sibId of siblings) {
+        if (sibId === primary)
+            continue;
+        if (resolveUnknown(db, String(sibId), answer))
+            count++;
+    }
+    return `Closed ${count} unknown${count === 1 ? "" : "s"}.`;
+}
+export const resolveIngestTools = {
+    DEFS: RESOLVE_DEFS,
+    LABELS: RESOLVE_LABELS,
+    execute: resolveExecute,
 };

package/dist/ai/tools/merchants.js

@@ -1,5 +1,5 @@
 import { upsertMerchant, findMerchantByAlias, findMerchantById, setMerchantDefaultAccount, } from "../../db/queries/merchants.js";
-import { appendAction } from "../../db/queries/action_log.js";
+import { appendAction } from "../../db/queries/action-log.js";
 import { sanitizeForPrompt } from "../sanitize.js";
 /**
  * Merchant tools
@@ -17,9 +17,18 @@ const DEFS = [
         input_schema: {
             type: "object",
             properties: {
-                canonical_name: { type: "string", description: "Title-cased merchant name, e.g. 'Starbucks', 'Amazon'." },
-                alias: { type: "string", description: "Optional raw descriptor (as seen on a statement). Plasalid normalizes and dedups it." },
-                default_account_id: { type: "string", description: "Optional learned cache: the merchant's default expense account." },
+                canonical_name: {
+                    type: "string",
+                    description: "Title-cased merchant name, e.g. 'Starbucks', 'Amazon'.",
+                },
+                alias: {
+                    type: "string",
+                    description: "Optional raw descriptor (as seen on a statement). Plasalid normalizes and dedups it.",
+                },
+                default_account_id: {
+                    type: "string",
+                    description: "Optional learned cache: the merchant's default expense account.",
+                },
             },
             required: ["canonical_name"],
         },
@@ -30,7 +39,10 @@ const DEFS = [
         input_schema: {
             type: "object",
             properties: {
-                descriptor: { type: "string", description: "The raw statement line or merchant string to look up." },
+                descriptor: {
+                    type: "string",
+                    description: "The raw statement line or merchant string to look up.",
+                },
             },
             required: ["descriptor"],
         },
@@ -56,8 +68,6 @@ const LABELS = {
 async function execute(db, name, input, ctx) {
     switch (name) {
         case "find_or_create_merchant": {
-            if (ctx?.dryRun)
-                return `Would upsert merchant "${input.canonical_name}".`;
             const existing = db
                 .prepare(`SELECT id FROM merchants WHERE canonical_name = ?`)
                 .get(input.canonical_name);
@@ -73,22 +83,27 @@ async function execute(db, name, input, ctx) {
                     user_input: ctx.userInput ?? null,
                     action_type: "create_merchant",
                     target_id: merchant.id,
-                    payload: { canonical_name: merchant.canonical_name, default_account_id: merchant.default_account_id },
+                    payload: {
+                        canonical_name: merchant.canonical_name,
+                        default_account_id: merchant.default_account_id,
+                    },
                 });
             }
-            const defaultStr = merchant.default_account_id ? ` (default → ${merchant.default_account_id})` : "";
+            const defaultStr = merchant.default_account_id
+                ? ` (default → ${merchant.default_account_id})`
+                : "";
             return `Merchant ${merchant.id}: ${sanitizeForPrompt(merchant.canonical_name)}${defaultStr}.`;
         }
         case "find_merchant_by_descriptor": {
             const hit = findMerchantByAlias(db, String(input.descriptor ?? ""));
             if (!hit)
                 return `No merchant matched descriptor "${sanitizeForPrompt(String(input.descriptor ?? ""))}".`;
-            const defaultStr = hit.default_account_id ? ` (default → ${hit.default_account_id})` : "";
+            const defaultStr = hit.default_account_id
+                ? ` (default → ${hit.default_account_id})`
+                : "";
             return `Merchant ${hit.merchant.id}: ${sanitizeForPrompt(hit.merchant.canonical_name)}${defaultStr}.`;
         }
         case "set_merchant_default_account": {
-            if (ctx?.dryRun)
-                return `Would set ${input.merchant_id}'s default to ${input.account_id}.`;
             const m = findMerchantById(db, input.merchant_id);
             if (!m)
                 return `Merchant ${input.merchant_id} not found.`;