ultimate-brain 0.4.1 → 0.6.0

package/dist/commands/source.js

@@ -1,20 +1,30 @@
 import { BrainError } from "../lib/errors.js";
-import { rangesProblem, splitParts } from "../lib/parts.js";
-import { hasInboxBody } from "../lib/sync.js";
-import { formatTimestamp } from "../lib/time.js";
+import { lineDiff } from "../lib/diff.js";
 import { Workspace } from "../lib/workspace.js";
-/** `brain source full-text <src-id> [--parts <range>[,<range>…]]` (spec/cli.md §5.17, 0043). */
+/** `brain source full-text` (spec/cli.md §5.17): retired in 0.6.0 by decision 0049. Writes nothing. */
 export const sourceFullTextCommand = {
     name: "source full-text",
     usage: "brain source full-text <src-id> [--parts <range>[,<range>…]] [--json]",
-    summary: "Ask for a source's text on its Inbox row: all of it, or the parts given. The next render writes it once and clears the row's box.",
+    summary: "Retired in 0.6.0: use Keep as document on the source's Inbox row.",
     options: { parts: "string" },
     maxPositionals: 1,
     needsBrain: true,
-    async run({ args, brain, now }) {
+    async run() {
+        throw new BrainError("RETIRED", "brain source full-text was retired in 0.6.0: use Keep as document");
+    },
+};
+/** `brain source diff <src-id>` (spec/cli.md §5.19, 0045): the lines that changed from the version it replaces. */
+export const sourceDiffCommand = {
+    name: "source diff",
+    usage: "brain source diff <src-id> [--json]",
+    summary: "Show the lines a new version of a source changed against the version it replaces, without context lines. Read-only.",
+    options: {},
+    maxPositionals: 1,
+    needsBrain: true,
+    async run({ args, brain }) {
         const [id] = args.positionals;
         if (id === undefined)
-            throw new BrainError("USAGE", "Name the source: brain source full-text <src-id>");
+            throw new BrainError("USAGE", "Name the source: brain source diff <src-id>");
         const workspace = await Workspace.open(brain);
         const note = workspace.get(id);
         if (note === undefined)
@@ -22,35 +32,17 @@ export const sourceFullTextCommand = {
         const invalid = (message) => { throw new BrainError("INPUT_INVALID", message, [{ pointer: "", message }]); };
         if (note.type !== "source")
             invalid(`${id} is a ${note.type}, not a source`);
-        if (!hasInboxBody(note))
-            invalid(`${id} has no Inbox body the brain writes (a minutes or capture source, or an attached file)`);
-        const count = splitParts(note.body).parts.length;
-        const raw = args.options.parts;
-        const parts = raw === undefined ? undefined : raw.split(",").map((part) => part.trim());
-        if (parts !== undefined) {
-            if (parts.some((part) => part === ""))
-                invalid(`--parts ${raw} has an empty item`);
-            const problem = rangesProblem(parts, count);
-            if (problem !== null)
-                invalid(`--parts ${problem}`);
-        }
-        const requested = formatTimestamp(now);
-        const document = workspace.edit(note);
-        document.attributes.notion_text = "full";
-        if (parts === undefined)
-            delete document.attributes.notion_parts;
-        else
-            document.attributes.notion_parts = parts;
-        document.attributes.notion_text_requested = requested;
-        // System fields only: `updated` stays (spec/cli.md §3.6.6).
-        workspace.save(note.path, document);
-        const errors = workspace.newErrors();
-        if (errors.length > 0)
-            throw new BrainError("INPUT_INVALID", errors.map((issue) => `${issue.path}: ${issue.rule}: ${issue.message}`).join("; "));
-        await workspace.commit([{ op: "full-text", id: note.id, title: String(note.attributes.title), pairs: [["parts", parts === undefined ? "all" : parts.join(",")]] }], now);
+        const replaces = note.attributes.replaces;
+        if (typeof replaces !== "string")
+            invalid(`${id} has no replaces: it is the first version`);
+        const earlier = workspace.get(replaces);
+        if (earlier === undefined)
+            throw new BrainError("UNKNOWN_ID", `No note with id ${String(replaces)}`);
+        const lines = lineDiff(earlier.body, note.body);
+        const diff = lines.join("\n");
         return {
-            data: { id: note.id, path: note.path, parts: count, notion_text: "full", notion_parts: parts ?? null, notion_text_requested: requested },
-            human: `${note.path}: full text${parts === undefined ? "" : ` (parts ${parts.join(", ")} of ${count})`} on the next publish\n`,
+            data: { id: note.id, replaces: earlier.id, removed: lines.filter((line) => line.startsWith("- ")).length, added: lines.filter((line) => line.startsWith("+ ")).length, diff },
+            human: diff === "" ? "no lines changed\n" : `${diff}\n`,
         };
     },
 };

package/dist/commands/status.js

@@ -6,8 +6,9 @@ import { lintBrain } from "../lib/lint.js";
 import { scanNotes } from "../lib/notes.js";
 import { describeErrors, loadSchemas } from "../lib/schemas.js";
 import { isRecord } from "../lib/input.js";
+import { databaseId, modulesOf } from "../lib/modules.js";
 import { expandPath, linkedRepos, workTreeTop } from "../lib/repos.js";
-const NOTE_TYPES = ["area", "project", "person", "org", "meeting", "decision", "question", "concept", "source", "view", "goal", "memory"];
+const NOTE_TYPES = ["area", "project", "person", "org", "meeting", "decision", "question", "concept", "source", "view", "goal", "memory", "reference"];
 const PROPOSAL_STATUSES = ["pending", "approved", "edited", "rejected", "applied", "closed"];
 /** `brain status` (spec/cli.md §5.2). */
 export const statusCommand = {
@@ -61,6 +62,7 @@ export const statusCommand = {
             notes: noteCounts,
             proposals: proposalCounts,
             notion,
+            modules: modulesOf(brain.config),
             settings,
             repos,
             index_stale: currentIndex !== index,
@@ -72,12 +74,10 @@ export const statusCommand = {
 };
 function readNotion(config) {
     const notion = config.notion;
-    const databases = notion.databases;
     const configured = [];
     const missing = [];
-    for (const key of ["areas", "goals", "key_results", "projects", "meetings", "people", "orgs", "decisions", "questions", "review", "inbox", "concepts"]) {
-        const value = key === "inbox" && databases.inbox === undefined ? databases.capture_inbox : databases[key];
-        (typeof value === "string" && value !== "" ? configured : missing).push(key);
+    for (const key of ["areas", "goals", "key_results", "projects", "meetings", "people", "orgs", "decisions", "questions", "review", "inbox", "concepts", "documents"]) {
+        (databaseId(config, key) !== "" ? configured : missing).push(key);
     }
     const tasks = notion.tasks;
     return { configured, missing, tasks_database: typeof tasks.database === "string" && tasks.database !== "" };

package/dist/commands/sync.js

@@ -1,6 +1,7 @@
 import { readJsonInput } from "../lib/input.js";
 import { applyPlan, buildPlan, parsePlan, parseSnapshot, record, render, renderTasks } from "../lib/sync.js";
 import { Workspace } from "../lib/workspace.js";
+import { modulesOf } from "../lib/modules.js";
 import { BrainError } from "../lib/errors.js";
 import { lintWarnings } from "../lib/warnings.js";
 export const syncPlanCommand = {
@@ -43,7 +44,8 @@ export const syncRenderCommand = {
 export const syncTasksCommand = {
     name: "sync tasks", usage: "brain sync tasks (--meeting <mtg-id> | --source <src-id>) --input <file|-> [--json]", summary: "Render action-item task payloads for a meeting or source.", options: { meeting: "string", source: "string", input: "string" }, maxPositionals: 0, needsBrain: true,
     async run({ args, brain }) { const meeting = args.options.meeting; const source = args.options.source; const input = args.options.input; if ((meeting === undefined) === (source === undefined) || input === undefined)
-        throw new BrainError("USAGE", "sync tasks needs exactly one of --meeting or --source, and --input"); return { data: renderTasks(await Workspace.open(brain), meeting ?? source, await readJsonInput(input, "sync tasks")), human: "Task payloads rendered.\n" }; },
+        throw new BrainError("USAGE", "sync tasks needs exactly one of --meeting or --source, and --input"); if (!modulesOf(brain.config).tasks)
+        throw new BrainError("MODULE_OFF", "The Tasks module is off: brain modules on tasks"); return { data: renderTasks(await Workspace.open(brain), meeting ?? source, await readJsonInput(input, "sync tasks")), human: "Task payloads rendered.\n" }; },
 };
 export const syncRecordCommand = {
     name: "sync record", usage: "brain sync record --input <file|-> [--dry-run] [--json]", summary: "Record successful Notion publication results.", options: { input: "string", "dry-run": "boolean" }, maxPositionals: 0, needsBrain: true,

package/dist/commands/upgrade.js

@@ -5,7 +5,9 @@ import { promisify } from "node:util";
 import { BrainError } from "../lib/errors.js";
 import { atomicWriteFile, ensureDirectory } from "../lib/fs-safe.js";
 import { appendLog } from "../lib/log.js";
+import { isRecord } from "../lib/input.js";
 import { lintBrain } from "../lib/lint.js";
+import { modulesOf, withModules } from "../lib/modules.js";
 import { scanNotes } from "../lib/notes.js";
 import { assertPlainPath, installedProduct, listShippedSkillFiles } from "../lib/skills.js";
 const exec = promisify(execFile);
@@ -50,32 +52,33 @@ export const upgradeCommand = {
             changes.push({ path: "CLAUDE.md", action: "created", content: "@AGENTS.md\n" });
         else
             unchanged += 1;
-        // 0.3.0: Inbox is the former Capture Inbox. Keep the database id, but retire the old key.
+        // 0.3.0: Inbox is the former Capture Inbox; 0.6.0: Documents are the former References (0049).
+        // Keep each database id, but retire the old key. 0.6.0 also writes the modules block (0048).
         const brainJson = "brain.json";
         await assertPlainPath(root, brainJson);
         const brainText = await readOptional(join(root, brainJson));
         if (brainText !== null) {
             try {
-                const config = JSON.parse(brainText);
+                let config = JSON.parse(brainText);
+                let changed = false;
                 const notion = config.notion;
-                if (notion !== null && typeof notion === "object" && !Array.isArray(notion)) {
-                    const databases = notion.databases;
-                    if (databases !== null && typeof databases === "object" && !Array.isArray(databases)) {
-                        const values = databases;
-                        if (values.capture_inbox !== undefined) {
-                            const inbox = typeof values.inbox === "string" && values.inbox !== "" ? values.inbox : values.capture_inbox;
-                            const nextDatabases = {};
-                            for (const [key, value] of Object.entries(values)) {
-                                if (key === "capture_inbox")
-                                    nextDatabases.inbox = inbox;
-                                else if (key !== "inbox")
-                                    nextDatabases[key] = value;
-                            }
-                            const next = { ...config, notion: { ...notion, databases: nextDatabases } };
-                            changes.push({ path: brainJson, action: "updated", content: `${JSON.stringify(next, null, 2)}\n` });
-                        }
+                if (isRecord(notion) && isRecord(notion.databases)) {
+                    let databases = notion.databases;
+                    for (const [old, key] of [["capture_inbox", "inbox"], ["references", "documents"]]) {
+                        if (databases[old] === undefined)
+                            continue;
+                        databases = renameKey(databases, old, key);
+                        changed = true;
                     }
+                    if (changed)
+                        config = { ...config, notion: { ...notion, databases } };
+                }
+                if (isRecord(config) && !("modules" in config)) {
+                    config = withModules(config, modulesOf(config));
+                    changed = true;
                 }
+                if (changed)
+                    changes.push({ path: brainJson, action: "updated", content: `${JSON.stringify(config, null, 2)}\n` });
             }
             catch {
                 changes.push({ path: brainJson, action: "skipped" });
@@ -261,3 +264,15 @@ async function gitDirty(root) {
         return false;
     return (await exec("git", ["status", "--porcelain"], { cwd: root })).stdout !== "";
 }
+/** Rename `old` to `key` in place; when `key` already holds an id, just drop `old` (spec/cli.md §5.15 step 5). */
+function renameKey(values, old, key) {
+    const value = typeof values[key] === "string" && values[key] !== "" ? values[key] : values[old];
+    const next = {};
+    for (const [name, existing] of Object.entries(values)) {
+        if (name === old)
+            next[key] = value;
+        else if (name !== key)
+            next[name] = existing;
+    }
+    return next;
+}

package/dist/lib/apply.js

@@ -2,15 +2,16 @@ import { isDeepStrictEqual } from "node:util";
 import { posix } from "node:path";
 import { assertNoProblems, isRecord, unknownKeys } from "./input.js";
 import { compareCodePoints } from "./notes.js";
-import { stageNewItem } from "./proposals.js";
+import { bodyHash, bodyOf, reviewTitle, sourceTitle, stageNewItem, writeProposal } from "./proposals.js";
 import { loadSchemas } from "./schemas.js";
 import { formatDate, normalizeTimestamp } from "./time.js";
-const ACTIONS = ["approve", "reject", "edit"];
-export const EDITABLE = new Set(["update_fact", "contradiction", "add_to_note", "answer"]);
+const ACTIONS = ["approve", "reject", "fix", "edit"];
+export const EDITABLE = new Set(["update_fact", "contradiction", "add_to_note", "update_body", "answer"]);
+const FIX_KEYS = ["value", "change", "note", "field", "link"];
 /** Reference fields a merge leaves alone: the meeting side of a persisted pair (spec/schema.md §11.2). */
 const PAIR_FIELDS = new Set(["decisions", "questions", "decided_in", "raised_in"]);
 /** Corrections change knowledge notes only: sources are immutable and proposals are records. */
-const KNOWLEDGE_TYPES = new Set(["area", "goal", "project", "person", "org", "meeting", "decision", "question", "concept", "memory"]);
+const KNOWLEDGE_TYPES = new Set(["area", "goal", "project", "person", "org", "meeting", "decision", "question", "concept", "reference", "memory"]);
 const REFERENCE_FIELDS = [
     "area", "areas", "goal", "client", "org", "projects", "people", "attendees", "deciders", "source", "sources",
     "answer", "project", "generated_from", "facts",
@@ -49,19 +50,25 @@ export function parseApplyInput(input) {
         const pointer = `/decisions/${index}`;
         if (!isRecord(item))
             return problems.push({ pointer, message: "must be an object" });
-        problems.push(...unknownKeys(item, ["proposal", "action", "value", "note", "exclude", "decided_at", "decided_by"], pointer));
+        problems.push(...unknownKeys(item, ["proposal", "action", "value", "note", "fixes", "exclude", "decided_at", "decided_by"], pointer));
         if (typeof item.proposal !== "string")
             problems.push({ pointer: `${pointer}/proposal`, message: "must be a proposal id" });
         if (!ACTIONS.includes(item.action))
-            problems.push({ pointer: `${pointer}/action`, message: "must be approve, reject or edit" });
+            problems.push({ pointer: `${pointer}/action`, message: "must be approve, reject, fix or edit" });
+        if (item.action === "fix" && (typeof item.note !== "string" || item.note === ""))
+            problems.push({ pointer: `${pointer}/note`, message: "is required for fix: the user's words" });
+        if (item.action === "fix" && (!Array.isArray(item.fixes) || item.fixes.length === 0 || item.fixes.some((entry) => !isRecord(entry) || !Object.hasOwn(entry, "value") || Object.keys(entry).some((key) => !FIX_KEYS.includes(key)))))
+            problems.push({ pointer: `${pointer}/fixes`, message: "must be a non-empty list of entries with a value (spec/schema.md §11.3)" });
+        if (item.action !== "fix" && item.fixes !== undefined)
+            problems.push({ pointer: `${pointer}/fixes`, message: "is only allowed for fix" });
         if (item.action === "edit" && (item.value === undefined || item.value === null))
             problems.push({ pointer: `${pointer}/value`, message: "is required for edit" });
         if (item.action !== "edit" && item.value !== undefined)
             problems.push({ pointer: `${pointer}/value`, message: "is only allowed for edit" });
         if (item.note !== undefined && typeof item.note !== "string")
             problems.push({ pointer: `${pointer}/note`, message: "must be a string" });
-        if (item.exclude !== undefined && (!Array.isArray(item.exclude) || item.exclude.some((entry) => !isRecord(entry) || !(isNoteExclude(entry) || (typeof entry.field === "string" && Object.hasOwn(entry, "value") && Object.keys(entry).every((key) => ["target", "field", "value"].includes(key)))))))
-            problems.push({ pointer: `${pointer}/exclude`, message: "must be a list of {field, value}, {target, field, value} or {note} entries" });
+        if (item.exclude !== undefined && (!Array.isArray(item.exclude) || item.exclude.some((entry) => !isRecord(entry) || !(isNoteExclude(entry) || isChangeExclude(entry) || (typeof entry.field === "string" && Object.hasOwn(entry, "value") && Object.keys(entry).every((key) => ["target", "field", "value"].includes(key)))))))
+            problems.push({ pointer: `${pointer}/exclude`, message: "must be a list of {field, value}, {target, field, value}, {note} or {change} entries" });
         if (!isTimestamp(item.decided_at))
             problems.push({ pointer: `${pointer}/decided_at`, message: "must be an ISO 8601 UTC timestamp" });
         if (item.decided_by !== "notion" && item.decided_by !== "chat")
@@ -178,10 +185,10 @@ function applyDecision(workspace, input, today, recordOnly) {
     const p = document.attributes;
     if (p.status === "applied" || p.status === "closed")
         return { result: "skipped", reason: "ALREADY_TERMINAL" };
-    const incoming = { action: input.action, ...(input.value === undefined ? {} : { value: input.value }), ...(input.note === undefined ? {} : { note: input.note }), ...(input.exclude === undefined ? {} : { exclude: input.exclude }), decided_at: input.decided_at, decided_by: input.decided_by };
+    const incoming = { action: input.action, ...(input.value === undefined ? {} : { value: input.value }), ...(input.note === undefined ? {} : { note: input.note }), ...(input.fixes === undefined ? {} : { fixes: input.fixes }), ...(input.exclude === undefined ? {} : { exclude: input.exclude }), decided_at: input.decided_at, decided_by: input.decided_by };
     const recorded = isRecord(p.decision) ? p.decision : undefined;
     let decision = incoming;
-    if (recorded !== undefined && (recorded.action !== incoming.action || !isDeepStrictEqual(recorded.value, incoming.value) || !isDeepStrictEqual(recorded.exclude, incoming.exclude))) {
+    if (recorded !== undefined && (recorded.action !== incoming.action || !isDeepStrictEqual(recorded.value, incoming.value) || !isDeepStrictEqual(recorded.fixes, incoming.fixes) || !isDeepStrictEqual(recorded.exclude, incoming.exclude))) {
         // You changed your mind in Notion before it was applied: the later decision wins.
         if (Date.parse(recorded.decided_at) >= Date.parse(incoming.decided_at))
             decision = recorded;
@@ -190,30 +197,31 @@ function applyDecision(workspace, input, today, recordOnly) {
         decision = recorded;
     }
     if (decision.action === "edit" && !EDITABLE.has(String(p.kind))) {
-        throw new ItemFailure("EDIT_NOT_ALLOWED", `edit is not allowed on a ${String(p.kind)} proposal (spec/schema.md §11.1)`);
+        throw new ItemFailure("EDIT_NOT_ALLOWED", `edit is not allowed on a ${String(p.kind)} proposal (spec/schema.md §11.1); use fix`);
     }
+    const exclude = decision.exclude ?? [];
     if (decision.exclude !== undefined) {
-        if (decision.action !== "approve" || (p.kind !== "add_link" && p.kind !== "review_notes"))
-            throw new ItemFailure("INPUT_INVALID", "exclude is only allowed on an approved add_link or review_notes proposal");
+        if ((decision.action !== "approve" && decision.action !== "fix") || (p.kind !== "add_link" && p.kind !== "review_notes"))
+            throw new ItemFailure("INPUT_INVALID", "exclude is only allowed on an approved or fixed add_link or review_notes proposal");
         if (p.kind === "add_link") {
-            if (decision.exclude.some((excluded) => excluded.target !== undefined || isNoteExclude(excluded)))
+            if (exclude.some((excluded) => excluded.target !== undefined || isNoteExclude(excluded) || isChangeExclude(excluded)))
                 throw new ItemFailure("INPUT_INVALID", "exclude on an add_link takes {field, value} entries");
             const links = proposalLinks(p);
-            if (decision.exclude.some((excluded) => !links.some((link) => link.field === excluded.field && isDeepStrictEqual(link.value, excluded.value))))
+            if (exclude.some((excluded) => !links.some((link) => link.field === excluded.field && isDeepStrictEqual(link.value, excluded.value))))
                 throw new ItemFailure("EXCLUDE_UNKNOWN", "exclude contains a link that is not in the proposal");
         }
         else {
-            if (decision.exclude.some((excluded) => !isNoteExclude(excluded) && excluded.target === undefined))
-                throw new ItemFailure("INPUT_INVALID", "exclude on a review_notes takes {note} and {target, field, value} entries");
-            const notes = list(p.notes);
-            const links = reviewLinks(p);
-            if (decision.exclude.some((excluded) => isNoteExclude(excluded) ? !notes.includes(excluded.note) : !links.some((link) => sameLink(link, excluded))))
+            if (exclude.some((excluded) => !isNoteExclude(excluded) && !isChangeExclude(excluded) && excluded.target === undefined))
+                throw new ItemFailure("INPUT_INVALID", "exclude on a review_notes takes {note}, {target, field, value} and {change} entries");
+            if (exclude.some((excluded) => !inReview(p, excluded)))
                 throw new ItemFailure("EXCLUDE_UNKNOWN", "exclude contains an entry that is not in the proposal");
         }
     }
+    // A fix corrects the proposal before it is applied; the file keeps what was proposed (spec/schema.md §11.3).
+    const fixed = decision.action === "fix" ? corrected(workspace, p, decision.fixes ?? [], exclude) : { q: p, noteFixes: new Map() };
     const action = decision.action === incoming.action ? undefined : decision.action;
     p.decision = decision;
-    p.status = decision.action === "approve" ? "approved" : decision.action === "edit" ? "edited" : "rejected";
+    p.status = decision.action === "approve" ? "approved" : decision.action === "reject" ? "rejected" : "edited";
     p.updated = today;
     if (recordOnly) {
         workspace.save(proposal.path, document);
@@ -223,18 +231,21 @@ function applyDecision(workspace, input, today, recordOnly) {
         p.status = "closed";
         workspace.save(proposal.path, document);
         // A rejected review_notes archives the notes still draft, with no successor (spec/schema.md §11.2).
-        const notes = p.kind === "review_notes" ? reviewNotes(workspace, p, "reject", [], today) : undefined;
+        const notes = p.kind === "review_notes" ? reviewNotes(workspace, p, "reject", [], today, "", new Map()).notes : undefined;
         return { result: "closed", action, ...(notes === undefined ? {} : { notes }) };
     }
     const D = decision.decided_at.slice(0, 10);
-    const V = decision.action === "edit" ? decision.value : undefined;
+    const V = decision.action === "edit" ? decision.value : fixed.value;
     if (p.kind === "review_notes") {
-        const notes = reviewNotes(workspace, p, "approve", decision.exclude ?? [], today);
+        const applied = reviewNotes(workspace, fixed.q, "approve", exclude, today, D, fixed.noteFixes);
+        if (applied.dropped.length > 0)
+            p.dropped = applied.dropped;
         p.status = "applied";
         workspace.save(proposal.path, document);
-        return { result: "applied", action, notes };
+        const deferred = exclude.length === 0 ? undefined : defer(workspace, proposal.id, p, exclude, today);
+        return { result: "applied", action, notes: applied.notes, changes: applied.changes, ...(deferred === undefined ? {} : { deferred }) };
     }
-    const stale = applyKind(workspace, p, proposal.path, V, D, today, (decision.exclude ?? []));
+    const stale = applyKind(workspace, fixed.q, proposal.path, V, D, today, exclude);
     if (stale !== null) {
         p.status = "closed";
         p.closed_reason = "stale";
@@ -245,6 +256,158 @@ function applyDecision(workspace, input, today, recordOnly) {
     workspace.save(proposal.path, document);
     return { result: "applied", action };
 }
+/** Whether an exclude or fix entry names an item of a review_notes (spec/schema.md §11.3). */
+function inReview(p, entry) {
+    if (entry.change !== undefined)
+        return Number.isInteger(entry.change) && entry.change >= 0 && entry.change < list(p.changes).length;
+    if (entry.note !== undefined)
+        return list(p.notes).includes(entry.note);
+    return reviewLinks(p).some((link) => sameLink(link, entry));
+}
+/**
+ * The proposal as `fixes` correct it (spec/schema.md §11.3): a copy of its fields, the value V for
+ * single-value kinds, and the fields to set on listed notes. Throws FIX_UNKNOWN for an entry that names
+ * no item, INVALID_RESULT for a value of the wrong shape, INPUT_INVALID for an item fixed and excluded.
+ */
+function corrected(workspace, p, fixes, exclude) {
+    const q = structuredClone(p);
+    const noteFixes = new Map();
+    const kind = String(p.kind);
+    const unknown = (entry) => { throw new ItemFailure("FIX_UNKNOWN", `fixes entry ${JSON.stringify(entry)} names no item of this ${kind} proposal`); };
+    const shape = (message) => { throw new ItemFailure("INVALID_RESULT", message); };
+    const only = (keys) => (entry) => Object.keys(entry).every((key) => keys.includes(key));
+    const single = () => {
+        const entry = fixes[0];
+        if (!only(["value"])(entry))
+            unknown(entry);
+        if (fixes.length !== 1)
+            shape(`a fix on a ${kind} takes exactly one {value}`);
+        return entry;
+    };
+    if (kind === "update_fact" || kind === "contradiction") {
+        const { value } = single();
+        if (typeof value !== "string" && typeof value !== "number")
+            shape("a fact value is a string or a number");
+        return { q, value, noteFixes };
+    }
+    if (kind === "add_to_note" || kind === "update_body" || kind === "answer") {
+        const { value } = single();
+        if (typeof value !== "string" || value.trim() === "")
+            shape(`a fix on a ${kind} is a non-empty text`);
+        return { q, value, noteFixes };
+    }
+    if (kind === "supersede" || kind === "merge") {
+        const { value } = single();
+        const key = kind === "supersede" ? "supersedes" : "merge_into";
+        const note = typeof value === "string" ? workspace.get(value) : undefined;
+        const target = workspace.get(String(p.target));
+        if (note === undefined || note.id === p.target || note.type !== target?.type)
+            shape(`${String(value)} must be another existing ${target?.type ?? "note"}`);
+        if (kind === "supersede" && list(note.attributes.relations).some((relation) => record(relation).type === "superseded_by"))
+            shape(`${note.id} is already superseded`);
+        q[key] = note.id;
+        return { q, noteFixes };
+    }
+    if (kind === "new_item") {
+        const note = record(q.note);
+        const frontmatter = record(note.frontmatter);
+        for (const entry of fixes) {
+            if (!only(["field", "value"])(entry) || typeof entry.field !== "string" || (entry.field !== "title" && !Object.hasOwn(frontmatter, entry.field)))
+                unknown(entry);
+            if (entry.field === "title")
+                note.title = entry.value;
+            else
+                frontmatter[entry.field] = entry.value;
+        }
+        return { q, noteFixes };
+    }
+    if (kind === "add_link") {
+        const links = list(q.links).map(record);
+        for (const entry of fixes) {
+            const link = record(entry.link);
+            const at = only(["link", "value"])(entry) ? links.findIndex((candidate) => candidate.field === link.field && isDeepStrictEqual(candidate.value, link.value)) : -1;
+            if (at === -1)
+                unknown(entry);
+            if (exclude.some((excluded) => excluded.field === link.field && isDeepStrictEqual(excluded.value, link.value)))
+                throw new ItemFailure("INPUT_INVALID", "an item can't be both fixed and excluded");
+            links[at] = { ...links[at], value: entry.value };
+        }
+        q.links = links;
+        return { q, noteFixes };
+    }
+    if (kind === "review_notes") {
+        const changes = list(q.changes).map(record);
+        const links = list(q.links).map(record);
+        for (const entry of fixes) {
+            const excluded = (item) => exclude.some((other) => isDeepStrictEqual(other, item));
+            if (entry.change !== undefined) {
+                if (!only(["change", "value"])(entry) || !inReview(p, { change: entry.change }))
+                    unknown(entry);
+                if (excluded({ change: entry.change }))
+                    throw new ItemFailure("INPUT_INVALID", "an item can't be both fixed and excluded");
+                const change = changes[entry.change];
+                if (change.kind === "update_fact") {
+                    if (typeof entry.value !== "string" && typeof entry.value !== "number")
+                        shape("a fact value is a string or a number");
+                    change.after = entry.value;
+                }
+                else {
+                    if (typeof entry.value !== "string" || entry.value.trim() === "")
+                        shape(`a fix on an ${String(change.kind)} is a non-empty text`);
+                    change.content = entry.value;
+                }
+            }
+            else if (entry.note !== undefined) {
+                if (!only(["note", "field", "value"])(entry) || !inReview(p, { note: entry.note }))
+                    unknown(entry);
+                if (excluded({ note: entry.note }))
+                    throw new ItemFailure("INPUT_INVALID", "an item can't be both fixed and excluded");
+                const field = entry.field;
+                if (typeof field !== "string" || !(NOTE_FIX_FIELDS.includes(field) || /^facts\.[a-z][a-z0-9_]*$/.test(field)))
+                    shape(`${String(field)} is not a field a fix may set on a note`);
+                noteFixes.set(String(entry.note), [...(noteFixes.get(String(entry.note)) ?? []), { field, value: entry.value }]);
+            }
+            else if (entry.link !== undefined) {
+                const link = record(entry.link);
+                const at = only(["link", "value"])(entry) ? links.findIndex((candidate) => sameLink({ target: candidate.target, field: candidate.field, value: candidate.value }, link)) : -1;
+                if (at === -1)
+                    unknown(entry);
+                if (excluded(link))
+                    throw new ItemFailure("INPUT_INVALID", "an item can't be both fixed and excluded");
+                links[at] = { ...links[at], value: entry.value };
+            }
+            else {
+                unknown(entry);
+            }
+        }
+        q.changes = changes;
+        q.links = links;
+        return { q, noteFixes };
+    }
+    throw new ItemFailure("INVALID_RESULT", `Unknown proposal kind ${kind}`);
+}
+/** Fields a fix may set on a note listed by a review_notes: those a correction may set, and projects (spec/schema.md §11.3). */
+const NOTE_FIX_FIELDS = ["title", "summary", "why", "area", "goal", "client", "org", "people", "projects"];
+/**
+ * Write the excluded items of an applied review_notes as one new pending review_notes (spec/schema.md
+ * §11.3): the same source, `deferred_from` = this proposal, each item as stored, in its original order.
+ */
+function defer(workspace, id, p, exclude, today) {
+    const notes = list(p.notes).filter((note) => exclude.some((entry) => isNoteExclude(entry) && entry.note === note));
+    const links = reviewLinks(p).filter((link) => exclude.some((entry) => sameLink(link, entry)));
+    const changes = list(p.changes).filter((_change, index) => exclude.some((entry) => entry.change === index));
+    const source = String(p.source);
+    const fields = {
+        kind: "review_notes",
+        title: reviewTitle(workspace, source, changes.length, notes.length, links.length, "Deferred from"),
+        notes, links,
+        ...(changes.length === 0 ? {} : { changes }),
+        deferred_from: id,
+        why: p.why,
+        source,
+    };
+    return writeProposal(workspace, fields, today).id;
+}
 /** Apply a proposal's kind to its targets. Returns a message when the proposal is stale. */
 function applyKind(workspace, p, proposalPath, V, D, today, exclude = []) {
     const kind = String(p.kind);
@@ -263,6 +426,8 @@ function applyKind(workspace, p, proposalPath, V, D, today, exclude = []) {
             return `facts.${field} is ${shown(current)}, proposal expected ${shown(p.before)}`;
         }
     }
+    if (kind === "update_body" && bodyHash(target.body) !== p.before_hash)
+        return `${target.id}'s body changed after the proposal was written`;
     switch (kind) {
         case "update_fact":
             setFact(a, field, V ?? p.after, String(p.from), D, String(p.source));
@@ -280,6 +445,10 @@ function applyKind(workspace, p, proposalPath, V, D, today, exclude = []) {
             a.sources = union(list(a.sources), [p.source]);
             break;
         }
+        case "update_body":
+            document.body = bodyOf(String(V ?? p.content));
+            a.sources = union(list(a.sources), [p.source]);
+            break;
         case "add_link":
             for (const link of proposalLinks(p))
                 if (!exclude.some((item) => item.field === link.field && isDeepStrictEqual(item.value, link.value)) && !list(a[String(link.field)]).some((value) => isDeepStrictEqual(value, link.value)))
@@ -308,23 +477,55 @@ function applyKind(workspace, p, proposalPath, V, D, today, exclude = []) {
     return null;
 }
 /**
- * Apply or reject a review_notes proposal (spec/schema.md §11.2): approve marks the listed draft
- * notes `reviewed` and applies the links, reject archives the draft notes. Excluded entries stay
- * as they are; a note no longer `draft` is left alone and reported `unchanged`.
+ * Apply or reject a review_notes proposal (spec/schema.md §11.2–11.3). Approve applies, in order, the
+ * changes not excluded (a stale one is dropped alone), marks the listed draft notes `reviewed` with
+ * their fixes, and applies the links; reject archives the draft notes. Excluded entries stay as they
+ * are; a note no longer `draft` is left alone and reported `unchanged`.
  */
-function reviewNotes(workspace, p, action, exclude, today) {
+function reviewNotes(workspace, p, action, exclude, today, D, noteFixes) {
+    const changes = [];
+    const dropped = [];
+    if (action === "approve") {
+        list(p.changes).map(record).forEach((change, index) => {
+            const entry = { index, kind: String(change.kind), target: String(change.target) };
+            if (exclude.some((excluded) => excluded.change === index)) {
+                changes.push({ ...entry, result: "deferred" });
+                return;
+            }
+            const stale = applyKind(workspace, { ...change, source: p.source }, "", undefined, D, today);
+            if (stale === null)
+                changes.push({ ...entry, result: "applied" });
+            else {
+                changes.push({ ...entry, result: "dropped", reason: "STALE_PROPOSAL" });
+                dropped.push({ change: index, reason: "stale" });
+            }
+        });
+    }
     const results = [];
     for (const id of list(p.notes).map(String)) {
         const note = existing(workspace, id);
-        const lifecycle = String(note.attributes.lifecycle);
         const excluded = exclude.some((entry) => isNoteExclude(entry) && entry.note === id);
+        const fixes = action === "approve" ? noteFixes.get(id) ?? [] : [];
+        if (fixes.length > 0) {
+            const document = workspace.edit(note);
+            for (const { field, value } of fixes) {
+                const fact = /^facts\.(.+)$/.exec(String(field))?.[1];
+                if (fact !== undefined)
+                    setFact(document.attributes, fact, value, D, D, String(p.source));
+                else
+                    document.attributes[String(field)] = value;
+            }
+            document.attributes.updated = today;
+            workspace.save(note.path, document);
+        }
+        const lifecycle = String(workspace.get(id).attributes.lifecycle);
         if (lifecycle !== "draft")
             results.push({ id, result: "unchanged", lifecycle });
         else if (excluded)
             results.push({ id, result: "kept_draft", lifecycle });
         else {
             const next = action === "approve" ? "reviewed" : "archived";
-            const document = workspace.edit(note);
+            const document = workspace.edit(workspace.get(id));
             document.attributes.lifecycle = next;
             document.attributes.updated = today;
             workspace.save(note.path, document);
@@ -345,7 +546,7 @@ function reviewNotes(workspace, p, action, exclude, today) {
             workspace.save(target.path, document);
         }
     }
-    return results;
+    return { notes: results, changes, dropped };
 }
 function reviewLinks(proposal) {
     return list(proposal.links).filter(isRecord).map((link) => ({ target: link.target, field: link.field, value: link.value }));
@@ -356,6 +557,9 @@ function sameLink(link, entry) {
 function isNoteExclude(entry) {
     return typeof entry.note === "string" && Object.keys(entry).length === 1;
 }
+function isChangeExclude(entry) {
+    return Number.isInteger(entry.change) && entry.change >= 0 && Object.keys(entry).length === 1;
+}
 function proposalLinks(proposal) {
     if (Array.isArray(proposal.links))
         return proposal.links.filter(isRecord).map((link) => ({ field: link.field, value: link.value }));