plasalid 0.2.0

package/dist/ai/redactor.js

@@ -0,0 +1,91 @@
+import { config } from "../config.js";
+import { readContext } from "./context.js";
+function buildRedactions() {
+    const entries = [];
+    const seen = new Set();
+    function add(real, token) {
+        const trimmed = real.trim();
+        if (trimmed.length < 2 || seen.has(trimmed.toLowerCase()))
+            return;
+        seen.add(trimmed.toLowerCase());
+        entries.push({ real: trimmed, token });
+    }
+    const userName = config.userName;
+    if (userName && userName !== "User") {
+        add(userName, "[USER]");
+        const parts = userName.split(/\s+/);
+        if (parts.length > 1) {
+            add(parts[0], "[USER_FIRST]");
+            add(parts[parts.length - 1], "[USER_LAST]");
+        }
+    }
+    const context = readContext();
+    if (context) {
+        const familyMatch = context.match(/## Family\n([\s\S]*?)(?=\n##|$)/);
+        if (familyMatch) {
+            const lines = familyMatch[1].split("\n").filter(l => l.trim().startsWith("-"));
+            for (const line of lines) {
+                const text = line.replace(/^-\s*/, "").trim();
+                if (!text || text.startsWith("(") || text.toLowerCase() === userName.toLowerCase())
+                    continue;
+                const nameMatch = text.match(/^(?:partner|spouse|wife|husband|child|kid|son|daughter|dependent)[:\s]+(.+)/i)
+                    || text.match(/^([\p{Lu}\p{Lo}][\p{L}\s]+)/u);
+                if (nameMatch) {
+                    const name = nameMatch[1].replace(/\s*\(.*\)/, "").trim();
+                    if (name && name.toLowerCase() !== userName.toLowerCase()) {
+                        add(name, "[PARTNER]");
+                    }
+                }
+            }
+        }
+        const incomeMatch = context.match(/## Income\n([\s\S]*?)(?=\n##|$)/);
+        if (incomeMatch) {
+            const lines = incomeMatch[1].split("\n").filter(l => l.trim().startsWith("-"));
+            for (const line of lines) {
+                const text = line.replace(/^-\s*/, "").trim();
+                if (!text || text.startsWith("("))
+                    continue;
+                const employerMatch = text.match(/(?:employer|works? (?:at|for)|employed (?:at|by))[:\s]+([A-Z][\w\s&.,-]+?)(?:\s*[-–—|,;(\n]|$)/i)
+                    || text.match(/\bfrom ([A-Z][A-Za-z\s&.,-]+?)(?:\s*[-–—|,;(\n]|$)/)
+                    || text.match(/\bat ([A-Z][A-Za-z\s&.,-]+?)(?:\s*[-–—|,;(\n]|$)/);
+                if (employerMatch) {
+                    add(employerMatch[1].trim(), "[EMPLOYER]");
+                }
+            }
+        }
+    }
+    entries.sort((a, b) => b.real.length - a.real.length);
+    return entries;
+}
+// Patterns for numeric / identifier PII commonly found in Thai financial data.
+const NUMERIC_PII_PATTERNS = [
+    // Thai national ID with dashes: 1-2345-67890-12-3
+    [/\b\d-\d{4}-\d{5}-\d{2}-\d\b/g, "[NATID]"],
+    // Thai national ID without dashes (13 digits) — must precede the generic ACCT pattern.
+    [/\b\d{13}\b/g, "[NATID]"],
+    // Thai mobile numbers: 0[689]xxxxxxxx (10 digits starting 06/08/09)
+    [/\b0[689]\d{8}\b/g, "[PHONE]"],
+    // 16-digit credit card (with optional separators)
+    [/\b\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\b/g, "[CARD]"],
+    // 10–12 digit account / routing numbers at a word boundary
+    [/\b\d{10,12}\b(?=\s|$|[,.])/g, "[ACCT]"],
+];
+export function redact(text) {
+    const redactions = buildRedactions();
+    let result = text;
+    for (const { real, token } of redactions) {
+        result = result.replaceAll(real, token);
+    }
+    for (const [pattern, replacement] of NUMERIC_PII_PATTERNS) {
+        result = result.replace(pattern, replacement);
+    }
+    return result;
+}
+export function unredact(text) {
+    const redactions = buildRedactions();
+    let result = text;
+    for (const { real, token } of redactions) {
+        result = result.replaceAll(token, real);
+    }
+    return result;
+}

package/dist/ai/sanitize.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Defensive helpers for interpolating user / model-controlled text into
+ * tool-output strings that flow back to the LLM. They strip control characters
+ * that could smuggle instructions across data/instruction boundaries.
+ */
+/** Strip control characters (newlines, tabs, ANSI escapes) from text. */
+export declare function stripControls(text: string): string;
+/** Sanitize text for prompt interpolation (no length clip — keep full content). */
+export declare function sanitizeForPrompt(text: string | null | undefined): string;
+/**
+ * Sanitize for use inside a `|`-delimited row. Replaces literal `|` characters
+ * with `/` so a memo / account name containing `|` can't spoof extra columns.
+ */
+export declare function sanitizeForPromptCell(text: string | null | undefined): string;

package/dist/ai/sanitize.js

@@ -0,0 +1,25 @@
+/**
+ * Defensive helpers for interpolating user / model-controlled text into
+ * tool-output strings that flow back to the LLM. They strip control characters
+ * that could smuggle instructions across data/instruction boundaries.
+ */
+/** Strip control characters (newlines, tabs, ANSI escapes) from text. */
+export function stripControls(text) {
+    // eslint-disable-next-line no-control-regex
+    return text.replace(/[\x00-\x1F\x7F]/g, " ").trim();
+}
+/** Sanitize text for prompt interpolation (no length clip — keep full content). */
+export function sanitizeForPrompt(text) {
+    if (!text)
+        return "";
+    return stripControls(text);
+}
+/**
+ * Sanitize for use inside a `|`-delimited row. Replaces literal `|` characters
+ * with `/` so a memo / account name containing `|` can't spoof extra columns.
+ */
+export function sanitizeForPromptCell(text) {
+    if (!text)
+        return "";
+    return stripControls(text).replace(/\|/g, "/");
+}

package/dist/ai/system-prompt.d.ts

@@ -0,0 +1,13 @@
+import type Database from "libsql";
+export declare function buildChatSystemPrompt(db: Database.Database): string;
+export interface ScanPromptOptions {
+    fileName: string;
+}
+export interface ReconcilePromptOptions {
+    accountId?: string;
+    from?: string;
+    to?: string;
+    dryRun: boolean;
+}
+export declare function buildReconcileSystemPrompt(db: Database.Database, opts: ReconcilePromptOptions): string;
+export declare function buildScanSystemPrompt(db: Database.Database, opts: ScanPromptOptions): string;

package/dist/ai/system-prompt.js

@@ -0,0 +1,174 @@
+import { config } from "../config.js";
+import { getMemories } from "./memory.js";
+import { readContext } from "./context.js";
+import { stripControls } from "./sanitize.js";
+import { getAccountBalances } from "../db/queries/account_balance.js";
+import { getThaiTaxonomyHint } from "../accounts/taxonomy.js";
+function chatPersona(name) {
+    return `Your name is Plasalid ("ปลาสลิด") — You're ${name}'s personal money coach. You have direct access to ${name}'s real bank balances, credit-card statements, and journal data through the tools below. Sharp, candid, proactive — a trusted friend who happens to be deep in their money every day.
+
+## How you talk
+- Lead with the insight, not the data. Don't say "Here's the breakdown." Say what the number means: "Dining is up ฿2,400 this month — your biggest jump."
+- Always cite actual figures, dates, and account names from tool results. Never make up data.
+- Have a point of view. When ${name} asks "what should I do?", say what you'd do and why. Present alternatives only after your recommendation.
+- Be proactive: if you notice something concerning (overdraft trajectory, unusual spending, a payment due soon, a balance trending the wrong way), bring it up even if not asked.
+- Be concise. 2-4 sentences for simple questions. Skip preamble like "Great question!" or "Let me look that up." Just answer.
+- Warm but direct. Celebrate wins genuinely. Flag problems without sugarcoating.
+
+## How you work
+1. Call the read tools to look up current data — never guess balances, dates, or transactions.
+2. Connect the dots. Don't just report numbers; tell ${name} what they mean for them, referencing whatever's in the "## About ${name}" block (employer, household, goals).
+3. For period comparisons, give both percentages and absolute differences.
+4. End with a next step when it helps. A good partner always has a suggestion.
+5. For questions about ${name} themselves (name, family, employer, household), answer from the "## About ${name}" block — it's authoritative. If a fact isn't there, say so plainly; don't redirect biographical questions to \`plasalid scan\`.
+6. Default currency is THB unless an account is explicitly in another. Don't mix currencies.
+
+## Output rules
+- Reply in the dominant language of ${name}'s message; default to English when mixed or ambiguous.
+- Markdown sparingly: **bold** for figures, simple bullets, no code blocks.
+- No emoji of any kind (no check marks, crosses, warning signs, colored circles, faces, hands, arrows-as-emoji). Use plain words.
+- No tables — no markdown \`|\` tables, no ASCII grids, no pipe-delimited rows. The TUI breaks them. Use prose, dashes, or numbered lists.
+- If the data needed to answer isn't in the database, say so plainly and suggest \`plasalid scan\` when relevant.`;
+}
+const SCAN_PERSONA = `You are Plasalid's scanner. You scan one financial document at a time (bank statement, credit-card statement, payslip, transfer slip) and post the contents to a local double-entry bookkeeping database.
+
+Rules:
+1. Infer the primary account type (asset, liability, income, expense) from the document itself — header text, account type field, transaction signs, statement layout. Do not rely on the filename or directory.
+2. Every transaction must become a balanced \`record_journal_entry\` call. Total debits must equal total credits.
+3. Account-type conventions:
+   - **Asset** (e.g. bank, cash): DEBIT increases, CREDIT decreases.
+   - **Liability** (e.g. credit card, loan): CREDIT increases what is owed, DEBIT decreases it (a payment).
+   - **Income**: CREDIT increases.
+   - **Expense**: DEBIT increases.
+4. Dates: convert Buddhist Era → Gregorian by subtracting 543 from the year. Store as YYYY-MM-DD.
+5. Default currency is THB. Tag every line with its ISO 4217 currency code on the \`record_journal_entry\` call; only deviate from THB when the row explicitly shows another currency (foreign-card purchases, FX transfers, multi-currency wallets).
+6. Account numbers: store only the last 4 digits (mask the rest with bullets, e.g. \`••1234\`). Never persist the full account number.
+7. If the document reveals an account that doesn't exist yet, call \`create_account\` once before posting entries to it. Reuse existing accounts; don't create duplicates — call \`list_accounts\` first.
+8. Persist account metadata when the document carries it: bank name, masked number, statement day, due day, points balance.
+9. If you are unsure about a row (ambiguous category, missing date, unclear sign), call \`ask_user\` instead of guessing.
+10. When the file is fully processed, call \`mark_file_scanned\` with a short summary.
+
+Common Thai statement patterns to expect:
+- Bank statements list incoming, outgoing with running balance.
+- Credit-card statements list a statement balance, minimum payment, due date, statement-cut date, and per-transaction rows.
+- Payslips list gross salary, tax, social-security, and net pay.
+- Transfer slips (PromptPay / mobile banking) show source account, destination account, amount, and a reference number.
+
+Pick a stable account id format: \`<type>:<bank>-<subtype>-<last4>\`, e.g. \`asset:kbank-savings-1234\`, \`liability:ktc-card-5678\`, \`expense:food\`, \`income:salary\`.
+
+How to phrase ask_user when you're unsure about a row:
+- Frame each question as a complete sentence with enough context: include the date, the amount (formatted as ฿N,NNN.NN), and the row's description.
+- Never reference accounts by their internal id (\`a:…\`). Use the human account name (e.g. "KBank Savings ••8745") in the question.
+- Always include "Skip — leave as is" as one of the options.
+
+Output formatting: use plain ASCII numbers (\`1.\`, \`2.\`, \`3.\`) for any lists. Never use Unicode circled digits (①②③). Never use emoji of any kind (no check marks, crosses, warning signs, colored circles, faces, hands, etc.) — use plain words.`;
+export function buildChatSystemPrompt(db) {
+    const memories = getMemories(db);
+    const context = readContext();
+    const name = config.userName;
+    const now = new Date();
+    const dateStr = now.toLocaleDateString("en-GB", {
+        weekday: "long",
+        month: "long",
+        day: "numeric",
+        year: "numeric",
+    });
+    let prompt = `${chatPersona(name)}\n\nToday is ${dateStr}.`;
+    prompt += `\n\n## About ${name}\n`;
+    prompt += context
+        ? context
+        : `(No personal context on file yet. ${name} can edit ~/.plasalid/context.md to add family, income, or other facts.)`;
+    const balances = getAccountBalances(db);
+    if (balances.length > 0) {
+        prompt += `\n\n## Accounts on file\n`;
+        prompt += balances
+            .map((a) => `- ${a.id} | ${a.name} | ${a.type}${a.subtype ? `/${a.subtype}` : ""} | balance ${a.balance.toFixed(2)} ${a.currency}`)
+            .join("\n");
+    }
+    else {
+        prompt += `\n\nNo accounts have been scanned yet. ${name} should drop files into ~/.plasalid/data/ and run \`plasalid scan\`.`;
+    }
+    if (memories.length > 0) {
+        prompt += `\n\n## Things to remember about ${name}\n`;
+        prompt += memories
+            .map((m) => `- [${m.category}] ${stripControls(m.content)}`)
+            .join("\n");
+    }
+    return prompt;
+}
+const RECONCILE_PERSONA = `You are Plasalid's reconciler. You revisit existing journal entries and accounts to fix data-quality issues: duplicate transactions, mis-categorized lines, inconsistent account naming, missing metadata, sign-convention slips.
+
+Hard rules:
+1. Survey first. Call list_accounts and get_net_worth, then use find_duplicate_entries, find_similar_accounts, and find_unused_accounts to gather candidate issues within the user's requested scope.
+2. For every write you propose, call ask_user with concrete options. Wait for the user's confirmation before applying.
+3. Conservative defaults: when uncertain, save_memory and skip. Never delete without explicit user confirmation. If dry-run is enabled, the write tools will return "Would ..." messages — relay those to the user without further action.
+4. Bookkeeping rules still apply. record_journal_entry must balance. For amount fixes, delete the broken entry and record a fresh replacement.
+5. Stop when there's nothing material left to fix. Call mark_reconcile_done with a short summary (counts of merges/deletes/edits applied).
+
+How to phrase ask_user:
+- Frame each question as a complete sentence with enough context for the user to decide quickly. Include the date, the amount (formatted as ฿N,NNN.NN), the description, and the affected account names.
+- Never reference entries or accounts by their internal id (\`je:…\`, \`a:…\`) in the question. Use the date + description + human account name instead.
+- Always include "Skip — leave as is" as one of the options so the user has an explicit do-nothing path.
+- Example:
+  Avoid: \`prompt: "Merge these?"\`
+  Prefer: \`prompt: "Two ฿350 lunch entries dated 2026-01-15 and 2026-01-17, both posted to KBank Savings ••8745 → Food. Merge into one?"\`, \`options: ["Yes — delete the 01-17 entry", "Yes — delete the 01-15 entry", "Skip — leave as is"]\`
+
+How to write the mark_reconcile_done summary:
+- Write a short user-facing report of what actually changed, in plain language. The user does not know what the internal detectors are.
+- Report counts and actions, never internal grouping. Examples:
+  - "Merged 3 duplicate transactions. Renamed 1 account. No other changes."
+  - "No duplicates found. Skipped 2 unused accounts on your instruction."
+- Never reference internal detector names (\`find_duplicate_entries\`, "Group 1", "Group 1-5", "candidate group N"). Those are tool internals.
+- Keep the summary to one to three sentences. Lead with what was applied; tail with what was skipped or deferred.
+
+Output formatting:
+- Use plain ASCII numbers (\`1.\`, \`2.\`, \`3.\`) for any lists or option numbering you generate. Never use Unicode circled digits (①②③).
+- Never use emoji of any kind (no check marks, crosses, warning signs, colored circles, faces, hands, etc.) — use plain words.
+- Always reply in English.
+- Be brief in prose; the user is reviewing in real time and wants to confirm fast.`;
+export function buildReconcileSystemPrompt(db, opts) {
+    const balances = getAccountBalances(db);
+    const memories = getMemories(db);
+    const today = new Date().toISOString().slice(0, 10);
+    let prompt = `${RECONCILE_PERSONA}\n\nToday is ${today}.\n\n## Current chart of accounts\n`;
+    prompt +=
+        balances.length === 0
+            ? "(empty)"
+            : balances
+                .map((a) => `- ${a.id} | ${a.name} | ${a.type}${a.subtype ? `/${a.subtype}` : ""} | balance ${a.balance.toFixed(2)} ${a.currency}`)
+                .join("\n");
+    prompt += `\n\n## Scope`;
+    prompt += `\n- account: ${opts.accountId ?? "all"}`;
+    prompt += `\n- from: ${opts.from ?? "all time"}`;
+    prompt += `\n- to: ${opts.to ?? "now"}`;
+    prompt += `\n- dry run: ${opts.dryRun ? "yes — write tools will not mutate the DB" : "no — write tools will mutate the DB after confirmation"}`;
+    if (memories.length > 0) {
+        prompt += `\n\n## Saved memories (apply where relevant)\n`;
+        prompt += memories
+            .map((m) => `- [${m.category}] ${stripControls(m.content)}`)
+            .join("\n");
+    }
+    return prompt;
+}
+export function buildScanSystemPrompt(db, opts) {
+    const balances = getAccountBalances(db);
+    const memories = getMemories(db);
+    const today = new Date().toISOString().slice(0, 10);
+    let prompt = `${SCAN_PERSONA}\n\nToday is ${today}.\n\n## Current chart of accounts\n`;
+    prompt +=
+        balances.length === 0
+            ? "(empty — you may need to create accounts)"
+            : balances
+                .map((a) => `- ${a.id} | ${a.name} | ${a.type}${a.subtype ? `/${a.subtype}` : ""}`)
+                .join("\n");
+    prompt += `\n\n## File context\nFile: ${opts.fileName}`;
+    prompt += `\n\n## Taxonomy hints\n${getThaiTaxonomyHint()}`;
+    if (memories.length > 0) {
+        prompt += `\n\n## Saved scanning hints (memories)\n`;
+        prompt += memories
+            .filter((m) => m.category === "scanning_hint" || m.category === "general")
+            .map((m) => `- ${stripControls(m.content)}`)
+            .join("\n");
+    }
+    return prompt;
+}

package/dist/ai/thai-taxonomy-hint.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Stringified **Thai** taxonomy block for the scan/reconcile system prompts.
+ * Listing known Thai institutions inline gives the model anchors for
+ * `bank_name` normalization. Subtype hints help the model pick a consistent
+ * `subtype`. Plasalid is currently Thailand-focused; if/when we expand to
+ * other locales this helper splits into per-locale variants.
+ */
+export declare function getThaiTaxonomyHint(): string;

package/dist/ai/thai-taxonomy-hint.js

@@ -0,0 +1,22 @@
+import { ALL_THAI_INSTITUTIONS, SUGGESTED_ASSET_SUBTYPES, SUGGESTED_LIABILITY_SUBTYPES, SUGGESTED_EXPENSE_SUBTYPES, SUGGESTED_INCOME_SUBTYPES, } from "../accounts/taxonomy.js";
+/**
+ * Stringified **Thai** taxonomy block for the scan/reconcile system prompts.
+ * Listing known Thai institutions inline gives the model anchors for
+ * `bank_name` normalization. Subtype hints help the model pick a consistent
+ * `subtype`. Plasalid is currently Thailand-focused; if/when we expand to
+ * other locales this helper splits into per-locale variants.
+ */
+export function getThaiTaxonomyHint() {
+    const institutions = ALL_THAI_INSTITUTIONS
+        .map(i => `${i.code} (${i.label}, ${i.kind})${i.notes ? ` — ${i.notes}` : ""}`)
+        .join("\n");
+    return [
+        `Known Thai institutions:`,
+        institutions,
+        ``,
+        `Suggested asset subtypes: ${SUGGESTED_ASSET_SUBTYPES.join(", ")}`,
+        `Suggested liability subtypes: ${SUGGESTED_LIABILITY_SUBTYPES.join(", ")}`,
+        `Suggested expense subtypes: ${SUGGESTED_EXPENSE_SUBTYPES.join(", ")}`,
+        `Suggested income subtypes: ${SUGGESTED_INCOME_SUBTYPES.join(", ")}`,
+    ].join("\n");
+}

package/dist/ai/thinking-phrases.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Idle/thinking phrases used by the chat hook and the scan spinner when the
+ * AI is composing a response (no specific tool to label). Kept in one place so
+ * both surfaces stay in sync.
+ */
+export declare const THINKING_PHRASES: string[];
+export declare function pickThinkingPhrase(): string;

package/dist/ai/thinking-phrases.js

@@ -0,0 +1,15 @@
+/**
+ * Idle/thinking phrases used by the chat hook and the scan spinner when the
+ * AI is composing a response (no specific tool to label). Kept in one place so
+ * both surfaces stay in sync.
+ */
+export const THINKING_PHRASES = [
+    "Thinking...",
+    "Looking through your journal...",
+    "Checking your accounts...",
+    "Crunching the numbers...",
+    "Pulling up your data...",
+];
+export function pickThinkingPhrase() {
+    return THINKING_PHRASES[Math.floor(Math.random() * THINKING_PHRASES.length)];
+}

package/dist/ai/thinking.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Idle/thinking phrases used by the chat hook and the scan spinner when the
+ * AI is composing a response (no specific tool to label). Kept in one place so
+ * both surfaces stay in sync.
+ */
+export declare const THINKING_PHRASES: string[];
+export declare function pickThinking(): string;

package/dist/ai/thinking.js

@@ -0,0 +1,15 @@
+/**
+ * Idle/thinking phrases used by the chat hook and the scan spinner when the
+ * AI is composing a response (no specific tool to label). Kept in one place so
+ * both surfaces stay in sync.
+ */
+export const THINKING_PHRASES = [
+    "Thinking...",
+    "Looking through your journal...",
+    "Checking your accounts...",
+    "Crunching the numbers...",
+    "Pulling up your data...",
+];
+export function pickThinking() {
+    return THINKING_PHRASES[Math.floor(Math.random() * THINKING_PHRASES.length)];
+}

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

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

package/dist/ai/tools/common.js

@@ -0,0 +1,83 @@
+import { saveMemory, getMemories } from "../memory.js";
+import { getAccountBalances } from "../../db/queries/account_balance.js";
+import { formatCurrencyAmount } from "../../currency.js";
+import { sanitizeForPrompt, sanitizeForPromptCell } from "../sanitize.js";
+import { ACCOUNT_TYPE_DESCRIPTIONS } from "../../accounts/taxonomy.js";
+const ACCOUNT_TYPES = Object.keys(ACCOUNT_TYPE_DESCRIPTIONS);
+function formatTHB(amount) {
+    return formatCurrencyAmount(amount, { minimumFractionDigits: 2, maximumFractionDigits: 2 });
+}
+const DEFS = [
+    {
+        name: "list_accounts",
+        description: "List accounts in the chart of accounts, optionally filtered by type.",
+        input_schema: {
+            type: "object",
+            properties: {
+                type: { type: "string", enum: ACCOUNT_TYPES, description: "Filter by account type." },
+            },
+            required: [],
+        },
+    },
+    {
+        name: "save_memory",
+        description: "Persist a fact or bank-specific scanning hint to long-term memory.",
+        input_schema: {
+            type: "object",
+            properties: {
+                content: { type: "string", description: "What to remember." },
+                category: { type: "string", description: "Category: general, scanning_hint, preference, life_event.", default: "general" },
+            },
+            required: ["content"],
+        },
+    },
+    {
+        name: "get_memories",
+        description: "Retrieve all saved long-term memories.",
+        input_schema: { type: "object", properties: {}, required: [] },
+    },
+];
+const LABELS = {
+    list_accounts: "Listing accounts",
+    save_memory: "Saving memory",
+    get_memories: "Recalling memories",
+};
+async function execute(db, name, input, _ctx) {
+    switch (name) {
+        case "list_accounts": {
+            const accounts = getAccountBalances(db, input?.type ? { type: input.type } : {});
+            if (accounts.length === 0)
+                return "No accounts in the chart of accounts yet.";
+            return accounts
+                .map(a => {
+                const meta = [];
+                if (a.bank_name)
+                    meta.push(sanitizeForPrompt(a.bank_name));
+                if (a.account_number_masked)
+                    meta.push(sanitizeForPrompt(a.account_number_masked));
+                if (a.due_day)
+                    meta.push(`due day ${a.due_day}`);
+                if (a.points_balance)
+                    meta.push(`${a.points_balance} pts`);
+                const metaStr = meta.length ? ` [${meta.join(" · ")}]` : "";
+                return `${a.id} | ${sanitizeForPromptCell(a.name)} | ${a.type}${a.subtype ? `/${a.subtype}` : ""} | balance ${formatTHB(a.balance)}${metaStr}`;
+            })
+                .join("\n");
+        }
+        case "save_memory": {
+            saveMemory(db, input.content, input.category || "general");
+            return `Saved memory: "${sanitizeForPrompt(input.content)}"`;
+        }
+        case "get_memories": {
+            const memories = getMemories(db);
+            if (memories.length === 0)
+                return "No memories saved yet.";
+            return memories
+                .map(m => `[${m.category}] ${sanitizeForPrompt(m.content)} (saved ${m.created_at})`)
+                .join("\n");
+        }
+        default:
+            return undefined;
+    }
+}
+export const commonTools = { DEFS, LABELS, execute };

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

@@ -0,0 +1,8 @@
+import type Database from "libsql";
+import type { ToolDefinition } from "../provider.js";
+import type { AgentExecutionContext, ToolProfile } from "./types.js";
+export type { AgentExecutionContext, ToolProfile } from "./types.js";
+export declare function getToolDefinitions(profile: ToolProfile): ToolDefinition[];
+export declare function executeTool(db: Database.Database, name: string, input: any, ctx?: AgentExecutionContext): Promise<string>;
+/** Human-readable labels shown in the spinner during tool calls. */
+export declare const TOOL_LABELS: Record<string, string>;

package/dist/ai/tools/index.js

@@ -0,0 +1,34 @@
+import { commonTools } from "./common.js";
+import { readTools } from "./read.js";
+import { ingestTools } from "./ingest.js";
+import { scanTools } from "./scan.js";
+import { reconcileTools } from "./reconcile.js";
+/**
+ * Profile composition. Each profile is the union of one or more tool modules;
+ * the dispatcher iterates every module on each tool call so we never need a
+ * central switch.
+ */
+const PROFILES = {
+    scan: [commonTools, ingestTools, scanTools],
+    chat: [commonTools, readTools],
+    reconcile: [commonTools, readTools, ingestTools, reconcileTools],
+};
+export function getToolDefinitions(profile) {
+    return PROFILES[profile].flatMap(m => m.DEFS);
+}
+export async function executeTool(db, name, input, ctx) {
+    for (const mod of [commonTools, readTools, ingestTools, scanTools, reconcileTools]) {
+        const result = await mod.execute(db, name, input, ctx);
+        if (result !== undefined)
+            return result;
+    }
+    return `Unknown tool: ${name}`;
+}
+/** Human-readable labels shown in the spinner during tool calls. */
+export const TOOL_LABELS = {
+    ...commonTools.LABELS,
+    ...readTools.LABELS,
+    ...ingestTools.LABELS,
+    ...scanTools.LABELS,
+    ...reconcileTools.LABELS,
+};

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

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