plasalid 0.7.9 → 0.8.1

package/dist/cli/ink/ScanDashboard.js

@@ -30,16 +30,18 @@ const COL = {
     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 })] }));
+    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, " (", info.providerName, "/", info.modelName, ")"] }));
 }
 function usePhase(controller) {
     const [phase, setPhase] = useState("parse");
@@ -79,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

@@ -6,26 +6,24 @@ import { config, saveConfig, getConfigPath, getPlasalidDir, getDataDir, } from "
 import { generateKey } from "../db/encryption.js";
 import { createContextTemplate } from "../ai/context.js";
 import { printLogo } from "./logo.js";
-const DEFAULT_ANTHROPIC_MODEL = "claude-sonnet-4-6";
-const DEFAULT_OPENAI_BASE_URL = "http://localhost:11434/v1";
+import { statusSpinner } from "./ux.js";
+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-2.5-pro",
+};
 function ensureDir(p) {
     if (!existsSync(p))
         mkdirSync(p, { recursive: true });
 }
-function readEnvDefaults() {
-    return {
-        anthropicKey: process.env.ANTHROPIC_API_KEY?.trim() || "",
-        userName: process.env.PLASALID_USER_NAME?.trim() || "",
-        openaiBaseURL: process.env.OPENAI_COMPATIBLE_BASE_URL?.trim() || "",
-        openaiKey: process.env.OPENAI_COMPATIBLE_API_KEY?.trim() || "",
-    };
-}
 function printBanner() {
     console.log("");
     printLogo();
     console.log("");
     console.log("Welcome to Plasalid. Let's get you set up — a few quick questions.");
     console.log("");
+    console.log(chalk.dim("Time to power up your engine — wire in an AI, pick a model, seal your vault."));
 }
 function printSummary(dataDir) {
     console.log("");
@@ -42,9 +40,10 @@ function printSummary(dataDir) {
     console.log(chalk.dim(`  Optional: ${chalk.cyan(`plasalid record "..."`)}${chalk.dim(" to record manual/undocumented transaction, balance, or account at any time.")}`));
 }
 /**
- * Wraps inquirer's list prompt with a blank line above and below, and inserts
- * a Separator(" ") row above the first choice so the question and the first
- * option don't crowd each other. Mirrors `makePromptUser` in `src/cli/ux.ts`.
+ * Each helper prints one leading blank line. Inquirer collapses the resolved
+ * prompt to a single line, so each new helper produces exactly one blank row
+ * between adjacent questions. passwordPrompt has no `default` because the
+ * masked-but-pre-filled state confuses "press Enter to keep".
  */
 async function listPrompt(opts) {
     console.log("");
@@ -53,134 +52,193 @@ async function listPrompt(opts) {
             type: "list",
             name: opts.name,
             message: opts.message,
-            choices: [new inquirer.Separator(" "), ...opts.choices],
+            choices: opts.choices,
             default: opts.default,
         },
     ]);
-    console.log("");
     return answer[opts.name];
 }
