@wirecat/cli-core 0.548.0 → 0.549.0

package/dist/services/proposals/kinds/relationship-update.js

@@ -0,0 +1,53 @@
+import { proposerOfAction } from "../../../store/index.js";
+import { actionStatus, kept, projectOf, pushed, storedStatus } from "./shared.js";
+const KIND = "relationship_update";
+const summaryOf = ({ changes }) => Object.entries(changes)
+    .map(([field, value]) => `${field} ${value ?? "cleared"}`)
+    .join(", ");
+const rowOf = (action) => {
+    const payload = action.payload;
+    return {
+        id: action.id,
+        kind: KIND,
+        status: actionStatus(action.status),
+        project: projectOf(payload.to, payload.from),
+        subject: `relationship:${payload.relationship}`,
+        object: payload.to,
+        summary: summaryOf(payload),
+        proposedBy: proposerOfAction(action),
+        reason: action.reason,
+        evidence: [],
+        score: null,
+        signals: null,
+        parts: null,
+        createdAt: action.createdAt,
+    };
+};
+/** An agent's change to a relationship's role or purpose; the owner's applies at once and never waits here. */
+export const relationshipUpdateKind = (store) => ({
+    kind: KIND,
+    stored: [KIND],
+    list: async (filter) => {
+        const status = storedStatus(filter);
+        const stored = await store.proposedActions.list({
+            kinds: [KIND],
+            ...(status === undefined ? {} : { status }),
+            ...pushed(filter),
+        });
+        return kept(stored.map(rowOf), filter);
+    },
+    get: async (id) => rowOf(await store.proposedActions.get(id)),
+    decide: async (id, { confirm, by, reason }) => {
+        const { relation } = await store.knowledge.decideRelationUpdate(id, {
+            confirm,
+            by,
+            ...(reason === undefined ? {} : { reason }),
+        });
+        return {
+            id,
+            kind: KIND,
+            status: confirm ? "confirmed" : "rejected",
+            made: relation ? [`relationship:${relation.id}`] : [],
+        };
+    },
+});

package/dist/services/proposals/registry.js

@@ -6,6 +6,7 @@ import { findingsKind } from "./kinds/findings.js";
 import { keyDocumentKind } from "./kinds/key-document.js";
 import { memoryKind } from "./kinds/memory.js";
 import { relationshipKind } from "./kinds/relationship.js";
