plasalid 0.5.8 → 0.6.0

package/dist/db/queries/unknowns.js

@@ -0,0 +1,114 @@
+import { randomUUID } from "crypto";
+/**
+ * Insert a new unknowns row and flip the `has_unknown` boolean on whichever
+ * target (transaction / account) was named. Returns the new id. The id keeps
+ * the historical `cn:` prefix — it's opaque and nothing else references it,
+ * so the prefix is a no-op detail.
+ */
+export function recordUnknown(db, input) {
+    const id = `cn:${randomUUID()}`;
+    db.prepare(`INSERT INTO unknowns (id, file_id, transaction_id, account_id, kind, prompt, options_json) VALUES (?, ?, ?, ?, ?, ?, ?)`).run(id, input.file_id, input.transaction_id, input.account_id, input.kind ?? null, input.prompt, input.options ? JSON.stringify(input.options) : null);
+    if (input.transaction_id) {
+        db.prepare(`UPDATE transactions SET has_unknown = 1 WHERE id = ?`).run(input.transaction_id);
+    }
+    if (input.account_id) {
+        db.prepare(`UPDATE accounts SET has_unknown = 1 WHERE id = ?`).run(input.account_id);
+    }
+    return id;
+}
+/**
+ * Mark an existing unknown as resolved with the user's answer and, if no other
+ * open unknowns reference the same target, clear the target's `has_unknown`
+ * flag. Returns the unknown's target so callers can log or react.
+ */
+export function resolveUnknown(db, id, answer) {
+    const target = getUnknownTarget(db, id);
+    if (!target)
+        return null;
+    db.prepare(`UPDATE unknowns SET answer = ?, resolved_at = datetime('now') WHERE id = ?`).run(answer, id);
+    maybeClearHasUnknownFlags(db, target);
+    return target;
+}
+/**
+ * Look up the transaction/account an unknown is attached to. Returns null when
+ * the unknown id doesn't exist.
+ */
+export function getUnknownTarget(db, id) {
+    const row = db
+        .prepare(`SELECT transaction_id, account_id FROM unknowns WHERE id = ?`)
+        .get(id);
+    return row ?? null;
+}
+/**
+ * Clear `has_unknown` on the named transaction / account if no other open
+ * unknowns still reference it. Safe to call after any resolution; idempotent.
+ */
+export function maybeClearHasUnknownFlags(db, target) {
+    if (target.transaction_id) {
+        const open = db
+            .prepare(`SELECT 1 FROM unknowns WHERE transaction_id = ? AND resolved_at IS NULL LIMIT 1`)
+            .get(target.transaction_id);
+        if (!open)
+            db.prepare(`UPDATE transactions SET has_unknown = 0 WHERE id = ?`).run(target.transaction_id);
+    }
+    if (target.account_id) {
+        const open = db
+            .prepare(`SELECT 1 FROM unknowns WHERE account_id = ? AND resolved_at IS NULL LIMIT 1`)
+            .get(target.account_id);
+        if (!open)
+            db.prepare(`UPDATE accounts SET has_unknown = 0 WHERE id = ?`).run(target.account_id);
+    }
+}
+export function countOpenUnknowns(db, scope = {}) {
+    const conditions = ["resolved_at IS NULL"];
+    const params = [];
+    if (scope.file_id) {
+        conditions.push("file_id = ?");
+        params.push(scope.file_id);
+    }
+    if (scope.transaction_id) {
+        conditions.push("transaction_id = ?");
+        params.push(scope.transaction_id);
+    }
+    if (scope.account_id) {
+        conditions.push("account_id = ?");
+        params.push(scope.account_id);
+    }
+    if (scope.kind) {
+        conditions.push("kind = ?");
+        params.push(scope.kind);
+    }
+    const row = db
+        .prepare(`SELECT COUNT(*) AS n FROM unknowns WHERE ${conditions.join(" AND ")}`)
+        .get(...params);
+    return row.n;
+}
+export function listOpenUnknowns(db, limit = 50) {
+    const capped = Math.min(Math.max(limit, 1), 200);
+    return db.prepare(`SELECT id, file_id, transaction_id, account_id, kind, prompt, options_json, created_at
+     FROM unknowns
+     WHERE resolved_at IS NULL
+     ORDER BY created_at ASC
+     LIMIT ?`).all(capped);
+}
+/**
+ * Open unknowns filtered by `kind`, ordered by the position of the kind in the
+ * input array (priority) then by created_at. Pass `["uncategorized","duplicate"]`
+ * to drain uncategorized rows before duplicates.
+ *
+ * `kind` is free-text TEXT in the schema; canonical values used by built-ins:
+ *   uncategorized, duplicate, correlation, recurrence_candidate,
+ *   similar_accounts, file_password
+ */
+export function listOpenUnknownsByKind(db, kinds, limit = 50) {
+    if (kinds.length === 0)
+        return [];
+    const capped = Math.min(Math.max(limit, 1), 200);
+    const placeholders = kinds.map(() => "?").join(",");
+    const cases = kinds.map((_, i) => `WHEN ? THEN ${i}`).join(" ");
+    return db.prepare(`SELECT id, file_id, transaction_id, account_id, kind, prompt, options_json, created_at
+     FROM unknowns
+     WHERE resolved_at IS NULL AND kind IN (${placeholders})
+     ORDER BY CASE kind ${cases} ELSE ${kinds.length} END, created_at ASC
+     LIMIT ?`).all(...kinds, ...kinds, capped);
+}

