@wirecat/cli-core 0.426.0 → 0.427.0

package/CHANGELOG.md

@@ -7,6 +7,37 @@ shape of this file.
 
 ## Unreleased
 
+## 0.427.0 — 25.10.2026
+
+### Added
+
+- **Every CLI on cli-core gets `skill status` and `skill show --for claude|agents`** from cli-base 0.56.0. `skill
+  status` says, for each agent, whether its installed SKILL.md matches this version; `skill show --for` prints the copy
+  installed there, so a host can show what `skill install` would change.
+- **`store info` for every WireCat tool, and whether this tool can read the store.** `storeInfo(env)` returns the answer for a tool that builds its own program (drive, memo); `storeInfoCommand()` is the `info` command and `sharedStoreCommand()` a `store` group holding it, for a tool on `createProgram` with no `store` of its own (zm). `schema` gains `reason` (`missing`, `older`, `current`, `newer` — this tool may still write it — or `too_new`) and `upgrade`: `{ version, min_compatible }` the file will be at after this tool's next run, or `null`, so a caller can name every other tool whose `speaks` is below that minimum before it updates. `writable` keeps saying whether this tool can open the file. The answer has `clients`, each tool that opened the store with its `version`, cli-core `core`, `speaks` and `seen_at`. A missing store answers with this tool's `schema` too, and a file that does not open with `schema.speaks`.
+- **`store tables list` lists every table of the archive, and `store info` describes the file itself.** WireCat
+  Desktop's Storage page showed totals but not which tables the archive holds, its migrations or the last backup, and
+  the app may not open the file. `store tables list [query...]` answers each table's `name`, `kind` (`data`,
+  `search_index`, `search_index_part`, `internal`) and `rows`, read-only; a search index's rows stay `null`, since
+  counting them scans the whole index. `--full` adds `bytes`, the pages a table and its indexes hold, which reads the
+  whole file: under a second when it is in memory, ten seconds to two minutes when not, on a 3 GB store. Under Bun,
+  whose SQLite has no `dbstat`, `--full` says so. `store info` gains `journal_mode`, `pages` (`size`, `count`, and
+  `free`, the pages a `VACUUM` would give back), `migrations` (every applied version with its `min_compatible` and
+  `applied_at`) and `backup`, the time, file and check from the `backups/last.json` marker a backup job leaves beside
+  the store (`null` without one). The resource word `tables` comes from cli-base
+  ([WireCatLabs/cli-base#334](https://github.com/WireCatLabs/cli-base/pull/334)).
+
+### Changed — may break callers
+
+- **cli-core needs `@wirecat/cli-base` 0.56.** The peer range moves from `>=0.53.0 <0.54.0` to `>=0.56.0 <0.57.0`. A
+  CLI that pins cli-base moves its pin with this release. cli-base 0.54 and 0.55 change the release lock and the
+  changelog guard, which a CLI adopts through community's standards sync, and 0.56 adds the `missing-run-log` lint
+  rule: a CLI without `runs` fails `cli-dev lint` until it registers `runsCommand(app)`.
+
+### Fixed
+
+- **`store info` opens the store read-only.** It no longer sets the journal mode, and a store too new for this tool answers with its schema and empty `rows` instead of failing to count tables it may have renamed.
+
 ## 0.426.0 — 25.10.2026
 
 ### Added

package/dist/cli/index.d.ts

@@ -109,5 +109,6 @@ export { AGENTS, type Agent, agentFor, screenFor } from "./setup-screen.js";
 export { accountCommand, addMeetingBatchCommand, addMeetingPreparationCommand, addMeetingProjectCandidatesCommand, addMeetingSeriesInventoryCommand, attachmentsCommand, botAdminsCommand, botCommand, botMcpCommand, botMembersCommand, botMessagesCommand, callsCommand, chatsCommand, commandsCommand, completeCommand, configCommand, contactsCommand, conversationsCommand, deleteCommand, doctorCommand, editCommand, floodCommand, forwardCommand, generatedApiCommand, guideCommand, imagesCommand, inboxCommand, markReadCommand, mcpCommand, mentionsCommand, messagesCommand, metadataCommand, modelCatalogueCommand, modelsCommand, pinCommand, pollsCommand, reactionsCommand, recipientsCommand, repliesCommand, reviewCommand, runsCommand, scheduleCommand, searchCommand, searchesCommand, sendCommand, sendsCommand, serveCommand, serverCommand, skillCommand, starCommands, statsCommand, stickersCommand, storeCommand, tagsCommand, tasksCommand, tasksStatsCommand, topicsCommand, unpinCommand, upgradeCommand, watchCommand, } from "./shared-command-exports.js";
 export { assertSharedContracts, customizeSharedCommand, hasSharedContract, overrideSharedContract, type SharedContractOverride, sharedContractOverrides, sharedContracts, } from "./shared-contracts.js";
 export { runnable, withSafety } from "./steps.js";
+export { type StoreInfo, sharedStoreCommand, storeInfo, storeInfoCommand } from "./store-info.js";
 export { changeStoreSetting, isStoreSetting, STORE_SETTINGS, storeSettings } from "./store-settings.js";
 export { restartServers, type UpgradeContext } from "./upgrade-command.js";

package/dist/cli/index.js

@@ -100,5 +100,6 @@ export { AGENTS, agentFor, screenFor } from "./setup-screen.js";
 export { accountCommand, addMeetingBatchCommand, addMeetingPreparationCommand, addMeetingProjectCandidatesCommand, addMeetingSeriesInventoryCommand, attachmentsCommand, botAdminsCommand, botCommand, botMcpCommand, botMembersCommand, botMessagesCommand, callsCommand, chatsCommand, commandsCommand, completeCommand, configCommand, contactsCommand, conversationsCommand, deleteCommand, doctorCommand, editCommand, floodCommand, forwardCommand, generatedApiCommand, guideCommand, imagesCommand, inboxCommand, markReadCommand, mcpCommand, mentionsCommand, messagesCommand, metadataCommand, modelCatalogueCommand, modelsCommand, pinCommand, pollsCommand, reactionsCommand, recipientsCommand, repliesCommand, reviewCommand, runsCommand, scheduleCommand, searchCommand, searchesCommand, sendCommand, sendsCommand, serveCommand, serverCommand, skillCommand, starCommands, statsCommand, stickersCommand, storeCommand, tagsCommand, tasksCommand, tasksStatsCommand, topicsCommand, unpinCommand, upgradeCommand, watchCommand, } from "./shared-command-exports.js";
 export { assertSharedContracts, customizeSharedCommand, hasSharedContract, overrideSharedContract, sharedContractOverrides, sharedContracts, } from "./shared-contracts.js";
 export { runnable, withSafety } from "./steps.js";
+export { sharedStoreCommand, storeInfo, storeInfoCommand } from "./store-info.js";
 export { changeStoreSetting, isStoreSetting, STORE_SETTINGS, storeSettings } from "./store-settings.js";
 export { restartServers } from "./upgrade-command.js";

package/dist/cli/messenger/store-maintenance-command.d.ts

@@ -3,9 +3,9 @@ import type { CacheDatabase } from "../../store/driver.js";
 import type { Messenger } from "./context.js";
 /** `doctor`'s short summary of the store. Must answer for a broken file, so an error is a field. */
 export declare const storeSummary: (env: NodeJS.ProcessEnv) => Promise<{
-    error?: undefined;
     path: string;
     exists: boolean;
+    error?: undefined;
 } | {
     path: string;
     exists: boolean;

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

@@ -7,31 +7,27 @@ import { holdersOf } from "../../background/processes.js";
 import { RULES_VERSION } from "../../conversations/link.js";
 import { syncsOneChat } from "../../ports/traits.js";
 import { isSealed, sealFile, unsealFile } from "../../sealed.js";
-import { MIGRATIONS, migrate } from "../../store/migrations.js";
+import { fileSchemaOf, SPEAKS, writableBy } from "../../store/compatibility.js";
+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, openSqlite, openStore, orphanPointers, pendingNormalization, resetAttachmentWords, resetNoteIndex, resetSearchIndex, resetStems, rowCounts, searchIndexState, stemmerCache, stemsState, storeContents, } from "../../store/store.js";
+import { drainNoteIndex, fillSearchIndex, fillStems, involvementStoreOver, noteIndexState, 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";
 import { lineOf, nextStep } from "../steps.js";
+import { storeInfoCommand } from "../store-info.js";
 import { answerOf } from "./ask.js";
 import { ENCRYPT_OPTION, passwordOf } from "./password.js";
 import { servingProfiles } from "./serve-command.js";
-const SPEAKS = MIGRATIONS.at(-1)?.version ?? 0;
+import { storeTablesCommand } from "./store-tables-command.js";
 const SEARCH_INDEXES = ["messages_fts", "chats_fts", "identities_fts"];
 /** Contentless: it has no table to be compared with, only its own structure to check. */
 const WORD_INDEX = "message_words";
-/** An empty file is normal: `openStore` creates it before the first migration runs. */
 const schemaOf = (database) => {
-    const tracked = database.prepare("SELECT 1 FROM sqlite_master WHERE name = 'schema_migrations'").get();
-    const row = tracked
-        ? database.prepare("SELECT version, min_compatible FROM schema_migrations ORDER BY version DESC LIMIT 1").get()
-        : undefined;
-    const version = Number(row?.version ?? 0);
-    const minCompatible = Number(row?.min_compatible ?? 0);
-    return { version, minCompatible, writable: version <= SPEAKS || minCompatible <= SPEAKS };
+    const file = fileSchemaOf(database);
+    return { ...file, writable: writableBy(file) };
 };
 const count = (database, table) => Number(database.prepare(`SELECT count(*) AS n FROM ${table}`).get()?.n ?? 0);
 /** Before version 6 the column does not exist, and a file behind this build is not migrated here. */
@@ -49,16 +45,6 @@ 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);
@@ -84,7 +70,7 @@ export const storeSummary = async (env) => {
 /** A maintenance answer: one item, snake_case, its hints as steps where a registered one fits. */
 const result = (command, value, next = []) => renderAnswer(command, outputFor(command), itemOf(snakeKeys(value), { next }));
 export const storeMaintenanceCommands = (messenger) => [
-    infoCommand(),
+    storeInfoCommand(),
     checkCommand(messenger),
     migrateCommand(messenger),
     reindexCommand(messenger),
@@ -94,6 +80,7 @@ export const storeMaintenanceCommands = (messenger) => [
     repairCommand(messenger),
     resetCommand(messenger),
     copiesCommand(),
+    storeTablesCommand(messenger),
 ];
 /** Renaming tables under a running `serve` would pull them from under its statements. */
 const refuseWhileServing = (command, messenger) => {
@@ -162,31 +149,6 @@ const copiesCommand = () => new Command("copies").description("the tables `store
     const deleted = await reading(path, (database) => deleteCopy(database, name));
     result(this, { path, deleted });
 }));
-const infoCommand = () => annotate(new Command("info"), { output: { entity: "store_info" }, effects: LOCAL_READ })
-    .summary("the local archive's format, size and contents")
-    .description("the store file: where it is, its size, its schema and how many rows it holds, by provider, chat kind, account, year (UTC) and attachment kind, over every account; changes nothing")
-    .action(async function () {
-    const path = storePath(environmentOf(this).env ?? process.env);
-    if (!existsSync(path)) {
-        result(this, { path, exists: false });
-        return;
-    }
-    const read = readingOnly(path, (database) => {
-        const { version, minCompatible, writable } = schemaOf(database);
-        return {
-            path,
-            exists: true,
-            bytes: { file: bytesOf(path), wal: bytesOf(`${path}-wal`) },
-            schema: { version, minCompatible, speaks: SPEAKS, writable },
-            rows: version > 0 ? rowCounts(database) : {},
-            pendingNormalization: pendingIfKnown(database),
-            wordIndex: searchIndexState(database) ?? null,
-            stemIndex: stemsState(database) ?? null,
-            ...(version > 0 ? storeContents(database) : {}),
-        };
-    });
-    result(this, await read.catch((error) => ({ path, exists: true, opens: false, error: messageOf(error) })));
-});
 /**
  * Reports and never repairs. The per-chat completeness is what tells "nothing was said" from "not
  * fetched" (NEED-399 A). Times are the chat's newest message by the messenger's list against the

package/dist/cli/messenger/store-tables-command.d.ts

@@ -0,0 +1,5 @@
+import { type QueryRegistry } from "@wirecat/cli-base/query";
+import { Command } from "commander";
+import type { Messenger } from "./context.js";
+export declare const STORE_TABLES_QUERY: QueryRegistry;
+export declare const storeTablesCommand: (messenger: Messenger) => Command;

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

@@ -0,0 +1,59 @@
+import { existsSync } from "node:fs";
+import { CliError } from "@wirecat/cli-base";
+import { annotate } from "@wirecat/cli-base/commands";
+import { queryFieldsOf } from "@wirecat/cli-base/query";
+import { Command } from "commander";
+import { storeTable } from "../../entities/store-table.js";
+import { storePath } from "../../store/path.js";
+import { readStoreTables } from "../../store/store.js";
+import { environmentOf, outputFor } from "../context.js";
+import { LOCAL_READ } from "../effects.js";
+import { listOf, renderAnswer } from "../envelope.js";
+import { queryTerms, typedQuery, withQuery } from "../list-query.js";
+const PATH = "store tables list";
+export const STORE_TABLES_QUERY = {
+    entity: "store_table",
+    backend: "native",
+    fields: queryFieldsOf(storeTable, {
+        native: ["name", "kind"],
+        examples: { name: "name:messages", kind: "kind:data" },
+    }).map((field) => field.native
+        ? { ...field, operators: field.operators.filter((operator) => operator === "term" || operator === "phrase") }
+        : field),
+};
+const filterOf = (words) => {
+    const terms = queryTerms(words, STORE_TABLES_QUERY, PATH);
+    const name = terms.get("name");
+    const kind = terms.get("kind");
+    return { ...(name === undefined ? {} : { name }), ...(kind === undefined ? {} : { kind }) };
+};
+export const storeTablesCommand = (messenger) => {
+    const tables = new Command("tables").description("the tables of the local archive");
+    withQuery(annotate(tables.command("list"), {
+        effects: LOCAL_READ,
+        examples: [
+            `${messenger.app.command} store tables list`,
+            `${messenger.app.command} store tables list kind:data`,
+            `${messenger.app.command} store tables list --full --json`,
+        ],
+    }), STORE_TABLES_QUERY)
+        .summary("every table of the local archive, with its kind and row count")
+        .description("every table of the local archive: its kind (data, search index, part of a search index, internal) and its " +
+        "rows, a search index's rows not counted; --full adds each table's size on disk, which reads the whole file " +
+        "(about ten seconds for 3 GB); changes nothing")
+        .action(async function (words) {
+        const filter = filterOf(words);
+        const { full } = this.optsWithGlobals();
+        const path = storePath(environmentOf(this).env ?? process.env);
+        if (!existsSync(path))
+            throw new CliError("not_found", `no store at ${path}`);
+        const items = await readStoreTables(path, { filter, sizes: full === true });
+        renderAnswer(this, outputFor(this), listOf(PATH, {
+            items,
+            limit: Math.max(1, items.length),
+            has_more: false,
+            args: words.length ? { query: typedQuery(words) } : {},
+        }));
+    });
+    return tables;
+};

package/dist/cli/store-info.d.ts

@@ -0,0 +1,12 @@
+import { Command } from "commander";
+import type * as v from "valibot";
+import type { storeInfo as storeInfoEntity } from "../entities/store-maintenance.js";
+export type StoreInfo = v.InferOutput<typeof storeInfoEntity>;
+/**
+ * The shared store as this build sees it, for any WireCat tool. Opened read-only: it never migrates, never sets a
+ * journal mode, and answers for a file newer than this build instead of refusing it.
+ */
+export declare const storeInfo: (env: NodeJS.ProcessEnv) => Promise<StoreInfo>;
+export declare const storeInfoCommand: () => Command;
+/** `store info` for a tool with no `store` command of its own. */
+export declare const sharedStoreCommand: () => Command;

package/dist/cli/store-info.js

@@ -0,0 +1,72 @@
+import { existsSync, statSync } from "node:fs";
+import { annotate } from "@wirecat/cli-base/commands";
+import { Command } from "commander";
+import { compatibilityOf, fileSchemaOf } from "../store/compatibility.js";
+import { storePath } from "../store/path.js";
+import { fileFacts, openSqlite, pendingNormalization, rowCounts, searchIndexState, stemsState, storeClients, storeContents, } from "../store/store.js";
+import { environmentOf, outputFor } from "./context.js";
+import { LOCAL_READ } from "./effects.js";
+import { itemOf, renderAnswer, snakeKeys } from "./envelope.js";
+/** Before version 6 the column does not exist, and a file behind this build is not migrated here. */
+const pendingIfKnown = (database) => database.prepare("SELECT 1 FROM pragma_table_info('messages') WHERE name = 'normalized_text'").get()
+    ? pendingNormalization(database)
+    : null;
+const bytesOf = (path) => (existsSync(path) ? statSync(path).size : 0);
+const messageOf = (error) => (error instanceof Error ? error.message : String(error));
+/** A file this build may not open may have renamed what the counts read, so only its schema is reported. */
+const contentsOf = (database, version, writable) => version > 0 && writable
+    ? {
+        rows: rowCounts(database),
+        pendingNormalization: pendingIfKnown(database),
+        wordIndex: searchIndexState(database) ?? null,
+        stemIndex: stemsState(database) ?? null,
+        ...storeContents(database),
+    }
+    : { rows: {}, pendingNormalization: null, wordIndex: null, stemIndex: null };
+/**
+ * The shared store as this build sees it, for any WireCat tool. Opened read-only: it never migrates, never sets a
+ * journal mode, and answers for a file newer than this build instead of refusing it.
+ */
+export const storeInfo = async (env) => {
+    const path = storePath(env);
+    if (!existsSync(path))
+        return snakeKeys({ path, exists: false, schema: compatibilityOf(undefined) });
+    let schema = compatibilityOf(undefined);
+    try {
+        const { database } = await openSqlite(path, { readOnly: true });
+        try {
+            schema = compatibilityOf(fileSchemaOf(database));
+            const answer = {
+                path,
+                exists: true,
+                ...fileFacts(database, path),
+                bytes: { file: bytesOf(path), wal: bytesOf(`${path}-wal`) },
+                schema,
+                clients: storeClients(database).map(({ seenAt, ...client }) => ({
+                    ...client,
+                    seenAt: new Date(seenAt).toISOString(),
+                })),
+                ...contentsOf(database, schema.version, schema.writable),
+            };
+            return snakeKeys(answer);
+        }
+        finally {
+            database.close();
+        }
+    }
+    catch (error) {
+        const { speaks } = schema;
+        return snakeKeys({ path, exists: true, opens: false, error: messageOf(error), schema: { speaks } });
+    }
+};
+export const storeInfoCommand = () => annotate(new Command("info"), { output: { entity: "store_info" }, effects: LOCAL_READ })
+    .summary("the shared store's format, size and contents, and whether this tool can read it")
+    .description("the store file: where it is, its size, its schema against the one this tool speaks, which tools used it and how many rows it holds, by provider, chat kind, account, year (UTC) and attachment kind, over every account; changes nothing")
+    .action(async function () {
+    const answer = await storeInfo(environmentOf(this).env ?? process.env);
+    renderAnswer(this, outputFor(this), itemOf(answer));
+});
+/** `store info` for a tool with no `store` command of its own. */
+export const sharedStoreCommand = () => annotate(new Command("store"), { effects: LOCAL_READ })
+    .description("the shared local store every WireCat tool reads")
+    .addCommand(storeInfoCommand());

package/dist/entities/index.d.ts

@@ -75,6 +75,7 @@ import { savedSearch, searchHistoryClear } from "./saved-search.js";
 import { sendAttempt } from "./send-attempt.js";
 import { storeBackup, storeCheck, storeCopyRemoval, storeDecrypt, storeInfo, storeMigration, storeReindex, storeRepair, storeReset, storeRestore } from "./store-maintenance.js";
 import { storeChatStatus, storeClear, storeExport, storeGapPlan, storeGapRepair, storeJobCancel, storeJobClear, storeJobDetails, storeJobRetry } from "./store-records.js";
+import { storeTable } from "./store-table.js";
 import { automaticTags, tagChange } from "./tag-change.js";
 import { tagging } from "./tagging.js";
 import { task } from "./task.js";
@@ -86,7 +87,7 @@ import { topic } from "./topic.js";
  * subset of its fields, never a renamed one. Commands move onto these one by one; until then, a schema
  * is the target, not a description of today's output.
  */
-export { account, accountChange, accountPrivacy, accountPrivacyChange, accountProfile, accountSession, adminReport, agenda, analysisConsent, analysisConsentRevocation, attachment, attachmentBytes, attachmentExtraction, attachmentTextChange, automaticTags, botAdmin, botMenuEntry, botProfile, botSeenChat, botTemplate, botWebhook, cachedChatMetadata, callRecord, chart, chat, chatAdminChange, chatArchive, chatEvent, chatFolderChange, chatFolderOrder, chatFolderRemoval, chatGroupChange, chatInspection, chatInvite, chatInviteChange, chatMembersChange, chatMembersFetch, chatMetadata, chatMetadataRefresh, chatModeration, chatMuting, chatPin, chatRead, chatRemoval, chatRequestChange, chatRules, chatSender, chatStats, chatTracking, chatUnread, contact, contactActivity, contactAlias, contactCheck, contactContext, contactImport, contactLookup, contactNote, contactNoteRemoval, contactPreparation, contactProfile, contactStateChange, contactSync, contactUpdate, conversation, conversationBatch, conversationBatchStatus, conversationBuildResult, conversationChange, conversationDetails, conversationEmbedding, conversationEmbeddingStatus, conversationHit, conversationPreparation, conversationReadiness, counterRefresh, counters, document, documentLink, endedAccountSessions, evidence, evidencePacket, fact, folder, hit, identity, imageEmbedding, inviteLink, job, joinRequest, linkedPerson, mediaArchive, mediaArchiveCheck, mediaArchiveMove, mediaArchiveTimer, meeting, meetingProjectCandidates, meetingSeriesInventory, member, memory, mention, mentionDecision, mentionDetails, mentionDomain, mentionRebuild, message, messageContext, messageCounts, messageDeletion, messageDownload, messageEvent, messageLink, messageLinks, messagePin, messageStar, messageSync, messageTranscript, messageWrite, model, modelKey, note, officialStats, organization, person, place, poll, pollChange, pollVote, project, ranking, reactionChange, recipient, recipientAdded, recipientChange, recipientOff, recipientRemoved, recordedRun, reference, relationship, reminder, removedModelKey, retention, runDetails, runHit, runLocation, savedSearch, scheduledJob, searchHistoryClear, sendAttempt, serveSummary, stickerInventory, storeBackup, storeChatStatus, storeCheck, storeClear, storeCopyRemoval, storeDecrypt, storedModelKey, storeExport, storeGapPlan, storeGapRepair, storeInfo, storeJobCancel, storeJobClear, storeJobDetails, storeJobRetry, storeMigration, storeReindex, storeRepair, storeReset, storeRestore, tagChange, tagging, task, taskCard, taskCategories, taskClosed, taskCreated, taskLinks, taskMerge, taskPair, taskScan, taskSimilar, taskStats, taskUnmerge, topic, trackedChat, trackedChatHistory, watchedMessage, watchItem, };
+export { account, accountChange, accountPrivacy, accountPrivacyChange, accountProfile, accountSession, adminReport, agenda, analysisConsent, analysisConsentRevocation, attachment, attachmentBytes, attachmentExtraction, attachmentTextChange, automaticTags, botAdmin, botMenuEntry, botProfile, botSeenChat, botTemplate, botWebhook, cachedChatMetadata, callRecord, chart, chat, chatAdminChange, chatArchive, chatEvent, chatFolderChange, chatFolderOrder, chatFolderRemoval, chatGroupChange, chatInspection, chatInvite, chatInviteChange, chatMembersChange, chatMembersFetch, chatMetadata, chatMetadataRefresh, chatModeration, chatMuting, chatPin, chatRead, chatRemoval, chatRequestChange, chatRules, chatSender, chatStats, chatTracking, chatUnread, contact, contactActivity, contactAlias, contactCheck, contactContext, contactImport, contactLookup, contactNote, contactNoteRemoval, contactPreparation, contactProfile, contactStateChange, contactSync, contactUpdate, conversation, conversationBatch, conversationBatchStatus, conversationBuildResult, conversationChange, conversationDetails, conversationEmbedding, conversationEmbeddingStatus, conversationHit, conversationPreparation, conversationReadiness, counterRefresh, counters, document, documentLink, endedAccountSessions, evidence, evidencePacket, fact, folder, hit, identity, imageEmbedding, inviteLink, job, joinRequest, linkedPerson, mediaArchive, mediaArchiveCheck, mediaArchiveMove, mediaArchiveTimer, meeting, meetingProjectCandidates, meetingSeriesInventory, member, memory, mention, mentionDecision, mentionDetails, mentionDomain, mentionRebuild, message, messageContext, messageCounts, messageDeletion, messageDownload, messageEvent, messageLink, messageLinks, messagePin, messageStar, messageSync, messageTranscript, messageWrite, model, modelKey, note, officialStats, organization, person, place, poll, pollChange, pollVote, project, ranking, reactionChange, recipient, recipientAdded, recipientChange, recipientOff, recipientRemoved, recordedRun, reference, relationship, reminder, removedModelKey, retention, runDetails, runHit, runLocation, savedSearch, scheduledJob, searchHistoryClear, sendAttempt, serveSummary, stickerInventory, storeBackup, storeChatStatus, storeCheck, storeClear, storeCopyRemoval, storeDecrypt, storedModelKey, storeExport, storeGapPlan, storeGapRepair, storeInfo, storeJobCancel, storeJobClear, storeJobDetails, storeJobRetry, storeMigration, storeReindex, storeRepair, storeReset, storeRestore, storeTable, tagChange, tagging, task, taskCard, taskCategories, taskClosed, taskCreated, taskLinks, taskMerge, taskPair, taskScan, taskSimilar, taskStats, taskUnmerge, topic, trackedChat, trackedChatHistory, watchedMessage, watchItem, };
 export declare const ENTITIES: {
     readonly meeting_ingestion: v.StrictObjectSchema<{
         readonly meetings: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
@@ -9430,11 +9431,25 @@ export declare const ENTITIES: {
     readonly store_info: v.UnionSchema<[v.StrictObjectSchema<{
         readonly path: v.StringSchema<undefined>;
         readonly exists: v.LiteralSchema<false, undefined>;
+        readonly schema: v.StrictObjectSchema<{
+            readonly version: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly min_compatible: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly writable: v.BooleanSchema<undefined>;
+            readonly speaks: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly reason: v.PicklistSchema<["missing", "older", "current", "newer", "too_new"], undefined>;
+            readonly upgrade: v.NullableSchema<v.StrictObjectSchema<{
+                readonly version: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                readonly min_compatible: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            }, undefined>, undefined>;
+        }, undefined>;
     }, undefined>, v.StrictObjectSchema<{
-        path: v.StringSchema<undefined>;
-        exists: v.LiteralSchema<true, undefined>;
-        opens: v.LiteralSchema<false, undefined>;
-        error: v.StringSchema<undefined>;
+        readonly path: v.StringSchema<undefined>;
+        readonly exists: v.LiteralSchema<true, undefined>;
+        readonly opens: v.LiteralSchema<false, undefined>;
+        readonly error: v.StringSchema<undefined>;
+        readonly schema: v.StrictObjectSchema<{
+            readonly speaks: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        }, undefined>;
     }, undefined>, v.StrictObjectSchema<{
         readonly by_provider: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
             readonly chats: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
@@ -9478,12 +9493,40 @@ export declare const ENTITIES: {
             readonly file: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
             readonly wal: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
         }, undefined>;
+        readonly journal_mode: v.StringSchema<undefined>;
+        readonly pages: v.StrictObjectSchema<{
+            readonly size: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly count: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly free: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        }, undefined>;
+        readonly migrations: v.ArraySchema<v.StrictObjectSchema<{
+            readonly version: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly min_compatible: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly applied_at: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+        }, undefined>, undefined>;
+        readonly backup: v.NullableSchema<v.StrictObjectSchema<{
+            readonly at: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+            readonly file: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly checked: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
         readonly schema: v.StrictObjectSchema<{
             readonly version: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
             readonly min_compatible: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
             readonly writable: v.BooleanSchema<undefined>;
             readonly speaks: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly reason: v.PicklistSchema<["missing", "older", "current", "newer", "too_new"], undefined>;
+            readonly upgrade: v.NullableSchema<v.StrictObjectSchema<{
+                readonly version: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                readonly min_compatible: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            }, undefined>, undefined>;
         }, undefined>;
+        readonly clients: v.ArraySchema<v.StrictObjectSchema<{
+            readonly command: v.StringSchema<undefined>;
+            readonly version: v.StringSchema<undefined>;
+            readonly core: v.StringSchema<undefined>;
+            readonly speaks: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly seen_at: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+        }, undefined>, undefined>;
         readonly rows: Omit<v.StrictObjectSchema<{
             readonly accounts: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
             readonly chats: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
@@ -9809,6 +9852,12 @@ export declare const ENTITIES: {
             readonly rows: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
         }, undefined>;
     }, undefined>;
+    readonly store_table: v.StrictObjectSchema<{
+        readonly name: v.StringSchema<undefined>;
+        readonly kind: v.PicklistSchema<readonly ["data", "search_index", "search_index_part", "internal"], undefined>;
+        readonly rows: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+        readonly bytes: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>, undefined>;
+    }, undefined>;
     readonly agenda: v.StrictObjectSchema<{
         readonly at: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
         readonly account: v.StringSchema<undefined>;

package/dist/entities/index.js

@@ -81,6 +81,7 @@ import { savedSearch, searchHistoryClear } from "./saved-search.js";
 import { sendAttempt } from "./send-attempt.js";
 import { storeBackup, storeCheck, storeCopyRemoval, storeDecrypt, storeInfo, storeMigration, storeReindex, storeRepair, storeReset, storeRestore, } from "./store-maintenance.js";
 import { storeChatStatus, storeClear, storeExport, storeGapPlan, storeGapRepair, storeJobCancel, storeJobClear, storeJobDetails, storeJobRetry, syncProgress, } from "./store-records.js";
+import { storeTable } from "./store-table.js";
 import { automaticTags, tagChange } from "./tag-change.js";
 import { tagging } from "./tagging.js";
 import { task } from "./task.js";
@@ -92,7 +93,7 @@ import { topic } from "./topic.js";
  * subset of its fields, never a renamed one. Commands move onto these one by one; until then, a schema
  * is the target, not a description of today's output.
  */
-export { account, accountChange, accountPrivacy, accountPrivacyChange, accountProfile, accountSession, adminReport, agenda, analysisConsent, analysisConsentRevocation, attachment, attachmentBytes, attachmentExtraction, attachmentTextChange, automaticTags, botAdmin, botMenuEntry, botProfile, botSeenChat, botTemplate, botWebhook, cachedChatMetadata, callRecord, chart, chat, chatAdminChange, chatArchive, chatEvent, chatFolderChange, chatFolderOrder, chatFolderRemoval, chatGroupChange, chatInspection, chatInvite, chatInviteChange, chatMembersChange, chatMembersFetch, chatMetadata, chatMetadataRefresh, chatModeration, chatMuting, chatPin, chatRead, chatRemoval, chatRequestChange, chatRules, chatSender, chatStats, chatTracking, chatUnread, contact, contactActivity, contactAlias, contactCheck, contactContext, contactImport, contactLookup, contactNote, contactNoteRemoval, contactPreparation, contactProfile, contactStateChange, contactSync, contactUpdate, conversation, conversationBatch, conversationBatchStatus, conversationBuildResult, conversationChange, conversationDetails, conversationEmbedding, conversationEmbeddingStatus, conversationHit, conversationPreparation, conversationReadiness, counterRefresh, counters, document, documentLink, endedAccountSessions, evidence, evidencePacket, fact, folder, hit, identity, imageEmbedding, inviteLink, job, joinRequest, linkedPerson, mediaArchive, mediaArchiveCheck, mediaArchiveMove, mediaArchiveTimer, meeting, meetingProjectCandidates, meetingSeriesInventory, member, memory, mention, mentionDecision, mentionDetails, mentionDomain, mentionRebuild, message, messageContext, messageCounts, messageDeletion, messageDownload, messageEvent, messageLink, messageLinks, messagePin, messageStar, messageSync, messageTranscript, messageWrite, model, modelKey, note, officialStats, organization, person, place, poll, pollChange, pollVote, project, ranking, reactionChange, recipient, recipientAdded, recipientChange, recipientOff, recipientRemoved, recordedRun, reference, relationship, reminder, removedModelKey, retention, runDetails, runHit, runLocation, savedSearch, scheduledJob, searchHistoryClear, sendAttempt, serveSummary, stickerInventory, storeBackup, storeChatStatus, storeCheck, storeClear, storeCopyRemoval, storeDecrypt, storedModelKey, storeExport, storeGapPlan, storeGapRepair, storeInfo, storeJobCancel, storeJobClear, storeJobDetails, storeJobRetry, storeMigration, storeReindex, storeRepair, storeReset, storeRestore, tagChange, tagging, task, taskCard, taskCategories, taskClosed, taskCreated, taskLinks, taskMerge, taskPair, taskScan, taskSimilar, taskStats, taskUnmerge, topic, trackedChat, trackedChatHistory, watchedMessage, watchItem, };
+export { account, accountChange, accountPrivacy, accountPrivacyChange, accountProfile, accountSession, adminReport, agenda, analysisConsent, analysisConsentRevocation, attachment, attachmentBytes, attachmentExtraction, attachmentTextChange, automaticTags, botAdmin, botMenuEntry, botProfile, botSeenChat, botTemplate, botWebhook, cachedChatMetadata, callRecord, chart, chat, chatAdminChange, chatArchive, chatEvent, chatFolderChange, chatFolderOrder, chatFolderRemoval, chatGroupChange, chatInspection, chatInvite, chatInviteChange, chatMembersChange, chatMembersFetch, chatMetadata, chatMetadataRefresh, chatModeration, chatMuting, chatPin, chatRead, chatRemoval, chatRequestChange, chatRules, chatSender, chatStats, chatTracking, chatUnread, contact, contactActivity, contactAlias, contactCheck, contactContext, contactImport, contactLookup, contactNote, contactNoteRemoval, contactPreparation, contactProfile, contactStateChange, contactSync, contactUpdate, conversation, conversationBatch, conversationBatchStatus, conversationBuildResult, conversationChange, conversationDetails, conversationEmbedding, conversationEmbeddingStatus, conversationHit, conversationPreparation, conversationReadiness, counterRefresh, counters, document, documentLink, endedAccountSessions, evidence, evidencePacket, fact, folder, hit, identity, imageEmbedding, inviteLink, job, joinRequest, linkedPerson, mediaArchive, mediaArchiveCheck, mediaArchiveMove, mediaArchiveTimer, meeting, meetingProjectCandidates, meetingSeriesInventory, member, memory, mention, mentionDecision, mentionDetails, mentionDomain, mentionRebuild, message, messageContext, messageCounts, messageDeletion, messageDownload, messageEvent, messageLink, messageLinks, messagePin, messageStar, messageSync, messageTranscript, messageWrite, model, modelKey, note, officialStats, organization, person, place, poll, pollChange, pollVote, project, ranking, reactionChange, recipient, recipientAdded, recipientChange, recipientOff, recipientRemoved, recordedRun, reference, relationship, reminder, removedModelKey, retention, runDetails, runHit, runLocation, savedSearch, scheduledJob, searchHistoryClear, sendAttempt, serveSummary, stickerInventory, storeBackup, storeChatStatus, storeCheck, storeClear, storeCopyRemoval, storeDecrypt, storedModelKey, storeExport, storeGapPlan, storeGapRepair, storeInfo, storeJobCancel, storeJobClear, storeJobDetails, storeJobRetry, storeMigration, storeReindex, storeRepair, storeReset, storeRestore, storeTable, tagChange, tagging, task, taskCard, taskCategories, taskClosed, taskCreated, taskLinks, taskMerge, taskPair, taskScan, taskSimilar, taskStats, taskUnmerge, topic, trackedChat, trackedChatHistory, watchedMessage, watchItem, };
 export const ENTITIES = {
     sync_progress: syncProgress,
     ...MEETING_RESULT_ENTITIES,
@@ -291,6 +292,7 @@ export const ENTITIES = {
     store_reset: storeReset,
     store_repair: storeRepair,
     store_copy_removal: storeCopyRemoval,
+    store_table: storeTable,
     agenda,
     model,
     chat_group_change: chatGroupChange,

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

@@ -2,11 +2,25 @@ import * as v from "valibot";
 export declare const storeInfo: v.UnionSchema<[v.StrictObjectSchema<{
     readonly path: v.StringSchema<undefined>;
     readonly exists: v.LiteralSchema<false, undefined>;
+    readonly schema: v.StrictObjectSchema<{
+        readonly version: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly min_compatible: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly writable: v.BooleanSchema<undefined>;
+        readonly speaks: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly reason: v.PicklistSchema<["missing", "older", "current", "newer", "too_new"], undefined>;
+        readonly upgrade: v.NullableSchema<v.StrictObjectSchema<{
+            readonly version: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly min_compatible: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        }, undefined>, undefined>;
+    }, undefined>;
 }, undefined>, v.StrictObjectSchema<{
-    path: v.StringSchema<undefined>;
-    exists: v.LiteralSchema<true, undefined>;
-    opens: v.LiteralSchema<false, undefined>;
-    error: v.StringSchema<undefined>;
+    readonly path: v.StringSchema<undefined>;
+    readonly exists: v.LiteralSchema<true, undefined>;
+    readonly opens: v.LiteralSchema<false, undefined>;
+    readonly error: v.StringSchema<undefined>;
+    readonly schema: v.StrictObjectSchema<{
+        readonly speaks: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    }, undefined>;
 }, undefined>, v.StrictObjectSchema<{
     readonly by_provider: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
         readonly chats: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
@@ -50,12 +64,42 @@ export declare const storeInfo: v.UnionSchema<[v.StrictObjectSchema<{
         readonly file: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
         readonly wal: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
     }, undefined>;
+    readonly journal_mode: v.StringSchema<undefined>;
+    /** `free` pages hold nothing; a `VACUUM` would give them back. */
+    readonly pages: v.StrictObjectSchema<{
+        readonly size: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly count: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly free: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    }, undefined>;
+    readonly migrations: v.ArraySchema<v.StrictObjectSchema<{
+        readonly version: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly min_compatible: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly applied_at: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+    }, undefined>, undefined>;
+    /** From the marker a backup job leaves in `backups/last.json` beside the store; null without one. */
+    readonly backup: v.NullableSchema<v.StrictObjectSchema<{
+        readonly at: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+        readonly file: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly checked: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
     readonly schema: v.StrictObjectSchema<{
         readonly version: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
         readonly min_compatible: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
         readonly writable: v.BooleanSchema<undefined>;
         readonly speaks: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly reason: v.PicklistSchema<["missing", "older", "current", "newer", "too_new"], undefined>;
+        readonly upgrade: v.NullableSchema<v.StrictObjectSchema<{
+            readonly version: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly min_compatible: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        }, undefined>, undefined>;
     }, undefined>;
+    readonly clients: v.ArraySchema<v.StrictObjectSchema<{
+        readonly command: v.StringSchema<undefined>;
+        readonly version: v.StringSchema<undefined>;
+        readonly core: v.StringSchema<undefined>;
+        readonly speaks: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly seen_at: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+    }, undefined>, undefined>;
     readonly rows: Omit<v.StrictObjectSchema<{
         readonly accounts: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
         readonly chats: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;

package/dist/entities/store-maintenance.js

@@ -2,6 +2,12 @@ import * as v from "valibot";
 import { count, text, time } from "./fields.js";
 const absent = v.strictObject({ path: text, exists: v.literal(false) });
 const schema = v.strictObject({ version: count, min_compatible: count, writable: v.boolean(), speaks: count });
+const infoSchema = v.strictObject({
+    ...schema.entries,
+    reason: v.picklist(["missing", "older", "current", "newer", "too_new"]),
+    upgrade: v.nullable(v.strictObject({ version: count, min_compatible: count })),
+});
+const client = v.strictObject({ command: text, version: text, core: text, speaks: count, seen_at: time });
 const wordIndex = v.strictObject({
     watermark: count,
     filled_through: count,
@@ -47,13 +53,20 @@ const contents = {
     by_attachment_kind: v.optional(v.array(v.strictObject({ type: text, kind: text, count, bytes: count }))),
 };
 export const storeInfo = v.union([
-    absent,
-    v.strictObject(readFailure),
+    v.strictObject({ ...absent.entries, schema: infoSchema }),
+    v.strictObject({ ...readFailure, schema: v.strictObject({ speaks: count }) }),
     v.strictObject({
         path: text,
         exists: v.literal(true),
         bytes: v.strictObject({ file: count, wal: count }),
-        schema,
+        journal_mode: text,
+        /** `free` pages hold nothing; a `VACUUM` would give them back. */
+        pages: v.strictObject({ size: count, count, free: count }),
+        migrations: v.array(v.strictObject({ version: count, min_compatible: count, applied_at: time })),
+        /** From the marker a backup job leaves in `backups/last.json` beside the store; null without one. */
+        backup: v.nullable(v.strictObject({ at: time, file: v.nullable(text), checked: v.nullable(text) })),
+        schema: infoSchema,
+        clients: v.array(client),
         rows,
         pending_normalization: v.nullable(count),
         word_index: v.nullable(wordIndex),

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

@@ -0,0 +1,8 @@
+import * as v from "valibot";
+export declare const TABLE_KINDS: readonly ["data", "search_index", "search_index_part", "internal"];
+export declare const storeTable: v.StrictObjectSchema<{
+    readonly name: v.StringSchema<undefined>;
+    readonly kind: v.PicklistSchema<readonly ["data", "search_index", "search_index_part", "internal"], undefined>;
+    readonly rows: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+    readonly bytes: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>, undefined>;
+}, undefined>;

package/dist/entities/store-table.js

@@ -0,0 +1,9 @@
+import * as v from "valibot";
+import { count, text } from "./fields.js";
+export const TABLE_KINDS = ["data", "search_index", "search_index_part", "internal"];
+export const storeTable = v.strictObject({
+    name: text,
+    kind: v.picklist(TABLE_KINDS),
+    rows: v.nullable(count),
+    bytes: v.optional(v.nullable(count)),
+});

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

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

package/dist/store/compatibility.d.ts

@@ -0,0 +1,28 @@
+import type { CacheDatabase } from "./driver.js";
+import { type Migration } from "./migrations.js";
+export declare const SPEAKS: number;
+export interface FileSchema {
+    version: number;
+    minCompatible: number;
+}
+/** Where the file stands against this build: `missing` and `older` are what this build's next run migrates. */
+export type SchemaReason = "missing" | "older" | "current" | "newer" | "too_new";
+/** An empty file is normal: `openStore` creates it before the first migration runs. */
+export declare const fileSchemaOf: (database: CacheDatabase) => FileSchema;
+/** The negation of `migrate`'s refusal: a newer file stays open to this build until its minimum passes it. */
+export declare const writableBy: ({ version, minCompatible }: FileSchema, speaks?: number) => boolean;
+/**
+ * What this build makes of the file, and what its next run would leave behind: `upgrade.minCompatible` is the
+ * minimum the file will demand afterwards, so a caller can name every other tool that will then refuse it.
+ */
+export declare const compatibilityOf: (file: FileSchema | undefined, migrations?: readonly Migration[]) => {
+    version: number;
+    minCompatible: number;
+    speaks: number;
+    writable: boolean;
+    reason: SchemaReason;
+    upgrade: {
+        version: number;
+        minCompatible: number;
+    } | null;
+};

package/dist/store/compatibility.js

@@ -0,0 +1,41 @@
+import { MIGRATIONS } from "./migrations.js";
+export const SPEAKS = MIGRATIONS.at(-1)?.version ?? 0;
+/** An empty file is normal: `openStore` creates it before the first migration runs. */
+export const fileSchemaOf = (database) => {
+    const tracked = database.prepare("SELECT 1 FROM sqlite_master WHERE name = 'schema_migrations'").get();
+    const row = tracked
+        ? database.prepare("SELECT version, min_compatible FROM schema_migrations ORDER BY version DESC LIMIT 1").get()
+        : undefined;
+    return { version: Number(row?.version ?? 0), minCompatible: Number(row?.min_compatible ?? 0) };
+};
+/** The negation of `migrate`'s refusal: a newer file stays open to this build until its minimum passes it. */
+export const writableBy = ({ version, minCompatible }, speaks = SPEAKS) => version <= speaks || minCompatible <= speaks;
+/**
+ * What this build makes of the file, and what its next run would leave behind: `upgrade.minCompatible` is the
+ * minimum the file will demand afterwards, so a caller can name every other tool that will then refuse it.
+ */
+export const compatibilityOf = (file, migrations = MIGRATIONS) => {
+    const speaks = migrations.at(-1)?.version ?? 0;
+    const { version, minCompatible } = file ?? { version: 0, minCompatible: 0 };
+    const writable = writableBy({ version, minCompatible }, speaks);
+    const reason = !file
+        ? "missing"
+        : version < speaks
+            ? "older"
+            : version === speaks
+                ? "current"
+                : writable
+                    ? "newer"
+                    : "too_new";
+    const raisedTo = migrations
+        .filter((migration) => migration.version > version)
+        .reduce((highest, migration) => Math.max(highest, migration.minCompatible), minCompatible);
+    return {
+        version,
+        minCompatible,
+        speaks,
+        writable,
+        reason,
+        upgrade: version < speaks ? { version: speaks, minCompatible: raisedTo } : null,
+    };
+};

package/dist/store/exports.d.ts

@@ -19,6 +19,7 @@ export { type AttachmentTextEntry, type AttachmentView, attachmentColumns, type
 export { pendingNormalization } from "./sqlite/backfill.js";
 export type { ChatRekey, ChatRekeys } from "./sqlite/chat-rekey.js";
 export { CHAT_COLUMNS, TRACKED_CHAT_COLUMNS, titlePart } from "./sqlite/chats.js";
+export { storeClients } from "./sqlite/clients.js";
 export { CHAT_LIST_KEY, type ChatCompleteness, fetchedKey, historyStartKey } from "./sqlite/completeness.js";
 export { CONVERSATION_COLUMNS } from "./sqlite/conversations.js";
 export type { CounterTarget } from "./sqlite/counters.js";

package/dist/store/exports.js

@@ -3,6 +3,7 @@ export { accountGroupsOf } from "./sqlite/account-groups.js";
 export { attachmentColumns, resetAttachmentWords, } from "./sqlite/attachment-texts.js";
 export { pendingNormalization } from "./sqlite/backfill.js";
 export { CHAT_COLUMNS, TRACKED_CHAT_COLUMNS, titlePart } from "./sqlite/chats.js";
+export { storeClients } from "./sqlite/clients.js";
 export { CHAT_LIST_KEY, fetchedKey, historyStartKey } from "./sqlite/completeness.js";
 export { CONVERSATION_COLUMNS } from "./sqlite/conversations.js";
 export { messageOfEmail, threadConversation } from "./sqlite/emails.js";

package/dist/store/sqlite/store-tables.d.ts

@@ -0,0 +1,43 @@
+import type { TABLE_KINDS } from "../../entities/store-table.js";
+import type { CacheDatabase } from "../driver.js";
+export type TableKind = (typeof TABLE_KINDS)[number];
+export interface StoreTable {
+    name: string;
+    kind: TableKind;
+    /** Counted for data and internal tables only: a search index's row count is a scan of the whole index. */
+    rows: number | null;
+    /** With sizes: the pages the table and its indexes hold; null for a search index, whose parts hold its pages. */
+    bytes?: number | null;
+}
+export interface TableFilter {
+    name?: string;
+    kind?: TableKind;
+}
+/** Read-only by the connection itself: listing tables must not set a journal mode or migrate the file. */
+export declare const readStoreTables: (path: string, options?: {
+    filter?: TableFilter;
+    sizes?: boolean;
+}) => Promise<StoreTable[]>;
+export declare const storeTables: (database: CacheDatabase, { filter, sizes }?: {
+    filter?: TableFilter;
+    sizes?: boolean;
+}) => StoreTable[];
+/** Facts about the file itself, cheap enough for `store info`: no page is read beyond the header and the history. */
+export declare const fileFacts: (database: CacheDatabase, path: string) => {
+    journalMode: string;
+    pages: {
+        size: number;
+        count: number;
+        free: number;
+    };
+    migrations: {
+        version: number;
+        minCompatible: number;
+        appliedAt: string;
+    }[];
+    backup: {
+        at: string;
+        file: string | null;
+        checked: string | null;
+    } | null;
+};

package/dist/store/sqlite/store-tables.js

@@ -0,0 +1,111 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { CliError } from "@wirecat/cli-base";
+import { openSqlite } from "./open.js";
+const BOOKKEEPING = ["schema_migrations", "store_settings"];
+/** `PRAGMA table_list` names virtual and shadow tables itself, so a new search index needs no list kept here. */
+const LISTED = `
+  SELECT name, CASE
+      WHEN type = 'virtual' THEN 'search_index'
+      WHEN type = 'shadow' THEN 'search_index_part'
+      WHEN name LIKE 'sqlite\\_%' ESCAPE '\\' OR name IN (${BOOKKEEPING.map((name) => `'${name}'`).join(", ")})
+        THEN 'internal'
+      ELSE 'data'
+    END AS kind
+  FROM pragma_table_list
+  WHERE schema = 'main' AND name <> 'sqlite_schema'`;
+/** Read-only by the connection itself: listing tables must not set a journal mode or migrate the file. */
+export const readStoreTables = async (path, options = {}) => {
+    const { database } = await openSqlite(path, { readOnly: true });
+    try {
+        return storeTables(database, options);
+    }
+    finally {
+        database.close();
+    }
+};
+export const storeTables = (database, { filter = {}, sizes = false } = {}) => {
+    const listed = database
+        .prepare(`SELECT name, kind FROM (${LISTED})
+       WHERE (? IS NULL OR name = ?) AND (? IS NULL OR kind = ?) ORDER BY name`)
+        .all(filter.name ?? null, filter.name ?? null, filter.kind ?? null, filter.kind ?? null)
+        .map((row) => ({ name: String(row.name), kind: String(row.kind) }));
+    const bytes = sizes ? pageBytes(database) : undefined;
+    return listed.map(({ name, kind }) => ({
+        name,
+        kind,
+        rows: kind === "data" || kind === "internal" ? rowCount(database, name) : null,
+        ...(bytes ? { bytes: kind === "search_index" ? null : (bytes.get(name) ?? 0) } : {}),
+    }));
+};
+const rowCount = (database, table) => Number(database.prepare(`SELECT count(*) AS n FROM "${table.replaceAll('"', '""')}"`).get()?.n ?? 0);
+/** Every page of the file is read: about ten seconds for a 3 GB store whose pages are not in memory. */
+const pageBytes = (database) => {
+    let rows;
+    try {
+        // Joined here, not in SQL: as the inner side of a join, dbstat walks the whole file once per outer row.
+        rows = database.prepare("SELECT name, pgsize FROM dbstat WHERE schema = 'main' AND aggregate = 1").all();
+    }
+    catch (error) {
+        if (!/no such table: dbstat/.test(String(error)))
+            throw error;
+        throw new CliError("configuration_error", "this SQLite cannot measure table sizes (it was built without dbstat) — run the command under Node instead of Bun");
+    }
+    const owners = new Map(database
+        .prepare("SELECT name, tbl_name FROM sqlite_schema WHERE type = 'index'")
+        .all()
+        .map((row) => [String(row.name), String(row.tbl_name)]));
+    const bytes = new Map();
+    for (const { name, pgsize } of rows) {
+        const owner = owners.get(String(name)) ?? String(name);
+        bytes.set(owner, (bytes.get(owner) ?? 0) + Number(pgsize));
+    }
+    return bytes;
+};
+/** Facts about the file itself, cheap enough for `store info`: no page is read beyond the header and the history. */
+export const fileFacts = (database, path) => {
+    const pragma = (name) => database.prepare(`PRAGMA ${name}`).get()?.[name];
+    const tracked = database.prepare("SELECT 1 FROM sqlite_schema WHERE name = 'schema_migrations'").get();
+    return {
+        journalMode: String(pragma("journal_mode")),
+        pages: {
+            size: Number(pragma("page_size")),
+            count: Number(pragma("page_count")),
+            free: Number(pragma("freelist_count")),
+        },
+        migrations: tracked
+            ? database
+                .prepare("SELECT version, min_compatible, applied_at FROM schema_migrations ORDER BY version")
+                .all()
+                .map((row) => ({
+                version: Number(row.version),
+                minCompatible: Number(row.min_compatible),
+                appliedAt: new Date(Number(row.applied_at)).toISOString(),
+            }))
+            : [],
+        backup: lastBackup(path),
+    };
+};
+/**
+ * The marker the owner's backup job writes beside the store; cli-memo's `mail trash` already trusts it. Only its
+ * time, file name and check are passed on, and a marker that does not parse reads as none.
+ */
+const lastBackup = (path) => {
+    const marker = join(dirname(path), "backups", "last.json");
+    if (!existsSync(marker))
+        return null;
+    try {
+        const { at, file, checked } = JSON.parse(readFileSync(marker, "utf8"));
+        const time = typeof at === "string" ? Date.parse(at) : Number.NaN;
+        if (Number.isNaN(time))
+            return null;
+        return {
+            at: new Date(time).toISOString(),
+            file: typeof file === "string" ? file : null,
+            checked: typeof checked === "string" ? checked : null,
+        };
+    }
+    catch {
+        return null;
+    }
+};

package/dist/store/store.d.ts

@@ -106,5 +106,6 @@ export interface MessageStore {
     close(): Promise<void>;
 }
 export { BACKFILL_ON_OPEN, type StoreOptions } from "./sqlite/open-store.js";
+export { fileFacts, readStoreTables, type TableKind } from "./sqlite/store-tables.js";
 export declare const openStore: (options?: StoreOptions) => Promise<MessageStore>;
 export * from "./exports.js";

package/dist/store/store.js

@@ -41,6 +41,7 @@ import { syncStoreOver } from "./sync.js";
 import { tagsStoreOver } from "./tags.js";
 import { accountVectorsOver, vectorsStoreOver } from "./vectors.js";
 export { BACKFILL_ON_OPEN } from "./sqlite/open-store.js";
+export { fileFacts, readStoreTables } from "./sqlite/store-tables.js";
 export const openStore = async (options = {}) => {
     const context = await openStoreContext(options);
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.426.0",
+  "version": "0.427.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",
@@ -213,7 +213,7 @@
     "@types/node": "^22.20.4",
     "@types/pngjs": "6.0.5",
     "@vitest/coverage-v8": "^5.0.2",
-    "@wirecat/cli-base": "0.53.0",
+    "@wirecat/cli-base": "0.56.0",
     "@wirecat/cli-core-legacy-tags": "npm:@wirecat/cli-core@0.414.0",
     "commander": "15.0.0",
     "cspell": "10.3.6",
@@ -234,7 +234,7 @@
   },
   "peerDependencies": {
     "@napi-rs/canvas": ">=0.1.69 <2",
-    "@wirecat/cli-base": ">=0.53.0 <0.54.0",
+    "@wirecat/cli-base": ">=0.56.0 <0.57.0",
     "commander": ">=15"
   },
   "bin": {

package/parity.json

@@ -4207,6 +4207,12 @@
       }
     },
     "skill show": {
+      "in": "all",
+      "options": {
+        "--for": "all"
+      }
+    },
+    "skill status": {
       "in": "all"
     },
     "stats": {
@@ -4614,6 +4620,12 @@
     "store status": {
       "in": "all"
     },
+    "store tables": {
+      "in": "all"
+    },
+    "store tables list": {
+      "in": "all"
+    },
     "tags": {
       "in": "all"
     },