plasalid 0.8.3 → 0.9.0

package/dist/cli/helper.d.ts

@@ -3,9 +3,17 @@
  * in the middle. Returns `s` unchanged when already short enough.
  */
 export declare function truncateMiddle(s: string, max: number): string;
+/**
+ * Count visible terminal cells. Each code point counts as 1, except Unicode
+ * combining marks (\p{M}) which stack on the preceding base char and count
+ * as 0. Does not handle East-Asian wide characters; revisit if CJK filenames
+ * appear in real ledgers.
+ */
+export declare function displayWidth(s: string): number;
 /**
  * Right-pad to a fixed visible width. Assumes `s` has no ANSI codes — callers
  * working with colored strings should compose color around the padded value,
- * not inside it.
+ * not inside it. Pads by display width so Thai (and other scripts with
+ * combining marks) stay aligned with surrounding columns.
  */
 export declare function padRight(s: string, width: number): string;

package/dist/cli/helper.js

@@ -14,11 +14,26 @@ export function truncateMiddle(s, max) {
     const tail = Math.floor(keep / 2);
     return `${s.slice(0, head)}…${s.slice(s.length - tail)}`;
 }
+/**
+ * Count visible terminal cells. Each code point counts as 1, except Unicode
+ * combining marks (\p{M}) which stack on the preceding base char and count
+ * as 0. Does not handle East-Asian wide characters; revisit if CJK filenames
+ * appear in real ledgers.
+ */
+export function displayWidth(s) {
+    let w = 0;
+    for (const c of s)
+        if (!/^\p{M}$/u.test(c))
+            w++;
+    return w;
+}
 /**
  * Right-pad to a fixed visible width. Assumes `s` has no ANSI codes — callers
  * working with colored strings should compose color around the padded value,
- * not inside it.
+ * not inside it. Pads by display width so Thai (and other scripts with
+ * combining marks) stay aligned with surrounding columns.
  */
 export function padRight(s, width) {
-    return s.length >= width ? s : s + " ".repeat(width - s.length);
+    const visual = displayWidth(s);
+    return visual >= width ? s : s + " ".repeat(width - visual);
 }

package/dist/cli/index.js

@@ -119,6 +119,14 @@ program
     const { runScanCommand } = await import("./commands/scan.js");
     await runScanCommand({ regex: regexes[0], force: !!opts.force, parallel });
 });
+program
+    .command("files")
+    .description("Browse scanned files; press d to drop one and cascade-remove its data")
+    .action(async () => {
+    ensureConfigured();
+    const { showFiles } = await import("./commands/files.js");
+    await showFiles();
+});
 program
     .command("rules")
     .description("Browse the rules the system has learned (press d to delete)")
