@wirecat/cli-core 0.558.0 → 0.560.0

package/dist/store/sqlite/schema.d.ts

@@ -14890,6 +14890,359 @@ export declare const paymentAllocations: import("drizzle-orm/sqlite-core").SQLit
     dialect: 'sqlite';
     isAlias: false;
 }>;
+/** What a source said about one of its records, as it said it: the layer under the entity an import makes. */
+export declare const records: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "records";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "records";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        accountId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "records";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        type: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "records";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        externalId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "records";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        fields: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "records";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        revision: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "records";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        fingerprint: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "records";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        entityType: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "records";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        entityId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "records";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        projectedFingerprint: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "records";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        batchId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "records";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "records";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        updatedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "records";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        deletedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "records";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+    };
+    dialect: 'sqlite';
+    isAlias: false;
+}>;
+export declare const recordRelations: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "record_relations";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "record_relations";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        recordId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "record_relations";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        role: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "record_relations";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        targetType: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "record_relations";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        targetExternalId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "record_relations";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        targetId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "record_relations";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "record_relations";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+    };
+    dialect: 'sqlite';
+    isAlias: false;
+}>;
 export declare const proposedActions: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
     name: "proposed_actions";
     schema: undefined;

package/dist/store/sqlite/schema.js

@@ -1492,6 +1492,43 @@ export const paymentAllocations = sqliteTable("payment_allocations", {
     index("payment_allocations_by_invoice_id").on(table.invoiceId),
     index("payment_allocations_by_author_type_author_id").on(table.authorType, table.authorId),
 ]);
+/** What a source said about one of its records, as it said it: the layer under the entity an import makes. */
+export const records = sqliteTable("records", {
+    id: integer("id").primaryKey(),
+    accountId: integer("account_id")
+        .notNull()
+        .references(() => accounts.id),
+    type: text("type").notNull(),
+    externalId: text("external_id").notNull(),
+    fields: text("fields").notNull(),
+    revision: integer("revision"),
+    fingerprint: text("fingerprint").notNull(),
+    entityType: text("entity_type"),
+    entityId: integer("entity_id"),
+    projectedFingerprint: text("projected_fingerprint"),
+    batchId: text("batch_id").notNull(),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull(),
+    deletedAt: integer("deleted_at"),
+}, (table) => [
+    unique().on(table.accountId, table.type, table.externalId),
+    index("records_by_entity_type_entity_id").on(table.entityType, table.entityId),
+]);
+export const recordRelations = sqliteTable("record_relations", {
+    id: integer("id").primaryKey(),
+    recordId: integer("record_id")
+        .notNull()
+        .references(() => records.id),
+    role: text("role").notNull(),
+    targetType: text("target_type").notNull(),
+    targetExternalId: text("target_external_id").notNull(),
+    targetId: integer("target_id").references(() => records.id),
+    createdAt: integer("created_at").notNull(),
+}, (table) => [
+    unique().on(table.recordId, table.role, table.targetType, table.targetExternalId),
+    index("record_relations_by_target_type_target_external_id").on(table.targetType, table.targetExternalId),
+    index("record_relations_by_target_id").on(table.targetId),
+]);
 export const proposedActions = sqliteTable("proposed_actions", {
     id: integer("id").primaryKey(),
     kind: text("kind").notNull(),

package/dist/store/sqlite/tasks.d.ts

@@ -36,4 +36,6 @@ export interface StoreTaskStore extends Omit<Required<TaskStore>, "reviewDuplica
         closeSuggestion: CloseSuggestion | null;
     }[]>;
 }
+/** The inbox project of a task account (`telegram:100`), made the first time `create` asks for it. */
+export declare const inboxProject: ({ database, now }: Pick<StoreContext, "database" | "now">, account: string, create: boolean) => number | undefined;
 export declare const taskStoreOver: (context: StoreContext) => StoreTaskStore;

package/dist/store/sqlite/tasks.js

