@wirecat/cli-core 0.547.0 → 0.549.0

package/dist/entities/index.d.ts

@@ -4911,6 +4911,7 @@ export declare const ENTITIES: {
             readonly origin: v.PicklistSchema<readonly ["file", "owner", "suggested", "message", "calendar"], undefined>;
             readonly target_text: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly role: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly purpose: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly evidence: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly provenance: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly confirmed: v.BooleanSchema<undefined>;
@@ -4925,6 +4926,7 @@ export declare const ENTITIES: {
             readonly origin: v.PicklistSchema<readonly ["file", "owner", "suggested", "message", "calendar"], undefined>;
             readonly target_text: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly role: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly purpose: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly evidence: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly provenance: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly confirmed: v.BooleanSchema<undefined>;
@@ -5023,6 +5025,7 @@ export declare const ENTITIES: {
                 readonly origin: v.PicklistSchema<readonly ["file", "owner", "suggested", "message", "calendar"], undefined>;
                 readonly target_text: v.NullableSchema<v.StringSchema<undefined>, undefined>;
                 readonly role: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                readonly purpose: v.NullableSchema<v.StringSchema<undefined>, undefined>;
                 readonly evidence: v.NullableSchema<v.StringSchema<undefined>, undefined>;
                 readonly provenance: v.NullableSchema<v.StringSchema<undefined>, undefined>;
                 readonly confirmed: v.BooleanSchema<undefined>;
@@ -5037,6 +5040,7 @@ export declare const ENTITIES: {
                 readonly origin: v.PicklistSchema<readonly ["file", "owner", "suggested", "message", "calendar"], undefined>;
                 readonly target_text: v.NullableSchema<v.StringSchema<undefined>, undefined>;
                 readonly role: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                readonly purpose: v.NullableSchema<v.StringSchema<undefined>, undefined>;
                 readonly evidence: v.NullableSchema<v.StringSchema<undefined>, undefined>;
                 readonly provenance: v.NullableSchema<v.StringSchema<undefined>, undefined>;
                 readonly confirmed: v.BooleanSchema<undefined>;
@@ -5136,6 +5140,7 @@ export declare const ENTITIES: {
             readonly origin: v.PicklistSchema<readonly ["file", "owner", "suggested", "message", "calendar"], undefined>;
             readonly target_text: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly role: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly purpose: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly evidence: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly provenance: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly confirmed: v.BooleanSchema<undefined>;
@@ -5150,6 +5155,7 @@ export declare const ENTITIES: {
             readonly origin: v.PicklistSchema<readonly ["file", "owner", "suggested", "message", "calendar"], undefined>;
             readonly target_text: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly role: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly purpose: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly evidence: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly provenance: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly confirmed: v.BooleanSchema<undefined>;
@@ -5277,6 +5283,7 @@ export declare const ENTITIES: {
                 readonly origin: v.PicklistSchema<readonly ["file", "owner", "suggested", "message", "calendar"], undefined>;
                 readonly target_text: v.NullableSchema<v.StringSchema<undefined>, undefined>;
                 readonly role: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                readonly purpose: v.NullableSchema<v.StringSchema<undefined>, undefined>;
                 readonly evidence: v.NullableSchema<v.StringSchema<undefined>, undefined>;
                 readonly provenance: v.NullableSchema<v.StringSchema<undefined>, undefined>;
                 readonly confirmed: v.BooleanSchema<undefined>;
@@ -5291,6 +5298,7 @@ export declare const ENTITIES: {
                 readonly origin: v.PicklistSchema<readonly ["file", "owner", "suggested", "message", "calendar"], undefined>;
                 readonly target_text: v.NullableSchema<v.StringSchema<undefined>, undefined>;
                 readonly role: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                readonly purpose: v.NullableSchema<v.StringSchema<undefined>, undefined>;
                 readonly evidence: v.NullableSchema<v.StringSchema<undefined>, undefined>;
                 readonly provenance: v.NullableSchema<v.StringSchema<undefined>, undefined>;
                 readonly confirmed: v.BooleanSchema<undefined>;
@@ -5383,6 +5391,7 @@ export declare const ENTITIES: {
                 readonly origin: v.PicklistSchema<readonly ["file", "owner", "suggested", "message", "calendar"], undefined>;
                 readonly target_text: v.NullableSchema<v.StringSchema<undefined>, undefined>;
                 readonly role: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                readonly purpose: v.NullableSchema<v.StringSchema<undefined>, undefined>;
                 readonly evidence: v.NullableSchema<v.StringSchema<undefined>, undefined>;
                 readonly provenance: v.NullableSchema<v.StringSchema<undefined>, undefined>;
                 readonly confirmed: v.BooleanSchema<undefined>;
@@ -5397,6 +5406,7 @@ export declare const ENTITIES: {
                 readonly origin: v.PicklistSchema<readonly ["file", "owner", "suggested", "message", "calendar"], undefined>;
                 readonly target_text: v.NullableSchema<v.StringSchema<undefined>, undefined>;
                 readonly role: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                readonly purpose: v.NullableSchema<v.StringSchema<undefined>, undefined>;
                 readonly evidence: v.NullableSchema<v.StringSchema<undefined>, undefined>;
                 readonly provenance: v.NullableSchema<v.StringSchema<undefined>, undefined>;
                 readonly confirmed: v.BooleanSchema<undefined>;
@@ -6600,6 +6610,7 @@ export declare const ENTITIES: {
         readonly to: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
         readonly kind: v.PicklistSchema<readonly ["member-of", "related-to"], undefined>;
         readonly role: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly purpose: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly evidence: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly confirmed: v.BooleanSchema<undefined>;
         readonly provenance: v.NullableSchema<v.StringSchema<undefined>, undefined>;

package/dist/entities/relationship.d.ts

@@ -6,6 +6,8 @@ export declare const relationship: v.StrictObjectSchema<{
     readonly to: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
     readonly kind: v.PicklistSchema<readonly ["member-of", "related-to"], undefined>;
     readonly role: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    /** A purpose from memo's config; `null` means `work`. */
+    readonly purpose: v.NullableSchema<v.StringSchema<undefined>, undefined>;
     readonly evidence: v.NullableSchema<v.StringSchema<undefined>, undefined>;
     /** An agent's suggestion stays unconfirmed, and `weak`, until the owner confirms it. */
     readonly confirmed: v.BooleanSchema<undefined>;

package/dist/entities/relationship.js

@@ -8,6 +8,8 @@ export const relationship = v.strictObject({
     to: reference,
     kind: v.picklist(RELATION_KINDS),
     role: v.nullable(text),
+    /** A purpose from memo's config; `null` means `work`. */
+    purpose: v.nullable(text),
     evidence: v.nullable(text),
     /** An agent's suggestion stays unconfirmed, and `weak`, until the owner confirms it. */
     confirmed: v.boolean(),

package/dist/entities/task-results.d.ts

@@ -53,6 +53,7 @@ export declare const taskCard: v.StrictObjectSchema<{
         readonly origin: v.PicklistSchema<readonly ["file", "owner", "suggested", "message", "calendar"], undefined>;
         readonly target_text: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly role: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly purpose: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly evidence: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly provenance: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly confirmed: v.BooleanSchema<undefined>;
@@ -67,6 +68,7 @@ export declare const taskCard: v.StrictObjectSchema<{
         readonly origin: v.PicklistSchema<readonly ["file", "owner", "suggested", "message", "calendar"], undefined>;
         readonly target_text: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly role: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly purpose: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly evidence: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly provenance: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly confirmed: v.BooleanSchema<undefined>;
@@ -165,6 +167,7 @@ export declare const taskCreated: v.StrictObjectSchema<{
             readonly origin: v.PicklistSchema<readonly ["file", "owner", "suggested", "message", "calendar"], undefined>;
             readonly target_text: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly role: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly purpose: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly evidence: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly provenance: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly confirmed: v.BooleanSchema<undefined>;
@@ -179,6 +182,7 @@ export declare const taskCreated: v.StrictObjectSchema<{
             readonly origin: v.PicklistSchema<readonly ["file", "owner", "suggested", "message", "calendar"], undefined>;
             readonly target_text: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly role: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly purpose: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly evidence: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly provenance: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly confirmed: v.BooleanSchema<undefined>;
@@ -278,6 +282,7 @@ export declare const taskLinks: v.UnionSchema<[v.StrictObjectSchema<{
         readonly origin: v.PicklistSchema<readonly ["file", "owner", "suggested", "message", "calendar"], undefined>;
         readonly target_text: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly role: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly purpose: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly evidence: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly provenance: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly confirmed: v.BooleanSchema<undefined>;
@@ -292,6 +297,7 @@ export declare const taskLinks: v.UnionSchema<[v.StrictObjectSchema<{
         readonly origin: v.PicklistSchema<readonly ["file", "owner", "suggested", "message", "calendar"], undefined>;
         readonly target_text: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly role: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly purpose: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly evidence: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly provenance: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly confirmed: v.BooleanSchema<undefined>;
@@ -419,6 +425,7 @@ export declare const taskMerge: v.StrictObjectSchema<{
             readonly origin: v.PicklistSchema<readonly ["file", "owner", "suggested", "message", "calendar"], undefined>;
             readonly target_text: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly role: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly purpose: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly evidence: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly provenance: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly confirmed: v.BooleanSchema<undefined>;
@@ -433,6 +440,7 @@ export declare const taskMerge: v.StrictObjectSchema<{
             readonly origin: v.PicklistSchema<readonly ["file", "owner", "suggested", "message", "calendar"], undefined>;
             readonly target_text: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly role: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly purpose: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly evidence: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly provenance: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly confirmed: v.BooleanSchema<undefined>;
@@ -525,6 +533,7 @@ export declare const taskUnmerge: v.StrictObjectSchema<{
             readonly origin: v.PicklistSchema<readonly ["file", "owner", "suggested", "message", "calendar"], undefined>;
             readonly target_text: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly role: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly purpose: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly evidence: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly provenance: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly confirmed: v.BooleanSchema<undefined>;
@@ -539,6 +548,7 @@ export declare const taskUnmerge: v.StrictObjectSchema<{
             readonly origin: v.PicklistSchema<readonly ["file", "owner", "suggested", "message", "calendar"], undefined>;
             readonly target_text: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly role: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly purpose: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly evidence: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly provenance: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly confirmed: v.BooleanSchema<undefined>;

package/dist/entities/task-results.js

@@ -15,6 +15,7 @@ const link = v.strictObject({
     origin: v.picklist(LINK_SOURCES),
     target_text: v.nullable(text),
     role: v.nullable(text),
+    purpose: v.nullable(text),
     evidence: v.nullable(text),
     provenance: v.nullable(text),
     confirmed: v.boolean(),

package/dist/errors/reasons.js

@@ -144,6 +144,7 @@ const OTHERS = [
     ],
     validation("name.invalid", "the name is not valid"),
     validation("output.choose-fields", "at a terminal, --json names the fields it prints"),
+    validation("output.conflict", "two output switches ask for different output"),
     validation("output.one-object", "a report is one JSON object; --jsonl streams lists only"),
     validation("output.unknown-field", "the answer has no field by that name"),
     validation("name.taken", "the name is already used"),

package/dist/meetings/event-store.d.ts

@@ -253,6 +253,16 @@ export interface EventStore {
     saveCalendars(accountId: number, calendars: CalendarInput[], now: number): Promise<StoredCalendar[]>;
     calendars(accountId: number): Promise<StoredCalendar[]>;
     setCalendarSynced(calendarId: number, synced: boolean, now: number): Promise<void>;
+    /**
+     * The calendar and everything stored from it go, for a calendar that is not the owner's data (a followed feed): its
+     * entries, the events and series only it held, what was built from them (links, tags, search pieces, people seen
+     * only there) and its cursor. An event another calendar also holds stays, with that copy's fields; a meeting linked
+     * to a gone event stays, unlinked. Notes the owner wrote stay.
+     */
+    forgetCalendar(calendarId: number, now: number): Promise<{
+        entries: number;
+        events: number;
+    }>;
     /** One sync page, matched by rules 1–5, in one transaction. */
     saveEntries(calendarId: number, entries: EntryInput[], now: number): Promise<StoredEntry[]>;
     /**

package/dist/meetings/testing/event-store-contract.js

@@ -192,6 +192,42 @@ export const eventStoreContract = (make) => {
             assert.equal(occurrence?.entries[0]?.deletedAt, null);
             assert.equal(await store.removeEntries(calendar, ["p"], CONTRACT_NOW + 1), 0);
         }),
+        test("a forgotten calendar goes with its entries and the events only it held; a shared event keeps the other copy", async (fixture) => {
+            const { store, calendar, accountId } = fixture;
+            const feed = await second(fixture, "ics:example");
+            await store.saveEntries(calendar, [single("w1", later, { icalUid: "shared@example.com", title: "Mine" })], 2);
+            const series = {
+                ...single("weekly", later, { title: "Weekly" }),
+                kind: "series",
+                recurrence: ["RRULE:FREQ=WEEKLY"],
+            };
+            await store.saveEntries(feed, [
+                single("f1", later, { icalUid: "shared@example.com", title: "Theirs", description: "longer text" }),
+                single("f2", later + HOUR, { title: "Only in the feed", participants: [{ email: "guest@example.com" }] }),
+                series,
+            ], 3);
+            await store.saveSlots(feed, [
+                {
+                    series: "weekly",
+                    slots: [
+                        {
+                            ...single("weekly@1", later + 2 * HOUR),
+                            kind: "occurrence",
+                            seriesExternalId: "weekly",
+                            originalStartsAt: later + 2 * HOUR,
+                        },
+                    ],
+                },
+            ], { from: earlier, to: later + 7 * 24 * HOUR }, "cursor", 3);
+            await store.setCursor(feed, "cursor", 3);
+            const forgotten = await store.forgetCalendar(feed, 4);
+            assert.deepEqual(forgotten, { entries: 4, events: 2 });
+            assert.deepEqual((await store.calendars(accountId)).map(({ externalId }) => externalId), ["primary"]);
+            const left = await store.events({ accountId });
+            assert.deepEqual(left.map(({ title, status }) => [title, status]), [["Mine", "confirmed"]]);
+            assert.equal((await store.event(left[0]?.id))?.entries.length, 1);
+            assert.equal(await store.entry(feed, "weekly"), null);
+        }),
         test("a calendar's cursor is its own, and null forgets it", async (fixture) => {
             const { store, calendar } = fixture;
             const other = await second(fixture);

package/dist/output-detail.js

@@ -2,13 +2,17 @@ export const DETAILS = ["brief", "full"];
 /** Message fields mail never has and a messenger hit rarely fills; a null one is noise. */
 const RARELY_SET = ["editedAt", "replyTo", "forwardedFrom", "reactions"];
 const BRIEF = ["locator", "chatTitle", "timestamp", "senderName", "excerpt", "score"];
-const isHit = (value) => typeof value === "object" &&
-    value !== null &&
-    typeof value.locator === "string" &&
-    typeof value.text === "string";
+/** A messenger answer's hit (`message.hit`): already cut to an excerpt, so only `brief` changes it. */
+const SNAKE_BRIEF = ["ref", "chat_title", "timestamp", "sender_name", "excerpt", "score"];
+const isRecord = (value) => typeof value === "object" && value !== null;
+const isSnakeHit = (value) => isRecord(value) && typeof value.ref === "string" && typeof value.excerpt === "string";
+const isHit = (value) => isSnakeHit(value) || (isRecord(value) && typeof value.locator === "string" && typeof value.text === "string");
+const picked = (hit, keys) => Object.fromEntries(keys.flatMap((key) => (hit[key] === undefined || hit[key] === null ? [] : [[key, hit[key]]])));
 const shaped = (hit, detail) => {
+    if (isSnakeHit(hit))
+        return detail === "brief" ? picked(hit, SNAKE_BRIEF) : hit;
     if (detail === "brief")
-        return Object.fromEntries(BRIEF.flatMap((key) => (hit[key] === undefined || hit[key] === null ? [] : [[key, hit[key]]])));
+        return picked(hit, BRIEF);
     const { text, providerMetadata, ...rest } = hit;
     for (const key of RARELY_SET)
         if (rest[key] === null)

package/dist/output.d.ts

@@ -14,6 +14,8 @@ export interface OutputOptions {
     hitDetail?: Detail;
     /** Takes the answer as an object in place of printing it — an agent's run (`BaseEnvironment.agent`). */
     capture?: (value: unknown) => void;
+    /** One line per item (WC-OUT-24); anything printed past `renderAnswer` stays JSON. */
+    compact?: boolean;
 }
 /**
  * One place decides the mode, so no command can disagree with another.
@@ -23,9 +25,11 @@ export interface OutputOptions {
  * instead. In every machine mode **stdout carries JSON and nothing else** — diagnostics are on stderr in all modes, which is what makes
  * that contract hold by construction rather than by remembering.
  */
-export declare const resolveOutput: ({ json, jsonl, quiet, streams, tty, color, fields, hitDetail, env, capture, }?: OutputOptions) => {
+export declare const resolveOutput: ({ json, jsonl, quiet, streams, tty, color, fields, hitDetail, env, capture, compact, }?: OutputOptions) => {
     format: "json" | "jsonl" | "pretty";
     color: boolean;
     streams: Streams;
     renderer: Renderer;
+    compact?: boolean | undefined;
+    full?: boolean | undefined;
 };

package/dist/output.js

@@ -1,6 +1,23 @@
-import { createRenderer, processStreams, singleLine, } from "@wirecat/cli-base";
+import { CliError, createRenderer, processStreams, singleLine, } from "@wirecat/cli-base";
+import { COMPACT_FLAG } from "@wirecat/cli-base/standards";
 import { fieldsOf, projectFields } from "./cli/result-fields.js";
 import { atDetail } from "./output-detail.js";
+const refuseCompact = ({ json, jsonl, fields, hitDetail }) => {
+    const other = jsonl
+        ? "--jsonl"
+        : fields !== undefined
+            ? "--json=…"
+            : json
+                ? "--json"
+                : hitDetail === "brief"
+                    ? "--brief"
+                    : "";
+    if (other)
+        throw new CliError("validation_error", `${COMPACT_FLAG} and ${other} ask for different output — pick one`, {
+            reason: "output.conflict",
+            param: COMPACT_FLAG,
+        });
+};
 /**
  * One place decides the mode, so no command can disagree with another.
  *
@@ -9,9 +26,11 @@ import { atDetail } from "./output-detail.js";
  * instead. In every machine mode **stdout carries JSON and nothing else** — diagnostics are on stderr in all modes, which is what makes
  * that contract hold by construction rather than by remembering.
  */
-export const resolveOutput = ({ json, jsonl, quiet, streams = processStreams, tty, color, fields, hitDetail, env = process.env, capture, } = {}) => {
+export const resolveOutput = ({ json, jsonl, quiet, streams = processStreams, tty, color, fields, hitDetail, env = process.env, capture, compact, } = {}) => {
+    if (compact)
+        refuseCompact({ json, jsonl, fields, hitDetail });
     const interactive = tty ?? process.stdout.isTTY === true;
-    const format = jsonl ? "jsonl" : json || !interactive ? "json" : "pretty";
+    const format = jsonl ? "jsonl" : json || compact || !interactive ? "json" : "pretty";
     const painted = format === "pretty" && (color ?? (env.NO_COLOR === undefined && env.TERM !== "dumb" && !env.CI));
     const printing = createRenderer({ format, color: painted, streams });
     const rendered = capture
@@ -37,7 +56,13 @@ export const resolveOutput = ({ json, jsonl, quiet, streams = processStreams, tt
                 stream: (items) => created.stream([...items].map((item) => projectFields(item, paths))),
             }
             : created;
-    return { format, color: painted, streams, renderer: quiet ? silence(renderer) : renderer };
+    return {
+        format,
+        color: painted,
+        streams,
+        renderer: quiet ? silence(renderer) : renderer,
+        ...(compact ? { compact: true, full: hitDetail === "full" } : {}),
+    };
 };
 /** Fields a person writes in paragraphs; every other string is a name, a title, an id or a path. */
 const MULTI_LINE = new Set(["text", "description"]);

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

@@ -0,0 +1,4 @@
+import type { MessageStore } from "../../../store/index.js";
+import type { ProposalKind } from "../types.js";
+/** An agent's change to a relationship's role or purpose; the owner's applies at once and never waits here. */
+export declare const relationshipUpdateKind: (store: Pick<MessageStore, "knowledge" | "proposedActions">) => ProposalKind;

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/accounts.d.ts

@@ -1,3 +1,4 @@
+import type { CacheDatabase } from "../driver.js";
 import type { AccountKey, StoredAccount } from "../types.js";
 import type { StoreContext } from "./open.js";
 /** An account's row, made on first sight; a name only replaces what was known when there is one. */
@@ -10,3 +11,10 @@ export declare const storedAccounts: ({ orm }: StoreContext) => StoredAccount[];
 export declare const storedAccount: ({ orm }: StoreContext, { provider, account }: AccountKey) => StoredAccount;
 /** Everything the account holds, children before parents: the foreign keys are enforced. */
 export declare const purgeAccount: ({ orm, database }: StoreContext, accountKey: number) => void;
+export declare const unreferenced: (database: CacheDatabase, table: "identities") => Set<number>;
+/**
+ * People only the purged account had seen go with it. An identity stays while anything else points at it
+ * (another account, a tag, a note, a link), or while its person is kept: the owner, a person something
+ * points at, or one linked to an identity that stays.
+ */
+export declare const dropOrphanPeople: (database: CacheDatabase, unseenBefore: Set<number>) => void;

package/dist/store/sqlite/accounts.js

@@ -132,7 +132,7 @@ const referencesTo = (database, table, skip) => {
     const pointers = pointerPairs(database).map(({ table: tbl, pointer }) => `SELECT ${pointer}_id AS id FROM "${tbl}" WHERE ${pointer}_type = '${type}'`);
     return [...keys, ...pointers].join(" UNION ");
 };
-const unreferenced = (database, table) => new Set(database
+export const unreferenced = (database, table) => new Set(database
     .prepare(`SELECT id FROM ${table} WHERE id NOT IN (SELECT id FROM (${referencesTo(database, table, OWN)}) WHERE id IS NOT NULL)`)
     .all()
     .map(({ id }) => Number(id)));
@@ -141,7 +141,7 @@ const unreferenced = (database, table) => new Set(database
  * (another account, a tag, a note, a link), or while its person is kept: the owner, a person something
  * points at, or one linked to an identity that stays.
  */
-const dropOrphanPeople = (database, unseenBefore) => {
+export const dropOrphanPeople = (database, unseenBefore) => {
     const orphans = [...unreferenced(database, "identities")].filter((id) => !unseenBefore.has(id));
     if (orphans.length === 0)
         return;

package/dist/store/sqlite/calendar-forget.d.ts

@@ -0,0 +1,17 @@
+import type { CacheDatabase } from "../driver.js";
+/**
+ * `EventStore.forgetCalendar` inside its transaction: children before parents, since the foreign keys are enforced.
+ * `refresh` gives a kept event or series its fields again from the copies left.
+ */
+export declare const forgetCalendarRows: (database: CacheDatabase, { calendarId, accountId, cursorKey, now }: {
+    calendarId: number;
+    accountId: number;
+    cursorKey: string;
+    now: number;
+}, refresh: {
+    event: (id: number, now: number) => void;
+    series: (id: number, now: number) => void;
+}) => {
+    entries: number;
+    events: number;
+};

package/dist/store/sqlite/calendar-forget.js

@@ -0,0 +1,68 @@
+import { dropOrphanPeople, unreferenced } from "./accounts.js";
+import { dropUnusedVectors } from "./vector-index.js";
+const distinctIds = (rows) => [...new Set(rows.map((row) => Number(row.id)))];
+/**
+ * `EventStore.forgetCalendar` inside its transaction: children before parents, since the foreign keys are enforced.
+ * `refresh` gives a kept event or series its fields again from the copies left.
+ */
+export const forgetCalendarRows = (database, { calendarId, accountId, cursorKey, now }, refresh) => {
+    const unseenBefore = unreferenced(database, "identities");
+    const ids = (sql) => distinctIds(database.prepare(sql).all(calendarId));
+    const entryIds = ids("SELECT id FROM calendar_entries WHERE calendar_id = ?");
+    const eventIds = ids("SELECT event_id AS id FROM calendar_entries WHERE calendar_id = ? AND event_id IS NOT NULL");
+    const seriesIds = ids("SELECT event_series_id AS id FROM calendar_entries WHERE calendar_id = ? AND event_series_id IS NOT NULL");
+    const hashes = [];
+    const dropAround = (type, list) => {
+        const json = JSON.stringify(list);
+        const inList = "IN (SELECT value FROM json_each(?))";
+        for (const row of database
+            .prepare(`SELECT DISTINCT content_hash FROM chunks WHERE chunkable_type = ? AND chunkable_id ${inList}`)
+            .all(type, json))
+            hashes.push(String(row.content_hash));
+        database.prepare(`DELETE FROM chunks WHERE chunkable_type = ? AND chunkable_id ${inList}`).run(type, json);
+        database
+            .prepare(`DELETE FROM links WHERE (from_type = ? AND from_id ${inList}) OR (to_type = ? AND to_id ${inList})`)
+            .run(type, json, type, json);
+        for (const [table, pointer] of [
+            ["taggings", "taggable"],
+            ["aliases", "aliasable"],
+            ["attachments", "attachable"],
+            ["link_reviews", "linkable"],
+            ["entity_link_events", "linkable"],
+        ])
+            database.prepare(`DELETE FROM ${table} WHERE ${pointer}_type = ? AND ${pointer}_id ${inList}`).run(type, json);
+    };
+    const entries = JSON.stringify(entryIds);
+    for (const table of ["calendar_entry_participants", "calendar_entry_revisions"])
+        database.prepare(`DELETE FROM ${table} WHERE entry_id IN (SELECT value FROM json_each(?))`).run(entries);
+    dropAround("calendar_entry", entryIds);
+    // Occurrences point at their series in the same table: the pointers go first, so the order of rows is free.
+    database.prepare("UPDATE calendar_entries SET series_entry_id = NULL WHERE calendar_id = ?").run(calendarId);
+    database.prepare("DELETE FROM calendar_entries WHERE calendar_id = ?").run(calendarId);
+    const held = (column, id) => database.prepare(`SELECT 1 FROM calendar_entries WHERE ${column} = ? LIMIT 1`).get(id) !== undefined;
+    const goneSeries = seriesIds.filter((id) => !held("event_series_id", id));
+    const goneEvents = eventIds.filter((id) => !held("event_id", id));
+    const gone = (list) => JSON.stringify(list);
+    database
+        .prepare("UPDATE meetings SET event_id = NULL, updated_at = ? WHERE event_id IN (SELECT value FROM json_each(?))")
+        .run(now, gone(goneEvents));
+    dropAround("event", goneEvents);
+    database.prepare("DELETE FROM events WHERE id IN (SELECT value FROM json_each(?))").run(gone(goneEvents));
+    for (const table of ["meeting_series", "events"])
+        database
+            .prepare(`UPDATE ${table} SET event_series_id = NULL, updated_at = ? WHERE event_series_id IN (SELECT value FROM json_each(?))`)
+            .run(now, gone(goneSeries));
+    dropAround("event_series", goneSeries);
+    database.prepare("DELETE FROM event_series WHERE id IN (SELECT value FROM json_each(?))").run(gone(goneSeries));
+    for (const id of seriesIds)
+        if (!goneSeries.includes(id))
+            refresh.series(id, now);
+    for (const id of eventIds)
+        if (!goneEvents.includes(id))
+            refresh.event(id, now);
+    database.prepare("DELETE FROM sync_cursors WHERE account_id = ? AND key = ?").run(accountId, cursorKey);
+    database.prepare("DELETE FROM calendars WHERE id = ?").run(calendarId);
+    dropOrphanPeople(database, unseenBefore);
+    dropUnusedVectors(database, hashes);
+    return { entries: entryIds.length, events: goneEvents.length };
+};