@wirecat/cli-core 0.546.0 → 0.547.0

package/dist/services/proposals/kinds/key-document.js

@@ -0,0 +1,75 @@
+import { CliError } from "@wirecat/cli-base";
+import { proposerOfAction } from "../../../store/index.js";
+import { actionStatus, kept, proposedLink, pushed, storedStatus } from "./shared.js";
+const linkRow = (link) => ({
+    id: `key:${link.id}`,
+    kind: "key_document",
+    status: "proposed",
+    project: link.to,
+    subject: link.from,
+    object: link.to,
+    summary: null,
+    proposedBy: { type: "unknown" },
+    reason: link.evidence,
+    evidence: [link.from],
+    score: null,
+    signals: null,
+    parts: null,
+    createdAt: link.createdAt,
+});
+const storedRow = (action) => {
+    const payload = action.payload;
+    return {
+        id: action.id,
+        kind: "key_document",
+        status: actionStatus(action.status),
+        project: payload.project,
+        subject: payload.ref,
+        object: payload.project,
+        summary: null,
+        proposedBy: proposerOfAction(action),
+        reason: action.reason ?? payload.reason ?? null,
+        evidence: [payload.ref],
+        score: null,
+        signals: null,
+        parts: null,
+        createdAt: action.createdAt,
+    };
+};
+/**
+ * A note, document or message proposed as one of a project's key documents. Stored `key_document` rows are the new
+ * home; older suggestions are unconfirmed `key` links, shown as `key:<id>`.
+ */
+export const keyDocumentKind = (store) => {
+    const legacy = async () => (await store.notes.links({ kind: "related-to", role: "key", confirmed: false })).filter((link) => link.to?.startsWith("project:") && proposedLink(link.provenance));
+    const legacyLink = async (id) => {
+        const link = (await legacy()).find((one) => `key:${one.id}` === id);
+        if (!link)
+            throw new CliError("not_found", `no suggested key document ${id}`);
+        return link;
+    };
+    return {
+        kind: "key_document",
+        prefix: "key",
+        stored: ["key_document"],
+        list: async (filter) => {
+            const status = storedStatus(filter);
+            const stored = await store.proposedActions.list({
+                kinds: ["key_document"],
+                ...(status === undefined ? {} : { status }),
+                ...pushed(filter),
+            });
+            const links = (filter.status ?? "proposed") === "rejected" ? [] : await legacy();
+            return kept([...stored.map(storedRow), ...links.map(linkRow)], filter);
+        },
+        get: async (id) => id.startsWith("key:") ? linkRow(await legacyLink(id)) : storedRow(await store.proposedActions.get(id)),
+        decide: async (id, { confirm, by, reason }) => {
+            const status = confirm ? "confirmed" : "rejected";
+            const decision = { confirm, by, ...(reason === undefined ? {} : { reason }) };
+            const link = id.startsWith("key:")
+                ? await store.knowledge.decideSuggestedLink(id.slice("key:".length), decision)
+                : (await store.knowledge.decideLinkProposal(id, decision)).link;
+            return { id, kind: "key_document", status, made: link ? [`link:${link.id}`] : [] };
+        },
+    };
+};

package/dist/services/proposals/kinds/memory.d.ts

@@ -0,0 +1,4 @@
+import type { MessageStore } from "../../../store/index.js";
+import type { ProposalKind } from "../types.js";
+/** Memories keep their own table; rejecting one marks it stale. */
+export declare const memoryKind: (store: Pick<MessageStore, "memories">) => ProposalKind;

package/dist/services/proposals/kinds/memory.js

@@ -0,0 +1,42 @@
+import { kept, proposerOfAuthor, pushed } from "./shared.js";
+/** A stale memory is the one a person turned down; a superseded one held until another replaced it. */
+const STATUS = {
+    proposed: "proposed",
+    confirmed: "confirmed",
+    superseded: "confirmed",
+    stale: "rejected",
+};
+const rowOf = (memory) => ({
+    id: memory.ref,
+    kind: "memory",
+    status: STATUS[memory.status],
+    project: memory.project,
+    subject: memory.subject ?? memory.ref,
+    object: null,
+    summary: null,
+    proposedBy: proposerOfAuthor(memory.author),
+    reason: null,
+    evidence: memory.evidence.slice(0, 5),
+    score: null,
+    signals: null,
+    parts: null,
+    createdAt: memory.createdAt,
+});
+/** Memories keep their own table; rejecting one marks it stale. */
+export const memoryKind = (store) => ({
+    kind: "memory",
+    prefix: "memory",
+    list: async (filter) => {
+        const status = filter.status ?? "proposed";
+        const memories = await store.memories.list({
+            ...pushed(filter),
+            ...(status === "all" ? {} : { status: status === "rejected" ? "stale" : status }),
+        });
+        return kept(memories.map(rowOf), filter);
+    },
+    get: async (id) => rowOf(await store.memories.get(id)),
+    decide: async (id, { confirm, by }) => {
+        const memory = confirm ? await store.memories.confirm(id, by) : await store.memories.markStale(id, by);
+        return { id, kind: "memory", status: confirm ? "confirmed" : "rejected", made: confirm ? [memory.ref] : [] };
+    },
+});