@@ -163,6 +171,10 @@ program.configureHelp({
             name: "scan",
             desc: "Scan new PDFs (optionally by regex; --force to re-scan)",
         },
+        {
+            name: "files",
+            desc: "Browse scanned files; press d to drop one and cascade-remove its data",
+        },
         {
             name: "rules",
             desc: "Browse the rules the system has learned (press d to delete)",

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

@@ -0,0 +1,7 @@
+import type Database from "libsql";
+import { type ScannedFileRow } from "../../db/queries/files.js";
+export interface FilesBrowserProps {
+    files: ScannedFileRow[];
+    db: Database.Database;
+}
+export declare function FilesBrowser({ files: initialFiles, db }: FilesBrowserProps): import("react/jsx-runtime").JSX.Element;

package/dist/cli/ink/FilesBrowser.js

@@ -0,0 +1,103 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo, useState } from "react";
+import { Text } from "ink";
+import chalk from "chalk";
+import { padRight, truncateMiddle } from "../helper.js";
+import { ListBrowser } from "./ListBrowser.js";
+import { keyOf } from "./keys.js";
+import { getDataDir } from "../../config.js";
+import { deleteScannedFile, } from "../../db/queries/files.js";
+import { countTransactionsBySourceFile } from "../../db/queries/transactions.js";
+import { countQuestions } from "../../db/queries/questions.js";
+const COL = {
+    status: 9,
+    provenance: 28,
+    scannedAt: 20,
+};
+const MIN_PATH_WIDTH = 16;
+const MAX_PATH_WIDTH = 50;
+const STATUS_COLOR = {
+    scanned: chalk.green,
+    failed: chalk.red,
+    pending: chalk.gray,
+};
+export function FilesBrowser({ files: initialFiles, db }) {
+    const [files, setFiles] = useState(initialFiles);
+    const [confirm, setConfirm] = useState(null);
+    const adapter = useMemo(() => {
+        const commitDelete = () => {
+            if (!confirm)
+                return;
+            deleteScannedFile(db, confirm.fileId);
+            setFiles(prev => prev.filter(f => f.id !== confirm.fileId));
+            setConfirm(null);
+        };
+        const cancelConfirm = () => setConfirm(null);
+        const CONFIRM_KEYS = {
+            y: commitDelete,
+            n: cancelConfirm,
+            escape: cancelConfirm,
+        };
+        const BROWSE_KEYS = {
+            d: (cursorItem) => {
+                if (!cursorItem)
+                    return false;
+                setConfirm({
+                    fileId: cursorItem.id,
+                    path: cursorItem.path,
+                    cascadeTx: countTransactionsBySourceFile(db, cursorItem.id),
+                    // includeDeferred: true so the count matches what ON DELETE CASCADE will actually drop.
+                    cascadeQuestions: countQuestions(db, { file_id: cursorItem.id, includeDeferred: true }),
+                });
+                return true;
+            },
+        };
+        return {
+            title: "Scanned files",
+            items: files,
+            getId: f => f.id,
+            renderRow: (f, ctx) => renderFileRow(f, ctx.isCursor, ctx.cols),
+            matches: (f, needle) => f.path.toLowerCase().includes(needle) ||
+                (f.provider ?? "").toLowerCase().includes(needle) ||
+                (f.model ?? "").toLowerCase().includes(needle),
+            emptyMessage: "No scanned files match the current filter.",
+            summary: confirm ? (_jsx(Text, { color: "yellow", children: `Delete ${truncateMiddle(confirm.path, 60)}? (y/n)  Cascade removes ${confirm.cascadeTx} transaction(s) and ${confirm.cascadeQuestions} question(s).` })) : undefined,
+            onKey: (input, key, { cursorItem }) => {
+                const k = keyOf(input, key).toLowerCase();
+                if (confirm !== null) {
+                    CONFIRM_KEYS[k]?.();
+                    return true;
+                }
+                return BROWSE_KEYS[k]?.(cursorItem) ?? false;
+            },
+        };
+    }, [files, confirm, db]);
+    return _jsx(ListBrowser, { adapter: adapter });
+}
+function renderFileRow(f, isCursor, cols) {
+    const marker = isCursor ? "▸" : " ";
+    const status = STATUS_COLOR[f.status](padRight(f.status, COL.status));
+    const provenanceRaw = f.provider && f.model ? `${f.provider}/${f.model}` : f.status === "failed" ? "(failed)" : "(not stamped)";
+    const provenance = chalk.dim(padRight(truncateMiddle(provenanceRaw, COL.provenance), COL.provenance));
+    const scannedAtRaw = f.scanned_at ?? "—";
+    const scannedAt = chalk.dim(padRight(scannedAtRaw, COL.scannedAt));
+    // Layout: "M status(9)  path(flex)  provenance(28)  scannedAt(20)"
+    const fixedWidth = 1 + 1 + COL.status + 2 + 2 + COL.provenance + 2 + COL.scannedAt;
+    const pathBudget = Math.max(MIN_PATH_WIDTH, Math.min(MAX_PATH_WIDTH, cols - fixedWidth - 2));
+    const pathRaw = truncateMiddle(relativeFromDataDir(f.path), pathBudget);
+    const pathPadded = padRight(pathRaw, pathBudget);
+    const path = isCursor ? chalk.cyan.bold(pathPadded) : pathPadded;
+    return `${marker} ${status}  ${path}  ${provenance}  ${scannedAt}`;
+}
+/** Strip the configured data-dir prefix so the path column shows just the
+ *  meaningful tail (subdirs + filename). Falls back to the absolute path
+ *  for files that somehow live outside the data dir. */
+function relativeFromDataDir(absolutePath) {
+    const dataDir = getDataDir().replace(/\/+$/, "");
+    if (absolutePath === dataDir)
+        return absolutePath;
+    const prefix = dataDir + "/";
+    return absolutePath.startsWith(prefix)
+        ? absolutePath.slice(prefix.length)
+        : absolutePath;
+}

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

@@ -1,8 +1,16 @@
 import { type ReactNode } from "react";
 import { type Key } from "ink";
 export interface ListBrowserAdapter<T> {
-    title: string;
+    /** Title row "{title} · N results · {filterSummary} · cursor/N". Omit to
+     *  hide the title row and its separator rule entirely — useful when the
+     *  adapter supplies its own `headerNode` and the auto-title would be
+     *  redundant (e.g. ScanDashboard). */
+    title?: string;
     filterSummary?: string;
+    /** Optional fixed chrome rendered above the title row. Use this when the
+     *  list needs a multi-line header (e.g. a pipeline status indicator plus
+     *  column labels) that should not scroll with the items. */
+    headerNode?: ReactNode;
     items: T[];
     getId: (item: T) => string;
     /** Returns the row as a single ANSI-colored string for the given context. */

package/dist/cli/ink/ListBrowser.js

@@ -1,4 +1,4 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { memo, useEffect, useMemo, useState } from "react";
 import { Box, Text, useApp, useInput, useStdout } from "ink";
 import { keyOf } from "./keys.js";
@@ -124,7 +124,7 @@ export function ListBrowser({ adapter }) {
     const ruleWidth = Math.min(cols, 120);
     const visibleEnd = Math.min(filtered.length, scrollOffset + effectiveViewportSize);
     const visible = filtered.slice(scrollOffset, visibleEnd);
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: [_jsx(Text, { bold: true, children: adapter.title }), _jsx(Text, { dimColor: true, children: `  ·  ${filtered.length} results` }), adapter.filterSummary ? _jsx(Text, { dimColor: true, children: `  ·  ${adapter.filterSummary}` }) : null, filtered.length > viewportSize ? (_jsx(Text, { dimColor: true, children: `  ·  ${Math.min(cursor + 1, filtered.length)}/${filtered.length}` })) : null] }), _jsx(Text, { dimColor: true, children: "─".repeat(ruleWidth) }), filtered.length === 0 ? (_jsx(Text, { color: "yellow", children: adapter.emptyMessage ?? "No results match the current filter." })) : (_jsx(Box, { flexDirection: "column", children: visible.map((item, i) => {
+    return (_jsxs(Box, { flexDirection: "column", children: [adapter.headerNode, adapter.title ? (_jsxs(_Fragment, { children: [_jsxs(Text, { children: [_jsx(Text, { bold: true, children: adapter.title }), _jsx(Text, { dimColor: true, children: `  ·  ${filtered.length} results` }), adapter.filterSummary ? _jsx(Text, { dimColor: true, children: `  ·  ${adapter.filterSummary}` }) : null, filtered.length > viewportSize ? (_jsx(Text, { dimColor: true, children: `  ·  ${Math.min(cursor + 1, filtered.length)}/${filtered.length}` })) : null] }), _jsx(Text, { dimColor: true, children: "─".repeat(ruleWidth) })] })) : null, filtered.length === 0 ? (_jsx(Text, { color: "yellow", children: adapter.emptyMessage ?? "No results match the current filter." })) : (_jsx(Box, { flexDirection: "column", children: visible.map((item, i) => {
                     const idx = scrollOffset + i;
                     const isCursor = idx === cursor;
                     const id = adapter.getId(item);

package/dist/cli/ink/PromptFrame.js

@@ -7,5 +7,5 @@ export function PromptFrame({ buffer, footerText, showCaret, banner }) {
     const { stdout } = useStdout();
     const cols = stdout?.columns || 80;
     const rule = chalk.dim("─".repeat(cols));
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: rule }), _jsx(TextInput, { buffer: buffer, prompt: chalk.dim("❯ "), showCaret: showCaret }), _jsx(Text, { children: rule }), _jsx(Text, { children: chalk.dim(`  ${footerText}`) }), banner ? _jsx(Text, { children: banner }) : null] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: rule }), _jsx(TextInput, { buffer: buffer, prompt: chalk.dim("❯ "), showCaret: showCaret }), _jsx(Text, { children: rule }), _jsx(Text, { children: `  ${footerText}` }), banner ? _jsx(Text, { children: banner }) : null] }));
 }

package/dist/cli/ink/ScanDashboard.js

@@ -1,7 +1,11 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useEffect, useState } from "react";
-import { Box, Text, useStdout } from "ink";
+import { memo, useEffect, useMemo, useState } from "react";
+import { Box, Text } from "ink";
 import Spinner from "ink-spinner";
+import chalk from "chalk";
+import { padRight, truncateMiddle } from "../helper.js";
+import { ListBrowser } from "./ListBrowser.js";
+import { keyOf } from "./keys.js";
 export function createScanDashboardController() {
     const subscribers = new Set();
     return {
@@ -25,6 +29,7 @@ function classify(input, rules) {
     throw new Error("classify: no rule matched (missing catch-all?)");
 }
 const COL = {
+    marker: 2, // "▸ " or "  "
     status: 14,
     files: 34,
     transactions: 13,
@@ -33,11 +38,36 @@ const COL = {
 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(AttachmentLine, { info: props.attachment }), _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 }), phase !== "done" && _jsx(Footnote, {})] }));
+    const spinnerFrame = useSpinnerFrame();
+    const items = useMemo(() => Array.from(rows.entries(), ([fileId, group]) => ({ fileId, group })), [rows]);
+    const adapter = useMemo(() => ({
+        headerNode: (_jsxs(Box, { flexDirection: "column", children: [_jsx(Header, { phase: phase }), _jsx(AttachmentLine, { info: props.attachment }), _jsx(ColumnHeader, {})] })),
+        items,
+        getId: (i) => i.fileId,
+        renderRow: (i, ctx) => renderFileRow(i.group, ctx.isCursor, ctx.isExpanded, spinnerFrame, phase),
+        renderExpanded: (i) => (_jsx(ChunkList, { chunks: i.group.chunks, frame: spinnerFrame })),
+        getExpandedHeight: (i) => i.group.chunks.size,
+        matches: (i, needle) => i.group.fileName.toLowerCase().includes(needle),
+        summary: phase !== "done" ? _jsx(Footnote, {}) : null,
+        onKey: (input, key) => {
+            const k = keyOf(input, key);
+            return k === "q" || k === "escape";
+        },
+        emptyMessage: "No files in the scan queue.",
+    }), [phase, items, props.attachment, spinnerFrame]);
+    return _jsx(ListBrowser, { adapter: adapter });
+}
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+function useSpinnerFrame() {
+    const [i, setI] = useState(0);
+    useEffect(() => {
+        const id = setInterval(() => setI((prev) => (prev + 1) % SPINNER_FRAMES.length), 80);
+        return () => clearInterval(id);
+    }, []);
+    return SPINNER_FRAMES[i];
 }
 function Footnote() {
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "output accuracy depends on the model's vision capability." }), _jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "by the way, user can run" }), _jsx(Text, { color: "cyan", children: "clarify" }), _jsx(Text, { dimColor: true, children: ", " }), _jsx(Text, { color: "cyan", children: "record" }), _jsx(Text, { dimColor: true, children: ", and " }), _jsx(Text, { color: "cyan", children: "chat" }), _jsx(Text, { dimColor: true, children: " to correct the data later." })] })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "Output accuracy depends on the model's vision capability." }), _jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "You can run " }), _jsx(Text, { color: "cyan", children: "clarify" }), _jsx(Text, { dimColor: true, children: ", " }), _jsx(Text, { color: "cyan", children: "record" }), _jsx(Text, { dimColor: true, children: ", and " }), _jsx(Text, { color: "cyan", children: "chat" }), _jsx(Text, { dimColor: true, children: " to correct the data later." })] })] }));
 }
 function AttachmentLine({ info }) {
     const detail = info.format === "pdf" ? "pdf (native)" : "png (rasterized)";
@@ -51,20 +81,6 @@ function usePhase(controller) {
     }), [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] })),
