@wirecat/cli-core 0.499.0 → 0.500.0

package/CHANGELOG.md

@@ -7,6 +7,26 @@ shape of this file.
 
 ## Unreleased
 
+## 0.500.0 — 31.10.2026
+
+### Added
+
+- **A memory or fact can be forgotten for good.** `store.memories.remove(ref)` and `store.facts.remove(ref)` erase the
+  row, every link from or to it, its tags, and its words, pieces and vectors in the search indexes, in one write. The
+  words indexes are merged and freed pages zeroed (`secure_delete`), so the text is not left in the file; the
+  write-ahead log is emptied when no reader holds it. A record that replaced it no longer names it (`supersedes:
+  null`). Removing a fact also erases the soft-deleted memory it was migrated from in version 2, which still held its
+  text. Both answer `{ ref, removed: true, links }`, where `links` counts the links erased.
+- **`store.facts.reject(ref)`** turns down a proposed fact: `FACT_STATUSES` gains `rejected`.
+- **`store.memories.sources(ref)` and `store.facts.sources(ref)`** read each evidence link back as an `EvidenceSource`:
+  `ref`, `kind`, `title`, `sender`, `at`, `excerpt` (280 characters at most), `tool` and `missing`. A source deleted
+  since is still listed, `missing: true` with no excerpt, where `evidence` leaves it out; `ref` is `null` when its row
+  is gone from the store.
+- **`Memory` and `Fact` carry `subjectName` and `subjectIsOwner`.** A person is named by their name, else the
+  owner's alias for them, else an identity's name; a project or organization by its name. The owner has no name in the
+  store, so `subjectName` is `null` and `subjectIsOwner` is `true`. The `memory` and `fact` entities gain optional
+  `subject_name`, `subject_is_owner` and `sources`.
+
 ## 0.499.0 — 31.10.2026
 
 ### Added

package/dist/domain/knowledge.d.ts

@@ -1,5 +1,5 @@
 export declare const FACT_TYPES: readonly ["fact", "statement", "question", "decision", "promise"];
-export declare const FACT_STATUSES: readonly ["proposed", "accepted", "superseded", "reversed"];
+export declare const FACT_STATUSES: readonly ["proposed", "accepted", "superseded", "reversed", "rejected"];
 export declare const MEMORY_KINDS: readonly ["summary", "digest", "preference"];
 export declare const MEMORY_STATUSES: readonly ["proposed", "confirmed", "stale", "superseded"];
 export declare const MEMORY_SCOPES: readonly ["personal", "work"];

package/dist/domain/knowledge.js

@@ -1,6 +1,6 @@
 import { TASK_KINDS } from "../tasks/index.js";
 export const FACT_TYPES = ["fact", "statement", "question", "decision", "promise"];
-export const FACT_STATUSES = ["proposed", "accepted", "superseded", "reversed"];
+export const FACT_STATUSES = ["proposed", "accepted", "superseded", "reversed", "rejected"];
 export const MEMORY_KINDS = ["summary", "digest", "preference"];
 export const MEMORY_STATUSES = ["proposed", "confirmed", "stale", "superseded"];
 export const MEMORY_SCOPES = ["personal", "work"];

package/dist/entities/fact.d.ts