package/dist/services/proposals/kinds/relationship.d.ts

@@ -0,0 +1,10 @@
+import type { MessageStore } from "../../../store/index.js";
+import type { ProposalKind } from "../types.js";
+type RelationshipStore = Pick<MessageStore, "knowledge" | "notes" | "proposedActions">;
+/**
+ * A person, organization, chat or mail thread proposed as related to another thing. New proposals are stored
+ * `relationship` rows; suggestions written before them are unconfirmed links, shown as `link:<id>` until the store
+ * moves them.
+ */
+export declare const relationshipKind: (store: RelationshipStore) => ProposalKind;
+export {};

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

@@ -0,0 +1,82 @@
+import { CliError } from "@wirecat/cli-base";
+import { proposerOfAction } from "../../../store/index.js";
+import { actionStatus, kept, projectOf, proposedLink, pushed, storedStatus } from "./shared.js";
+const linkRow = (link) => ({
+    id: `link:${link.id}`,
+    kind: "relationship",
+    status: "proposed",
+    project: projectOf(link.to, link.from),
+    subject: link.from,
+    object: link.to,
+    summary: link.role,
+    proposedBy: { type: "unknown" },
+    reason: link.evidence,
+    evidence: [],
+    score: null,
+    signals: null,
+    parts: null,
+    createdAt: link.createdAt,
+});
+const storedRow = (action) => {
+    const payload = action.payload;
+    return {
+        id: action.id,
+        kind: "relationship",
+        status: actionStatus(action.status),
+        project: projectOf(payload.to, payload.from),
+        subject: payload.from,
+        object: payload.to,
+        summary: payload.role ?? null,
+        proposedBy: proposerOfAction(action),
+        reason: action.reason,
+        evidence: (payload.evidence ?? []).slice(0, 5),
+        score: payload.score ?? null,
+        signals: payload.signals ?? null,
+        parts: null,
+        createdAt: action.createdAt,
+    };
+};
+/**
+ * A person, organization, chat or mail thread proposed as related to another thing. New proposals are stored
+ * `relationship` rows; suggestions written before them are unconfirmed links, shown as `link:<id>` until the store
+ * moves them.
+ */
+export const relationshipKind = (store) => {
+    const legacy = async () => {
+        const [members, related] = await Promise.all([
+            store.notes.links({ kind: "member-of", confirmed: false }),
+            store.notes.links({ kind: "related-to", confirmed: false }),
+        ]);
+        return [...members, ...related].filter((link) => link.to !== null && link.role !== "key" && proposedLink(link.provenance));
+    };
+    const legacyLink = async (id) => {
+        const link = (await legacy()).find((one) => `link:${one.id}` === id);
+        if (!link)
+            throw new CliError("not_found", `no proposed relationship ${id}`);
+        return link;
+    };
+    return {
+        kind: "relationship",
+        prefix: "link",
+        stored: ["relationship"],
+        list: async (filter) => {
+            const status = storedStatus(filter);
+            const stored = await store.proposedActions.list({
+                kinds: ["relationship"],
+                ...(status === undefined ? {} : { status }),
+                ...pushed(filter),
+            });
+            const links = (filter.status ?? "proposed") === "rejected" ? [] : await legacy();
+            return kept([...stored.map(storedRow), ...links.map(linkRow)], filter);
+        },
+        get: async (id) => id.startsWith("link:") ? linkRow(await legacyLink(id)) : storedRow(await store.proposedActions.get(id)),
+        decide: async (id, { confirm, by, reason }) => {
+            const status = confirm ? "confirmed" : "rejected";
+            const decision = { confirm, by, ...(reason === undefined ? {} : { reason }) };
+            const link = id.startsWith("link:")
+                ? await store.knowledge.decideSuggestedLink(id.slice("link:".length), decision)
+                : (await store.knowledge.decideLinkProposal(id, decision)).link;
+            return { id, kind: "relationship", status, made: link ? [`relationship:${link.id}`] : [] };
+        },
+    };
+};