@@ -87,19 +103,34 @@ 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("clarify", phase)]("clarify")] }));
 }
 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" }),
+    return (_jsxs(Box, { flexDirection: "row", marginTop: 1, children: [_jsx(Box, { width: COL.marker }), _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 statusText(status, frame) {
+    switch (status) {
+        case "queued":
+            return "queued";
+        case "running":
+            return `${frame} running`;
+        case "scanning":
+            return `${frame} scanning`;
+        case "clarify":
+            return `${frame} clarify`;
+        case "done":
+            return "✓ done";
+        case "failed":
+            return "failed";
+        case "partial":
+            return "partial";
+    }
+}
+const STATUS_COLOR = {
+    queued: chalk.gray,
+    running: chalk.yellow,
+    scanning: chalk.yellow,
+    clarify: chalk.yellow,
+    done: chalk.green,
+    failed: chalk.red,
+    partial: chalk.yellow,
 };
 const FILE_STATUS_RULES = [
     { when: ({ finished, total }) => finished < total, state: "scanning" },
@@ -120,40 +151,34 @@ function aggregate(chunks, total) {
     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);
+function renderFileRow(group, isCursor, isExpanded, frame, phase) {
+    const chunks = Array.from(group.chunks.values());
     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) => (_jsx(ChunkRow, { chunk: c }, c.pageNumber)))] }));
