@wirecat/cli-core 0.546.0 → 0.548.0

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;
     }>;

package/dist/store/sqlite/notes.js

@@ -4,6 +4,7 @@ import { googleDocumentLinks } from "../../domain/google-documents.js";
 import { DOCUMENT_ACCOUNT_PROVIDERS, filesAccountSql, folderProviderOf, folderProviderSql, isDocumentAccountProvider, } from "../../domain/providers.js";
 import { parseReference } from "../../domain/references.js";
 import { normalizeTag } from "../../domain/tags.js";
+import { assertMayWithdraw } from "../decisions.js";
 import { fold } from "../normalize.js";
 import { ulid } from "../ulid.js";
 import { ownerPerson } from "./actors.js";
@@ -149,6 +150,20 @@ export const resolvePersonLinks = (database, names) => {
         if (check.get(key))
             resolveKey(database, key);
 };
+/** A confirmed link is the owner's statement, of any kind; an agent's link is written unconfirmed. */
+const ownerLink = (input) => {
+    if (input.confirmed === false)
+        return input;
+    if (input.by === undefined)
+        throw new CliError("validation_error", "a confirmed link names who writes it: the owner", {
+            reason: "proposal.decider-required",
+        });
+    if (input.by !== "owner")
+        throw new CliError("permission_error", "an agent's link is written unconfirmed; only the owner confirms one", {
+            reason: "proposal.owner-only",
+        });
+    return input;
+};
 /** Writes one link; an identical resolved link is answered instead of doubled. */
 export const insertLink = (context, input) => {
     const { database, now } = context;
@@ -592,7 +607,7 @@ export const notesStoreOver = (context) => {
             database.prepare("DELETE FROM notes WHERE id = ?").run(Number(bare));
             return { id, removed: true };
         }),
