@wirecat/cli-core 0.516.0 → 0.518.0

package/CHANGELOG.md

@@ -7,6 +7,37 @@ shape of this file.
 
 ## Unreleased
 
+## 0.518.0 — 01.11.2026
+
+### Added
+
+- **A memory names its project (store version 43)**: `memories.add({ project })`, `memories.list({ project })` and
+  `memories.update(ref, { project })`, which moves a memory to another project or to none with `null`. A memory and a
+  fact carry `project` and `projectName` (`project` and `project_name` in the `memory` and `fact` entities), so a reader
+  needs no second lookup for the name.
+- **`evidenceFindings.sources(id)`** reads each reference a findings batch cites back once, in the shape of
+  `memories.sources`: `kind`, `title`, `sender`, `at`, an excerpt of at most 280 characters, `tool` and `missing`.
+
+### Fixed
+
+- **A findings batch closed with nothing accepted reads as `rejected`** in `proposedActions.get` and `list`, and
+  `list({ status: "rejected" })` finds it. The store still writes it `approved`, so older builds read it as before.
+
+## 0.517.0 — 01.11.2026
+
+### Added
+
+- **`withSyncCommands(found, sync)`** gives each linked chat of a stored project gathering its `syncCommand`: the
+  line the text names to sync a chat held in part, or null. tg's and max's `projects evidence --json` carry it as
+  `linked_chats[].sync_command`, so an agent reading JSON gets the command the text shows.
+
+### Fixed
+
+- **A chat that reaches its first message is no longer "held from <date> only"** in `missing`, `next` and the
+  `projects evidence` text: it is "held from its first message, behind since <date>", or "with gaps".
+- **`messages sync` progress says how far back it got as a date** ("back to 2026-09-27"), not as a message key, which
+  for MAX was a number of milliseconds.
+
 ## 0.516.0 — 01.11.2026
 
 ### Fixed

package/dist/cli/index.d.ts

@@ -109,7 +109,7 @@ export { window, withPaging } from "./paging.js";
 export { type CommandPermissions, commandPathKey, commandPermissions, knownBeside, knownPermissionKeys, type PermissionKeyOf, type PermissionKeySource, refuseUnknownPermissionKeys, unknownPermissionIssues, unknownPermissionKeys, } from "./permission-keys.js";
 export { asFirstWord, commandWords, liftProfile, profileFree, refuseCommandName, rootOf, takesProfile, usableProfileName, } from "./profile.js";
 export { createProgram, type ProgramDefinition, type ProgramOptions, type RunOptions, run } from "./program.js";
-export { type ProjectTextHints, projectAnswerParts, projectCutoffTime, projectEvidenceText, projectWindowOf, } from "./project-evidence.js";
+export { type ProjectTextHints, projectAnswerParts, projectCutoffTime, projectEvidenceText, projectWindowOf, withSyncCommands, } from "./project-evidence.js";
 export { fieldsOf, projectFields } from "./result-fields.js";
 export { type Config, type Configuration, count, first, flag, fromFile, type GlobalFlags, NONE_NAMED, namedProfile, type ProfileKind, plain, type ResolveOptions, type Settings, type SettingsExtension, type SettingsExtensionContext, type Source, settingsFor, } from "./settings.js";
 export { type PermissionAnswer, readSetupAnswers, type SetupAnswers, setupPermissionCeiling } from "./setup-answers.js";

package/dist/cli/index.js

@@ -99,7 +99,7 @@ export { window, withPaging } from "./paging.js";
 export { commandPathKey, commandPermissions, knownBeside, knownPermissionKeys, refuseUnknownPermissionKeys, unknownPermissionIssues, unknownPermissionKeys, } from "./permission-keys.js";
 export { asFirstWord, commandWords, liftProfile, profileFree, refuseCommandName, rootOf, takesProfile, usableProfileName, } from "./profile.js";
 export { createProgram, run } from "./program.js";
-export { projectAnswerParts, projectCutoffTime, projectEvidenceText, projectWindowOf, } from "./project-evidence.js";
+export { projectAnswerParts, projectCutoffTime, projectEvidenceText, projectWindowOf, withSyncCommands, } from "./project-evidence.js";
 export { fieldsOf, projectFields } from "./result-fields.js";
 export { count, first, flag, fromFile, NONE_NAMED, namedProfile, plain, settingsFor, } from "./settings.js";
 export { readSetupAnswers, setupPermissionCeiling } from "./setup-answers.js";