package/dist/services/proposals/kinds/shared.d.ts

@@ -0,0 +1,25 @@
+import type { Proposer } from "../../../store/decisions.js";
+import type { ProposalFilter, ProposalRow } from "../types.js";
+/** A stored author as a proposer, with the kind read from its bot row. */
+export declare const proposerOfAuthor: (author: {
+    type: "person" | "bot";
+    id: string;
+    name: string | null;
+    kind: "agent" | "rule" | null;
+}) => Proposer;
+/** What a kind keeps of the rows it read: the filter's status and proposer, newest first, at most `limit`. */
+export declare const kept: (rows: ProposalRow[], filter: ProposalFilter) => ProposalRow[];
+/** The filters every store list takes, so a page is filled by the query and not cut after it. */
+export declare const pushed: (filter: ProposalFilter) => {
+    project?: string | undefined;
+    proposedBy?: "agent" | "rule" | {
+        bot: string;
+    } | undefined;
+    limit: number;
+};
+/** A suggestion an agent or a rule wrote; Drive's editor links and other records stay out of the inbox. */
+export declare const proposedLink: (provenance: string | null) => boolean;
+export declare const projectOf: (...refs: (string | null | undefined)[]) => string | null;
+export declare const actionStatus: (status: string) => ProposalRow["status"];
+/** The stored statuses a filter's status reads, so the store does the filtering when it can. */
+export declare const storedStatus: (filter: ProposalFilter) => "proposed" | "rejected" | undefined;

package/dist/services/proposals/kinds/shared.js

@@ -0,0 +1,49 @@
+/** A stored author as a proposer, with the kind read from its bot row. */
+export const proposerOfAuthor = (author) => {
+    if (author.type === "person")
+        return { type: "person", id: author.id };
+    if (author.name === null)
+        return { type: "unknown" };
+    return { type: "bot", id: author.id, name: author.name, kind: author.kind ?? "agent" };
+};
+const byMatches = (row, by) => {
+    if (by === undefined)
+        return true;
+    const proposer = row.proposedBy;
+    if (proposer.type !== "bot")
+        return false;
+    if (by === "agent" || by === "rule")
+        return proposer.kind === by;
+    return proposer.name === by.bot;
+};
+/** What a kind keeps of the rows it read: the filter's status and proposer, newest first, at most `limit`. */
+export const kept = (rows, filter) => {
+    const status = filter.status ?? "proposed";
+    return rows
+        .filter((row) => (status === "all" || row.status === status) && byMatches(row, filter.by))
+        .filter((row) => filter.project === undefined || row.project === filter.project)
+        .sort((a, b) => b.createdAt.localeCompare(a.createdAt))
+        .slice(0, filter.limit);
+};
+/** The filters every store list takes, so a page is filled by the query and not cut after it. */
+export const pushed = (filter) => ({
+    ...(filter.project === undefined ? {} : { project: filter.project }),
+    ...(filter.by === undefined ? {} : { proposedBy: filter.by }),
+    limit: Math.min(filter.limit, 500),
+});
+/** A suggestion an agent or a rule wrote; Drive's editor links and other records stay out of the inbox. */
+export const proposedLink = (provenance) => /^(agent|rule):/.test(provenance ?? "");
+export const projectOf = (...refs) => refs.find((ref) => typeof ref === "string" && ref.startsWith("project:")) ?? null;
+const ACTION_STATUS = {
+    proposed: "proposed",
+    approved: "confirmed",
+    executed: "confirmed",
+    failed: "confirmed",
+    rejected: "rejected",
+};
+export const actionStatus = (status) => ACTION_STATUS[status] ?? "proposed";
+/** The stored statuses a filter's status reads, so the store does the filtering when it can. */
+export const storedStatus = (filter) => {
+    const status = filter.status ?? "proposed";
+    return status === "proposed" || status === "rejected" ? status : undefined;
+};

package/dist/services/proposals/registry.d.ts

