@wirecat/cli-core 0.428.0 → 0.430.0

package/CHANGELOG.md

@@ -7,6 +7,23 @@ shape of this file.
 
 ## Unreleased
 
+## 0.430.0 — 25.10.2026
+
+### Added
+
+- **Run records for a CLI with its own commander program** (`/cli`). `recordRuns(program, options)` gives a `startCli` tool WC-LIFE-15 in one call: `--record` and `--no-record`, a failed run for every failed command — a usage error before any action included, named by its command words and never an argument — and a run of every command when the flag or the saved `record` asks. `providerEvent(event)` and `providerRequest(operation)` put a provider call's operation, status and duration into the current command's run from anywhere in the program. `commandRuns(options)` keeps one command's run from a tool's own hooks under `run()`, and `runSettings(flag, saved)` is the rule both follow. zoom-cli, drive-cli and cli-memo replace their own copies with it. A run with no profile now leaves `profile` out rather than writing `""`.
+
+## 0.429.0 — 25.10.2026
+
+### Added
+
+- **`@wirecat/cli-core/cli/start` gives a bin `startCli` without the rest of `./cli`**, and **a bare `--version` or `-V` is answered before the program loads**. Importing `./cli` for `startCli` loaded about 1,000 files before the program even ran; `./cli/start` loads about 50 (`check:dist` keeps it under 80). The version is `app.version` and a newline on stdout, exit 0 — what Commander printed. Nothing else runs for it: no SQLite swap, no crash handler, and no notice a tool's `run` prints. `--version` with any other word (`--version --json`, `personal --version`) goes through the program as before. `startCli` and `run()` load the first-run questions, the store and the consent prompt only when a command asks them: the program module alone now loads about 320 files, not 850 (the `./cli` barrel a CLI imports still loads them all).
+- **`store reset --dry-run` lists what a reset would empty and deletes nothing**: the store's files, their bytes,
+  every data table with its row count (search indexes are left out: they are rebuilt from those tables), whether a
+  backup comes first, and `in_use` — whether a serve or another process has the file open now, which the real reset
+  refuses (`null` where the system cannot say). It reads without a write lock, so it answers while a sync runs, and
+  it runs under `<PREFIX>_READ_ONLY`. A desktop app shows the list in its confirmation dialog.
+
 ## 0.428.0 — 25.10.2026
 
 ### Changed — may break callers

package/dist/cli/command-runs.d.ts

@@ -0,0 +1,64 @@
+import { type RenderFormat, type Streams } from "@wirecat/cli-base";
+import type { Command } from "commander";
+import type { AppIdentity } from "../ports/app.js";
+import type { RequestEvent } from "../runs/events.js";
+/** What the owner saved: `record` and `keep_runs_for_days`, read from the CLI's own config. */
+export interface SavedRunSettings {
+    record?: boolean | undefined;
+    keepRunsForDays?: number | undefined;
+}
+export interface RunSettings {
+    record: boolean;
+    keepFailedRuns: boolean;
+    keepRunsForDays: number;
+}
+/** `--record`/`--no-record` first, then the config; a failure is kept unless either says no (WC-LIFE-15). */
+export declare const runSettings: (flag: boolean | undefined, saved?: SavedRunSettings) => RunSettings;
+export interface CommandRunOptions {
+    app: AppIdentity;
+    /** The owner's saved choice. One that throws — a config that will not load — leaves the defaults. */
+    settings: () => SavedRunSettings;
+    /**
+     * The profile the command runs for; one that throws or is empty leaves the run without one. Given only by a CLI
+     * whose first word may be a profile, so a failure before any command skips that word when naming the run.
+     */
+    profile?: () => string | undefined;
+    /** An agent's run is named `mcp <command>`. Read from the program's environment when left out. */
+    agent?: boolean;
+    /** The data stream's format, which the warning about an unwritable run follows; `--json`/`--jsonl` when left out. */
+    format?: () => RenderFormat;
+    /** What a failed run keeps of the error: cli-memo turns a Commander or Valibot error into a CLI error first. */
+    recognise?: (error: unknown) => unknown;
+    env?: NodeJS.ProcessEnv;
+    streams?: Streams;
+}
+/** One command's run at a time, for a CLI that starts and ends it from its own hooks (zoom-cli under `run()`). */
+export interface CommandRuns {
+    start(action: Command): void;
+    succeed(): Promise<void>;
+    fail(error: unknown): Promise<void>;
+    /** The id the command's run has, kept or not, so its answer can name it. */
+    runId(): string | undefined;
+    events(event: RequestEvent): void;
+}
+export declare const commandRuns: (options: CommandRunOptions) => CommandRuns;
+/** For a provider client far from the program: the event lands in the current command's run, or nowhere. */
+export declare const providerEvent: (event: RequestEvent) => void;
+/**
+ * Times one provider call under a fixed operation name — nothing the call carries goes into the run. The returned
+ * function ends it; an `error` or an `errorCode` makes it a failed one.
+ */
+export declare const providerRequest: (operation: string, sink?: (event: RequestEvent) => void) => ({ status, error, errorCode }?: {
+    status?: number;
+    error?: unknown;
+    errorCode?: string;
+}) => void;
+/**
+ * WC-LIFE-15 for a CLI with its own commander program (`startCli`, not `run()`): adds `--record` and `--no-record`,
+ * keeps every failed command as a run — a usage error before any action too — and every command when recording is
+ * on. Call it after the program's other `parseAsync` wrappers, so its own is the outermost and sees how the parse
+ * really ended; a refusal in an earlier `preAction` hook is then kept under the words read from the line.
+ */
+export declare const recordRuns: (program: Command, options: CommandRunOptions & {
+    content: string;
+}) => void;