-        addLink: async (input) => write(database, () => insertLink(context, input)),
+        addLink: async (input) => write(database, () => insertLink(context, ownerLink(input))),
         links: async (options = {}) => {
             const pair = (reference) => {
                 if (reference === undefined)
@@ -617,7 +632,8 @@ export const notesStoreOver = (context) => {
                 .all(from.type, from.type, from.id, to.type, to.type, to.id, options.unresolved ? 1 : 0, ...filters.map(({ value }) => value))
                 .map((row) => linkOf(database, row));
         },
-        removeLink: async (id) => write(database, () => {
+        removeLink: async (id, by) => write(database, () => {
+            assertMayWithdraw({ id: `link:${id}`, proposedBy: { type: "unknown" }, proposed: false }, by);
             if (!/^\d+$/.test(id) || !database.prepare("DELETE FROM links WHERE id = ?").run(Number(id)).changes)
                 throw new CliError("not_found", `no link ${id} in the local store`);
             return { id, removed: true };

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

@@ -1,3 +1,4 @@
+import { type DecisionPolicy } from "../decisions.js";
 import { type StoreContext } from "./open.js";
 export interface StoreOptions {
     /** Open an existing compatible store without maintenance; SQLite refuses writes. */
@@ -11,6 +12,8 @@ export interface StoreOptions {
     version?: string;
     /** Where the notice of an upgrade that locks other CLIs out goes; stderr, since stdout may carry JSON or MCP. */
     warn?: (line: string) => void;
+    /** The host's decision policy (its `agent_decisions`); the default lets an agent decide with a reason. */
+    decisions?: DecisionPolicy;
 }
 export declare const BACKFILL_ON_OPEN = 5000;
-export declare const openStoreContext: ({ path, env, now, command, version, warn, readOnly, }?: StoreOptions) => Promise<StoreContext>;
+export declare const openStoreContext: ({ path, env, now, command, version, warn, readOnly, decisions, }?: StoreOptions) => Promise<StoreContext>;

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

@@ -1,6 +1,7 @@
 import { mkdirSync, statSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
 import { CliError } from "@wirecat/cli-base";
+import { DEFAULT_DECISION_POLICY } from "../decisions.js";
 import { migrate } from "../migrations.js";
 import { storeCapable } from "../open.js";
 import { storePath } from "../path.js";
@@ -31,7 +32,7 @@ const createWritable = (file) => {
         throw new CliError("permission_error", "the message store cannot be written from here; run where it is writable, or set MESSAGING_STORE", { reason: "store.not-writable" });
     }
 };
-export const openStoreContext = async ({ path, env, now = Date.now, command, version, warn = (line) => process.stderr.write(`${line}\n`), readOnly = false, } = {}) => {
+export const openStoreContext = async ({ path, env, now = Date.now, command, version, warn = (line) => process.stderr.write(`${line}\n`), readOnly = false, decisions = DEFAULT_DECISION_POLICY, } = {}) => {
     if (typeof readOnly !== "boolean")
         throw new CliError("validation_error", "readOnly must be a boolean");
     await storeCapable();
@@ -68,7 +69,12 @@ export const openStoreContext = async ({ path, env, now = Date.now, command, ver
             });
         }
         loadProviders(database);
-        return { ...opened, now, sharedConfig: sharedConfigPath(file, env ?? process.env) };
+        return {
+            ...opened,
+            now,
+            sharedConfig: sharedConfigPath(file, env ?? process.env),
+            decisions,
+        };
     }
     catch (error) {
         database.close();

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

@@ -1,3 +1,4 @@
+import type { DecisionPolicy } from "../decisions.js";
 import { type CacheDatabase } from "../driver.js";
 import type { SQLiteAsyncDatabase } from "./drizzle/core.js";
 /** Drizzle over the store's connection. Synchronous inside: a transaction never awaits (plan D3). */
@@ -11,6 +12,8 @@ export interface StoreContext extends OpenedSqlite {
     now: () => number;
     /** The owner's shared config file, whose `task_categories` edits the store's list; none in a bare context. */
     sharedConfig?: string;
+    /** Who may decide proposals, set once by the host at open; every decide method reads it. */
+    decisions?: DecisionPolicy;
 }
 /**
  * One SQLite connection, seen two ways: the `CacheDatabase` seam the hand-written SQL and the

package/dist/store/sqlite/proposed-actions.d.ts

@@ -1,5 +1,6 @@
+import { type Decider, type Proposer } from "../decisions.js";
 import type { AccountKey } from "../types.js";
-import type { Actor } from "./actors.js";
+import { type Actor, type ProposedByFilter } from "./actors.js";
 import { type Author } from "./memories.js";
 import type { StoreContext } from "./open.js";
 export declare const PROPOSAL_STATUSES: readonly ["proposed", "approved", "rejected", "executed", "failed"];
@@ -18,11 +19,12 @@ export interface ProposedAction {
     payload: unknown;
     reason: string | null;
     status: (typeof PROPOSAL_STATUSES)[number];
-    /** `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. */
     proposedBy: {
         type: Actor["type"];
         id: string;
         name: string | null;
+        kind: "agent" | "rule" | null;
     };
     decidedBy: {
         type: Actor["type"];
@@ -50,14 +52,20 @@ export interface ProposedActionsStore {
     pending(options?: {
         limit?: number;
     }): Promise<ProposedAction[]>;
-    /** Newest first; every status unless one is named. */
+    /** Newest first; every status unless one is named, every kind unless `kinds` names some or `except` leaves some out. */
     list(options?: {
         status?: ProposedAction["status"];
         limit?: number;
+        kinds?: readonly string[];
+        except?: readonly string[];
+        proposedBy?: ProposedByFilter;
+        /** A `project:<id>` the action targets or its payload names as `to`, `from` or `project`. */
+        project?: string;
     }): Promise<ProposedAction[]>;
-    /** `result` records what the approval made, such as the task it became. */
-    approve(id: string, result?: unknown): Promise<ProposedAction>;
-    reject(id: string): Promise<ProposedAction>;
+    /** `result` records what the approval made, such as the task it became. `by` must be allowed to decide it. */
+    approve(id: string, by: Decider, result?: unknown): Promise<ProposedAction>;
+    /** `reason` is kept as the result: why it was turned down. */
+    reject(id: string, by: Decider, reason?: string): Promise<ProposedAction>;
     /** An approved action the adapter carried out, with what the provider answered. */
     executed(id: string, result?: unknown): Promise<ProposedAction>;
     failed(id: string, error: string): Promise<ProposedAction>;
@@ -65,10 +73,15 @@ export interface ProposedActionsStore {
 }
 type ProposalOperations = Omit<{
     [K in keyof ProposedActionsStore]: ProposedActionsStore[K] extends (...args: infer A) => Promise<infer R> ? (...args: A) => R : never;
-}, "approve"> & {
-    /** `by` records an agent deciding for the owner; the public store always records the owner. */
+}, "approve" | "reject"> & {
+    /** Records a decision already checked; `by` records an agent deciding for the owner. */
     approve(id: string, result?: unknown, by?: Author): ProposedAction;
+    reject(id: string, by?: Author, result?: unknown): ProposedAction;
+    /** Who proposed it, for `mayDecide`. */
+    proposer(id: string): Proposer;
 };
+/** Who proposed an action, for `mayDecide`. */
+export declare const proposerOfAction: ({ proposedBy }: ProposedAction) => Proposer;
 export declare const proposalOperationsOver: (context: StoreContext) => ProposalOperations;
 export declare const proposedActionsStoreOver: (context: StoreContext) => ProposedActionsStore;
 export {};