@@ -18,32 +18,34 @@ export { inboxKey, linkInbox, taskAccountOf } from "./task-keys.js";
 export { taskIdOf, taskRowOf } from "./things.js";
 const COLUMNS = "t.id AS row_id, t.package_id, t.source_locator, t.source_kind, t.source_group, t.type, t.status, t.close_reason, t.source, t.created_at, t.due_at, t.closed_at, " +
     "t.closed_by_type, t.closed_by_id, t.key, t.category, t.claimed_by, t.claimed_until, p.name AS account";
+/** The inbox project of a task account (`telegram:100`), made the first time `create` asks for it. */
+export const inboxProject = ({ database, now }, account, create) => {
+    const key = inboxKey(account);
+    const found = database.prepare("SELECT id FROM projects WHERE key = ?").get(key);
+    if (!create)
+        return found ? Number(found.id) : undefined;
+    const [provider, external] = [account.slice(0, account.indexOf(":")), account.slice(account.indexOf(":") + 1)];
+    const owning = database
+        .prepare("SELECT id FROM accounts WHERE provider = ? AND external_id = ?")
+        .get(provider, external);
+    const accountId = owning ? Number(owning.id) : null;
+    // A task can arrive before its messenger saved the account; the project learns it on a later task.
+    if (found) {
+        if (accountId !== null)
+            database
+                .prepare("UPDATE projects SET account_id = ? WHERE id = ? AND account_id IS NULL")
+                .run(accountId, Number(found.id));
+        return Number(found.id);
+    }
+    const at = now();
+    return Number(database
+        .prepare("INSERT INTO projects (key, name, name_folded, description, type, account_id, scope, tasks_count, status, created_at, updated_at) " +
+        "VALUES (?, ?, ?, ?, 'personal', ?, 'personal', 0, 'active', ?, ?) RETURNING id")
+        .get(key, account, folded(account), `What waits on the owner in ${account}`, accountId, at, at)?.id);
+};
 export const taskStoreOver = (context) => {
     const { database, now } = context;
-    const inbox = (account, create) => {
-        const key = inboxKey(account);
-        const found = database.prepare("SELECT id FROM projects WHERE key = ?").get(key);
-        if (!create)
-            return found ? Number(found.id) : undefined;
-        const [provider, external] = [account.slice(0, account.indexOf(":")), account.slice(account.indexOf(":") + 1)];
-        const owning = database
-            .prepare("SELECT id FROM accounts WHERE provider = ? AND external_id = ?")
-            .get(provider, external);
-        const accountId = owning ? Number(owning.id) : null;
-        // A task can arrive before its messenger saved the account; the project learns it on a later task.
-        if (found) {
-            if (accountId !== null)
-                database
-                    .prepare("UPDATE projects SET account_id = ? WHERE id = ? AND account_id IS NULL")
-                    .run(accountId, Number(found.id));
-            return Number(found.id);
-        }
-        const at = now();
-        return Number(database
-            .prepare("INSERT INTO projects (key, name, name_folded, description, type, account_id, scope, tasks_count, status, created_at, updated_at) " +
-            "VALUES (?, ?, ?, ?, 'personal', ?, 'personal', 0, 'active', ?, ?) RETURNING id")
-            .get(key, account, folded(account), `What waits on the owner in ${account}`, accountId, at, at)?.id);
-    };
+    const inbox = (account, create) => inboxProject(context, account, create);
     // A task made here has no package id and may be a type the package does not know; the package never sees it.
     const select = (where) => database.prepare(`SELECT ${COLUMNS} FROM tasks t JOIN projects p ON p.id = t.project_id WHERE t.package_id IS NOT NULL AND ${where}`);
     const toTask = (row) => {

package/dist/store/sqlite/test-accounts.d.ts

@@ -0,0 +1,8 @@
+import type { StoreContext } from "./open.js";
+/** Set by store version 48 and deleted once the purge ran. */
+export declare const TEST_ACCOUNTS_TO_PURGE = "test_accounts_to_purge";
+/**
+ * Removes every account of the test provider, as `cache clear` removes one. A failure keeps the key for the next open
+ * and only warns: a leftover test account must never stop the owner's store from opening.
+ */
+export declare const purgeTestAccounts: (context: StoreContext, warn: (line: string) => void) => number;

package/dist/store/sqlite/test-accounts.js

@@ -0,0 +1,31 @@
+import { purgeAccount } from "./accounts.js";
+import { write } from "./transaction.js";
+/** Set by store version 48 and deleted once the purge ran. */
+export const TEST_ACCOUNTS_TO_PURGE = "test_accounts_to_purge";
+/** The fake messenger of `src/testing/shared-program.ts`; no tool writes it. */
+const TEST_PROVIDER = "chat";
+/**
+ * Removes every account of the test provider, as `cache clear` removes one. A failure keeps the key for the next open
+ * and only warns: a leftover test account must never stop the owner's store from opening.
+ */
+export const purgeTestAccounts = (context, warn) => {
+    const { database } = context;
+    if (!database.prepare("SELECT 1 AS found FROM store_settings WHERE key = ?").get(TEST_ACCOUNTS_TO_PURGE))
+        return 0;
+    try {
+        return write(database, () => {
+            const pks = database
+                .prepare("SELECT id FROM accounts WHERE provider = ? ORDER BY id")
+                .all(TEST_PROVIDER)
+                .map((row) => Number(row.id));
+            for (const pk of pks)
+                purgeAccount(context, pk);
+            database.prepare("DELETE FROM store_settings WHERE key = ?").run(TEST_ACCOUNTS_TO_PURGE);
+            return pks.length;
+        });
+    }
+    catch (error) {
+        warn(`could not remove the test accounts from the store; the next open tries again: ${String(error)}`);
+        return 0;
+    }
+};

package/dist/store/sqlite/work-tasks.d.ts

@@ -232,6 +232,7 @@ export declare const checkRevision: (row: Row, expected: number | undefined) =>
 type WorkTaskOperations = Omit<WorkTasks, "create" | "assign"> & {
     create(input: NewWorkTask, by: Author): TaskDetails;
     assign(id: string, assignment: TaskAssignment, by: Author, check?: RevisionCheck): TaskDetails;
+    editNow(id: string, fields: TaskFields, by: Author): TaskDetails;
 };
 export declare const workTaskOperationsOver: (context: StoreContext) => WorkTaskOperations;
 export declare const workTasksOver: (context: StoreContext) => WorkTasks;

package/dist/store/sqlite/work-tasks.js

@@ -396,6 +396,12 @@ export const workTaskOperationsOver = (context) => {
             });
             return details(task);
         },
