@wirecat/cli-core 0.546.0 → 0.547.0

package/dist/store/sqlite/facts.js

@@ -1,12 +1,14 @@
 import { CliError } from "@wirecat/cli-base";
 import { FACT_TYPES, MEMORY_SCOPES } from "../../domain/knowledge.js";
 import { calendarMoment } from "../../domain/moment.js";
+import { assertMayDecide, assertMayWithdraw, deciderAuthor } from "../decisions.js";
+import { proposedBySql, proposerOf } from "./actors.js";
 import { evidenceSourcesOf } from "./evidence-sources.js";
 import { linkKind } from "./link-kinds.js";
 import { authorActor, authorOf, dropLinksOf, erase, evidenceOf, keepHighestId, linkEvidence, nextId, projectOf, subjectOf, } from "./memories.js";
 import { requiredThing } from "./notes.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 NAMED = "SELECT f.*, b.name AS author_name, b.kind AS author_kind 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();
 const oneOf = (value, allowed, what) => {
     if (typeof value !== "string" || !allowed.includes(value))
@@ -42,15 +44,32 @@ export const factOperationsOver = (context) => {
             throw new CliError("validation_error", `${reference} is not a fact`);
         return database.prepare(`${NAMED} WHERE f.id = ?`).get(thing.id);
     };
-    const accept = (id) => {
+    const withdrawn = (row, by) => assertMayWithdraw({
+        id: `fact:${row.id}`,
+        proposedBy: proposerOf(database, row.author_type, row.author_id),
+        proposed: row.status === "proposed",
+    }, by);
+    const decided = (row, by) => assertMayDecide({ id: `fact:${row.id}`, proposedBy: proposerOf(database, row.author_type, row.author_id) }, by, context.decisions);
+    /** Keeps who decided for the owner and why in `metadata.decision`; the decider's actor is in `confirmed_by`. */
+    const keepDecision = (id, by, reason) => {
+        const why = [by === "owner" ? undefined : by.reason.trim(), reason?.trim() || undefined].filter(Boolean).join(": ");
+        if (by === "owner" && !why)
+            return;
+        const decision = by === "owner" ? { by: "owner", reason: why } : { by: "agent", bot: by.bot, reason: why };
+        database
+            .prepare("UPDATE facts SET metadata = json_set(coalesce(metadata, '{}'), '$.decision', json(?)) WHERE id = ?")
+            .run(JSON.stringify(decision), id);
+    };
+    const accept = (id, by = "owner", reason) => {
         const row = database.prepare("SELECT * FROM facts WHERE id = ?").get(id);
         if (row.status !== "proposed" && row.status !== "accepted")
             throw new CliError("validation_error", `a ${String(row.status)} fact cannot be accepted`);
-        const { actor } = authorActor(context, "owner");
+        const { actor } = authorActor(context, deciderAuthor(by));
         const at = now();
         database
             .prepare("UPDATE facts SET status = 'accepted', confirmed_by_type = ?, confirmed_by_id = ?, updated_at = ? WHERE id = ?")
             .run(actor.type, actor.id, at, id);
+        keepDecision(id, by, reason);
         if (row.supersedes_id != null)
             database
                 .prepare("UPDATE facts SET status = 'superseded', updated_at = ? WHERE id = ? AND status IN ('proposed', 'accepted')")
@@ -100,20 +119,29 @@ export const factOperationsOver = (context) => {
         list: (options = {}) => {
             const project = options.project === undefined ? undefined : requiredThing(database, options.project, "the project");
             const subject = options.subject === undefined ? undefined : requiredThing(database, options.subject);
+            const by = proposedBySql("f.author_type", "f.author_id", options.proposedBy);
+            const order = options.order === "created" ? "f.created_at" : "coalesce(f.occurred_at, f.created_at)";
             return database
                 .prepare(`${NAMED} WHERE f.deleted_at IS NULL AND (? IS NULL OR f.type = ?) AND (? IS NULL OR f.project_id = ?) ` +
                 "AND (? IS NULL OR (f.subject_type = ? AND f.subject_id = ?)) AND (? IS NULL OR f.status = ?) " +
-                "ORDER BY coalesce(f.occurred_at, f.created_at) DESC, f.id DESC LIMIT ?")
-                .all(options.type ?? null, options.type ?? null, project?.id ?? null, project?.id ?? null, subject?.type ?? null, subject?.type ?? null, subject?.id ?? null, options.status ?? null, options.status ?? null, Math.min(Math.max(options.limit ?? 100, 1), 500))
+                `AND ${by.sql} ORDER BY ${order} DESC, f.id DESC LIMIT ?`)
+                .all(options.type ?? null, options.type ?? null, project?.id ?? null, project?.id ?? null, subject?.type ?? null, subject?.type ?? null, subject?.id ?? null, options.status ?? null, options.status ?? null, ...by.params, Math.min(Math.max(options.limit ?? 100, 1), 500))
                 .map(factOf);
         },
-        accept: (reference) => {
+        accept: (reference, by, reason) => {
+            const row = rowOf(reference);
+            decided(row, by);
+            write(database, () => accept(Number(row.id), by, reason));
+            return factOf(rowOf(reference));
+        },
+        acceptChecked: (reference, by) => {
             const id = Number(rowOf(reference).id);
-            write(database, () => accept(id));
+            write(database, () => accept(id, by));
             return factOf(rowOf(reference));
         },
-        reverse: (reference) => {
+        reverse: (reference, by) => {
             const row = rowOf(reference);
+            assertMayWithdraw({ id: `fact:${row.id}`, proposedBy: { type: "unknown" }, proposed: false }, by);
             if (row.type !== "decision")
                 throw new CliError("validation_error", "only a decision can be reversed");
             if (row.status !== "accepted")
@@ -121,15 +149,20 @@ 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) => {
+        reject: (reference, by, reason) => {
             const row = rowOf(reference);
+            decided(row, by);
             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));
+            write(database, () => {
+                database.prepare("UPDATE facts SET status = 'rejected', updated_at = ? WHERE id = ?").run(now(), Number(row.id));
+                keepDecision(Number(row.id), by, reason);
+            });
             return factOf(rowOf(reference));
         },
-        remove: (reference) => {
+        remove: (reference, by) => {
             const row = rowOf(reference);
+            withdrawn(row, by);
             const id = Number(row.id);
             const twin = row.source === "memory" && row.metadata != null ? migratedFrom(String(row.metadata)) : undefined;
             const links = erase(database, () => {
@@ -165,10 +198,10 @@ export const factsStoreOver = (context) => {
         add: async (input) => operations.add(input),
         get: async (reference) => operations.get(reference),
         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),
+        accept: async (reference, by, reason) => operations.accept(reference, by, reason),
+        reverse: async (reference, by) => operations.reverse(reference, by),
+        reject: async (reference, by, reason) => operations.reject(reference, by, reason),
+        remove: async (reference, by) => operations.remove(reference, by),
         sources: async (reference) => operations.sources(reference),
     };
 };

package/dist/store/sqlite/findings-core.d.ts

@@ -1,4 +1,5 @@
 import { type Finding, type FindingEvidence, type FindingOutcome, type FindingsInput } from "../../meetings/index.js";
+import type { Decider } from "../decisions.js";
 import type { StoreContext } from "./open.js";
 export interface FindingsAgent {
     bot: string;
@@ -14,5 +15,5 @@ export declare const findingsCoreOver: (context: StoreContext, kind: string) =>
     snapshot: (input: FindingsInput, cite: (evidence: FindingEvidence, finding: Finding, projectId: string | null, seen: Map<string, unknown>) => void) => string;
     snapshotParts: (input: FindingsInput, cite: (evidence: FindingEvidence, finding: Finding, projectId: string | null, seen: Map<string, unknown>) => void) => Record<string, string>;
     previous: (account: number | null, fingerprint: string) => FindingOutcome | undefined;
-    outcomes: (account: number | null, input: FindingsInput, accepted: string[], agent: FindingsAgent) => FindingOutcome[];
+    outcomes: (account: number | null, input: FindingsInput, accepted: string[], agent: FindingsAgent, decidedBy: Decider) => FindingOutcome[];
 };

package/dist/store/sqlite/findings-core.js

@@ -68,7 +68,7 @@ export const findingsCoreOver = (context, kind) => {
             .get(account, kind, fingerprint);
         return row ? JSON.parse(String(row.item)) : undefined;
     };
-    const create = (finding, agent) => {
+    const create = (finding, agent, decidedBy) => {
         const evidence = finding.evidence.map((item) => item.reference);
         if (finding.kind === "fact") {
             const fact = facts.add({
@@ -79,7 +79,7 @@ export const findingsCoreOver = (context, kind) => {
                 evidence,
                 by: agent,
             });
-            return facts.accept(fact.ref).ref;
+            return facts.acceptChecked(fact.ref, decidedBy).ref;
         }
         if (finding.project === undefined)
             return invalid("a task finding names the project the task goes in");
@@ -99,7 +99,7 @@ export const findingsCoreOver = (context, kind) => {
         return task.ref;
     };
     /** Reuses an earlier decision on an unchanged candidate; refuses to accept one that was rejected. */
-    const outcomes = (account, input, accepted, agent) => input.findings.map((finding) => {
+    const outcomes = (account, input, accepted, agent, decidedBy) => input.findings.map((finding) => {
         const fingerprint = findingFingerprint(finding);
         const prior = previous(account, fingerprint);
         if (prior) {
@@ -112,7 +112,7 @@ export const findingsCoreOver = (context, kind) => {
             id: finding.id,
             fingerprint,
             status,
-            reference: status === "accepted" ? create(finding, agent) : null,
+            reference: status === "accepted" ? create(finding, agent, decidedBy) : null,
             reused: false,
         };
     });

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

@@ -1,8 +1,13 @@
 import { type QueryAst } from "@wirecat/cli-base/query";
+import { type Decider } from "../decisions.js";
 import type { AccountKey } from "../types.js";
 import { RELATION_KINDS } from "./link-kinds.js";
 import { type MeetingProjectsStore } from "./meeting-projects.js";
+import type { Author } from "./memories.js";
+import { type Link } from "./notes.js";
 import type { StoreContext } from "./open.js";
+import type { ProposedAction } from "./proposed-actions.js";
+import { type LinkDecision } from "./relation-proposals.js";
 import type { TagCreationOptions } from "./tag-creation.js";
 import { type Label, type TagKind, type TagRow } from "./tags.js";
 import { type ThingState } from "./things.js";
@@ -177,21 +182,43 @@ export interface KnowledgeStore extends VocabularyStore, MeetingProjectsStore {
         description?: string;
     }): Promise<Project>;
     projects(query?: QueryAst): Promise<Project[]>;
-    relate(key: KnowledgeScope, input: {
+    /** The owner's relationship is a link; `confirmed: false` keeps it a weak suggestion only the owner decides. */
+    relate(key: KnowledgeScope, input: RelateInput & {
+        by: "owner";
+    }): Promise<KnowledgeRelation>;
+    /** An agent's relationship is a `relationship` proposal for the owner, never a link. */
+    relate(key: KnowledgeScope, input: RelateInput & {
+        by: Exclude<Author, "owner">;
+    }): Promise<ProposedAction>;
+    /**
+     * An agent's or a rule's relationship, written as a `relationship` proposal for the owner instead of a link. The
+     * same pending pair returns the proposal already held.
+     */
+    proposeRelation(key: KnowledgeScope, input: {
         from: string;
         to: string;
         kind: KnowledgeRelation["kind"];
         role?: string;
-        evidence?: string;
-        confirmed?: boolean;
-        provenance?: string;
-    }): Promise<KnowledgeRelation>;
+        evidence?: string[];
+        reason?: string;
+    }, by: Exclude<Author, "owner">): Promise<ProposedAction>;
+    /** Decides a stored `relationship` or `key_document` proposal; the link and the decision land together. */
+    decideLinkProposal(id: string, decision: LinkDecision): Promise<{
+        proposal: ProposedAction;
+        link: Link | null;
+    }>;
+    /** Decides an unconfirmed link written before proposals were stored. Its author is unknown, so only the owner may. */
+    decideSuggestedLink(id: string, decision: LinkDecision): Promise<Link | null>;
     relations(key: KnowledgeScope, reference?: string): Promise<KnowledgeRelation[]>;
-    removeRelation(key: KnowledgeScope, id: string): Promise<{
+    /**
+     * Removing an unconfirmed relationship rejects it, so `by` must be allowed to decide it. Removing a link to a
+     * project, or rejecting any suggestion, leaves a rejected `relationship` proposal so a scan never proposes it again.
+     */
+    removeRelation(key: KnowledgeScope, id: string, by: Decider): Promise<{
         id: string;
         removed: true;
     }>;
-    confirmRelation(key: KnowledgeScope, id: string): Promise<KnowledgeRelation>;
+    confirmRelation(key: KnowledgeScope, id: string, by: Decider): Promise<KnowledgeRelation>;
     schedule(key: AccountKey, task: string, dueAt: string, timezone: string): Promise<Reminder>;
     reminders(key: AccountKey, query?: QueryAst): Promise<Reminder[]>;
     cancelReminder(key: AccountKey, id: string): Promise<Reminder>;
@@ -202,4 +229,13 @@ export interface KnowledgeStore extends VocabularyStore, MeetingProjectsStore {
     }): Promise<Reminder[]>;
     acknowledgeReminder(key: AccountKey, id: string, receipt: string): Promise<Reminder>;
 }
+export interface RelateInput {
+    from: string;
+    to: string;
+    kind: KnowledgeRelation["kind"];
+    role?: string;
+    evidence?: string;
+    confirmed?: boolean;
+    provenance?: string;
+}
 export declare const knowledgeStoreOver: (context: StoreContext) => KnowledgeStore;

package/dist/store/sqlite/knowledge.js

@@ -6,6 +6,7 @@ import { normalizeTag } from "../../domain/tags.js";
 import { normalizeVocabularyName } from "../../domain/vocabulary.js";
 import { formatMeetingReference } from "../../meetings/index.js";
 import { isClosedState } from "../../tasks/index.js";
+import { assertMayDecide } from "../decisions.js";
 import { fold } from "../normalize.js";
 import { ulid } from "../ulid.js";
 import { ownerPerson } from "./actors.js";
@@ -14,6 +15,7 @@ import { meetingProjectsStoreOver } from "./meeting-projects.js";
 import { holdingText } from "./note-index.js";
 import { insertLink, linkOf } from "./notes.js";
 import { queryFilter } from "./query-filter.js";
+import { relationProposalsOver } from "./relation-proposals.js";
 import { addTags as addThingTags, canonicalTagNamed, createTag, labelsOf, liveTagging, removeTags as removeThingTags, setMainTopic, } from "./tags.js";
 import { INBOX_KEY_LENGTH, TASK_KEY_PREFIXES } from "./task-keys.js";
 import { inboxKey, taskAccountOf, taskIdOf, taskRowOf } from "./tasks.js";
@@ -24,6 +26,11 @@ const TYPED_KEY_PREFIXES = new Set(Object.values(TASK_KEY_PREFIXES));
 export const ORGANIZATION_KINDS = ["company", "team", "family", "community"];
 export const PROJECT_TYPES = ["work", "client", "personal", "oss", "other"];
 export const SCOPES = ["personal", "work"];
+/**
+ * A link records no actor, only free-text provenance anyone could write, so whoever proposed one is unverified and
+ * only the owner decides it.
+ */
+const UNVERIFIED = { type: "unknown" };
 const iso = (value) => new Date(Number(value)).toISOString();
 const bounded = (limit = 100, offset = 0) => {
     if (!Number.isInteger(limit) ||
@@ -226,6 +233,7 @@ export const knowledgeStoreOver = (context) => {
         confidenceCategory: link.confirmed ? "owner-confirmed" : "weak",
         createdAt: link.createdAt,
     });
+    const proposals = relationProposalsOver(context);
     const RELATIONS = `SELECT * FROM links WHERE kind IN (${RELATION_KINDS.map(linkKind).join(",")}) AND to_id IS NOT NULL`;
     const relation = (id) => {
         const row = /^\d+$/.test(id) ? database.prepare(`${RELATIONS} AND id = ?`).get(Number(id)) : undefined;
@@ -233,6 +241,19 @@ export const knowledgeStoreOver = (context) => {
             throw new CliError("not_found", "no relationship with that id");
         return row;
     };
+    /** The two ends of a relationship, checked, and the link that already joins them. */
+    const pair = (key, input) => {
+        const from = related(key, input.from, true);
+        const to = related(key, input.to);
+        if ((from.type === to.type && from.id === to.id) || !RELATION_KINDS.includes(input.kind))
+            throw new CliError("validation_error", "a relationship needs distinct references and a supported kind");
+        if ((from.type === "chat" || from.type === "email_thread") && (input.kind !== "member-of" || to.type !== "project"))
+            throw new CliError("validation_error", "a chat is related only as member-of a project");
+        const existing = database
+            .prepare(`${RELATIONS} AND from_type=? AND from_id=? AND to_type=? AND to_id=? AND kind=?`)
+            .get(from.type, from.id, to.type, to.id, input.kind);
+        return { from, to, existing };
+    };
     /** A chat may only be the member: its reference names its own account, so it is never another account's. */
     const related = (key, reference, member = false) => {
         checked(key);
@@ -517,17 +538,19 @@ export const knowledgeStoreOver = (context) => {
                 .all(...(where?.params ?? []))
                 .map(projectOf);
         },
-        relate: async (key, input) => {
-            const from = related(key, input.from, true);
-            const to = related(key, input.to);
-            if ((from.type === to.type && from.id === to.id) || !RELATION_KINDS.includes(input.kind))
-                throw new CliError("validation_error", "a relationship needs distinct references and a supported kind");
-            if ((from.type === "chat" || from.type === "email_thread") &&
-                (input.kind !== "member-of" || to.type !== "project"))
-                throw new CliError("validation_error", "a chat is related only as member-of a project");
-            const existing = database
-                .prepare(`${RELATIONS} AND from_type=? AND from_id=? AND to_type=? AND to_id=? AND kind=?`)
-                .get(from.type, from.id, to.type, to.id, input.kind);
+        relate: (async (key, input) => {
+            if (input.by === undefined)
+                throw new CliError("validation_error", "a relationship names who writes it: the owner or an agent", {
+                    reason: "proposal.decider-required",
+                });
+            const { from, existing } = pair(key, input);
+            if (input.by !== "owner") {
+                if (existing)
+                    throw new CliError("validation_error", `relationship ${String(existing.id)} already links them`, {
+                        reason: "relationship.exists",
+                    });
+                return proposals.propose(from, { ...input, ...(input.evidence === undefined ? {} : { reason: input.evidence }), evidence: [] }, input.by);
+            }
             if (existing)
                 return relationOf(linkOf(database, existing));
             const confirmed = input.confirmed !== false;
@@ -541,7 +564,17 @@ export const knowledgeStoreOver = (context) => {
                 ...(input.evidence === undefined ? {} : { evidence: input.evidence }),
                 ...(input.provenance === undefined ? {} : { provenance: input.provenance }),
             })));
+        }),
+        proposeRelation: async (key, input, by) => {
+            const { from, existing } = pair(key, input);
+            if (existing)
+                throw new CliError("validation_error", `relationship ${String(existing.id)} already links them`, {
+                    reason: "relationship.exists",
+                });
+            return proposals.propose(from, input, by);
         },
+        decideLinkProposal: async (id, decision) => proposals.decideProposal(id, decision),
+        decideSuggestedLink: async (id, decision) => proposals.decideLink(id, decision),
         relations: async (key, reference) => {
             checked(key);
             const thing = reference === undefined ? undefined : thingOf(database, reference);
@@ -552,16 +585,23 @@ export const knowledgeStoreOver = (context) => {
                 .all(thing?.type ?? null, thing?.type ?? null, thing?.id ?? null, thing?.type ?? null, thing?.id ?? null)
                 .map((row) => relationOf(linkOf(database, row)));
         },
-        removeRelation: async (key, id) => {
+        removeRelation: async (key, id, by) => {
             checked(key);
-            relation(id);
-            database.prepare("DELETE FROM links WHERE id = ?").run(Number(id));
+            const row = relation(id);
+            const link = linkOf(database, row);
+            assertMayDecide({ id: `link:${id}`, proposedBy: UNVERIFIED }, by, context.decisions);
+            write(database, () => {
+                if (!link.confirmed || String(row.to_type) === "project")
+                    proposals.rejected(link, by);
+                database.prepare("DELETE FROM links WHERE id = ?").run(Number(id));
+            });
             return { id, removed: true };
         },
-        confirmRelation: async (key, id) => {
+        confirmRelation: async (key, id, by) => {
             checked(key);
             const row = relation(id);
             const link = linkOf(database, row);
+            assertMayDecide({ id: `link:${id}`, proposedBy: UNVERIFIED }, by, context.decisions);
             related(key, link.from, true);
             related(key, String(link.to));
             database

package/dist/store/sqlite/meeting-findings.js

@@ -1,5 +1,6 @@
 import { CliError } from "@wirecat/cli-base";
 import { findingHash, MEETING_FINDINGS_KIND, meetingCueFingerprint, meetingFindingFingerprint, parseMeetingReference, validateMeetingFindings, } from "../../meetings/index.js";
+import { assertMayDecide, deciderAuthor } from "../decisions.js";
 import { findingsCoreOver } from "./findings-core.js";
 import { authorActor } from "./memories.js";
 import { proposalOperationsOver } from "./proposed-actions.js";
@@ -176,6 +177,9 @@ export const meetingFindingsStoreOver = (context) => {
                 decision.accept.some((candidate) => !batch.input.findings.some((finding) => finding.id === candidate)))
                 return invalid("accept only unique IDs shown in this batch");
             const accepted = [...decision.accept].sort();
+            if (decision.by === undefined)
+                return invalid("a findings review names who decides: the owner or an agent");
+            assertMayDecide({ id, proposedBy: proposals.proposer(id) }, decision.by, context.decisions);
             if (batch.receipt) {
                 if (JSON.stringify(batch.receipt.accepted) !== JSON.stringify(accepted))
                     return invalid("this findings batch was already reviewed with a different decision");
@@ -191,12 +195,8 @@ export const meetingFindingsStoreOver = (context) => {
                 bot: proposal.proposedBy.name,
                 ...(input.agentModel === null ? {} : { model: input.agentModel }),
             };
-            const items = core.outcomes(account, batch.input, accepted, agent);
-            return view(proposals.approve(id, {
-                previewFingerprint: batch.fingerprint,
-                accepted,
-                items,
-            }));
+            const items = core.outcomes(account, batch.input, accepted, agent, decision.by);
+            return view(proposals.approve(id, { previewFingerprint: batch.fingerprint, accepted, items }, deciderAuthor(decision.by)));
         }),
     };
 };

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

@@ -1,12 +1,14 @@
 import { MEMORY_KINDS, MEMORY_SCOPES, type MEMORY_STATUSES } from "../../domain/knowledge.js";
-import { type Actor } from "./actors.js";
+import { type Decider } from "../decisions.js";
+import { type Actor, type ProposedByFilter } 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. */
+/** Who wrote it: the owner, or an agent (or a rule scorer) by its bot handle and the model it ran on. */
 export type Author = "owner" | {
     bot: string;
     model?: string;
+    kind?: "agent" | "rule";
 };
 export interface Memory {
     id: string;
@@ -22,11 +24,12 @@ export interface Memory {
     /** The project it belongs to, as `project:<id>`. */
     project: string | null;
     projectName: string | null;
-    /** `name` is a bot's handle; `null` for a person. */
+    /** `name` is a bot's handle and `kind` whether it is an agent or a rule; both `null` for a person. */
     author: {
         type: Actor["type"];
         id: string;
         name: string | null;
+        kind: "agent" | "rule" | null;
     };
     model: string | null;
     confidence: number | null;
@@ -63,21 +66,22 @@ export interface MemoriesStore {
         kind?: Memory["kind"];
         status?: Memory["status"];
         scope?: Memory["scope"];
+        proposedBy?: ProposedByFilter;
         limit?: number;
     }): Promise<Memory[]>;
     /** Moves it to another project, or to none with `null`. */
     update(reference: string, change: {
         project: string | null;
     }): Promise<Memory>;
-    /** The owner stands behind it; its evidence was checked now. */
-    confirm(reference: string): Promise<Memory>;
-    /** Its evidence no longer holds. */
-    markStale(reference: string): Promise<Memory>;
+    /** The owner, or an agent for the owner, stands behind it; its evidence was checked now. */
+    confirm(reference: string, by: Decider): Promise<Memory>;
+    /** Its evidence no longer holds; for an agent's memory this is how it is turned down, so `by` must be allowed. */
+    markStale(reference: string, by: Decider): 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<{
+    remove(reference: string, by: Decider): Promise<{
         ref: string;
         removed: true;
         links: number;

package/dist/store/sqlite/memories.js

@@ -1,7 +1,8 @@
 import { CliError } from "@wirecat/cli-base";
 import { MEMORY_KINDS, MEMORY_SCOPES } from "../../domain/knowledge.js";
+import { assertMayDecide, assertMayWithdraw } from "../decisions.js";
 import { normalize } from "../normalize.js";
-import { botNamed, ownerPerson } from "./actors.js";
+import { botNamed, ownerPerson, proposedBySql, proposerOf } from "./actors.js";
 import { evidenceSourcesOf } from "./evidence-sources.js";
 import { linkKind } from "./link-kinds.js";
 import { CORPORA, corpusIndexState, drainCorpus } from "./note-index.js";
@@ -9,7 +10,7 @@ import { requiredThing } from "./notes.js";
 import { stemmerCache } from "./stems.js";
 import { referenceOfThing, storedThing } from "./things.js";
 import { write } from "./transaction.js";
-const NAMED = "SELECT m.*, b.name AS author_name FROM memories m LEFT JOIN bots b ON m.author_type = 'bot' AND b.id = m.author_id";
+const NAMED = "SELECT m.*, b.name AS author_name, b.kind AS author_kind FROM memories m LEFT JOIN bots b ON m.author_type = 'bot' AND b.id = m.author_id";
 const iso = (value) => new Date(Number(value)).toISOString();
 const oneOf = (value, allowed, what) => {
     if (typeof value !== "string" || !allowed.includes(value))
@@ -20,7 +21,7 @@ export const authorActor = (context, author) => {
     if (author === "owner")
         return { actor: ownerPerson(context.database), model: null };
     return {
-        actor: botNamed(context.database, author.bot, context.now(), "agent"),
+        actor: botNamed(context.database, author.bot, context.now(), author.kind ?? "agent"),
         model: author.model === undefined ? null : author.model.trim().slice(0, 200) || null,
     };
 };
@@ -28,6 +29,7 @@ export const authorOf = (row) => ({
     type: row.author_type,
     id: String(row.author_id),
     name: row.author_name == null ? null : String(row.author_name),
+    kind: row.author_type !== "bot" ? null : row.author_kind === "rule" || row.author_name === "rule" ? "rule" : "agent",
 });
 /** Writes `evidence` links from a row to each reference, refusing one the store does not hold. */
 export const linkEvidence = (context, from, references, author) => {
@@ -153,6 +155,10 @@ export const memoriesStoreOver = (context) => {
             throw new CliError("not_found", `${reference} is a fact now: store.facts holds it`);
         return row;
     };
+    const decided = (reference, by) => {
+        const row = rowOf(reference);
+        assertMayDecide({ id: `memory:${row.id}`, proposedBy: proposerOf(database, row.author_type, row.author_id) }, by, context.decisions);
+    };
     const setStatus = (reference, status, verified) => {
         const row = rowOf(reference);
         const at = now();
@@ -179,6 +185,10 @@ export const memoriesStoreOver = (context) => {
             if (input.confidence !== undefined && !(input.confidence >= 0 && input.confidence <= 1))
                 throw new CliError("validation_error", "confidence takes 0–1");
             const status = oneOf(input.status ?? "proposed", ["proposed", "confirmed"], "a new memory's status");
+            if (status === "confirmed" && input.author !== "owner")
+                throw new CliError("permission_error", "an agent's memory waits as proposed; only the owner confirms it", {
+                    reason: "proposal.owner-only",
+                });
             const id = write(database, () => {
                 const { actor, model } = authorActor(context, input.author);
                 const subject = input.subject === undefined ? undefined : requiredThing(database, input.subject, "the subject");
@@ -201,11 +211,12 @@ export const memoriesStoreOver = (context) => {
         list: async (options = {}) => {
             const subject = options.subject === undefined ? undefined : requiredThing(database, options.subject);
             const project = options.project === undefined ? null : projectId(database, options.project);
+            const by = proposedBySql("m.author_type", "m.author_id", options.proposedBy);
             return database
                 .prepare(`${NAMED} WHERE m.deleted_at IS NULL AND (? IS NULL OR (m.subject_type = ? AND m.subject_id = ?)) ` +
                 "AND (? IS NULL OR m.project_id = ?) AND (? IS NULL OR m.kind = ?) AND (? IS NULL OR m.status = ?) AND (? IS NULL OR m.scope = ?) " +
-                "ORDER BY m.created_at DESC, m.id DESC LIMIT ?")
-                .all(subject?.type ?? null, subject?.type ?? null, subject?.id ?? null, project, project, options.kind ?? null, options.kind ?? null, options.status ?? null, options.status ?? null, options.scope ?? null, options.scope ?? null, Math.min(Math.max(options.limit ?? 100, 1), 500))
+                `AND ${by.sql} ORDER BY m.created_at DESC, m.id DESC LIMIT ?`)
+                .all(subject?.type ?? null, subject?.type ?? null, subject?.id ?? null, project, project, options.kind ?? null, options.kind ?? null, options.status ?? null, options.status ?? null, options.scope ?? null, options.scope ?? null, ...by.params, Math.min(Math.max(options.limit ?? 100, 1), 500))
                 .map(memoryOf);
         },
         update: async (reference, change) => write(database, () => {
@@ -214,10 +225,22 @@ export const memoriesStoreOver = (context) => {
             database.prepare("UPDATE memories SET project_id = ?, updated_at = ? WHERE id = ?").run(project, now(), id);
             return memoryOf(rowOf(`memory:${id}`));
         }),
-        confirm: async (reference) => setStatus(reference, "confirmed", true),
-        markStale: async (reference) => setStatus(reference, "stale", false),
-        remove: async (reference) => {
-            const id = Number(rowOf(reference).id);
+        confirm: async (reference, by) => {
+            decided(reference, by);
+            return setStatus(reference, "confirmed", true);
+        },
+        markStale: async (reference, by) => {
+            decided(reference, by);
+            return setStatus(reference, "stale", false);
+        },
+        remove: async (reference, by) => {
+            const row = rowOf(reference);
+            assertMayWithdraw({
+                id: `memory:${row.id}`,
+                proposedBy: proposerOf(database, row.author_type, row.author_id),
+                proposed: row.status === "proposed",
+            }, by);
+            const id = Number(row.id);
             const links = erase(database, () => {
                 keepHighestId(database, "memories", now());
                 database.prepare("UPDATE memories SET supersedes_id = NULL WHERE supersedes_id = ?").run(id);
@@ -238,7 +261,7 @@ export const memoriesStoreOver = (context) => {
                 throw new CliError("validation_error", "say what to find in the memories");
             const match = `normalized_text : (${words.map((word) => `"${word.replaceAll('"', '""')}"*`).join(" AND ")})`;
             return database
-                .prepare("SELECT m.*, b.name AS author_name FROM memory_words w JOIN memories m ON m.id = w.rowid " +
+                .prepare("SELECT m.*, b.name AS author_name, b.kind AS author_kind FROM memory_words w JOIN memories m ON m.id = w.rowid " +
                 "LEFT JOIN bots b ON m.author_type = 'bot' AND b.id = m.author_id WHERE memory_words MATCH ? " +
                 "AND m.deleted_at IS NULL AND (? IS NULL OR (m.subject_type = ? AND m.subject_id = ?)) " +
                 "AND (? IS NULL OR m.scope = ?) ORDER BY bm25(memory_words), m.id LIMIT ?")

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

@@ -1,4 +1,5 @@
 import type { Section } from "../../readers/types.js";
+import { type Decider } from "../decisions.js";
 import type { CacheDatabase } from "../driver.js";
 import { type DocumentMetadata } from "./document-metadata.js";
 import { type ImportedDocuments } from "./imported-documents.js";
@@ -81,6 +82,8 @@ export interface LinkInput {
     evidence?: string;
     provenance?: string;
     confirmed?: boolean;
+    /** Who writes it: a confirmed link needs the owner. */
+    by?: Decider;
 }
 export interface FileNoteInput {
     folderId: string;
@@ -151,7 +154,8 @@ export interface NotesStore extends NoteSearch, ImportedDocuments {
     }>;
     addLink(input: LinkInput): Promise<Link>;
     links(options?: LinkListFilter): Promise<Link[]>;
-    removeLink(id: string): Promise<{
+    /** Only the owner removes a link: it records no actor, so who proposed it cannot be checked. */
+    removeLink(id: string, by: Decider): Promise<{
         id: string;
         removed: true;
     }>;