-}
-function ChunkRow({ chunk }) {
-    const connector = "|-";
-    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);
+    const effectiveStatus = phase === "clarify" ? "clarify" : agg.status;
+    const marker = isExpanded ? "▾" : isCursor ? "▸" : " ";
+    const status = STATUS_COLOR[effectiveStatus](padRight(statusText(effectiveStatus, frame), COL.status));
+    const nameRaw = truncateMiddle(group.fileName, COL.files - 2);
+    const namePadded = padRight(nameRaw, COL.files);
+    const name = isCursor ? chalk.cyan.bold(namePadded) : chalk.dim(namePadded);
+    const tx = renderCount(agg.totalTx, COL.transactions);
+    const q = renderCount(agg.totalQuestions, COL.questions);
+    return `${marker} ${status}${name}${tx}${q}`;
+}
+function renderCount(n, width) {
+    const raw = n > 0 ? String(n) : "-";
+    const padded = padRight(raw, width);
+    return n > 0 ? padded : chalk.gray(padded);
+}
+const ChunkList = memo(function ChunkList({ chunks, frame, }) {
+    const sorted = Array.from(chunks.values()).sort((a, b) => a.pageNumber - b.pageNumber);
+    return (_jsx(Box, { flexDirection: "column", children: sorted.map((c) => (_jsx(Text, { children: renderChunkLine(c, frame) }, c.pageNumber))) }));
+});
+function renderChunkLine(c, frame) {
+    const status = STATUS_COLOR[c.status](padRight(statusText(c.status, frame), COL.status));
+    const part = chalk.dim(padRight(`  |- part ${c.pageNumber}`, COL.files));
+    const tx = renderCount(c.txCount, COL.transactions);
+    const q = renderCount(c.questionsCount, COL.questions);
+    return `  ${status}${part}${tx}${q}`;
 }
 function useFileGroups(controller, files) {
     const [rows, setRows] = useState(() => seedRows(files));

package/dist/cli/ink/hooks/useFooterText.js

@@ -1,5 +1,7 @@
 import { useEffect, useMemo, useState } from "react";
 import chalk from "chalk";
+import { getActiveModel } from "../../../config.js";
+import { getProvider } from "../../../ai/providers/index.js";
 const HINTS = [
     "try: what's my net worth?",
     "try: how many months of runway do I have?",
@@ -36,33 +38,23 @@ const HINTS = [
 export function useFooterText(db) {
     const [tick, setTick] = useState(0);
     const [hintIdx] = useState(() => Math.floor(Math.random() * HINTS.length));
+    const providerModel = `${getProvider().name}/${getActiveModel()}`;
     useEffect(() => {
         const id = setInterval(() => setTick((t) => t + 1), 60_000);
         return () => clearInterval(id);
     }, []);
     return useMemo(() => {
-        const lastScan = db
-            .prepare(`SELECT MAX(scanned_at) AS ts FROM scanned_files WHERE status = 'scanned'`)
+        const { n: fileCount } = db
+            .prepare(`SELECT COUNT(*) AS n FROM scanned_files WHERE status = 'scanned'`)
             .get();
-        let scanStr = "";
-        if (lastScan?.ts) {
-            const diffMs = Date.now() - new Date(lastScan.ts + "Z").getTime();
-            const mins = Math.floor(diffMs / 60000);
-            if (mins < 1)
-                scanStr = "scanned just now";
-            else if (mins < 60)
-                scanStr = `scanned ${mins}m ago`;
-            else if (mins < 1440)
-                scanStr = `scanned ${Math.floor(mins / 60)}h ago`;
-            else
-                scanStr = `scanned ${Math.floor(mins / 1440)}d ago`;
-        }
         const idx = (hintIdx + tick) % HINTS.length;
-        const parts = [`${chalk.cyan("<°(((><")}`];
-        if (scanStr)
-            parts.push(scanStr);
-        parts.push(HINTS[idx]);
-        parts.push("ctrl+c to exit");
-        return parts.join("  |  ");
-    }, [db, tick, hintIdx]);
+        const parts = [
+            chalk.cyan("<°(((><"),
+            chalk.dim(providerModel),
+            chalk.dim(`${fileCount} file${fileCount === 1 ? "" : "s"}`),
+            chalk.dim(HINTS[idx]),
+            chalk.dim("ctrl+c to exit"),
+        ];
+        return parts.join(chalk.dim("  |  "));
+    }, [db, tick, hintIdx, providerModel]);
 }

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

@@ -4,8 +4,37 @@ export interface ScannedFileTotals {
     pending: number;
     failed: number;
 }
+export interface ScannedFileRow {
+    id: string;
+    path: string;
+    file_hash: string;
+    mime: string;
+    status: "pending" | "scanned" | "failed";
+    scanned_at: string | null;
+    provider: string | null;
+    model: string | null;
+    error: string | null;
+    created_at: string;
+}
 /**
  * Bucket the `scanned_files` table by its `status` enum. Missing buckets are
  * filled with 0 so callers can render a stable shape without null checks.
  */
 export declare function countScannedFiles(db: Database.Database): ScannedFileTotals;
+export declare function listScannedFiles(db: Database.Database): ScannedFileRow[];
+export declare function findScannedFileById(db: Database.Database, id: string): ScannedFileRow | null;
+export interface DeleteScannedFileResult {
+    /** The deleted row, or null when no row matched the id. */
+    removed: ScannedFileRow | null;
+    /** Count of transaction rows that cascaded out. */
+    removedTransactions: number;
+    /** Count of question rows that cascaded out. */
+    removedQuestions: number;
+}
+/**
+ * Delete a `scanned_files` row by id. Cascades remove transactions
+ * (`transactions.source_file_id`) and questions (`questions.file_id`) via the
+ * schema's ON DELETE CASCADE. Cascaded counts are gathered before the DELETE
+ * so callers can report what disappeared.
+ */
+export declare function deleteScannedFile(db: Database.Database, id: string): DeleteScannedFileResult;

package/dist/db/queries/files.js

@@ -14,3 +14,37 @@ export function countScannedFiles(db) {
     }
     return totals;
 }