package/dist/cli/command-runs.js

@@ -0,0 +1,171 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { isCliError } from "@wirecat/cli-base";
+import { startRecording, wasSettled } from "../runs/recording.js";
+import { KEEP_RUNS_FOR_DAYS } from "../runs/run.js";
+import { environmentOf } from "./context.js";
+/** `--record`/`--no-record` first, then the config; a failure is kept unless either says no (WC-LIFE-15). */
+export const runSettings = (flag, saved = {}) => {
+    const record = flag ?? saved.record ?? false;
+    return {
+        record,
+        keepFailedRuns: record || (flag !== false && saved.record !== false),
+        keepRunsForDays: saved.keepRunsForDays ?? KEEP_RUNS_FOR_DAYS,
+    };
+};
+const SKIPPED = new Set(["runs", "help"]);
+const pathOf = (command) => {
+    const words = [];
+    for (let at = command; at?.parent; at = at.parent)
+        words.unshift(at.name());
+    return words;
+};
+const tracker = (options) => {
+    let recording;
+    const open = (program, words, flag, format) => {
+        recording = undefined;
+        // Reading the log is not worth a run of its own.
+        if (SKIPPED.has(words[0] ?? ""))
+            return;
+        const environment = environmentOf(program);
+        let saved = {};
+        try {
+            saved = options.settings();
+        }
+        catch { }
+        let profile;
+        try {
+            profile = options.profile?.() || undefined;
+        }
+        catch { }
+        const settings = runSettings(flag, saved);
+        const agent = options.agent ?? environment.agent !== undefined;
+        const streams = options.streams ?? environment.streams;
+        const env = options.env ?? environment.env;
+        recording = startRecording({
+            app: options.app,
+            command: `${agent ? "mcp " : ""}${words.join(" ") || options.app.command}`,
+            ...(profile === undefined ? {} : { profile }),
+            record: settings.record,
+            keepFailed: settings.keepFailedRuns,
+            keepDays: settings.keepRunsForDays,
+            trace: false,
+            format,
+            ...(streams ? { streams } : {}),
+            ...(env ? { env } : {}),
+        });
+    };
+    const finish = () => {
+        const done = recording;
+        recording = undefined;
+        return done;
+    };
+    return {
+        start(action) {
+            const flags = action.optsWithGlobals();
+            const json = (flags.json !== undefined && flags.json !== false) || Boolean(flags.jsonl);
+            open(action, pathOf(action), flags.record, options.format?.() ?? (json ? "json" : "pretty"));
+        },
+        async succeed() {
+            await finish()?.succeed();
+        },
+        async fail(error) {
+            await finish()?.fail(options.recognise ? options.recognise(error) : error);
+        },
+        runId: () => recording?.runId,
+        events: (event) => recording?.events(event),
+        open,
+    };
+};
+export const commandRuns = (options) => tracker(options);
+const parses = new AsyncLocalStorage();
+/** For a provider client far from the program: the event lands in the current command's run, or nowhere. */
+export const providerEvent = (event) => parses.getStore()?.runs.events(event);
+/**
+ * Times one provider call under a fixed operation name — nothing the call carries goes into the run. The returned
+ * function ends it; an `error` or an `errorCode` makes it a failed one.
+ */
+export const providerRequest = (operation, sink = providerEvent) => {
+    sink({ event: "request", operation });
+    const started = performance.now();
+    return ({ status, error, errorCode } = {}) => {
+        const failed = error !== undefined || errorCode !== undefined;
+        sink({
+            event: "response",
+            operation,
+            ...(status === undefined ? {} : { status }),
+            durationMs: Math.round(performance.now() - started),
+            outcome: failed ? "error" : "ok",
+            ...(failed ? { errorCode: errorCode ?? (isCliError(error) ? error.code : "provider_error") } : {}),
+        });
+    };
+};
+/** `files list` from `files list abc --limit 5`: command words only, never an argument. */
+const pathFromArgs = (program, args, profileWord) => {
+    const words = [];
+    let at = program;
+    let skipped = !profileWord;
+    for (const arg of args) {
+        if (arg.startsWith("-"))
+            continue;
+        const next = at.commands.find((one) => one.name() === arg || one.aliases().includes(arg));
+        if (next) {
+            words.push(arg);
+            at = next;
+        }
+        else if (words.length === 0 && !skipped)
+            skipped = true;
+        else
+            break;
+    }
+    return words;
+};
+const isHelpExit = (error) => {
+    const { code, exitCode } = (error ?? {});
+    return typeof code === "string" && code.startsWith("commander.") && (exitCode === 0 || code === "commander.help");
+};
+/**
+ * WC-LIFE-15 for a CLI with its own commander program (`startCli`, not `run()`): adds `--record` and `--no-record`,
+ * keeps every failed command as a run — a usage error before any action too — and every command when recording is
+ * on. Call it after the program's other `parseAsync` wrappers, so its own is the outermost and sees how the parse
+ * really ended; a refusal in an earlier `preAction` hook is then kept under the words read from the line.
+ */
+export const recordRuns = (program, options) => {
+    program
+        .option("--record", `keep this run — ids and timings, never ${options.content}`)
+        .option("--no-record", "do not keep this run, even if it fails");
+    program.hook("preAction", (_root, action) => {
+        const parse = parses.getStore();
+        if (!parse)
+            return;
+        parse.started = true;
+        parse.runs.start(action);
+    });
+    const parseAsync = program.parseAsync.bind(program);
+    program.parseAsync = (argv, settings) => {
+        const parse = { runs: tracker(options), started: false };
+        return parses.run(parse, async () => {
+            try {
+                const parsed = await parseAsync(argv, settings);
+                await parse.runs.succeed();
+                return parsed;
+            }
+            catch (error) {
+                if (!isHelpExit(error) && !wasSettled(error)) {
+                    try {
+                        if (!parse.started) {
+                            const args = settings?.from === "user" ? (argv ?? []) : (argv ?? process.argv).slice(2);
+                            const flag = args.includes("--no-record") ? false : args.includes("--record") ? true : undefined;
+                            const json = args.some((arg) => arg === "--json" || arg.startsWith("--json=") || arg === "--jsonl");
+                            const words = pathFromArgs(program, args, options.profile !== undefined);
+                            const format = options.format?.() ?? (json ? "json" : "pretty");
+                            parse.runs.open(program, words, flag, format);
+                        }
+                        await parse.runs.fail(error);
+                    }
+                    catch { }
+                }
+                throw error;
+            }
+        });
+    };
+};