+import { relationshipUpdateKind } from "./kinds/relationship-update.js";
 const PREFIX = /^([a-z][a-z_]*):/;
 const refusalOf = (id, error) => {
     if (!(error instanceof CliError))
@@ -118,6 +119,7 @@ export const proposalRegistry = (store) => {
     const registry = emptyProposalRegistry(store);
     for (const kind of [
         relationshipKind(store),
+        relationshipUpdateKind(store),
         keyDocumentKind(store),
         factKind(store),
         memoryKind(store),

package/dist/store/decisions.d.ts

@@ -1,6 +1,7 @@
 /**
  * Who proposed something waiting for the owner. `unknown` is a suggestion that names no author, such as an
- * unconfirmed link written without provenance: only the owner decides it.
+ * unconfirmed link written without provenance: only the owner decides it. `verified: false` is a bot named only by
+ * free text anyone could write, as an old suggested link's provenance: only the owner decides that one too.
  */
 export type Proposer = {
     type: "person";
@@ -10,6 +11,7 @@ export type Proposer = {
     id: string;
     name: string;
     kind: "agent" | "rule";
+    verified?: false;
 } | {
     type: "unknown";
 };

package/dist/store/decisions.js

@@ -20,6 +20,8 @@ export const mayDecide = (row, by, policy = DEFAULT_DECISION_POLICY) => {
     const proposer = row.proposedBy;
     if (proposer.type === "unknown")
         return refuse("permission_error", "proposal.owner-only", "this proposal names no author; only the owner decides it");
+    if (proposer.type === "bot" && proposer.verified === false)
+        return refuse("permission_error", "proposal.owner-only", `${proposer.name} is named only by an old link's provenance; only the owner decides it`);
     if (proposer.type === "bot" && proposer.kind === "rule" && policy.ruleProposalsOwnerOnly)
         return refuse("permission_error", "proposal.owner-only", `proposed by ${proposer.name}: only the owner decides it`);
     if (proposer.type === "bot" && proposer.kind === "agent" && botKey(proposer.name) === botKey(by.bot))
@@ -39,7 +41,11 @@ export const assertMayWithdraw = (row, by) => {
     if (by === "owner")
         return;
     const proposer = row.proposedBy;
-    if (row.proposed && proposer.type === "bot" && proposer.kind === "agent" && botKey(proposer.name) === botKey(by.bot))
+    if (row.proposed &&
+        proposer.type === "bot" &&
+        proposer.kind === "agent" &&
+        proposer.verified !== false &&
+        botKey(proposer.name) === botKey(by.bot))
         return;
     throw new CliError("permission_error", `only the owner removes or reverses ${row.id}`, {
         reason: "proposal.owner-only",

package/dist/store/index.d.ts

@@ -1,5 +1,6 @@
 export type { ContextEvidenceItem, ContextEvidencePage, ContextEvidenceReader, ContextEvidenceRequest, ContextEvidenceSender, ContextSource, } from "../context/evidence.js";
 export { FACT_STATUSES, FACT_TYPES, MEMORY_KINDS, MEMORY_SCOPES, MEMORY_STATUSES, TASK_TYPES, WORK_TASK_TYPES, } from "../domain/knowledge.js";
+export type { RefState, RefSummary, RefSummaryKind, RefsStore } from "../domain/ref-summaries.js";
 export type { TagConsolidationApplyOptions, TagConsolidationOptions, TagConsolidationPreview, TagConsolidationReceipt, TagConsolidationStore, } from "../domain/tag-consolidation.js";
 export type { TagRedirectIndex, TagRedirectResolution, TagRedirectSnapshot } from "../domain/tag-redirects.js";
 export { createTagRedirectIndex } from "../domain/tag-redirects.js";
@@ -51,7 +52,7 @@ export { type NearestNote, NOTE_FIELDS, type NoteChunkToEmbed, type NoteHit, typ
 export type { FileNoteInput, Link, LinkInput, LinkListFilter, Note, NoteFolder, NotesStore, NoteTag, } from "./sqlite/notes.js";
 export type { PrivateContact, PrivateContactNote } from "./sqlite/private-people.js";
 export { PROPOSAL_STATUSES, type ProposalInput, type ProposedAction, type ProposedActionsStore, proposerOfAction, } from "./sqlite/proposed-actions.js";
-export type { LinkDecision } from "./sqlite/relation-proposals.js";
+export type { LinkDecision, RelationUpdate } from "./sqlite/relation-proposals.js";
 export { fillSearchIndex, resetSearchIndex, type SearchIndexFill, type SearchIndexState, searchIndexState, } from "./sqlite/search-index.js";
 export type { SyncStateSave } from "./sqlite/sync.js";
 export type { TagCreationOptions, TagCreationReview } from "./sqlite/tag-creation.js";

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

@@ -13,6 +13,8 @@ export interface EvidenceSource {
     /** Deleted at its source since it was cited, or no longer in the store. */
     missing: boolean;
 }
+/** Each distinct reference read back, in order; one the store no longer resolves keeps its reference, `missing`. */
+export declare const sourcesOfReferences: (database: CacheDatabase, references: readonly string[]) => EvidenceSource[];
 /**
  * Every `evidence` link from a memory or fact, in the order they were written, including one whose target was
  * deleted since: `evidenceOf` drops those, so a reader would never learn the record lost a source.
@@ -21,5 +23,3 @@ export declare const evidenceSourcesOf: (database: CacheDatabase, from: {
     type: string;
     id: number;
 }) => EvidenceSource[];
-/** Each distinct reference read back, in order; one the store no longer resolves keeps its reference, `missing`. */
-export declare const sourcesOfReferences: (database: CacheDatabase, references: readonly string[]) => EvidenceSource[];

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

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

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

@@ -1,17 +1,17 @@
 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 KnowledgeRelation, type LinkDecision, type RelateInput, type RelationUpdate } 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";
 import { type VocabularyStore } from "./vocabulary.js";
+export type { KnowledgeRelation, RelateInput } from "./relation-proposals.js";
 export type { Label } from "./tags.js";
 export type KnowledgeTarget = {
     type: "message";
@@ -90,18 +90,6 @@ export interface Project {
     scope: (typeof SCOPES)[number];
     createdAt: string;
 }
-export interface KnowledgeRelation {
-    id: string;
-    from: string;
-    to: string;
-    kind: (typeof RELATION_KINDS)[number];
-    role: string | null;
-    evidence: string | null;
-    confirmed: boolean;
-    provenance: string | null;
-    confidenceCategory: "owner-confirmed" | "weak";
-    createdAt: string;
-}
 export interface Reminder {
     id: string;
     task: string;
@@ -199,9 +187,24 @@ export interface KnowledgeStore extends VocabularyStore, MeetingProjectsStore {
         to: string;
         kind: KnowledgeRelation["kind"];
         role?: string;
+        purpose?: string;
         evidence?: string[];
         reason?: string;
     }, by: Exclude<Author, "owner">): Promise<ProposedAction>;
+    /** The owner sets a relationship's role and purpose; `null` clears one. */
+    updateRelation(key: KnowledgeScope, id: string, input: RelationUpdate & {
+        by: "owner";
+    }): Promise<KnowledgeRelation>;
+    /** An agent's change is a `relationship_update` proposal for the owner; the same pending change is answered again. */
+    updateRelation(key: KnowledgeScope, id: string, input: RelationUpdate & {
+        by: Exclude<Author, "owner">;
+        reason?: string;
+    }): Promise<ProposedAction>;
+    /** Decides a `relationship_update` proposal; a confirmed one changes the relationship in the same transaction. */
+    decideRelationUpdate(id: string, decision: LinkDecision): Promise<{
+        proposal: ProposedAction;
+        relation: KnowledgeRelation | null;
+    }>;
     /** Decides a stored `relationship` or `key_document` proposal; the link and the decision land together. */
     decideLinkProposal(id: string, decision: LinkDecision): Promise<{
         proposal: ProposedAction;
@@ -229,13 +232,4 @@ 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

@@ -15,7 +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 { relationOf, 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";
@@ -221,18 +221,6 @@ export const knowledgeStoreOver = (context) => {
         scope: row.scope,
         createdAt: iso(row.created_at),
     });
-    const relationOf = (link) => ({
-        id: link.id,
-        from: link.from,
-        to: String(link.to),
-        kind: link.kind,
-        role: link.role,
-        evidence: link.evidence,
-        confirmed: link.confirmed,
-        provenance: link.provenance,
-        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) => {
@@ -561,6 +549,7 @@ export const knowledgeStoreOver = (context) => {
                 origin: confirmed ? "owner" : "suggested",
                 confirmed,
                 ...(input.role === undefined ? {} : { role: input.role }),
+                ...(input.purpose === undefined ? {} : { purpose: input.purpose }),
                 ...(input.evidence === undefined ? {} : { evidence: input.evidence }),
                 ...(input.provenance === undefined ? {} : { provenance: input.provenance }),
             })));
@@ -573,6 +562,17 @@ export const knowledgeStoreOver = (context) => {
                 });
             return proposals.propose(from, input, by);
         },
+        updateRelation: (async (key, id, input) => {
+            checked(key);
+            const link = linkOf(database, relation(id));
+            if (input.by === "owner")
+                return relationOf(proposals.update(link, input));
+            return proposals.proposeUpdate(link, input, input.by);
+        }),
+        decideRelationUpdate: async (id, decision) => {
+            const { proposal, link } = proposals.decideUpdate(id, decision);
+            return { proposal, relation: link && relationOf(link) };
+        },
         decideLinkProposal: async (id, decision) => proposals.decideProposal(id, decision),
         decideSuggestedLink: async (id, decision) => proposals.decideLink(id, decision),
         relations: async (key, reference) => {

package/dist/store/sqlite/manifest.js

@@ -57,6 +57,8 @@ export const MANIFEST = [
     { name: "20261031230945_version-41-task-fields", version: 41, minCompatible: 34 },
     { name: "20261101002523_version-42-task-revision", version: 42, minCompatible: 34 },
     { name: "20261101011859_version-43-memory-project", version: 43, minCompatible: 34 },
+    { name: "20261102050533_version-44-relationship-purpose", version: 44, minCompatible: 34 },
+    { name: "20261102050534_version-44-suggested-links-move", version: 44, minCompatible: 34 },
 ];
 export const generatedMigrations = (manifest = MANIFEST, generated = GENERATED) => {
     const migrations = [];

package/dist/store/sqlite/migrations.generated.js

@@ -877,5 +877,17 @@ export const GENERATED = [
             "ALTER TABLE `memories` ADD `project_id` integer REFERENCES projects(id);",
             "CREATE INDEX `memories_by_project_id` ON `memories` (`project_id`);"
         ]
+    },
+    {
+        "name": "20261102050533_version-44-relationship-purpose",
+        "statements": [
+            "ALTER TABLE `links` ADD `purpose` text;"
+        ]
+    },
+    {
+        "name": "20261102050534_version-44-suggested-links-move",
+        "statements": [
+            "-- A suggestion's references (chat:, msg:) need the store's own encoding, which SQL cannot write, so the next writable\n-- open moves the unconfirmed agent and rule links into `proposed_actions` and deletes this key (moveSuggestedLinks).\nINSERT OR REPLACE INTO store_settings (key, value, at) VALUES ('suggested_links_to_move', '1', unixepoch() * 1000);"
+        ]
     }
 ];

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

@@ -56,6 +56,8 @@ export interface Link {
     origin: (typeof LINK_SOURCES)[number];
     targetText: string | null;
     role: string | null;
+    /** What a chat is for in a project, from the purposes memo's config lists; `null` means `work`. */
+    purpose: string | null;
     evidence: string | null;
     provenance: string | null;
     confirmed: boolean;
@@ -79,6 +81,7 @@ export interface LinkInput {
     anchor?: string;
     origin?: (typeof LINK_ORIGINS)[number];
     role?: string;
+    purpose?: string;
     evidence?: string;
     provenance?: string;
     confirmed?: boolean;
@@ -194,6 +197,8 @@ export declare const requiredThing: (database: CacheDatabase, reference: string,
  * and only a name some note is waiting for costs more.
  */
 export declare const resolvePersonLinks: (database: CacheDatabase, names: (string | null | undefined)[]) => void;
+/** The store keeps no list of purposes: memo's config holds it, and checks a purpose before it gets here. */
+export declare const purposeOf: (purpose: string) => string;
 /** Writes one link; an identical resolved link is answered instead of doubled. */
 export declare const insertLink: (context: StoreContext, input: LinkInput) => Link;
 export declare const notesStoreOver: (context: StoreContext) => Omit<NotesStore, keyof NoteSearch>;

package/dist/store/sqlite/notes.js

@@ -87,6 +87,7 @@ export const linkOf = (database, row) => {
         origin: row.source,
         targetText: row.target_text == null ? null : String(row.target_text),
         role: row.role == null ? null : String(row.role),
+        purpose: row.purpose == null ? null : String(row.purpose),
         evidence: row.evidence == null ? null : String(row.evidence),
         provenance: metadata.provenance ?? null,
         confirmed: Number(row.confirmed) === 1,
@@ -164,6 +165,8 @@ const ownerLink = (input) => {
         });
     return input;
 };
+/** The store keeps no list of purposes: memo's config holds it, and checks a purpose before it gets here. */
+export const purposeOf = (purpose) => textOf(purpose, "a purpose", 100);
 /** Writes one link; an identical resolved link is answered instead of doubled. */
 export const insertLink = (context, input) => {
     const { database, now } = context;
@@ -187,8 +190,9 @@ export const insertLink = (context, input) => {
     const provenance = input.provenance === undefined ? undefined : textOf(input.provenance, "provenance", 2000);
     const row = database
         .prepare("INSERT INTO links (from_type, from_id, to_type, to_id, kind, anchor, source, target_text, target_folded, role, evidence, " +
-        "metadata, confirmed, created_at, author, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING id")
-        .get(from.type, from.id, to?.type ?? null, to?.id ?? null, kind, input.anchor ?? null, origin, targetText, targetText === null ? null : targetKey(targetText), input.role === undefined ? null : textOf(input.role, "a role", 200), input.evidence === undefined ? null : textOf(input.evidence, "evidence", 2000), provenance === undefined ? null : JSON.stringify({ provenance }), input.confirmed === false ? 0 : 1, at, origin === "owner" ? "owner" : null, at);
+        "metadata, confirmed, created_at, author, updated_at, purpose) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) " +
+        "RETURNING id")
+        .get(from.type, from.id, to?.type ?? null, to?.id ?? null, kind, input.anchor ?? null, origin, targetText, targetText === null ? null : targetKey(targetText), input.role === undefined ? null : textOf(input.role, "a role", 200), input.evidence === undefined ? null : textOf(input.evidence, "evidence", 2000), provenance === undefined ? null : JSON.stringify({ provenance }), input.confirmed === false ? 0 : 1, at, origin === "owner" ? "owner" : null, at, input.purpose === undefined ? null : purposeOf(input.purpose));
     if (to === null && targetText !== null)
         resolveKey(database, targetKey(targetText));
     return linkOf(database, database.prepare("SELECT * FROM links WHERE id = ?").get(Number(row?.id)));

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

@@ -16,6 +16,7 @@ import { loadProviders } from "./providers.js";
 import { assertReadCompatible } from "./read-compatibility.js";
 import { stemsState } from "./stems.js";
 import { fillStems, followDefaultStemmers } from "./stems-fill.js";
+import { moveSuggestedLinks } from "./suggested-links.js";
 import { fillVectorIndexes } from "./vector-index.js";
 export const BACKFILL_ON_OPEN = 5_000;
 const NOT_WRITABLE = new Set(["EACCES", "EPERM", "EROFS"]);
@@ -55,6 +56,7 @@ export const openStoreContext = async ({ path, env, now = Date.now, command, ver
             fillFiles(database, now);
             fillFolded(database);
             fillJoinKeys(database);
+            moveSuggestedLinks(database, now);
             const pending = pendingNormalization(database);
             if (pending > 0 && pending <= BACKFILL_ON_OPEN)
                 backfillNormalized(database);

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

@@ -81,7 +81,7 @@ type ProposalOperations = Omit<{
     proposer(id: string): Proposer;
 };
 /** Who proposed an action, for `mayDecide`. */
-export declare const proposerOfAction: ({ proposedBy }: ProposedAction) => Proposer;
+export declare const proposerOfAction: ({ proposedBy, payload }: ProposedAction) => Proposer;
 export declare const proposalOperationsOver: (context: StoreContext) => ProposalOperations;
 export declare const proposedActionsStoreOver: (context: StoreContext) => ProposedActionsStore;
 export {};

package/dist/store/sqlite/proposed-actions.js

@@ -20,11 +20,19 @@ const STATUS = `CASE WHEN p.status = 'approved' AND p.kind IN ('${MEETING_FINDIN
 const NAMED = `SELECT p.*, ${STATUS} AS shown_status, b.name AS proposer_name, b.kind AS proposer_kind FROM proposed_actions p ` +
     "LEFT JOIN bots b ON p.proposed_by_type = 'bot' AND b.id = p.proposed_by_id";
 /** Who proposed an action, for `mayDecide`. */
-export const proposerOfAction = ({ proposedBy }) => proposedBy.type === "person"
+export const proposerOfAction = ({ proposedBy, payload }) => proposedBy.type === "person"
     ? { type: "person", id: proposedBy.id }
     : proposedBy.name === null
         ? { type: "unknown" }
-        : { type: "bot", id: proposedBy.id, name: proposedBy.name, kind: proposedBy.kind ?? "agent" };
+        : {
+            type: "bot",
+            id: proposedBy.id,
+            name: proposedBy.name,
+            kind: proposedBy.kind ?? "agent",
+            ...(movedSuggestion(payload) ? { verified: false } : {}),
+        };
+/** A suggestion moved from `links` names its bot only as the link's provenance text said it (store version 44). */
+const movedSuggestion = (payload) => typeof payload === "object" && payload !== null && "suggestedLink" in payload;
 export const proposalOperationsOver = (context) => {
     const { database, now } = context;
     const actionOf = (row) => {

package/dist/store/sqlite/ref-summaries.d.ts

@@ -0,0 +1,17 @@
+import { type RefSummary } from "../../domain/ref-summaries.js";
+import type { CacheDatabase } from "../driver.js";
+/** A summary plus what an evidence reader shows beside it; `summaries` drops the extra fields. */
+export interface RefRead extends RefSummary {
+    sender: string | null;
+    excerpt: string | null;
+}
+/**
+ * Every ref read back in one statement per kind present, keyed by the text passed and in its order. A bad ref is
+ * `unknown` and a ref the store lacks is `unavailable`: one bad row must not fail a page of them.
+ */
+export declare const refReadsOf: (database: CacheDatabase, texts: readonly string[], { excerpt }?: {
+    excerpt?: boolean;
+}) => Map<string, RefRead>;
+export declare const refSummariesOf: (database: CacheDatabase, texts: readonly string[], options?: {
+    excerpt?: boolean;
+}) => Map<string, RefSummary>;