+export function listScannedFiles(db) {
+    return db
+        .prepare(`SELECT id, path, file_hash, mime, status, scanned_at, provider, model, error, created_at
+       FROM scanned_files
+       ORDER BY scanned_at DESC, created_at DESC`)
+        .all();
+}
+export function findScannedFileById(db, id) {
+    const row = db
+        .prepare(`SELECT id, path, file_hash, mime, status, scanned_at, provider, model, error, created_at
+       FROM scanned_files WHERE id = ?`)
+        .get(id);
+    return row ?? null;
+}
+/**
+ * Delete a `scanned_files` row by id. Cascades remove transactions
+ * (`transactions.source_file_id`) and questions (`questions.file_id`) via the
+ * schema's ON DELETE CASCADE. Cascaded counts are gathered before the DELETE
+ * so callers can report what disappeared.
+ */
+export function deleteScannedFile(db, id) {
+    const removed = findScannedFileById(db, id);
+    if (!removed) {
+        return { removed: null, removedTransactions: 0, removedQuestions: 0 };
+    }
+    const removedTransactions = db
+        .prepare(`SELECT COUNT(*) AS n FROM transactions WHERE source_file_id = ?`)
+        .get(id).n;
+    const removedQuestions = db
+        .prepare(`SELECT COUNT(*) AS n FROM questions WHERE file_id = ?`)
+        .get(id).n;
+    db.prepare(`DELETE FROM scanned_files WHERE id = ?`).run(id);
+    return { removed, removedTransactions, removedQuestions };
+}

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