package/dist/cli/messenger/projects-command.js

@@ -7,7 +7,7 @@ import { gatherStoredProject } from "../../services/stored-project-gathering.js"
 import { FETCH } from "../effects.js";
 import { itemOf, renderAnswer, snakeKeys } from "../envelope.js";
 import { positiveCount } from "../paging.js";
-import { projectAnswerParts, projectCutoffTime, projectEvidenceText, projectWindowOf } from "../project-evidence.js";
+import { projectAnswerParts, projectCutoffTime, projectEvidenceText, projectWindowOf, withSyncCommands, } from "../project-evidence.js";
 import { lineOf } from "../steps.js";
 import { messengerContext } from "./context.js";
 const collect = (value, previous) => [...previous, value];
@@ -120,12 +120,13 @@ export const projectsCommand = (messenger) => {
             : undefined;
         const found = await context.withStore((store, account) => gather(store, account, fetcher));
         const parts = projectAnswerParts(options.sinceTime, found);
-        renderAnswer(this, context, itemOf(snakeKeys(found), parts), () => projectEvidenceText(found, {
+        const hints = {
             sync: (one, since) => one.provider === messenger.provider
                 ? lineOf(this, `projects evidence ${quote(project)} --since-time ${since} --sync-first`)
                 : null,
             showDocument: "the notes app that imported it",
-        }));
+        };
+        renderAnswer(this, context, itemOf(snakeKeys(withSyncCommands(found, hints.sync)), parts), () => projectEvidenceText(found, hints));
     }));
     return projects;
 };

package/dist/cli/messenger/search-answers.d.ts

@@ -18,6 +18,11 @@ export type HitItem = InferOutput<(typeof ENTITIES)["hit"]>;
 /** The page a `--page` asks for, as the offset the search services take. */
 export declare const offsetOf: (page: number | undefined, limit: number) => number | undefined;
 export declare const messageHitItem: (hit: FoundMessage, query?: string) => MessageHitItem;