@@ -0,0 +1,9 @@
+import type { MessageStore } from "../../store/store.js";
+import type { ProposalRegistry } from "./types.js";
+/** An empty registry: the host registers its kinds. `proposalRegistry` is this with the core kinds. */
+export declare const emptyProposalRegistry: (store: Pick<MessageStore, "proposedActions" | "decisionPolicy">) => ProposalRegistry & {
+    claimed(): string[];
+};
+/** Every proposal kind core knows, behind one check of who may decide. */
+/** The policy is the store's, set when it was opened, so the registry and the store methods never disagree. */
+export declare const proposalRegistry: (store: MessageStore) => ProposalRegistry;

package/dist/services/proposals/registry.js

@@ -0,0 +1,129 @@
+import { CliError } from "@wirecat/cli-base";
+import { mayDecide } from "../../store/decisions.js";
+import { actionKind } from "./kinds/action.js";
+import { factKind } from "./kinds/fact.js";
+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";
+const PREFIX = /^([a-z][a-z_]*):/;
+const refusalOf = (id, error) => {
+    if (!(error instanceof CliError))
+        throw error;
+    const code = error.code === "not_found" || error.code === "permission_error" ? error.code : "validation_error";
+    const reason = error.details?.reason;
+    return { id, code, reason: typeof reason === "string" ? reason : code, message: error.message };
+};
+/** An empty registry: the host registers its kinds. `proposalRegistry` is this with the core kinds. */
+export const emptyProposalRegistry = (store) => {
+    const policy = store.decisionPolicy;
+    const kinds = [];
+    const claimed = () => kinds.flatMap((kind) => kind.stored ?? []);
+    const kindOf = async (id) => {
+        const prefix = PREFIX.exec(id)?.[1];
+        const found = prefix !== undefined
+            ? kinds.find((kind) => kind.prefix === prefix)
+            : await (async () => {
+                const stored = (await store.proposedActions.get(id)).kind;
+                return (kinds.find((kind) => kind.stored?.includes(stored)) ??
+                    kinds.find((kind) => kind.prefix === undefined && kind.stored === undefined));
+            })();
+        if (!found)
+            throw new CliError("not_found", `no proposal ${id}`, { reason: "proposal.unknown-kind" });
+        return found;
+    };
+    const registry = {
+        claimed,
+        register: (kind) => {
+            if (kinds.some((one) => one.kind === kind.kind))
+                throw new CliError("configuration_error", `proposal kind ${kind.kind} is registered twice`);
+            if (kind.prefix !== undefined && kinds.some((one) => one.prefix === kind.prefix))
+                throw new CliError("configuration_error", `proposal prefix ${kind.prefix} is registered twice`);
+            kinds.push(kind);
+        },
+        list: async (filter) => {
+            if (!Number.isSafeInteger(filter.limit) || filter.limit < 1 || filter.limit > 50)
+                throw new CliError("validation_error", "a proposal list takes 1–50 items");
+            if (!Number.isSafeInteger(filter.offset) || filter.offset < 0)
+                throw new CliError("validation_error", "a proposal list takes a nonnegative offset");
+            const asked = filter.kinds === undefined ? kinds : kinds.filter((kind) => filter.kinds?.includes(kind.kind));
+            const wide = { ...filter, offset: 0, limit: filter.offset + filter.limit + 1 };
+            const rows = (await Promise.all(asked.map((kind) => kind.list(wide)))).flat();
+            rows.sort((a, b) => b.createdAt.localeCompare(a.createdAt) || b.id.localeCompare(a.id));
+            const page = rows.slice(filter.offset, filter.offset + filter.limit + 1);
+            return { items: page.slice(0, filter.limit), hasMore: page.length > filter.limit };
+        },
+        get: async (id) => (await kindOf(id)).get(id),
+        decide: async (ids, decision) => {
+            const parts = new Map();
+            const whole = new Set();
+            const order = [];
+            for (const id of ids) {
+                const [batch, part] = id.split("/");
+                if (!batch)
+                    continue;
+                if (!parts.has(batch)) {
+                    parts.set(batch, []);
+                    order.push(batch);
+                }
+                if (part === undefined)
+                    whole.add(batch);
+                else
+                    parts.get(batch)?.push(part);
+            }
+            const decided = [];
+            const refused = [];
+            const refuseIds = (id, message) => refused.push({ id, code: "validation_error", reason: "proposal.ids", message });
+            for (const id of order) {
+                const chosen = parts.get(id) ?? [];
+                if (chosen.length && whole.has(id)) {
+                    refuseIds(id, `name ${id} or some of its parts (${id}/${chosen[0]}), not both`);
+                    continue;
+                }
+                try {
+                    const kind = await kindOf(id);
+                    if (chosen.length && !kind.parts) {
+                        refuseIds(id, `a ${kind.kind} proposal has no parts; name ${id} alone`);
+                        continue;
+                    }
+                    const row = await kind.get(id);
+                    if (row.status !== "proposed") {
+                        refused.push({
+                            id,
+                            code: "validation_error",
+                            reason: "proposal.wrong-state",
+                            message: `${id} is already ${row.status}`,
+                        });
+                        continue;
+                    }
+                    const refusal = mayDecide(row, decision.by, policy);
+                    if (refusal) {
+                        refused.push(refusal);
+                        continue;
+                    }
+                    decided.push(await kind.decide(id, chosen.length ? { ...decision, parts: chosen } : decision));
+                }
+                catch (error) {
+                    refused.push(refusalOf(id, error));
+                }
+            }
+            return { decided, refused };
+        },
+    };
+    return registry;
+};
+/** Every proposal kind core knows, behind one check of who may decide. */
+/** The policy is the store's, set when it was opened, so the registry and the store methods never disagree. */
+export const proposalRegistry = (store) => {
+    const registry = emptyProposalRegistry(store);
+    for (const kind of [
+        relationshipKind(store),
+        keyDocumentKind(store),
+        factKind(store),
+        memoryKind(store),
+        findingsKind(store),
+    ])
+        registry.register(kind);
+    registry.register(actionKind(store, registry.claimed));
+    return registry;
+};