package/dist/cli/entry.d.ts

@@ -2,6 +2,7 @@ import { type ChildProcess, type SpawnOptions } from "node:child_process";
 import type { ErrorReason } from "@wirecat/cli-base/standards";
 import type { Command } from "commander";
 import { type AppIdentity } from "../ports/app.js";
+export type { AppIdentity };
 /** What `startCli` hands the CLI's own program: the process, wired once. */
 export interface EntryContext {
     /** `process.argv` without the runtime and the script. */

package/dist/cli/entry.js

@@ -1,10 +1,8 @@
 import { spawn } from "node:child_process";
 import { CliError, catchCrashes } from "@wirecat/cli-base";
-import { readOnlyLockOf } from "../ports/app.js";
+import { envName, readOnlyLockOf } from "../ports/app.js";
 import { ensureSqlite } from "../sqlite-runtime.js";
-import { readSecret } from "../terminal/prompt.js";
-import { commandPathOf } from "./command-contract.js";
-import { setupAtStart } from "./first-run.js";
+import { logVersion } from "./argv-log.js";
 const processIo = () => ({
     argv: process.argv,
     env: process.env,
@@ -26,6 +24,8 @@ const processIo = () => ({
 export const startCli = async (entry) => {
     const io = { ...processIo(), ...entry.io };
     const args = io.argv.slice(2);
+    if (args.length === 1 && (args[0] === "--version" || args[0] === "-V"))
+        return printVersion(entry.app, io);
     const tty = io.stdout.isTTY === true;
     const release = catchCrashes({
         cli: entry.app.command,
@@ -62,6 +62,10 @@ export const startCli = async (entry) => {
             // The first-run questions write the shared config; a dry run writes nothing.
             if (command.optsWithGlobals().dryRun === true)
                 return;
+            const [{ setupAtStart }, { commandPathOf }] = await Promise.all([
+                import("./first-run.js"),
+                import("./command-contract.js"),
+            ]);
             await setupAtStart({
                 command: entry.app.command,
                 env: io.env,
@@ -75,6 +79,7 @@ export const startCli = async (entry) => {
         ask: async (question, command) => {
             if (headless(command) || io.stdin.isTTY !== true)
                 return false;
+            const { readSecret } = await import("../terminal/prompt.js");
             const answer = await readSecret(`${question} [y/N] `, {
                 input: io.stdin,
                 output: io.stderr,
@@ -112,6 +117,16 @@ export const startCli = async (entry) => {
     else if (code !== undefined)
         io.setExitCode(code);
 };
+/**
+ * Answered before the program loads, which is most of a start: an agent asks for the version to learn whether the
+ * tool is there at all. Only the bare flag — anything else on the line goes through the program as before.
+ */
+const printVersion = (app, io) => {
+    const argvLog = io.env[envName(app, "TEST_ARGV_LOG")];
+    if (argvLog)
+        logVersion(argvLog);
+    io.stdout.write(`${app.version}\n`);
+};
 /** Help and the version were printed already; help for a missing command is a usage mistake, as in `run()`. */
 const commanderExit = (error) => {
     if (!(error instanceof Error))

package/dist/cli/first-run.js

@@ -4,13 +4,8 @@ import { delimiter, join } from "node:path";
 import { installerOf, updateCommand } from "@wirecat/cli-base/update";
 import { LANGUAGES } from "../search/languages.js";
 import { DEFAULT_STEMMERS } from "../search/stem.js";
-import { openCache } from "../store/open.js";
 import { storePath } from "../store/path.js";
 import { sharedConfigPath } from "../store/shared-config.js";
-import { openStore } from "../store/store.js";
-import { readSecret } from "../terminal/prompt.js";
-import { WIRECAT_TOOLS } from "./help/first-screen.js";
-import { buildStems } from "./messenger/store-maintenance-command.js";
 import { QUESTIONS, readSetupAnswers, unanswered, writeSetupAnswers, } from "./setup-answers.js";
 /** Commands that run without first-run questions: they serve agents, help, or open the store themselves. */
 const SKIPPED = new Set(["help", "guide", "completion", "mcp", "serve", "server", "update", "store"]);
@@ -86,6 +81,8 @@ const suggested = (env, contentLanguages) => {
     return (own.length ? own : LANGUAGES.filter(({ code }) => code === "en" || code === system)).map(({ name }) => name);
 };
 const askLanguages = async ({ command, env, io, contentLanguages }) => {
+    // The store and its maintenance are most of cli-core; every command runs this file, few ever ask.
+    const { openStore } = await import("../store/store.js");
     const store = await openStore({ env });
     let rebuild = false;
     try {
@@ -117,6 +114,10 @@ const askLanguages = async ({ command, env, io, contentLanguages }) => {
     }
     if (!rebuild)
         return;
+    const [{ openCache }, { buildStems }] = await Promise.all([
+        import("../store/open.js"),
+        import("./messenger/store-maintenance-command.js"),
+    ]);
     const database = await openCache(storePath(env));
     try {
         buildStems(database, (note) => io.say(`  ${note}`), { force: true });
@@ -128,6 +129,7 @@ const askLanguages = async ({ command, env, io, contentLanguages }) => {
 const askTools = async (run) => {
     const { command, env, io } = run;
     const installed = run.installed ?? ((name) => onPath(name, env));
+    const { WIRECAT_TOOLS } = await import("./help/first-screen.js");
     const others = WIRECAT_TOOLS.filter((tool) => tool.command !== command);
     const missing = others.filter((tool) => !installed(tool.command));
     io.say("Other WireCat tools — they share this store, so one search finds everything:");
@@ -213,7 +215,7 @@ export const setupAtStart = async (start) => {
         contentLanguages: start.contentLanguages,
         all: start.path[0] === "setup",
         io: {
-            ask: (prompt) => readSecret(prompt, { input, echo: true }),
+            ask: async (prompt) => (await import("../terminal/prompt.js")).readSecret(prompt, { input, echo: true }),
             say: (text) => process.stderr.write(`${text}\n`),
         },
     }).catch((error) => {

package/dist/cli/index.d.ts

@@ -50,6 +50,7 @@ export { BotTokenStore, type BotTokenStoreOptions } from "./bot/token.js";
 export { PressLog, UpdatesCursor } from "./bot/updates.js";
 export type { CommandAvailability, DiscoveredCommand } from "./command-availability.js";
 export { commandContract, type JsonSchema, SCHEMA_DIALECT } from "./command-contract.js";
+export { type CommandRunOptions, type CommandRuns, commandRuns, providerEvent, providerRequest, type RunSettings, recordRuns, runSettings, type SavedRunSettings, } from "./command-runs.js";
 export { CONTRACT } from "./commands-command.js";
 export { refuseUnknownKey } from "./config-command.js";
 export { type ConfigIssue, type ConfigIssueKind, checkConfigText, issueMessage } from "./config-issues.js";

package/dist/cli/index.js

@@ -43,6 +43,7 @@ export { botFiles, botsDirectory, ChatRegistry, registryProfiles } from "./bot/r
 export { BotTokenStore } from "./bot/token.js";
 export { PressLog, UpdatesCursor } from "./bot/updates.js";
 export { commandContract, SCHEMA_DIALECT } from "./command-contract.js";
+export { commandRuns, providerEvent, providerRequest, recordRuns, runSettings, } from "./command-runs.js";
 export { CONTRACT } from "./commands-command.js";
 export { refuseUnknownKey } from "./config-command.js";
 export { checkConfigText, issueMessage } from "./config-issues.js";

package/dist/cli/messenger/store-maintenance-command.js

@@ -12,7 +12,7 @@ import { migrate } from "../../store/migrations.js";
 import { openCache } from "../../store/open.js";
 import { storePath } from "../../store/path.js";
 import { deleteCopy, repairStore } from "../../store/repair.js";
-import { drainNoteIndex, fillSearchIndex, fillStems, involvementStoreOver, noteIndexState, openStore, orphanPointers, pendingNormalization, resetAttachmentWords, resetNoteIndex, resetSearchIndex, resetStems, searchIndexState, stemmerCache, stemsState, } from "../../store/store.js";
+import { drainNoteIndex, fillSearchIndex, fillStems, involvementStoreOver, noteIndexState, openSqlite, openStore, orphanPointers, pendingNormalization, resetAttachmentWords, resetNoteIndex, resetSearchIndex, resetStems, searchIndexState, stemmerCache, stemsState, } from "../../store/store.js";
 import { environmentOf, outputFor } from "../context.js";
 import { destroysNothing, LOCAL_READ, LOCAL_WRITE } from "../effects.js";
 import { itemOf, renderAnswer, snakeKeys } from "../envelope.js";
@@ -45,6 +45,16 @@ const reading = async (path, read) => {
         database.close();
     }
 };
+/** For a command that only reads: the connection refuses writes, and opening sets no journal mode. */
+const readingOnly = async (path, read) => {
+    const { database } = await openSqlite(path, { readOnly: true });
+    try {
+        return read(database);
+    }
+    finally {
+        database.close();
+    }
+};
 /** `doctor`'s short summary of the store. Must answer for a broken file, so an error is a field. */
 export const storeSummary = async (env) => {
     const path = storePath(env);
@@ -630,22 +640,30 @@ const quiesce = async (path, messenger, then, warn, waitMs = STORE_LOCK_WAIT_MS)
     }
 };
 /**
- * For a store this build cannot migrate: a backup beside it, then an empty store at this build's
- * schema. The backup is made before anything is deleted, and its path is said before the delete.
+ * For a store this build cannot migrate, or one the owner wants empty: a backup beside it, then an empty
+ * store at this build's schema. The backup is made before anything is deleted, and its path is said before
+ * the delete. A new file rather than `DELETE FROM` every table: deleted rows would stay readable in free
+ * pages until a VACUUM, and every table comes back in this build's shape.
  */
 const resetCommand = (messenger) => annotate(new Command("reset"), { output: { entity: "store_reset" }, effects: LOCAL_WRITE })
     .summary("back up the local archive and replace it with an empty one")
     .description("back the store up beside itself, then delete it and start an empty one at this build's schema; asks first, or --yes")
     .option("--no-backup", "delete the store without backing it up first")
-    .action(async function ({ backup: keep }) {
+    .option("--dry-run", "list every table it would empty, with its rows, and delete nothing")
+    .action(async function ({ backup: keep, dryRun }) {
     const { renderer } = outputFor(this);
     const { command } = messenger.app;
-    const path = storePath(environmentOf(this).env ?? process.env);
+    const env = environmentOf(this).env ?? process.env;
+    const path = storePath(env);
     if (!existsSync(path)) {
         result(this, { path, exists: false, reset: false });
         renderer.note(`no store at ${path} — nothing to reset; the first \`${command}\` command that reads a chat creates it`);
         return;
     }
+    if (dryRun) {
+        result(this, await resetPreview(path, messenger, env, keep));
+        return;
+    }
     refuseWhileServing(this, messenger);
     if (this.optsWithGlobals().yes !== true) {
         const what = `this deletes the store at ${path} and starts an empty one, ${keep ? "after a backup beside it" : "with no backup"}`;
@@ -674,7 +692,7 @@ const resetCommand = (messenger) => annotate(new Command("reset"), { output: { e
         });
         renderer.note(`backed the store up to ${backup}`);
     }
-    for (const suffix of ["", "-wal", "-shm"])
+    for (const suffix of STORE_PARTS)
         rmSync(`${path}${suffix}`, { force: true });
     await (await openStore({ path, command })).close();
     const schema = await reading(path, (database) => schemaOf(database).version);
@@ -683,5 +701,43 @@ const resetCommand = (messenger) => annotate(new Command("reset"), { output: { e
         ? `the store is empty at schema ${schema}; \`${command} store restore ${backup}\` puts the old one back once a build can read it`
         : `the store is empty at schema ${schema}; there is no backup`);
 });
+const STORE_PARTS = ["", "-wal", "-shm"];
+/**
+ * What a reset would delete, read without a write lock so it answers while a sync runs. `in_use` is what the
+ * real run would refuse over now; `null` where this system cannot say who has the file open.
+ */
+const resetPreview = async (path, messenger, env, keep) => {
+    const files = STORE_PARTS.map((suffix) => `${path}${suffix}`).filter((file) => existsSync(file));
+    const holders = holdersOf(files.map((file) => realpathSync(file)));
+    const serving = servingProfiles(messenger.app, env).length > 0;
+    const read = await readingOnly(path, (database) => ({
+        schema: schemaOf(database).version,
+        tables: emptiedTables(database),
+    }));
+    return {
+        path,
+        exists: true,
+        reset: false,
+        dryRun: true,
+        files,
+        bytes: files.reduce((sum, file) => sum + bytesOf(file), 0),
+        schema: read.schema,
+        tables: read.tables,
+        backupFirst: keep,
+        inUse: serving || (holders === undefined ? null : holders.length > 0),
+    };
+};
+/** The tables that hold data; a search index and its shadow tables are rebuilt from them, so they are left out. */
+const emptiedTables = (database) => {
+    const all = database
+        .prepare("SELECT name, sql FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' ORDER BY name")
+        .all()
+        .map((row) => ({ name: String(row.name), virtual: /^\s*CREATE\s+VIRTUAL/i.test(String(row.sql)) }));
+    const indexes = all.filter((table) => table.virtual).map((table) => `${table.name}_`);
+    return all
+        .filter((table) => !table.virtual && table.name !== "schema_migrations")
+        .filter((table) => !indexes.some((prefix) => table.name.startsWith(prefix)))
+        .map((table) => ({ name: table.name, rows: count(database, `"${table.name}"`) }));
+};
 const isoOf = (value) => new Date(Number(value)).toISOString();
 const messageOf = (error) => (error instanceof Error ? error.message : String(error));

package/dist/cli/shared-command-exports.d.ts

@@ -4,8 +4,8 @@ export declare const generatedApiCommand: (api: import("./bot/api.js").ApiComman
 export declare const botCommand: (bot: import("./index.js").BotMessenger) => import("commander").Command;
 export declare const botMcpCommand: (bot: import("./index.js").BotMessenger) => import("commander").Command;
 export declare const botMessagesCommand: (bot: import("./index.js").BotMessenger) => import("commander").Command;
-export declare const commandsCommand: (app: import("./index.js").AppIdentity) => import("commander").Command;
-export declare const configCommand: (app: import("./index.js").AppIdentity, config: {
+export declare const commandsCommand: (app: import("./entry.js").AppIdentity) => import("commander").Command;
+export declare const configCommand: (app: import("./entry.js").AppIdentity, config: {
     resolveSettings: (flags?: import("./settings.js").GlobalFlags, options?: import("./settings.js").ResolveOptions) => import("./settings.js").Settings & object;
     configuredProfiles: (options?: import("./settings.js").ResolveOptions) => string[];
     changeSetting: (path: string, { profile, setting, value, kind, root, }: {
@@ -172,7 +172,7 @@ export declare const configCommand: (app: import("./index.js").AppIdentity, conf
 }, args_2?: {
     permissionKey?: import("./permission-keys.js").PermissionKeyOf;
 } | undefined) => import("commander").Command;
-export declare const guideCommand: (app: Pick<import("./index.js").AppIdentity, "command">, options: import("./guide.js").GuideOptions) => import("commander").Command;
+export declare const guideCommand: (app: Pick<import("./entry.js").AppIdentity, "command">, options: import("./guide.js").GuideOptions) => import("commander").Command;
 export declare const addMeetingBatchCommand: (program: import("commander").Command, deps: {
     reader: import("../meetings/batch.js").MeetingBatchReader;
     input: (path: string, signal?: AbortSignal) => Promise<string>;
@@ -410,7 +410,7 @@ export declare const tasksCommand: (messenger: import("./index.js").Messenger) =
 export declare const tasksStatsCommand: (messenger: import("./index.js").Messenger) => import("commander").Command;
 export declare const topicsCommand: (messenger: import("./index.js").Messenger) => import("commander").Command;
 export declare const watchCommand: (messenger: import("./index.js").Messenger) => import("commander").Command;
-export declare const runsCommand: (app: import("./index.js").AppIdentity) => import("commander").Command;
-export declare const skillCommand: (app: import("./index.js").AppIdentity, skill: URL) => import("commander").Command;
-export declare const upgradeCommand: (app: import("./index.js").AppIdentity, packageName: string, contextFor: (command: import("commander").Command) => import("./upgrade-command.js").UpgradeContext) => import("commander").Command;
-export declare const modelCatalogueCommand: (app: import("./index.js").AppIdentity, options: import("./model-catalogue-command.js").ModelCatalogueOptions) => import("commander").Command;
+export declare const runsCommand: (app: import("./entry.js").AppIdentity) => import("commander").Command;
+export declare const skillCommand: (app: import("./entry.js").AppIdentity, skill: URL) => import("commander").Command;
+export declare const upgradeCommand: (app: import("./entry.js").AppIdentity, packageName: string, contextFor: (command: import("commander").Command) => import("./upgrade-command.js").UpgradeContext) => import("commander").Command;
+export declare const modelCatalogueCommand: (app: import("./entry.js").AppIdentity, options: import("./model-catalogue-command.js").ModelCatalogueOptions) => import("commander").Command;

package/dist/entities/index.d.ts

@@ -9773,6 +9773,20 @@ export declare const ENTITIES: {
         readonly path: v.StringSchema<undefined>;
         readonly exists: v.LiteralSchema<false, undefined>;
         readonly reset: v.LiteralSchema<false, undefined>;
+    }, undefined>, v.StrictObjectSchema<{
+        readonly path: v.StringSchema<undefined>;
+        readonly exists: v.LiteralSchema<true, undefined>;
+        readonly reset: v.LiteralSchema<false, undefined>;
+        readonly dry_run: v.LiteralSchema<true, undefined>;
+        readonly files: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+        readonly bytes: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly schema: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly tables: v.ArraySchema<v.StrictObjectSchema<{
+            readonly name: v.StringSchema<undefined>;
+            readonly rows: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        }, undefined>, undefined>;
+        readonly backup_first: v.BooleanSchema<undefined>;
+        readonly in_use: v.NullableSchema<v.BooleanSchema<undefined>, undefined>;
     }, undefined>, v.StrictObjectSchema<{
         readonly path: v.StringSchema<undefined>;
         readonly exists: v.LiteralSchema<true, undefined>;

package/dist/entities/store-maintenance.d.ts

@@ -346,6 +346,20 @@ export declare const storeReset: v.UnionSchema<[v.StrictObjectSchema<{
     readonly path: v.StringSchema<undefined>;
     readonly exists: v.LiteralSchema<false, undefined>;
     readonly reset: v.LiteralSchema<false, undefined>;
+}, undefined>, v.StrictObjectSchema<{
+    readonly path: v.StringSchema<undefined>;
+    readonly exists: v.LiteralSchema<true, undefined>;
+    readonly reset: v.LiteralSchema<false, undefined>;
+    readonly dry_run: v.LiteralSchema<true, undefined>;
+    readonly files: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+    readonly bytes: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly schema: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly tables: v.ArraySchema<v.StrictObjectSchema<{
+        readonly name: v.StringSchema<undefined>;
+        readonly rows: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    }, undefined>, undefined>;
+    readonly backup_first: v.BooleanSchema<undefined>;
+    readonly in_use: v.NullableSchema<v.BooleanSchema<undefined>, undefined>;
 }, undefined>, v.StrictObjectSchema<{
     readonly path: v.StringSchema<undefined>;
     readonly exists: v.LiteralSchema<true, undefined>;

package/dist/entities/store-maintenance.js

@@ -147,6 +147,18 @@ export const storeRestore = v.strictObject({
 });
 export const storeReset = v.union([
     v.strictObject({ ...absent.entries, reset: v.literal(false) }),
+    v.strictObject({
+        path: text,
+        exists: v.literal(true),
+        reset: v.literal(false),
+        dry_run: v.literal(true),
+        files: v.array(text),
+        bytes: count,
+        schema: count,
+        tables: v.array(v.strictObject({ name: text, rows: count })),
+        backup_first: v.boolean(),
+        in_use: v.nullable(v.boolean()),
+    }),
     v.strictObject({
         path: text,
         exists: v.literal(true),

package/dist/meetings/mcp/index.d.ts

@@ -38,7 +38,6 @@ export declare const meetingTools: ({
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -54,11 +53,11 @@ export declare const meetingTools: ({
             format?: undefined;
             transcript_id?: undefined;
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -76,11 +75,11 @@ export declare const meetingTools: ({
             format?: undefined;
             transcript_id?: undefined;
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -102,6 +101,7 @@ export declare const meetingTools: ({
                 minimum: number;
             };
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
@@ -188,7 +188,6 @@ export declare const meetingTools: ({
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -204,11 +203,11 @@ export declare const meetingTools: ({
             format?: undefined;
             transcript_id?: undefined;
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -226,11 +225,11 @@ export declare const meetingTools: ({
             format?: undefined;
             transcript_id?: undefined;
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -252,6 +251,7 @@ export declare const meetingTools: ({
                 minimum: number;
             };
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
@@ -338,7 +338,6 @@ export declare const meetingTools: ({
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -354,11 +353,11 @@ export declare const meetingTools: ({
             format?: undefined;
             transcript_id?: undefined;
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -376,11 +375,11 @@ export declare const meetingTools: ({
             format?: undefined;
             transcript_id?: undefined;
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -402,6 +401,7 @@ export declare const meetingTools: ({
                 minimum: number;
             };
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
@@ -488,7 +488,6 @@ export declare const meetingTools: ({
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -504,11 +503,11 @@ export declare const meetingTools: ({
             format?: undefined;
             transcript_id?: undefined;
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -526,11 +525,11 @@ export declare const meetingTools: ({
             format?: undefined;
             transcript_id?: undefined;
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -552,6 +551,7 @@ export declare const meetingTools: ({
                 minimum: number;
             };
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
@@ -638,7 +638,6 @@ export declare const meetingTools: ({
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -654,11 +653,11 @@ export declare const meetingTools: ({
             format?: undefined;
             transcript_id?: undefined;
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -676,11 +675,11 @@ export declare const meetingTools: ({
             format?: undefined;
             transcript_id?: undefined;
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -702,6 +701,7 @@ export declare const meetingTools: ({
                 minimum: number;
             };
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.428.0",
+  "version": "0.430.0",
   "description": "The messenger-neutral half of a messaging CLI: domain model, message locators, rendering, name resolution, the SQLite seam, the command skeleton and shared read commands, the send guard, run records and the message store",
   "license": "Apache-2.0",
   "author": "Viacheslav Ptsarev",
@@ -48,6 +48,10 @@
       "types": "./dist/cli/index.d.ts",
       "default": "./dist/cli/index.js"
     },
+    "./cli/start": {
+      "types": "./dist/cli/entry.d.ts",
+      "default": "./dist/cli/entry.js"
+    },
     "./sends": {
       "types": "./dist/sends/index.d.ts",
       "default": "./dist/sends/index.js"

package/parity.json

@@ -4611,6 +4611,7 @@
     "store reset": {
       "in": "all",
       "options": {
+        "--dry-run": "all",
         "--no-backup": "all"
       }
     },