plasalid 0.8.0 → 0.8.1

package/README.md

@@ -157,7 +157,7 @@ OPENAI_MODEL=                 # default: gpt-5.4-mini
 
 # Google Gemini
 GEMINI_API_KEY=               # required when provider is gemini
-GEMINI_MODEL=                 # default: gemini-3.5-flash
+GEMINI_MODEL=                 # default: gemini-2.5-pro
 
 # OpenAI-compatible (LM Studio, Ollama, vLLM, etc.)
 OPENAI_COMPAT_BASE_URL=       # e.g. http://localhost:1234/v1

package/dist/cli/commands/scan.js

@@ -3,6 +3,12 @@ import { getDb } from "../../db/connection.js";
 import { runScan } from "../../scanner/engine.js";
 import { getActiveModel } from "../../config.js";
 import { getProvider } from "../../ai/providers/index.js";
+import { AbortedError } from "../../ai/errors.js";
+/** Show the cursor — always safe; mirrors the TTY mount-time hide. */
+function restoreTerminal() {
+    if (process.stdout.isTTY)
+        process.stdout.write("\x1b[?25h");
+}
 export async function runScanCommand(opts) {
     if (opts.regex) {
         try {
@@ -16,17 +22,46 @@ export async function runScanCommand(opts) {
     }
     const parallel = opts.parallel ?? 5;
     const isTTY = !!process.stdout.isTTY;
-    const hooks = isTTY ? await buildTtyHooks() : buildPlainHooks();
-    const result = await runScan(getDb(), {
-        regex: opts.regex,
-        force: opts.force,
-        interactive: true,
-        maxFileWorkers: parallel,
-    }, hooks);
-    renderSummary(result.state);
+    const controller = new AbortController();
+    let sigintCount = 0;
+    const onSigint = () => {
+        sigintCount++;
+        if (sigintCount === 1) {
+            controller.abort();
+            return;
+        }
+        restoreTerminal();
+        process.exit(130);
+    };
+    process.on("SIGINT", onSigint);
+    const hooks = isTTY
+        ? await buildTtyHooks(controller.signal)
+        : buildPlainHooks(controller.signal);
+    try {
+        const result = await runScan(getDb(), {
+            regex: opts.regex,
+            force: opts.force,
+            interactive: true,
+            maxFileWorkers: parallel,
+        }, hooks, controller.signal);
+        renderSummary(result.state);
+    }
+    catch (err) {
+        if (err instanceof AbortedError) {
+            restoreTerminal();
+            console.log("");
+            console.log(chalk.yellow("scan cancelled. anything committed before cancel stays in the database (run `scan --force` or `revert`)."));
+            process.exitCode = 130;
+            return;
+        }
+        throw err;
+    }
+    finally {
+        process.removeListener("SIGINT", onSigint);
+    }
 }
 /* TTY mode — Ink dashboard with one in-place row per file. */
-async function buildTtyHooks() {
+async function buildTtyHooks(signal) {
     const { render } = await import("ink");
     const { createElement } = await import("react");
     const { ScanDashboard, createScanDashboardController } = await import("../ink/ScanDashboard.js");
@@ -34,6 +69,14 @@ async function buildTtyHooks() {
     let inkInstance = null;
     let unsubscribeProgress = null;
     const chunkLookup = new Map();
+    // Surface cancellation through Ink's controller, not raw stdout — writing
+    // to stdout while Ink is rendering corrupts its frame tracking and leaves
+    // a phantom copy of the header in scrollback. once:true so the listener
+    // self-removes without leaking past the scan run.
+    const onAbortEvt = () => {
+        controller.publish({ type: "phase-set", phase: "cancelling" });
+    };
+    signal.addEventListener("abort", onAbortEvt, { once: true });
     return {
         afterDecrypt: (s) => {
             const total = s.decrypted.length + s.skipped.length + s.failed.length;
@@ -117,6 +160,18 @@ async function buildTtyHooks() {
             inkInstance = null;
             process.stdout.write("\x1b[?25h");
         },
+        /**
+         * Cancellation lands here when the user hits Ctrl+C mid-scan. Drop the
+         * Ink dashboard immediately so subsequent stderr lines aren't trapped
+         * under its render, and restore the cursor we hid at mount time.
+         */
+        onAbort: () => {
+            unsubscribeProgress?.();
+            unsubscribeProgress = null;
+            inkInstance?.unmount();
+            inkInstance = null;
+            process.stdout.write("\x1b[?25h");
+        },
     };
 }
 const FINALIZE_RULES = [
@@ -135,10 +190,14 @@ function classifyFinalize(t) {
             return r.kind;
     return "partial";
 }
-function buildPlainHooks() {
+function buildPlainHooks(signal) {
     const tallies = new Map();
     const fileIdByChunkId = new Map();
     let unsubscribeProgress = null;
+    // No Ink in this mode, so writing one dim line directly is safe.
+    signal.addEventListener("abort", () => {
+        console.log(chalk.dim("Cancelling… waiting for in-flight work."));
+    }, { once: true });
     const finalize = (fileId) => {
         const t = tallies.get(fileId);
         if (!t || t.completedChunks + t.failedChunks < t.totalChunks)

package/dist/cli/commands/status.js

@@ -6,6 +6,7 @@ import { getRecurringSummary } from "../../db/queries/recurrences.js";
 import { countScannedFiles } from "../../db/queries/files.js";
 import { countQuestions } from "../../db/queries/questions.js";
 import { countMemories } from "../../ai/memory.js";
+import { config, getActiveModel } from "../../config.js";
 import { formatAmount } from "../../currency.js";
 import { visibleLength } from "../format.js";
 const LABEL_WIDTH = 18;
@@ -14,6 +15,8 @@ export function showStatus() {
     printSection("Financial", financialRows(db));
     console.log("");
     printSection("System", systemRows(db));
+    console.log("");
+    printSection("Model", modelRows(), { align: "left" });
 }
 function financialRows(db) {
     const nw = getNetWorth(db);
@@ -72,7 +75,14 @@ function systemRows(db) {
     }
     return rows;
 }
-function printSection(title, rows) {
+function modelRows() {
+    return [
+        { label: "Provider", value: config.providerType },
+        { label: "Model", value: getActiveModel() },
+    ];
+}
+function printSection(title, rows, opts) {
+    const align = opts?.align ?? "right";
     console.log(chalk.bold(title));
     console.log(chalk.dim("─".repeat(title.length)));
     const valueWidth = Math.max(0, ...rows.map((r) => visibleLength(r.value)));
@@ -80,7 +90,10 @@ function printSection(title, rows) {
         const label = row.label.padEnd(LABEL_WIDTH);
         const valuePad = " ".repeat(Math.max(0, valueWidth - visibleLength(row.value)));
         const suffix = row.suffix ? `  ${row.suffix}` : "";
-        console.log(`  ${label}${valuePad}${row.value}${suffix}`);
+        const body = align === "left"
+            ? `${row.value}${valuePad}${suffix}`
+            : `${valuePad}${row.value}${suffix}`;
+        console.log(`  ${label}${body}`);
     }
 }
 function formatInteger(n) {

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

@@ -2,7 +2,7 @@
  * Events the CLI publishes into the dashboard. The CLI subscribes to the
  * scanner's ScanProgress sink and routes per-chunk ticks here via chunkLookup.
  */
-export type CurrentPhase = "parse" | "clarify" | "done";
+export type CurrentPhase = "parse" | "clarify" | "cancelling" | "done";
 export type DashboardEvent = {
     type: "chunk-start";
     fileId: string;

package/dist/cli/ink/ScanDashboard.js

@@ -34,11 +34,14 @@ 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 })] }));
+    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, {})] }));
+}
+function Footnote() {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "output accuracy depends on the model's VL capability." }), _jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "we also provide " }), _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 rectify the data later." })] })] }));
 }
 function AttachmentLine({ info }) {
     const detail = info.format === "pdf" ? "pdf (native)" : "png (rasterized)";
-    return (_jsxs(Text, { dimColor: true, children: ["sending: ", detail, " \u00B7 ", info.providerName, " \u00B7 ", info.modelName] }));
+    return (_jsxs(Text, { dimColor: true, children: ["sending: ", detail, " (", info.providerName, "/", info.modelName, ")"] }));
 }
 function usePhase(controller) {
     const [phase, setPhase] = useState("parse");
@@ -78,6 +81,12 @@ function phaseStateOf(label, current) {
     return "pending";
 }
 function Header({ phase }) {
+    // Cancellation collapses the parse/clarify segments — neither is still
+    // running once the user hits Ctrl+C, and showing them as "pending" would
+    // be misleading. The single "cancelling…" label communicates the wind-down.
+    if (phase === "cancelling") {
+        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: " -> " }), _jsxs(Text, { color: "red", children: [_jsx(Spinner, { type: "dots" }), " cancelling\u2026"] })] }));
+    }
     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() {

package/dist/cli/setup.js

@@ -11,7 +11,7 @@ const DEFAULT_LOCAL_OPENAI_BASE_URL = "http://localhost:11434/v1";
 const RECOMMENDED_MODEL = {
     anthropic: "claude-sonnet-4-6",
     openai: "gpt-5.4-mini",
-    gemini: "gemini-3.5-flash",
+    gemini: "gemini-2.5-pro",
 };
 function ensureDir(p) {
     if (!existsSync(p))
@@ -127,9 +127,15 @@ async function promptModelInput(vendor) {
     const carriedOver = savedModelFor(vendor);
     const recommended = vendor === "openai-compat" ? "" : RECOMMENDED_MODEL[vendor];
     const defaultValue = carriedOver || recommended;
+    // openai-compat has no single recommended model — the scanner rasterizes
+    // PDFs to PNG on this path, so any non-vision model will fail on scan. Steer
+    // the user toward a vision-language model in the prompt.
+    const message = vendor === "openai-compat"
+        ? "Which AI model? (use a vision-language model)"
+        : `Which AI model? (recommended: ${RECOMMENDED_MODEL[vendor]})`;
     return inputPrompt({
         name: "model",
-        message: "Which AI model?",
+        message,
         default: defaultValue || undefined,
         validate: (v) => v.trim().length > 0 || "Required",
     });

package/dist/config.js

@@ -39,7 +39,7 @@ function buildConfig() {
         openaiCompatBaseURL: process.env.OPENAI_COMPAT_BASE_URL || file.openaiCompatBaseURL || "",
         openaiCompatModel: process.env.OPENAI_COMPAT_MODEL || file.openaiCompatModel || "",
         geminiKey: process.env.GEMINI_API_KEY || file.geminiKey || "",
-        geminiModel: process.env.GEMINI_MODEL || file.geminiModel || "gemini-3.5-flash",
+        geminiModel: process.env.GEMINI_MODEL || file.geminiModel || "gemini-2.5-pro",
         displayLocale: file.displayLocale || "th-TH",
         displayCurrency: file.displayCurrency || "THB",
         dbPath: process.env.PLASALID_DB_PATH ||

package/dist/scanner/clarifier.d.ts

@@ -28,6 +28,8 @@ export interface RunClarifyOpts {
         toolCount: number;
         elapsedMs: number;
     }) => void;
+    /** When set and aborted, runClarify stops between passes/questions. */
+    signal?: AbortSignal;
 }
 export declare const CLARIFIER_PASSES: readonly ClarifierPass[];
 /**

package/dist/scanner/clarifier.js

@@ -156,6 +156,7 @@ async function runAgentLoop(opts, closures, tally) {
                     },
                 },
                 onProgress: opts.onProgress,
+                signal: opts.signal,
             });
             return countRemaining(db, opts.scanId);
         },

package/dist/scanner/concurrency.d.ts

@@ -4,8 +4,15 @@
  * never aborts the rest — its slot settles as `{ ok: false, error }` and the
  * caller decides what to do.
  *
+ * Pass `signal` to make the pool cancellation-aware: when it aborts, no new
+ * task is claimed (tasks already running aren't interrupted — their own
+ * signal-aware work is expected to react). Unclaimed slots stay `undefined`
+ * in the returned array; the caller can spot them by checking length vs the
+ * filled entries.
+ *
  * No new dependency. Simple worker-pool: kicks off up to `n` tasks, then each
- * worker pulls the next index from a shared cursor until the queue is drained.
+ * worker pulls the next index from a shared cursor until the queue is drained
+ * or the signal aborts.
  */
 export type Settled<T> = {
     ok: true;
@@ -14,4 +21,4 @@ export type Settled<T> = {
     ok: false;
     error: unknown;
 };
-export declare function runWithConcurrency<T>(tasks: Array<() => Promise<T>>, n: number): Promise<Settled<T>[]>;
+export declare function runWithConcurrency<T>(tasks: Array<() => Promise<T>>, n: number, signal?: AbortSignal): Promise<Settled<T>[]>;

package/dist/scanner/concurrency.js

@@ -1,9 +1,11 @@
-export async function runWithConcurrency(tasks, n) {
+export async function runWithConcurrency(tasks, n, signal) {
     const results = new Array(tasks.length);
     const workerCount = Math.max(1, Math.min(n, tasks.length));
     let cursor = 0;
     async function worker() {
         while (cursor < tasks.length) {
+            if (signal?.aborted)
+                return;
             const index = cursor++;
             try {
                 results[index] = { ok: true, value: await tasks[index]() };

package/dist/scanner/engine.d.ts

@@ -65,6 +65,7 @@ export interface ScanState {
     readonly startedAt: number;
     readonly options: RunScanOptions;
     readonly progress: ScanProgress;
+    readonly signal: AbortSignal;
     files: ScannedFile[];
     decrypted: DecryptedFile[];
     skipped: SkippedFile[];
@@ -87,4 +88,4 @@ export declare const DEFAULT_PHASES: readonly {
  * through ScanState, then runs the phase chain. Nothing survives between
  * scans.
  */
-export declare function runScan(db: Database.Database, opts?: RunScanOptions, hooks?: ScanHooks): Promise<ScanResult>;
+export declare function runScan(db: Database.Database, opts?: RunScanOptions, hooks?: ScanHooks, signal?: AbortSignal): Promise<ScanResult>;

package/dist/scanner/engine.js

@@ -5,6 +5,9 @@ import { parsePhase } from "./parse.js";
 import { chunkPdf } from "./pdf/chunker.js";
 import { runClarify } from "./clarifier.js";
 import { errorMessage } from "./result.js";
+import { AbortedError } from "../ai/errors.js";
+/** A signal that never aborts. Used when callers don't pass one. */
+const NEVER_ABORTS = new AbortController().signal;
 const chunkPhase = async (_db, state, hooks) => {
     await hooks.beforeChunk?.(state);
     for (const file of state.decrypted)
@@ -17,6 +20,7 @@ const clarifyPhase = async (db, state, hooks) => {
         db,
         scanId: state.scanId,
         interactive: state.options.interactive ?? true,
+        signal: state.signal,
     });
     state.clarifySummary = summary;
     await hooks.afterClarify?.(state, summary);
@@ -32,7 +36,7 @@ export const DEFAULT_PHASES = [
  * through ScanState, then runs the phase chain. Nothing survives between
  * scans.
  */
-export async function runScan(db, opts = {}, hooks = {}) {
+export async function runScan(db, opts = {}, hooks = {}, signal = NEVER_ABORTS) {
     const scanId = `sc:${randomUUID()}`;
     const progress = createProgress();
     const state = {
@@ -40,6 +44,7 @@ export async function runScan(db, opts = {}, hooks = {}) {
         startedAt: Date.now(),
         options: opts,
         progress,
+        signal,
         files: [],
         decrypted: [],
         skipped: [],
@@ -50,8 +55,19 @@ export async function runScan(db, opts = {}, hooks = {}) {
     };
     await fire(hooks.onStart, state);
     const phases = opts.phases ?? DEFAULT_PHASES;
-    await runPhaseChain(db, state, hooks, phases);
-    await fire(hooks.onFinish, state);
+    try {
+        await runPhaseChain(db, state, hooks, phases);
+        if (state.signal.aborted)
+            throw new AbortedError();
+    }
+    catch (err) {
+        if (err instanceof AbortedError)
+            await fire(hooks.onAbort, state);
+        throw err;
+    }
+    finally {
+        await fire(hooks.onFinish, state);
+    }
     return { scanId, state };
 }
 async function runPhaseChain(db, state, hooks, phases) {
@@ -67,6 +83,8 @@ async function tryPhase(db, state, hooks, name, phase) {
         return false;
     }
     catch (err) {
+        if (err instanceof AbortedError)
+            throw err;
         state.errors.push({ phase: name, error: err });
         await fire(hooks.onError, err, name, state);
         return true;

package/dist/scanner/hooks.d.ts

@@ -19,5 +19,11 @@ export interface ScanHooks {
     beforeClarify?(s: Readonly<ScanState>): MaybePromise<void>;
     afterClarify?(s: Readonly<ScanState>, summary: ClarifySummary): MaybePromise<void>;
     onError?(err: unknown, phase: PhaseName, s: Readonly<ScanState>): MaybePromise<void>;
+    /**
+     * Fired when an AbortSignal trip propagates out of any phase. The CLI uses
+     * this to unmount Ink and restore the cursor before runScan's promise
+     * settles. onFinish still fires after onAbort.
+     */
+    onAbort?(s: Readonly<ScanState>): MaybePromise<void>;
     onFinish?(s: Readonly<ScanState>): MaybePromise<void>;
 }

package/dist/scanner/parse.js

@@ -1,8 +1,8 @@
 import { runWithConcurrency } from "./concurrency.js";
 import { runScanWorker } from "./worker.js";
 import { errorMessage } from "./result.js";
-const DEFAULT_MAX_FILE_WORKERS = 5;
-const DEFAULT_MAX_SCAN_WORKERS_PER_FILE = 5;
+const MAX_FILE_WORKERS = 5;
+const MAX_SCAN_WORKERS_PER_FILE = 5;
 const HARD_CAP = 8;
 const clamp = (n, fallback) => Math.min(HARD_CAP, Math.max(1, n ?? fallback));
 /**
@@ -13,35 +13,47 @@ const clamp = (n, fallback) => Math.min(HARD_CAP, Math.max(1, n ?? fallback));
  */
 export async function parsePhase(db, state, hooks) {
     await hooks.beforeParse?.(state);
-    const maxFile = clamp(state.options.maxFileWorkers, DEFAULT_MAX_FILE_WORKERS);
-    const maxChunk = clamp(state.options.maxScanWorkersPerFile, DEFAULT_MAX_SCAN_WORKERS_PER_FILE);
+    const maxFile = clamp(state.options.maxFileWorkers, MAX_FILE_WORKERS);
+    const maxChunk = clamp(state.options.maxScanWorkersPerFile, MAX_SCAN_WORKERS_PER_FILE);
     const fileGroups = state.decrypted
-        .map(file => ({
+        .map((file) => ({
         fileId: file.path,
         scannedFileId: file.scannedFileId,
-        chunks: state.chunks.filter(c => c.fileId === file.path),
+        chunks: state.chunks.filter((c) => c.fileId === file.path),
     }))
-        .filter(g => g.chunks.length > 0);
-    const fileTasks = fileGroups.map(group => () => {
-        const chunkTasks = group.chunks.map(chunk => () => runScanWorker({
+        .filter((g) => g.chunks.length > 0);
+    const fileTasks = fileGroups.map((group) => () => {
+        const chunkTasks = group.chunks.map((chunk) => () => runScanWorker({
             db,
             scanId: state.scanId,
             scannedFileId: group.scannedFileId,
             progress: state.progress,
             chunk,
+            signal: state.signal,
         }, hooks));
-        return runWithConcurrency(chunkTasks, maxChunk);
+        return runWithConcurrency(chunkTasks, maxChunk, state.signal);
     });
-    const settled = await runWithConcurrency(fileTasks, maxFile);
+    const settled = await runWithConcurrency(fileTasks, maxFile, state.signal);
     for (let i = 0; i < settled.length; i++) {
         const r = settled[i];
-        if (!r.ok)
-            state.errors.push({ phase: "parse", target: fileGroups[i].fileId, error: errorMessage(r.error) });
+        if (r && !r.ok)
+            state.errors.push({
+                phase: "parse",
+                target: fileGroups[i].fileId,
+                error: errorMessage(r.error),
+            });
     }
-    for (const file of state.decrypted) {
-        if (!file.scannedFileId)
+    // Only flip files to "scanned" for groups that actually completed. On abort
+    // the pool leaves later groups unclaimed (their settled slot is undefined);
+    // those rows stay `pending` so a future re-scan can pick them up. Partial
+    // transactions already committed during the run stay (scanner is DB-direct).
+    for (let i = 0; i < fileGroups.length; i++) {
+        if (!settled[i])
             continue;
-        db.prepare(`UPDATE scanned_files SET status = 'scanned', scanned_at = datetime('now') WHERE id = ?`).run(file.scannedFileId);
+        const sfId = fileGroups[i].scannedFileId;
+        if (!sfId)
+            continue;
+        db.prepare(`UPDATE scanned_files SET status = 'scanned', scanned_at = datetime('now') WHERE id = ?`).run(sfId);
     }
     await hooks.afterParse?.(state);
 }

package/dist/scanner/worker.d.ts

@@ -8,6 +8,7 @@ export interface ScanWorkerDeps {
     readonly scannedFileId: string | undefined;
     readonly progress: ScanProgress;
     readonly chunk: Chunk;
+    readonly signal: AbortSignal;
 }
 /**
  * Process one chunk: run the LLM scan agent over a single-page PDF blob with
@@ -15,5 +16,10 @@ export interface ScanWorkerDeps {
  * context. Agent's record_transactions / note_question calls write directly to
  * the DB; per-row ticks fan out via `progress.emit`. Failures land in the DB
  * as a `chunk_failed` question so the clarifier can pick them up.
+ *
+ * Cancellation entry point: the worker pool stops claiming new chunks when
+ * `signal` aborts; in-flight provider calls abort natively via the SDK and
+ * surface as a failed tryExecute outcome — we suppress the chunk_failed row
+ * in that case (see below) since cancellation isn't a real failure.
  */
 export declare function runScanWorker(deps: ScanWorkerDeps, hooks: ScanHooks): Promise<void>;

package/dist/scanner/worker.js

@@ -10,6 +10,11 @@ import { tryExecute } from "./result.js";
  * context. Agent's record_transactions / note_question calls write directly to
  * the DB; per-row ticks fan out via `progress.emit`. Failures land in the DB
  * as a `chunk_failed` question so the clarifier can pick them up.
+ *
+ * Cancellation entry point: the worker pool stops claiming new chunks when
+ * `signal` aborts; in-flight provider calls abort natively via the SDK and
+ * surface as a failed tryExecute outcome — we suppress the chunk_failed row
+ * in that case (see below) since cancellation isn't a real failure.
  */
 export async function runScanWorker(deps, hooks) {
     const workerId = `cw:${randomUUID()}`;
@@ -34,10 +39,16 @@ export async function runScanWorker(deps, hooks) {
             chunkId: deps.chunk.chunkId,
             progress: deps.progress,
         },
+        signal: deps.signal,
     }));
     hooks.onWorkerEnd?.(workerId, deps.chunk, outcome.ok);
-    if (!outcome.ok)
+    if (!outcome.ok) {
+        // A worker whose in-flight call was cancelled by Ctrl+C is not a real
+        // failure — don't pollute the questions table with chunk_failed rows.
+        if (deps.signal.aborted)
+            return;
         recordChunkFailure(deps, outcome.error);
+    }
 }
 function recordChunkFailure(deps, error) {
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plasalid",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "Plasalid — The Harness Layer for Personal Finance",
   "keywords": [
     "finance",