package/dist/services/proposals/types.d.ts

@@ -0,0 +1,85 @@
+import type { Decider, Proposer, Refusal } from "../../store/decisions.js";
+export interface ProposalRow {
+    /** `17070` for a stored proposal; `fact:512`, `memory:88`, `link:17` and `key:9` for the kinds kept elsewhere. */
+    id: string;
+    kind: string;
+    status: "proposed" | "confirmed" | "rejected";
+    project: string | null;
+    /** The reference it is about. */
+    subject: string;
+    /** The reference it links to, when it links. */
+    object: string | null;
+    /** A fact's statement or a finding count; never message text. */
+    summary: string | null;
+    proposedBy: Proposer;
+    reason: string | null;
+    /** At most 5 references. */
+    evidence: string[];
+    score: number | null;
+    signals: {
+        scorer: string;
+        weight: number;
+        why: string;
+    }[] | null;
+    parts: {
+        id: string;
+        kind: string;
+        summary: string;
+        outcome: "accepted" | "rejected" | null;
+    }[] | null;
+    createdAt: string;
+}
+export interface ProposalFilter {
+    project?: string;
+    kinds?: string[];
+    by?: "agent" | "rule" | {
+        bot: string;
+    };
+    status?: ProposalRow["status"] | "all";
+    limit: number;
+    offset: number;
+}
+export interface Decision {
+    confirm: boolean;
+    by: Decider;
+    /** Why, kept with the decision; a memory has nowhere to keep it. */
+    reason?: string;
+    /** The findings of a batch to accept; the rest are rejected. */
+    parts?: string[];
+}
+export interface Decided {
+    id: string;
+    kind: string;
+    status: "confirmed" | "rejected";
+    /** References the decision made: `relationship:2203`, `fact:530`, `task:…`. */
+    made: string[];
+}
+/**
+ * One kind of proposal. `prefix` names its own id space (`fact` for `fact:512`); a kind stored in `proposed_actions`
+ * names the stored kinds it owns in `stored` and has bare number ids. A new kind registers itself; nothing else changes.
+ */
+export interface ProposalKind {
+    readonly kind: string;
+    readonly prefix?: string;
+    readonly stored?: readonly string[];
+    /** Whether its proposals have parts decided on their own, as a findings batch has findings. */
+    readonly parts?: boolean;
+    /** Bounded: at most `offset + limit` rows, newest first. */
+    list(filter: ProposalFilter): Promise<ProposalRow[]>;
+    get(id: string): Promise<ProposalRow>;
+    /** Called only after `mayDecide` allowed it. */
+    decide(id: string, decision: Decision): Promise<Decided>;
+}
+export interface ProposalRegistry {
+    register(kind: ProposalKind): void;
+    list(filter: ProposalFilter): Promise<{
+        items: ProposalRow[];
+        hasMore: boolean;
+    }>;
+    get(id: string): Promise<ProposalRow>;
+    /** Each id on its own: one refusal never undoes the others. */
+    decide(ids: string[], decision: Decision): Promise<{
+        decided: Decided[];
+        refused: Refusal[];
+    }>;
+}

