@wirecat/cli-core 0.545.0 → 0.547.0

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

@@ -3,13 +3,13 @@ import type { Attachment, Metadata } from "../../meetings/index.js";
 import type { Stemmer, Stemmers } from "../../search/stem.js";
 import type { CacheDatabase } from "../driver.js";
 import type { ConversationSummary, StoredHit } from "../types.js";
-import { type EmailLocationInput, type FolderEmail } from "./email-locations.js";
+import { type EmailLocationInput, type FolderEmail, type PartialEmail } from "./email-locations.js";
 import { type MailRulesStore } from "./mail-rules.js";
 import { type AttachmentInput } from "./meetings.js";
 import type { StoreContext } from "./open.js";
 import { type SyncStateSave } from "./sync.js";
 import { type ThreadFilter } from "./thread-columns.js";
-export type { EmailLocationInput, FolderEmail };
+export type { EmailLocationInput, FolderEmail, PartialEmail };
 export interface EmailAddress {
     address: string;
     name: string | null;
@@ -217,6 +217,10 @@ export interface MailStore {
     emails(filter?: EmailFilter): Promise<Email[]>;
     /** Each matching email's Message-ID and mailboxes, without text or people: cheap over a whole mailbox. */
     emailRefs(filter?: Omit<EmailFilter, "limit" | "offset">): Promise<EmailRef[]>;
+    partialEmails(accountId: number, limit: number): Promise<{
+        emails: PartialEmail[];
+        total: number;
+    }>;
     /** Each matching email's sender, recipients, list, size, flag and mailboxes, oldest first; no text. */
     emailFacts(filter?: Omit<EmailFilter, "limit" | "offset">): Promise<EmailFacts[]>;
     /**

package/dist/store/sqlite/emails.js

@@ -2,7 +2,7 @@ import { formatLocator } from "../../domain/locator.js";
 import { formatReference } from "../../domain/references.js";
 import { fold, normalize } from "../normalize.js";
 import { chunkAttachments, drainEmailIndex, dropAttachmentChunks, MAIL_PIECES, queueThreads, threadPieces, titleOf, } from "./email-index.js";
-import { folderEmails, forgetLocations, locate, setLocations, } from "./email-locations.js";
+import { folderEmails, forgetLocations, locate, partialEmails, setLocations, } from "./email-locations.js";
 import { markEmailsDeleted, markEmailsRestored, recountEmailThread as recount, setEmailFlags } from "./email-state.js";
 import { bool, flag, fromJson, int, page, str, toJson } from "./events.js";
 import { folded } from "./folded.js";
@@ -469,6 +469,7 @@ export const mailStoreOver = ({ database, orm, now }, stemmerFor = stemmerCache(
             mailboxes: JSON.parse(String(row.boxes)),
         }));
     },
+    partialEmails: async (accountId, limit) => partialEmails(database, accountId, limit),
     async emailFacts(filter = {}) {
         const [where, params] = emailWhere(filter);
         return database

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

@@ -1,6 +1,7 @@
 import { CliError } from "@wirecat/cli-base";
 import { contextEvidenceFingerprint } from "../../context/evidence.js";
 import { findingFingerprint, findingHash } from "../../meetings/index.js";
+import { assertMayDecide } from "../decisions.js";
 import { EVIDENCE_FINDINGS_KIND, validateEvidenceFindings, } from "../evidence-findings.js";
 import { contextRecordOf } from "./context-evidence.js";
 import { sourcesOfReferences } from "./evidence-sources.js";
@@ -80,8 +81,10 @@ export const evidenceFindingsStoreOver = (context) => {
     };
     const snapshot = (input) => core.snapshot(input, cite());
     const decider = (by) => {
-        if (by === undefined || by === "owner")
+        if (by === "owner")
             return { author: "owner", decision: { by: "owner" } };
+        if (by === undefined)
+            return invalid("a findings review names who decides: the owner or an agent with a reason");
         const raw = by;
         const agent = findingsAgent({
             bot: raw.bot,
@@ -157,7 +160,14 @@ export const evidenceFindingsStoreOver = (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();
-            const { author, decision: decidedBy } = decider(decision.by);
+            const { author, decision: checked } = decider(decision.by);
+            const reason = typeof decision.reason === "string" ? decision.reason.trim().slice(0, 2000) : "";
+            const decidedBy = reason && checked.by === "owner"
+                ? { ...checked, reason }
+                : reason && checked.by === "agent"
+                    ? { ...checked, reason: `${checked.reason}: ${reason}` }
+                    : checked;
+            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");
@@ -187,7 +197,7 @@ export const evidenceFindingsStoreOver = (context) => {
                 bot: proposal.proposedBy.name,
                 ...(input.agentModel === null ? {} : { model: input.agentModel }),
             };
-            const items = core.outcomes(null, batch.input, accepted, agent);
+            const items = core.outcomes(null, batch.input, accepted, agent, decision.by);
             return view(proposals.approve(id, {
                 previewFingerprint: batch.fingerprint,
                 accepted,

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

@@ -1,5 +1,5 @@
 import { linkKind } from "./link-kinds.js";
-import { canonicalThingReference, referenceOfThing, stateOfThing, storedThing, thingOf } from "./things.js";
+import { referenceOfThing, stateOfThing, storedThing, thingOf } from "./things.js";
 const EXCERPT_CHARS = 280;
 const excerptOf = (text) => {
     if (text == null)
@@ -59,7 +59,7 @@ export const evidenceSourcesOf = (database, from) => database
     .map((link) => sourceOf(database, storedThing(link.to_type, link.to_id)));
 const thingNamed = (database, reference) => {
     try {
-        return thingOf(database, canonicalThingReference(reference));
+        return thingOf(database, reference);
     }
     catch {
         return undefined;

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 Decider } from "../decisions.js";
+import { type Actor, type ProposedByFilter } from "./actors.js";
 import { type EvidenceSource } from "./evidence-sources.js";
 import { type Author } from "./memories.js";
 import type { StoreContext } from "./open.js";
@@ -18,11 +19,12 @@ export interface Fact {
     subjectIsOwner: boolean;
     occurredAt: string | null;
     supersedes: 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;
     confirmedBy: {
@@ -59,19 +61,22 @@ export interface FactsStore {
         project?: string;
         subject?: string;
         status?: Fact["status"];
+        proposedBy?: ProposedByFilter;
+        /** `created` lists the newest written first; by default the newest by when it happened. */
+        order?: "occurred" | "created";
         limit?: number;
     }): Promise<Fact[]>;
