plasalid 0.7.1 → 0.7.2

package/dist/cli/ink/ScanDashboard.js

@@ -0,0 +1,214 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Box, Text, useStdout } from "ink";
+import Spinner from "ink-spinner";
+export function createScanDashboardController() {
+    const subscribers = new Set();
+    return {
+        publish(event) {
+            for (const sub of subscribers)
+                sub(event);
+        },
+        subscribe(handler) {
+            subscribers.add(handler);
+            return () => {
+                subscribers.delete(handler);
+            };
+        },
+    };
+}
+/** First matching rule wins. The final rule should be a catch-all. */
+function classify(input, rules) {
+    for (const r of rules)
+        if (r.when(input))
+            return r.state;
+    throw new Error("classify: no rule matched (missing catch-all?)");
+}
+const COL = {
+    status: 14,
+    files: 34,
+    transactions: 13,
+    questions: 10,
+};
+/**
+ * Tree-layout scan dashboard. Header carries the only animated element (one
+ * `<Spinner>`). All other status indicators are static glyphs that only
+ * redraw when their data changes.
+ */
+export function ScanDashboard(props) {
+    const rows = useFileGroups(props.controller, props.files);
+    const phase = usePhase(props.controller);
+    const ruleWidth = useRuleWidth();
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Header, { phase: phase }), _jsx(Box, { marginTop: 1, children: _jsx(ColumnHeader, {}) }), _jsx(Divider, { width: ruleWidth }), Array.from(rows.entries()).map(([fileId, group]) => (_jsx(FileGroupView, { group: group }, fileId))), _jsx(Divider, { width: ruleWidth })] }));
+}
+function usePhase(controller) {
+    const [phase, setPhase] = useState("parse");
+    useEffect(() => controller.subscribe(event => {
+        if (event.type === "phase-set")
+            setPhase(event.phase);
+    }), [controller]);
+    return phase;
+}
+function useRuleWidth() {
+    const { stdout } = useStdout();
+    const [cols, setCols] = useState(() => stdout?.columns ?? 100);
+    useEffect(() => {
+        if (!stdout)
+            return;
+        const onResize = () => setCols(stdout.columns ?? 100);
+        stdout.on("resize", onResize);
+        return () => { stdout.off("resize", onResize); };
+    }, [stdout]);
+    return Math.min(cols, 120);
+}
+const PHASE_RENDER = {
+    pending: (label) => _jsx(Text, { dimColor: true, children: label }),
+    running: (label) => _jsxs(Text, { color: "yellow", children: [_jsx(Spinner, { type: "dots" }), " ", label] }),
+    done: (label) => _jsxs(Text, { color: "green", children: ["\u2713 ", label] }),
+};
+const PHASE_ORDER = ["parse", "resolve", "done"];
+function phaseStateOf(label, current) {
+    const li = PHASE_ORDER.indexOf(label);
+    const ci = PHASE_ORDER.indexOf(current);
+    if (ci > li)
+        return "done";
+    if (ci === li)
+        return "running";
+    return "pending";
+}
+function Header({ phase }) {
+    return (_jsxs(Text, { children: [_jsx(Text, { bold: true, children: "Scanner" }), _jsx(Text, { dimColor: true, children: "  ·  " }), _jsx(Text, { color: "green", children: "\u2713 decrypt" }), _jsx(Text, { dimColor: true, children: " -> " }), _jsx(Text, { color: "green", children: "\u2713 chunk" }), _jsx(Text, { dimColor: true, children: " -> " }), PHASE_RENDER[phaseStateOf("parse", phase)]("parse"), _jsx(Text, { dimColor: true, children: " -> " }), PHASE_RENDER[phaseStateOf("resolve", phase)]("resolve")] }));
+}
+function ColumnHeader() {
+    return (_jsxs(Box, { flexDirection: "row", children: [_jsx(Box, { width: COL.status, children: _jsx(Text, { dimColor: true, children: "status" }) }), _jsx(Box, { width: COL.files, children: _jsx(Text, { dimColor: true, children: "files" }) }), _jsx(Box, { width: COL.transactions, children: _jsx(Text, { dimColor: true, children: "transactions" }) }), _jsx(Box, { width: COL.questions, children: _jsx(Text, { dimColor: true, children: "questions" }) })] }));
+}
+function Divider({ width }) {
+    return _jsx(Text, { dimColor: true, children: "─".repeat(width) });
+}
+const spin = (label) => () => (_jsxs(Text, { color: "yellow", children: [_jsx(Spinner, { type: "dots" }), " ", label] }));
+const STATUS_RENDER = {
+    queued: () => _jsx(Text, { color: "gray", children: "queued" }),
+    running: spin("running"),
+    scanning: spin("scanning"),
+    done: () => _jsx(Text, { color: "green", children: "\u2713 done" }),
+    failed: () => _jsx(Text, { color: "red", children: "failed" }),
+    partial: () => _jsx(Text, { color: "yellow", children: "partial" }),
+};
+const FILE_STATUS_RULES = [
+    { when: ({ finished, total }) => finished < total, state: "scanning" },
+    { when: ({ failed }) => failed === 0, state: "done" },
+    { when: ({ failed, total }) => failed === total, state: "failed" },
+    { when: () => true, state: "partial" },
+];
+function aggregate(chunks, total) {
+    let done = 0, failed = 0, totalTx = 0, totalQuestions = 0;
+    for (const c of chunks) {
+        if (c.status === "done")
+            done++;
+        else if (c.status === "failed")
+            failed++;
+        totalTx += c.txCount;
+        totalQuestions += c.questionsCount;
+    }
+    const status = classify({ finished: done + failed, failed, total }, FILE_STATUS_RULES);
+    return { totalTx, totalQuestions, status };
+}
+function FileGroupView({ group }) {
+    const chunks = Array.from(group.chunks.values()).sort((a, b) => a.pageNumber - b.pageNumber);
+    const agg = aggregate(chunks, group.totalChunks);
+    const fileName = `> ${truncateMiddle(group.fileName, COL.files - 2)}`;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Row, { status: _jsx(StatusText, { status: agg.status }), files: _jsx(Text, { dimColor: true, children: fileName }), transactions: agg.totalTx, questions: agg.totalQuestions }), chunks.map((c, i) => (_jsx(ChunkRow, { chunk: c, last: i === chunks.length - 1 }, c.pageNumber)))] }));
+}
+function ChunkRow({ chunk, last }) {
+    const connector = last ? "`-" : "|-";
+    return (_jsx(Row, { status: _jsx(StatusText, { status: chunk.status }), files: _jsx(Text, { dimColor: true, children: `  ${connector} part ${chunk.pageNumber}` }), transactions: chunk.txCount, questions: chunk.questionsCount }));
+}
+function StatusText({ status }) {
+    return STATUS_RENDER[status]();
+}
+function Row({ status, files, transactions, questions, }) {
+    return (_jsxs(Box, { flexDirection: "row", children: [_jsx(Box, { width: COL.status, children: status }), _jsx(Box, { width: COL.files, children: files }), _jsx(Box, { width: COL.transactions, children: _jsx(Numeric, { n: transactions }) }), _jsx(Box, { width: COL.questions, children: _jsx(Numeric, { n: questions }) })] }));
+}
+const NUMERIC_RULES = [
+    { when: (n) => n > 0, state: "present" },
+    { when: () => true, state: "empty" },
+];
+const NUMERIC_RENDER = {
+    present: (n) => _jsx(Text, { children: n }),
+    empty: () => (_jsx(Text, { color: "gray", dimColor: true, children: "-" })),
+};
+function Numeric({ n }) {
+    return NUMERIC_RENDER[classify(n, NUMERIC_RULES)](n);
+}
+function truncateMiddle(s, width) {
+    if (s.length <= width)
+        return s;
+    const keep = width - 1;
+    const left = Math.ceil(keep / 2);
+    const right = Math.floor(keep / 2);
+    return s.slice(0, left) + "..." + s.slice(s.length - right);
+}
+function useFileGroups(controller, files) {
+    const [rows, setRows] = useState(() => seedRows(files));
+    useEffect(() => {
+        return controller.subscribe((event) => {
+            setRows((prev) => {
+                const changed = applyDashboardEvent(prev, event);
+                return changed ? new Map(prev) : prev;
+            });
+        });
+    }, [controller]);
+    return rows;
+}
+function seedRows(files) {
+    const seed = new Map();
+    for (const f of files) {
+        const chunks = new Map();
+        for (let p = 1; p <= f.totalPages; p++) {
+            chunks.set(p, {
+                pageNumber: p,
+                status: "queued",
+                txCount: 0,
+                questionsCount: 0,
+            });
+        }
+        seed.set(f.fileId, {
+            fileName: f.fileName,
+            totalChunks: f.totalPages,
+            chunks,
+        });
+    }
+    return seed;
+}
+const REDUCERS = {
+    "chunk-start": (_event, chunk) => {
+        if (chunk.status !== "queued")
+            return false;
+        chunk.status = "running";
+        return true;
+    },
+    "chunk-tx": (_event, chunk) => {
+        chunk.txCount++;
+        return true;
+    },
+    "chunk-question": (_event, chunk) => {
+        chunk.questionsCount++;
+        return true;
+    },
+    "chunk-end": (event, chunk) => {
+        if (TERMINAL_STATUSES.includes(chunk.status))
+            return false;
+        chunk.status = event.ok ? "done" : "failed";
+        return true;
+    },
+};
+const TERMINAL_STATUSES = ["done", "failed"];
+function applyDashboardEvent(rows, event) {
+    if (event.type === "phase-set")
+        return false;
+    const chunk = rows.get(event.fileId)?.chunks.get(event.pageNumber);
+    if (!chunk)
+        return false;
+    const reducer = REDUCERS[event.type];
+    return reducer(event, chunk);
+}

