plasalid 0.7.1 → 0.7.2

package/dist/ai/tools/merchants.js

@@ -1,5 +1,4 @@
 import { upsertMerchant, findMerchantByAlias, findMerchantById, setMerchantDefaultAccount, } from "../../db/queries/merchants.js";
-import { appendAction } from "../../db/queries/action-log.js";
 import { sanitizeForPrompt } from "../sanitize.js";
 /**
  * Merchant tools
@@ -65,30 +64,14 @@ const LABELS = {
     find_merchant_by_descriptor: "Looking up merchant",
     set_merchant_default_account: "Updating merchant default",
 };
-async function execute(db, name, input, ctx) {
+async function execute(db, name, input, _ctx) {
     switch (name) {
         case "find_or_create_merchant": {
-            const existing = db
-                .prepare(`SELECT id FROM merchants WHERE canonical_name = ?`)
-                .get(input.canonical_name);
             const merchant = upsertMerchant(db, {
                 canonical_name: input.canonical_name,
                 alias: input.alias,
                 default_account_id: input.default_account_id,
             });
-            if (ctx?.correlationId && !existing) {
-                appendAction(db, {
-                    correlation_id: ctx.correlationId,
-                    command: ctx.command ?? "record",
-                    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,
-                    },
-                });
-            }
             const defaultStr = merchant.default_account_id
                 ? ` (default → ${merchant.default_account_id})`
                 : "";
@@ -109,16 +92,6 @@ async function execute(db, name, input, ctx) {
                 return `Merchant ${input.merchant_id} not found.`;
             try {
                 const result = setMerchantDefaultAccount(db, input.merchant_id, input.account_id);
-                if (ctx?.correlationId) {
-                    appendAction(db, {
-                        correlation_id: ctx.correlationId,
-                        command: ctx.command ?? "record",
-                        user_input: ctx.userInput ?? null,
-                        action_type: "update_merchant_default",
-                        target_id: input.merchant_id,
-                        payload: { before: result.before, after: result.after },
-                    });
-                }
                 return `Merchant ${input.merchant_id}: default ${result.before ?? "(none)"} → ${result.after}.`;
             }
             catch (err) {

package/dist/ai/tools/read.js

@@ -1,6 +1,6 @@
 import { findAccountById, getAccountBalances, getNetWorth, getPeriodTotals, } from "../../db/queries/account-balance.js";
 import { listPostings } from "../../db/queries/transactions.js";
-import { listOpenUnknowns } from "../../db/queries/unknowns.js";
+import { listQuestions } from "../../db/queries/questions.js";
 import { searchPostings } from "../../db/queries/search.js";
 import { formatAmount } from "../../currency.js";
 import { sanitizeForPrompt, sanitizeForPromptCell } from "../sanitize.js";
@@ -62,15 +62,15 @@ const DEFS = [
         },
     },
     {
-        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.",
+        name: "list_questions",
+        description: "List clarification questions 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 unknown kind (e.g. 'uncategorized_expense').",
+                    description: "Optional filter by question kind (e.g. 'uncategorized_expense').",
                 },
             },
             required: [],
@@ -83,7 +83,7 @@ const LABELS = {
     list_postings: "Listing postings",
     search_transactions: "Searching transactions",
     get_period_totals: "Summing period totals",
-    list_open_unknowns: "Listing open unknowns",
+    list_questions: "Listing questions",
 };
 async function execute(db, name, input, _ctx) {
     switch (name) {
@@ -139,13 +139,13 @@ 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_unknowns": {
-            const rows = listOpenUnknowns(db, input.limit ?? 50);
+        case "list_questions": {
+            const rows = listQuestions(db, input.limit ?? 50);
             const filtered = input.kind
                 ? rows.filter((r) => r.kind === input.kind)
                 : rows;
             if (filtered.length === 0)
-                return "No open unknowns. The picture is clear.";
+                return "No questions. The picture is clear.";
             return filtered
                 .map((r) => {
                 const targets = [

package/dist/ai/tools/record.js

@@ -1,6 +1,5 @@
 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 { formatAmount } from "../../currency.js";
 import { sanitizeForPrompt } from "../sanitize.js";
 const EQUITY_ADJUST_ID = "equity:adjustments";
@@ -11,9 +10,7 @@ function todayIso() {
  * Record-only tool definitions
  *
  * `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.
+ * `rename_account`, and `delete_account` mutate the DB.
  */
 const DEFS = [
     {
@@ -81,7 +78,7 @@ const DEFS = [
     },
     {
         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 resolve's ask_user, this does NOT write to the unknowns 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 questions table — record-time questions are transient.",
         input_schema: {
             type: "object",
             properties: {
@@ -200,40 +197,10 @@ async function adjustAccountBalance(db, input, ctx) {
     }
     try {
         const tx = db.transaction(() => {
-            const equityExisted = !!findAccountById(db, EQUITY_ADJUST_ID);
-            if (!equityExisted) {
+            if (!findAccountById(db, EQUITY_ADJUST_ID)) {
                 ensureStructuralAccount(db, "equity:adjustments");
-                if (ctx.correlationId) {
-                    appendAction(db, {
-                        correlation_id: ctx.correlationId,
-                        command: ctx.command ?? "record",
-                        user_input: ctx.userInput ?? null,
-                        action_type: "create_account",
-                        target_id: EQUITY_ADJUST_ID,
-                        payload: { row: findAccountById(db, EQUITY_ADJUST_ID) },
-                    });
-                }
             }
             insertTransactionRows(db, validated);
-            if (ctx.correlationId) {
-                appendAction(db, {
-                    correlation_id: ctx.correlationId,
-                    command: ctx.command ?? "record",
-                    user_input: ctx.userInput ?? null,
-                    action_type: "adjust_balance",
-                    target_id: validated.id,
-                    payload: {
-                        account_id: account.id,
-                        before_balance: current,
-                        after_balance: target,
-                        transaction: {
-                            date: validated.date,
-                            description: validated.description,
-                        },
-                        postings: validated.postings,
-                    },
-                });
-            }
         });
         tx();
     }

package/dist/ai/tools/resolve.js

@@ -2,13 +2,6 @@ import { deleteTransaction, updateTransaction, updatePosting, } from "../../db/q
 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",
@@ -48,7 +41,7 @@ const DEFS = [
     },
     {
         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.",
+        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 question.",
         input_schema: {
             type: "object",
             properties: {
@@ -96,7 +89,7 @@ const DEFS = [
     },
     {
         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.",
+        description: "Move every posting on `from_id` over to `to_id`, then delete the source account. Use to apply a similar_accounts question'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" } },
@@ -112,7 +105,7 @@ const LABELS = {
     link_transaction_to_recurrence: "Linking transaction to recurrence",
     merge_accounts: "Merging accounts",
 };
-async function execute(db, name, input) {
+async function execute(db, name, input, _ctx) {
     switch (name) {
         case "update_transaction": {
             const changed = updateTransaction(db, input.transaction_id, {
@@ -140,20 +133,30 @@ async function execute(db, name, input) {
                 : `Deleted transaction ${input.transaction_id} and its postings.`;
         }
         case "record_recurrence": {
-            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).`;
+            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": {
-            linkTransactionToRecurrence(db, input.transaction_id, input.recurrence_id);
-            return `Linked transaction ${input.transaction_id} → recurrence ${input.recurrence_id}.`;
+            try {
+                linkTransactionToRecurrence(db, input.transaction_id, input.recurrence_id);
+                return `Linked transaction ${input.transaction_id} → recurrence ${input.recurrence_id}.`;
+            }
+            catch (err) {
+                return `Could not link: ${err.message}`;
+            }
         }
         case "merge_accounts": {
             const moved = mergeAccounts(db, input.from_id, input.to_id);

package/dist/ai/tools/scan.js

@@ -19,7 +19,6 @@ async function execute(_db, name, input, ctx) {
     if (name !== "mark_file_scanned")
         return undefined;
     const summary = input.summary || "";
-    ctx?.buffer?.markDone(summary);
     ctx?.onComplete?.(summary);
     return `Marked file as scanned. Summary: ${sanitizeForPrompt(summary)}`;
 }

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

@@ -1,9 +1,10 @@
 import type Database from "libsql";
 import type { ToolDefinition } from "../provider.js";
-import type { BufferedWriteContext } from "../../scanner/buffer.js";
-export type ToolProfile = "scan" | "chat" | "resolve" | "record";
+import type { ScanProgress } from "../../scanner/progress.js";
+import type { ClosedQuestion } from "../../db/queries/questions.js";
+export type ToolProfile = "scan" | "chat" | "record" | "resolve";
 /**
- * Structured highlights the resolve agent can pass to ask_user. The prompter
+ * Structured highlights an interactive 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.
@@ -15,30 +16,22 @@ export interface PromptUserFacts {
     accounts?: string[];
 }
 export interface AgentExecutionContext {
-    /** Set during scan so `record_transaction` can stamp `source_file_id`. */
+    /** Set during scan so writes can be stamped with `source_file_id`. */
     fileId?: string;
     /** When false, ask_user returns a marker and the caller halts after the run. */
     interactive: 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 resolve). */
+    /** Called when the model declares the session is done (scan or record). */
     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" | "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 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.
-     */
-    buffer?: BufferedWriteContext;
+    /** Scan-only: tag questions inserted during this scan run. */
+    scanId?: string;
+    /** Scan-only: per-chunk progress sink for dashboard ticks. */
+    progress?: ScanProgress;
+    /** Scan-only: the chunk this agent invocation is processing. */
+    chunkId?: string;
+    /** Resolve-only: notified for each closed question so the caller can synthesize memory rules. */
+    onQuestionClosed?: (closed: ClosedQuestion) => void;
 }
 /**
  * A tool module owns a slice of tool definitions, the spinner labels that go

package/dist/cli/commands/record.js

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

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

@@ -1,2 +1,5 @@
-import { type ResolveOptions } from "../../resolver/pipeline.js";
-export declare function runResolveCommand(opts: ResolveOptions): Promise<void>;
+/**
+ * Zero-arg resolver. Hands every question to the resolver (deterministic
+ * passes first, then the LLM agent) and prints a colored summary on completion.
+ */
+export declare function runResolveCommand(): Promise<void>;

package/dist/cli/commands/resolve.js

@@ -1,13 +1,44 @@
 import chalk from "chalk";
-import { runResolve } from "../../resolver/pipeline.js";
-export async function runResolveCommand(opts) {
+import { getDb } from "../../db/connection.js";
+import { runResolve } from "../../scanner/resolver.js";
+import { makePromptUser, makeAgentOnProgress, statusSpinner } from "../ux.js";
+/**
+ * Zero-arg resolver. Hands every question to the resolver (deterministic
+ * passes first, then the LLM agent) and prints a colored summary on completion.
+ */
+export async function runResolveCommand() {
+    const db = getDb();
+    const spinner = statusSpinner("Resolving...");
+    const promptUser = makePromptUser(spinner);
+    const onProgress = makeAgentOnProgress(spinner);
     try {
-        const summary = await runResolve(opts);
+        const summary = await runResolve({
+            db,
+            interactive: !!process.stdout.isTTY,
+            promptUser,
+            onProgress,
+        });
+        spinner.succeed("Resolve done.");
         console.log("");
-        console.log(chalk.bold(summary));
+        console.log(formatSummary(summary));
     }
     catch (err) {
-        console.error(chalk.red(`Resolve failed: ${err.message}`));
+        spinner.fail(err instanceof Error ? err.message : "Resolve failed.");
         process.exitCode = 1;
     }
 }
+function formatSummary(summary) {
+    if (summary.total === 0) {
+        return chalk.dim("No questions.");
+    }
+    const tally = Object.entries(summary.tally)
+        .map(([k, v]) => `${k}×${v}`)
+        .join(", ");
+    const lines = [
+        chalk.bold(`Resolved ${summary.resolved}/${summary.total} questions${tally ? ` (${tally})` : ""}.`),
+    ];
+    if (summary.remaining > 0) {
+        lines.push(chalk.yellow(`${summary.remaining} question(s) remain.`));
+    }
+    return lines.join("\n");
+}

package/dist/cli/commands/revert.js

@@ -3,7 +3,9 @@ import inquirer from "inquirer";
 import { relative, sep } from "path";
 import { getDb } from "../../db/connection.js";
 import { getDataDir } from "../../config.js";
-import { compileMatcher } from "../../scanner/pipeline.js";
+function compileMatcher(input) {
+    return new RegExp(input, "i");
+}
 function pathToRelPath(absolutePath) {
     return relative(getDataDir(), absolutePath).split(sep).join("/");
 }
@@ -43,7 +45,7 @@ export async function runRevertCommand(regex) {
         matches = findRevertMatches(getDb(), regex);
     }
     catch (err) {
-        console.error(chalk.red(`Invalid regex: ${err.message}`));
+        console.error(chalk.red(`Invalid regex: ${err instanceof Error ? err.message : String(err)}`));
         process.exitCode = 1;
         return;
     }

package/dist/cli/commands/rules.js

@@ -29,7 +29,7 @@ export function renderRules(db) {
     const rules = collectRules(db);
     if (rules.length === 0) {
         return ("No rules yet.\n\n" +
-            chalk.dim("Rules accumulate as you resolve unknowns. Run `plasalid resolve` after a scan."));
+            chalk.dim("Rules accumulate as you resolve questions. Run `plasalid resolve` after a scan."));
     }
     const width = Math.max(...rules.map((r) => r.displayId.length));
     const lines = [chalk.bold(`Rules (${rules.length}):`)];
@@ -46,7 +46,7 @@ export function forgetRules(db, pattern) {
         re = new RegExp(`^${pattern}$`);
     }
     catch (err) {
-        return { ok: false, error: `Invalid regex /${pattern}/: ${err.message}` };
+        return { ok: false, error: `Invalid regex /${pattern}/: ${err instanceof Error ? err.message : String(err)}` };
     }
     const snapshot = collectRules(db);
     const hits = snapshot.filter((r) => re.test(r.displayId));