+/**
+ * What the store holds of a chat that is not complete, in words. A chat that reaches its first message is only
+ * behind or has gaps: saying "held from <date> only" would claim older history is missing.
+ */
+export declare const heldPhrase: ({ completeness, held }: Pick<ChatCoverage, "completeness" | "held">) => string;
 /**
  * What the archive lacked for this answer, and the step that would fill it. From a search's coverage, or from the
  * chats an answer is about (`since` is the start of the window it was asked for).

package/dist/cli/messenger/search-answers.js

@@ -96,6 +96,19 @@ const metaOf = (accounts, skipped = [], heldInPart = false) => ({
         : {}),
 });
 const day = (at) => at?.slice(0, 10) ?? "no date";
+/**
+ * What the store holds of a chat that is not complete, in words. A chat that reaches its first message is only
+ * behind or has gaps: saying "held from <date> only" would claim older history is missing.
+ */
+export const heldPhrase = ({ completeness, held }) => {
+    if (completeness.state === "unknown" || !held.oldestAt)
+        return "never fetched";
+    if (!completeness.reachesStart)
+        return `held from ${day(held.oldestAt)} only`;
+    if (completeness.gaps)
+        return "held from its first message, with gaps";
+    return `held from its first message, behind since ${day(held.newestAt)}`;
+};
 /**
  * The steps for chats the store holds only in part. Bounded first, when the answer's window is known, then the whole
  * chat; both name the first chat only, because a download is the owner's call. Counts and dates only, never text.
@@ -105,7 +118,7 @@ const chatGaps = (rows, since) => {
     const [first] = open;
     if (!first)
         return { next: [], missing: [] };
-    const held = first.completeness.state === "unknown" ? "never fetched" : `held from ${day(first.held.oldestAt)} only`;
+    const held = heldPhrase(first);
     const steps = (args, why) => ({
         ...nextStep("messages.sync", { args: { chat: first.chatId, ...args } }),
         why,

package/dist/cli/project-evidence.d.ts

@@ -41,6 +41,102 @@ export declare const projectAnswerParts: (sinceTime: string, found: StoredProjec
         complete: boolean;
     };
 };
+/**
+ * The gathering with each linked chat's `syncCommand`: the line that syncs a chat held in part back to the window
+ * start, or null when it needs none or no command here can. JSON readers get what the text says per chat.
+ */
+export declare const withSyncCommands: (found: StoredProjectGathering, sync: ProjectTextHints["sync"]) => {
+    schemaVersion: 1;
+    runKey: string;
+    fingerprint: string;
+    resumed: boolean;
+    project: {
+        name: string;
+        key: string | null;
+        background: string | null;
+        aliases: string[];
+    };
+    window: {
+        after: number;
+        before: number;
+        asOf: number;
+        lookbackDays: number | null;
+        basis: "explicit" | "lookback";
+        timeBasis: "per-item-time-kind";
+    };
+    scope: {
+        origin: "all-connected" | "explicit";
+        sources: import("../context/evidence.js").ContextSource[];
+    };
+    lanes: import("../services/project-gathering-request.js").ProjectLane[];
+    fetch: import("../services/project-gathering-request.js").ProjectChatFetched[];
+    index: import("../services/project-gathering.js").ProjectIndexCatchUp;
+    units: {
+        lane: string;
+        source: number;
+        after: number;
+        before: number;
+        state: import("../services/project-gathering-request.js").ProjectUnitState;
+        pages: number;
+        issue: string | null;
+    }[];
+    items: import("../services/project-gathering.js").ProjectEvidenceItem[];
+    people: import("../services/project-gathering.js").ProjectEvidencePerson[];
+    peopleOmitted: number;
+    oversized: {
+        ref: string;
+        lanes: string[];
+        source: number;
+        bytes: number;
+    }[];
+    matchedAgain: {
+        ref: string;
+        lanes: string[];
+    }[];
+    usage: {
+        reads: number;
+        readBytes: number;
+        aroundBytes: number;
+        items: number;
+        elapsedMs: number;
+    };
+    totals: {
+        reads: number;
+        readBytes: number;
+        items: number;
+        invocations: number;
+    };
+    stopped: import("../services/project-gathering.js").ProjectGatheringStop;
+    complete: boolean;
+    completeness: "complete" | "partial" | "unknown";
+    checkpoint: string | null;
+    projectRef: string | null;
+    unreadSources: {
+        source: string;
+        kind: string;
+        reason?: "out-of-scope" | "linked-chat-limit" | "member-limit" | "no-identity" | "unknown-provider";
+    }[];
+    mentions: import("../services/project-gathering-mentions.js").EvidenceMentions;
+    linkedChats: {
+        provider: string;
+        account: string;
+        chat: string;
+        ref: string;
+        source: number | null;
+        lane: string | null;
+        state: "in-scope" | "out-of-scope" | "pending" | "unavailable";
+        title: string | null;
+        completeness: import("../store/exports.js").ChatCompleteness | null;
+        held: {
+            messages: number;
+            oldestAt: string | null;
+            newestAt: string | null;
+        } | null;
+        items?: number | undefined;
+        capped?: boolean | undefined;
+        syncCommand: string | null;
+    }[];
+};
 export interface ProjectTextHints {
     /** The command that syncs one linked chat back to `since` (`YYYY-MM-DD`), or null when no command here can. */
     sync: (chat: StoredProjectGathering["linkedChats"][number], since: string) => string | null;

package/dist/cli/project-evidence.js

@@ -1,7 +1,7 @@
 import { CliError } from "@wirecat/cli-base";
 import * as v from "valibot";
 import { dateWindow, momentOf } from "../services/moment.js";
-import { coverageGaps } from "./messenger/search-answers.js";
+import { coverageGaps, heldPhrase } from "./messenger/search-answers.js";
 /** Days back (`90d`) or a start date (`2026-09-01`); either way the run freezes its end, so a resume keeps it. */
 export const projectWindowOf = (value) => {
     const days = /^([1-9]\d{0,2})d$/.exec(value)?.[1];
@@ -47,6 +47,17 @@ export const projectAnswerParts = (sinceTime, found) => {
         },
     };
 };