package/dist/db/schema.js

@@ -14,7 +14,7 @@ export function migrate(db) {
       points_balance REAL,
       metadata_json TEXT,
       pii_flag INTEGER NOT NULL DEFAULT 0,
-      has_concern INTEGER NOT NULL DEFAULT 0,
+      has_unknown INTEGER NOT NULL DEFAULT 0,
       created_at TEXT NOT NULL DEFAULT (datetime('now'))
     );
 
@@ -74,7 +74,7 @@ export function migrate(db) {
       source_file_id TEXT REFERENCES scanned_files(id) ON DELETE CASCADE,
       source_page INTEGER,
       recurrence_id TEXT REFERENCES recurrences(id) ON DELETE SET NULL,
-      has_concern INTEGER NOT NULL DEFAULT 0,
+      has_unknown INTEGER NOT NULL DEFAULT 0,
       created_at TEXT NOT NULL DEFAULT (datetime('now'))
     );
 
@@ -98,7 +98,7 @@ export function migrate(db) {
     CREATE INDEX IF NOT EXISTS postings_transaction_idx ON postings(transaction_id);
     CREATE INDEX IF NOT EXISTS postings_account_idx ON postings(account_id);
 
-    CREATE TABLE IF NOT EXISTS concerns (
+    CREATE TABLE IF NOT EXISTS unknowns (
       id TEXT PRIMARY KEY,
       file_id TEXT REFERENCES scanned_files(id) ON DELETE CASCADE,
       transaction_id TEXT REFERENCES transactions(id) ON DELETE CASCADE,

package/dist/resolver/pipeline.d.ts

@@ -0,0 +1,16 @@
+export interface ResolveOptions {
+    accountId?: string;
+    from?: string;
+    to?: string;
+    kind?: string;
+    interactive?: boolean;
+    /** Hard cap on unknowns handed to the agent in one run. Default 200. */
+    limit?: number;
+}
+/**
+ * Hand every open unknown to the resolve agent in a single invocation. The
+ * agent surveys, applies memory-driven and heuristic resolutions silently,
+ * groups what remains, asks the user once per group, and reports back via
+ * mark_resolve_done. The pipeline just sets up plumbing and prints the report.
+ */
+export declare function runResolve(opts?: ResolveOptions): Promise<string>;

package/dist/resolver/pipeline.js

@@ -0,0 +1,38 @@
+import { getDb } from "../db/connection.js";
+import { runResolveAgent } from "../ai/agent.js";
+import { listOpenUnknowns, listOpenUnknownsByKind } from "../db/queries/unknowns.js";
+import { statusSpinner, makePromptUser, makeAgentOnProgress, } from "../cli/ux.js";
+import { buildResolveUserMessage } from "./prompts.js";
+/**
+ * Hand every open unknown to the resolve agent in a single invocation. The
+ * agent surveys, applies memory-driven and heuristic resolutions silently,
+ * groups what remains, asks the user once per group, and reports back via
+ * mark_resolve_done. The pipeline just sets up plumbing and prints the report.
+ */
+export async function runResolve(opts = {}) {
+    const db = getDb();
+    const unknowns = opts.kind
+        ? listOpenUnknownsByKind(db, [opts.kind], opts.limit ?? 200)
+        : listOpenUnknowns(db, opts.limit ?? 200);
+    if (unknowns.length === 0)
+        return "No open unknowns.";
+    const interactive = opts.interactive ?? true;
+    const spinner = statusSpinner(`Resolving ${unknowns.length} unknown(s)...`);
+    const promptUser = interactive ? makePromptUser(spinner) : undefined;
+    let summary = "";
+    try {
+        await runResolveAgent({
+            db,
+            prompt: { accountId: opts.accountId, from: opts.from, to: opts.to },
+            initialMessages: [{ role: "user", content: buildResolveUserMessage(unknowns) }],
+            agentCtx: { interactive, promptUser, onComplete: (s) => { summary = s; } },
+            onProgress: makeAgentOnProgress(spinner),
+        });
+        spinner.succeed("Resolve done.");
+    }
+    catch (err) {
+        spinner.fail(`Resolve failed: ${err.message}`);
+        throw err;
+    }
+    return summary;
+}

package/dist/resolver/prompts.d.ts

@@ -0,0 +1,8 @@
+import type { OpenUnknownRow } from "../db/queries/unknowns.js";
+/**
+ * Kickoff message handed to the resolve agent. Data only — one line per
+ * unknown, with all the fields the persona's six-step workflow needs (id,
+ * kind, transaction/account/file ids, prompt, options). Instructions live in
+ * RESOLVE_PERSONA; the system prompt already carries memory rules.
+ */
+export declare function buildResolveUserMessage(unknowns: OpenUnknownRow[]): string;

package/dist/resolver/prompts.js

@@ -0,0 +1,26 @@
+/**
+ * Kickoff message handed to the resolve agent. Data only — one line per
+ * unknown, with all the fields the persona's six-step workflow needs (id,
+ * kind, transaction/account/file ids, prompt, options). Instructions live in
+ * RESOLVE_PERSONA; the system prompt already carries memory rules.
+ */
+export function buildResolveUserMessage(unknowns) {
+    const lines = [`${unknowns.length} open unknown(s) to resolve.`, ``, `Unknowns:`];
+    for (const c of unknowns) {
+        const options = parseOptions(c.options_json);
+        const optionsStr = options.length > 0 ? ` | options=[${options.join(" / ")}]` : "";
+        lines.push(`- ${c.id} | kind=${c.kind ?? "(none)"} | tx=${c.transaction_id ?? "(none)"} | acct=${c.account_id ?? "(none)"} | file=${c.file_id ?? "(none)"}${optionsStr}`, `    prompt: ${c.prompt.replace(/\n/g, " ")}`);
+    }
+    return lines.join("\n");
+}
+function parseOptions(json) {
+    if (!json)
+        return [];
+    try {
+        const parsed = JSON.parse(json);
+        return Array.isArray(parsed) ? parsed.filter((o) => typeof o === "string") : [];
+    }
+    catch {
+        return [];
+    }
+}

package/dist/scanner/account-mutex.d.ts

@@ -0,0 +1 @@
+export declare function runExclusive<T>(fn: () => Promise<T> | T): Promise<T>;

package/dist/scanner/account-mutex.js

@@ -0,0 +1,16 @@
+/**
+ * Process-wide serialization for write operations that race when multiple scan
+ * agents run in parallel. Each in-flight `create_account` / `update_account_metadata`
+ * is held inside `runExclusive` so the SQLite write + the subsequent read-back
+ * by another agent's `list_accounts` are consistent.
+ *
+ * Single tail-promise queue: cheap, deterministic, no extra deps.
+ */
+let tail = Promise.resolve();
+export function runExclusive(fn) {
+    const next = tail.then(() => fn());
+    // Swallow rejection so a thrown callback doesn't poison the queue for the
+    // next caller. The caller still sees the rejection through `next`.
+    tail = next.catch(() => undefined);
+    return next;
+}

package/dist/scanner/buffer.d.ts

@@ -1,7 +1,7 @@
 import type Database from "libsql";
 import { type TransactionInput } from "../db/queries/transactions.js";
 /**
- * One scan agent's pending writes. Transactions and concerns accumulate here
+ * One scan agent's pending writes. Transactions and unknowns accumulate here
  * while the LLM works; nothing hits the DB until `commit()` runs inside a
  * single SQLite transaction. If `commit()` throws, the transaction rolls back
  * and the DB stays exactly as it was before this file's scan began.
@@ -11,8 +11,8 @@ import { type TransactionInput } from "../db/queries/transactions.js";
  * their own mutexes so concurrent agents see each other's creates and don't
  * duplicate.
  */
-export interface BufferedConcern {
-    /** Synthesized when the LLM called note_concern with a buffered transaction_id. */
+export interface BufferedUnknown {
+    /** Synthesized when the LLM called note_unknown with a buffered transaction_id. */
     transaction_id: string | null;
     account_id: string | null;
     kind?: string | null;
@@ -20,32 +20,32 @@ export interface BufferedConcern {
     options?: string[];
 }
 export interface BufferedTransaction {
-    /** Synthesized at queue-time so concerns can reference this transaction. */
+    /** Synthesized at queue-time so unknowns can reference this transaction. */
     transaction_id: string;
     input: TransactionInput;
 }
 export declare class BufferedWriteContext {
     readonly fileName: string;
     readonly transactions: BufferedTransaction[];
-    readonly concerns: BufferedConcern[];
+    readonly unknowns: BufferedUnknown[];
     doneSummary: string | null;
     constructor(fileName: string);
     /**
      * Queue a transaction. Returns the synthesized transaction id so the agent
-     * can use it in subsequent note_concern calls inside the same file.
+     * can use it in subsequent note_unknown calls inside the same file.
      */
     appendTransaction(input: TransactionInput): string;
-    appendConcern(concern: BufferedConcern): void;
+    appendUnknown(unknown: BufferedUnknown): void;
     markDone(summary: string): void;
     get isDone(): boolean;
     /**
      * Replay all buffered writes inside one DB transaction. `scannedFileId` is
-     * stamped onto every transaction and concern so they're attributable to this
-     * file. Returns `{ transactions, concerns }` counts so the caller can report
+     * stamped onto every transaction and unknown so they're attributable to this
+     * file. Returns `{ transactions, unknowns }` counts so the caller can report
      * them.
      */
     commit(db: Database.Database, scannedFileId: string): {
         transactions: number;
-        concerns: number;
+        unknowns: number;
     };
 }

package/dist/scanner/buffer.js

@@ -1,25 +1,25 @@
 import { randomUUID } from "crypto";
 import { insertTransactionRows, validateTransaction, } from "../db/queries/transactions.js";
-import { recordConcern } from "../db/queries/concerns.js";
+import { recordUnknown } from "../db/queries/unknowns.js";
 export class BufferedWriteContext {
     fileName;
     transactions = [];
-    concerns = [];
+    unknowns = [];
     doneSummary = null;
     constructor(fileName) {
         this.fileName = fileName;
     }
     /**
      * Queue a transaction. Returns the synthesized transaction id so the agent
-     * can use it in subsequent note_concern calls inside the same file.
+     * can use it in subsequent note_unknown calls inside the same file.
      */
     appendTransaction(input) {
         const transactionId = `tx:${randomUUID()}`;
         this.transactions.push({ transaction_id: transactionId, input });
         return transactionId;
     }
-    appendConcern(concern) {
-        this.concerns.push(concern);
+    appendUnknown(unknown) {
+        this.unknowns.push(unknown);
     }
     markDone(summary) {
         this.doneSummary = summary;
@@ -29,8 +29,8 @@ export class BufferedWriteContext {
     }
     /**
      * Replay all buffered writes inside one DB transaction. `scannedFileId` is
-     * stamped onto every transaction and concern so they're attributable to this
-     * file. Returns `{ transactions, concerns }` counts so the caller can report
+     * stamped onto every transaction and unknown so they're attributable to this
+     * file. Returns `{ transactions, unknowns }` counts so the caller can report
      * them.
      */
     commit(db, scannedFileId) {
@@ -46,18 +46,18 @@ export class BufferedWriteContext {
             for (const { validated: v } of validated) {
                 insertTransactionRows(db, v);
             }
-            for (const c of this.concerns) {
-                recordConcern(db, {
+            for (const u of this.unknowns) {
+                recordUnknown(db, {
                     file_id: scannedFileId,
-                    transaction_id: c.transaction_id,
-                    account_id: c.account_id,
-                    kind: c.kind ?? null,
-                    prompt: c.prompt,
-                    options: c.options,
+                    transaction_id: u.transaction_id,
+                    account_id: u.account_id,
+                    kind: u.kind ?? null,
+                    prompt: u.prompt,
+                    options: u.options,
                 });
             }
         });
         tx();
-        return { transactions: this.transactions.length, concerns: this.concerns.length };
+        return { transactions: this.transactions.length, unknowns: this.unknowns.length };
     }
 }

package/dist/scanner/decrypt-queue.d.ts

@@ -0,0 +1,57 @@
+import type Database from "libsql";
+import type { ScannedFile } from "./walker.js";
+export interface DecryptedFile {
+    path: string;
+    fileName: string;
+    relPath: string;
+    hash: string;
+    mime: string;
+    decryptedBytes: Buffer;
+    /** True if a prior scan covered this hash; only present when --force is set. */
+    replacesPriorScannedFileId?: string;
+}
+export interface SkippedFile {
+    file: ScannedFile;
+    /** id of the scanned_files row that already has this hash. */
+    existingScannedFileId: string;
+}
+export interface FailedFile {
+    file: ScannedFile;
+    error: string;
+}
+export interface DecryptQueueResult {
+    decrypted: DecryptedFile[];
+    skipped: SkippedFile[];
+    failed: FailedFile[];
+}
+export interface DecryptQueueOptions {
+    /** Re-decrypt and queue files that match a prior hash. */
+    force: boolean;
+    /** If false, never prompt for a password; treat unlock failure as failed. */
+    interactive: boolean;
+    /** Called as each file finishes (any outcome) so a spinner can update its label. */
+    onProgress?: (event: {
+        index: number;
+        total: number;
+        fileName: string;
+        outcome: "decrypted" | "skipped" | "failed";
+    }) => void;
+}
+/**
+ * Phase 1 of scan: walk every file in the queue, decrypt any that need it,
+ * and return a partition (decrypted / skipped / failed). The actual agent
+ * work in Phase 2 only sees `decrypted` — no password prompts during the
+ * parallel scan loop.
+ *
+ * Failures don't abort; the caller (CLI) confirms whether to proceed.
+ */
+export declare function decryptQueue(db: Database.Database, files: ScannedFile[], opts: DecryptQueueOptions): Promise<DecryptQueueResult>;
+/**
+ * Interactive go/no-go gate when some files failed to decrypt. Returns true
+ * if the caller should proceed with the decrypted set, false to abort the
+ * whole scan run.
+ *
+ * Returns true automatically when interactive is false (CI / non-TTY runs);
+ * the caller is expected to inspect `result.failed` and report.
+ */
+export declare function confirmProceedAfterFailures(result: DecryptQueueResult, interactive: boolean): Promise<boolean>;

package/dist/scanner/decrypt-queue.js

@@ -0,0 +1,114 @@
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { readPdf } from "./pdf.js";
+import { unlockIfNeeded, persistUnlockOutcome } from "./unlock.js";
+async function decryptOne(db, file, opts) {
+    let pdf;
+    try {
+        pdf = readPdf(file.path);
+    }
+    catch (err) {
+        return { kind: "failed", error: `read failed: ${errorMessage(err)}` };
+    }
+    const existing = findScannedByHash(db, pdf.hash);
+    if (existing && !opts.force) {
+        return { kind: "skipped", existingScannedFileId: existing.id };
+    }
+    try {
+        const unlocked = await unlockIfNeeded({
+            db,
+            filePath: file.path,
+            bytes: pdf.bytes,
+            interactive: opts.interactive,
+        });
+        persistUnlockOutcome(db, file.path, unlocked.outcome);
+        return {
+            kind: "decrypted",
+            file: {
+                path: file.path,
+                fileName: file.name,
+                relPath: file.relPath,
+                hash: pdf.hash,
+                mime: pdf.mime,
+                decryptedBytes: unlocked.decrypted,
+                replacesPriorScannedFileId: existing?.id,
+            },
+        };
+    }
+    catch (err) {
+        return { kind: "failed", error: errorMessage(err) || "unlock failed" };
+    }
+}
+function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+/**
+ * Phase 1 of scan: walk every file in the queue, decrypt any that need it,
+ * and return a partition (decrypted / skipped / failed). The actual agent
+ * work in Phase 2 only sees `decrypted` — no password prompts during the
+ * parallel scan loop.
+ *
+ * Failures don't abort; the caller (CLI) confirms whether to proceed.
+ */
+export async function decryptQueue(db, files, opts) {
+    const decrypted = [];
+    const skipped = [];
+    const failed = [];
+    for (let i = 0; i < files.length; i++) {
+        const file = files[i];
+        const outcome = await decryptOne(db, file, opts);
+        const progress = (kind) => opts.onProgress?.({ index: i, total: files.length, fileName: file.name, outcome: kind });
+        switch (outcome.kind) {
+            case "decrypted":
+                decrypted.push(outcome.file);
+                progress("decrypted");
+                break;
+            case "skipped":
+                skipped.push({ file, existingScannedFileId: outcome.existingScannedFileId });
+                progress("skipped");
+                break;
+            case "failed":
+                failed.push({ file, error: outcome.error });
+                progress("failed");
+                break;
+        }
+    }
+    return { decrypted, skipped, failed };
+}
+/**
+ * Interactive go/no-go gate when some files failed to decrypt. Returns true
+ * if the caller should proceed with the decrypted set, false to abort the
+ * whole scan run.
+ *
+ * Returns true automatically when interactive is false (CI / non-TTY runs);
+ * the caller is expected to inspect `result.failed` and report.
+ */
+export async function confirmProceedAfterFailures(result, interactive) {
+    if (result.failed.length === 0)
+        return true;
+    console.log("");
+    console.log(chalk.yellow(`${result.failed.length} file(s) could not be decrypted:`));
+    for (const f of result.failed) {
+        console.log(`  ${chalk.red("✗")} ${f.file.relPath} — ${chalk.dim(f.error)}`);
+    }
+    if (result.decrypted.length === 0) {
+        console.log(chalk.red("Nothing to scan."));
+        return false;
+    }
+    if (!interactive)
+        return true;
+    const { proceed } = (await inquirer.prompt([
+        {
+            type: "confirm",
+            name: "proceed",
+            message: `Proceed scanning the ${result.decrypted.length} file(s) that decrypted successfully?`,
+            default: true,
+        },
+    ]));
+    return proceed;
+}
+function findScannedByHash(db, hash) {
+    return db
+        .prepare(`SELECT id FROM scanned_files WHERE file_hash = ?`)
+        .get(hash) ?? null;
+}

package/dist/scanner/detectors/correlations.d.ts

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

package/dist/scanner/detectors/correlations.js

@@ -0,0 +1,51 @@
+import { findCorrelatedTransactions } from "../../db/queries/transactions.js";
+import { formatAmount } from "../../currency.js";
+/**
+ * Cross-account correlation: a single money movement that landed on two
+ * different accounts (e.g. transfer from bank to card recorded once per
+ * statement). One concern per pair, attached to the newer side. Only pairs
+ * with at least one side in `fileIds` are surfaced.
+ *
+ * Replaces the pre-commit `applyCrossFileCorrelations` that used to run on
+ * buffered (uncommitted) transactions; running post-commit lets us reuse the
+ * DB-backed `findCorrelatedTransactions` and avoid the buffer-shape adapter.
+ */
+function detect(db, scope) {
+    if (scope.fileIds.length === 0)
+        return [];
+    const pairs = findCorrelatedTransactions(db);
+    if (pairs.length === 0)
+        return [];
+    const inScope = transactionsInScope(db, scope.fileIds);
+    const out = [];
+    for (const pair of pairs) {
+        if (!inScope.has(pair.a.id) && !inScope.has(pair.b.id))
+            continue;
+        const [older, newer] = pair.a.date <= pair.b.date ? [pair.a, pair.b] : [pair.b, pair.a];
+        out.push({
+            file_id: null,
+            transaction_id: newer.id,
+            account_id: null,
+            kind: "correlation",
+            prompt: buildPrompt(pair, older, newer),
+            options: ["Merge into one transaction", "Keep separate (these are two real events)", "Skip"],
+        });
+    }
+    return out;
+}
+function buildPrompt(pair, older, newer) {
+    const amount = formatAmount(pair.amount, pair.currency);
+    return [
+        `Possible cross-account correlation (${amount}, ${pair.day_gap} day(s) apart).`,
+        `  ${newer.date} — ${newer.description} — ${newer.account_names.join(", ")}`,
+        `  ${older.date} — ${older.description} — ${older.account_names.join(", ")}`,
+    ].join("\n");
+}
+function transactionsInScope(db, fileIds) {
+    const placeholders = fileIds.map(() => "?").join(",");
+    const rows = db
+        .prepare(`SELECT id FROM transactions WHERE source_file_id IN (${placeholders})`)
+        .all(...fileIds);
+    return new Set(rows.map(r => r.id));
+}
+export const correlationsDetector = { name: "correlations", detect };

package/dist/scanner/detectors/duplicates.d.ts

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