+        /** `edit` inside the caller's write, so a decision that edits a task rolls back with it. */
+        editNow: (id, fields, by) => {
+            const task = required(id);
+            write(database, () => edit(task, fields, authorActor(context, by).actor));
+            return details(task);
+        },
         move: async (id, move, by, check = {}) => {
             const task = required(id);
             return write(database, () => {

package/dist/store/store.d.ts

@@ -9,6 +9,7 @@ import { type ConversationsStore } from "./conversations.js";
 import { type CountersStore } from "./counters.js";
 import { type DecisionPolicy } from "./decisions.js";
 import type { EvidenceFindingsStore } from "./evidence-findings.js";
+import type { MailFindingsStore } from "./mail-findings.js";
 import type { MeetingFindingsStore } from "./meeting-findings.js";
 import { type MentionsStore } from "./mentions.js";
 import { type MessagesStore } from "./messages.js";
@@ -35,6 +36,7 @@ import { type SourceMentionStore } from "./sqlite/mention-sources.js";
 import { type NotesStore } from "./sqlite/notes.js";
 import { type StoreOptions } from "./sqlite/open-store.js";
 import { type ProposedActionsStore } from "./sqlite/proposed-actions.js";
+import { type RecordStore } from "./sqlite/records.js";
 import { type StoreTaskStore } from "./sqlite/tasks.js";
 import { type SyncStore } from "./sync.js";
 import { type TagsStore } from "./tags.js";
@@ -93,11 +95,15 @@ export interface MessageStore {
     readonly meetingFindings: MeetingFindingsStore;
     /** Cited facts and follow-ups about one project from stored messages, mail and documents, for review. */
     readonly evidenceFindings: EvidenceFindingsStore;
+    /** What an agent read in new mail, cited and staged per mailbox; only the owner decides it. */
+    readonly mailFindings: MailFindingsStore;
     /** What any ref names, a page of them at a time: read once per page, never once per row. */
     readonly refs: RefsStore;
     readonly facts: FactsStore;
     /** Invoices, payments and their allocations, in exact minor units; an agent's or an import's wait for the owner. */
     readonly finance: FinanceStore;
+    /** What each import said, by the source's identity; `ingest` (services) is the way in. */
+    readonly records: RecordStore;
     /** What agents concluded: summaries, digests, facts, preferences, each with evidence and a scope. */
     readonly memories: MemoriesStore;
     /** What an agent wants done outside the store, waiting for the owner's approval. */

package/dist/store/store.js

@@ -28,6 +28,7 @@ import { financeStoreOver } from "./sqlite/finance.js";
 import { involvementStoreOver } from "./sqlite/involvements.js";
 import { knowledgeStoreOver } from "./sqlite/knowledge.js";
 import { logPruner } from "./sqlite/log-pruning.js";
+import { mailFindingsStoreOver } from "./sqlite/mail-findings.js";
 import { meetingFindingsStoreOver } from "./sqlite/meeting-findings.js";
 import { meetingVectorsOver } from "./sqlite/meeting-vectors.js";
 import { meetingStoreOver } from "./sqlite/meetings.js";
@@ -38,6 +39,7 @@ import { notesStoreOver } from "./sqlite/notes.js";
 import { openStoreContext } from "./sqlite/open-store.js";
 import { projectAnnotationStoreOver } from "./sqlite/project-transfer/store.js";
 import { proposedActionsStoreOver } from "./sqlite/proposed-actions.js";
+import { recordStoreOver } from "./sqlite/records.js";
 import { refSummariesOf } from "./sqlite/ref-summaries.js";
 import * as stems from "./sqlite/stems.js";
 import { taskStoreOver } from "./sqlite/tasks.js";
@@ -107,11 +109,13 @@ const storeOver = (context) => {
     const calendar = once(() => ({ ...eventStoreOver(context), ...eventSearchOver(context) }));
     const meetingFindings = once(() => meetingFindingsStoreOver(context));
     const evidenceFindings = once(() => evidenceFindingsStoreOver(context));
+    const mailFindings = once(() => mailFindingsStoreOver(context));
     const refs = {
         summaries: async (texts, options) => refSummariesOf(context.database, texts, options),
     };
     const facts = once(() => factsStoreOver(context));
     const finance = once(() => financeStoreOver(context));
+    const records = once(() => recordStoreOver(context));
     const memories = once(() => memoriesStoreOver(context));
     const proposedActions = once(() => proposedActionsStoreOver(context));
     const agentActions = once(() => agentActionsStoreOver(context, pruneLogsWhenDue));
@@ -209,12 +213,18 @@ const storeOver = (context) => {
         get evidenceFindings() {
             return evidenceFindings();
         },
+        get mailFindings() {
+            return mailFindings();
+        },
         get facts() {
             return facts();
         },
         get finance() {
             return finance();
         },
+        get records() {
+            return records();
+        },
         get memories() {
             return memories();
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.558.0",
+  "version": "0.560.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",
@@ -25,9 +25,11 @@
     "CHANGELOG.md",
     "LICENSE",
     "THIRD_PARTY_NOTICES",
-    "docs/search/recipes.json"
+    "docs/search/recipes.json",
+    "schemas"
   ],
   "exports": {
+    "./schemas/records-envelope.v1.schema.json": "./schemas/records-envelope.v1.schema.json",
     "./documents": {
       "types": "./dist/documents.d.ts",
       "default": "./dist/documents.js"