@@ -22,12 +22,17 @@ export interface QuestionRow {
     prompt: string;
     options_json: string | null;
     context_json: string | null;
+    deferred_until: string | null;
     created_at: string;
 }
 export interface ClosedQuestion {
     prompt: string;
     kind: string | null;
     answer: string;
+    /** Stable signature pulled from the question's context_json. When set, the
+     * rule synthesizer keys the learned rule on this (so future questions with
+     * different prose but the same key match). When null, no rule is learned. */
+    rule_key: string | null;
 }
 /**
  * Insert a new questions row and flip the `has_question` boolean on whichever
@@ -53,10 +58,22 @@ export interface CountQuestionsScope {
     account_id?: string;
     kind?: string;
     scan_id?: string;
+    /** When true, count deferred rows too (default false — defer hides). */
+    includeDeferred?: boolean;
 }
 export declare function countQuestions(db: Database.Database, scope?: CountQuestionsScope): number;
 export interface ListQuestionsOptions {
     limit?: number;
     scanId?: string;
+    /** When true, include deferred rows in the result (default false). */
+    includeDeferred?: boolean;
 }
 export declare function listQuestions(db: Database.Database, opts?: ListQuestionsOptions): QuestionRow[];
+/**
+ * Mark a question as deferred for `days` days from now. The default
+ * `listQuestions` / `countQuestions` filter hides deferred rows until the
+ * timestamp passes, so the clarifier won't re-encounter the question on the
+ * next run. Pass `includeDeferred: true` to those functions for an
+ * unfiltered view (e.g. for the rules / files browsers).
+ */
+export declare function deferQuestion(db: Database.Database, id: string, days: number): boolean;