-async function promptUserName(env) {
-    const { userName } = await inquirer.prompt([
+async function inputPrompt(opts) {
+    console.log("");
+    const answer = await inquirer.prompt([
         {
             type: "input",
-            name: "userName",
-            message: "What should I call you? (Your name)",
-            default: env.userName || (config.userName === "User" ? "" : config.userName),
+            name: opts.name,
+            message: opts.message,
+            default: opts.default,
+            validate: opts.validate,
+        },
+    ]);
+    return String(answer[opts.name] ?? "").trim();
+}
+async function passwordPrompt(opts) {
+    console.log("");
+    const answer = await inquirer.prompt([
+        {
+            type: "password",
+            name: opts.name,
+            message: opts.message,
+            mask: "*",
+            validate: opts.validate,
         },
     ]);
-    return String(userName || "").trim();
+    return String(answer[opts.name] ?? "");
+}
+function savedModelFor(vendor) {
+    switch (vendor) {
+        case "anthropic":
+            return config.anthropicModel;
+        case "openai":
+            return config.openaiModel;
+        case "gemini":
+            return config.geminiModel;
+        case "openai-compat":
+            return config.openaiCompatModel;
+    }
+}
+async function promptUserName() {
+    return inputPrompt({
+        name: "userName",
+        message: "What should I call you? (Your name)",
+    });
 }
 async function promptProviderChoice() {
     return listPrompt({
-        name: "providerChoice",
+        name: "vendor",
         message: "Which AI provider would you like to use?",
         choices: [
-            { name: "Anthropic (Claude)", value: "anthropic" },
+            { name: "Anthropic", value: "anthropic" },
+            { name: "OpenAI", value: "openai" },
+            { name: "Google Gemini", value: "gemini" },
             {
-                name: "OpenAI compatible (OpenAI, LM Studio, vLLM, Ollama)",
-                value: "openai-compatible",
+                name: "OpenAI Compatible (LM Studio, vLLM, Ollama, other)",
+                value: "openai-compat",
             },
         ],
         default: "anthropic",
     });
 }
-async function promptAnthropicCredentials(env) {
-    const { key, model } = await inquirer.prompt([
-        {
-            type: "password",
-            name: "key",
-            message: "Paste your Anthropic API key (https://console.anthropic.com):",
-            mask: "*",
-            default: env.anthropicKey || config.anthropicKey || undefined,
-            validate: (v) => v.startsWith("sk-") ? true : "Enter a key starting with sk-...",
-        },
-        {
-            type: "input",
-            name: "model",
-            message: "Which Claude model?",
-            default: config.providerType === "anthropic" && config.model
-                ? config.model
-                : DEFAULT_ANTHROPIC_MODEL,
-        },
-    ]);
-    return {
-        anthropicKey: key,
-        model: model || DEFAULT_ANTHROPIC_MODEL,
-    };
+/**
+ * Model default: the value previously saved for this vendor, else its
+ * recommended flagship. openai-compat has none, so it starts blank and the
+ * required-non-empty validator catches blank submissions.
+ */
+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,
+        default: defaultValue || undefined,
+        validate: (v) => v.trim().length > 0 || "Required",
+    });
 }
-async function promptOpenAICompatCredentials(env) {
-    const { baseURL, apiKey, model } = await inquirer.prompt([
-        {
-            type: "input",
-            name: "baseURL",
-            message: "What's the base URL of your OpenAI-compatible server?",
-            default: env.openaiBaseURL ||
-                config.openaiCompatibleBaseURL ||
-                DEFAULT_OPENAI_BASE_URL,
-            validate: (v) => /^https?:\/\//.test(v) || "Must start with http:// or https://",
-        },
-        {
-            type: "password",
-            name: "apiKey",
-            message: "API key (leave blank if your server doesn't need one):",
-            mask: "*",
-            default: env.openaiKey || config.openaiCompatibleKey || undefined,
-        },
-        {
-            type: "input",
-            name: "model",
-            message: "Which model? (e.g. gpt-5, qwen3-coder:480b, deepseek-v3.1:671b)",
-            default: config.providerType === "openai-compatible" && config.model
-                ? config.model
-                : "",
-            validate: (v) => v.trim().length > 0 || "Required",
+/**
+ * Empty submit silently keeps the existing key when one is on file. Otherwise
+ * the validator rejects empty (or accepts empty when `optional`, e.g. local
+ * servers that need no auth).
+ */
+async function promptApiKey(opts) {
+    const hasExisting = opts.existing.length > 0;
+    const fresh = await passwordPrompt({
+        name: "key",
+        message: `${opts.label}:`,
+        validate: (v) => {
+            if (v === "" && (hasExisting || opts.optional))
+                return true;
+            if (opts.prefix && !v.startsWith(opts.prefix)) {
+                return `Enter a key starting with ${opts.prefix}...`;
+            }
+            if (v.length === 0)
+                return "Required";
+            return true;
         },
-    ]);
+    });
+    return fresh === "" && hasExisting ? opts.existing : fresh;
+}
+async function promptAnthropicCredentials() {
+    const anthropicKey = await promptApiKey({
+        label: "Paste your Anthropic API key (https://console.anthropic.com)",
+        existing: config.anthropicKey,
+        prefix: "sk-",
+    });
+    const anthropicModel = await promptModelInput("anthropic");
+    return { providerType: "anthropic", anthropicKey, anthropicModel };
+}
+async function promptOpenAICredentials() {
+    const openaiKey = await promptApiKey({
+        label: "Paste your OpenAI API key (https://platform.openai.com/api-keys)",
+        existing: config.openaiKey,
+        prefix: "sk-",
+    });
+    const openaiModel = await promptModelInput("openai");
+    return { providerType: "openai", openaiKey, openaiModel };
+}
+async function promptGeminiCredentials() {
+    const geminiKey = await promptApiKey({
+        label: "Paste your Google AI Studio API key (https://aistudio.google.com/apikey)",
+        existing: config.geminiKey,
+    });
+    const geminiModel = await promptModelInput("gemini");
+    return { providerType: "gemini", geminiKey, geminiModel };
+}
+async function promptOpenAICompatCredentials() {
+    const baseURLDefault = config.providerType === "openai-compat" && config.openaiCompatBaseURL
+        ? config.openaiCompatBaseURL
+        : DEFAULT_LOCAL_OPENAI_BASE_URL;
+    const openaiCompatBaseURL = await inputPrompt({
+        name: "baseURL",
+        message: "What's the base URL of your LLM server?",
+        default: baseURLDefault,
+        validate: (v) => /^https?:\/\//.test(v) || "Must start with http:// or https://",
+    });
+    const openaiCompatKey = await promptApiKey({
+        label: "Paste your LLM server API key",
+        existing: config.openaiCompatKey,
+        optional: true,
+    });
+    const openaiCompatModel = await promptModelInput("openai-compat");
     return {
-        openaiCompatibleBaseURL: baseURL,
-        openaiCompatibleKey: apiKey || "",
-        model: model.trim(),
+        providerType: "openai-compat",
+        openaiCompatBaseURL,
+        openaiCompatKey,
+        openaiCompatModel,
     };
 }
-async function promptCredentials(provider, env) {
-    return provider === "openai-compatible"
-        ? promptOpenAICompatCredentials(env)
-        : promptAnthropicCredentials(env);
-}
-async function ensureEncryptionKey() {
-    if (config.dbEncryptionKey) {
-        console.log("");
-        console.log(chalk.dim("Using the encryption key already on file."));
-        return;
+async function promptCredentials(vendor) {
+    switch (vendor) {
+        case "anthropic":
+            return promptAnthropicCredentials();
+        case "openai":
+            return promptOpenAICredentials();
+        case "gemini":
+            return promptGeminiCredentials();
+        case "openai-compat":
+            return promptOpenAICompatCredentials();
     }
-    const mode = await listPrompt({
-        name: "mode",
-        message: "Encrypt the local database? (recommended)",
-        choices: [
-            { name: "Yes (generate a strong key automatically)", value: "auto" },
-            { name: "Yes (I'll provide my own passphrase)", value: "manual" },
-            { name: "No (store plaintext)", value: "none" },
-        ],
-        default: "auto",
-    });
-    if (mode === "auto") {
+}
+/**
+ * Encryption key is auto-generated. The work is microseconds,
+ * but the banner just told the user to "seal your vault" — hold the spinner
+ * so the step is visible.
+ */
+async function sealVault() {
+    const spinner = statusSpinner("Sealing your vault…");
+    const start = Date.now();
+    if (!config.dbEncryptionKey) {
         saveConfig({ dbEncryptionKey: generateKey() });
-        console.log(chalk.dim(`Generated a new DB encryption key and saved it to ${getConfigPath()}.`));
-        return;
-    }
-    if (mode === "manual") {
-        const { key: passphrase } = await inquirer.prompt([
-            {
-                type: "password",
-                name: "key",
-                message: "Choose a passphrase (at least 8 characters):",
-                mask: "*",
-                validate: (v) => v.length >= 8 || "Use at least 8 characters.",
-            },
-        ]);
-        saveConfig({ dbEncryptionKey: passphrase });
     }
+    const remaining = 600 - (Date.now() - start);
+    if (remaining > 0)
+        await new Promise((r) => setTimeout(r, remaining));
+    spinner.succeed("Vault sealed.");
 }
 function finalizeDataDir(userName) {
     const dataDir = config.dataDir || resolve(getPlasalidDir(), "data");
@@ -192,16 +250,14 @@ function finalizeDataDir(userName) {
 export async function runSetup() {
     printBanner();
     ensureDir(getPlasalidDir());
-    const env = readEnvDefaults();
-    const userName = await promptUserName(env);
-    const provider = await promptProviderChoice();
-    const credentials = await promptCredentials(provider, env);
+    const userName = await promptUserName();
+    const vendor = await promptProviderChoice();
+    const credentials = await promptCredentials(vendor);
     saveConfig({
-        providerType: provider,
         userName: userName || "User",
         ...credentials,
     });
-    await ensureEncryptionKey();
+    await sealVault();
     const dataDir = finalizeDataDir(userName || "User");
     printSummary(dataDir);
 }

package/dist/config.d.ts

@@ -1,10 +1,15 @@
 import "dotenv/config";
 export interface PlasalidConfig {
+    providerType: "anthropic" | "openai" | "gemini" | "openai-compat";
     anthropicKey: string;
-    model: string;
-    providerType: "anthropic" | "openai-compatible";
-    openaiCompatibleKey: string;
-    openaiCompatibleBaseURL: string;
+    anthropicModel: string;
+    openaiKey: string;
+    openaiModel: string;
+    geminiKey: string;
+    geminiModel: string;
+    openaiCompatKey: string;
+    openaiCompatBaseURL: string;
+    openaiCompatModel: string;
     displayLocale: string;
     displayCurrency: string;
     dbPath: string;
@@ -18,4 +23,5 @@ export declare function getConfigPath(): string;
 export declare function getDataDir(): string;
 export declare const config: PlasalidConfig;
 export declare function isConfigured(): boolean;
+export declare function getActiveModel(): string;
 export declare function saveConfig(partial: Partial<PlasalidConfig>): void;

package/dist/config.js

@@ -1,5 +1,5 @@
 import "dotenv/config";
-import { readFileSync, writeFileSync, existsSync, mkdirSync, chmodSync } from "fs";
+import { readFileSync, writeFileSync, existsSync, mkdirSync, chmodSync, } from "fs";
 import { resolve } from "path";
 import { homedir } from "os";
 const PLASALID_DIR = resolve(homedir(), ".plasalid");
@@ -28,28 +28,55 @@ function buildConfig() {
     // Precedence: env > file > default. Env is checked first so a shell-exported
     // override always wins over whatever is in ~/.plasalid/config.json.
     return {
-        anthropicKey: process.env.ANTHROPIC_API_KEY || file.anthropicKey || "",
-        model: process.env.PLASALID_MODEL || file.model || "claude-sonnet-4-6",
         providerType: process.env.PLASALID_PROVIDER ||
             file.providerType ||
             "anthropic",
-        openaiCompatibleKey: process.env.OPENAI_COMPATIBLE_API_KEY || file.openaiCompatibleKey || "",
-        openaiCompatibleBaseURL: process.env.OPENAI_COMPATIBLE_BASE_URL || file.openaiCompatibleBaseURL || "",
+        anthropicKey: process.env.ANTHROPIC_API_KEY || file.anthropicKey || "",
+        anthropicModel: process.env.ANTHROPIC_MODEL || file.anthropicModel || "claude-sonnet-4-6",
+        openaiKey: process.env.OPENAI_API_KEY || file.openaiKey || "",
+        openaiModel: process.env.OPENAI_MODEL || file.openaiModel || "gpt-5.4-mini",
+        openaiCompatKey: process.env.OPENAI_COMPAT_API_KEY || file.openaiCompatKey || "",
+        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-2.5-pro",
         displayLocale: file.displayLocale || "th-TH",
         displayCurrency: file.displayCurrency || "THB",
-        dbPath: process.env.PLASALID_DB_PATH || file.dbPath || resolve(PLASALID_DIR, "db.sqlite"),
+        dbPath: process.env.PLASALID_DB_PATH ||
+            file.dbPath ||
+            resolve(PLASALID_DIR, "db.sqlite"),
         dbEncryptionKey: process.env.PLASALID_DB_ENCRYPTION_KEY || file.dbEncryptionKey || "",
-        dataDir: process.env.PLASALID_DATA_DIR || file.dataDir || resolve(PLASALID_DIR, "data"),
+        dataDir: process.env.PLASALID_DATA_DIR ||
+            file.dataDir ||
+            resolve(PLASALID_DIR, "data"),
         userName: file.userName || "User",
         thinkingBudget: file.thinkingBudget ?? 8000,
     };
 }
 export const config = buildConfig();
 export function isConfigured() {
-    if (config.providerType === "openai-compatible") {
-        return !!config.openaiCompatibleBaseURL;
+    switch (config.providerType) {
+        case "anthropic":
+            return !!config.anthropicKey;
+        case "openai":
+            return !!config.openaiKey;
+        case "gemini":
+            return !!config.geminiKey;
+        case "openai-compat":
+            return !!config.openaiCompatBaseURL;
+    }
+}
+export function getActiveModel() {
+    switch (config.providerType) {
+        case "anthropic":
+            return config.anthropicModel;
+        case "openai":
+            return config.openaiModel;
+        case "gemini":
+            return config.geminiModel;
+        case "openai-compat":
+            return config.openaiCompatModel;
     }
-    return !!config.anthropicKey;
 }
 export function saveConfig(partial) {
     const configPath = getConfigPath();
@@ -57,7 +84,9 @@ export function saveConfig(partial) {
         mkdirSync(PLASALID_DIR, { recursive: true });
     const existing = loadFileConfig();
     const merged = { ...existing, ...partial };
-    writeFileSync(configPath, JSON.stringify(merged, null, 2) + "\n", { mode: 0o600 });
+    writeFileSync(configPath, JSON.stringify(merged, null, 2) + "\n", {
+        mode: 0o600,
+    });
     try {
         chmodSync(configPath, 0o600);
     }

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;