package/dist/services/proposals/types.js

@@ -0,0 +1 @@
+export {};

package/dist/services/server-search.d.ts

@@ -2,12 +2,15 @@ import type { Id } from "../domain/models.js";
 import type { ServiceDeps } from "./deps.js";
 import type { SearchQuery } from "./messages.js";
 export declare const SERVER_SEARCH_KEY = "messages.server-search";
-/** `maxMessageBytes`: a candidate larger than this is not downloaded; a sync reads it, and the answer says so. */
+/**
+ * `textBytes`: a mail candidate is read up to this many bytes, its headers and text; one cut short is stored partial
+ * and the next sync reads it whole.
+ */
 export declare const SERVER_BOUNDS: {
     timeMs: number;
     perCall: number;
     maxCalls: number;
-    maxMessageBytes: number;
+    textBytes: number;
 };
 export declare const DEFAULT_BACKEND = "both";
 export type Backend = "archive" | "server" | "both";
@@ -26,8 +29,8 @@ export interface ServerSearched {
         chat: string | null;
         reason: "rate_limited" | "search_failed" | "time_or_abort_bound";
     }[];
-    /** Candidates larger than `SERVER_BOUNDS.maxMessageBytes`, left on the server unread. */
-    tooLarge?: number;
+    /** Candidates stored from their first `SERVER_BOUNDS.textBytes`, without the attachments; a sync reads them whole. */
+    partial?: number;
     complete: boolean;
 }
 export type HitSource = "archive" | "server" | "both";

package/dist/services/server-search.js

@@ -2,8 +2,11 @@ import { CliError } from "@wirecat/cli-base";
 import { capability } from "../ports/messenger.js";
 import { prepareLucene } from "./messages-search.js";
 export const SERVER_SEARCH_KEY = "messages.server-search";
-/** `maxMessageBytes`: a candidate larger than this is not downloaded; a sync reads it, and the answer says so. */
-export const SERVER_BOUNDS = { timeMs: 5_000, perCall: 100, maxCalls: 3, maxMessageBytes: 5_000_000 };
+/**
+ * `textBytes`: a mail candidate is read up to this many bytes, its headers and text; one cut short is stored partial
+ * and the next sync reads it whole.
+ */
+export const SERVER_BOUNDS = { timeMs: 5_000, perCall: 100, maxCalls: 3, textBytes: 262_144 };
 export const DEFAULT_BACKEND = "both";
 export const sourceKey = (chatId, id) => JSON.stringify([chatId, id]);
 const merge = (one, other) => {

package/dist/services/tasks.js

@@ -260,7 +260,9 @@ export const tasksService = (deps, categories) => {
                 const link = {
                     from: (await store.tasks.details(target.id)).ref,
                     kind: "evidence",
-                    origin: origin === "owner" ? "owner" : "suggested",
+                    ...(origin === "owner"
+                        ? { origin: "owner", by: "owner" }
+                        : { origin: "suggested", confirmed: false }),
                 };
                 try {
                     await store.notes.addLink({ ...link, to: note ? note.ref : source });
@@ -448,17 +450,19 @@ export const tasksService = (deps, categories) => {
                     account: account.account,
                     chat: await storedChatId(deps.messenger, chat, store, account, { includeLeft: true }),
                 })));
-                const origin = by === "owner" ? "owner" : "suggested";
+                const origin = by === "owner"
+                    ? { origin: "owner", by: "owner" }
+                    : { origin: "suggested", confirmed: false };
                 for (const target of [...written, ...chatRefs]) {
                     try {
-                        await store.notes.addLink({ from, to: target, kind: kind, origin });
+                        await store.notes.addLink({ from, to: target, kind: kind, ...origin });
                     }
                     catch (error) {
                         // Only text that names nothing typed, or a message not saved yet; a mistyped `person:9` is refused.
                         const unsaved = error instanceof CliError && error.code === "not_found" && target.startsWith("msg:");
                         if (!unsaved && !(error instanceof CliError && error.code === "validation_error"))
                             throw error;
-                        await store.notes.addLink({ from, targetText: target, kind: kind, origin });
+                        await store.notes.addLink({ from, targetText: target, kind: kind, ...origin });
                     }
                 }
                 if (!written.some((target) => target.startsWith("msg:")))