+/**
+ * The gathering with each linked chat's `syncCommand`: the line that syncs a chat held in part back to the window
+ * start, or null when it needs none or no command here can. JSON readers get what the text says per chat.
+ */
+export const withSyncCommands = (found, sync) => ({
+    ...found,
+    linkedChats: found.linkedChats.map((one) => ({
+        ...one,
+        syncCommand: one.completeness === null || one.completeness.state === "complete" ? null : sync(one, day(found.window.after)),
+    })),
+});
 const LABELS = {
     "person-only": "  [person only]",
     sender: "  [sent by contact]",
@@ -120,13 +131,11 @@ export const projectEvidenceText = (found, hints) => {
     for (const one of found.fetch)
         lines.push(`${one.chat}: ${FETCH_STATES[one.state] ?? one.state} before reading` +
             `${one.reason && one.state !== "skipped" ? ` (${one.reason})` : ""}`);
-    const held = (one) => one.completeness?.state === "unknown" || !one.held?.oldestAt
-        ? "never fetched"
-        : `held from ${one.held.oldestAt.slice(0, 10)} only`;
     for (const one of found.linkedChats)
         if (one.completeness !== null && one.completeness.state !== "complete") {
             const sync = hints.sync(one, day(found.window.after));
-            lines.push(`${one.title ?? one.ref}: ${held(one)}${one.state === "pending" ? ", not read this run" : ""}` +
+            const held = one.held === null ? "never fetched" : heldPhrase({ completeness: one.completeness, held: one.held });
+            lines.push(`${one.title ?? one.ref}: ${held}${one.state === "pending" ? ", not read this run" : ""}` +
                 (sync ? ` — sync it: ${sync}` : ""));
         }
     const capped = found.linkedChats.filter((one) => one.capped);

package/dist/entities/fact.d.ts

@@ -6,6 +6,8 @@ export declare const fact: v.StrictObjectSchema<{
     readonly text: v.StringSchema<undefined>;
     readonly status: v.PicklistSchema<readonly ["proposed", "accepted", "superseded", "reversed", "rejected"], undefined>;
     readonly project: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    /** What the project is called. */
+    readonly project_name: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
     readonly subject: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
     /** What the subject is called; `null` for the owner and for a row with no name. */
     readonly subject_name: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;

package/dist/entities/fact.js

@@ -8,6 +8,8 @@ export const fact = v.strictObject({
     text,
     status: v.picklist(FACT_STATUSES),
     project: v.nullable(text),
+    /** What the project is called. */
+    project_name: v.optional(v.nullable(text)),
     subject: v.nullable(reference),
     /** What the subject is called; `null` for the owner and for a row with no name. */
     subject_name: v.optional(v.nullable(text)),

package/dist/entities/index.d.ts

@@ -5369,6 +5369,7 @@ export declare const ENTITIES: {
         readonly text: v.StringSchema<undefined>;
         readonly status: v.PicklistSchema<readonly ["proposed", "accepted", "superseded", "reversed", "rejected"], undefined>;
         readonly project: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly project_name: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
         readonly subject: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
         readonly subject_name: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
         readonly subject_is_owner: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
@@ -5408,6 +5409,8 @@ export declare const ENTITIES: {
         readonly subject: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
         readonly subject_name: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
         readonly subject_is_owner: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+        readonly project: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>, undefined>;
+        readonly project_name: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
         readonly author: v.StrictObjectSchema<{
             readonly type: v.PicklistSchema<["person", "bot"], undefined>;
             readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;

package/dist/entities/memory.d.ts

@@ -8,6 +8,9 @@ export declare const memory: v.StrictObjectSchema<{
     /** What the subject is called; `null` for the owner and for a row with no name. */
     readonly subject_name: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
     readonly subject_is_owner: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+    /** The project it belongs to, and what that project is called. */
+    readonly project: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>, undefined>;
+    readonly project_name: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
     readonly author: v.StrictObjectSchema<{
         readonly type: v.PicklistSchema<["person", "bot"], undefined>;
         readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;

package/dist/entities/memory.js

@@ -10,6 +10,9 @@ export const memory = v.strictObject({
     /** What the subject is called; `null` for the owner and for a row with no name. */
     subject_name: v.optional(v.nullable(text)),
     subject_is_owner: v.optional(v.boolean()),
+    /** The project it belongs to, and what that project is called. */
+    project: v.optional(v.nullable(reference)),
+    project_name: v.optional(v.nullable(text)),
     author,
     model: v.nullable(text),
     confidence: v.nullable(v.number()),

package/dist/services/archive.js

@@ -308,7 +308,7 @@ export const fetchInto = async ({ history, store, account, fetching, limit, page
         before = byTime
             ? new Date(boundary + (fresh > 0 && !(window && fetching.beforeInclusive) ? 1 : 0)).toISOString()
             : String(boundary);
-        note(`${fetched} messages so far, back to ${held.from}`);
+        note(`${fetched} messages so far, back to ${fromAt.slice(0, 10)}`);
         const wait = fetching.jitter ? pauseMs * (1 + Math.random()) : pauseMs;
         await sleep(wait, undefined, { signal: stop }).catch(() => { });
     }

package/dist/store/evidence-findings.d.ts

@@ -1,4 +1,5 @@
 import { type FindingOutcome, type FindingsInput, type FindingsReceipt } from "../meetings/index.js";
+import type { EvidenceSource } from "./sqlite/evidence-sources.js";
 export declare const EVIDENCE_FINDINGS_KIND = "evidence_findings";
 export declare const validateEvidenceFindings: (input: FindingsInput) => FindingsInput;
 /** Who decided: the owner, or an agent the host let decide for the owner, with its reason. */
@@ -60,4 +61,6 @@ export interface EvidenceFindingsStore {
         accept: string[];
         by?: EvidenceFindingsDecider;
     }): Promise<EvidenceFindingsBatch>;
+    /** Each reference the batch cites, read back once; one gone from the store since is `missing`. */
+    sources(id: string): Promise<EvidenceSource[]>;
 }

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

@@ -3,6 +3,7 @@ import { contextEvidenceFingerprint } from "../../context/evidence.js";
 import { findingFingerprint, findingHash } from "../../meetings/index.js";
 import { EVIDENCE_FINDINGS_KIND, validateEvidenceFindings, } from "../evidence-findings.js";
 import { contextRecordOf } from "./context-evidence.js";
+import { sourcesOfReferences } from "./evidence-sources.js";
 import { findingsAgent, findingsCoreOver } from "./findings-core.js";
 import { authorActor } from "./memories.js";
 import { proposalOperationsOver } from "./proposed-actions.js";
@@ -34,7 +35,7 @@ export const evidenceFindingsStoreOver = (context) => {
     };
     const view = (proposal) => {
         const input = proposal.payload;
-        if (!input || !proposal.target || !["proposed", "approved"].includes(proposal.status))
+        if (!input || !proposal.target || !["proposed", "approved", "rejected"].includes(proposal.status))
             return invalid("invalid stored findings batch");
         return {
             id: proposal.id,
@@ -123,6 +124,7 @@ export const evidenceFindingsStoreOver = (context) => {
             });
         },
         get: async (id) => view(load(id)),
+        sources: async (id) => sourcesOfReferences(database, view(load(id)).input.findings.flatMap((finding) => finding.evidence.map((one) => one.reference))),
         list: async ({ project, limit = 20, offset = 0, status } = {}) => {
             if (status !== undefined && status !== "proposed" && status !== "reviewed")
                 return invalid("finding status is proposed or reviewed");

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

@@ -21,3 +21,5 @@ 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,5 +1,5 @@
 import { linkKind } from "./link-kinds.js";
-import { referenceOfThing, stateOfThing, storedThing } from "./things.js";
+import { canonicalThingReference, referenceOfThing, stateOfThing, storedThing, thingOf } from "./things.js";
 const EXCERPT_CHARS = 280;
 const excerptOf = (text) => {
     if (text == null)
@@ -32,16 +32,7 @@ const 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) => {
-    const thing = storedThing(link.to_type, link.to_id);
+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);
@@ -56,4 +47,37 @@ export const evidenceSourcesOf = (database, from) => database
         tool: textOf(row?.tool),
         missing: gone,
     };
+};
+/**
+ * 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, canonicalThingReference(reference));
+    }
+    catch {
+        return undefined;
+    }
+};
+/** 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/facts.d.ts

@@ -12,6 +12,7 @@ export interface Fact {
     /** Proposed, then accepted or rejected; a correction supersedes it; only a decision is reversed. */
     status: (typeof FACT_STATUSES)[number];
     project: string | null;
+    projectName: string | null;
     subject: string | null;
     subjectName: string | null;
     subjectIsOwner: boolean;

package/dist/store/sqlite/facts.js

@@ -3,7 +3,7 @@ import { FACT_TYPES, MEMORY_SCOPES } from "../../domain/knowledge.js";
 import { calendarMoment } from "../../domain/moment.js";
 import { evidenceSourcesOf } from "./evidence-sources.js";
 import { linkKind } from "./link-kinds.js";
-import { authorActor, authorOf, dropLinksOf, erase, evidenceOf, keepHighestId, linkEvidence, nextId, subjectOf, } from "./memories.js";
+import { authorActor, authorOf, dropLinksOf, erase, evidenceOf, keepHighestId, linkEvidence, nextId, projectOf, subjectOf, } from "./memories.js";
 import { requiredThing } from "./notes.js";
 import { write } from "./transaction.js";
 const NAMED = "SELECT f.*, b.name AS author_name FROM facts f LEFT JOIN bots b ON f.author_type = 'bot' AND b.id = f.author_id";
@@ -21,7 +21,7 @@ export const factOperationsOver = (context) => {
         type: row.type,
         statement: String(row.statement),
         status: row.status,
-        project: row.project_id == null ? null : `project:${row.project_id}`,
+        ...projectOf(database, row),
         ...subjectOf(database, row),
         occurredAt: row.occurred_at == null ? null : iso(row.occurred_at),
         supersedes: row.supersedes_id == null ? null : `fact:${row.supersedes_id}`,

package/dist/store/sqlite/manifest.js

@@ -56,6 +56,7 @@ export const MANIFEST = [
     { name: "20261030225520_version-40-note-trigrams", version: 40, minCompatible: 34 },
     { 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 },
 ];
 export const generatedMigrations = (manifest = MANIFEST, generated = GENERATED) => {
     const migrations = [];

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

@@ -43,7 +43,7 @@ export const meetingFindingsStoreOver = (context) => {
     };
     const view = (proposal) => {
         const input = proposal.payload;
-        if (!input || !proposal.account || !["proposed", "approved"].includes(proposal.status))
+        if (!input || !proposal.account || !["proposed", "approved", "rejected"].includes(proposal.status))
             return invalid("invalid stored findings batch");
         return {
             id: proposal.id,

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

@@ -19,6 +19,9 @@ export interface Memory {
     subjectName: string | null;
     /** The subject is the owner. */
     subjectIsOwner: boolean;
+    /** The project it belongs to, as `project:<id>`. */
+    project: string | null;
+    projectName: string | null;
     /** `name` is a bot's handle; `null` for a person. */
     author: {
         type: Actor["type"];
@@ -45,6 +48,7 @@ export interface MemoryInput {
     evidence: string[];
     author: Author;
     subject?: string;
+    project?: string;
     confidence?: number;
     status?: "proposed" | "confirmed";
     /** The memory this one replaces; it becomes `superseded`. */
@@ -55,11 +59,16 @@ export interface MemoriesStore {
     get(reference: string): Promise<Memory>;
     list(options?: {
         subject?: string;
+        project?: string;
         kind?: Memory["kind"];
         status?: Memory["status"];
         scope?: Memory["scope"];
         limit?: number;
     }): Promise<Memory[]>;
+    /** Moves it to another project, or to none with `null`. */
+    update(reference: string, change: {
+        project: string | null;
+    }): Promise<Memory>;
     /** The owner stands behind it; its evidence was checked now. */
     confirm(reference: string): Promise<Memory>;
     /** Its evidence no longer holds. */
@@ -100,6 +109,16 @@ export declare const evidenceOf: (context: StoreContext, from: {
 }) => string[];
 /** What a memory's or fact's subject is called, for a reader who should not have to look the reference up. */
 export declare const subjectOf: (database: StoreContext["database"], row: Row) => Pick<Memory, "subject" | "subjectName" | "subjectIsOwner">;
+/** A memory's or fact's project, with its name, so a reader does not look the project up. */
+export declare const projectOf: (database: StoreContext["database"], row: Row) => {
+    project: null;
+    projectName: null;
+} | {
+    project: string;
+    projectName: string | null;
+};
+/** A `project:<id>` the store holds, as its row id. */
+export declare const projectId: (database: StoreContext["database"], reference: string) => number;
 type Numbered = "memories" | "facts";
 /**
  * The id the next row takes: above every row there is and every one forgotten. SQLite hands out the highest id + 1,

package/dist/store/sqlite/memories.js

@@ -64,6 +64,20 @@ export const subjectOf = (database, row) => {
         subjectIsOwner: Number(named?.owner) === 1,
     };
 };
+/** A memory's or fact's project, with its name, so a reader does not look the project up. */
+export const projectOf = (database, row) => {
+    if (row.project_id == null)
+        return { project: null, projectName: null };
+    const named = database.prepare(SUBJECT_NAMES.project).get(Number(row.project_id));
+    return { project: `project:${row.project_id}`, projectName: named?.name == null ? null : String(named.name) };
+};
+/** A `project:<id>` the store holds, as its row id. */
+export const projectId = (database, reference) => {
+    const project = requiredThing(database, reference, "the project");
+    if (project.type !== "project")
+        throw new CliError("validation_error", `${reference} is not a project`);
+    return project.id;
+};
 const highestKey = (table) => `ids.${table}.highest`;
 /**
  * The id the next row takes: above every row there is and every one forgotten. SQLite hands out the highest id + 1,
@@ -118,6 +132,7 @@ export const memoriesStoreOver = (context) => {
         kind: row.kind,
         body: String(row.body),
         ...subjectOf(database, row),
+        ...projectOf(database, row),
         author: authorOf(row),
         model: row.model == null ? null : String(row.model),
         confidence: row.confidence == null ? null : Number(row.confidence),
@@ -167,12 +182,14 @@ export const memoriesStoreOver = (context) => {
             const id = write(database, () => {
                 const { actor, model } = authorActor(context, input.author);
                 const subject = input.subject === undefined ? undefined : requiredThing(database, input.subject, "the subject");
+                const project = input.project === undefined ? null : projectId(database, input.project);
                 const replaced = input.supersedes === undefined ? undefined : Number(rowOf(input.supersedes).id);
                 const at = now();
                 const made = Number(database
                     .prepare("INSERT INTO memories (id, kind, body, subject_type, subject_id, author_type, author_id, model, confidence, status, " +
-                    "last_verified_at, supersedes_id, scope, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING id")
-                    .get(nextId(database, "memories"), kind, body, subject?.type ?? null, subject?.id ?? null, actor.type, actor.id, model, input.confidence ?? null, status, status === "confirmed" ? at : null, replaced ?? null, scope, at, at)?.id);
+                    "last_verified_at, supersedes_id, scope, project_id, created_at, updated_at) " +
+                    "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING id")
+                    .get(nextId(database, "memories"), kind, body, subject?.type ?? null, subject?.id ?? null, actor.type, actor.id, model, input.confidence ?? null, status, status === "confirmed" ? at : null, replaced ?? null, scope, project, at, at)?.id);
                 linkEvidence(context, { type: "memory", id: made }, input.evidence, input.author === "owner" ? "owner" : "agent");
                 if (replaced !== undefined)
                     database.prepare("UPDATE memories SET status = 'superseded', updated_at = ? WHERE id = ?").run(at, replaced);
@@ -183,13 +200,20 @@ export const memoriesStoreOver = (context) => {
         get: async (reference) => memoryOf(rowOf(reference)),
         list: async (options = {}) => {
             const subject = options.subject === undefined ? undefined : requiredThing(database, options.subject);
+            const project = options.project === undefined ? null : projectId(database, options.project);
             return database
                 .prepare(`${NAMED} WHERE m.deleted_at IS NULL AND (? IS NULL OR (m.subject_type = ? AND m.subject_id = ?)) ` +
-                "AND (? IS NULL OR m.kind = ?) AND (? IS NULL OR m.status = ?) AND (? IS NULL OR m.scope = ?) " +
+                "AND (? IS NULL OR m.project_id = ?) AND (? IS NULL OR m.kind = ?) AND (? IS NULL OR m.status = ?) AND (? IS NULL OR m.scope = ?) " +
                 "ORDER BY m.created_at DESC, m.id DESC LIMIT ?")
-                .all(subject?.type ?? null, subject?.type ?? null, subject?.id ?? null, options.kind ?? null, options.kind ?? null, options.status ?? null, options.status ?? null, options.scope ?? null, options.scope ?? null, Math.min(Math.max(options.limit ?? 100, 1), 500))
+                .all(subject?.type ?? null, subject?.type ?? null, subject?.id ?? null, project, project, options.kind ?? null, options.kind ?? null, options.status ?? null, options.status ?? null, options.scope ?? null, options.scope ?? null, Math.min(Math.max(options.limit ?? 100, 1), 500))
                 .map(memoryOf);
         },
+        update: async (reference, change) => write(database, () => {
+            const id = Number(rowOf(reference).id);
+            const project = change.project === null ? null : projectId(database, change.project);
+            database.prepare("UPDATE memories SET project_id = ?, updated_at = ? WHERE id = ?").run(project, now(), id);
+            return memoryOf(rowOf(`memory:${id}`));
+        }),
         confirm: async (reference) => setStatus(reference, "confirmed", true),
         markStale: async (reference) => setStatus(reference, "stale", false),
         remove: async (reference) => {

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

@@ -870,5 +870,12 @@ export const GENERATED = [
             "CREATE TRIGGER tasks_revision_tagging_ai AFTER INSERT ON taggings WHEN new.taggable_type = 'task' BEGIN\n  UPDATE tasks SET revision = revision + 1 WHERE id = new.taggable_id;\nEND;",
             "CREATE TRIGGER tasks_revision_tagging_ad AFTER DELETE ON taggings WHEN old.taggable_type = 'task' BEGIN\n  UPDATE tasks SET revision = revision + 1 WHERE id = old.taggable_id;\nEND;"
         ]
+    },
+    {
+        "name": "20261101011859_version-43-memory-project",
+        "statements": [
+            "ALTER TABLE `memories` ADD `project_id` integer REFERENCES projects(id);",
+            "CREATE INDEX `memories_by_project_id` ON `memories` (`project_id`);"
+        ]
     }
 ];

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

@@ -8,9 +8,15 @@ import { write } from "./transaction.js";
 export const PROPOSAL_STATUSES = ["proposed", "approved", "rejected", "executed", "failed"];
 export const PROPOSAL_VERDICTS = ["useful", "not_useful"];
 const iso = (value) => (value == null ? null : new Date(Number(value)).toISOString());
-const NAMED = "SELECT p.*, b.name AS proposer_name FROM proposed_actions p " +
-    "LEFT JOIN bots b ON p.proposed_by_type = 'bot' AND b.id = p.proposed_by_id";
 const json = (value) => (value == null ? null : JSON.parse(String(value)));
+/**
+ * A findings batch closed with nothing accepted is stored `approved`, as older builds read it; it reads as
+ * `rejected`, the decision the owner made.
+ */
+const STATUS = `CASE WHEN p.status = 'approved' AND p.kind IN ('${MEETING_FINDINGS_KIND}', '${EVIDENCE_FINDINGS_KIND}') ` +
+    "AND json_array_length(p.result, '$.accepted') = 0 THEN 'rejected' ELSE p.status END";
+const NAMED = `SELECT p.*, ${STATUS} AS shown_status, b.name AS proposer_name FROM proposed_actions p ` +
+    "LEFT JOIN bots b ON p.proposed_by_type = 'bot' AND b.id = p.proposed_by_id";
 export const proposalOperationsOver = (context) => {
     const { database, now } = context;
     const actionOf = (row) => {
@@ -26,7 +32,7 @@ export const proposalOperationsOver = (context) => {
                 : (referenceOfThing(database, storedThing(row.target_type, row.target_id)) ?? null),
             payload: json(row.payload),
             reason: row.reason == null ? null : String(row.reason),
-            status: row.status,
+            status: row.shown_status,
             proposedBy: {
                 type: row.proposed_by_type,
                 id: String(row.proposed_by_id),
@@ -106,7 +112,7 @@ export const proposalOperationsOver = (context) => {
             if (status !== undefined && !PROPOSAL_STATUSES.includes(status))
                 throw new CliError("validation_error", `a status is one of ${PROPOSAL_STATUSES.join(", ")}`);
             return database
-                .prepare(`${NAMED} WHERE (? IS NULL OR p.status = ?) ORDER BY p.created_at DESC, p.id DESC LIMIT ?`)
+                .prepare(`${NAMED} WHERE (? IS NULL OR ${STATUS} = ?) ORDER BY p.created_at DESC, p.id DESC LIMIT ?`)
                 .all(status ?? null, status ?? null, Math.min(Math.max(limit, 1), 500))
                 .map(actionOf);
         },

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

@@ -8226,6 +8226,22 @@ export declare const memories: import("drizzle-orm/sqlite-core").SQLiteTableWith
             identity: undefined;
             generated: undefined;
         }, {}>;
+        projectId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "memories";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
     };
     dialect: 'sqlite';
     isAlias: false;

package/dist/store/sqlite/schema.js

@@ -872,10 +872,12 @@ export const memories = sqliteTable("memories", {
     createdAt: integer("created_at").notNull(),
     updatedAt: integer("updated_at").notNull(),
     deletedAt: integer("deleted_at"),
+    projectId: integer("project_id").references(() => projects.id),
 }, (table) => [
     index("memories_by_subject_type_subject_id").on(table.subjectType, table.subjectId),
     index("memories_by_author_type_author_id").on(table.authorType, table.authorId),
     index("memories_by_supersedes_id").on(table.supersedesId),
+    index("memories_by_project_id").on(table.projectId),
 ]);
 export const memoryIndexPending = sqliteTable("memory_index_pending", {
     id: integer("id").notNull(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.516.0",
+  "version": "0.518.0",
   "description": "The messenger-neutral half of a messaging CLI: domain model, message locators, rendering, name resolution, the SQLite seam, the command skeleton and shared read commands, the send guard, run records and the message store",
   "license": "Apache-2.0",
   "author": "Viacheslav Ptsarev",