-    /** The owner accepts a proposed fact; the fact it supersedes stops holding. */
-    accept(reference: string): Promise<Fact>;
+    /** The owner, or an agent for the owner, accepts a proposed fact; the fact it supersedes stops holding. */
+    accept(reference: string, by: Decider, reason?: 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>;
+    reverse(reference: string, by: Decider): Promise<Fact>;
+    /** The owner, or an agent for the owner, turns down a proposed fact; it stays, marked `rejected`. */
+    reject(reference: string, by: Decider, reason?: 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<{
+    remove(reference: string, by: Decider): Promise<{
         ref: string;
         removed: true;
         links: number;
@@ -81,6 +86,9 @@ export interface FactsStore {
 }
 type FactOperations = {
     [K in keyof FactsStore]: FactsStore[K] extends (...args: infer A) => Promise<infer R> ? (...args: A) => R : never;
+} & {
+    /** Accepts as part of a decision already checked, such as a reviewed findings batch. */
+    acceptChecked(reference: string, by: Decider): Fact;
 };
 export declare const factOperationsOver: (context: StoreContext) => FactOperations;
 export declare const factsStoreOver: (context: StoreContext) => FactsStore;

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/identities.js

@@ -205,7 +205,7 @@ export const people = ({ orm, database }, provider, { account, accounts: native
         }
     }
     const byId = new Map(everyone.map((person) => [person.id, person]));
-    return { get: (id) => byId.get(id), all: () => everyone };
+    return { provider, get: (id) => byId.get(id), all: () => everyone };
 };
 const contactsWhere = (accountKey, key, { query, notes }) => {
     if (query !== undefined && query.trim().length < 3) {

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) ||
@@ -127,7 +134,7 @@ export const knowledgeStoreOver = (context) => {
         if (thing.type === "meeting")
             return { type: "meeting", id: String(thing.id) };
         const reference = referenceOfThing(database, thing);
-        if (reference === undefined || reference.startsWith("meeting:"))
+        if (reference === undefined)
             return undefined;
         const parsed = parseReference(reference);
         if (parsed.type === "message")
@@ -136,7 +143,12 @@ export const knowledgeStoreOver = (context) => {
             return { type: "chat", id: parsed.chat };
         if (parsed.type === "folder")
             return { type: "folder", id: parsed.id, path: parsed.path };
-        if (parsed.type === "entity" || parsed.type === "memory" || parsed.type === "fact" || parsed.type === "bot")
+        if (parsed.type === "entity" ||
+            parsed.type === "memory" ||
+            parsed.type === "fact" ||
+            parsed.type === "bot" ||
+            parsed.type === "event" ||
+            parsed.type === "meeting")
             return undefined;
         return { type: parsed.type, id: parsed.id };
     };
@@ -221,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;
@@ -228,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);
@@ -512,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;
@@ -536,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);
@@ -547,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)));
         }),
     };
 };