package/dist/cli/ink/scan_dashboard.d.ts

@@ -1,38 +1,53 @@
-export type ScanDashboardEvent = {
-    type: "scan-start";
+import type { AuditEngine } from "../../scanner/auditor.js";
+import type { Bus } from "../../scanner/bus.js";
+/**
+ * Events the CLI publishes into the dashboard to drive chunk-row updates.
+ * Audit pulse + chunk tx counters are derived from bus events the dashboard
+ * subscribes to directly (no double-routing through the controller).
+ */
+export type DashboardEvent = {
+    type: "chunk-start";
+    fileId: string;
     fileName: string;
+    pageNumber: number;
+    totalPages: number;
 } | {
-    type: "scan-progress";
-    fileName: string;
-    step: string;
+    type: "chunk-progress";
+    fileId: string;
+    pageNumber: number;
+    phase: "tool" | "responding";
+    toolName?: string;
 } | {
-    type: "scan-end";
-    fileName: string;
-    status: "scanned" | "failed";
-    transactions: number;
-    unknowns: number;
-    error?: string;
+    type: "chunk-tx";
+    fileId: string;
+    pageNumber: number;
+} | {
+    type: "chunk-unknown";
+    fileId: string;
+    pageNumber: number;
+} | {
+    type: "chunk-end";
+    fileId: string;
+    pageNumber: number;
+    ok: boolean;
 };
-/**
- * Subscribe / publish channel between the pipeline (which knows nothing about
- * UI) and the dashboard (which knows nothing about the pipeline). The CLI
- * creates one of these, fans events into it, and hands it to the component.
- */
-export declare class ScanDashboardController {
-    private subscribers;
-    publish(event: ScanDashboardEvent): void;
-    subscribe(handler: (e: ScanDashboardEvent) => void): () => void;
+export interface ScanDashboardController {
+    publish(event: DashboardEvent): void;
+    subscribe(handler: (e: DashboardEvent) => void): () => void;
 }
+export declare function createScanDashboardController(): ScanDashboardController;
 interface Props {
     controller: ScanDashboardController;
+    bus: Bus;
+    audit: AuditEngine;
+    scanId: string;
     totalFiles: number;
     parallel: number;
 }
 /**
- * Multi-row live dashboard for the scan phase. Rows appear when a file starts
- * scanning, update as steps flow, and freeze when the agent loop ends. Counts
- * shown are the in-buffer counts at scan-end; correlation may add unknowns
- * later, which the terse summary reflects.
+ * Multi-component dashboard: breadcrumb header, audit pulse, file-group panel
+ * with per-chunk activity rows, key-bindings footer. Mounted by the CLI on
+ * `beforeParse`, unmounted on `afterParse`.
  */
-export declare function ScanDashboard({ controller, totalFiles, parallel }: Props): import("react/jsx-runtime").JSX.Element;
+export declare function ScanDashboard(props: Props): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/cli/ink/scan_dashboard.js

@@ -1,62 +1,157 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useState } from "react";
 import { Box, Text } from "ink";
 import Spinner from "ink-spinner";
-/**
- * Subscribe / publish channel between the pipeline (which knows nothing about
- * UI) and the dashboard (which knows nothing about the pipeline). The CLI
- * creates one of these, fans events into it, and hands it to the component.
- */
-export class ScanDashboardController {
-    subscribers = [];
-    publish(event) {
-        for (const sub of this.subscribers)
-            sub(event);
-    }
-    subscribe(handler) {
-        this.subscribers.push(handler);
-        return () => {
-            this.subscribers = this.subscribers.filter(s => s !== handler);
-        };
-    }
+export function createScanDashboardController() {
+    let subscribers = [];
+    return {
+        publish(event) { for (const sub of subscribers)
+            sub(event); },
+        subscribe(handler) {
+            subscribers.push(handler);
+            return () => { subscribers = subscribers.filter(s => s !== handler); };
+        },
+    };
 }
 /**
- * Multi-row live dashboard for the scan phase. Rows appear when a file starts
- * scanning, update as steps flow, and freeze when the agent loop ends. Counts
- * shown are the in-buffer counts at scan-end; correlation may add unknowns
- * later, which the terse summary reflects.
+ * Multi-component dashboard: breadcrumb header, audit pulse, file-group panel
+ * with per-chunk activity rows, key-bindings footer. Mounted by the CLI on
+ * `beforeParse`, unmounted on `afterParse`.
  */
-export function ScanDashboard({ controller, totalFiles, parallel }) {
+export function ScanDashboard(props) {
+    const rows = useFileGroups(props.controller);
+    const audit = useAuditSnapshot(props.bus, props.audit);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Header, { scanId: props.scanId, totalFiles: props.totalFiles, parallel: props.parallel }), _jsx(AuditPulse, { audit: audit }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: Array.from(rows.entries()).map(([fileId, group]) => (_jsx(FileGroupView, { group: group }, fileId))) }), _jsx(Footer, {})] }));
+}
+function Header({ scanId, totalFiles, parallel }) {
+    const shortId = scanId.replace(/^sc:/, "").slice(0, 8);
+    return (_jsxs(Text, { children: [_jsx(Text, { bold: true, children: "Plasalid Scan" }), _jsxs(Text, { dimColor: true, children: ["  \u00B7  sc:", shortId, "  \u00B7  ", totalFiles, " file(s)  \u00B7  ", parallel, "\u00D7", parallel, " parallel  \u00B7  "] }), _jsx(Text, { color: "green", children: "\u2713 decrypt" }), _jsx(Text, { dimColor: true, children: " \u2192 " }), _jsx(Text, { color: "green", children: "\u2713 chunk" }), _jsx(Text, { dimColor: true, children: " \u2192 " }), _jsxs(Text, { color: "yellow", children: [_jsx(Spinner, { type: "dots" }), " parse"] }), _jsx(Text, { dimColor: true, children: " \u2192 \u00B7 review \u2192 \u00B7 commit" })] }));
+}
+function AuditPulse({ audit }) {
+    const tallyEntries = Object.entries(audit.tally);
+    const tallyStr = tallyEntries.length === 0 ? "" : tallyEntries.map(([k, v]) => `${k}×${v}`).join("  ");
+    const idle = audit.pending === 0;
+    return (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "Auditor:  " }), idle
+                ? _jsx(Text, { color: "green", children: "\u2713 idle" })
+                : _jsxs(Text, { color: "yellow", children: [_jsx(Spinner, { type: "dots" }), " ", audit.pending, " queued"] }), _jsxs(Text, { dimColor: true, children: ["  \u00B7  ", audit.processed, " events processed"] }), tallyStr.length > 0 && _jsxs(Text, { dimColor: true, children: ["  \u00B7  ", tallyStr] })] }));
+}
+function FileGroupView({ group }) {
+    const chunks = Array.from(group.chunks.values()).sort((a, b) => a.pageNumber - b.pageNumber);
+    const done = chunks.filter(c => c.status === "done").length;
+    const failed = chunks.filter(c => c.status === "failed").length;
+    const totalTx = chunks.reduce((s, c) => s + c.txCount, 0);
+    const totalUnknowns = chunks.reduce((s, c) => s + c.unknownsCount, 0);
+    const finished = done + failed;
+    const overall = finished === group.totalChunks
+        ? (failed === 0 ? "done" : failed === group.totalChunks ? "failed" : "partial")
+        : "scanning";
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: [_jsx(FileMarker, { status: overall }), " ", _jsx(Text, { bold: true, children: group.fileName }), _jsxs(Text, { dimColor: true, children: ["  ", finished, " / ", group.totalChunks, " chunks \u00B7 ", totalTx, " transactions", totalUnknowns > 0 ? `, ${totalUnknowns} unknowns` : ""] })] }), chunks.map(c => _jsx(ChunkRow, { chunk: c }, c.pageNumber))] }));
+}
+function FileMarker({ status }) {
+    if (status === "scanning")
+        return _jsx(Text, { color: "yellow", children: _jsx(Spinner, { type: "dots" }) });
+    if (status === "done")
+        return _jsx(Text, { color: "green", children: "\u2713" });
+    if (status === "failed")
+        return _jsx(Text, { color: "red", children: "\u2717" });
+    return _jsx(Text, { color: "yellow", children: "\u26A0" });
+}
+function ChunkRow({ chunk }) {
+    return (_jsxs(Text, { children: ["      ", _jsx(StatusGlyph, { status: chunk.status }), _jsxs(Text, { dimColor: true, children: ["  p", chunk.pageNumber.toString().padEnd(3), "  "] }), _jsx(Text, { dimColor: true, children: chunk.activity })] }));
+}
+function StatusGlyph({ status }) {
+    if (status === "running")
+        return _jsx(Text, { color: "yellow", children: _jsx(Spinner, { type: "dots" }) });
+    if (status === "done")
+        return _jsx(Text, { color: "green", children: "\u2713" });
+    if (status === "failed")
+        return _jsx(Text, { color: "red", children: "\u2717" });
+    return _jsx(Text, { dimColor: true, children: "\u00B7" });
+}
+function Footer() {
+    return (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "\u2191\u2193 scroll \u00B7 q quit \u00B7 ? help" }) }));
+}
+/* ------------------------------------------------------------------------ */
+/* Hooks                                                                    */
+/* ------------------------------------------------------------------------ */
+function useFileGroups(controller) {
     const [rows, setRows] = useState(() => new Map());
     useEffect(() => {
         return controller.subscribe(event => {
             setRows(prev => {
                 const next = new Map(prev);
-                switch (event.type) {
-                    case "scan-start":
-                        next.set(event.fileName, { kind: "scanning", step: "starting..." });
-                        break;
-                    case "scan-progress":
-                        next.set(event.fileName, { kind: "scanning", step: event.step });
-                        break;
-                    case "scan-end":
-                        next.set(event.fileName, event.status === "scanned"
-                            ? { kind: "done", transactions: event.transactions, unknowns: event.unknowns }
-                            : { kind: "failed", error: event.error ?? "failed" });
-                        break;
-                }
+                applyDashboardEvent(next, event);
                 return next;
             });
         });
     }, [controller]);
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: ["Scanning ", totalFiles, " file(s) (", parallel, " in parallel)"] }), Array.from(rows.entries()).map(([name, state]) => (_jsx(FileRow, { name: name, state: state }, name)))] }));
+    return rows;
 }