@@ -4,9 +4,12 @@ export declare const fact: v.StrictObjectSchema<{
     readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
     readonly kind: v.PicklistSchema<readonly ["fact", "statement", "question", "decision", "promise"], undefined>;
     readonly text: v.StringSchema<undefined>;
-    readonly status: v.PicklistSchema<readonly ["proposed", "accepted", "superseded", "reversed"], undefined>;
+    readonly status: v.PicklistSchema<readonly ["proposed", "accepted", "superseded", "reversed", "rejected"], undefined>;
     readonly project: v.NullableSchema<v.StringSchema<undefined>, undefined>;
     readonly subject: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+    /** What the subject is called; `null` for the owner and for a row with no name. */
+    readonly subject_name: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+    readonly subject_is_owner: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
     readonly occurred_at: v.NullableSchema<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>;
     readonly supersedes: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
     readonly author: v.StrictObjectSchema<{
@@ -24,6 +27,17 @@ export declare const fact: v.StrictObjectSchema<{
     /** Who recorded it: the owner, or an agent whose fact waits as proposed. */
     readonly origin: v.PicklistSchema<["owner", "agent"], undefined>;
     readonly evidence: v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+    /** With `--sources`: each piece of evidence read back. */
+    readonly sources: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
+        readonly ref: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+        readonly kind: v.StringSchema<undefined>;
+        readonly title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly sender: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly at: v.NullableSchema<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>;
+        readonly excerpt: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly tool: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly missing: v.BooleanSchema<undefined>;
+    }, undefined>, undefined>, undefined>;
     readonly created_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 updated_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>;

package/dist/entities/fact.js

@@ -1,6 +1,6 @@
 import * as v from "valibot";
 import { FACT_STATUSES, FACT_TYPES, MEMORY_SCOPES } from "../domain/knowledge.js";
-import { author, id, reference, text, time } from "./fields.js";
+import { author, evidenceSource, id, reference, text, time } from "./fields.js";
 export const fact = v.strictObject({
     ref: reference,
     id,
@@ -9,6 +9,9 @@ export const fact = v.strictObject({
     status: v.picklist(FACT_STATUSES),
     project: v.nullable(text),
     subject: v.nullable(reference),
+    /** What the subject is called; `null` for the owner and for a row with no name. */
+    subject_name: v.optional(v.nullable(text)),
+    subject_is_owner: v.optional(v.boolean()),
     occurred_at: v.nullable(time),
     supersedes: v.nullable(reference),
     author,
@@ -19,6 +22,8 @@ export const fact = v.strictObject({
     /** Who recorded it: the owner, or an agent whose fact waits as proposed. */
     origin: v.picklist(["owner", "agent"]),
     evidence: v.array(reference),
+    /** With `--sources`: each piece of evidence read back. */
+    sources: v.optional(v.array(evidenceSource)),
     created_at: time,
     updated_at: time,
 });

package/dist/entities/fields.d.ts

@@ -10,6 +10,17 @@ export declare const count: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>
 /** Fields of an answer item someone other than the owner wrote, as dotted paths: an agent reads them as data. */
 export declare const untrusted: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
 export declare const providerMetadata: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>;
+/** A reference a memory or fact rests on, read back; `missing` once it was deleted since. */
+export declare const evidenceSource: v.StrictObjectSchema<{
+    readonly ref: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+    readonly kind: v.StringSchema<undefined>;
+    readonly title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly sender: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly at: v.NullableSchema<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>;
+    readonly excerpt: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly tool: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly missing: v.BooleanSchema<undefined>;
+}, undefined>;
 export declare const author: v.StrictObjectSchema<{
     readonly type: v.PicklistSchema<["person", "bot"], undefined>;
     readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;

package/dist/entities/fields.js

@@ -10,6 +10,17 @@ export const count = v.pipe(v.number(), v.integer(), v.minValue(0));
 /** Fields of an answer item someone other than the owner wrote, as dotted paths: an agent reads them as data. */
 export const untrusted = v.optional(v.array(text));
 export const providerMetadata = v.optional(v.record(v.string(), v.unknown()));
+/** A reference a memory or fact rests on, read back; `missing` once it was deleted since. */
+export const evidenceSource = v.strictObject({
+    ref: v.nullable(reference),
+    kind: text,
+    title: v.nullable(text),
+    sender: v.nullable(text),
+    at: v.nullable(time),
+    excerpt: v.nullable(text),
+    tool: v.nullable(text),
+    missing: v.boolean(),
+});
 export const author = v.strictObject({
     type: v.picklist(["person", "bot"]),
     id,

package/dist/entities/index.d.ts

@@ -5340,9 +5340,11 @@ export declare const ENTITIES: {
         readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
         readonly kind: v.PicklistSchema<readonly ["fact", "statement", "question", "decision", "promise"], undefined>;
         readonly text: v.StringSchema<undefined>;
-        readonly status: v.PicklistSchema<readonly ["proposed", "accepted", "superseded", "reversed"], undefined>;
+        readonly status: v.PicklistSchema<readonly ["proposed", "accepted", "superseded", "reversed", "rejected"], undefined>;
         readonly project: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly subject: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+        readonly subject_name: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+        readonly subject_is_owner: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
         readonly occurred_at: v.NullableSchema<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>;
         readonly supersedes: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
         readonly author: v.StrictObjectSchema<{
@@ -5358,6 +5360,16 @@ export declare const ENTITIES: {
         readonly scope: v.NullableSchema<v.PicklistSchema<readonly ["personal", "work"], undefined>, undefined>;
         readonly origin: v.PicklistSchema<["owner", "agent"], undefined>;
         readonly evidence: v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+        readonly sources: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
+            readonly ref: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+            readonly kind: v.StringSchema<undefined>;
+            readonly title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly sender: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly at: v.NullableSchema<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>;
+            readonly excerpt: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly tool: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly missing: v.BooleanSchema<undefined>;
+        }, undefined>, undefined>, undefined>;
         readonly created_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 updated_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>;
@@ -5367,6 +5379,8 @@ export declare const ENTITIES: {
         readonly kind: v.PicklistSchema<readonly ["summary", "digest", "preference"], undefined>;
         readonly text: v.StringSchema<undefined>;
         readonly subject: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+        readonly subject_name: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+        readonly subject_is_owner: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
         readonly author: v.StrictObjectSchema<{
             readonly type: v.PicklistSchema<["person", "bot"], undefined>;
             readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
@@ -5378,6 +5392,16 @@ export declare const ENTITIES: {
         readonly scope: v.PicklistSchema<readonly ["personal", "work"], undefined>;
         readonly supersedes: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
         readonly evidence: v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+        readonly sources: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
+            readonly ref: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+            readonly kind: v.StringSchema<undefined>;
+            readonly title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly sender: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly at: v.NullableSchema<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>;
+            readonly excerpt: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly tool: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly missing: v.BooleanSchema<undefined>;
+        }, undefined>, undefined>, undefined>;
         readonly last_verified_at: v.NullableSchema<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>;
         readonly created_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 updated_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`">]>;

package/dist/entities/memory.d.ts

@@ -5,6 +5,9 @@ export declare const memory: v.StrictObjectSchema<{
     readonly kind: v.PicklistSchema<readonly ["summary", "digest", "preference"], undefined>;
     readonly text: v.StringSchema<undefined>;
     readonly subject: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+    /** What the subject is called; `null` for the owner and for a row with no name. */
+    readonly subject_name: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+    readonly subject_is_owner: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
     readonly author: v.StrictObjectSchema<{
         readonly type: v.PicklistSchema<["person", "bot"], undefined>;
         readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
@@ -16,6 +19,17 @@ export declare const memory: v.StrictObjectSchema<{
     readonly scope: v.PicklistSchema<readonly ["personal", "work"], undefined>;
     readonly supersedes: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
     readonly evidence: v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+    /** With `--sources`: each piece of evidence read back. */
+    readonly sources: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
+        readonly ref: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+        readonly kind: v.StringSchema<undefined>;
+        readonly title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly sender: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly at: v.NullableSchema<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>;
+        readonly excerpt: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly tool: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly missing: v.BooleanSchema<undefined>;
+    }, undefined>, undefined>, undefined>;
     readonly last_verified_at: v.NullableSchema<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>;
     readonly created_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 updated_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`">]>;

package/dist/entities/memory.js

@@ -1,12 +1,15 @@
 import * as v from "valibot";
 import { MEMORY_KINDS, MEMORY_SCOPES, MEMORY_STATUSES } from "../domain/knowledge.js";
-import { author, id, reference, text, time } from "./fields.js";
+import { author, evidenceSource, id, reference, text, time } from "./fields.js";
 export const memory = v.strictObject({
     ref: reference,
     id,
     kind: v.picklist(MEMORY_KINDS),
     text,
     subject: v.nullable(reference),
+    /** What the subject is called; `null` for the owner and for a row with no name. */
+    subject_name: v.optional(v.nullable(text)),
+    subject_is_owner: v.optional(v.boolean()),
     author,
     model: v.nullable(text),
     confidence: v.nullable(v.number()),
@@ -14,6 +17,8 @@ export const memory = v.strictObject({
     scope: v.picklist(MEMORY_SCOPES),
     supersedes: v.nullable(reference),
     evidence: v.array(reference),
+    /** With `--sources`: each piece of evidence read back. */
+    sources: v.optional(v.array(evidenceSource)),
     last_verified_at: v.nullable(time),
     created_at: time,
     updated_at: time,

package/dist/store/index.d.ts

@@ -31,6 +31,7 @@ export { CATALOG_QUERY } from "./sqlite/catalog.js";
 export type { ChatMetadata } from "./sqlite/chats.js";
 export type { Email, EmailAddress, EmailAttachment, EmailFacts, EmailFilter, EmailInput, EmailInThread, EmailLocationInput, EmailRecipient, EmailRef, EmailThread, EmailVectorHit, FolderEmail, Mailbox, MailboxInput, MailFilter, MailStore, SenderScore, ThreadDetails, ThreadSave, } from "./sqlite/emails.js";
 export { EVENT_FIELDS, type EventChunkToEmbed, type EventHit, type EventQuery, type EventSearch, type NearestEvent, } from "./sqlite/event-search.js";
+export type { EvidenceSource } from "./sqlite/evidence-sources.js";
 export type { Fact, FactInput, FactsStore } from "./sqlite/facts.js";
 export type { FileListQuery, FilesStore, StoredFile } from "./sqlite/files.js";
 export { IMPORTED_DOCUMENT_QUERY, type ImportedDocuments } from "./sqlite/imported-documents.js";

package/dist/store/project-transfer/request.d.ts

@@ -6,7 +6,7 @@ export declare const projectAnnotationRequest: (request: ProjectAnnotationTarget
             ref: string;
             type: "decision" | "fact" | "promise" | "question" | "statement";
             statement: string;
-            status: "accepted" | "proposed" | "reversed" | "superseded";
+            status: "accepted" | "proposed" | "rejected" | "reversed" | "superseded";
             subject: string | null;
             occurred_at: number | null;
             supersedes: string | null;

package/dist/store/project-transfer/schema.d.ts

@@ -25,7 +25,7 @@ export declare const projectAnnotationsSchema: v.StrictObjectSchema<{
         readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, number, undefined>]>;
         readonly type: v.PicklistSchema<readonly ["fact", "statement", "question", "decision", "promise"], undefined>;
         readonly statement: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, number, undefined>]>;
-        readonly status: v.PicklistSchema<readonly ["proposed", "accepted", "superseded", "reversed"], undefined>;
+        readonly status: v.PicklistSchema<readonly ["proposed", "accepted", "superseded", "reversed", "rejected"], undefined>;
         readonly subject: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
         readonly occurred_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.SafeIntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
         readonly supersedes: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
@@ -40,7 +40,7 @@ export declare const projectAnnotationsSchema: v.StrictObjectSchema<{
         ref: string;
         type: "decision" | "fact" | "promise" | "question" | "statement";
         statement: string;
-        status: "accepted" | "proposed" | "reversed" | "superseded";
+        status: "accepted" | "proposed" | "rejected" | "reversed" | "superseded";
         subject: string | null;
         occurred_at: number | null;
         supersedes: string | null;

package/dist/store/project-transfer/snapshot-model.d.ts

@@ -6,7 +6,7 @@ export declare const projectAnnotationSnapshotSchema: v.StrictObjectSchema<{
         readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, number, undefined>]>;
         readonly type: v.PicklistSchema<readonly ["fact", "statement", "question", "decision", "promise"], undefined>;
         readonly statement: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, number, undefined>]>;
-        readonly status: v.PicklistSchema<readonly ["proposed", "accepted", "superseded", "reversed"], undefined>;
+        readonly status: v.PicklistSchema<readonly ["proposed", "accepted", "superseded", "reversed", "rejected"], undefined>;
         readonly subject: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
         readonly occurred_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.SafeIntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
         readonly supersedes: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
@@ -21,7 +21,7 @@ export declare const projectAnnotationSnapshotSchema: v.StrictObjectSchema<{
         ref: string;
         type: "decision" | "fact" | "promise" | "question" | "statement";
         statement: string;
-        status: "accepted" | "proposed" | "reversed" | "superseded";
+        status: "accepted" | "proposed" | "rejected" | "reversed" | "superseded";
         subject: string | null;
         occurred_at: number | null;
         supersedes: string | null;

package/dist/store/sqlite/evidence-sources.d.ts

@@ -0,0 +1,23 @@
+import type { CacheDatabase } from "../driver.js";
+/** One reference a memory or fact rests on, read back whole enough to judge it without opening it. */
+export interface EvidenceSource {
+    /** `null` when the row is gone from the store and its reference with it. */
+    ref: string | null;
+    kind: string;
+    title: string | null;
+    sender: string | null;
+    at: string | null;
+    excerpt: string | null;
+    /** The provider the source came through: `telegram`, `email`, `notes`, `zoom`… */
+    tool: string | null;
+    /** Deleted at its source since it was cited, or no longer in the store. */
+    missing: boolean;
+}
+/**
+ * Every `evidence` link from a memory or fact, in the order they were written, including one whose target was
+ * deleted since: `evidenceOf` drops those, so a reader would never learn the record lost a source.
+ */
+export declare const evidenceSourcesOf: (database: CacheDatabase, from: {
+    type: string;
+    id: number;
+}) => EvidenceSource[];

package/dist/store/sqlite/evidence-sources.js

@@ -0,0 +1,59 @@
+import { linkKind } from "./link-kinds.js";
+import { referenceOfThing, stateOfThing, storedThing } from "./things.js";
+const EXCERPT_CHARS = 280;
+const excerptOf = (text) => {
+    if (text == null)
+        return null;
+    const flat = String(text).replace(/\s+/g, " ").trim();
+    if (!flat)
+        return null;
+    return flat.length > EXCERPT_CHARS ? `${flat.slice(0, EXCERPT_CHARS - 1)}…` : flat;
+};
+const iso = (value) => (value == null ? null : new Date(Number(value)).toISOString());
+const textOf = (value) => (value == null || String(value).trim() === "" ? null : String(value));
+const READS = {
+    message: "SELECT c.title, coalesce(m.sender_name, i.name) AS sender, m.sent_at AS at, m.text AS body, a.provider AS tool " +
+        "FROM messages m JOIN chats c ON c.id = m.chat_id JOIN accounts a ON a.id = c.account_id " +
+        "LEFT JOIN identities i ON i.id = m.sender_identity_id WHERE m.id = ?",
+    email: "SELECT e.subject AS title, coalesce(e.from_name, e.from_address) AS sender, e.sent_at AS at, " +
+        "coalesce(e.body_text, e.snippet) AS body, 'email' AS tool FROM emails e WHERE e.id = ?",
+    note: "SELECT title, NULL AS sender, updated_at AS at, body, 'notes' AS tool FROM notes WHERE id = ?",
+    document: "SELECT d.title, NULL AS sender, coalesce(d.external_updated_at, d.updated_at) AS at, d.body, a.provider AS tool " +
+        "FROM documents d JOIN accounts a ON a.id = d.account_id WHERE d.id = ?",
+    meeting: "SELECT m.title, NULL AS sender, m.started_at AS at, m.description AS body, a.provider AS tool " +
+        "FROM meetings m JOIN accounts a ON a.id = m.account_id WHERE m.id = ?",
+    meeting_transcript: "SELECT m.title, NULL AS sender, m.started_at AS at, NULL AS body, a.provider AS tool FROM meeting_transcripts t " +
+        "JOIN meetings m ON m.id = t.meeting_id JOIN accounts a ON a.id = m.account_id WHERE t.id = ?",
+    meeting_transcript_row: "SELECT m.title, r.speaker_name AS sender, m.started_at + coalesce(r.start_ms, 0) AS at, r.text AS body, " +
+        "a.provider AS tool FROM meeting_transcript_rows r JOIN meeting_transcripts t ON t.id = r.meeting_transcript_id " +
+        "JOIN meetings m ON m.id = t.meeting_id JOIN accounts a ON a.id = m.account_id WHERE r.id = ?",
+};
+const KIND = {
+    meeting_transcript: "meeting",
+    meeting_transcript_row: "meeting",
+};
+/**
+ * Every `evidence` link from a memory or fact, in the order they were written, including one whose target was
+ * deleted since: `evidenceOf` drops those, so a reader would never learn the record lost a source.
+ */
+export const evidenceSourcesOf = (database, from) => database
+    .prepare(`SELECT to_type, to_id FROM links WHERE from_type = ? AND from_id = ? AND kind = ${linkKind("evidence")} ` +
+    "AND to_id IS NOT NULL ORDER BY id")
+    .all(from.type, from.id)
+    .map((link) => {
+    const thing = storedThing(link.to_type, link.to_id);
+    const state = stateOfThing(database, thing);
+    const read = READS[thing.type];
+    const row = read === undefined || state === "unavailable" ? undefined : database.prepare(read).get(thing.id);
+    const gone = state !== "available";
+    return {
+        ref: referenceOfThing(database, thing) ?? null,
+        kind: KIND[thing.type] ?? thing.type,
+        title: textOf(row?.title),
+        sender: textOf(row?.sender),
+        at: iso(row?.at),
+        excerpt: gone ? null : excerptOf(row?.body),
+        tool: textOf(row?.tool),
+        missing: gone,
+    };
+});

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

@@ -1,5 +1,6 @@
 import { type FACT_STATUSES, FACT_TYPES, MEMORY_SCOPES } from "../../domain/knowledge.js";
 import type { Actor } from "./actors.js";
+import { type EvidenceSource } from "./evidence-sources.js";
 import { type Author } from "./memories.js";
 import type { StoreContext } from "./open.js";
 /** What happened, as its evidence shows; its evidence is `links` of kind `evidence`. */
@@ -12,6 +13,8 @@ export interface Fact {
     status: (typeof FACT_STATUSES)[number];
     project: string | null;
     subject: string | null;
+    subjectName: string | null;
+    subjectIsOwner: boolean;
     occurredAt: string | null;
     supersedes: string | null;
     /** `name` is a bot's handle; `null` for a person. */
@@ -61,6 +64,19 @@ export interface FactsStore {
     accept(reference: string): Promise<Fact>;
     /** An accepted decision no longer holds and nothing replaced it. */
     reverse(reference: string): Promise<Fact>;
+    /** The owner turns down a proposed fact; it stays, marked `rejected`. */
+    reject(reference: string): Promise<Fact>;
+    /**
+     * Erases the fact: its row, its links, its tags, and the memory it was migrated from, which still held its text.
+     * A decision that replaced it no longer names it. A backup made before keeps it.
+     */
+    remove(reference: string): Promise<{
+        ref: string;
+        removed: true;
+        links: number;
+    }>;
+    /** Each reference it rests on, read back; one deleted since is `missing`. */
+    sources(reference: string): Promise<EvidenceSource[]>;
 }
 type FactOperations = {
     [K in keyof FactsStore]: FactsStore[K] extends (...args: infer A) => Promise<infer R> ? (...args: A) => R : never;

package/dist/store/sqlite/facts.js

@@ -1,10 +1,10 @@
 import { CliError } from "@wirecat/cli-base";
 import { FACT_TYPES, MEMORY_SCOPES } from "../../domain/knowledge.js";
 import { calendarMoment } from "../../domain/moment.js";
+import { evidenceSourcesOf } from "./evidence-sources.js";
 import { linkKind } from "./link-kinds.js";
-import { authorActor, authorOf, evidenceOf, linkEvidence } from "./memories.js";
+import { authorActor, authorOf, dropLinksOf, erase, evidenceOf, linkEvidence, subjectOf, } from "./memories.js";
 import { requiredThing } from "./notes.js";
-import { referenceOfThing, storedThing } from "./things.js";
 import { write } from "./transaction.js";
 const NAMED = "SELECT f.*, b.name AS author_name FROM facts f LEFT JOIN bots b ON f.author_type = 'bot' AND b.id = f.author_id";
 const iso = (value) => new Date(Number(value)).toISOString();
@@ -22,9 +22,7 @@ export const factOperationsOver = (context) => {
         statement: String(row.statement),
         status: row.status,
         project: row.project_id == null ? null : `project:${row.project_id}`,
-        subject: row.subject_type == null
-            ? null
-            : (referenceOfThing(database, storedThing(row.subject_type, row.subject_id)) ?? null),
+        ...subjectOf(database, row),
         occurredAt: row.occurred_at == null ? null : iso(row.occurred_at),
         supersedes: row.supersedes_id == null ? null : `fact:${row.supersedes_id}`,
         author: authorOf(row),
@@ -125,8 +123,41 @@ export const factOperationsOver = (context) => {
             database.prepare("UPDATE facts SET status = 'reversed', updated_at = ? WHERE id = ?").run(now(), Number(row.id));
             return factOf(rowOf(reference));
         },
+        reject: (reference) => {
+            const row = rowOf(reference);
+            if (row.status !== "proposed")
+                throw new CliError("validation_error", `only a proposed fact can be rejected; this one is ${String(row.status)}`);
+            database.prepare("UPDATE facts SET status = 'rejected', updated_at = ? WHERE id = ?").run(now(), Number(row.id));
+            return factOf(rowOf(reference));
+        },
+        remove: (reference) => {
+            const row = rowOf(reference);
+            const id = Number(row.id);
+            const twin = row.source === "memory" && row.metadata != null ? migratedFrom(String(row.metadata)) : undefined;
+            const links = erase(database, () => {
+                database.prepare("UPDATE facts SET supersedes_id = NULL WHERE supersedes_id = ?").run(id);
+                const count = dropLinksOf(database, { type: "fact", id });
+                database.prepare("DELETE FROM links WHERE from_type = 'fact' AND from_id = ?").run(id);
+                database.prepare("DELETE FROM taggings WHERE taggable_type = 'fact' AND taggable_id = ?").run(id);
+                database.prepare("DELETE FROM facts WHERE id = ?").run(id);
+                if (twin !== undefined)
+                    database.prepare("DELETE FROM memories WHERE id = ? AND deleted_at IS NOT NULL").run(twin);
+                return count;
+            });
+            return { ref: `fact:${id}`, removed: true, links };
+        },
+        sources: (reference) => evidenceSourcesOf(database, { type: "fact", id: Number(rowOf(reference).id) }),
     };
 };
+const migratedFrom = (metadata) => {
+    try {
+        const { memory } = JSON.parse(metadata);
+        return Number.isInteger(memory) ? Number(memory) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
 export const factsStoreOver = (context) => {
     const operations = factOperationsOver(context);
     return {
@@ -135,5 +166,8 @@ export const factsStoreOver = (context) => {
         list: async (options) => operations.list(options),
         accept: async (reference) => operations.accept(reference),
         reverse: async (reference) => operations.reverse(reference),
+        reject: async (reference) => operations.reject(reference),
+        remove: async (reference) => operations.remove(reference),
+        sources: async (reference) => operations.sources(reference),
     };
 };

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

@@ -1,5 +1,6 @@
 import { MEMORY_KINDS, MEMORY_SCOPES, type MEMORY_STATUSES } from "../../domain/knowledge.js";
 import { type Actor } from "./actors.js";
+import { type EvidenceSource } from "./evidence-sources.js";
 import { type NoteIndexState } from "./note-index.js";
 import type { StoreContext } from "./open.js";
 /** Who wrote it: the owner, or an agent by its bot handle and the model it ran on. */
@@ -14,6 +15,10 @@ export interface Memory {
     body: string;
     /** What it is about, as a reference; `null` for a general fact. */
     subject: string | null;
+    /** What the subject is called; `null` for the owner, who has no name in the store, and for a nameless row. */
+    subjectName: string | null;
+    /** The subject is the owner. */
+    subjectIsOwner: boolean;
     /** `name` is a bot's handle; `null` for a person. */
     author: {
         type: Actor["type"];
@@ -59,6 +64,17 @@ export interface MemoriesStore {
     confirm(reference: string): Promise<Memory>;
     /** Its evidence no longer holds. */
     markStale(reference: string): Promise<Memory>;
+    /**
+     * Erases the memory: its row, its text in the search and meaning indexes, and every link from or to it. A memory
+     * that replaced it no longer names it. A backup made before keeps it.
+     */
+    remove(reference: string): Promise<{
+        ref: string;
+        removed: true;
+        links: number;
+    }>;
+    /** Each reference it rests on, read back; one deleted since is `missing`. */
+    sources(reference: string): Promise<EvidenceSource[]>;
     /** Indexes what was written since, then finds memories holding every word or a longer one it starts, best first. */
     search(text: string, options?: {
         subject?: string;
@@ -82,5 +98,17 @@ export declare const evidenceOf: (context: StoreContext, from: {
     type: string;
     id: number;
 }) => string[];
+/** What a memory's or fact's subject is called, for a reader who should not have to look the reference up. */
+export declare const subjectOf: (database: StoreContext["database"], row: Row) => Pick<Memory, "subject" | "subjectName" | "subjectIsOwner">;
+/** Counts every link from or to a row and drops the ones its delete trigger does not: those pointing at it. */
+export declare const dropLinksOf: (database: StoreContext["database"], thing: {
+    type: string;
+    id: number;
+}) => number;
+/**
+ * Runs a delete so the text does not linger in the file: freed pages are zeroed, the words indexes merged so no
+ * segment still holds the erased words, and the write-ahead log emptied when no reader holds it.
+ */
+export declare const erase: <T>(database: StoreContext["database"], work: () => T) => T;
 export declare const memoriesStoreOver: (context: StoreContext) => MemoriesStore;
 export {};

package/dist/store/sqlite/memories.js

@@ -2,6 +2,7 @@ import { CliError } from "@wirecat/cli-base";
 import { MEMORY_KINDS, MEMORY_SCOPES } from "../../domain/knowledge.js";
 import { normalize } from "../normalize.js";
 import { botNamed, ownerPerson } from "./actors.js";
+import { evidenceSourcesOf } from "./evidence-sources.js";
 import { linkKind } from "./link-kinds.js";
 import { CORPORA, corpusIndexState, drainCorpus } from "./note-index.js";
 import { requiredThing } from "./notes.js";
@@ -42,6 +43,55 @@ export const evidenceOf = (context, from) => context.database
     .prepare(`SELECT to_type, to_id FROM links WHERE from_type = ? AND from_id = ? AND kind = ${linkKind("evidence")} AND to_id IS NOT NULL ORDER BY id`)
     .all(from.type, from.id)
     .flatMap((row) => referenceOfThing(context.database, storedThing(row.to_type, row.to_id)) ?? []);
+const SUBJECT_NAMES = {
+    person: "SELECT p.owner, coalesce(p.name, (SELECT a.name FROM aliases a WHERE a.aliasable_type = 'person' " +
+        "AND a.aliasable_id = p.id ORDER BY a.display DESC, a.id LIMIT 1), (SELECT i.name FROM identity_links l " +
+        "JOIN identities i ON i.id = l.identity_id WHERE l.person_id = p.id AND i.name IS NOT NULL ORDER BY i.id LIMIT 1)) " +
+        "AS name FROM persons p WHERE p.id = ?",
+    project: "SELECT 0 AS owner, name FROM projects WHERE id = ?",
+    organization: "SELECT 0 AS owner, name FROM organizations WHERE id = ?",
+};
+/** What a memory's or fact's subject is called, for a reader who should not have to look the reference up. */
+export const subjectOf = (database, row) => {
+    if (row.subject_type == null)
+        return { subject: null, subjectName: null, subjectIsOwner: false };
+    const thing = storedThing(row.subject_type, row.subject_id);
+    const read = SUBJECT_NAMES[thing.type];
+    const named = read === undefined ? undefined : database.prepare(read).get(thing.id);
+    return {
+        subject: referenceOfThing(database, thing) ?? null,
+        subjectName: named?.name == null ? null : String(named.name),
+        subjectIsOwner: Number(named?.owner) === 1,
+    };
+};
+/** Counts every link from or to a row and drops the ones its delete trigger does not: those pointing at it. */
+export const dropLinksOf = (database, thing) => {
+    const count = Number(database
+        .prepare("SELECT count(*) AS n FROM links WHERE (from_type = ? AND from_id = ?) OR (to_type = ? AND to_id = ?)")
+        .get(thing.type, thing.id, thing.type, thing.id)?.n);
+    database.prepare("DELETE FROM links WHERE to_type = ? AND to_id = ?").run(thing.type, thing.id);
+    return count;
+};
+/**
+ * Runs a delete so the text does not linger in the file: freed pages are zeroed, the words indexes merged so no
+ * segment still holds the erased words, and the write-ahead log emptied when no reader holds it.
+ */
+export const erase = (database, work) => {
+    database.exec("PRAGMA secure_delete = ON");
+    try {
+        const done = write(database, () => {
+            const result = work();
+            for (const index of ["memory_words", "memory_stems"])
+                database.prepare(`INSERT INTO ${index} (${index}) VALUES ('optimize')`).run();
+            return result;
+        });
+        database.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+        return done;
+    }
+    finally {
+        database.exec("PRAGMA secure_delete = OFF");
+    }
+};
 export const memoriesStoreOver = (context) => {
     const { database, now } = context;
     const stemmerFor = stemmerCache();
@@ -50,9 +100,7 @@ export const memoriesStoreOver = (context) => {
         ref: `memory:${row.id}`,
         kind: row.kind,
         body: String(row.body),
-        subject: row.subject_type == null
-            ? null
-            : (referenceOfThing(database, storedThing(row.subject_type, row.subject_id)) ?? null),
+        ...subjectOf(database, row),
         author: authorOf(row),
         model: row.model == null ? null : String(row.model),
         confidence: row.confidence == null ? null : Number(row.confidence),
@@ -127,6 +175,17 @@ export const memoriesStoreOver = (context) => {
         },
         confirm: async (reference) => setStatus(reference, "confirmed", true),
         markStale: async (reference) => setStatus(reference, "stale", false),
+        remove: async (reference) => {
+            const id = Number(rowOf(reference).id);
+            const links = erase(database, () => {
+                database.prepare("UPDATE memories SET supersedes_id = NULL WHERE supersedes_id = ?").run(id);
+                const count = dropLinksOf(database, { type: "memory", id });
+                database.prepare("DELETE FROM memories WHERE id = ?").run(id);
+                return count;
+            });
+            return { ref: `memory:${id}`, removed: true, links };
+        },
+        sources: async (reference) => evidenceSourcesOf(database, { type: "memory", id: Number(rowOf(reference).id) }),
         search: async (text, { subject: subjectRef, scope, limit = 20 } = {}) => {
             const subject = subjectRef === undefined ? undefined : requiredThing(database, subjectRef);
             drainCorpus(database, CORPORA.memory, stemmerFor);

package/dist/store/sqlite/project-transfer/snapshot.d.ts

@@ -7,7 +7,7 @@ export declare const projectAnnotationSnapshot: (database: CacheDatabase, projec
             ref: string;
             type: "decision" | "fact" | "promise" | "question" | "statement";
             statement: string;
-            status: "accepted" | "proposed" | "reversed" | "superseded";
+            status: "accepted" | "proposed" | "rejected" | "reversed" | "superseded";
             subject: string | null;
             occurred_at: number | null;
             supersedes: string | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.499.0",
+  "version": "0.500.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",