-function FileRow({ name, state }) {
-    if (state.kind === "scanning") {
-        return (_jsxs(Text, { children: ["  ", _jsx(Text, { color: "yellow", children: _jsx(Spinner, { type: "dots" }) }), " ", name, " ", _jsxs(Text, { dimColor: true, children: ["\u00B7 ", state.step] })] }));
-    }
-    if (state.kind === "done") {
-        return (_jsxs(Text, { children: ["  ", _jsx(Text, { color: "green", children: "\u2713" }), " ", name, " ", _jsxs(Text, { dimColor: true, children: ["(", state.transactions, " transactions, ", state.unknowns, " unknowns)"] })] }));
+function applyDashboardEvent(rows, event) {
+    switch (event.type) {
+        case "chunk-start": {
+            let group = rows.get(event.fileId);
+            if (!group) {
+                const chunks = new Map();
+                for (let p = 1; p <= event.totalPages; p++) {
+                    chunks.set(p, { pageNumber: p, status: "queued", activity: "queued", txCount: 0, unknownsCount: 0 });
+                }
+                group = { fileName: event.fileName, totalChunks: event.totalPages, chunks };
+                rows.set(event.fileId, group);
+            }
+            const chunk = group.chunks.get(event.pageNumber);
+            if (chunk) {
+                chunk.status = "running";
+                chunk.activity = "starting…";
+            }
+            break;
+        }
+        case "chunk-progress": {
+            const chunk = rows.get(event.fileId)?.chunks.get(event.pageNumber);
+            if (chunk && chunk.status === "running") {
+                chunk.activity = event.toolName ?? (event.phase === "responding" ? "thinking" : chunk.activity);
+            }
+            break;
+        }
+        case "chunk-tx": {
+            const chunk = rows.get(event.fileId)?.chunks.get(event.pageNumber);
+            if (chunk)
+                chunk.txCount++;
+            break;
+        }
+        case "chunk-unknown": {
+            const chunk = rows.get(event.fileId)?.chunks.get(event.pageNumber);
+            if (chunk)
+                chunk.unknownsCount++;
+            break;
+        }
+        case "chunk-end": {
+            const chunk = rows.get(event.fileId)?.chunks.get(event.pageNumber);
+            if (chunk) {
+                chunk.status = event.ok ? "done" : "failed";
+                chunk.activity = event.ok
+                    ? `posted ${chunk.txCount} transactions${chunk.unknownsCount > 0 ? `, ${chunk.unknownsCount} unknowns` : ""}`
+                    : "failed";
+            }
+            break;
+        }
     }
-    return (_jsxs(Text, { children: ["  ", _jsx(Text, { color: "red", children: "\u2717" }), " ", name, " ", _jsxs(Text, { dimColor: true, children: ["\u2014 ", state.error] })] }));
+}
+function useAuditSnapshot(bus, audit) {
+    const [snap, setSnap] = useState(() => ({
+        pending: audit.stats.pending,
+        processed: audit.stats.processed,
+        tally: { ...audit.tally },
+    }));
+    useEffect(() => {
+        // Re-read on every bus event. Cheap; the pulse is just three numbers.
+        return bus.subscribe(() => {
+            setSnap({
+                pending: audit.stats.pending,
+                processed: audit.stats.processed,
+                tally: { ...audit.tally },
+            });
+        });
+    }, [bus, audit]);
+    return snap;
 }

package/dist/db/queries/account-balance.d.ts

@@ -15,7 +15,7 @@ export interface AccountRow {
     points_balance: number | null;
     metadata_json: string | null;
     pii_flag: number;
-    has_unknown: number;
+    has_question: number;
     created_at: string;
 }
 export interface AccountBalance extends AccountRow {

package/dist/db/queries/questions.d.ts

@@ -0,0 +1,62 @@
+import type Database from "libsql";
+export interface QuestionTarget {
+    transaction_id: string | null;
+    account_id: string | null;
+}
+export interface RecordQuestionInput extends QuestionTarget {
+    file_id: string | null;
+    scan_id?: string | null;
+    kind?: string | null;
+    prompt: string;
+    options?: string[];
+    /** Kind-specific structured context (e.g. partner ids for similar_accounts). */
+    context?: Record<string, unknown> | null;
+}
+export interface QuestionRow {
+    id: string;
+    scan_id: string | null;
+    file_id: string | null;
+    transaction_id: string | null;
+    account_id: string | null;
+    kind: string | null;
+    prompt: string;
+    options_json: string | null;
+    context_json: string | null;
+    created_at: string;
+}
+export interface ClosedQuestion {
+    prompt: string;
+    kind: string | null;
+    answer: string;
+}
+/**
+ * Insert a new questions row and flip the `has_question` 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 declare function recordQuestion(db: Database.Database, input: RecordQuestionInput): string;
+/**
+ * Close a question by capturing its (prompt, kind, answer) tuple and
+ * deleting the row outright. Returns the captured tuple so callers can
+ * synthesize memory rules; returns null when the id doesn't exist.
+ */
+export declare function closeQuestion(db: Database.Database, id: string, answer: string): ClosedQuestion | null;
+/**
+ * Look up the transaction/account a question is attached to. Returns null when
+ * the question id doesn't exist.
+ */
+export declare function getQuestionTarget(db: Database.Database, id: string): QuestionTarget | null;
+export interface CountQuestionsScope {
+    file_id?: string;
+    transaction_id?: string;
+    account_id?: string;
+    kind?: string;
+    scan_id?: string;
+}
+export declare function countQuestions(db: Database.Database, scope?: CountQuestionsScope): number;
+export interface ListQuestionsOptions {
+    limit?: number;
+    scanId?: string;
+}
+export declare function listQuestions(db: Database.Database, opts?: ListQuestionsOptions): QuestionRow[];